diff --git a/packages/typescript/schemas/jsconfig.schema.json b/packages/typescript/schemas/jsconfig.schema.json
index 942fc702a92b7..7a1d9a50dbd41 100644
--- a/packages/typescript/schemas/jsconfig.schema.json
+++ b/packages/typescript/schemas/jsconfig.schema.json
@@ -85,15 +85,36 @@
                                 "type": "array",
                                 "items": {
                                     "type": "string"
-                                }
+                                },
+                                "description": "File extensions handled by this mapper. Defaults to the value of 'typescript.contentMapper.extensions' in the package manifest."
+                            },
+                            "include": {
+                                "type": "array",
+                                "items": {
+                                    "type": "string"
+                                },
+                                "description": "Patterns relative to this config file that narrow which files the mapper handles."
+                            },
+                            "outputExtensions": {
+                                "anyOf": [
+                                    {
+                                        "type": "object",
+                                        "additionalProperties": {
+                                            "type": "string"
+                                        }
+                                    },
+                                    {
+                                        "type": "null"
+                                    }
+                                ],
+                                "description": "Maps source file extensions to output extensions for declaration filenames and rewritten imports."
                             },
                             "options": {
                                 "type": "object"
                             }
                         },
                         "required": [
-                            "package",
-                            "extensions"
+                            "package"
                         ],
                         "additionalProperties": false
                     }
diff --git a/packages/typescript/schemas/tsconfig.schema.json b/packages/typescript/schemas/tsconfig.schema.json
index 6679e3ee65697..5bc10ba9414fb 100644
--- a/packages/typescript/schemas/tsconfig.schema.json
+++ b/packages/typescript/schemas/tsconfig.schema.json
@@ -85,15 +85,36 @@
                                 "type": "array",
                                 "items": {
                                     "type": "string"
-                                }
+                                },
+                                "description": "File extensions handled by this mapper. Defaults to the value of 'typescript.contentMapper.extensions' in the package manifest."
+                            },
+                            "include": {
+                                "type": "array",
+                                "items": {
+                                    "type": "string"
+                                },
+                                "description": "Patterns relative to this config file that narrow which files the mapper handles."
+                            },
+                            "outputExtensions": {
+                                "anyOf": [
+                                    {
+                                        "type": "object",
+                                        "additionalProperties": {
+                                            "type": "string"
+                                        }
+                                    },
+                                    {
+                                        "type": "null"
+                                    }
+                                ],
+                                "description": "Maps source file extensions to output extensions for declaration filenames and rewritten imports."
                             },
                             "options": {
                                 "type": "object"
                             }
                         },
                         "required": [
-                            "package",
-                            "extensions"
+                            "package"
                         ],
                         "additionalProperties": false
                     }
diff --git a/packages/typescript/src/vscode/extensionApi.ts b/packages/typescript/src/vscode/extensionApi.ts
index 36cf8432723f4..1b6f264063d79 100644
--- a/packages/typescript/src/vscode/extensionApi.ts
+++ b/packages/typescript/src/vscode/extensionApi.ts
@@ -25,10 +25,11 @@ export interface ContentMapperManifest {
     readonly compilerOptions?: readonly string[] | undefined;
     readonly dynamicConfig?: boolean | undefined;
     readonly outputExtensions?: Readonly<Record<string, string>> | undefined;
+    readonly extensions?: readonly string[] | undefined;
 }
 
 export interface ContentMapperContribution {
-    readonly extensions: readonly string[];
+    readonly extensions?: readonly string[] | undefined;
     readonly inferredProjectContribution?: {
         readonly options?: Readonly<Record<string, unknown>> | undefined;
         readonly manifest: ContentMapperManifest;
diff --git a/packages/vscode-typescript/src/contentMapperContributions.ts b/packages/vscode-typescript/src/contentMapperContributions.ts
index d6c506a83f293..b3108ad7ea654 100644
--- a/packages/vscode-typescript/src/contentMapperContributions.ts
+++ b/packages/vscode-typescript/src/contentMapperContributions.ts
@@ -3,7 +3,7 @@ export type { ContentMapperContribution, ContentMapperManifest } from "@typescri
 
 export interface SerializedContentMapperContribution {
     readonly contributorId: string;
-    readonly extensions: readonly string[];
+    readonly extensions?: readonly string[];
     readonly inferredProjectContribution?: {
         readonly options?: Readonly<Record<string, unknown>>;
         readonly manifest: {
@@ -14,6 +14,7 @@ export interface SerializedContentMapperContribution {
             readonly compilerOptions?: readonly string[];
             readonly dynamicConfig?: boolean;
             readonly outputExtensions?: Readonly<Record<string, string>>;
+            readonly extensions?: readonly string[];
         };
     };
 }
@@ -26,7 +27,7 @@ export function serializeContentMapperContributions(
         contributions.forEach(contribution => {
             result.push({
                 contributorId,
-                extensions: [...contribution.extensions],
+                ...(contribution.extensions && { extensions: [...contribution.extensions] }),
                 inferredProjectContribution: contribution.inferredProjectContribution && {
                     options: contribution.inferredProjectContribution.options,
                     manifest: {
@@ -37,6 +38,9 @@ export function serializeContentMapperContributions(
                         ...(contribution.inferredProjectContribution.manifest.outputExtensions && {
                             outputExtensions: { ...contribution.inferredProjectContribution.manifest.outputExtensions },
                         }),
+                        ...(contribution.inferredProjectContribution.manifest.extensions && {
+                            extensions: [...contribution.inferredProjectContribution.manifest.extensions],
+                        }),
                     },
                 },
             });
@@ -50,10 +54,11 @@ export function validateContentMapperRegistration(contributorId: string, contrib
         throw new TypeError("Content mapper contributor ID must not be empty.");
     }
     for (const contribution of contributions) {
-        if (contribution.extensions.length === 0 || contribution.extensions.some(extension => !isExtension(extension))) {
+        const extensions = contribution.extensions ?? contribution.inferredProjectContribution?.manifest.extensions;
+        if (!extensions || extensions.length === 0 || extensions.some(extension => !isExtension(extension))) {
             throw new TypeError("Content mapper contributions require non-empty extensions beginning with '.' and containing no path separators.");
         }
-        if (contribution.extensions.some(extension => /\.(?:[cm]?[jt]s|[jt]sx|json)$/i.test(extension))) {
+        if (extensions.some(extension => /\.(?:[cm]?[jt]s|[jt]sx|json)$/i.test(extension))) {
             throw new TypeError("Content mapper extensions must not end in a built-in extension.");
         }
         const inferredProjectContribution = contribution.inferredProjectContribution;
@@ -69,6 +74,9 @@ export function validateContentMapperRegistration(contributorId: string, contrib
         if (inferredProjectContribution?.manifest.outputExtensions && Object.entries(inferredProjectContribution.manifest.outputExtensions).some(([source, output]) => !isExtension(source) || !isExtension(output))) {
             throw new TypeError("Content mapper output extensions must be non-empty, begin with '.', and contain no path separators.");
         }
+        if (inferredProjectContribution?.manifest.extensions?.some(extension => !isExtension(extension))) {
+            throw new TypeError("Content mapper manifest extensions must be non-empty, begin with '.', and contain no path separators.");
+        }
     }
 }
 
@@ -83,7 +91,8 @@ export function documentMatchesContentMapperContributions(
     const documentPath = document.uri.path.toLowerCase();
     for (const contributions of registrations.values()) {
         for (const contribution of contributions) {
-            if (contribution.extensions.some(extension => documentPath.endsWith(extension.toLowerCase()))) {
+            const extensions = contribution.extensions ?? contribution.inferredProjectContribution?.manifest.extensions ?? [];
+            if (extensions.some(extension => documentPath.endsWith(extension.toLowerCase()))) {
                 return true;
             }
         }
diff --git a/packages/vscode-typescript/test/contentMapperContributions.test.ts b/packages/vscode-typescript/test/contentMapperContributions.test.ts
index 57e3771d28765..eeea7d9d851f3 100644
--- a/packages/vscode-typescript/test/contentMapperContributions.test.ts
+++ b/packages/vscode-typescript/test/contentMapperContributions.test.ts
@@ -90,4 +90,30 @@ describe("content mapper contributions", { concurrency: true }, () => {
             },
         }]);
     });
+
+    test("uses manifest extensions when the contribution omits extensions", () => {
+        const contribution = {
+            inferredProjectContribution: {
+                manifest: {
+                    name: "mapper",
+                    exec: ["mapper"],
+                    extensions: [".toml"],
+                },
+            },
+        } satisfies ContentMapperContribution;
+        assert.doesNotThrow(() => validateContentMapperRegistration("mapper", [contribution]));
+        assert.deepEqual(serializeContentMapperContributions(new Map([["mapper", [contribution]]])), [{
+            contributorId: "mapper",
+            inferredProjectContribution: {
+                options: undefined,
+                manifest: {
+                    name: "mapper",
+                    exec: ["mapper"],
+                    extensions: [".toml"],
+                    cwd: undefined,
+                    compilerOptions: undefined,
+                },
+            },
+        }]);
+    });
 });
diff --git a/tools/scripts/lsp/generate.mts b/tools/scripts/lsp/generate.mts
index 5afe911d2457b..b05beb6f56f39 100644
--- a/tools/scripts/lsp/generate.mts
+++ b/tools/scripts/lsp/generate.mts
@@ -460,6 +460,7 @@ const customStructures: Structure[] = [
             { name: "compilerOptions", type: { kind: "array", element: { kind: "base", name: "string" } }, optional: true, documentation: "Compiler option names forwarded to the mapper." },
             { name: "dynamicConfig", type: { kind: "base", name: "boolean" }, optional: true, documentation: "Whether the mapper uses project-scoped dynamic configuration." },
             { name: "outputExtensions", type: { kind: "map", key: { kind: "base", name: "string" }, value: { kind: "base", name: "string" } }, optional: true, documentation: "Default source-to-runtime output extension mappings." },
+            { name: "extensions", type: { kind: "array", element: { kind: "base", name: "string" } }, optional: true, documentation: "Default source extensions handled by the mapper." },
         ],
         documentation: "Inline content mapper manifest supplied by a contributing extension.",
     },
@@ -475,7 +476,7 @@ const customStructures: Structure[] = [
         name: "ContentMapperContribution",
         properties: [
             { name: "contributorId", type: { kind: "base", name: "string" }, documentation: "Unique identifier of the contributor extension." },
-            { name: "extensions", type: { kind: "array", element: { kind: "base", name: "string" } }, documentation: "File extensions handled by this content mapper." },
+            { name: "extensions", type: { kind: "array", element: { kind: "base", name: "string" } }, optional: true, documentation: "File extensions handled by this content mapper." },
             { name: "inferredProjectContribution", type: { kind: "reference", name: "InferredProjectContentMapperContribution" }, optional: true, documentation: "When present, contributes this mapper to inferred projects." },
         ],
         documentation: "One extension-provided content mapper contribution.",
diff --git a/tools/scripts/tsc/options-schema.ts b/tools/scripts/tsc/options-schema.ts
index cacc817c3349a..8dee3358b5516 100644
--- a/tools/scripts/tsc/options-schema.ts
+++ b/tools/scripts/tsc/options-schema.ts
@@ -110,10 +110,23 @@ function valueSchema(declaration: Declaration): JSONSchema {
                     type: "object",
                     properties: {
                         package: { type: "string", minLength: 1 },
-                        extensions: { type: "array", items: { type: "string" } },
+                        extensions: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "File extensions handled by this mapper. Defaults to the value of 'typescript.contentMapper.extensions' in the package manifest.",
+                        },
+                        include: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Patterns relative to this config file that narrow which files the mapper handles.",
+                        },
+                        outputExtensions: {
+                            ...nullable({ type: "object", additionalProperties: { type: "string" } }),
+                            description: "Maps source file extensions to output extensions for declaration filenames and rewritten imports.",
+                        },
                         options: { type: "object" },
                     },
-                    required: ["package", "extensions"],
+                    required: ["package"],
                     additionalProperties: false,
                 };
             }
diff --git a/tools/scripts/tsc/options.test.ts b/tools/scripts/tsc/options.test.ts
index 27c9827bdb056..d4fa3ab8b1448 100644
--- a/tools/scripts/tsc/options.test.ts
+++ b/tools/scripts/tsc/options.test.ts
@@ -352,6 +352,10 @@ test("schemas accept representative valid configs and reject malformed configs",
         { compilerOptions: { paths: { "@/*": ["src/*"] }, plugins: [{ name: "some-plugin", customSetting: true }], moduleSuffixes: ["", ".native"] } },
         { typeAcquisition: { enable: true, include: ["node"], exclude: [] } },
         { contentMappers: [{ package: "mapper", extensions: [".vue"], options: { customSetting: true } }] },
+        { contentMappers: [{ package: "mapper" }] },
+        { contentMappers: [{ package: "mapper", include: ["src", "**/blob.toml"] }] },
+        { contentMappers: [{ package: "mapper", include: [], outputExtensions: { ".vue": ".js" } }] },
+        { contentMappers: [{ package: "mapper", outputExtensions: null }] },
         { "$schema": "./tsconfig.schema.json", "tool-specific": { anything: true } },
     ];
     const invalid = [
@@ -378,8 +382,10 @@ test("schemas accept representative valid configs and reject malformed configs",
         { references: [{ path: "" }] },
         { references: [{ path: null }] },
         { contentMappers: [{ package: "", extensions: [] }] },
-        { contentMappers: [{ package: "mapper" }] },
         { contentMappers: [{ package: "mapper", extensions: [1] }] },
+        { contentMappers: [{ package: "mapper", include: "src" }] },
+        { contentMappers: [{ package: "mapper", include: [1] }] },
+        { contentMappers: [{ package: "mapper", outputExtensions: { ".vue": 1 } }] },
         { contentMappers: [{ package: "mapper", extensions: [], options: null }] },
     ];
     for (const kind of ["tsconfig", "jsconfig"] as const) {
diff --git a/tsc/internal/api/module_resolution.go b/tsc/internal/api/module_resolution.go
index d7640b28892c1..985d05a867977 100644
--- a/tsc/internal/api/module_resolution.go
+++ b/tsc/internal/api/module_resolution.go
@@ -356,11 +356,18 @@ func (s *Session) handleResolveModuleName(ctx context.Context, params *ResolveMo
 		if err != nil {
 			return nil, err
 		}
-		resolver = module.NewResolver(module.ResolverOptions{
+		options := module.ResolverOptions{
 			Host:            sd.snapshot,
 			CompilerOptions: data.compilerOptions,
 			ExtraExtensions: sd.snapshot.ContentMapperExtensions(),
-		})
+		}
+		if configPath := data.compilerOptions.ConfigFilePath; configPath != "" {
+			if config := sd.snapshot.ConfigFileRegistry.GetConfig(s.caseSensitivity().PathKey(configPath.AsPath())); config != nil {
+				options.ExtraExtensions = config.ContentMapperExtensions()
+				options.ContentMapperFileMatcher = config.ContentMapperFileMatcher()
+			}
+		}
+		resolver = module.NewResolver(options)
 	} else {
 		resolver = module.NewResolver(module.ResolverOptions{
 			Host:            s,
diff --git a/tsc/internal/api/session_module_resolution_test.go b/tsc/internal/api/session_module_resolution_test.go
index ccffe90b69709..731145f291ff1 100644
--- a/tsc/internal/api/session_module_resolution_test.go
+++ b/tsc/internal/api/session_module_resolution_test.go
@@ -66,6 +66,56 @@ func TestModuleResolverUsesSnapshotFileSystem(t *testing.T) {
 	assert.Assert(t, len(result.Trace) > 0)
 }
 
+func TestContentMapperModuleResolverProjectContext(t *testing.T) {
+	t.Parallel()
+	init, _ := projecttestutil.GetSessionInitOptions(map[string]any{
+		"/a/tsconfig.json": `{
+			"files": ["a.ts"], "compilerOptions": {"noLib": true},
+			"contentMappers": [{"package": "mapper", "extensions": [".blob.toml"], "include": ["../b"]}]
+		}`,
+		"/b/tsconfig.json": `{
+			"files": ["b.ts"], "compilerOptions": {"noLib": true},
+			"contentMappers": [{"package": "mapper", "extensions": [".toml"]}]
+		}`,
+		"/a/a.ts":        "export {};",
+		"/b/b.ts":        "export {};",
+		"/b/x.blob.toml": "",
+		"/c/x.blob.toml": "",
+		"/node_modules/mapper/package.json": `{
+			"name": "mapper", "typescript": {"contentMapper": {"exec": ["run"]}}
+		}`,
+	}, nil, nil)
+	init.Options.RunExternalCode = true
+	session := NewStandaloneSession(init, nil)
+	defer session.Close()
+	snapshot, err := session.handleCreateSnapshot(t.Context(), &CreateSnapshotParams{
+		OpenProjects: []DocumentIdentifier{{FileName: "/a/tsconfig.json"}, {FileName: "/b/tsconfig.json"}},
+	})
+	assert.NilError(t, err)
+	for _, test := range []struct {
+		configPath tspath.RootedFilePath
+		extension  string
+		directory  string
+	}{
+		{configPath: "/b/tsconfig.json", directory: "/b", extension: ".toml"},
+		{directory: "/c", extension: ".blob.toml"},
+	} {
+		resolver, err := session.handleCreateModuleResolver(&CreateModuleResolverParams{
+			CompilerOptions: core.CompilerOptions{
+				ConfigFilePath: test.configPath, Module: core.ModuleKindPreserve, ModuleResolution: core.ModuleResolutionKindBundler,
+			},
+		})
+		assert.NilError(t, err)
+		result, err := session.handleResolveModuleName(t.Context(), &ResolveModuleNameParams{
+			Snapshot: snapshot.Snapshot, Resolver: resolver, ModuleName: "./x.blob.toml",
+			ContainingDirectory: DocumentIdentifier{FileName: test.directory},
+		})
+		assert.NilError(t, err)
+		assert.Assert(t, result.ResolvedModule != nil)
+		assert.Equal(t, result.ResolvedModule.Extension, test.extension)
+	}
+}
+
 func TestStaticModuleResolutionSpecificityAndLifetime(t *testing.T) {
 	t.Parallel()
 
diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go
index d689a6453e8a6..e80cbefa5edaf 100644
--- a/tsc/internal/checker/checker.go
+++ b/tsc/internal/checker/checker.go
@@ -16,6 +16,7 @@ import (
 	"github.com/microsoft/TypeScript/tsc/internal/ast"
 	"github.com/microsoft/TypeScript/tsc/internal/binder"
 	"github.com/microsoft/TypeScript/tsc/internal/collections"
+	"github.com/microsoft/TypeScript/tsc/internal/contentmapper"
 	"github.com/microsoft/TypeScript/tsc/internal/core"
 	"github.com/microsoft/TypeScript/tsc/internal/debug"
 	"github.com/microsoft/TypeScript/tsc/internal/diagnostics"
@@ -15601,6 +15602,7 @@ func (c *Checker) resolveExternalModule(
 				!tspath.IsDeclarationFileName(moduleReference) &&
 				(!ast.IsLiteralImportTypeNode(location) && !ast.IsPartOfTypeOnlyImportOrExportDeclaration(location) ||
 					checkDeclarationRewrite) {
+				rewrites = contentmapper.RewritesForImport(rewrites, importingSourceFile.FileName(), specifier, c.program.ContentMapperExtensionForFileName, caseSensitivity)
 				shouldRewrite := specifier.ShouldRewriteExtension(rewrites, caseSensitivity)
 				mappedSource := false
 				if sourceFile.ContentMapper() != "" {
diff --git a/tsc/internal/checker/nodebuilderimpl.go b/tsc/internal/checker/nodebuilderimpl.go
index 7c90f3f320fbc..281ba55b11c40 100644
--- a/tsc/internal/checker/nodebuilderimpl.go
+++ b/tsc/internal/checker/nodebuilderimpl.go
@@ -8,6 +8,7 @@ import (
 
 	"github.com/microsoft/TypeScript/tsc/internal/ast"
 	"github.com/microsoft/TypeScript/tsc/internal/collections"
+	"github.com/microsoft/TypeScript/tsc/internal/contentmapper"
 	"github.com/microsoft/TypeScript/tsc/internal/core"
 	"github.com/microsoft/TypeScript/tsc/internal/debug"
 	"github.com/microsoft/TypeScript/tsc/internal/jsnum"
@@ -1350,6 +1351,9 @@ func (b *NodeBuilderImpl) rewriteContentMappedModuleSpecifier(specifier tspath.M
 	if b.ctx.internalFlags&nodebuilder.InternalFlagsRewriteModuleSpecifiers != 0 && b.ch.compilerOptions.RewriteRelativeImportExtensions.IsTrue() {
 		rewrites := b.ctx.host.ContentMapperExtensionRewrites()
 		caseSensitivity := b.ctx.host.CaseSensitivity()
+		if b.ctx.enclosingFile != nil {
+			rewrites = contentmapper.RewritesForImport(rewrites, b.ctx.enclosingFile.FileName(), specifier, b.ctx.host.ContentMapperExtensionForFileName, caseSensitivity)
+		}
 		if specifier.ShouldRewriteExtension(rewrites, caseSensitivity) {
 			rewritten, _ := specifier.RewriteExtension(rewrites, caseSensitivity)
 			return rewritten
diff --git a/tsc/internal/compiler/contentmapper_test.go b/tsc/internal/compiler/contentmapper_test.go
index 31b8f831870e8..8a0a29e3c8e14 100644
--- a/tsc/internal/compiler/contentmapper_test.go
+++ b/tsc/internal/compiler/contentmapper_test.go
@@ -66,6 +66,118 @@ func newContentMapperProgramWithOptions(t *testing.T, contentMapperProject conte
 	})
 }
 
+func TestContentMapperSymlinkedPackage(t *testing.T) {
+	t.Parallel()
+	for _, test := range []struct {
+		name             string
+		include          []string
+		wantFiltered     bool
+		preserveSymlinks bool
+	}{
+		{name: "logical include", include: []string{"node_modules/@scope/lib"}},
+		{name: "unchanged association"},
+		{name: "realpath mapper", include: []string{"packages/lib"}, wantFiltered: true},
+		{name: "logical then real include", include: []string{"node_modules/@scope/lib", "packages/lib"}, wantFiltered: true},
+		{name: "real then logical include", include: []string{"packages/lib", "node_modules/@scope/lib"}, wantFiltered: true},
+		{name: "preserved logical include", include: []string{"node_modules/@scope/lib"}, wantFiltered: true, preserveSymlinks: true},
+		{name: "preserved real include", include: []string{"packages/lib"}, preserveSymlinks: true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			// A root and both package and relative imports must share the same loaded path.
+			dataPath := tspath.RootedFilePath("/project/packages/lib/data.vue")
+			directImport := "./packages/lib/data.vue"
+			if test.preserveSymlinks {
+				dataPath = "/project/node_modules/@scope/lib/data.vue"
+				directImport = "./node_modules/@scope/lib/data.vue"
+			}
+			fs := vfstest.FromMap(map[string]any{
+				"/project/main.ts":                   `import { value } from "@scope/lib/data.vue"; import { value as direct } from "` + directImport + `"; export { value, direct };`,
+				"/project/node_modules/@scope/lib":   vfstest.Symlink("/project/packages/lib"),
+				"/project/packages/lib/package.json": `{"name": "@scope/lib", "version": "1.0.0"}`,
+				"/project/packages/lib/data.vue":     "<template />",
+			}, tspath.CaseSensitive)
+			config := tsoptions.NewParsedCommandLine(&core.CompilerOptions{
+				NoLib: core.TSTrue, Module: core.ModuleKindPreserve, ModuleResolution: core.ModuleResolutionKindBundler,
+				PreserveSymlinks: core.BoolToTristate(test.preserveSymlinks),
+			}, []tspath.RootedFilePath{"/project/main.ts", dataPath}, nil, "/project", fs.CaseSensitivity())
+			fallback := &contentmapper.Mapper{Package: "fallback", Extensions: []string{".vue"}, Name: "fallback"}
+			config.ParsedConfig.ContentMappers = []*contentmapper.Mapper{fallback}
+			expectedMapper := fallback
+			if test.include != nil {
+				filtered := &contentmapper.Mapper{Package: "filtered", Extensions: []string{".vue"}, Include: test.include, Name: "filtered"}
+				config.ParsedConfig.ContentMappers = append(config.ParsedConfig.ContentMappers, filtered)
+				if test.wantFiltered {
+					expectedMapper = filtered
+				}
+			}
+			program := compiler.NewProgram(compiler.ProgramOptions{
+				Config: config,
+				Host: compiler.NewCompilerHost(fs, "/", nil, nil, fakeContentMapperHost{
+					transform: func(fileName, content string) (contentmapper.Result, error) {
+						return contentmapper.Result{Text: "export const value = 1;", VirtualExtension: ".ts", Mappings: spanmap.New(nil)}, nil
+					},
+				}),
+				SingleThreaded: core.TSTrue,
+			})
+			assert.Equal(t, len(program.SourceFiles()), 2)
+			assert.Equal(t, len(program.DuplicateSourceFiles()), 0)
+			file := program.GetSourceFile(dataPath)
+			assert.Assert(t, file != nil)
+			assert.Equal(t, file.Text(), "export const value = 1;")
+			assert.Equal(t, program.GetContentMapper(file), expectedMapper)
+			assert.Equal(t, program.ContentMapperExtensionForFileName(file.FileName()), ".vue")
+			assert.Equal(t, len(program.GetSemanticDiagnostics(context.Background(), program.GetSourceFile("/project/main.ts"))), 0)
+		})
+	}
+}
+
+func TestContentMapperRelativeSymlinkedDirectory(t *testing.T) {
+	t.Parallel()
+	// Root discovery and the relative import must both retain src/linked rather than its realpath.
+	for _, filtered := range []bool{false, true} {
+		t.Run(core.IfElse(filtered, "filtered", "extension only"), func(t *testing.T) {
+			t.Parallel()
+			fs := vfstest.FromMap(map[string]any{
+				"/project/tsconfig.json": `{
+					"compilerOptions": {"noLib": true, "module": "preserve", "moduleResolution": "bundler"},
+					"include": ["src"],
+					"contentMappers": [{"package": "mapper", "extensions": [".vue"]` + core.IfElse(filtered, `, "include": ["src"]`, "") + `}]
+				}`,
+				"/project/node_modules/mapper/package.json": `{
+					"name": "mapper", "typescript": {"contentMapper": {"exec": ["run"]}}
+				}`,
+				"/project/src/main.ts":     `import { value } from "./linked/data.vue"; export { value };`,
+				"/project/src/linked":      vfstest.Symlink("/project/shared"),
+				"/project/shared/data.vue": "<template />",
+			}, tspath.CaseSensitive)
+			config, errors := tsoptions.GetParsedCommandLineOfConfigFile(
+				"/project/tsconfig.json", &core.CompilerOptions{RunExternalCode: core.TSTrue}, nil, tsoptions.NewDefaultParseConfigHost(fs), nil,
+			)
+			assert.Equal(t, len(errors), 0)
+			assert.Equal(t, len(config.Errors), 0)
+			assert.Assert(t, slices.Contains(config.FileNames(), "/project/src/linked/data.vue"))
+			program := compiler.NewProgram(compiler.ProgramOptions{
+				Config: config,
+				Host: compiler.NewCompilerHost(fs, "/", nil, nil, fakeContentMapperHost{
+					transform: func(fileName, content string) (contentmapper.Result, error) {
+						return contentmapper.Result{Text: "export const value = 1;", VirtualExtension: ".ts", Mappings: spanmap.New(nil)}, nil
+					},
+				}),
+				SingleThreaded: core.TSTrue,
+			})
+			assert.Equal(t, len(program.SourceFiles()), 2)
+			assert.Equal(t, len(program.DuplicateSourceFiles()), 0)
+			assert.Assert(t, program.GetSourceFile("/project/shared/data.vue") == nil)
+			file := program.GetSourceFile("/project/src/linked/data.vue")
+			assert.Assert(t, file != nil)
+			assert.Equal(t, file.Text(), "export const value = 1;")
+			assert.Equal(t, program.GetContentMapper(file), config.ContentMappers()[0])
+			assert.Equal(t, len(program.GetSemanticDiagnostics(t.Context(), program.GetSourceFile("/project/src/main.ts"))), 0)
+		})
+	}
+}
+
 func TestContentMapperVirtualExtensionSetsImpliedNodeFormat(t *testing.T) {
 	t.Parallel()
 	program := newContentMapperProgramWithOptions(
diff --git a/tsc/internal/compiler/emitHost.go b/tsc/internal/compiler/emitHost.go
index 6139ebb7ee2c8..24c5b39d6de67 100644
--- a/tsc/internal/compiler/emitHost.go
+++ b/tsc/internal/compiler/emitHost.go
@@ -111,8 +111,8 @@ func (host *emitHost) CommonSourceDirectory() tspath.RootedDirectoryPath {
 	return host.program.CommonSourceDirectory()
 }
 
-func (host *emitHost) ContentMapperExtensions() []string {
-	return host.program.ContentMapperExtensions()
+func (host *emitHost) ContentMapperExtensionForFileName(fileName tspath.RootedFilePath) string {
+	return host.program.ContentMapperExtensionForFileName(fileName)
 }
 
 func (host *emitHost) ContentMapperExtensionRewrites() []tspath.ExtensionRewrite {
diff --git a/tsc/internal/compiler/emitter.go b/tsc/internal/compiler/emitter.go
index 7cf9d58b5fcef..bf48ca92ac2f0 100644
--- a/tsc/internal/compiler/emitter.go
+++ b/tsc/internal/compiler/emitter.go
@@ -131,13 +131,14 @@ func getScriptTransformers(emitResolver printer.EmitResolver, host printer.EmitH
 	}
 
 	opts := transformers.TransformOptions{
-		Context:                        emitContext,
-		CompilerOptions:                options,
-		Resolver:                       referenceResolver,
-		EmitResolver:                   emitResolver,
-		GetEmitModuleFormatOfFile:      host.GetEmitModuleFormatOfFile,
-		ContentMapperExtensionRewrites: host.ContentMapperExtensionRewrites(),
-		CaseSensitivity:                host.CaseSensitivity(),
+		Context:                           emitContext,
+		CompilerOptions:                   options,
+		Resolver:                          referenceResolver,
+		EmitResolver:                      emitResolver,
+		GetEmitModuleFormatOfFile:         host.GetEmitModuleFormatOfFile,
+		ContentMapperExtensionRewrites:    host.ContentMapperExtensionRewrites(),
+		ContentMapperExtensionForFileName: host.ContentMapperExtensionForFileName,
+		CaseSensitivity:                   host.CaseSensitivity(),
 	}
 
 	// transform TypeScript syntax
diff --git a/tsc/internal/compiler/fileloader.go b/tsc/internal/compiler/fileloader.go
index b8bb4b7283cb4..0d709236af465 100644
--- a/tsc/internal/compiler/fileloader.go
+++ b/tsc/internal/compiler/fileloader.go
@@ -56,7 +56,6 @@ type fileLoader struct {
 	caseSensitivity                                tspath.CaseSensitivity
 	supportedExtensions                            [][]string
 	supportedExtensionsWithJsonIfResolveJsonModule [][]string
-	contentMapperExtensions                        []string
 
 	filesParser *filesParser
 	rootTasks   []*parseTask
@@ -189,15 +188,15 @@ func processAllProgramFiles(
 		rootTasks:           make([]*parseTask, 0, len(rootFiles)+len(compilerOptions.Lib)),
 		supportedExtensions: supportedExtensions,
 		supportedExtensionsWithJsonIfResolveJsonModule: supportedExtensionsWithJsonIfResolveJsonModule,
-		contentMapperExtensions:                        opts.Config.ContentMapperExtensions(),
 	}
 	loader.addProjectReferenceTasks(singleThreaded)
 	resolverOptions := module.ResolverOptions{
-		Host:            loader.projectReferences.host,
-		CompilerOptions: compilerOptions,
-		TypingsLocation: opts.TypingsLocation,
-		ProjectName:     opts.ProjectName,
-		ExtraExtensions: opts.Config.ContentMapperExtensions(),
+		Host:                     loader.projectReferences.host,
+		CompilerOptions:          compilerOptions,
+		TypingsLocation:          opts.TypingsLocation,
+		ProjectName:              opts.ProjectName,
+		ExtraExtensions:          opts.Config.ContentMapperExtensions(),
+		ContentMapperFileMatcher: opts.Config.ContentMapperFileMatcher(),
 	}
 	if opts.CreateModuleResolver != nil {
 		loader.resolver = opts.CreateModuleResolver(resolverOptions)
@@ -420,7 +419,7 @@ func (p *fileLoader) parseSourceFile(t *parseTask) *ast.SourceFile {
 		PathKey:                        t.path,
 		ExternalModuleIndicatorOptions: ast.GetExternalModuleIndicatorOptions(t.normalizedFilePath, options, t.metadata),
 	}
-	if t.normalizedFilePath.ExtensionIsOneOf(p.contentMapperExtensions) {
+	if p.opts.Config.GetContentMapperForFileName(t.normalizedFilePath) != nil {
 		return p.parseContentMappedFile(parseOptions)
 	}
 	return p.host.GetSourceFile(parseOptions)
diff --git a/tsc/internal/compiler/program.go b/tsc/internal/compiler/program.go
index 9946362def3ad..6713d3cb30233 100644
--- a/tsc/internal/compiler/program.go
+++ b/tsc/internal/compiler/program.go
@@ -550,7 +550,9 @@ func (p *Program) GetContentMapper(file *ast.SourceFile) *contentmapper.Mapper {
 	return nil
 }
 
-func (p *Program) ContentMapperExtensions() []string { return p.opts.Config.ContentMapperExtensions() }
+func (p *Program) ContentMapperExtensionForFileName(fileName tspath.RootedFilePath) string {
+	return p.opts.Config.ContentMapperExtensionForFileName(fileName)
+}
 
 func (p *Program) ContentMapperExtensionRewrites() []tspath.ExtensionRewrite {
 	return p.opts.Config.ContentMapperExtensionRewrites()
diff --git a/tsc/internal/contentmapper/contentmapper.go b/tsc/internal/contentmapper/contentmapper.go
index 158e6ee4be1b5..08a1f437f8a23 100644
--- a/tsc/internal/contentmapper/contentmapper.go
+++ b/tsc/internal/contentmapper/contentmapper.go
@@ -29,10 +29,11 @@ import (
 var ErrProjectUnavailable = errors.New("content mapper project is unavailable")
 
 // Definition is a content mapper as declared in a tsconfig's "contentMappers": the npm package that
-// implements the mapper and the otherwise unsupported file extensions it registers.
+// implements the mapper, its effective file extensions, and an optional project-relative include filter.
 type Definition struct {
 	Package    string   `json:"package"`
 	Extensions []string `json:"extensions"`
+	Include    []string `json:"include,omitzero"`
 	// OutputExtensions contains the resolved mapping after applying manifest defaults and project overrides.
 	OutputExtensions map[string]string `json:"outputExtensions,omitzero"`
 	Options          json.Value        `json:"options,omitempty"`
@@ -48,6 +49,7 @@ type Manifest struct {
 	CompilerOptions         []string
 	DynamicConfig           bool
 	DefaultOutputExtensions map[string]string
+	DefaultExtensions       []string
 }
 
 // Mapper is a resolved content mapper: its tsconfig Definition combined with the Manifest resolved from
@@ -128,6 +130,8 @@ func (m *Mapper) Equals(other *Mapper) bool {
 	return m.Package == other.Package &&
 		(m.Extensions == nil) == (other.Extensions == nil) &&
 		slices.Equal(m.Extensions, other.Extensions) &&
+		(m.Include == nil) == (other.Include == nil) &&
+		slices.Equal(m.Include, other.Include) &&
 		(m.Definition.OutputExtensions == nil) == (other.Definition.OutputExtensions == nil) &&
 		maps.Equal(m.Definition.OutputExtensions, other.Definition.OutputExtensions) &&
 		(m.Options == nil) == (other.Options == nil) &&
@@ -139,6 +143,8 @@ func (m *Mapper) Equals(other *Mapper) bool {
 		(m.CompilerOptions == nil) == (other.CompilerOptions == nil) &&
 		slices.Equal(m.CompilerOptions, other.CompilerOptions) &&
 		m.DynamicConfig == other.DynamicConfig &&
+		(m.DefaultExtensions == nil) == (other.DefaultExtensions == nil) &&
+		slices.Equal(m.DefaultExtensions, other.DefaultExtensions) &&
 		(m.Manifest.DefaultOutputExtensions == nil) == (other.Manifest.DefaultOutputExtensions == nil) &&
 		maps.Equal(m.Manifest.DefaultOutputExtensions, other.Manifest.DefaultOutputExtensions) &&
 		m.PackageDirectory == other.PackageDirectory &&
diff --git a/tsc/internal/contentmapper/filematcher.go b/tsc/internal/contentmapper/filematcher.go
new file mode 100644
index 0000000000000..be425edb5cc85
--- /dev/null
+++ b/tsc/internal/contentmapper/filematcher.go
@@ -0,0 +1,94 @@
+package contentmapper
+
+import (
+	"github.com/microsoft/TypeScript/tsc/internal/tspath"
+	"github.com/microsoft/TypeScript/tsc/internal/vfs/vfsmatch"
+)
+
+// FileMatcher is the static, host-independent file association data for a project.
+type FileMatcher struct {
+	mappers         []*Mapper
+	includes        []*vfsmatch.SpecMatcher
+	caseSensitivity tspath.CaseSensitivity
+}
+
+func NewFileMatcher(mappers []*Mapper, baseDirectory tspath.RootedDirectoryPath, caseSensitivity tspath.CaseSensitivity) *FileMatcher {
+	matcher := &FileMatcher{mappers: mappers, caseSensitivity: caseSensitivity}
+	for _, mapper := range mappers {
+		matcher.includes = append(matcher.includes, vfsmatch.NewSpecMatcher(mapper.Include, baseDirectory, vfsmatch.UsageContentMapperInclude, caseSensitivity))
+	}
+	return matcher
+}
+
+func (m *FileMatcher) GetMapperForFileName(fileName tspath.RootedFilePath) *Mapper {
+	mapper, _ := m.match(fileName)
+	return mapper
+}
+
+func (m *FileMatcher) ExtensionForFileName(fileName tspath.RootedFilePath) string {
+	_, extension := m.match(fileName)
+	return extension
+}
+
+func (m *FileMatcher) match(fileName tspath.RootedFilePath) (*Mapper, string) {
+	if m == nil {
+		return nil, ""
+	}
+	var fallback *Mapper
+	longestExtension := ""
+	for i, mapper := range m.mappers {
+		extension := fileName.LongestExtension(mapper.Extensions, m.caseSensitivity)
+		if extension == "" {
+			continue
+		}
+		if mapper.Include != nil {
+			matcher := m.includes[i]
+			if matcher == nil {
+				// An empty include matches nothing.
+				continue
+			}
+			if !matcher.MatchFileName(fileName) {
+				continue
+			}
+			return mapper, extension
+		}
+		if len(extension) > len(longestExtension) {
+			fallback = mapper
+			longestExtension = extension
+		}
+	}
+	return fallback, longestExtension
+}
+
+// IsUnclaimed reports whether a registered extension matches but no mapper claims the file.
+func (m *FileMatcher) IsUnclaimed(fileName tspath.RootedFilePath) bool {
+	if m != nil {
+		for _, mapper := range m.mappers {
+			if fileName.LongestExtension(mapper.Extensions, m.caseSensitivity) != "" {
+				return m.GetMapperForFileName(fileName) == nil
+			}
+		}
+	}
+	return false
+}
+
+func RewritesForImport(rewrites []tspath.ExtensionRewrite, importingFile tspath.RootedFilePath, specifier tspath.ModuleSpecifier, extensionForFileName func(tspath.RootedFilePath) string, caseSensitivity tspath.CaseSensitivity) []tspath.ExtensionRewrite {
+	if importingFile != "" && extensionForFileName != nil && specifier.IsRelative() {
+		path := importingFile.Directory().ResolveFile(specifier.AsString())
+		return FilterExtensionRewrites(rewrites, extensionForFileName(path), caseSensitivity)
+	}
+	return rewrites
+}
+
+// FilterExtensionRewrites selects the rewrite for the winning mapper's extension, rather than a
+// longer extension registered by a mapper that does not claim this file.
+func FilterExtensionRewrites(rewrites []tspath.ExtensionRewrite, extension string, caseSensitivity tspath.CaseSensitivity) []tspath.ExtensionRewrite {
+	if extension != "" {
+		for i, rewrite := range rewrites {
+			if caseSensitivity.Canonicalize(rewrite.Source) == caseSensitivity.Canonicalize(extension) {
+				return rewrites[i : i+1]
+			}
+		}
+	}
+	return nil
+}
diff --git a/tsc/internal/diagnostics/diagnosticMessages.generated.json b/tsc/internal/diagnostics/diagnosticMessages.generated.json
index bf7f327e371c0..9b2c2f27f900c 100644
--- a/tsc/internal/diagnostics/diagnosticMessages.generated.json
+++ b/tsc/internal/diagnostics/diagnosticMessages.generated.json
@@ -1959,6 +1959,11 @@
     "The_typescript_contentMapper_outputExtensions_of_the_content_mapper_package_0_must_be_an_object_with_18122": "The 'typescript.contentMapper.outputExtensions' of the content mapper package '{0}' must be an object with string values.",
     "Content_mapper_extension_0_must_not_contain_path_separators_18123": "Content mapper extension '{0}' must not contain path separators.",
     "The_content_mapper_package_0_is_outside_the_open_workspace_and_will_not_be_loaded_18124": "The content mapper package '{0}' is outside the open workspace and will not be loaded.",
+    "Content_mapper_0_must_specify_extensions_in_tsconfig_or_its_package_manifest_18125": "Content mapper '{0}' must specify 'extensions' in tsconfig or its package manifest.",
+    "Content_mapper_0_is_also_registered_for_the_extension_1_but_has_a_conflicting_outputExtensions_mappi_18127": "Content mapper '{0}' is also registered for the extension '{1}', but has a conflicting 'outputExtensions' mapping. Each registration for this extension must produce the same output file name.",
+    "Content_mapper_0_is_also_registered_for_the_extension_1_but_has_no_outputExtensions_mapping_Each_reg_18128": "Content mapper '{0}' is also registered for the extension '{1}', but has no 'outputExtensions' mapping. Each registration for this extension must produce the same output file name.",
+    "The_conflicting_mapper_registration_is_declared_here_18130": "The conflicting mapper registration is declared here.",
+    "The_conflicting_mapper_registration_is_declared_here_Its_outputExtensions_setting_is_inherited_from__18131": "The conflicting mapper registration is declared here. Its 'outputExtensions' setting is inherited from the mapper's package.json.",
     "nodenext_if_module_is_nodenext_node16_if_module_is_node16_or_node18_otherwise_bundler_69010": "`nodenext` if `module` is `nodenext`; `node16` if `module` is `node16` or `node18`; otherwise, `bundler`.",
     "File_is_a_CommonJS_module_it_may_be_converted_to_an_ES_module_80001": "File is a CommonJS module; it may be converted to an ES module.",
     "This_constructor_function_may_be_converted_to_a_class_declaration_80002": "This constructor function may be converted to a class declaration.",
diff --git a/tsc/internal/diagnostics/diagnosticMessages.json b/tsc/internal/diagnostics/diagnosticMessages.json
index 895ede2e4fa92..ac9f8f97ab2e9 100644
--- a/tsc/internal/diagnostics/diagnosticMessages.json
+++ b/tsc/internal/diagnostics/diagnosticMessages.json
@@ -8955,5 +8955,25 @@
     "Content mapper extension '{0}' must not contain path separators.": {
         "category": "Error",
         "code": 18123
+    },
+    "Content mapper '{0}' must specify 'extensions' in tsconfig or its package manifest.": {
+        "category": "Error",
+        "code": 18125
+    },
+    "Content mapper '{0}' is also registered for the extension '{1}', but has a conflicting 'outputExtensions' mapping. Each registration for this extension must produce the same output file name.": {
+        "category": "Error",
+        "code": 18127
+    },
+    "Content mapper '{0}' is also registered for the extension '{1}', but has no 'outputExtensions' mapping. Each registration for this extension must produce the same output file name.": {
+        "category": "Error",
+        "code": 18128
+    },
+    "The conflicting mapper registration is declared here.": {
+        "category": "Message",
+        "code": 18130
+    },
+    "The conflicting mapper registration is declared here. Its 'outputExtensions' setting is inherited from the mapper's package.json.": {
+        "category": "Message",
+        "code": 18131
     }
 }
diff --git a/tsc/internal/diagnostics/diagnostics_generated.go b/tsc/internal/diagnostics/diagnostics_generated.go
index fbd75c71bbe08..7bba9723ccc9b 100644
--- a/tsc/internal/diagnostics/diagnostics_generated.go
+++ b/tsc/internal/diagnostics/diagnostics_generated.go
@@ -3922,6 +3922,16 @@ var Content_mapper_extension_0_must_not_contain_path_separators = &Message{code:
 
 var The_content_mapper_package_0_is_outside_the_open_workspace_and_will_not_be_loaded = &Message{code: 18124, category: CategoryError, key: "The_content_mapper_package_0_is_outside_the_open_workspace_and_will_not_be_loaded_18124", text: "The content mapper package '{0}' is outside the open workspace and will not be loaded."}
 
+var Content_mapper_0_must_specify_extensions_in_tsconfig_or_its_package_manifest = &Message{code: 18125, category: CategoryError, key: "Content_mapper_0_must_specify_extensions_in_tsconfig_or_its_package_manifest_18125", text: "Content mapper '{0}' must specify 'extensions' in tsconfig or its package manifest."}
+
+var Content_mapper_0_is_also_registered_for_the_extension_1_but_has_a_conflicting_outputExtensions_mapping_Each_registration_for_this_extension_must_produce_the_same_output_file_name = &Message{code: 18127, category: CategoryError, key: "Content_mapper_0_is_also_registered_for_the_extension_1_but_has_a_conflicting_outputExtensions_mappi_18127", text: "Content mapper '{0}' is also registered for the extension '{1}', but has a conflicting 'outputExtensions' mapping. Each registration for this extension must produce the same output file name."}
+
+var Content_mapper_0_is_also_registered_for_the_extension_1_but_has_no_outputExtensions_mapping_Each_registration_for_this_extension_must_produce_the_same_output_file_name = &Message{code: 18128, category: CategoryError, key: "Content_mapper_0_is_also_registered_for_the_extension_1_but_has_no_outputExtensions_mapping_Each_reg_18128", text: "Content mapper '{0}' is also registered for the extension '{1}', but has no 'outputExtensions' mapping. Each registration for this extension must produce the same output file name."}
+
+var The_conflicting_mapper_registration_is_declared_here = &Message{code: 18130, category: CategoryMessage, key: "The_conflicting_mapper_registration_is_declared_here_18130", text: "The conflicting mapper registration is declared here."}
+
+var The_conflicting_mapper_registration_is_declared_here_Its_outputExtensions_setting_is_inherited_from_the_mapper_s_package_json = &Message{code: 18131, category: CategoryMessage, key: "The_conflicting_mapper_registration_is_declared_here_Its_outputExtensions_setting_is_inherited_from__18131", text: "The conflicting mapper registration is declared here. Its 'outputExtensions' setting is inherited from the mapper's package.json."}
+
 var X_nodenext_if_module_is_nodenext_node16_if_module_is_node16_or_node18_otherwise_bundler = &Message{code: 69010, category: CategoryMessage, key: "nodenext_if_module_is_nodenext_node16_if_module_is_node16_or_node18_otherwise_bundler_69010", text: "`nodenext` if `module` is `nodenext`; `node16` if `module` is `node16` or `node18`; otherwise, `bundler`."}
 
 var File_is_a_CommonJS_module_it_may_be_converted_to_an_ES_module = &Message{code: 80001, category: CategorySuggestion, key: "File_is_a_CommonJS_module_it_may_be_converted_to_an_ES_module_80001", text: "File is a CommonJS module; it may be converted to an ES module."}
@@ -6423,6 +6433,11 @@ var allMessages = [...]**Message{
 	&The_typescript_contentMapper_outputExtensions_of_the_content_mapper_package_0_must_be_an_object_with_string_values,
 	&Content_mapper_extension_0_must_not_contain_path_separators,
 	&The_content_mapper_package_0_is_outside_the_open_workspace_and_will_not_be_loaded,
+	&Content_mapper_0_must_specify_extensions_in_tsconfig_or_its_package_manifest,
+	&Content_mapper_0_is_also_registered_for_the_extension_1_but_has_a_conflicting_outputExtensions_mapping_Each_registration_for_this_extension_must_produce_the_same_output_file_name,
+	&Content_mapper_0_is_also_registered_for_the_extension_1_but_has_no_outputExtensions_mapping_Each_registration_for_this_extension_must_produce_the_same_output_file_name,
+	&The_conflicting_mapper_registration_is_declared_here,
+	&The_conflicting_mapper_registration_is_declared_here_Its_outputExtensions_setting_is_inherited_from_the_mapper_s_package_json,
 	&X_nodenext_if_module_is_nodenext_node16_if_module_is_node16_or_node18_otherwise_bundler,
 	&File_is_a_CommonJS_module_it_may_be_converted_to_an_ES_module,
 	&This_constructor_function_may_be_converted_to_a_class_declaration,
diff --git a/tsc/internal/execute/tsctests/contentmapper_inclusion_test.go b/tsc/internal/execute/tsctests/contentmapper_inclusion_test.go
new file mode 100644
index 0000000000000..e668b8f3b9e6b
--- /dev/null
+++ b/tsc/internal/execute/tsctests/contentmapper_inclusion_test.go
@@ -0,0 +1,46 @@
+package tsctests
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTscContentMapperInclusion(t *testing.T) {
+	t.Parallel()
+	for _, rewrite := range []bool{false, true} {
+		input := &tscInput{
+			subScenario: "manifest extensions with a narrowing include and declaration fallback",
+			files: FileMap{
+				"/home/src/workspaces/project/tsconfig.json": `{
+				"compilerOptions": { "outDir": "./dist", "declaration": true, "module": "preserve", "allowArbitraryExtensions": true },
+				"contentMappers": [{ "package": "mapper", "include": ["**/blob.toml"] }]
+			}`,
+				"/home/src/workspaces/project/node_modules/mapper/package.json": `{
+				"name": "mapper", "version": "1.0.0",
+				"typescript": { "contentMapper": { "exec": ["verbatim-mapper"], "extensions": [".toml"] } }
+			}`,
+				"/home/src/workspaces/project/index.ts": `
+				export { value } from "./blob.toml";
+				export { other } from "./other.toml";
+				export { packaged } from "./node_modules/pkg/blob.toml";
+				export { ambient } from "./ambient.toml";
+				`,
+				"/home/src/workspaces/project/blob.toml":                  `export const value = 1;`,
+				"/home/src/workspaces/project/other.toml":                 `not TypeScript`,
+				"/home/src/workspaces/project/other.d.toml.ts":            `export declare const other: "declaration";`,
+				"/home/src/workspaces/project/ambient.toml":               `not TypeScript`,
+				"/home/src/workspaces/project/ambient.d.ts":               `declare module "*.toml" { export const ambient: string; }`,
+				"/home/src/workspaces/project/node_modules/pkg/blob.toml": `export const packaged = true;`,
+			},
+			commandLineArgs: []string{"--runExternalCode", "--listFiles"},
+		}
+		if rewrite {
+			input.subScenario = "filtered files rewrite but unclaimed imports keep their extension"
+			configPath := "/home/src/workspaces/project/tsconfig.json"
+			input.files[configPath] = strings.ReplaceAll(input.files[configPath].(string), `"declaration": true`, `"declaration": true, "rewriteRelativeImportExtensions": true`)
+			manifestPath := "/home/src/workspaces/project/node_modules/mapper/package.json"
+			input.files[manifestPath] = strings.ReplaceAll(input.files[manifestPath].(string), `"extensions": [".toml"]`, `"extensions": [".toml"], "outputExtensions": {".toml": ".js"}`)
+		}
+		input.run(t, "contentMapperInclusion")
+	}
+}
diff --git a/tsc/internal/fourslash/tests/contentMapperInclusion_test.go b/tsc/internal/fourslash/tests/contentMapperInclusion_test.go
new file mode 100644
index 0000000000000..c5aeb79b3c6b0
--- /dev/null
+++ b/tsc/internal/fourslash/tests/contentMapperInclusion_test.go
@@ -0,0 +1,57 @@
+package fourslash_test
+
+import (
+	"testing"
+
+	"github.com/microsoft/TypeScript/tsc/internal/core"
+	"github.com/microsoft/TypeScript/tsc/internal/fourslash"
+	. "github.com/microsoft/TypeScript/tsc/internal/fourslash/tests/util"
+	"github.com/microsoft/TypeScript/tsc/internal/testutil"
+	"github.com/microsoft/TypeScript/tsc/internal/testutil/contentmappertest"
+)
+
+func TestContentMapperInclusionCompletions(t *testing.T) {
+	t.Parallel()
+	for _, ambient := range []bool{false, true} {
+		t.Run(core.IfElse(ambient, "ambient fallback", "mapper only"), func(t *testing.T) {
+			t.Parallel()
+			defer testutil.RecoverAndFail(t, "Panic on fourslash test")
+			// The verbatim mapper exposes TypeScript unchanged with identity span mappings.
+			content := `// @Filename: /tsconfig.json
+{
+	"compilerOptions": {"module": "preserve"},
+	"contentMappers": [{"package": "mapper", "extensions": [".toml"], "include": ["blob.toml"]}]
+}
+// @Filename: /node_modules/mapper/package.json
+` + contentmappertest.PackageJSON(contentmappertest.VerbatimMapper) + `
+// @Filename: /blob.toml
+// @noOpen: true
+export const value = 1;
+// @Filename: /other.toml
+// @noOpen: true
+not TypeScript
+// @Filename: /main.ts
+import {} from "./[|/*path*/|]";
+`
+			if ambient {
+				// Unclaimed files can still be imported through a wildcard ambient module.
+				content += `// @Filename: /ambient.d.ts
+declare module "*.toml" {}
+`
+			}
+			f, done := fourslash.NewFourslashWithOptions(t, content, &fourslash.FourslashOptions{
+				ContentMapperSpawner: contentmappertest.NewSpawner(), RunExternalCode: true,
+			})
+			defer done()
+			f.VerifyCompletions(t, "path", &fourslash.CompletionsExpectedList{
+				ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{
+					CommitCharacters: &[]string{}, EditRange: Ignored,
+				},
+				Items: &fourslash.CompletionsExpectedItems{
+					Includes: append([]fourslash.CompletionsExpectedItem{"blob.toml"}, core.IfElse(ambient, []fourslash.CompletionsExpectedItem{"other.toml"}, nil)...),
+					Excludes: core.IfElse(ambient, nil, []string{"other.toml"}),
+				},
+			})
+		})
+	}
+}
diff --git a/tsc/internal/ls/autoimport/aliasresolver.go b/tsc/internal/ls/autoimport/aliasresolver.go
index e45dee48efbf1..3ac34d7d7e473 100644
--- a/tsc/internal/ls/autoimport/aliasresolver.go
+++ b/tsc/internal/ls/autoimport/aliasresolver.go
@@ -161,9 +161,8 @@ func (r *aliasResolver) CommonSourceDirectory() tspath.RootedDirectoryPath {
 	panic("unimplemented")
 }
 
-// ContentMapperExtensions implements checker.Program.
-func (r *aliasResolver) ContentMapperExtensions() []string {
-	return nil
+func (r *aliasResolver) ContentMapperExtensionForFileName(tspath.RootedFilePath) string {
+	return ""
 }
 
 func (r *aliasResolver) ContentMapperExtensionRewrites() []tspath.ExtensionRewrite {
diff --git a/tsc/internal/ls/sourcedefinition.go b/tsc/internal/ls/sourcedefinition.go
index 58eeda3b7b22e..677d249def544 100644
--- a/tsc/internal/ls/sourcedefinition.go
+++ b/tsc/internal/ls/sourcedefinition.go
@@ -169,10 +169,11 @@ func (l *LanguageService) newSourceDefResolver(
 		getSourceFile: program.GetSourceFile,
 		resolveFrom:   resolveFrom,
 		resolver: module.NewResolver(module.ResolverOptions{
-			Host:            &sourceDefResolutionHost{fs: program.Host().FS(), currentDirectory: program.BaseDirectory()},
-			CompilerOptions: noDtsOptions,
-			TypingsLocation: program.GetGlobalTypingsCacheLocation(),
-			ExtraExtensions: program.CommandLine().ContentMapperExtensions(),
+			Host:                     &sourceDefResolutionHost{fs: program.Host().FS(), currentDirectory: program.BaseDirectory()},
+			CompilerOptions:          noDtsOptions,
+			TypingsLocation:          program.GetGlobalTypingsCacheLocation(),
+			ExtraExtensions:          program.CommandLine().ContentMapperExtensions(),
+			ContentMapperFileMatcher: program.CommandLine().ContentMapperFileMatcher(),
 		}),
 	}
 }
diff --git a/tsc/internal/ls/string_completions.go b/tsc/internal/ls/string_completions.go
index c453bb239d3a5..d274ac93eae96 100644
--- a/tsc/internal/ls/string_completions.go
+++ b/tsc/internal/ls/string_completions.go
@@ -1041,9 +1041,9 @@ func (l *LanguageService) getExtensionOptions(
 	checker *checker.Checker,
 ) *extensionOptions {
 	extensionsToSearch := getSupportedExtensionsForModuleResolution(options, l.GetProgram().CommandLine().ContentMapperExtensions(), checker)
-
 	return &extensionOptions{
 		extensionsToSearch:  extensionsToSearch,
+		ambientExtensions:   getAmbientModuleExtensions(checker),
 		referenceKind:       referenceKind,
 		importingSourceFile: file,
 		endingPreference:    l.UserPreferences().ImportModuleSpecifierEnding,
@@ -1051,8 +1051,7 @@ func (l *LanguageService) getExtensionOptions(
 	}
 }
 
-func getSupportedExtensionsForModuleResolution(options *core.CompilerOptions, extraExtensions []string, checker *checker.Checker) []string {
-	/** file extensions from ambient modules declarations e.g. *.css */
+func getAmbientModuleExtensions(checker *checker.Checker) []string {
 	var extensions []string
 	if checker != nil {
 		ambientModules := checker.GetAmbientModules()
@@ -1064,6 +1063,11 @@ func getSupportedExtensionsForModuleResolution(options *core.CompilerOptions, ex
 			extensions = append(extensions, name[1:])
 		}
 	}
+	return extensions
+}
+
+func getSupportedExtensionsForModuleResolution(options *core.CompilerOptions, extraExtensions []string, checker *checker.Checker) []string {
+	extensions := getAmbientModuleExtensions(checker)
 	supportedExtensions := tsoptions.GetSupportedExtensions(options, extraExtensions)
 	for _, ext := range supportedExtensions {
 		extensions = append(extensions, ext...)
@@ -1238,12 +1242,18 @@ func (s *moduleCompletionNameAndKindSet) add(entry moduleCompletionNameAndKind)
 
 type extensionOptions struct {
 	extensionsToSearch  []string
+	ambientExtensions   []string
 	referenceKind       referenceKind
 	importingSourceFile *ast.SourceFile
 	endingPreference    modulespecifiers.ImportModuleSpecifierEndingPreference
 	resolutionMode      core.ResolutionMode
 }
 
+func (o *extensionOptions) shouldIncludeFile(fileName tspath.RootedFilePath, program *compiler.Program) bool {
+	return !program.CommandLine().ContentMapperFileMatcher().IsUnclaimed(fileName) ||
+		fileName.LongestExtension(o.ambientExtensions, program.CaseSensitivity()) != ""
+}
+
 type referenceKind int
 
 const (
@@ -1317,6 +1327,9 @@ func (l *LanguageService) getCompletionEntriesForDirectoryFragment(
 	)
 
 	for _, filePath := range files {
+		if !extensionOptions.shouldIncludeFile(filePath, program) {
+			continue
+		}
 		if exclude == program.PathKeyForFileName(filePath) {
 			continue // Avoid self-imports
 		}
@@ -1751,6 +1764,9 @@ func (l *LanguageService) getModulesForPathsPattern(
 
 		var result []moduleCompletionNameAndKind
 		for _, match := range matches {
+			if !extensionOptions.shouldIncludeFile(match, program) {
+				continue
+			}
 			trimmedWithPattern := trimPrefixAndSuffix(match.AsString(), completePrefix)
 			if trimmedWithPattern != "" {
 				if containsSlash(trimmedWithPattern) {
diff --git a/tsc/internal/lsp/lsproto/lsp_generated.go b/tsc/internal/lsp/lsproto/lsp_generated.go
index 9b2220387c7bb..bd805e7d711b3 100644
--- a/tsc/internal/lsp/lsproto/lsp_generated.go
+++ b/tsc/internal/lsp/lsproto/lsp_generated.go
@@ -9132,6 +9132,9 @@ type ContentMapperManifest struct {
 
 	// Default source-to-runtime output extension mappings.
 	OutputExtensions *map[string]string `json:"outputExtensions,omitzero"`
+
+	// Default source extensions handled by the mapper.
+	Extensions *[]string `json:"extensions,omitzero"`
 }
 
 var _ json.UnmarshalerFrom = (*ContentMapperManifest)(nil)
@@ -9161,7 +9164,7 @@ type ContentMapperContribution struct {
 	ContributorId string `json:"contributorId" lsp:"required"`
 
 	// File extensions handled by this content mapper.
-	Extensions []string `json:"extensions" lsp:"required"`
+	Extensions *[]string `json:"extensions,omitzero"`
 
 	// When present, contributes this mapper to inferred projects.
 	InferredProjectContribution *InferredProjectContentMapperContribution `json:"inferredProjectContribution,omitzero"`
diff --git a/tsc/internal/lsp/server.go b/tsc/internal/lsp/server.go
index dcb020b0ca1b7..4ffec6b1a9df6 100644
--- a/tsc/internal/lsp/server.go
+++ b/tsc/internal/lsp/server.go
@@ -206,7 +206,7 @@ type Server struct {
 	watcherID        atomic.Uint32
 	watchers         collections.SyncSet[project.WatcherID]
 
-	// contentMapperRegistrationMu serializes RegisterContentMapperExtensions so the method is correctly
+	// contentMapperRegistrationMu serializes RegisterContentMapperSelectors so the method is correctly
 	// synchronized on its own rather than relying on callers to serialize it. It guards
 	// contentMapperExtensionsRegistered and the ordered unregister/register requests the method sends.
 	contentMapperRegistrationMu sync.Mutex
@@ -452,11 +452,21 @@ func (s *Server) supportsContentMapperRegistration(id string) bool {
 	}
 }
 
-// RegisterContentMapperExtensions implements project.Client. It dynamically registers text document
-// synchronization and pull diagnostics for the given otherwise unsupported file extensions so the editor forwards their
-// open/change/close notifications to the server and requests diagnostics for them. It is called with the
-// full desired set each time it changes; an empty slice removes any prior registration.
-func (s *Server) RegisterContentMapperExtensions(ctx context.Context, extensions []string) error {
+func contentMapperDocumentPattern(selector project.ContentMapperSelector) lsproto.PatternOrRelativePattern {
+	if selector.Base == "" {
+		return lsproto.PatternOrRelativePattern{Pattern: new(selector.Pattern)}
+	}
+	baseURI := lsproto.URI(lsconv.FileNameToDocumentURI(tspath.RootedFilePathFromPath(selector.Base.AsPath())))
+	return lsproto.PatternOrRelativePattern{
+		RelativePattern: &lsproto.RelativePattern{
+			BaseUri: lsproto.WorkspaceFolderOrURI{URI: &baseURI},
+			Pattern: selector.Pattern,
+		},
+	}
+}
+
+// RegisterContentMapperSelectors replaces the client registrations; an empty slice removes them.
+func (s *Server) RegisterContentMapperSelectors(ctx context.Context, selectors []project.ContentMapperSelector) error {
 	if !s.clientCapabilities.TextDocument.Synchronization.DynamicRegistration {
 		return nil
 	}
@@ -504,25 +514,29 @@ func (s *Server) RegisterContentMapperExtensions(ctx context.Context, extensions
 		s.contentMapperExtensionsRegistered = false
 	}
 
-	if len(extensions) == 0 {
+	if len(selectors) == 0 {
 		return nil
 	}
 
-	filters := make([]lsproto.TextDocumentFilterLanguageOrSchemeOrPattern, 0, len(extensions))
-	for _, ext := range extensions {
+	filters := make([]lsproto.TextDocumentFilterLanguageOrSchemeOrPattern, 0, len(selectors))
+	for _, selector := range selectors {
 		filters = append(filters, lsproto.TextDocumentFilterLanguageOrSchemeOrPattern{
 			Pattern: &lsproto.TextDocumentFilterPattern{
-				Pattern: lsproto.PatternOrRelativePattern{Pattern: new("**/*" + ext)},
+				Pattern: contentMapperDocumentPattern(selector),
 			},
 		})
 	}
 	selector := lsproto.DocumentSelectorOrNull{DocumentSelector: &filters}
-	contentMapperFileRenameFilters := make([]*lsproto.FileOperationFilter, 0, len(extensions))
-	for _, extension := range extensions {
+	contentMapperFileRenameFilters := make([]*lsproto.FileOperationFilter, 0, len(selectors))
+	var seenExtensions collections.Set[string]
+	for _, selector := range selectors {
+		if !seenExtensions.AddIfAbsent(selector.Extension) {
+			continue
+		}
 		contentMapperFileRenameFilters = append(contentMapperFileRenameFilters, &lsproto.FileOperationFilter{
 			Scheme: new("file"),
 			Pattern: &lsproto.FileOperationPattern{
-				Glob: "**/*" + extension,
+				Glob: project.ContentMapperExtensionPattern(selector.Extension),
 			},
 		})
 	}
@@ -2559,8 +2573,12 @@ func parseContentMapperContributions(values []*lsproto.ContentMapperContribution
 			return result, errors.New("content mapper contribution requires a contributorId")
 		}
 		identity := fmt.Sprintf("%s[%d]", value.ContributorId, index)
-		validExtensions := make([]string, 0, len(value.Extensions))
-		for _, extension := range value.Extensions {
+		extensions := valueOrZero(value.Extensions)
+		if len(extensions) == 0 && value.InferredProjectContribution != nil && value.InferredProjectContribution.Manifest != nil {
+			extensions = valueOrZero(value.InferredProjectContribution.Manifest.Extensions)
+		}
+		validExtensions := make([]string, 0, len(extensions))
+		for _, extension := range extensions {
 			if !isValidContributedContentMapperExtension(extension) {
 				return result, fmt.Errorf("content mapper contribution %q has invalid extension %q", identity, extension)
 			}
@@ -2607,6 +2625,7 @@ func parseContentMapperContributions(values []*lsproto.ContentMapperContribution
 			DynamicConfig:   valueOrZero(manifest.DynamicConfig),
 			ContributionID:  identity,
 		}
+		mapper.Manifest.DefaultExtensions = slices.Clone(valueOrZero(manifest.Extensions))
 		mapper.Manifest.DefaultOutputExtensions = maps.Clone(valueOrZero(manifest.OutputExtensions))
 		mapper.Definition.OutputExtensions = maps.Clone(mapper.Manifest.DefaultOutputExtensions)
 		if manifest.Cwd != nil {
diff --git a/tsc/internal/lsp/server_contentmapper_internal_test.go b/tsc/internal/lsp/server_contentmapper_internal_test.go
index 6f3af6a07c41e..2392122e090ea 100644
--- a/tsc/internal/lsp/server_contentmapper_internal_test.go
+++ b/tsc/internal/lsp/server_contentmapper_internal_test.go
@@ -6,10 +6,34 @@ import (
 
 	"github.com/microsoft/TypeScript/tsc/internal/core"
 	"github.com/microsoft/TypeScript/tsc/internal/lsp/lsproto"
+	"github.com/microsoft/TypeScript/tsc/internal/project"
 	"github.com/microsoft/TypeScript/tsc/internal/tspath"
 	"gotest.tools/v3/assert"
 )
 
+func stringSlice(values ...string) *[]string { return &values }
+
+func TestContentMapperDocumentPattern(t *testing.T) {
+	t.Parallel()
+	for _, test := range []struct {
+		base             tspath.RootedDirectoryPath
+		baseURI, pattern string
+	}{
+		{"/project/local", "file:///project/local", "**/*.toml"},
+		{"c:/shared/src", "file:///c%3A/shared/src", "**/*.toml"},
+		{"/project", "file:///project", "file.toml"},
+		{"/", "file:///", "**/*.toml"},
+	} {
+		got := contentMapperDocumentPattern(project.ContentMapperSelector{Base: test.base, Pattern: test.pattern})
+		assert.Assert(t, got.Pattern == nil)
+		assert.Equal(t, string(*got.RelativePattern.BaseUri.URI), test.baseURI)
+		assert.Equal(t, got.RelativePattern.Pattern, test.pattern)
+	}
+	got := contentMapperDocumentPattern(project.ContentMapperSelector{Pattern: "**/*.toml"})
+	assert.Equal(t, *got.Pattern, "**/*.toml")
+	assert.Assert(t, got.RelativePattern == nil)
+}
+
 func TestContentMapperLoggerRequiresTrace(t *testing.T) {
 	t.Parallel()
 	var output strings.Builder
@@ -33,7 +57,7 @@ func TestParseContentMapperContributions(t *testing.T) {
 	contributions, err := parseContentMapperContributions([]*lsproto.ContentMapperContribution{
 		{
 			ContributorId: "publisher.extension",
-			Extensions:    []string{".vue"},
+			Extensions:    stringSlice(".vue"),
 			InferredProjectContribution: &lsproto.InferredProjectContentMapperContribution{
 				Options: &options,
 				Manifest: &lsproto.ContentMapperManifest{
@@ -42,13 +66,14 @@ func TestParseContentMapperContributions(t *testing.T) {
 					Exec:             []string{"node", "mapper.js"},
 					Cwd:              &cwd,
 					CompilerOptions:  &compilerOptions,
+					Extensions:       stringSlice(".toml"),
 					OutputExtensions: &outputExtensions,
 				},
 			},
 		},
 		{
 			ContributorId: "publisher.extension",
-			Extensions:    []string{".svelte"},
+			Extensions:    stringSlice(".svelte"),
 		},
 	})
 	assert.NilError(t, err)
@@ -57,6 +82,8 @@ func TestParseContentMapperContributions(t *testing.T) {
 	mapper := contributions.Mappers[0]
 	assert.Equal(t, mapper.Identity(), "publisher.extension[0] (Vue mapper@2.3.4)")
 	assert.Equal(t, mapper.PackageDirectory.AsString(), cwd)
+	assert.DeepEqual(t, mapper.Manifest.DefaultExtensions, []string{".toml"})
+	assert.DeepEqual(t, mapper.Definition.Extensions, []string{".vue"})
 	assert.DeepEqual(t, mapper.Manifest.DefaultOutputExtensions, map[string]string{".vue": ".js"})
 	assert.DeepEqual(t, mapper.Definition.OutputExtensions, map[string]string{".vue": ".js"})
 	outputExtensions[".vue"] = ".mjs"
@@ -72,8 +99,8 @@ func TestParseContentMapperContributionsRejectsConflictingInlineMappers(t *testi
 		return &lsproto.InferredProjectContentMapperContribution{Manifest: &lsproto.ContentMapperManifest{Name: name, Exec: []string{name}}}
 	}
 	_, err := parseContentMapperContributions([]*lsproto.ContentMapperContribution{
-		{ContributorId: "first", Extensions: []string{".vue"}, InferredProjectContribution: inferredProjectContribution("first")},
-		{ContributorId: "second", Extensions: []string{".vue"}, InferredProjectContribution: inferredProjectContribution("second")},
+		{ContributorId: "first", Extensions: stringSlice(".vue"), InferredProjectContribution: inferredProjectContribution("first")},
+		{ContributorId: "second", Extensions: stringSlice(".vue"), InferredProjectContribution: inferredProjectContribution("second")},
 	})
 	assert.ErrorContains(t, err, `both claim extension ".vue"`)
 }
@@ -84,14 +111,14 @@ func TestParseContentMapperContributionsUsesCaseInsensitiveExtensions(t *testing
 		return &lsproto.InferredProjectContentMapperContribution{Manifest: &lsproto.ContentMapperManifest{Name: name, Exec: []string{name}}}
 	}
 	_, err := parseContentMapperContributions([]*lsproto.ContentMapperContribution{
-		{ContributorId: "first", Extensions: []string{".vue"}, InferredProjectContribution: inferredProjectContribution("first")},
-		{ContributorId: "second", Extensions: []string{".VUE"}, InferredProjectContribution: inferredProjectContribution("second")},
+		{ContributorId: "first", Extensions: stringSlice(".vue"), InferredProjectContribution: inferredProjectContribution("first")},
+		{ContributorId: "second", Extensions: stringSlice(".VUE"), InferredProjectContribution: inferredProjectContribution("second")},
 	})
 	assert.ErrorContains(t, err, `both claim extension ".VUE"`)
 
 	_, err = parseContentMapperContributions([]*lsproto.ContentMapperContribution{{
 		ContributorId: "built-in",
-		Extensions:    []string{".TS"},
+		Extensions:    stringSlice(".TS"),
 	}})
 	assert.ErrorContains(t, err, `invalid extension ".TS"`)
 }
@@ -100,7 +127,7 @@ func TestParseContentMapperContributionsDefaultsOptionsToObject(t *testing.T) {
 	t.Parallel()
 	contributions, err := parseContentMapperContributions([]*lsproto.ContentMapperContribution{{
 		ContributorId: "publisher.extension",
-		Extensions:    []string{".vue"},
+		Extensions:    stringSlice(".vue"),
 		InferredProjectContribution: &lsproto.InferredProjectContentMapperContribution{
 			Manifest: &lsproto.ContentMapperManifest{Name: "mapper", Exec: []string{"mapper"}},
 		},
@@ -109,12 +136,28 @@ func TestParseContentMapperContributionsDefaultsOptionsToObject(t *testing.T) {
 	assert.Equal(t, string(contributions.Mappers[0].Definition.Options), `{}`)
 }
 
+func TestParseContentMapperContributionsUsesManifestExtensions(t *testing.T) {
+	t.Parallel()
+	contributions, err := parseContentMapperContributions([]*lsproto.ContentMapperContribution{{
+		ContributorId: "mapper",
+		InferredProjectContribution: &lsproto.InferredProjectContentMapperContribution{
+			Manifest: &lsproto.ContentMapperManifest{
+				Name: "mapper", Exec: []string{"mapper"}, Extensions: stringSlice(".toml"),
+			},
+		},
+	}})
+	assert.NilError(t, err)
+	assert.DeepEqual(t, contributions.Extensions, []string{".toml"})
+	assert.DeepEqual(t, contributions.Mappers[0].Definition.Extensions, []string{".toml"})
+	assert.DeepEqual(t, contributions.Mappers[0].Manifest.DefaultExtensions, []string{".toml"})
+}
+
 func TestParseContentMapperContributionsCompoundExtensions(t *testing.T) {
 	t.Parallel()
 	for _, extension := range []string{".y.z", ".component.tsx.vue"} {
 		contributions, err := parseContentMapperContributions([]*lsproto.ContentMapperContribution{{
 			ContributorId: "mapper",
-			Extensions:    []string{extension},
+			Extensions:    stringSlice(extension),
 			InferredProjectContribution: &lsproto.InferredProjectContentMapperContribution{
 				Manifest: &lsproto.ContentMapperManifest{Name: "mapper", Exec: []string{"mapper"}},
 			},
@@ -125,7 +168,7 @@ func TestParseContentMapperContributionsCompoundExtensions(t *testing.T) {
 	for _, nativeExtension := range core.Flatten(tspath.AllSupportedExtensionsWithJson) {
 		for _, extension := range []string{".component" + nativeExtension, ".component" + strings.ToUpper(nativeExtension)} {
 			_, err := parseContentMapperContributions([]*lsproto.ContentMapperContribution{{
-				ContributorId: "mapper", Extensions: []string{extension},
+				ContributorId: "mapper", Extensions: stringSlice(extension),
 			}})
 			assert.ErrorContains(t, err, "invalid extension")
 		}
@@ -138,7 +181,7 @@ func TestParseContentMapperContributionsRejectsInvalidOutputExtensions(t *testin
 		outputExtensions := map[string]string{".vue": "js"}
 		_, err := parseContentMapperContributions([]*lsproto.ContentMapperContribution{{
 			ContributorId: "publisher.extension",
-			Extensions:    []string{".vue"},
+			Extensions:    stringSlice(".vue"),
 			InferredProjectContribution: &lsproto.InferredProjectContentMapperContribution{
 				Manifest: &lsproto.ContentMapperManifest{
 					Name: "mapper", Exec: []string{"mapper"},
@@ -154,12 +197,12 @@ func TestParseContentMapperContributionsRejectsExtensionPaths(t *testing.T) {
 	t.Parallel()
 	for _, extension := range []string{".vue/foo", `.vue\foo`} {
 		_, err := parseContentMapperContributions([]*lsproto.ContentMapperContribution{{
-			ContributorId: "mapper", Extensions: []string{extension},
+			ContributorId: "mapper", Extensions: stringSlice(extension),
 		}})
 		assert.ErrorContains(t, err, "invalid extension")
 		for _, outputExtensions := range []map[string]string{{extension: ".js"}, {".vue": extension}} {
 			_, err := parseContentMapperContributions([]*lsproto.ContentMapperContribution{{
-				ContributorId: "mapper", Extensions: []string{".vue"},
+				ContributorId: "mapper", Extensions: stringSlice(".vue"),
 				InferredProjectContribution: &lsproto.InferredProjectContentMapperContribution{
 					Manifest: &lsproto.ContentMapperManifest{Name: "mapper", Exec: []string{"mapper"}, OutputExtensions: &outputExtensions},
 				},
diff --git a/tsc/internal/lsp/server_contentmapper_test.go b/tsc/internal/lsp/server_contentmapper_test.go
index 2a8595d1c8da5..f0061435ec78d 100644
--- a/tsc/internal/lsp/server_contentmapper_test.go
+++ b/tsc/internal/lsp/server_contentmapper_test.go
@@ -17,6 +17,8 @@ import (
 	"gotest.tools/v3/assert"
 )
 
+func stringSlice(values ...string) *[]string { return &values }
+
 func TestSetContentMapperContributionsBeforeDidOpen(t *testing.T) {
 	t.Parallel()
 	if !bundled.Embedded {
@@ -31,7 +33,7 @@ export const title = "Profile";
 	files := map[string]string{
 		"/home/project/tsconfig.json": `{
 			"compilerOptions": { "target": "es2020", "module": "esnext", "moduleResolution": "bundler", "strict": true },
-			"contentMappers": [ { "package": "mapper", "extensions": [".vue"] } ]
+			"contentMappers": [ { "package": "mapper", "extensions": [".vue"], "include": ["*.vue"] } ]
 		}`,
 		"/home/project/node_modules/mapper/package.json": contentmappertest.PackageJSON(contentmappertest.ComponentMapper),
 		"/home/project/ProfileCard.vue":                  component,
@@ -122,7 +124,7 @@ export const title = "Profile";
 		OpenDocuments: []lsproto.TextDocumentIdentifier{{Uri: uri}},
 		Contributions: []*lsproto.ContentMapperContribution{{
 			ContributorId: "test",
-			Extensions:    []string{".vue", ".svelte"},
+			Extensions:    stringSlice(".vue", ".svelte"),
 		}},
 	})
 	assert.Assert(t, ok && msg.AsResponse().Error == nil)
@@ -159,18 +161,30 @@ export const title = "Profile";
 			assert.Assert(t, registration.RegisterOptions != nil && registration.RegisterOptions.TextDocumentDidOpen != nil)
 			selector := registration.RegisterOptions.TextDocumentDidOpen.DocumentSelector.DocumentSelector
 			assert.Assert(t, selector != nil && len(*selector) == 1)
-			assert.Equal(t, *(*selector)[0].Pattern.Pattern.Pattern, "**/*.vue")
+			pattern := (*selector)[0].Pattern.Pattern.RelativePattern
+			assert.Assert(t, pattern != nil)
+			assert.Equal(t, string(*pattern.BaseUri.URI), "file:///home/project")
+			assert.Equal(t, pattern.Pattern, "*.vue")
 		}
 		if registration.Id == "content-mapper-semantic-tokens" {
 			assert.Assert(t, registration.RegisterOptions != nil && registration.RegisterOptions.TextDocumentSemanticTokens != nil)
 			selector := registration.RegisterOptions.TextDocumentSemanticTokens.DocumentSelector.DocumentSelector
 			assert.Assert(t, selector != nil && len(*selector) == 1)
-			assert.Equal(t, *(*selector)[0].Pattern.Pattern.Pattern, "**/*.vue")
+			pattern := (*selector)[0].Pattern.Pattern.RelativePattern
+			assert.Assert(t, pattern != nil)
+			assert.Equal(t, string(*pattern.BaseUri.URI), "file:///home/project")
+			assert.Equal(t, pattern.Pattern, "*.vue")
 		}
 		if registration.Id == "content-mapper-code-action" {
 			assert.Assert(t, registration.RegisterOptions != nil && registration.RegisterOptions.TextDocumentCodeAction != nil)
 			assert.DeepEqual(t, *registration.RegisterOptions.TextDocumentCodeAction.CodeActionKinds, expectedCodeActionKinds())
 		}
+		if registration.Id == "content-mapper-will-rename-files" {
+			// Rename filters deliberately cover the whole extension, even for narrowed selectors.
+			filters := registration.RegisterOptions.WorkspaceWillRenameFiles.Filters
+			assert.Equal(t, len(filters), 1)
+			assert.Equal(t, filters[0].Pattern.Glob, "**/*.vue")
+		}
 	}
 	for id, found := range expectedMapperRegistrations {
 		assert.Assert(t, found, "expected %s registration for .vue", id)
diff --git a/tsc/internal/module/cache.go b/tsc/internal/module/cache.go
index 9294e0e879bf1..4149917abe330 100644
--- a/tsc/internal/module/cache.go
+++ b/tsc/internal/module/cache.go
@@ -2,6 +2,7 @@ package module
 
 import (
 	"github.com/microsoft/TypeScript/tsc/internal/collections"
+	"github.com/microsoft/TypeScript/tsc/internal/contentmapper"
 	"github.com/microsoft/TypeScript/tsc/internal/core"
 	"github.com/microsoft/TypeScript/tsc/internal/packagejson"
 	"github.com/microsoft/TypeScript/tsc/internal/tspath"
@@ -61,21 +62,23 @@ func (c *parsedPatternsCache) Get(pathMappings *collections.OrderedMap[string, [
 }
 
 type ResolutionData struct {
-	compilerOptions *core.CompilerOptions
-	typingsLocation tspath.RootedDirectoryPath
-	projectName     string
-	extraExtensions []string
+	compilerOptions          *core.CompilerOptions
+	typingsLocation          tspath.RootedDirectoryPath
+	projectName              string
+	extraExtensions          []string
+	contentMapperFileMatcher *contentmapper.FileMatcher
 
 	packageJsonInfoCache *packagejson.InfoCache
 }
 
 func newResolutionData(opts ResolverOptions) *ResolutionData {
 	data := &ResolutionData{
-		compilerOptions:      opts.CompilerOptions,
-		typingsLocation:      opts.TypingsLocation,
-		projectName:          opts.ProjectName,
-		extraExtensions:      opts.ExtraExtensions,
-		packageJsonInfoCache: opts.PackageJsonCache,
+		compilerOptions:          opts.CompilerOptions,
+		typingsLocation:          opts.TypingsLocation,
+		projectName:              opts.ProjectName,
+		extraExtensions:          opts.ExtraExtensions,
+		contentMapperFileMatcher: opts.ContentMapperFileMatcher,
+		packageJsonInfoCache:     opts.PackageJsonCache,
 	}
 	if data.packageJsonInfoCache == nil {
 		data.packageJsonInfoCache = packagejson.NewInfoCache(opts.Host.FS().CaseSensitivity())
@@ -86,11 +89,12 @@ func newResolutionData(opts ResolverOptions) *ResolutionData {
 // Clone copies the package-json cache table without copying its entries.
 func (c *ResolutionData) Clone() *ResolutionData {
 	return &ResolutionData{
-		compilerOptions:      c.compilerOptions,
-		typingsLocation:      c.typingsLocation,
-		projectName:          c.projectName,
-		extraExtensions:      c.extraExtensions,
-		packageJsonInfoCache: c.packageJsonInfoCache.Clone(),
+		compilerOptions:          c.compilerOptions,
+		typingsLocation:          c.typingsLocation,
+		projectName:              c.projectName,
+		extraExtensions:          c.extraExtensions,
+		contentMapperFileMatcher: c.contentMapperFileMatcher,
+		packageJsonInfoCache:     c.packageJsonInfoCache.Clone(),
 	}
 }
 
diff --git a/tsc/internal/module/resolver.go b/tsc/internal/module/resolver.go
index 4b59f0582f927..8db72076ca57b 100644
--- a/tsc/internal/module/resolver.go
+++ b/tsc/internal/module/resolver.go
@@ -8,6 +8,7 @@ import (
 
 	"github.com/microsoft/TypeScript/tsc/internal/ast"
 	"github.com/microsoft/TypeScript/tsc/internal/collections"
+	"github.com/microsoft/TypeScript/tsc/internal/contentmapper"
 	"github.com/microsoft/TypeScript/tsc/internal/core"
 	"github.com/microsoft/TypeScript/tsc/internal/diagnostics"
 	"github.com/microsoft/TypeScript/tsc/internal/packagejson"
@@ -348,12 +349,13 @@ type DefaultResolver struct {
 }
 
 type ResolverOptions struct {
-	Host             ResolutionHost
-	CompilerOptions  *core.CompilerOptions
-	TypingsLocation  tspath.RootedDirectoryPath
-	ProjectName      string
-	ExtraExtensions  []string
-	PackageJsonCache *packagejson.InfoCache
+	Host                     ResolutionHost
+	CompilerOptions          *core.CompilerOptions
+	TypingsLocation          tspath.RootedDirectoryPath
+	ProjectName              string
+	ExtraExtensions          []string
+	ContentMapperFileMatcher *contentmapper.FileMatcher
+	PackageJsonCache         *packagejson.InfoCache
 }
 
 func (r *DefaultResolver) BaseDirectory() tspath.RootedDirectoryPath {
@@ -1642,13 +1644,33 @@ func (r *resolutionState) loadModuleFromFileNoImplicitExtensions(extensions exte
 	if !strings.Contains(base, ".") {
 		return continueSearching() // extensionless import, no lookups performed, since we don't support extensionless files
 	}
-	extensionless, extension := candidate.SplitExtension(r.resolver.extraExtensions)
+	extraExtensions := r.resolver.extraExtensions
+	if matcher := r.resolver.contentMapperFileMatcher; matcher != nil {
+		extraExtensions = nil
+		if extension := r.contentMapperExtensionForFileName(tspath.RootedFilePathFromPath(candidate.path)); extension != "" {
+			extraExtensions = []string{extension}
+		}
+	}
+	extensionless, extension := candidate.SplitExtension(extraExtensions)
 	if r.tracer != nil {
 		r.tracer.write(diagnostics.File_name_0_has_a_1_extension_stripping_it, candidate, extension)
 	}
 	return r.tryAddingExtensions(extensionless, candidate.Directory(), extensions, extension)
 }
 
+func (r *resolutionState) contentMapperExtensionForFileName(fileName tspath.RootedFilePath) string {
+	if fileName.LongestExtension(r.resolver.extraExtensions, r.resolver.fs.CaseSensitivity()) == "" {
+		return ""
+	}
+	// Match the path that createResolvedModuleHandlingSymlink will load.
+	if !r.compilerOptions.PreserveSymlinks.IsTrue() &&
+		!tspath.IsExternalModuleNameRelative(r.name) &&
+		fileName.ContainsLowercaseDirectorySequence("/node_modules/") {
+		fileName = r.realPath(fileName)
+	}
+	return r.resolver.contentMapperFileMatcher.ExtensionForFileName(fileName)
+}
+
 func (r *resolutionState) tryAddingExtensions(extensionless tspath.FileNameStem, directory tspath.RootedDirectoryPath, extensions extensions, originalExtension string) *resolved {
 	if directory != "" && !r.resolver.fs.DirectoryExists(directory) {
 		return continueSearching()
@@ -1756,7 +1778,12 @@ func (r *resolutionState) tryAddingExtensions(extensionless tspath.FileNameStem,
 		}
 		return continueSearching()
 	default:
-		if slices.Contains(r.resolver.extraExtensions, originalExtension) {
+		fileName := extensionless.AppendSuffix(originalExtension)
+		isExtraExtension := slices.Contains(r.resolver.extraExtensions, originalExtension)
+		if matcher := r.resolver.contentMapperFileMatcher; matcher != nil {
+			isExtraExtension = r.contentMapperExtensionForFileName(fileName) == originalExtension
+		}
+		if isExtraExtension {
 			// A fully specified import of an extraExtension resolves directly to the file.
 			if resolved := r.tryExtension(originalExtension, extensionless, false); !resolved.shouldContinueSearching() {
 				resolved.resolvedUsingExtraExtensions = true
diff --git a/tsc/internal/module/resolver_test.go b/tsc/internal/module/resolver_test.go
index c33f46144aeb6..9e8b0641c927d 100644
--- a/tsc/internal/module/resolver_test.go
+++ b/tsc/internal/module/resolver_test.go
@@ -9,6 +9,7 @@ import (
 
 	"github.com/microsoft/TypeScript/tsc/internal/ast"
 	"github.com/microsoft/TypeScript/tsc/internal/collections"
+	"github.com/microsoft/TypeScript/tsc/internal/contentmapper"
 	"github.com/microsoft/TypeScript/tsc/internal/core"
 	"github.com/microsoft/TypeScript/tsc/internal/packagejson"
 	"github.com/microsoft/TypeScript/tsc/internal/testutil"
@@ -35,6 +36,43 @@ type caseInsensitiveViewFS struct {
 	vfs.FS
 }
 
+func TestContentMapperFileMatching(t *testing.T) {
+	t.Parallel()
+	for _, sensitivity := range []tspath.CaseSensitivity{tspath.CaseSensitive, tspath.CaseInsensitive} {
+		t.Run(sensitivity.String(), func(t *testing.T) {
+			t.Parallel()
+			fs := vfstest.FromMap(map[string]string{
+				"/project/blob.toml":       "",
+				"/project/other.toml":      "",
+				"/project/other.d.toml.ts": "",
+				"/project/not-mapped.toml": "",
+			}, sensitivity)
+			matcher := contentmapper.NewFileMatcher([]*contentmapper.Mapper{
+				{Extensions: []string{".toml"}, Include: []string{"blob.toml"}},
+			}, "/project", sensitivity)
+			host := &resolutionTestInputs{fs: fs, cwd: "/project"}
+			resolver := NewResolver(ResolverOptions{
+				Host:            host,
+				CompilerOptions: &core.CompilerOptions{ModuleResolution: core.ModuleResolutionKindBundler},
+				ExtraExtensions: []string{".toml"}, ContentMapperFileMatcher: matcher,
+			})
+			for _, rebound := range []*DefaultResolver{resolver, resolver.GetResolutionData().Clone().NewResolver(host)} {
+				mapped, _, err := rebound.ResolveModuleName("./blob.toml", "/project/main.ts", core.ModuleKindESNext, nil)
+				assert.NilError(t, err)
+				assert.Equal(t, mapped.ResolvedFileName, tspath.RootedFilePath("/project/blob.toml"))
+				assert.Assert(t, mapped.ResolvedUsingExtraExtensions)
+				declaration, _, err := rebound.ResolveModuleName("./other.toml", "/project/main.ts", core.ModuleKindESNext, nil)
+				assert.NilError(t, err)
+				assert.Equal(t, declaration.ResolvedFileName, tspath.RootedFilePath("/project/other.d.toml.ts"))
+				assert.Assert(t, !declaration.ResolvedUsingExtraExtensions)
+				missing, _, err := rebound.ResolveModuleName("./not-mapped.toml", "/project/main.ts", core.ModuleKindESNext, nil)
+				assert.NilError(t, err)
+				assert.Assert(t, !missing.IsResolved())
+			}
+		})
+	}
+}
+
 func (caseInsensitiveViewFS) CaseSensitivity() tspath.CaseSensitivity {
 	return tspath.CaseInsensitive
 }
diff --git a/tsc/internal/modulespecifiers/specifiers_test.go b/tsc/internal/modulespecifiers/specifiers_test.go
index 920ca2c3c71dc..90050e49931e0 100644
--- a/tsc/internal/modulespecifiers/specifiers_test.go
+++ b/tsc/internal/modulespecifiers/specifiers_test.go
@@ -128,8 +128,8 @@ func (h *mockModuleSpecifierGenerationHost) CommonSourceDirectory() tspath.Roote
 	return h.currentDir
 }
 
-func (h *mockModuleSpecifierGenerationHost) ContentMapperExtensions() []string {
-	return h.contentMapperExtensions
+func (h *mockModuleSpecifierGenerationHost) ContentMapperExtensionForFileName(fileName tspath.RootedFilePath) string {
+	return fileName.LongestExtension(h.contentMapperExtensions, h.CaseSensitivity())
 }
 
 func (h *mockModuleSpecifierGenerationHost) ContentMapperExtensionRewrites() []tspath.ExtensionRewrite {
diff --git a/tsc/internal/modulespecifiers/types.go b/tsc/internal/modulespecifiers/types.go
index 20377ea5a7bf1..e3b0964c58a4d 100644
--- a/tsc/internal/modulespecifiers/types.go
+++ b/tsc/internal/modulespecifiers/types.go
@@ -50,7 +50,7 @@ type ModuleSpecifierGenerationHost interface {
 	GetSymlinkCache() *symlinks.KnownSymlinks
 	// GetFileIncludeReasons() any // !!! TODO: adapt new resolution cache model
 	CommonSourceDirectory() tspath.RootedDirectoryPath
-	ContentMapperExtensions() []string
+	ContentMapperExtensionForFileName(fileName tspath.RootedFilePath) string
 	ContentMapperExtensionRewrites() []tspath.ExtensionRewrite
 	GetGlobalTypingsCacheLocation() tspath.RootedDirectoryPath
 	CaseSensitivity() tspath.CaseSensitivity
diff --git a/tsc/internal/outputpaths/outputpaths.go b/tsc/internal/outputpaths/outputpaths.go
index a68837c1c36bb..a47efe2d156f4 100644
--- a/tsc/internal/outputpaths/outputpaths.go
+++ b/tsc/internal/outputpaths/outputpaths.go
@@ -2,13 +2,14 @@ package outputpaths
 
 import (
 	"github.com/microsoft/TypeScript/tsc/internal/ast"
+	"github.com/microsoft/TypeScript/tsc/internal/contentmapper"
 	"github.com/microsoft/TypeScript/tsc/internal/core"
 	"github.com/microsoft/TypeScript/tsc/internal/tspath"
 )
 
 type OutputPathsHost interface {
 	CommonSourceDirectory() tspath.RootedDirectoryPath
-	ContentMapperExtensions() []string
+	ContentMapperExtensionForFileName(fileName tspath.RootedFilePath) string
 	ContentMapperExtensionRewrites() []tspath.ExtensionRewrite
 	CaseSensitivity() tspath.CaseSensitivity
 }
@@ -116,7 +117,7 @@ func GetOutputJSFileName(inputFileName tspath.RootedFilePath, options *core.Comp
 }
 
 func isContentMappedFileName(fileName tspath.RootedFilePath, host OutputPathsHost) bool {
-	return fileName.LongestExtension(host.ContentMapperExtensions(), host.CaseSensitivity()) != ""
+	return host.ContentMapperExtensionForFileName(fileName) != ""
 }
 
 func GetOutputJSFileNameWorker(inputFileName tspath.RootedFilePath, options *core.CompilerOptions, host OutputPathsHost) tspath.RootedFilePath {
@@ -130,12 +131,16 @@ func GetOutputDeclarationFileNameWorker(inputFileName tspath.RootedFilePath, opt
 		dir = options.OutDir
 	}
 	path := getOutputFileNameWithoutChangingExtension(inputFileName, dir, host)
-	return ChangeToDeclarationExtension(path, host)
+	return changeToDeclarationExtensionForSource(path, inputFileName, host)
 }
 
 func GetExternalOutputFileName(inputFileName tspath.RootedFilePath, options *core.CompilerOptions, host OutputPathsHost) tspath.RootedFilePath {
+	extension := host.ContentMapperExtensionForFileName(inputFileName)
+	if extension == "" {
+		return ""
+	}
 	outputPath := getOutputFileNameWithoutChangingExtension(inputFileName, options.OutDir, host)
-	rewritten, ok := outputPath.RewriteExtension(host.ContentMapperExtensionRewrites(), host.CaseSensitivity())
+	rewritten, ok := rewriteContentMapperExtension(outputPath, extension, host)
 	if !ok {
 		return ""
 	}
@@ -170,13 +175,14 @@ func getDeclarationEmitOutputFilePathForFileName(file tspath.RootedFilePath, opt
 	}
 
 	if outputDir != "" {
-		return ChangeToDeclarationExtension(
+		return changeToDeclarationExtensionForSource(
 			GetSourceFileNameInNewDir(
 				file,
 				outputDir,
 				host.CommonSourceDirectory(),
 				host.CaseSensitivity(),
 			),
+			file,
 			host,
 		)
 	}
@@ -184,13 +190,23 @@ func getDeclarationEmitOutputFilePathForFileName(file tspath.RootedFilePath, opt
 }
 
 func ChangeToDeclarationExtension(path tspath.RootedFilePath, host OutputPathsHost) tspath.RootedFilePath {
-	if rewritten, ok := path.RewriteExtension(host.ContentMapperExtensionRewrites(), host.CaseSensitivity()); ok {
-		return changeToDeclarationExtension(rewritten)
+	return changeToDeclarationExtensionForSource(path, path, host)
+}
+
+func rewriteContentMapperExtension(path tspath.RootedFilePath, extension string, host OutputPathsHost) (tspath.RootedFilePath, bool) {
+	rewrites := contentmapper.FilterExtensionRewrites(host.ContentMapperExtensionRewrites(), extension, host.CaseSensitivity())
+	return path.RewriteExtension(rewrites, host.CaseSensitivity())
+}
+
+func changeToDeclarationExtensionForSource(path, source tspath.RootedFilePath, host OutputPathsHost) tspath.RootedFilePath {
+	extension := host.ContentMapperExtensionForFileName(source)
+	if extension == "" {
+		return changeToDeclarationExtension(path)
 	}
-	if extension := path.LongestExtension(host.ContentMapperExtensions(), tspath.CaseSensitive); extension != "" {
-		return path.RemoveExtension(extension).AppendSuffix(".d" + extension + ".ts")
+	if rewritten, ok := rewriteContentMapperExtension(path, extension, host); ok {
+		return changeToDeclarationExtension(rewritten)
 	}
-	return changeToDeclarationExtension(path)
+	return path.RemoveExtension(extension).AppendSuffix(".d" + extension + ".ts")
 }
 
 func changeToDeclarationExtension(path tspath.RootedFilePath) tspath.RootedFilePath {
diff --git a/tsc/internal/outputpaths/outputpaths_test.go b/tsc/internal/outputpaths/outputpaths_test.go
index 00f823d4b3b7d..62dc9aac1d4df 100644
--- a/tsc/internal/outputpaths/outputpaths_test.go
+++ b/tsc/internal/outputpaths/outputpaths_test.go
@@ -19,8 +19,8 @@ func (h outputPathsHost) CommonSourceDirectory() tspath.RootedDirectoryPath {
 	return h.commonSourceDirectory
 }
 
-func (h outputPathsHost) ContentMapperExtensions() []string {
-	return h.contentMapperExtensions
+func (h outputPathsHost) ContentMapperExtensionForFileName(fileName tspath.RootedFilePath) string {
+	return fileName.LongestExtension(h.contentMapperExtensions, h.CaseSensitivity())
 }
 
 func (h outputPathsHost) ContentMapperExtensionRewrites() []tspath.ExtensionRewrite {
diff --git a/tsc/internal/packagejson/packagejson.go b/tsc/internal/packagejson/packagejson.go
index 5251e8764611b..bb68004e15a23 100644
--- a/tsc/internal/packagejson/packagejson.go
+++ b/tsc/internal/packagejson/packagejson.go
@@ -115,6 +115,7 @@ type Fields struct {
 }
 
 type ContentMapperFields struct {
+	Extensions       Expected[[]string]          `json:"extensions"`
 	Exec             Expected[[]string]          `json:"exec"`
 	CompilerOptions  Expected[[]string]          `json:"compilerOptions"`
 	DynamicConfig    Expected[bool]              `json:"dynamicConfig"`
diff --git a/tsc/internal/printer/emithost.go b/tsc/internal/printer/emithost.go
index 827707eb6f74b..575971444bf1f 100644
--- a/tsc/internal/printer/emithost.go
+++ b/tsc/internal/printer/emithost.go
@@ -12,6 +12,7 @@ type EmitHost interface {
 	Options() *core.CompilerOptions
 	SourceFiles() []*ast.SourceFile
 	ContentMapperExtensionRewrites() []tspath.ExtensionRewrite
+	ContentMapperExtensionForFileName(fileName tspath.RootedFilePath) string
 	CaseSensitivity() tspath.CaseSensitivity
 	CommonSourceDirectory() tspath.RootedDirectoryPath
 	IsEmitBlocked(file tspath.RootedFilePath) bool
diff --git a/tsc/internal/project/client.go b/tsc/internal/project/client.go
index 1a7c9ae9c5b24..9bac54417f51f 100644
--- a/tsc/internal/project/client.go
+++ b/tsc/internal/project/client.go
@@ -1,17 +1,19 @@
 package project
 
 import (
+	"cmp"
 	"context"
 
 	"github.com/microsoft/TypeScript/tsc/internal/diagnostics"
 	"github.com/microsoft/TypeScript/tsc/internal/locale"
 	"github.com/microsoft/TypeScript/tsc/internal/lsp/lsproto"
+	"github.com/microsoft/TypeScript/tsc/internal/tspath"
 )
 
 type Client interface {
 	WatchFiles(ctx context.Context, id WatcherID, watchers []*lsproto.FileSystemWatcher) error
 	UnwatchFiles(ctx context.Context, id WatcherID) error
-	RegisterContentMapperExtensions(ctx context.Context, extensions []string) error
+	RegisterContentMapperSelectors(ctx context.Context, selectors []ContentMapperSelector) error
 	RefreshDiagnostics(ctx context.Context) error
 	PublishDiagnostics(ctx context.Context, params *lsproto.PublishDiagnosticsParams) error
 	RefreshInlayHints(ctx context.Context) error
@@ -25,3 +27,17 @@ type Client interface {
 	// GetLocale returns the current display locale for diagnostic messages.
 	GetLocale() locale.Locale
 }
+
+type ContentMapperSelector struct {
+	Base      tspath.RootedDirectoryPath // Empty for workspace-independent patterns.
+	Pattern   string
+	Extension string // Used for conservative file-operation filters.
+}
+
+func ContentMapperExtensionPattern(extension string) string {
+	return "**/*" + extension
+}
+
+func compareContentMapperSelectors(a, b ContentMapperSelector) int {
+	return cmp.Or(cmp.Compare(a.Base, b.Base), cmp.Compare(a.Pattern, b.Pattern), cmp.Compare(a.Extension, b.Extension))
+}
diff --git a/tsc/internal/project/configfileregistry.go b/tsc/internal/project/configfileregistry.go
index 1cb200b939ae3..318f5ba095032 100644
--- a/tsc/internal/project/configfileregistry.go
+++ b/tsc/internal/project/configfileregistry.go
@@ -4,12 +4,14 @@ import (
 	"iter"
 	"maps"
 	"slices"
+	"strings"
 
 	"github.com/microsoft/TypeScript/tsc/internal/collections"
 	"github.com/microsoft/TypeScript/tsc/internal/core"
 	"github.com/microsoft/TypeScript/tsc/internal/lsp/lsproto"
 	"github.com/microsoft/TypeScript/tsc/internal/tsoptions"
 	"github.com/microsoft/TypeScript/tsc/internal/tspath"
+	"github.com/microsoft/TypeScript/tsc/internal/vfs/vfsmatch"
 )
 
 type ConfigFileRegistry struct {
@@ -27,11 +29,50 @@ type ConfigFileRegistry struct {
 
 type configuredContentMappers struct {
 	extensions []string
+	selectors  []ContentMapperSelector
+}
+
+func contentMapperSelectorPattern(include, extension string) (string, bool) {
+	pattern := tspath.NormalizeSlashes(include)
+	if vfsmatch.IsImplicitGlob(tspath.GetBaseFileName(pattern)) {
+		pattern += "/**/*"
+	}
+	lowerPattern := strings.ToLower(pattern)
+	lowerExtension := strings.ToLower(extension)
+	if strings.HasSuffix(lowerPattern, lowerExtension) {
+		return pattern, true
+	}
+	if !strings.ContainsAny(pattern, "*?") {
+		return "", false
+	}
+	if strings.HasSuffix(pattern, "*") {
+		// Appending can miss matches for extension-like patterns such as "*.v*".
+		// Broader selectors are safe because the server rechecks claims.
+		last := tspath.GetBaseFileName(pattern)
+		if !strings.Contains(last[:len(last)-1], ".") {
+			return pattern + extension, true
+		}
+	}
+	return pattern, true
+}
+
+func contentMapperSelector(base tspath.RootedDirectoryPath, pattern, extension string) ContentMapperSelector {
+	prefix := pattern
+	if wildcard := strings.IndexAny(pattern, "*?"); wildcard >= 0 {
+		prefix = pattern[:wildcard]
+	}
+	baseLength := max(tspath.GetRootLength(pattern), strings.LastIndex(prefix, "/"))
+	if baseLength > 0 {
+		base = base.ResolveDirectory(pattern[:baseLength])
+		pattern = strings.TrimPrefix(pattern[baseLength:], "/")
+	}
+	return ContentMapperSelector{Base: base, Pattern: pattern, Extension: extension}
 }
 
 func collectConfiguredContentMappers(commandLines []*tsoptions.ParsedCommandLine) *configuredContentMappers {
 	var seenExtensions collections.Set[string]
 	var extensions []string
+	var selectors []ContentMapperSelector
 	for _, commandLine := range commandLines {
 		for _, mapper := range commandLine.ContentMappers() {
 			for _, extension := range mapper.Definition.Extensions {
@@ -39,10 +80,24 @@ func collectConfiguredContentMappers(commandLines []*tsoptions.ParsedCommandLine
 					extensions = append(extensions, extension)
 				}
 			}
+			for _, include := range mapper.Definition.Include {
+				for _, extension := range mapper.Definition.Extensions {
+					if pattern, ok := contentMapperSelectorPattern(include, extension); ok {
+						selectors = append(selectors, contentMapperSelector(commandLine.BaseDirectory(), pattern, extension))
+					}
+				}
+			}
+
+			if mapper.Definition.Include == nil {
+				for _, extension := range mapper.Definition.Extensions {
+					selectors = append(selectors, ContentMapperSelector{Pattern: ContentMapperExtensionPattern(extension), Extension: extension})
+				}
+			}
 		}
 	}
 	slices.Sort(extensions)
-	return &configuredContentMappers{extensions: extensions}
+	slices.SortFunc(selectors, compareContentMapperSelectors)
+	return &configuredContentMappers{extensions: extensions, selectors: selectors}
 }
 
 func (c *ConfigFileRegistry) contentMappers() *configuredContentMappers {
diff --git a/tsc/internal/project/configfileregistry_test.go b/tsc/internal/project/configfileregistry_test.go
new file mode 100644
index 0000000000000..f1e8843bdef76
--- /dev/null
+++ b/tsc/internal/project/configfileregistry_test.go
@@ -0,0 +1,73 @@
+package project
+
+import (
+	"testing"
+
+	"github.com/microsoft/TypeScript/tsc/internal/core"
+	"github.com/microsoft/TypeScript/tsc/internal/tsoptions"
+	"github.com/microsoft/TypeScript/tsc/internal/tspath"
+	"github.com/microsoft/TypeScript/tsc/internal/vfs/vfstest"
+	"gotest.tools/v3/assert"
+)
+
+func TestContentMapperSelectorPatternIntersection(t *testing.T) {
+	t.Parallel()
+	for _, test := range []struct {
+		include, want string
+	}{
+		{"**/foo*", "**/foo*.vue"},
+		{"**/*.v*", "**/*.v*"},
+		{"**/fo?", "**/fo?"},
+		{"**/*oml", "**/*oml"},
+	} {
+		got, ok := contentMapperSelectorPattern(test.include, ".vue")
+		assert.Assert(t, ok)
+		assert.Equal(t, got, test.want)
+	}
+}
+
+func TestContentMapperSelectorIncludes(t *testing.T) {
+	t.Parallel()
+	for _, test := range []struct {
+		name, directory, include, base string
+		extended, withoutSourceFile    bool
+	}{
+		{name: "configDir", directory: "/project", include: "${configDir}/local", base: "/project/local"},
+		{name: "inherited", directory: "/project", include: "src", extended: true, base: "/shared/src"},
+		{name: "rooted", directory: "/project", include: "/shared/src", base: "/shared/src"},
+		{name: "without source file", directory: "/project", include: "src", withoutSourceFile: true, base: "/project/src"},
+		{name: "Windows", directory: "c:/project", include: "../shared/src", base: "c:/shared/src"},
+		{name: "Windows separators", directory: "c:/project", include: `c:\\shared\\src`, base: "c:/shared/src"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			configText := `{"contentMappers": [{"package": "mapper", "include": ["` + test.include + `"]}]}`
+			files := map[string]string{
+				test.directory + "/tsconfig.json": configText,
+				test.directory + "/index.ts":      "",
+				test.directory + "/node_modules/mapper/package.json": `{
+					"name": "mapper", "typescript": {"contentMapper": {"exec": ["run"], "extensions": [".toml"]}}
+				}`,
+			}
+			if test.extended {
+				// Inherited includes stay relative to the base config, not the extending project.
+				files["/shared/base.json"] = configText
+				files[test.directory+"/tsconfig.json"] = `{"extends": "../shared/base.json"}`
+			}
+			fs := vfstest.FromMap(files, tspath.CaseSensitive)
+			config, errors := tsoptions.GetParsedCommandLineOfConfigFile(
+				tspath.RootedFilePathFromAbsolute(test.directory+"/tsconfig.json"),
+				&core.CompilerOptions{RunExternalCode: core.TSTrue}, nil, tsoptions.NewDefaultParseConfigHost(fs), nil,
+			)
+			assert.Equal(t, len(errors), 0)
+			assert.Equal(t, len(config.Errors), 0)
+			if test.withoutSourceFile {
+				config.ConfigFile = nil
+			}
+			got := collectConfiguredContentMappers([]*tsoptions.ParsedCommandLine{config})
+			assert.DeepEqual(t, got.selectors, []ContentMapperSelector{{
+				Base: tspath.RootedDirectoryPathFromAbsolute(test.base), Pattern: "**/*.toml", Extension: ".toml",
+			}})
+		})
+	}
+}
diff --git a/tsc/internal/project/contentmapper_test.go b/tsc/internal/project/contentmapper_test.go
index 95f2da159160a..98ddf34e4a408 100644
--- a/tsc/internal/project/contentmapper_test.go
+++ b/tsc/internal/project/contentmapper_test.go
@@ -93,6 +93,45 @@ func TestContentMapperProjectWithoutMappedFiles(t *testing.T) {
 	}
 }
 
+func TestContentMapperRegistryOnlyWatchRefresh(t *testing.T) {
+	t.Parallel()
+	files := map[string]any{
+		"/home/project/tsconfig.json": `{
+			"files": ["main.ts"], "references": [{"path": "./lib"}]
+		}`,
+		"/home/project/main.ts": "export {};",
+		"/home/project/lib/tsconfig.json": `{
+			"compilerOptions": {"composite": true},
+			"contentMappers": [{"package": "mapper", "extensions": [".box"], "include": ["src"]}]
+		}`,
+		"/home/project/lib/src/index.ts":                 "export {};",
+		"/home/project/node_modules/mapper/package.json": contentmappertest.PackageJSON(contentmappertest.TransformingMapper),
+	}
+	init, utils := projecttestutil.GetSessionInitOptions(files, &project.SessionOptions{
+		CurrentDirectory: "/home/project", DefaultLibraryPath: bundled.LibPath(),
+		PositionEncoding: lsproto.PositionEncodingKindUTF8, RunExternalCode: true, LoggingEnabled: true,
+	}, nil)
+	init.Spawner = contentmappertest.NewSpawner()
+	session := project.NewSession(init)
+	defer session.Close()
+	ctx := context.Background()
+	session.DidOpenFile(ctx, "file:///home/project/main.ts", 1, "export {};", lsproto.LanguageKindTypeScript)
+	_, err := session.GetLanguageService(ctx, "file:///home/project/main.ts")
+	assert.NilError(t, err)
+	session.WaitForBackgroundTasks()
+	snapshot := session.Snapshot()
+	assert.Assert(t, snapshot.ConfigFileRegistry.GetConfig("/home/project/lib/tsconfig.json") != nil)
+	assert.DeepEqual(t, snapshot.ConfigFileRegistry.GetConfig("/home/project/lib/tsconfig.json").ContentMapperExtensions(), []string{".box"})
+	assert.DeepEqual(t, snapshot.ContentMapperExtensions(), []string{".box"})
+	assert.Assert(t, snapshot.ProjectCollection.GetProject(project.ID("/home/project/lib/tsconfig.json")) == nil)
+	before := len(utils.Client().RefreshDiagnosticsCalls())
+	session.DidChangeWatchedFiles(ctx, []*lsproto.FileEvent{{
+		Uri: "file:///home/project/lib/src/new.box", Type: lsproto.FileChangeTypeCreated,
+	}})
+	session.WaitForBackgroundTasks()
+	assert.Assert(t, len(utils.Client().RefreshDiagnosticsCalls()) > before)
+}
+
 func TestContentMapperParallelFileLoading(t *testing.T) {
 	t.Parallel()
 	files := map[string]any{
@@ -174,9 +213,9 @@ func TestContentMapperInProject(t *testing.T) {
 
 		// The config's .box mapper should have been registered for text document synchronization.
 		session.WaitForBackgroundTasks()
-		calls := utils.Client().RegisterContentMapperExtensionsCalls()
-		assert.Assert(t, len(calls) > 0, "expected RegisterContentMapperExtensions to be called")
-		assert.DeepEqual(t, calls[len(calls)-1].Extensions, []string{".box"})
+		calls := utils.Client().RegisterContentMapperSelectorsCalls()
+		assert.Assert(t, len(calls) > 0, "expected RegisterContentMapperSelectors to be called")
+		assert.DeepEqual(t, calls[len(calls)-1].Selectors, []project.ContentMapperSelector{{Pattern: "**/*.box", Extension: ".box"}})
 	})
 
 	t.Run("untrusted workspace does not run the content mapper", func(t *testing.T) {
@@ -195,8 +234,8 @@ func TestContentMapperInProject(t *testing.T) {
 
 		// No content mapper extensions should be registered without trust.
 		session.WaitForBackgroundTasks()
-		for _, call := range utils.Client().RegisterContentMapperExtensionsCalls() {
-			assert.Equal(t, len(call.Extensions), 0, "expected no content mapper extensions to be registered without trust")
+		for _, call := range utils.Client().RegisterContentMapperSelectorsCalls() {
+			assert.Equal(t, len(call.Selectors), 0, "expected no content mapper selectors to be registered without trust")
 		}
 	})
 
@@ -835,11 +874,11 @@ func TestContentMappersInParallelProjectReferences(t *testing.T) {
 	uri := lsproto.DocumentUri("file:///home/project/src/index.d.ts")
 	session.DidOpenFile(context.Background(), uri, 1, files["/home/project/src/index.d.ts"].(string), lsproto.LanguageKindTypeScript)
 	session.WaitForBackgroundTasks()
-	calls := utils.Client().RegisterContentMapperExtensionsCalls()
+	calls := utils.Client().RegisterContentMapperSelectorsCalls()
 	assert.Assert(t, len(calls) > 0)
-	extensions := slices.Clone(calls[len(calls)-1].Extensions)
-	slices.Sort(extensions)
-	assert.DeepEqual(t, extensions, []string{".svelte", ".vue"})
+	assert.DeepEqual(t, calls[len(calls)-1].Selectors, []project.ContentMapperSelector{
+		{Pattern: "**/*.svelte", Extension: ".svelte"}, {Pattern: "**/*.vue", Extension: ".vue"},
+	})
 }
 
 func TestContentMapperOpenFileExcludedByConfigChange(t *testing.T) {
@@ -970,9 +1009,9 @@ func TestContentMapperRemovalWithOpenFile(t *testing.T) {
 	assert.Equal(t, spawner.closes.Load(), int32(0), "live old snapshot should retain the mapper process")
 	assert.NilError(t, releaseOldSnapshot())
 	assert.Equal(t, spawner.closes.Load(), int32(1), "process should close after the final live snapshot is released")
-	calls := utils.Client().RegisterContentMapperExtensionsCalls()
+	calls := utils.Client().RegisterContentMapperSelectorsCalls()
 	assert.Assert(t, len(calls) > 0, "expected content mapper registration updates")
-	assert.Equal(t, len(calls[len(calls)-1].Extensions), 0, "expected content mapper extensions to be unregistered")
+	assert.Equal(t, len(calls[len(calls)-1].Selectors), 0, "expected content mapper selectors to be unregistered")
 
 	session.DidCloseFile(ctx, boxURI)
 	_, err = session.GetLanguageService(ctx, boxURI)
diff --git a/tsc/internal/project/extendedconfigcache_test.go b/tsc/internal/project/extendedconfigcache_test.go
index e42021743a0f3..11ac43c047772 100644
--- a/tsc/internal/project/extendedconfigcache_test.go
+++ b/tsc/internal/project/extendedconfigcache_test.go
@@ -24,7 +24,7 @@ func (noopClient) WatchFiles(ctx context.Context, id WatcherID, watchers []*lspr
 
 func (noopClient) UnwatchFiles(ctx context.Context, id WatcherID) error { return nil }
 
-func (noopClient) RegisterContentMapperExtensions(ctx context.Context, extensions []string) error {
+func (noopClient) RegisterContentMapperSelectors(ctx context.Context, selectors []ContentMapperSelector) error {
 	return nil
 }
 
diff --git a/tsc/internal/project/session.go b/tsc/internal/project/session.go
index e02dd45c3e842..0b7163869b785 100644
--- a/tsc/internal/project/session.go
+++ b/tsc/internal/project/session.go
@@ -121,7 +121,7 @@ type Session struct {
 	// applied. Registration runs from background tasks that may finish out of order, so
 	// contentMapperRegistrationMu serializes updates and the snapshot ID keeps a stale task from
 	// overwriting a newer snapshot's registration.
-	registeredContentMapperExtensions []string
+	registeredContentMapperSelectors  []ContentMapperSelector
 	registeredContentMapperSnapshotID uint64
 	contentMapperRegistrationMu       sync.Mutex
 
@@ -448,7 +448,8 @@ func (s *Session) DidChangeWatchedFiles(ctx context.Context, changes []*lsproto.
 		if !hasRelevantChange {
 			filePath := change.Uri.Path()
 			path := s.caseSensitivity.PathKey(filePath).RemoveTrailingDirectorySeparator()
-			if contentMapperWatchedFiles.Has(path) {
+			if contentMapperWatchedFiles.Has(path) ||
+				tspath.RootedFilePathFromPath(filePath).LongestExtension(contentMapperExtensions, s.caseSensitivity) != "" {
 				hasRelevantChange = true
 				continue
 			}
@@ -468,8 +469,7 @@ func (s *Session) DidChangeWatchedFiles(ctx context.Context, changes []*lsproto.
 					}
 				}
 			} else {
-				if isRelevantExtension(extension) ||
-					path.ExtensionIsOneOf(contentMapperExtensions) {
+				if isRelevantExtension(extension) {
 					hasRelevantChange = true
 				}
 			}
@@ -1586,18 +1586,19 @@ func (s *Session) updateWatch[T any](ctx context.Context, oldWatcher, newWatcher
 	return errors
 }
 
-// updateContentMapperRegistrations computes the union of content mapper extensions across all loaded
-// configs in the new snapshot and, when the set changes, asks the client to synchronize text documents
-// with those extensions. This is how an otherwise unsupported file (e.g. a `.vue`) begins flowing to the server once a
-// config that maps it is discovered.
+// updateContentMapperRegistrations synchronizes selectors from loaded configs and inferred projects.
 func (s *Session) updateContentMapperRegistrations(ctx context.Context, snapshot *Snapshot) error {
 	if s.client == nil {
 		return nil
 	}
 	contentMappers := snapshot.ConfigFileRegistry.contentMappers()
-	extensions := append(slices.Clone(contentMappers.extensions), snapshot.inferredProjectContentMapperExtensions...)
-	slices.Sort(extensions)
-	extensions = slices.Compact(extensions)
+	selectors := make([]ContentMapperSelector, 0, len(snapshot.inferredProjectContentMapperExtensions)+len(contentMappers.selectors))
+	for _, extension := range snapshot.inferredProjectContentMapperExtensions {
+		selectors = append(selectors, ContentMapperSelector{Pattern: ContentMapperExtensionPattern(extension), Extension: extension})
+	}
+	selectors = append(selectors, contentMappers.selectors...)
+	slices.SortFunc(selectors, compareContentMapperSelectors)
+	selectors = slices.Compact(selectors)
 
 	s.contentMapperRegistrationMu.Lock()
 	defer s.contentMapperRegistrationMu.Unlock()
@@ -1606,21 +1607,18 @@ func (s *Session) updateContentMapperRegistrations(ctx context.Context, snapshot
 	if snapshot.ID() <= s.registeredContentMapperSnapshotID {
 		return nil
 	}
-	if slices.Equal(extensions, s.registeredContentMapperExtensions) {
+	if slices.Equal(selectors, s.registeredContentMapperSelectors) {
 		s.registeredContentMapperSnapshotID = snapshot.ID()
 		return nil
 	}
-	// RegisterContentMapperExtensions replaces the prior registration wholesale (unregistering extensions
-	// that are no longer mapped and registering the current set), so an empty set removes the registration
-	// once the last mapping config unloads. On failure we leave the state unadvanced so the next snapshot
-	// update retries.
-	if err := s.client.RegisterContentMapperExtensions(ctx, extensions); err != nil {
+	// Registration replaces the previous set; leave state unchanged on failure so the next update retries.
+	if err := s.client.RegisterContentMapperSelectors(ctx, selectors); err != nil {
 		if s.options.LoggingEnabled {
 			s.logger.Log(err)
 		}
 		return err
 	}
-	s.registeredContentMapperExtensions = extensions
+	s.registeredContentMapperSelectors = selectors
 	s.registeredContentMapperSnapshotID = snapshot.ID()
 	return nil
 }
diff --git a/tsc/internal/testutil/harnessutil/harnessutil.go b/tsc/internal/testutil/harnessutil/harnessutil.go
index 3b86a398b281b..d6365f43a071d 100644
--- a/tsc/internal/testutil/harnessutil/harnessutil.go
+++ b/tsc/internal/testutil/harnessutil/harnessutil.go
@@ -845,7 +845,8 @@ func (c *CompilationResult) getOutputPath(filePath tspath.RootedFilePath, ext st
 		}
 	}
 	if ext == outputPath.DeclarationEmitExtension() {
-		return outputpaths.ChangeToDeclarationExtension(outputPath, c.Program.Program())
+		declarationPath := outputpaths.ChangeToDeclarationExtension(filePath, c.Program.Program())
+		return outputPath.Directory().ResolveFile(declarationPath.BaseName())
 	}
 	return outputPath.ChangeExtension(ext)
 }
diff --git a/tsc/internal/testutil/projecttestutil/clientmock_generated.go b/tsc/internal/testutil/projecttestutil/clientmock_generated.go
index ccd0d4dd437d3..a819ff1a1e6ce 100644
--- a/tsc/internal/testutil/projecttestutil/clientmock_generated.go
+++ b/tsc/internal/testutil/projecttestutil/clientmock_generated.go
@@ -47,8 +47,8 @@ var _ project.Client = &ClientMock{}
 //			RefreshInlayHintsFunc: func(ctx context.Context) error {
 //				panic("mock out the RefreshInlayHints method")
 //			},
-//			RegisterContentMapperExtensionsFunc: func(ctx context.Context, extensions []string) error {
-//				panic("mock out the RegisterContentMapperExtensions method")
+//			RegisterContentMapperSelectorsFunc: func(ctx context.Context, selectors []project.ContentMapperSelector) error {
+//				panic("mock out the RegisterContentMapperSelectors method")
 //			},
 //			SendTelemetryFunc: func(ctx context.Context, telemetry lsproto.TelemetryEvent) error {
 //				panic("mock out the SendTelemetry method")
@@ -93,8 +93,8 @@ type ClientMock struct {
 	// RefreshInlayHintsFunc mocks the RefreshInlayHints method.
 	RefreshInlayHintsFunc func(ctx context.Context) error
 
-	// RegisterContentMapperExtensionsFunc mocks the RegisterContentMapperExtensions method.
-	RegisterContentMapperExtensionsFunc func(ctx context.Context, extensions []string) error
+	// RegisterContentMapperSelectorsFunc mocks the RegisterContentMapperSelectors method.
+	RegisterContentMapperSelectorsFunc func(ctx context.Context, selectors []project.ContentMapperSelector) error
 
 	// SendTelemetryFunc mocks the SendTelemetry method.
 	SendTelemetryFunc func(ctx context.Context, telemetry lsproto.TelemetryEvent) error
@@ -150,12 +150,12 @@ type ClientMock struct {
 			// Ctx is the ctx argument value.
 			Ctx context.Context
 		}
-		// RegisterContentMapperExtensions holds details about calls to the RegisterContentMapperExtensions method.
-		RegisterContentMapperExtensions []struct {
+		// RegisterContentMapperSelectors holds details about calls to the RegisterContentMapperSelectors method.
+		RegisterContentMapperSelectors []struct {
 			// Ctx is the ctx argument value.
 			Ctx context.Context
-			// Extensions is the extensions argument value.
-			Extensions []string
+			// Selectors is the selectors argument value.
+			Selectors []project.ContentMapperSelector
 		}
 		// SendTelemetry holds details about calls to the SendTelemetry method.
 		SendTelemetry []struct {
@@ -186,19 +186,19 @@ type ClientMock struct {
 			Watchers []*lsproto.FileSystemWatcher
 		}
 	}
-	lockGetLocale                       sync.RWMutex
-	lockIsActive                        sync.RWMutex
-	lockProgressFinish                  sync.RWMutex
-	lockProgressStart                   sync.RWMutex
-	lockPublishDiagnostics              sync.RWMutex
-	lockRefreshCodeLens                 sync.RWMutex
-	lockRefreshDiagnostics              sync.RWMutex
-	lockRefreshInlayHints               sync.RWMutex
-	lockRegisterContentMapperExtensions sync.RWMutex
-	lockSendTelemetry                   sync.RWMutex
-	lockSetLocale                       sync.RWMutex
-	lockUnwatchFiles                    sync.RWMutex
-	lockWatchFiles                      sync.RWMutex
+	lockGetLocale                      sync.RWMutex
+	lockIsActive                       sync.RWMutex
+	lockProgressFinish                 sync.RWMutex
+	lockProgressStart                  sync.RWMutex
+	lockPublishDiagnostics             sync.RWMutex
+	lockRefreshCodeLens                sync.RWMutex
+	lockRefreshDiagnostics             sync.RWMutex
+	lockRefreshInlayHints              sync.RWMutex
+	lockRegisterContentMapperSelectors sync.RWMutex
+	lockSendTelemetry                  sync.RWMutex
+	lockSetLocale                      sync.RWMutex
+	lockUnwatchFiles                   sync.RWMutex
+	lockWatchFiles                     sync.RWMutex
 }
 
 // GetLocale calls GetLocaleFunc.
@@ -459,40 +459,40 @@ func (mock *ClientMock) RefreshInlayHintsCalls() []struct {
 	return calls
 }
 
-// RegisterContentMapperExtensions calls RegisterContentMapperExtensionsFunc.
-func (mock *ClientMock) RegisterContentMapperExtensions(ctx context.Context, extensions []string) error {
+// RegisterContentMapperSelectors calls RegisterContentMapperSelectorsFunc.
+func (mock *ClientMock) RegisterContentMapperSelectors(ctx context.Context, selectors []project.ContentMapperSelector) error {
 	callInfo := struct {
-		Ctx        context.Context
-		Extensions []string
+		Ctx       context.Context
+		Selectors []project.ContentMapperSelector
 	}{
-		Ctx:        ctx,
-		Extensions: extensions,
+		Ctx:       ctx,
+		Selectors: selectors,
 	}
-	mock.lockRegisterContentMapperExtensions.Lock()
-	mock.calls.RegisterContentMapperExtensions = append(mock.calls.RegisterContentMapperExtensions, callInfo)
-	mock.lockRegisterContentMapperExtensions.Unlock()
-	if mock.RegisterContentMapperExtensionsFunc == nil {
+	mock.lockRegisterContentMapperSelectors.Lock()
+	mock.calls.RegisterContentMapperSelectors = append(mock.calls.RegisterContentMapperSelectors, callInfo)
+	mock.lockRegisterContentMapperSelectors.Unlock()
+	if mock.RegisterContentMapperSelectorsFunc == nil {
 		var errOut error
 		return errOut
 	}
-	return mock.RegisterContentMapperExtensionsFunc(ctx, extensions)
+	return mock.RegisterContentMapperSelectorsFunc(ctx, selectors)
 }
 
-// RegisterContentMapperExtensionsCalls gets all the calls that were made to RegisterContentMapperExtensions.
+// RegisterContentMapperSelectorsCalls gets all the calls that were made to RegisterContentMapperSelectors.
 // Check the length with:
 //
-//	len(mockedClient.RegisterContentMapperExtensionsCalls())
-func (mock *ClientMock) RegisterContentMapperExtensionsCalls() []struct {
-	Ctx        context.Context
-	Extensions []string
+//	len(mockedClient.RegisterContentMapperSelectorsCalls())
+func (mock *ClientMock) RegisterContentMapperSelectorsCalls() []struct {
+	Ctx       context.Context
+	Selectors []project.ContentMapperSelector
 } {
 	var calls []struct {
-		Ctx        context.Context
-		Extensions []string
+		Ctx       context.Context
+		Selectors []project.ContentMapperSelector
 	}
-	mock.lockRegisterContentMapperExtensions.RLock()
-	calls = mock.calls.RegisterContentMapperExtensions
-	mock.lockRegisterContentMapperExtensions.RUnlock()
+	mock.lockRegisterContentMapperSelectors.RLock()
+	calls = mock.calls.RegisterContentMapperSelectors
+	mock.lockRegisterContentMapperSelectors.RUnlock()
 	return calls
 }
 
diff --git a/tsc/internal/transformers/chain.go b/tsc/internal/transformers/chain.go
index fec592e5e2019..43d7349e1c730 100644
--- a/tsc/internal/transformers/chain.go
+++ b/tsc/internal/transformers/chain.go
@@ -25,13 +25,14 @@ func (ch *chainedTransformer) visit(node *ast.Node) *ast.Node {
 }
 
 type TransformOptions struct {
-	Context                        *printer.EmitContext
-	CompilerOptions                *core.CompilerOptions
-	Resolver                       binder.ReferenceResolver
-	EmitResolver                   printer.EmitResolver
-	GetEmitModuleFormatOfFile      func(file ast.HasFileName) core.ModuleKind
-	ContentMapperExtensionRewrites []tspath.ExtensionRewrite
-	CaseSensitivity                tspath.CaseSensitivity
+	Context                           *printer.EmitContext
+	CompilerOptions                   *core.CompilerOptions
+	Resolver                          binder.ReferenceResolver
+	EmitResolver                      printer.EmitResolver
+	GetEmitModuleFormatOfFile         func(file ast.HasFileName) core.ModuleKind
+	ContentMapperExtensionRewrites    []tspath.ExtensionRewrite
+	ContentMapperExtensionForFileName func(tspath.RootedFilePath) string
+	CaseSensitivity                   tspath.CaseSensitivity
 }
 
 type TransformerFactory = func(opt *TransformOptions) *Transformer
diff --git a/tsc/internal/transformers/declarations/transform.go b/tsc/internal/transformers/declarations/transform.go
index e63e37450bd2d..a19f95f0b2dc6 100644
--- a/tsc/internal/transformers/declarations/transform.go
+++ b/tsc/internal/transformers/declarations/transform.go
@@ -8,6 +8,7 @@ import (
 
 	"github.com/microsoft/TypeScript/tsc/internal/ast"
 	"github.com/microsoft/TypeScript/tsc/internal/collections"
+	"github.com/microsoft/TypeScript/tsc/internal/contentmapper"
 	"github.com/microsoft/TypeScript/tsc/internal/core"
 	"github.com/microsoft/TypeScript/tsc/internal/debug"
 	"github.com/microsoft/TypeScript/tsc/internal/diagnostics"
@@ -1609,6 +1610,7 @@ func (tx *DeclarationTransformer) rewriteModuleSpecifier(parent *ast.Node, input
 		specifier := tspath.ToModuleSpecifier(input.Text())
 		rewrites := tx.host.ContentMapperExtensionRewrites()
 		caseSensitivity := tx.host.CaseSensitivity()
+		rewrites = contentmapper.RewritesForImport(rewrites, tx.state.currentSourceFile.FileName(), specifier, tx.host.ContentMapperExtensionForFileName, caseSensitivity)
 		if !specifier.ShouldRewriteExtension(rewrites, caseSensitivity) {
 			return input
 		}
diff --git a/tsc/internal/transformers/moduletransforms/commonjsmodule.go b/tsc/internal/transformers/moduletransforms/commonjsmodule.go
index 8ee78bbea8543..ff49b1f9e95a7 100644
--- a/tsc/internal/transformers/moduletransforms/commonjsmodule.go
+++ b/tsc/internal/transformers/moduletransforms/commonjsmodule.go
@@ -14,27 +14,29 @@ import (
 
 type CommonJSModuleTransformer struct {
 	transformers.Transformer
-	topLevelVisitor                *ast.NodeVisitor // visits statements at top level of a module
-	topLevelNestedVisitor          *ast.NodeVisitor // visits nested statements at top level of a module
-	discardedValueVisitor          *ast.NodeVisitor // visits expressions whose values would be discarded at runtime
-	assignmentPatternVisitor       *ast.NodeVisitor // visits assignment patterns in a destructuring assignment
-	compilerOptions                *core.CompilerOptions
-	resolver                       binder.ReferenceResolver
-	getEmitModuleFormatOfFile      func(file ast.HasFileName) core.ModuleKind
-	moduleKind                     core.ModuleKind
-	languageVersion                core.ScriptTarget
-	currentSourceFile              *ast.SourceFile
-	currentModuleInfo              *externalModuleInfo
-	parentNode                     *ast.Node // used for ancestor tracking via pushNode/popNode to detect expression identifiers
-	currentNode                    *ast.Node // used for ancestor tracking via pushNode/popNode to detect expression identifiers
-	contentMapperExtensionRewrites []tspath.ExtensionRewrite
-	caseSensitivity                tspath.CaseSensitivity
+	topLevelVisitor                   *ast.NodeVisitor // visits statements at top level of a module
+	topLevelNestedVisitor             *ast.NodeVisitor // visits nested statements at top level of a module
+	discardedValueVisitor             *ast.NodeVisitor // visits expressions whose values would be discarded at runtime
+	assignmentPatternVisitor          *ast.NodeVisitor // visits assignment patterns in a destructuring assignment
+	compilerOptions                   *core.CompilerOptions
+	resolver                          binder.ReferenceResolver
+	getEmitModuleFormatOfFile         func(file ast.HasFileName) core.ModuleKind
+	moduleKind                        core.ModuleKind
+	languageVersion                   core.ScriptTarget
+	currentSourceFile                 *ast.SourceFile
+	currentModuleInfo                 *externalModuleInfo
+	parentNode                        *ast.Node // used for ancestor tracking via pushNode/popNode to detect expression identifiers
+	currentNode                       *ast.Node // used for ancestor tracking via pushNode/popNode to detect expression identifiers
+	contentMapperExtensionRewrites    []tspath.ExtensionRewrite
+	contentMapperExtensionForFileName func(tspath.RootedFilePath) string
+	caseSensitivity                   tspath.CaseSensitivity
 }
 
 func NewCommonJSModuleTransformer(opts *transformers.TransformOptions) *transformers.Transformer {
 	compilerOptions := opts.CompilerOptions
 	emitContext := opts.Context
 	tx := &CommonJSModuleTransformer{compilerOptions: compilerOptions, resolver: opts.Resolver, getEmitModuleFormatOfFile: opts.GetEmitModuleFormatOfFile, contentMapperExtensionRewrites: opts.ContentMapperExtensionRewrites, caseSensitivity: opts.CaseSensitivity}
+	tx.contentMapperExtensionForFileName = opts.ContentMapperExtensionForFileName
 	tx.topLevelVisitor = emitContext.NewNodeVisitor(tx.visitTopLevel)
 	tx.topLevelNestedVisitor = emitContext.NewNodeVisitor(tx.visitTopLevelNested)
 	tx.discardedValueVisitor = emitContext.NewNodeVisitor(tx.visitDiscardedValue)
@@ -682,7 +684,7 @@ func (tx *CommonJSModuleTransformer) createRequireCall(node *ast.Node /*ImportDe
 	var args []*ast.Expression
 	moduleName := getExternalModuleNameLiteral(tx.Factory(), node, tx.currentSourceFile, nil /*host*/, nil /*resolver*/, tx.compilerOptions)
 	if moduleName != nil {
-		args = append(args, rewriteModuleSpecifier(tx.EmitContext(), moduleName, tx.compilerOptions, tx.contentMapperExtensionRewrites, tx.caseSensitivity))
+		args = append(args, rewriteModuleSpecifier(tx.EmitContext(), moduleName, tx.compilerOptions, tx.contentMapperExtensionRewrites, tx.caseSensitivity, tx.currentSourceFile, tx.contentMapperExtensionForFileName))
 	}
 	return tx.Factory().NewCallExpression(
 		tx.Factory().NewIdentifier("require"),
@@ -1863,7 +1865,7 @@ func (tx *CommonJSModuleTransformer) visitImportCallExpression(node *ast.CallExp
 		argument = externalModuleName
 	} else if firstArgument != nil && rewriteOrShim {
 		if ast.IsStringLiteral(firstArgument) {
-			argument = rewriteModuleSpecifier(tx.EmitContext(), firstArgument, tx.compilerOptions, tx.contentMapperExtensionRewrites, tx.caseSensitivity)
+			argument = rewriteModuleSpecifier(tx.EmitContext(), firstArgument, tx.compilerOptions, tx.contentMapperExtensionRewrites, tx.caseSensitivity, tx.currentSourceFile, tx.contentMapperExtensionForFileName)
 		} else {
 			argument = tx.Factory().NewRewriteRelativeImportExtensionsHelper(firstArgument, tx.compilerOptions.Jsx == core.JsxEmitPreserve, tx.contentMapperExtensionRewrites, tx.caseSensitivity)
 		}
@@ -1973,7 +1975,7 @@ func (tx *CommonJSModuleTransformer) shimOrRewriteImportOrRequireCall(node *ast.
 		firstArgument := tx.Visitor().VisitNode(node.Arguments.Nodes[0])
 		firstArgumentChanged := false
 		if ast.IsStringLiteralLike(firstArgument) {
-			rewritten := rewriteModuleSpecifier(tx.EmitContext(), firstArgument, tx.compilerOptions, tx.contentMapperExtensionRewrites, tx.caseSensitivity)
+			rewritten := rewriteModuleSpecifier(tx.EmitContext(), firstArgument, tx.compilerOptions, tx.contentMapperExtensionRewrites, tx.caseSensitivity, tx.currentSourceFile, tx.contentMapperExtensionForFileName)
 			firstArgumentChanged = rewritten != firstArgument
 			firstArgument = rewritten
 		} else {
diff --git a/tsc/internal/transformers/moduletransforms/esmodule.go b/tsc/internal/transformers/moduletransforms/esmodule.go
index 093c02f2f6d5f..106cb21908c56 100644
--- a/tsc/internal/transformers/moduletransforms/esmodule.go
+++ b/tsc/internal/transformers/moduletransforms/esmodule.go
@@ -13,14 +13,15 @@ import (
 
 type ESModuleTransformer struct {
 	transformers.Transformer
-	compilerOptions                *core.CompilerOptions
-	resolver                       binder.ReferenceResolver
-	getEmitModuleFormatOfFile      func(file ast.HasFileName) core.ModuleKind
-	contentMapperExtensionRewrites []tspath.ExtensionRewrite
-	caseSensitivity                tspath.CaseSensitivity
-	currentSourceFile              *ast.SourceFile
-	importRequireStatements        *importRequireStatements
-	helperNameSubstitutions        map[string]*ast.IdentifierNode
+	compilerOptions                   *core.CompilerOptions
+	resolver                          binder.ReferenceResolver
+	getEmitModuleFormatOfFile         func(file ast.HasFileName) core.ModuleKind
+	contentMapperExtensionRewrites    []tspath.ExtensionRewrite
+	contentMapperExtensionForFileName func(tspath.RootedFilePath) string
+	caseSensitivity                   tspath.CaseSensitivity
+	currentSourceFile                 *ast.SourceFile
+	importRequireStatements           *importRequireStatements
+	helperNameSubstitutions           map[string]*ast.IdentifierNode
 }
 
 type importRequireStatements struct {
@@ -31,6 +32,7 @@ type importRequireStatements struct {
 func NewESModuleTransformer(opts *transformers.TransformOptions) *transformers.Transformer {
 	compilerOptions := opts.CompilerOptions
 	tx := &ESModuleTransformer{compilerOptions: compilerOptions, resolver: opts.Resolver, getEmitModuleFormatOfFile: opts.GetEmitModuleFormatOfFile, contentMapperExtensionRewrites: opts.ContentMapperExtensionRewrites, caseSensitivity: opts.CaseSensitivity}
+	tx.contentMapperExtensionForFileName = opts.ContentMapperExtensionForFileName
 	return tx.NewTransformer(tx.visit, opts.Context)
 }
 
@@ -107,7 +109,7 @@ func (tx *ESModuleTransformer) visitImportDeclaration(node *ast.ImportDeclaratio
 	if !tx.compilerOptions.RewriteRelativeImportExtensions.IsTrue() {
 		return node.AsNode()
 	}
-	updatedModuleSpecifier := rewriteModuleSpecifier(tx.EmitContext(), node.ModuleSpecifier, tx.compilerOptions, tx.contentMapperExtensionRewrites, tx.caseSensitivity)
+	updatedModuleSpecifier := rewriteModuleSpecifier(tx.EmitContext(), node.ModuleSpecifier, tx.compilerOptions, tx.contentMapperExtensionRewrites, tx.caseSensitivity, tx.currentSourceFile, tx.contentMapperExtensionForFileName)
 	return tx.Factory().UpdateImportDeclaration(
 		node,
 		nil, /*modifiers*/
@@ -201,7 +203,7 @@ func (tx *ESModuleTransformer) visitExportDeclaration(node *ast.ExportDeclaratio
 		return node.AsNode()
 	}
 
-	updatedModuleSpecifier := rewriteModuleSpecifier(tx.EmitContext(), node.ModuleSpecifier, tx.compilerOptions, tx.contentMapperExtensionRewrites, tx.caseSensitivity)
+	updatedModuleSpecifier := rewriteModuleSpecifier(tx.EmitContext(), node.ModuleSpecifier, tx.compilerOptions, tx.contentMapperExtensionRewrites, tx.caseSensitivity, tx.currentSourceFile, tx.contentMapperExtensionForFileName)
 	if tx.compilerOptions.Module > core.ModuleKindES2015 || node.ExportClause == nil || !ast.IsNamespaceExport(node.ExportClause) {
 		// Either ill-formed or don't need to be transformed.
 		return tx.Factory().UpdateExportDeclaration(
@@ -267,7 +269,7 @@ func (tx *ESModuleTransformer) visitImportOrRequireCall(node *ast.CallExpression
 
 	var argument *ast.Expression
 	if ast.IsStringLiteralLike(node.Arguments.Nodes[0]) {
-		argument = rewriteModuleSpecifier(tx.EmitContext(), node.Arguments.Nodes[0], tx.compilerOptions, tx.contentMapperExtensionRewrites, tx.caseSensitivity)
+		argument = rewriteModuleSpecifier(tx.EmitContext(), node.Arguments.Nodes[0], tx.compilerOptions, tx.contentMapperExtensionRewrites, tx.caseSensitivity, tx.currentSourceFile, tx.contentMapperExtensionForFileName)
 	} else {
 		argument = tx.Factory().NewRewriteRelativeImportExtensionsHelper(node.Arguments.Nodes[0], tx.compilerOptions.Jsx == core.JsxEmitPreserve, tx.contentMapperExtensionRewrites, tx.caseSensitivity)
 	}
@@ -295,7 +297,7 @@ func (tx *ESModuleTransformer) createRequireCall(node *ast.Node /*ImportDeclarat
 
 	var args []*ast.Expression
 	if moduleName != nil {
-		args = append(args, rewriteModuleSpecifier(tx.EmitContext(), moduleName, tx.compilerOptions, tx.contentMapperExtensionRewrites, tx.caseSensitivity))
+		args = append(args, rewriteModuleSpecifier(tx.EmitContext(), moduleName, tx.compilerOptions, tx.contentMapperExtensionRewrites, tx.caseSensitivity, tx.currentSourceFile, tx.contentMapperExtensionForFileName))
 	}
 
 	if tx.compilerOptions.GetEmitModuleKind() == core.ModuleKindPreserve {
diff --git a/tsc/internal/transformers/moduletransforms/utilities.go b/tsc/internal/transformers/moduletransforms/utilities.go
index 8ed465e9c7b34..b8ac50ec9e104 100644
--- a/tsc/internal/transformers/moduletransforms/utilities.go
+++ b/tsc/internal/transformers/moduletransforms/utilities.go
@@ -2,6 +2,7 @@ package moduletransforms
 
 import (
 	"github.com/microsoft/TypeScript/tsc/internal/ast"
+	"github.com/microsoft/TypeScript/tsc/internal/contentmapper"
 	"github.com/microsoft/TypeScript/tsc/internal/core"
 	"github.com/microsoft/TypeScript/tsc/internal/outputpaths"
 	"github.com/microsoft/TypeScript/tsc/internal/printer"
@@ -19,11 +20,12 @@ func isDeclarationNameOfEnumOrNamespace(emitContext *printer.EmitContext, node *
 	return false
 }
 
-func rewriteModuleSpecifier(emitContext *printer.EmitContext, node *ast.Expression, compilerOptions *core.CompilerOptions, rewrites []tspath.ExtensionRewrite, caseSensitivity tspath.CaseSensitivity) *ast.Expression {
+func rewriteModuleSpecifier(emitContext *printer.EmitContext, node *ast.Expression, compilerOptions *core.CompilerOptions, rewrites []tspath.ExtensionRewrite, caseSensitivity tspath.CaseSensitivity, sourceFile *ast.SourceFile, getMapperExtension func(tspath.RootedFilePath) string) *ast.Expression {
 	if node == nil || !ast.IsStringLiteral(node) || !compilerOptions.RewriteRelativeImportExtensions.IsTrue() {
 		return node
 	}
 	specifier := tspath.ToModuleSpecifier(node.Text())
+	rewrites = contentmapper.RewritesForImport(rewrites, sourceFile.FileName(), specifier, getMapperExtension, caseSensitivity)
 	if !specifier.ShouldRewriteExtension(rewrites, caseSensitivity) {
 		return node
 	}
diff --git a/tsc/internal/transformers/tstransforms/importelision_test.go b/tsc/internal/transformers/tstransforms/importelision_test.go
index 091adcf722297..5c3a7e3d1e9f5 100644
--- a/tsc/internal/transformers/tstransforms/importelision_test.go
+++ b/tsc/internal/transformers/tstransforms/importelision_test.go
@@ -50,8 +50,8 @@ func (p *fakeProgram) CommonSourceDirectory() tspath.RootedDirectoryPath {
 	panic("unimplemented")
 }
 
-func (p *fakeProgram) ContentMapperExtensions() []string {
-	return nil
+func (p *fakeProgram) ContentMapperExtensionForFileName(tspath.RootedFilePath) string {
+	return ""
 }
 
 func (p *fakeProgram) ContentMapperExtensionRewrites() []tspath.ExtensionRewrite {
diff --git a/tsc/internal/tsoptions/contentmappers.go b/tsc/internal/tsoptions/contentmappers.go
index e3d2a4bc04c10..14123ad8dbfe1 100644
--- a/tsc/internal/tsoptions/contentmappers.go
+++ b/tsc/internal/tsoptions/contentmappers.go
@@ -78,6 +78,12 @@ func resolveContentMapperManifest(host ParseConfigHost, containingFile tspath.Ro
 		return contentmapper.Manifest{}, packageDirectory, ast.NewCompilerDiagnostic(diagnostics.The_typescript_contentMapper_exec_of_the_content_mapper_package_0_must_be_a_non_empty_array_of_strings, packageName)
 	}
 	compilerOptions, _ := cm.CompilerOptions.GetValue()
+	extensions, valid := cm.Extensions.GetValue()
+	if cm.Extensions.IsPresent() && !valid {
+		return contentmapper.Manifest{}, packageDirectory, ast.NewCompilerDiagnostic(
+			diagnostics.Compiler_option_0_requires_a_value_of_type_1, "typescript.contentMapper.extensions", "string[]",
+		)
+	}
 	dynamicConfig, _ := cm.DynamicConfig.GetValue()
 	outputExtensions, valid := cm.OutputExtensions.GetValue()
 	if cm.OutputExtensions.IsPresent() && !valid {
@@ -105,5 +111,5 @@ func resolveContentMapperManifest(host ParseConfigHost, containingFile tspath.Ro
 			)
 		}
 	}
-	return contentmapper.Manifest{Name: name, Version: version, Exec: exec, CompilerOptions: compilerOptions, DynamicConfig: dynamicConfig, DefaultOutputExtensions: outputExtensions}, packageDirectory, nil
+	return contentmapper.Manifest{Name: name, Version: version, Exec: exec, CompilerOptions: compilerOptions, DynamicConfig: dynamicConfig, DefaultOutputExtensions: outputExtensions, DefaultExtensions: extensions}, packageDirectory, nil
 }
diff --git a/tsc/internal/tsoptions/contentmappers_test.go b/tsc/internal/tsoptions/contentmappers_test.go
index 68137b0ac1203..0f1d23ff0a107 100644
--- a/tsc/internal/tsoptions/contentmappers_test.go
+++ b/tsc/internal/tsoptions/contentmappers_test.go
@@ -2,11 +2,14 @@ package tsoptions
 
 import (
 	"slices"
+	"strings"
 	"testing"
 
+	"github.com/microsoft/TypeScript/tsc/internal/ast"
 	"github.com/microsoft/TypeScript/tsc/internal/contentmapper"
 	"github.com/microsoft/TypeScript/tsc/internal/core"
 	"github.com/microsoft/TypeScript/tsc/internal/diagnostics"
+	"github.com/microsoft/TypeScript/tsc/internal/locale"
 	"github.com/microsoft/TypeScript/tsc/internal/tspath"
 	"github.com/microsoft/TypeScript/tsc/internal/vfs/vfstest"
 	"gotest.tools/v3/assert"
@@ -33,11 +36,361 @@ func TestGetContentMapperForFileNameUsesHostCaseSensitivity(t *testing.T) {
 		ParsedConfig:    &ParsedOptions{ContentMappers: []*contentmapper.Mapper{mapper}},
 		caseSensitivity: tspath.CaseSensitive,
 	}
-
 	assert.Equal(t, insensitive.GetContentMapperForFileName("/src/Component.VUE"), mapper)
 	assert.Assert(t, sensitive.GetContentMapperForFileName("/src/Component.VUE") == nil)
 }
 
+func TestContentMapperIncludeInheritance(t *testing.T) {
+	t.Parallel()
+	// Inherited src is rebased; ${configDir} still refers to the extending config.
+	fs := vfstest.FromMap(map[string]string{
+		"/shared/base.json": `{
+			"contentMappers": [{"package": "mapper", "include": ["src", "${configDir}/local"]}]
+		}`,
+		"/project/tsconfig.json": `{
+			"extends": "../shared/base.json",
+			"compilerOptions": {"noLib": true},
+			"include": ["../shared/src", "local", "other"]
+		}`,
+		"/project/node_modules/mapper/package.json": `{
+			"name": "mapper", "typescript": {"contentMapper": {"exec": ["run"], "extensions": [".toml"]}}
+		}`,
+		"/shared/src/a.toml":    "",
+		"/project/local/b.toml": "",
+		"/project/other/c.toml": "",
+	}, tspath.CaseSensitive)
+	config, errors := GetParsedCommandLineOfConfigFile(
+		"/project/tsconfig.json", &core.CompilerOptions{RunExternalCode: core.TSTrue}, nil, NewDefaultParseConfigHost(fs), nil,
+	)
+	assert.Equal(t, len(errors), 0)
+	assert.Equal(t, len(config.Errors), 0)
+	assert.DeepEqual(t, config.FileNames(), []tspath.RootedFilePath{"/shared/src/a.toml", "/project/local/b.toml"})
+}
+
+func TestContentMapperManifestExtensionValidation(t *testing.T) {
+	t.Parallel()
+	for _, extensions := range []string{`null`, `"toml"`, `[1]`, `["toml"]`, `[".ts"]`, `[".foo.ts"]`, `[".a/b"]`} {
+		t.Run(extensions, func(t *testing.T) {
+			t.Parallel()
+			fs := vfstest.FromMap(map[string]string{
+				"/project/tsconfig.json": `{"contentMappers": [{"package": "mapper"}]}`,
+				"/project/index.ts":      "",
+				"/project/node_modules/mapper/package.json": `{
+					"name": "mapper", "typescript": {"contentMapper": {"exec": ["run"], "extensions": ` + extensions + `}}
+				}`,
+			}, tspath.CaseSensitive)
+			config, errors := GetParsedCommandLineOfConfigFile(
+				"/project/tsconfig.json", &core.CompilerOptions{RunExternalCode: core.TSTrue}, nil, NewDefaultParseConfigHost(fs), nil,
+			)
+			assert.Equal(t, len(errors), 0)
+			assert.Equal(t, len(config.Errors), 1)
+			assert.Assert(t, config.Errors[0].File() != nil)
+			assert.Equal(t, len(config.ContentMapperExtensions()), 0)
+		})
+	}
+}
+
+func TestContentMapperFilteredDuplicateExtensions(t *testing.T) {
+	t.Parallel()
+	for _, definition := range []string{
+		`{"package": "mapper", "include": ["src"]}`,
+		`{"package": "mapper", "include": ["src"], "extensions": [".toml", ".toml"]}`,
+	} {
+		t.Run(definition, func(t *testing.T) {
+			t.Parallel()
+			fs := vfstest.FromMap(map[string]string{
+				"/project/tsconfig.json": `{"contentMappers": [` + definition + `]}`,
+				"/project/index.ts":      "",
+				"/project/node_modules/mapper/package.json": `{
+					"name": "mapper", "typescript": {"contentMapper": {"exec": ["run"], "extensions": [".toml", ".toml"]}}
+				}`,
+			}, tspath.CaseSensitive)
+			config, errors := GetParsedCommandLineOfConfigFile(
+				"/project/tsconfig.json", &core.CompilerOptions{RunExternalCode: core.TSTrue}, nil, NewDefaultParseConfigHost(fs), nil,
+			)
+			assert.Equal(t, len(errors), 0)
+			assert.Equal(t, len(config.Errors), 1)
+			assert.Equal(t, len(config.ContentMapperExtensions()), 1)
+		})
+	}
+}
+
+func TestContentMapperOutputExtensionConsistency(t *testing.T) {
+	t.Parallel()
+	for _, test := range []struct {
+		name                 string
+		definitions          string
+		conflict             bool
+		conflictingExtension string
+	}{
+		{
+			name: "same extension agrees",
+			definitions: `[
+				{"package": "mapper", "include": ["src"], "outputExtensions": {".vue": ".js"}},
+				{"package": "mapper", "outputExtensions": {".vue": ".js"}}
+			]`,
+		},
+		{
+			name: "same extension conflicts",
+			definitions: `[
+				{"package": "mapper", "include": ["src"], "outputExtensions": {".vue": ".js"}},
+				{"package": "mapper", "outputExtensions": {".vue": ".mjs"}}
+			]`,
+			conflict: true,
+		},
+		{
+			name: "implicit identity conflicts",
+			definitions: `[
+				{"package": "mapper"},
+				{"package": "mapper", "include": ["src"], "outputExtensions": {".vue": ".js"}}
+			]`,
+			conflict: true,
+		},
+		{
+			name: "suffix overlap produces the same name",
+			definitions: `[
+				{"package": "mapper", "extensions": [".part.vue"], "include": ["src"], "outputExtensions": {".part.vue": ".part.js"}},
+				{"package": "mapper", "outputExtensions": {".vue": ".js"}}
+			]`,
+		},
+		{
+			name: "suffix overlap produces different names",
+			definitions: `[
+				{"package": "mapper", "extensions": [".part.vue"], "include": ["src"], "outputExtensions": {".part.vue": ".js"}},
+				{"package": "mapper", "outputExtensions": {".vue": ".js"}}
+			]`,
+			conflict:             true,
+			conflictingExtension: ".part.vue",
+		},
+		{
+			name: "unfiltered overlap preserves legacy behavior",
+			definitions: `[
+				{"package": "mapper", "extensions": [".part.vue"], "outputExtensions": {".part.vue": ".js"}},
+				{"package": "mapper", "outputExtensions": {".vue": ".js"}}
+			]`,
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			fs := vfstest.FromMap(map[string]string{
+				"/project/tsconfig.json": `{"contentMappers": ` + test.definitions + `}`,
+				"/project/index.ts":      "",
+				"/project/node_modules/mapper/package.json": `{
+					"name": "mapper", "typescript": {"contentMapper": {"exec": ["run"], "extensions": [".vue"]}}
+				}`,
+			}, tspath.CaseSensitive)
+			config, errors := GetParsedCommandLineOfConfigFile(
+				"/project/tsconfig.json", &core.CompilerOptions{RunExternalCode: core.TSTrue, RewriteRelativeImportExtensions: core.TSTrue},
+				nil, NewDefaultParseConfigHost(fs), nil,
+			)
+			assert.Equal(t, len(errors), 0)
+			if test.conflict {
+				assert.Equal(t, len(config.Errors), 1)
+				assert.Assert(t, strings.Contains(config.Errors[0].Localize(locale.Default), "'outputExtensions'"))
+				assert.DeepEqual(t, config.Errors[0].MessageArgs(), []string{"mapper", core.OrElse(test.conflictingExtension, ".vue")})
+				assert.Equal(t, len(config.Errors[0].RelatedInformation()), 1)
+			} else {
+				assert.Equal(t, len(config.Errors), 0)
+			}
+		})
+	}
+}
+
+func TestContentMapperOutputConflictLocations(t *testing.T) {
+	t.Parallel()
+	for _, test := range []struct {
+		name, first, second, manifest string
+		secondPackage, secondManifest string
+		extended, unresolved          bool
+		noMapping, inheritedOutput    bool
+	}{
+		{
+			name:  "same package with disjoint includes",
+			first: `"outputExtensions": {".vue": ".js"},`, second: `"outputExtensions": {".vue": ".mjs"},`,
+		},
+		{
+			name:     "manifest default overridden in tsconfig",
+			manifest: `, "outputExtensions": {".vue": ".js"}`, second: `"outputExtensions": {".vue": ".mjs"},`,
+			inheritedOutput: true,
+		},
+		{
+			name:     "tsconfig overridden by manifest default",
+			manifest: `, "outputExtensions": {".vue": ".mjs"}`, first: `"outputExtensions": {".vue": ".js"},`,
+		},
+		{
+			name: "implicit identity", second: `"outputExtensions": {".vue": ".mjs"},`,
+			noMapping: true,
+		},
+		{
+			name:  "implicit identity on second registration",
+			first: `"outputExtensions": {".vue": ".js"},`,
+		},
+		{
+			name:  "inherited registrations",
+			first: `"outputExtensions": {".vue": ".js"},`, second: `"outputExtensions": {".vue": ".mjs"},`,
+			extended: true,
+		},
+		{
+			name:          "different package manifests",
+			manifest:      `, "outputExtensions": {".vue": ".js"}`,
+			secondPackage: "other-mapper", secondManifest: `, "outputExtensions": {".vue": ".mjs"}`,
+			inheritedOutput: true,
+		},
+		{
+			name:  "unresolved registration before conflict",
+			first: `"outputExtensions": {".vue": ".js"},`, second: `"outputExtensions": {".vue": ".mjs"},`,
+			unresolved: true,
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			secondPackage := core.OrElse(test.secondPackage, "mapper")
+			firstRegistration := `{"package": "mapper", ` + test.first + ` "include": ["src"]}`
+			secondRegistration := `{"package": "` + secondPackage + `", ` + test.second + ` "include": ["other"]}`
+			configText := `{"contentMappers": [` + firstRegistration + `,` + secondRegistration + `]}`
+			if test.unresolved {
+				configText = strings.Replace(configText, `"contentMappers": [`, `"contentMappers": [{"package": "missing", "extensions": [".test"]},`, 1)
+			}
+			files := map[string]string{
+				"/project/tsconfig.json": configText,
+				"/project/index.ts":      "",
+				"/project/node_modules/mapper/package.json": `{
+					"name": "mapper", "typescript": {"contentMapper": {"exec": ["run"], "extensions": [".vue"]` + test.manifest + `}}
+				}`,
+			}
+			if test.secondPackage != "" {
+				files["/project/node_modules/"+secondPackage+"/package.json"] = `{
+					"name": "` + secondPackage + `", "typescript": {"contentMapper": {"exec": ["run"], "extensions": [".vue"]` + test.secondManifest + `}}
+				}`
+			}
+			configPath := tspath.RootedFilePath("/project/tsconfig.json")
+			if test.extended {
+				files["/shared/base.json"] = configText
+				files[configPath.AsString()] = `{"extends": "../shared/base.json"}`
+				configPath = "/shared/base.json"
+			}
+			fs := vfstest.FromMap(files, tspath.CaseSensitive)
+			config, errors := GetParsedCommandLineOfConfigFile(
+				"/project/tsconfig.json", &core.CompilerOptions{RunExternalCode: core.TSTrue, RewriteRelativeImportExtensions: core.TSTrue},
+				nil, NewDefaultParseConfigHost(fs), nil,
+			)
+			assert.Equal(t, len(errors), 0)
+			assert.Equal(t, len(config.Errors), core.IfElse(test.unresolved, 2, 1))
+			diagnostic := config.Errors[len(config.Errors)-1]
+			assert.DeepEqual(t, diagnostic.MessageArgs(), []string{"mapper", ".vue"})
+			mappingDescription := "a conflicting 'outputExtensions' mapping"
+			if test.noMapping {
+				mappingDescription = "no 'outputExtensions' mapping"
+			}
+			assert.Equal(t, diagnostic.Localize(locale.Default), "Content mapper 'mapper' is also registered for the extension '.vue', but has "+mappingDescription+". Each registration for this extension must produce the same output file name.")
+			assert.Equal(t, len(diagnostic.RelatedInformation()), 1)
+			related := diagnostic.RelatedInformation()[0]
+			assert.Equal(t, len(related.MessageArgs()), 0)
+			relatedText := "The conflicting mapper registration is declared here."
+			if test.inheritedOutput {
+				relatedText += " Its 'outputExtensions' setting is inherited from the mapper's package.json."
+			}
+			assert.Equal(t, related.Localize(locale.Default), relatedText)
+			for _, location := range []struct {
+				diagnostic *ast.Diagnostic
+				text       string
+			}{
+				{diagnostic, secondRegistration},
+				{related, firstRegistration},
+			} {
+				assert.Assert(t, location.diagnostic.File() != nil)
+				assert.Equal(t, location.diagnostic.File().FileName(), configPath)
+				assert.Equal(t, location.diagnostic.File().Text()[location.diagnostic.Pos():location.diagnostic.End()], location.text)
+			}
+		})
+	}
+}
+
+func TestContentMapperIncludeAndManifestExtensions(t *testing.T) {
+	t.Parallel()
+	fs := vfstest.FromMap(map[string]string{
+		"/project/tsconfig.json": `{
+				"compilerOptions": { "noLib": true },
+				"contentMappers": [
+					{ "package": "mapper", "include": ["src", "**/blob.toml"] }
+				]
+			}`,
+		"/project/node_modules/mapper/package.json": `{
+				"name": "mapper",
+				"typescript": { "contentMapper": { "exec": ["run"], "extensions": [".toml"] } }
+			}`,
+		"/project/src/config.toml":             "",
+		"/project/src/.hidden/config.toml":     "",
+		"/project/blob.toml":                   "",
+		"/project/other.toml":                  "",
+		"/project/index.ts":                    "",
+		"/project/node_modules/pkg/blob.toml":  "",
+		"/project/node_modules/pkg/other.toml": "",
+	}, tspath.CaseSensitive)
+	commandLine, errors := GetParsedCommandLineOfConfigFile(
+		"/project/tsconfig.json",
+		&core.CompilerOptions{RunExternalCode: core.TSTrue}, nil,
+		NewDefaultParseConfigHost(fs), nil,
+	)
+	assert.Equal(t, len(errors), 0)
+	assert.Equal(t, len(commandLine.GetConfigFileParsingDiagnostics()), 0)
+	assert.DeepEqual(t, commandLine.ContentMapperExtensions(), []string{".toml"})
+	assert.DeepEqual(t, commandLine.FileNames(), []tspath.RootedFilePath{
+		"/project/blob.toml", "/project/index.ts", "/project/src/config.toml",
+	})
+	for _, file := range []tspath.RootedFilePath{
+		"/project/src/config.toml", "/project/src/.hidden/config.toml",
+		"/project/blob.toml", "/project/node_modules/pkg/blob.toml",
+	} {
+		assert.Assert(t, commandLine.GetContentMapperForFileName(file) != nil, file)
+	}
+	for _, file := range []tspath.RootedFilePath{
+		"/project/other.toml", "/project/node_modules/pkg/other.toml", "/project/src/file.ts",
+	} {
+		assert.Assert(t, commandLine.GetContentMapperForFileName(file) == nil, file)
+	}
+}
+
+func TestContentMapperIncludePrecedence(t *testing.T) {
+	t.Parallel()
+	fallback := &contentmapper.Mapper{Extensions: []string{".toml"}}
+	first := &contentmapper.Mapper{Extensions: []string{".config.toml"}, Include: []string{"src"}}
+	second := &contentmapper.Mapper{Extensions: []string{".toml"}, Include: []string{"**/blob.config.toml"}}
+	commandLine := NewParsedCommandLine(&core.CompilerOptions{}, nil, nil, "/project", tspath.CaseSensitive)
+	commandLine.ParsedConfig.ContentMappers = []*contentmapper.Mapper{fallback, first, second}
+	assert.Equal(t, commandLine.GetContentMapperForFileName("/project/src/blob.config.toml"), first)
+	assert.Equal(t, commandLine.GetContentMapperForFileName("/project/blob.config.toml"), second)
+	assert.Equal(t, commandLine.GetContentMapperForFileName("/project/other.toml"), fallback)
+}
+
+func TestContentMapperIncludeReloadAndEmptyFilter(t *testing.T) {
+	t.Parallel()
+	for _, include := range []string{`["src"]`, `[]`} {
+		t.Run(include, func(t *testing.T) {
+			t.Parallel()
+			fs := vfstest.FromMap(map[string]string{
+				"/project/tsconfig.json": `{
+						"compilerOptions": {"noLib": true},
+						"contentMappers": [{"package": "mapper", "extensions": [".toml"], "include": ` + include + `}]
+					}`,
+				"/project/index.ts":   "",
+				"/project/src/a.toml": "",
+				"/project/other.toml": "",
+				"/project/node_modules/mapper/package.json": `{
+						"name": "mapper", "typescript": {"contentMapper": {"exec": ["run"], "extensions": [".vue"]}}
+					}`,
+			}, tspath.CaseSensitive)
+			config, errors := GetParsedCommandLineOfConfigFile("/project/tsconfig.json", &core.CompilerOptions{RunExternalCode: core.TSTrue}, nil, NewDefaultParseConfigHost(fs), nil)
+			assert.Equal(t, len(errors), 0)
+			assert.Equal(t, len(config.Errors), 0)
+			assert.DeepEqual(t, config.ContentMapperExtensions(), []string{".toml"})
+			assert.DeepEqual(t, config.ReloadFileNamesOfParsedCommandLine(fs).FileNames(), config.FileNames())
+			assert.Assert(t, !slices.Contains(config.FileNames(), "/project/other.toml"))
+			assert.Equal(t, slices.Contains(config.FileNames(), "/project/src/a.toml"), include != `[]`)
+		})
+	}
+}
+
 func TestGetOutputFileNamesExcludesMapperOwnedOutputs(t *testing.T) {
 	t.Parallel()
 	mapper := &contentmapper.Mapper{Extensions: []string{".vue"}}
@@ -59,6 +412,24 @@ func TestGetOutputFileNamesExcludesMapperOwnedOutputs(t *testing.T) {
 	assert.DeepEqual(t, slices.Collect(commandLine.GetOutputFileNames()), []tspath.RootedFilePath{"/dist/Component.d.vue.ts"})
 }
 
+func TestContentMapperOutputPathsUseWinningMapper(t *testing.T) {
+	t.Parallel()
+	config := NewParsedCommandLine(
+		&core.CompilerOptions{Declaration: core.TSTrue, OutDir: "/dist"},
+		[]tspath.RootedFilePath{"/project/src/a.config.toml", "/project/other/b.config.toml"},
+		nil, "/project", tspath.CaseSensitive,
+	)
+	config.ParsedConfig.ContentMappers = []*contentmapper.Mapper{
+		{Extensions: []string{".toml"}, OutputExtensions: map[string]string{".toml": ".js"}},
+		{Extensions: []string{".config.toml"}, Include: []string{"src"}},
+	}
+	assert.Equal(t, config.ContentMapperExtensionForFileName("/project/src/a.config.toml"), ".config.toml")
+	assert.Equal(t, config.ContentMapperExtensionForFileName("/project/other/b.config.toml"), ".toml")
+	assert.DeepEqual(t, slices.Collect(config.GetOutputFileNames()), []tspath.RootedFilePath{
+		"/dist/src/a.d.config.toml.ts", "/dist/other/b.config.d.ts",
+	})
+}
+
 func TestContentMapperExtensionRewritesPreserveLongestExtension(t *testing.T) {
 	t.Parallel()
 	mapper := &contentmapper.Mapper{
diff --git a/tsc/internal/tsoptions/parsedcommandline.go b/tsc/internal/tsoptions/parsedcommandline.go
index e5ada392c3033..60e3450b93466 100644
--- a/tsc/internal/tsoptions/parsedcommandline.go
+++ b/tsc/internal/tsoptions/parsedcommandline.go
@@ -75,6 +75,8 @@ type ParsedCommandLine struct {
 
 	contentMapperExtensionRewrites     []tspath.ExtensionRewrite
 	contentMapperExtensionRewritesOnce sync.Once
+	contentMapperFileMatcherOnce       sync.Once
+	contentMapperFileMatcher           *contentmapper.FileMatcher
 
 	locale     locale.Locale
 	localeOnce sync.Once
@@ -394,9 +396,10 @@ func (p *ParsedCommandLine) ContentMappers() []*contentmapper.Mapper {
 // ContentMapperExtensions returns the flattened list of file extensions registered by the
 // config's content mappers.
 func (p *ParsedCommandLine) ContentMapperExtensions() []string {
-	return core.FlatMap(p.ContentMappers(), func(m *contentmapper.Mapper) []string {
+	extensions := core.FlatMap(p.ContentMappers(), func(m *contentmapper.Mapper) []string {
 		return m.Definition.Extensions
 	})
+	return core.Deduplicate(extensions)
 }
 
 func (p *ParsedCommandLine) ContentMapperExtensionRewrites() []tspath.ExtensionRewrite {
@@ -447,19 +450,21 @@ func getContentMapperOutputExtension(outputExtensions map[string]string, sourceE
 	return "", false
 }
 
-// GetContentMapperForFileName returns the configured content mapper whose extensions include fileName,
-// or nil if no content mapper is registered for the file's extension.
+// GetContentMapperForFileName selects a mapper without executing it. Explicit include filters take
+// precedence over extension-only registrations; otherwise preserve longest-extension matching.
 func (p *ParsedCommandLine) GetContentMapperForFileName(fileName tspath.RootedFilePath) *contentmapper.Mapper {
-	caseSensitivity := p.CaseSensitivity()
-	extension := fileName.LongestExtension(p.ContentMapperExtensions(), caseSensitivity)
-	for _, mapper := range p.ContentMappers() {
-		if slices.ContainsFunc(mapper.Definition.Extensions, func(mapperExtension string) bool {
-			return extension == mapperExtension || caseSensitivity.IsCaseInsensitive() && strings.EqualFold(extension, mapperExtension)
-		}) {
-			return mapper
-		}
-	}
-	return nil
+	return p.ContentMapperFileMatcher().GetMapperForFileName(fileName)
+}
+
+func (p *ParsedCommandLine) ContentMapperFileMatcher() *contentmapper.FileMatcher {
+	p.contentMapperFileMatcherOnce.Do(func() {
+		p.contentMapperFileMatcher = contentmapper.NewFileMatcher(p.ContentMappers(), p.baseDirectory, p.CaseSensitivity())
+	})
+	return p.contentMapperFileMatcher
+}
+
+func (p *ParsedCommandLine) ContentMapperExtensionForFileName(fileName tspath.RootedFilePath) string {
+	return p.ContentMapperFileMatcher().ExtensionForFileName(fileName)
 }
 
 func (p *ParsedCommandLine) ResolvedProjectReferencePaths() []tspath.RootedFilePath {
@@ -559,6 +564,7 @@ func (p *ParsedCommandLine) ReloadFileNamesOfParsedCommandLine(fs vfs.FS) *Parse
 		p.CompilerOptions(),
 		fs,
 		p.ContentMapperExtensions(),
+		p.ContentMapperFileMatcher(),
 	)
 	parsedConfig.FileNames = fileNames
 	parsedCommandLine := ParsedCommandLine{
diff --git a/tsc/internal/tsoptions/parsedoptions_test.go b/tsc/internal/tsoptions/parsedoptions_test.go
index 3bfd5dc5ee81e..1a979d1ee6986 100644
--- a/tsc/internal/tsoptions/parsedoptions_test.go
+++ b/tsc/internal/tsoptions/parsedoptions_test.go
@@ -32,13 +32,14 @@ func TestParsedOptionsEquality(t *testing.T) {
 				{Path: "/project", OriginalPath: "../project", Circular: true}, nil,
 			},
 			ContentMappers: []*contentmapper.Mapper{{
-				Package: "mapper", Extensions: []string{".vue"}, Options: []byte(`{"setting":true}`),
+				Package: "mapper", Extensions: []string{".vue"}, Include: []string{"src"}, Options: []byte(`{"setting":true}`),
 				Name: "mapper", Version: "1", Exec: []string{"node", "mapper.js"}, CompilerOptions: []string{"target"}, DynamicConfig: true,
 				PackageDirectory: "/node_modules/mapper", ContributionID: "extension",
 			}, nil},
 		}
 		result.ContentMappers[0].Definition.OutputExtensions = map[string]string{".vue": ".mjs"}
 		result.ContentMappers[0].Manifest.DefaultOutputExtensions = map[string]string{".vue": ".js"}
+		result.ContentMappers[0].Manifest.DefaultExtensions = []string{".vue"}
 		return result
 	}
 	check(t, makeOptions(), makeOptions())
@@ -88,6 +89,8 @@ func TestParsedOptionsEquality(t *testing.T) {
 		}},
 		{"mapper package", func(p *ParsedOptions) { p.ContentMappers[0].Package = "other" }},
 		{"mapper extension", func(p *ParsedOptions) { p.ContentMappers[0].Extensions[0] = ".other" }},
+		{"mapper include", func(p *ParsedOptions) { p.ContentMappers[0].Include[0] = "other" }},
+		{"manifest extension", func(p *ParsedOptions) { p.ContentMappers[0].DefaultExtensions[0] = ".other" }},
 		{"mapper output extension", func(p *ParsedOptions) { p.ContentMappers[0].Definition.OutputExtensions[".vue"] = ".js" }},
 		{"mapper options", func(p *ParsedOptions) { p.ContentMappers[0].Options = []byte(`{}`) }},
 		{"mapper name", func(p *ParsedOptions) { p.ContentMappers[0].Name = "other" }},
diff --git a/tsc/internal/tsoptions/parsinghelpers.go b/tsc/internal/tsoptions/parsinghelpers.go
index a4fa63f7ced5f..9425ce8d42bb1 100644
--- a/tsc/internal/tsoptions/parsinghelpers.go
+++ b/tsc/internal/tsoptions/parsinghelpers.go
@@ -157,8 +157,13 @@ func parseContentMapper(value any) (*contentmapper.Mapper, []*ast.Diagnostic) {
 		} else {
 			errors = append(errors, ast.NewCompilerDiagnostic(diagnostics.Compiler_option_0_requires_a_value_of_type_1, "contentMapper.extensions", "string[]"))
 		}
-	} else {
-		errors = append(errors, ast.NewCompilerDiagnostic(diagnostics.Compiler_option_0_requires_a_value_of_type_1, "contentMapper.extensions", "string[]"))
+	}
+	if include, ok := v.Get("include"); ok {
+		if strs, isStringArray := parseStringArrayStrict(include); isStringArray {
+			mapper.Include = strs
+		} else {
+			errors = append(errors, ast.NewCompilerDiagnostic(diagnostics.Compiler_option_0_requires_a_value_of_type_1, "contentMapper.include", "string[]"))
+		}
 	}
 	if outputExtensions, ok := v.Get("outputExtensions"); ok && outputExtensions != nil {
 		if values, isStringMap := parseStringStringMapStrict(outputExtensions); isStringMap {
diff --git a/tsc/internal/tsoptions/tsconfigparsing.go b/tsc/internal/tsoptions/tsconfigparsing.go
index f2ea2fdc07f73..f8880844c6819 100644
--- a/tsc/internal/tsoptions/tsconfigparsing.go
+++ b/tsc/internal/tsoptions/tsconfigparsing.go
@@ -25,13 +25,14 @@ import (
 )
 
 type extendsResult struct {
-	options             *parsedCompilerOptions
-	include             []any
-	exclude             []any
-	files               []any
-	contentMappers      []any
-	compileOnSave       bool
-	extendedSourceFiles collections.Set[tspath.RootedFilePath]
+	options                 *parsedCompilerOptions
+	include                 []any
+	exclude                 []any
+	files                   []any
+	contentMappers          []any
+	contentMapperSourceFile *ast.SourceFile
+	compileOnSave           bool
+	extendedSourceFiles     collections.Set[tspath.RootedFilePath]
 }
 
 type configFileSpecs struct {
@@ -85,10 +86,11 @@ func (e *ExtendedConfigCacheEntry) ExtendedFileNames() []tspath.RootedFilePath {
 }
 
 type parsedTsconfig struct {
-	raw                 any
-	options             *parsedCompilerOptions
-	typeAcquisition     *core.TypeAcquisition
-	extendedConfigPaths []tspath.RootedFilePath
+	raw                     any
+	options                 *parsedCompilerOptions
+	typeAcquisition         *core.TypeAcquisition
+	extendedConfigPaths     []tspath.RootedFilePath
+	contentMapperSourceFile *ast.SourceFile
 }
 
 type parsedCompilerOptions struct {
@@ -1031,6 +1033,7 @@ func parseConfig(
 		ownConfig, err = parseOwnConfigOfJsonSourceFile(tsconfigToSourceFile(sourceFile), fs, basePath, configFileName)
 	}
 	errors = append(errors, err...)
+	ownConfig.contentMapperSourceFile = tsconfigToSourceFile(sourceFile)
 	if ownConfig.options != nil && ownConfig.options.Paths != nil {
 		// If we end up needing to resolve relative paths from 'paths' relative to
 		// the config file location, we'll need to know where that config file was.
@@ -1045,6 +1048,18 @@ func parseConfig(
 		if extendedConfig != nil && extendedConfig.options != nil {
 			extendsRaw := extendedConfig.raw
 			relativeDifference := ""
+			rebaseExtendedSpecs := func(specs []any) []any {
+				return core.Map(specs, func(value any) any {
+					spec, isString := value.(string)
+					if !isString || startsWithConfigDirTemplate(spec) || tspath.IsRootedDiskPath(spec) {
+						return value
+					}
+					if relativeDifference == "" {
+						relativeDifference = tspath.ConvertToRelativePath(extendedConfigPath.Directory().AsString(), basePath, caseSensitivity)
+					}
+					return tspath.CombinePaths(relativeDifference, spec)
+				})
+			}
 			setPropertyValue := func(propertyName string) {
 				if rawMap, ok := ownConfig.raw.(*collections.OrderedMap[string, any]); ok && rawMap.Has(propertyName) {
 					return
@@ -1052,24 +1067,7 @@ func parseConfig(
 				if propertyName == "include" || propertyName == "exclude" || propertyName == "files" {
 					if rawMap, ok := extendsRaw.(*collections.OrderedMap[string, any]); ok && rawMap.Has(propertyName) {
 						if slice, _ := rawMap.GetOrZero(propertyName).([]any); slice != nil {
-							value := core.Map(slice, func(path any) any {
-								pathStr, isString := path.(string)
-								if !isString {
-									return path
-								}
-								if startsWithConfigDirTemplate(pathStr) || tspath.IsRootedDiskPath(pathStr) {
-									return pathStr
-								} else {
-									if relativeDifference == "" {
-										relativeDifference = tspath.ConvertToRelativePath(
-											extendedConfigPath.Directory().AsString(),
-											basePath,
-											caseSensitivity,
-										)
-									}
-									return tspath.CombinePaths(relativeDifference, pathStr)
-								}
-							})
+							value := rebaseExtendedSpecs(slice)
 							if propertyName == "include" {
 								result.include = value
 							} else if propertyName == "exclude" {
@@ -1086,7 +1084,21 @@ func parseConfig(
 			setPropertyValue("exclude")
 			setPropertyValue("files")
 			if extendedRawMap, ok := extendsRaw.(*collections.OrderedMap[string, any]); ok && extendedRawMap.Has("contentMappers") {
+				result.contentMapperSourceFile = extendedConfig.contentMapperSourceFile
 				result.contentMappers, _ = extendedRawMap.GetOrZero("contentMappers").([]any)
+				result.contentMappers = core.Map(result.contentMappers, func(value any) any {
+					mapper, isMapper := value.(*collections.OrderedMap[string, any])
+					if !isMapper {
+						return value
+					}
+					include, hasInclude := mapper.GetOrZero("include").([]any)
+					if !hasInclude {
+						return value
+					}
+					mapper = mapper.Clone()
+					mapper.Set("include", rebaseExtendedSpecs(include))
+					return mapper
+				})
 			}
 			if extendedRawMap, ok := extendsRaw.(*collections.OrderedMap[string, any]); ok && extendedRawMap.Has("compileOnSave") {
 				if compileOnSave, ok := extendedRawMap.GetOrZero("compileOnSave").(bool); ok {
@@ -1120,6 +1132,7 @@ func parseConfig(
 		}
 		if result.contentMappers != nil && !ownConfig.raw.(*collections.OrderedMap[string, any]).Has("contentMappers") {
 			ownConfig.raw.(*collections.OrderedMap[string, any]).Set("contentMappers", result.contentMappers)
+			ownConfig.contentMapperSourceFile = result.contentMapperSourceFile
 		}
 		if result.compileOnSave && !ownConfig.raw.(*collections.OrderedMap[string, any]).Has("compileOnSave") {
 			ownConfig.raw.(*collections.OrderedMap[string, any]).Set("compileOnSave", result.compileOnSave)
@@ -1320,12 +1333,13 @@ func parseJsonConfigFileContentWorker(
 		sourceFile.configFileSpecs = &configFileSpecs
 	}
 
-	var contentMapperSourceFile *ast.SourceFile
-	if sourceFile != nil {
-		contentMapperSourceFile = sourceFile.SourceFile
-	}
+	contentMapperSourceFile := parsedConfig.contentMapperSourceFile
 	var contentMappers []*contentmapper.Mapper
-	var contentMapperIndices []int
+	contentMapperIndices := make(map[*contentmapper.Mapper]int)
+	containingFile := configFileName
+	if containingFile == "" {
+		containingFile = basePathForFileNames.ResolveFile("tsconfig.json")
+	}
 	contentMappersOfRaw := getPropFromRaw("contentMappers", func(element any) bool { return reflect.TypeOf(element) == orderedMapType }, "object")
 	for i, element := range contentMappersOfRaw.sliceValue {
 		mapper, mapperErrors := parseContentMapper(element)
@@ -1333,8 +1347,38 @@ func parseJsonConfigFileContentWorker(
 			errors = append(errors, setContentMapperDiagnosticLocation(mapperError, contentMapperSourceFile, getContentMapperSyntax(contentMapperSourceFile, i, "")))
 		}
 		if mapper != nil {
+			rawMapper := element.(*collections.OrderedMap[string, any])
+			if parsedConfig.options != nil && parsedConfig.options.RunExternalCode.IsTrue() {
+				manifest, packageDirectory, diagnostic := resolveContentMapperManifest(host, containingFile, mapper.Package)
+				mapper.PackageDirectory = packageDirectory
+				if diagnostic != nil {
+					errors = append(errors, setContentMapperDiagnosticLocation(diagnostic, contentMapperSourceFile, getContentMapperSyntax(contentMapperSourceFile, i, "package")))
+				} else {
+					mapper.Manifest = manifest
+					if mapper.Extensions == nil {
+						mapper.Extensions = slices.Clone(manifest.DefaultExtensions)
+						if mapper.Extensions == nil {
+							errors = append(errors, setContentMapperDiagnosticLocation(ast.NewCompilerDiagnostic(
+								diagnostics.Content_mapper_0_must_specify_extensions_in_tsconfig_or_its_package_manifest, mapper.Package,
+							), contentMapperSourceFile, getContentMapperSyntax(contentMapperSourceFile, i, "package")))
+							continue
+						}
+					}
+					if !rawMapper.Has("outputExtensions") {
+						mapper.Definition.OutputExtensions = maps.Clone(manifest.DefaultOutputExtensions)
+					}
+				}
+			}
+			for _, spec := range mapper.Include {
+				if diagnostic := specToDiagnostic(spec, true, basePathForFileNames); diagnostic != nil {
+					errors = append(errors, setContentMapperDiagnosticLocation(ast.NewCompilerDiagnostic(diagnostic, spec), contentMapperSourceFile, getContentMapperSyntax(contentMapperSourceFile, i, "include")))
+				}
+			}
+			if substituted := getSubstitutedStringArrayWithConfigDirTemplate(mapper.Include, basePathForFileNames); substituted != nil {
+				mapper.Include = substituted
+			}
 			contentMappers = append(contentMappers, mapper)
-			contentMapperIndices = append(contentMapperIndices, i)
+			contentMapperIndices[mapper] = i
 		}
 	}
 	totalContentMapperExtensions := 0
@@ -1346,10 +1390,16 @@ func parseJsonConfigFileContentWorker(
 	canonicalExtension := func(extension string) string {
 		return fs.CaseSensitivity().Canonicalize(extension)
 	}
-	for j, mapper := range contentMappers {
+	for _, mapper := range contentMappers {
+		index := contentMapperIndices[mapper]
+		rawMapper := contentMappersOfRaw.sliceValue[index].(*collections.OrderedMap[string, any])
 		validExtensions := make([]string, 0, len(mapper.Definition.Extensions))
+		seenMapperExtensions := make(map[string]struct{}, len(mapper.Definition.Extensions))
 		for _, ext := range mapper.Definition.Extensions {
-			extNode := getContentMapperExtensionSyntax(contentMapperSourceFile, contentMapperIndices[j], ext)
+			extNode := getContentMapperExtensionSyntax(contentMapperSourceFile, index, ext)
+			if !rawMapper.Has("extensions") {
+				extNode = getContentMapperSyntax(contentMapperSourceFile, index, "package")
+			}
 			canonicalExt := canonicalExtension(ext)
 			switch {
 			case !strings.HasPrefix(ext, "."):
@@ -1359,10 +1409,15 @@ func parseJsonConfigFileContentWorker(
 			case contentmapper.HasReservedSourceExtension(ext):
 				errors = append(errors, setContentMapperDiagnosticLocation(ast.NewCompilerDiagnostic(diagnostics.Content_mapper_file_extension_0_is_a_built_in_extension_and_cannot_be_registered_by_a_content_mapper, ext), contentMapperSourceFile, extNode))
 			default:
-				if _, seen := seenContentMapperExtensions[canonicalExt]; seen {
+				_, seenByMapper := seenMapperExtensions[canonicalExt]
+				_, seenByFallback := seenContentMapperExtensions[canonicalExt]
+				if seenByMapper || seenByFallback && mapper.Include == nil {
 					errors = append(errors, setContentMapperDiagnosticLocation(ast.NewCompilerDiagnostic(diagnostics.Content_mapper_file_extension_0_is_registered_by_more_than_one_content_mapper, ext), contentMapperSourceFile, extNode))
 				} else {
-					seenContentMapperExtensions[canonicalExt] = struct{}{}
+					seenMapperExtensions[canonicalExt] = struct{}{}
+					if mapper.Include == nil {
+						seenContentMapperExtensions[canonicalExt] = struct{}{}
+					}
 					contentMapperExtensions = append(contentMapperExtensions, ext)
 					validExtensions = append(validExtensions, ext)
 				}
@@ -1371,7 +1426,7 @@ func parseJsonConfigFileContentWorker(
 		mapper.Definition.Extensions = validExtensions
 		for _, sourceExtension := range slices.Sorted(maps.Keys(mapper.Definition.OutputExtensions)) {
 			outputExtension := mapper.Definition.OutputExtensions[sourceExtension]
-			outputExtensionsNode := getContentMapperSyntax(contentMapperSourceFile, contentMapperIndices[j], "outputExtensions")
+			outputExtensionsNode := getContentMapperSyntax(contentMapperSourceFile, index, "outputExtensions")
 			if strings.ContainsAny(sourceExtension, "/\\") {
 				errors = append(errors, setContentMapperDiagnosticLocation(ast.NewCompilerDiagnostic(diagnostics.Content_mapper_extension_0_must_not_contain_path_separators, sourceExtension), contentMapperSourceFile, outputExtensionsNode))
 			} else if !contentmapper.IsValidExtension(sourceExtension) {
@@ -1382,7 +1437,7 @@ func parseJsonConfigFileContentWorker(
 			} else if !contentmapper.IsValidExtension(outputExtension) {
 				errors = append(errors, setContentMapperDiagnosticLocation(ast.NewCompilerDiagnostic(diagnostics.Content_mapper_output_extension_0_must_be_non_empty_and_begin_with_a, outputExtension), contentMapperSourceFile, outputExtensionsNode))
 			}
-			if !slices.ContainsFunc(validExtensions, func(extension string) bool {
+			if rawMapper.Has("outputExtensions") && !slices.ContainsFunc(validExtensions, func(extension string) bool {
 				return canonicalExtension(extension) == canonicalExtension(sourceExtension)
 			}) {
 				errors = append(errors, setContentMapperDiagnosticLocation(ast.NewCompilerDiagnostic(diagnostics.Content_mapper_output_extension_mapping_source_0_is_not_registered_by_this_content_mapper, sourceExtension), contentMapperSourceFile, outputExtensionsNode))
@@ -1396,25 +1451,12 @@ func parseJsonConfigFileContentWorker(
 		contentMappers = nil
 		contentMapperExtensions = nil
 	} else if len(contentMappers) > 0 {
-		// Resolve each mapper's package.json now so its name, version, and run command are available to
-		// everything downstream (diagnostics, build-info staleness) without executing anything.
-		containingFile := configFileName
-		if containingFile == "" {
-			containingFile = basePathForFileNames.ResolveFile("tsconfig.json")
-		}
 		resolvedContentMappers := make([]*contentmapper.Mapper, 0, len(contentMappers))
-		for j, mapper := range contentMappers {
-			manifest, packageDirectory, diagnostic := resolveContentMapperManifest(host, containingFile, mapper.Package)
-			mapper.PackageDirectory = packageDirectory
-			if diagnostic != nil {
-				errors = append(errors, setContentMapperDiagnosticLocation(diagnostic, contentMapperSourceFile, getContentMapperSyntax(contentMapperSourceFile, contentMapperIndices[j], "package")))
+		for _, mapper := range contentMappers {
+			if mapper.Name == "" {
+				// Manifest resolution failed.
 				continue
 			}
-			mapper.Manifest = manifest
-			rawMapper := contentMappersOfRaw.sliceValue[contentMapperIndices[j]].(*collections.OrderedMap[string, any])
-			if _, present := rawMapper.Get("outputExtensions"); !present {
-				mapper.Definition.OutputExtensions = maps.Clone(manifest.DefaultOutputExtensions)
-			}
 			for _, sourceExtension := range mapper.Definition.Extensions {
 				outputExtension, ok := getContentMapperOutputExtension(mapper.Definition.OutputExtensions, sourceExtension, fs.CaseSensitivity().IsCaseInsensitive())
 				identity := sourceExtension == outputExtension || fs.CaseSensitivity().IsCaseInsensitive() && strings.EqualFold(sourceExtension, outputExtension)
@@ -1422,7 +1464,7 @@ func parseJsonConfigFileContentWorker(
 					errors = append(errors, setContentMapperDiagnosticLocation(
 						ast.NewCompilerDiagnostic(diagnostics.Content_mapper_output_extension_mapping_from_0_to_1_requires_rewriteRelativeImportExtensions_to_be_enabled, sourceExtension, outputExtension),
 						contentMapperSourceFile,
-						getContentMapperSyntax(contentMapperSourceFile, contentMapperIndices[j], ""),
+						getContentMapperSyntax(contentMapperSourceFile, contentMapperIndices[mapper], ""),
 					))
 				}
 			}
@@ -1433,10 +1475,61 @@ func parseJsonConfigFileContentWorker(
 			return mapper.Definition.Extensions
 		})
 	}
+	type extensionOutput struct {
+		extension, output string
+		mapper            *contentmapper.Mapper
+		mapped            bool
+	}
+	var extensionOutputs []extensionOutput
+	for _, mapper := range contentMappers {
+		for _, extension := range mapper.Extensions {
+			output, ok := getContentMapperOutputExtension(mapper.Definition.OutputExtensions, extension, fs.CaseSensitivity().IsCaseInsensitive())
+			if !ok {
+				output = extension
+			}
+			extensionOutputs = append(extensionOutputs, extensionOutput{
+				extension: canonicalExtension(extension), output: canonicalExtension(output), mapper: mapper, mapped: ok,
+			})
+		}
+	}
+	for i, extension := range extensionOutputs {
+		for _, other := range extensionOutputs[i+1:] {
+			longer, shorter := extension, other
+			if len(longer.extension) < len(shorter.extension) {
+				longer, shorter = shorter, longer
+			}
+			if !strings.HasSuffix(longer.extension, shorter.extension) || longer.mapper.Include == nil && shorter.mapper.Include == nil {
+				continue
+			}
+			// A runtime rewrite cannot select an include filter. Compare resulting names:
+			// .part.vue -> .js and .vue -> .js remove different amounts of the source name.
+			if longer.output != strings.TrimSuffix(longer.extension, shorter.extension)+shorter.output {
+				message := diagnostics.Content_mapper_0_is_also_registered_for_the_extension_1_but_has_a_conflicting_outputExtensions_mapping_Each_registration_for_this_extension_must_produce_the_same_output_file_name
+				if !extension.mapped {
+					message = diagnostics.Content_mapper_0_is_also_registered_for_the_extension_1_but_has_no_outputExtensions_mapping_Each_registration_for_this_extension_must_produce_the_same_output_file_name
+				}
+				index := contentMapperIndices[extension.mapper]
+				rawMapper := contentMappersOfRaw.sliceValue[index].(*collections.OrderedMap[string, any])
+				relatedMessage := diagnostics.The_conflicting_mapper_registration_is_declared_here
+				if extension.mapped && !rawMapper.Has("outputExtensions") {
+					relatedMessage = diagnostics.The_conflicting_mapper_registration_is_declared_here_Its_outputExtensions_setting_is_inherited_from_the_mapper_s_package_json
+				}
+				diagnostic := setContentMapperDiagnosticLocation(ast.NewCompilerDiagnostic(
+					message, extension.mapper.Package, extension.extension,
+				), contentMapperSourceFile, getContentMapperSyntax(contentMapperSourceFile, contentMapperIndices[other.mapper], ""))
+				diagnostic.AddRelatedInfo(setContentMapperDiagnosticLocation(ast.NewCompilerDiagnostic(
+					relatedMessage,
+				), contentMapperSourceFile, getContentMapperSyntax(contentMapperSourceFile, index, "")))
+				errors = append(errors, diagnostic)
+			}
+		}
+	}
 
+	contentMapperExtensions = core.Deduplicate(contentMapperExtensions)
+	mapperMatcher := contentmapper.NewFileMatcher(contentMappers, basePathForFileNames, fs.CaseSensitivity())
 	getFileNames := func(basePath tspath.RootedDirectoryPath) ([]tspath.RootedFilePath, int) {
 		parsedConfigOptions := parsedConfig.options
-		fileNames, literalFileNamesLen := getFileNamesFromConfigSpecs(configFileSpecs, basePath, parsedConfigOptions.CompilerOptions, fs, contentMapperExtensions)
+		fileNames, literalFileNamesLen := getFileNamesFromConfigSpecs(configFileSpecs, basePath, parsedConfigOptions.CompilerOptions, fs, contentMapperExtensions, mapperMatcher)
 		if shouldReportNoInputFiles(fileNames, canJsonReportNoInputFiles(rawConfig), resolutionStack) {
 			includeSpecs := configFileSpecs.includeSpecs
 			excludeSpecs := configFileSpecs.excludeSpecs
@@ -1877,6 +1970,7 @@ func getFileNamesFromConfigSpecs(
 	options *core.CompilerOptions,
 	host vfs.FS,
 	extraExtensions []string,
+	mapperMatcher *contentmapper.FileMatcher,
 ) ([]tspath.RootedFilePath, int) {
 	keyMapper := func(fileName tspath.RootedFilePath) tspath.PathKey {
 		return host.CaseSensitivity().PathKey(fileName.AsPath())
@@ -1904,6 +1998,9 @@ func getFileNamesFromConfigSpecs(
 	// Literal files are always included verbatim. An "include" or "exclude" specification cannot
 	// remove a literal file.
 	for i := range validatedFilesSpec {
+		if mapperMatcher.IsUnclaimed(validatedFileNames[i]) {
+			continue
+		}
 		literalFileMap.Set(keyMapper(validatedFileNames[i]), validatedFileNames[i])
 	}
 
@@ -1911,6 +2008,9 @@ func getFileNamesFromConfigSpecs(
 	if len(validatedIncludeSpecs) > 0 {
 		files := vfsmatch.ReadDirectory(host, basePath, core.Flatten(supportedExtensionsWithJsonIfResolveJsonModule), validatedExcludeSpecs, validatedIncludeSpecs, vfsmatch.UnlimitedDepth)
 		for _, file := range files {
+			if mapperMatcher.IsUnclaimed(file) {
+				continue
+			}
 			if file.ExtensionIs(tspath.ExtensionJson) {
 				if jsonOnlyIncludeMatchers == nil {
 					includes := core.Filter(validatedIncludeSpecs, func(include tspath.PathPattern) bool {
diff --git a/tsc/internal/tsoptions/tsconfigparsing_test.go b/tsc/internal/tsoptions/tsconfigparsing_test.go
index c5f50dc795f43..0f0ff58ab7901 100644
--- a/tsc/internal/tsoptions/tsconfigparsing_test.go
+++ b/tsc/internal/tsoptions/tsconfigparsing_test.go
@@ -1463,7 +1463,7 @@ func TestContentMappersValidation(t *testing.T) {
 		{
 			name:           "missing extensions",
 			contentMappers: `[{ "package": "x" }]`,
-			expectedCode:   diagnostics.Compiler_option_0_requires_a_value_of_type_1.Code(),
+			expectedCode:   diagnostics.Content_mapper_0_must_specify_extensions_in_tsconfig_or_its_package_manifest.Code(),
 		},
 		{
 			name:           "duplicate extension across mappers",
@@ -1495,6 +1495,29 @@ func TestContentMappersValidation(t *testing.T) {
 			contentMappers: `[{ "package": "x", "extensions": [".vue"], "options": ["strict"] }]`,
 			expectedCode:   diagnostics.Compiler_option_0_requires_a_value_of_type_1.Code(),
 		},
+		{
+			name:           "include is not an array",
+			contentMappers: `[{ "package": "x", "extensions": [".vue"], "include": "src" }]`,
+			expectedCode:   diagnostics.Compiler_option_0_requires_a_value_of_type_1.Code(),
+		},
+		{
+			name:           "include contains a non-string",
+			contentMappers: `[{ "package": "x", "extensions": [".vue"], "include": [1] }]`,
+			expectedCode:   diagnostics.Compiler_option_0_requires_a_value_of_type_1.Code(),
+		},
+		{
+			name:           "include ends in recursion",
+			contentMappers: `[{ "package": "x", "extensions": [".vue"], "include": ["src/**"] }]`,
+			expectedCode:   diagnostics.File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0.Code(),
+		},
+		{
+			name: "incompatible output extensions",
+			contentMappers: `[
+				{ "package": "a", "extensions": [".vue"], "outputExtensions": {".vue": ".js"}, "include": ["src"] },
+				{ "package": "b", "extensions": [".vue"] }
+			]`,
+			expectedCode: diagnostics.Content_mapper_0_is_also_registered_for_the_extension_1_but_has_a_conflicting_outputExtensions_mapping_Each_registration_for_this_extension_must_produce_the_same_output_file_name.Code(),
+		},
 	}
 
 	for _, test := range tests {
@@ -1507,10 +1530,13 @@ func TestContentMappersValidation(t *testing.T) {
 				allFileList:     map[string]string{"/app.ts": "export {}"},
 				existingOptions: &core.CompilerOptions{RunExternalCode: core.TSTrue},
 			}
-			if test.name == "duplicate extension across mappers" {
+			if test.name == "duplicate extension across mappers" || test.name == "incompatible output extensions" {
 				config.allFileList["/node_modules/a/package.json"] = `{ "name": "a", "version": "1.0.0", "typescript": { "contentMapper": { "exec": ["a"] } } }`
 				config.allFileList["/node_modules/b/package.json"] = `{ "name": "b", "version": "1.0.0", "typescript": { "contentMapper": { "exec": ["b"] } } }`
 			}
+			if test.name == "missing extensions" {
+				config.allFileList["/node_modules/x/package.json"] = `{ "name": "x", "typescript": { "contentMapper": { "exec": ["x"] } } }`
+			}
 			for apiName, getParsed := range map[string]func(testConfig, vfs.FS, tspath.RootedDirectoryPath) *tsoptions.ParsedCommandLine{
 				"json api":           getParsedWithJsonApi,
 				"jsonSourceFile api": getParsedWithJsonSourceFileApi,
diff --git a/tsc/internal/vfs/vfsmatch/MATCHING_ALGORITHM.md b/tsc/internal/vfs/vfsmatch/MATCHING_ALGORITHM.md
index 798658f9513b1..fd119e4bf7caa 100644
--- a/tsc/internal/vfs/vfsmatch/MATCHING_ALGORITHM.md
+++ b/tsc/internal/vfs/vfsmatch/MATCHING_ALGORITHM.md
@@ -17,10 +17,11 @@ calling routine unless stated otherwise.
 
 **Base path** — The absolute directory against which relative specs are resolved.
 
-**Usage mode** — One of three modes that alter matching semantics:
+**Usage mode** — One of four modes that alter matching semantics:
 - **Files** — Matches complete file paths.
 - **Directories** — Matches directory prefixes for traversal pruning.
 - **Exclude** — Matches paths to be excluded.
+- **ContentMapperInclude** — Matches complete file paths without discovery's hidden-folder, package-folder, or `.min.js` exclusions.
 
 **Component kind** — One of:
 - **Literal** — Contains no `*` or `?` characters.
@@ -157,7 +158,7 @@ calling routine unless stated otherwise.
 >    5. If the kind of _comp_ is **DoubleAsterisk**, then:
 >       1. Let _skipResult_ be the result of MATCH_PATH_INNER(_pattern_, _path_, _pathOffset_, _compIdx_ + 1, _prefixOnly_).
 >       2. If _skipResult_ is **true**, return **true**.
->       3. If _usage_ is not **Exclude**, then:
+>       3. If _usage_ is neither **Exclude** nor **ContentMapperInclude**, then:
 >          1. If IS_HIDDEN_PATH(_part_) is **true**, return **false**.
 >          2. If IS_PACKAGE_FOLDER(_part_) is **true**, return **false**.
 >       4. Set _pathOffset_ to _nextOffset_.
@@ -165,7 +166,7 @@ calling routine unless stated otherwise.
 >    6. If the kind of _comp_ is **Literal**, then:
 >       1. If STRINGS_EQUAL(_comp_.value, _part_, _caseSensitive_) is **false**, return **false**.
 >    7. If the kind of _comp_ is **Wildcard**, then:
->       1. If _usage_ is not **Exclude** and IS_PACKAGE_FOLDER(_part_) is **true**, return **false**.
+>       1. If _usage_ is neither **Exclude** nor **ContentMapperInclude** and IS_PACKAGE_FOLDER(_part_) is **true**, return **false**.
 >       2. If the result of MATCH_WILDCARD(_pattern_, _comp_.segments, _part_) is **false**, return **false**.
 >    8. Set _pathOffset_ to _nextOffset_.
 >    9. Increment _compIdx_.
@@ -184,7 +185,7 @@ calling routine unless stated otherwise.
 
 > 1. Let _usage_ be the usage mode of _pattern_.
 > 2. Let _caseSensitive_ be the case-sensitivity flag of _pattern_.
-> 3. If _usage_ is not **Exclude**, then:
+> 3. If _usage_ is neither **Exclude** nor **ContentMapperInclude**, then:
 >    1. If the length of _segments_ > 0, then:
 >       1. Let _firstKind_ be the kind of _segments_\[0\].
 >       2. If (_firstKind_ is **SegStar** or _firstKind_ is **SegQuestion**) and IS_HIDDEN_PATH(_string_) is **true**, return **false**.
diff --git a/tsc/internal/vfs/vfsmatch/stringer_generated.go b/tsc/internal/vfs/vfsmatch/stringer_generated.go
index 18d4c40eac86f..555dea4026836 100644
--- a/tsc/internal/vfs/vfsmatch/stringer_generated.go
+++ b/tsc/internal/vfs/vfsmatch/stringer_generated.go
@@ -11,11 +11,12 @@ func _() {
 	_ = x[UsageFiles-0]
 	_ = x[UsageDirectories-1]
 	_ = x[UsageExclude-2]
+	_ = x[UsageContentMapperInclude-3]
 }
 
-const _Usage_name = "FilesDirectoriesExclude"
+const _Usage_name = "FilesDirectoriesExcludeContentMapperInclude"
 
-var _Usage_index = [...]uint8{0, 5, 16, 23}
+var _Usage_index = [...]uint8{0, 5, 16, 23, 43}
 
 func (i Usage) String() string {
 	idx := int(i) - 0
diff --git a/tsc/internal/vfs/vfsmatch/vfsmatch.go b/tsc/internal/vfs/vfsmatch/vfsmatch.go
index 882d83bb0bede..ab72b2bb85324 100644
--- a/tsc/internal/vfs/vfsmatch/vfsmatch.go
+++ b/tsc/internal/vfs/vfsmatch/vfsmatch.go
@@ -22,6 +22,8 @@ const (
 	UsageFiles Usage = iota
 	UsageDirectories
 	UsageExclude
+	// UsageContentMapperInclude matches include specs without discovery's hidden/package-folder exclusions.
+	UsageContentMapperInclude
 )
 
 // UnlimitedDepth can be passed as the depth argument to indicate there is no depth limit.
@@ -103,6 +105,7 @@ type globPattern struct {
 	isExclude       bool        // exclude patterns have different matching rules
 	caseSensitivity tspath.CaseSensitivity
 	excludeMinJs    bool // for "files" patterns, exclude .min.js by default
+	matchAllNames   bool
 }
 
 // component is a single path segment in a glob pattern.
@@ -167,12 +170,13 @@ func compileGlobPattern(spec string, basePath tspath.RootedDirectoryPath, usage
 		isExclude:       usage == UsageExclude,
 		caseSensitivity: caseSensitivity,
 		excludeMinJs:    usage == UsageFiles,
+		matchAllNames:   usage == UsageContentMapperInclude,
 		// Avoid slice growth during compilation.
 		components: make([]component, 0, len(parts)),
 	}
 
 	for _, part := range parts {
-		p.components = append(p.components, parseComponent(part, usage != UsageExclude))
+		p.components = append(p.components, parseComponent(part, usage != UsageExclude && usage != UsageContentMapperInclude))
 	}
 	return p, true
 }
@@ -262,7 +266,7 @@ func (p *globPattern) matchPathParts(prefix, suffix string, pathOffset, compIdx
 			if p.matchPathParts(prefix, suffix, pathOffset, compIdx+1, prefixOnly) {
 				return true
 			}
-			if !p.isExclude && (isHiddenPath(pathPart) || isPackageFolder(pathPart)) {
+			if !p.isExclude && !p.matchAllNames && (isHiddenPath(pathPart) || isPackageFolder(pathPart)) {
 				return false
 			}
 			pathOffset = nextOffset
@@ -369,7 +373,7 @@ func nextPathPartParts(prefix, suffix string, offset int) (part string, nextOffs
 // matchWildcard matches a path component against wildcard segments.
 func (p *globPattern) matchWildcard(segs []segment, s string) bool {
 	// Include patterns: wildcards at start cannot match hidden files
-	if !p.isExclude && len(segs) > 0 && isHiddenPath(s) && (segs[0].kind == segStar || segs[0].kind == segQuestion) {
+	if !p.isExclude && !p.matchAllNames && len(segs) > 0 && isHiddenPath(s) && (segs[0].kind == segStar || segs[0].kind == segQuestion) {
 		return false
 	}
 
diff --git a/tsc/testdata/baselines/reference/tsc/contentMapperInclusion/filtered-files-rewrite-but-unclaimed-imports-keep-their-extension.js b/tsc/testdata/baselines/reference/tsc/contentMapperInclusion/filtered-files-rewrite-but-unclaimed-imports-keep-their-extension.js
new file mode 100644
index 0000000000000..c5333df274091
--- /dev/null
+++ b/tsc/testdata/baselines/reference/tsc/contentMapperInclusion/filtered-files-rewrite-but-unclaimed-imports-keep-their-extension.js
@@ -0,0 +1,81 @@
+currentDirectory::/home/src/workspaces/project
+useCaseSensitiveFileNames::true
+Input::
+//// [/home/src/workspaces/project/ambient.d.ts] *new* 
+declare module "*.toml" { export const ambient: string; }
+//// [/home/src/workspaces/project/ambient.toml] *new* 
+not TypeScript
+//// [/home/src/workspaces/project/blob.toml] *new* 
+export const value = 1;
+//// [/home/src/workspaces/project/index.ts] *new* 
+
+				export { value } from "./blob.toml";
+				export { other } from "./other.toml";
+				export { packaged } from "./node_modules/pkg/blob.toml";
+				export { ambient } from "./ambient.toml";
+				
+//// [/home/src/workspaces/project/node_modules/mapper/package.json] *new* 
+{
+				"name": "mapper", "version": "1.0.0",
+				"typescript": { "contentMapper": { "exec": ["verbatim-mapper"], "extensions": [".toml"], "outputExtensions": {".toml": ".js"} } }
+			}
+//// [/home/src/workspaces/project/node_modules/pkg/blob.toml] *new* 
+export const packaged = true;
+//// [/home/src/workspaces/project/other.d.toml.ts] *new* 
+export declare const other: "declaration";
+//// [/home/src/workspaces/project/other.toml] *new* 
+not TypeScript
+//// [/home/src/workspaces/project/tsconfig.json] *new* 
+{
+				"compilerOptions": { "outDir": "./dist", "declaration": true, "rewriteRelativeImportExtensions": true, "module": "preserve", "allowArbitraryExtensions": true },
+				"contentMappers": [{ "package": "mapper", "include": ["**/blob.toml"] }]
+			}
+
+tsgo --runExternalCode --listFiles
+ExitStatus:: Success
+Output::
+/home/src/tslibs/TS/Lib/lib.es2026.full.d.ts
+/home/src/workspaces/project/ambient.d.ts
+/home/src/workspaces/project/blob.toml
+/home/src/workspaces/project/other.d.toml.ts
+/home/src/workspaces/project/node_modules/pkg/blob.toml
+/home/src/workspaces/project/index.ts
+//// [/home/src/tslibs/TS/Lib/lib.es2026.full.d.ts] *Lib*
+/// <reference no-default-lib="true"/>
+interface Boolean {}
+interface Function {}
+interface CallableFunction {}
+interface NewableFunction {}
+interface IArguments {}
+interface Number { toExponential: any; }
+interface Object {}
+interface RegExp {}
+interface String { charAt: any; }
+interface Array<T> { length: number; [n: number]: T; }
+interface ReadonlyArray<T> {}
+interface SymbolConstructor {
+    (desc?: string | number): symbol;
+    for(name: string): symbol;
+    readonly toStringTag: symbol;
+}
+declare var Symbol: SymbolConstructor;
+interface Symbol {
+    readonly [Symbol.toStringTag]: string;
+}
+declare const console: { log(msg: any): void; };
+//// [/home/src/workspaces/project/dist/blob.d.ts] *new* 
+export declare const value = 1;
+
+//// [/home/src/workspaces/project/dist/index.d.ts] *new* 
+export { value } from "./blob.js";
+export { other } from "./other.toml";
+export { packaged } from "./node_modules/pkg/blob.js";
+export { ambient } from "./ambient.toml";
+
+//// [/home/src/workspaces/project/dist/index.js] *new* 
+export { value } from "./blob.js";
+export { other } from "./other.toml";
+export { packaged } from "./node_modules/pkg/blob.js";
+export { ambient } from "./ambient.toml";
+
+
diff --git a/tsc/testdata/baselines/reference/tsc/contentMapperInclusion/manifest-extensions-with-a-narrowing-include-and-declaration-fallback.js b/tsc/testdata/baselines/reference/tsc/contentMapperInclusion/manifest-extensions-with-a-narrowing-include-and-declaration-fallback.js
new file mode 100644
index 0000000000000..333bcfbb2d19a
--- /dev/null
+++ b/tsc/testdata/baselines/reference/tsc/contentMapperInclusion/manifest-extensions-with-a-narrowing-include-and-declaration-fallback.js
@@ -0,0 +1,81 @@
+currentDirectory::/home/src/workspaces/project
+useCaseSensitiveFileNames::true
+Input::
+//// [/home/src/workspaces/project/ambient.d.ts] *new* 
+declare module "*.toml" { export const ambient: string; }
+//// [/home/src/workspaces/project/ambient.toml] *new* 
+not TypeScript
+//// [/home/src/workspaces/project/blob.toml] *new* 
+export const value = 1;
+//// [/home/src/workspaces/project/index.ts] *new* 
+
+				export { value } from "./blob.toml";
+				export { other } from "./other.toml";
+				export { packaged } from "./node_modules/pkg/blob.toml";
+				export { ambient } from "./ambient.toml";
+				
+//// [/home/src/workspaces/project/node_modules/mapper/package.json] *new* 
+{
+				"name": "mapper", "version": "1.0.0",
+				"typescript": { "contentMapper": { "exec": ["verbatim-mapper"], "extensions": [".toml"] } }
+			}
+//// [/home/src/workspaces/project/node_modules/pkg/blob.toml] *new* 
+export const packaged = true;
+//// [/home/src/workspaces/project/other.d.toml.ts] *new* 
+export declare const other: "declaration";
+//// [/home/src/workspaces/project/other.toml] *new* 
+not TypeScript
+//// [/home/src/workspaces/project/tsconfig.json] *new* 
+{
+				"compilerOptions": { "outDir": "./dist", "declaration": true, "module": "preserve", "allowArbitraryExtensions": true },
+				"contentMappers": [{ "package": "mapper", "include": ["**/blob.toml"] }]
+			}
+
+tsgo --runExternalCode --listFiles
+ExitStatus:: Success
+Output::
+/home/src/tslibs/TS/Lib/lib.es2026.full.d.ts
+/home/src/workspaces/project/ambient.d.ts
+/home/src/workspaces/project/blob.toml
+/home/src/workspaces/project/other.d.toml.ts
+/home/src/workspaces/project/node_modules/pkg/blob.toml
+/home/src/workspaces/project/index.ts
+//// [/home/src/tslibs/TS/Lib/lib.es2026.full.d.ts] *Lib*
+/// <reference no-default-lib="true"/>
+interface Boolean {}
+interface Function {}
+interface CallableFunction {}
+interface NewableFunction {}
+interface IArguments {}
+interface Number { toExponential: any; }
+interface Object {}
+interface RegExp {}
+interface String { charAt: any; }
+interface Array<T> { length: number; [n: number]: T; }
+interface ReadonlyArray<T> {}
+interface SymbolConstructor {
+    (desc?: string | number): symbol;
+    for(name: string): symbol;
+    readonly toStringTag: symbol;
+}
+declare var Symbol: SymbolConstructor;
+interface Symbol {
+    readonly [Symbol.toStringTag]: string;
+}
+declare const console: { log(msg: any): void; };
+//// [/home/src/workspaces/project/dist/blob.d.toml.ts] *new* 
+export declare const value = 1;
+
+//// [/home/src/workspaces/project/dist/index.d.ts] *new* 
+export { value } from "./blob.toml";
+export { other } from "./other.toml";
+export { packaged } from "./node_modules/pkg/blob.toml";
+export { ambient } from "./ambient.toml";
+
+//// [/home/src/workspaces/project/dist/index.js] *new* 
+export { value } from "./blob.toml";
+export { other } from "./other.toml";
+export { packaged } from "./node_modules/pkg/blob.toml";
+export { ambient } from "./ambient.toml";
+
+