Add outputExtension to contentMappers entries

A content mapper turns `foo.gts` into virtual TypeScript, and declaration
emit names the result `foo.d.gts.ts` with `./foo.gts` kept in specifiers.
That is the only safe choice when nothing is known about the external
build. When that build compiles `foo.gts` to `foo.js`, the published
package needs `foo.d.ts` beside `foo.js`, and `.gts` specifiers do not
resolve for consumers that do not run the mapper.

`contentMappers[].outputExtension` (".js", ".mjs", or ".cjs") tells
TypeScript what the external build produces. With it set, declaration
emit names the file after the output (`foo.d.ts`, `foo.d.mts`,
`foo.d.cts`) and rewrites relative specifiers that resolved through the
mapper's extension to the output extension. Resolution, not string
matching, decides the rewrite, so a specifier that resolved to a sibling
`foo.d.gts.ts` is left alone. Any other value reports TS100069 on the
value in tsconfig.json.

The name collision from the issue (`app.ts` and `app.gts` both emitting
`app.d.ts`) is caught by the existing TS5056 output-path check.

JavaScript emit is unchanged: `rewriteRelativeImportExtensions` still
rewrites only TypeScript extensions.

Fixes #64053

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0188eg6bTrrUiWbj5FZaWH5Z

Author: NullVoxPopuli

tsc/internal/compiler/emitHost.go

@@ -113,6 +113,10 @@ func (host *emitHost) ContentMapperExtensions() []string {
 	return host.program.ContentMapperExtensions()
 }
 
+func (host *emitHost) ContentMapperOutputExtension(fileName string) string {
+	return host.program.ContentMapperOutputExtension(fileName)
+}
+
 func (host *emitHost) UseCaseSensitiveFileNames() bool {
 	return host.program.UseCaseSensitiveFileNames()
 }

tsc/internal/compiler/program.go

@@ -508,6 +508,12 @@ func (p *Program) GetContentMapper(file *ast.SourceFile) *contentmapper.Mapper {
 	return nil
 }
 
+// ContentMapperOutputExtension returns the extension an external build produces for a content-mapped
+// file, as declared by its mapper's "outputExtension", or an empty string when none is declared.
+func (p *Program) ContentMapperOutputExtension(fileName string) string {
+	return p.opts.Config.ContentMapperOutputExtension(fileName)
+}
+
 func (p *Program) ContentMapperExtensions() []string         { return p.opts.Config.ContentMapperExtensions() }
 func (p *Program) CommandLine() *tsoptions.ParsedCommandLine { return p.opts.Config }
 func (p *Program) Host() CompilerHost                        { return p.opts.Host }

tsc/internal/contentmapper/contentmapper.go

@@ -31,6 +31,11 @@ type Definition struct {
 	Package    string     `json:"package"`
 	Extensions []string   `json:"extensions"`
 	Options    json.Value `json:"options,omitempty"`
+	// OutputExtension is the JavaScript extension (".js", ".mjs", or ".cjs") that an external build
+	// produces for the mapper's files. When set, declaration emit names each file's declaration after
+	// that output (`component.vue` emits `component.d.ts`) and rewrites relative imports of the mapper's
+	// files to the output extension so the emitted declarations resolve without the mapper.
+	OutputExtension string `json:"outputExtension,omitempty"`
 }
 
 // Manifest is the content-mapper information read from a package's package.json: its name and version
@@ -63,6 +68,13 @@ func IsSupportedVirtualExtension(extension string) bool {
 	return supportedVirtualExtensions.Has(extension)
 }
 
+var supportedOutputExtensions = collections.NewSetFromItems(".js", ".mjs", ".cjs")
+
+// IsSupportedOutputExtension reports whether extension is a valid "outputExtension" for a content mapper.
+func IsSupportedOutputExtension(extension string) bool {
+	return supportedOutputExtensions.Has(extension)
+}
+
 // DiagnosticName returns the best available user-facing name, including when manifest resolution failed.
 func (m *Mapper) DiagnosticName() string {
 	switch {

tsc/internal/diagnostics/diagnostics_generated.go

@@ -338,5 +338,9 @@
     "Diagnostic directive {0} returned by the content mapper has an invalid 'unusedExpectDirectiveIndex'.": {
         "category": "Message",
         "code": 100068
+    },
+    "Content mapper output extension '{0}' must be '.js', '.mjs', or '.cjs'.": {
+        "category": "Error",
+        "code": 100069
     }
 }

tsc/internal/diagnostics/extraDiagnosticMessages.json

@@ -159,6 +159,11 @@ func (r *aliasResolver) ContentMapperExtensions() []string {
 	return nil
 }
 
+// ContentMapperOutputExtension implements checker.Program.
+func (r *aliasResolver) ContentMapperOutputExtension(fileName string) string {
+	return ""
+}
+
 // FileExists implements checker.Program.
 func (r *aliasResolver) FileExists(fileName string) bool {
 	panic("unimplemented")

tsc/internal/ls/autoimport/aliasresolver.go

@@ -48,6 +48,10 @@ func (h *mockModuleSpecifierGenerationHost) ContentMapperExtensions() []string {
 	return h.contentMapperExtensions
 }
 
+func (h *mockModuleSpecifierGenerationHost) ContentMapperOutputExtension(fileName string) string {
+	return ""
+}
+
 func (h *mockModuleSpecifierGenerationHost) GetProjectReferenceFromSource(path tspath.Path) *tsoptions.SourceOutputAndProjectReference {
 	return nil
 }

tsc/internal/modulespecifiers/specifiers_test.go

@@ -51,6 +51,7 @@ type ModuleSpecifierGenerationHost interface {
 	// GetFileIncludeReasons() any // !!! TODO: adapt new resolution cache model
 	CommonSourceDirectory() string
 	ContentMapperExtensions() []string
+	ContentMapperOutputExtension(fileName string) string
 	GetGlobalTypingsCacheLocation() string
 	UseCaseSensitiveFileNames() bool
 	GetCurrentDirectory() string

tsc/internal/modulespecifiers/types.go

@@ -9,6 +9,7 @@ import (
 type OutputPathsHost interface {
 	CommonSourceDirectory() string
 	ContentMapperExtensions() []string
+	ContentMapperOutputExtension(fileName string) string
 	GetCurrentDirectory() string
 	UseCaseSensitiveFileNames() bool
 }
@@ -147,6 +148,10 @@ func GetDeclarationEmitOutputFilePath(file string, options *core.CompilerOptions
 
 func ChangeToDeclarationExtension(path string, host OutputPathsHost) string {
 	if extension := tspath.GetLongestExtensionFromPath(path, host.ContentMapperExtensions(), false); extension != "" {
+		if outputExtension := host.ContentMapperOutputExtension(path); outputExtension != "" {
+			outputPath := tspath.RemoveExtension(path, extension) + outputExtension
+			return tspath.RemoveFileExtension(outputPath) + tspath.GetDeclarationEmitExtensionForPath(outputPath)
+		}
 		return tspath.RemoveExtension(path, extension) + ".d" + extension + ".ts"
 	}
 	pathWithoutExtension := tspath.RemoveFileExtension(path)

tsc/internal/outputpaths/outputpaths.go

@@ -1592,7 +1592,33 @@ func (tx *DeclarationTransformer) rewriteModuleSpecifier(parent *ast.Node, input
 		return nil
 	}
 	tx.resultHasExternalModuleIndicator = tx.resultHasExternalModuleIndicator || (parent.Kind != ast.KindModuleDeclaration && parent.Kind != ast.KindImportType)
-	return input
+	return tx.rewriteContentMappedSpecifier(input)
+}
+
+// rewriteContentMappedSpecifier rewrites a relative specifier that resolves to a content-mapped file
+// whose mapper declares an "outputExtension", so the specifier names the file an external build
+// produces (`./component.vue` becomes `./component.js`). The declaration for that file is emitted under
+// the same name (`component.d.ts`), so the rewritten specifier resolves without the mapper.
+func (tx *DeclarationTransformer) rewriteContentMappedSpecifier(input *ast.Node) *ast.Node {
+	if !ast.IsStringLiteral(input) || !tspath.PathIsRelative(input.Text()) {
+		return input
+	}
+	resolved := tx.host.GetResolvedModuleFromModuleSpecifier(tx.state.currentSourceFile, input)
+	if resolved == nil || !resolved.IsResolved() || !resolved.ResolvedUsingExtraExtensions {
+		return input
+	}
+	outputExtension := tx.host.ContentMapperOutputExtension(resolved.ResolvedFileName)
+	if outputExtension == "" {
+		return input
+	}
+	extension := tspath.GetLongestExtensionFromPath(input.Text(), tx.host.ContentMapperExtensions(), !tx.host.UseCaseSensitiveFileNames())
+	if extension == "" {
+		return input
+	}
+	updated := tx.Factory().NewStringLiteral(tspath.RemoveExtension(input.Text(), extension)+outputExtension, input.AsStringLiteral().TokenFlags)
+	tx.EmitContext().SetOriginal(updated, input)
+	tx.EmitContext().AssignCommentAndSourceMapRanges(updated, input)
+	return updated
 }
 
 func (tx *DeclarationTransformer) preserveJsDoc(updated *ast.Node, original *ast.Node) {