@nestia/core 11.2.1 → 12.0.0-dev.20260521.1

package/native/transform/core_websocket.go

@@ -0,0 +1,115 @@
+package transform
+
+import (
+	"fmt"
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+func validateNestiaCoreWebSocketRoute(
+	prog *driver.Program,
+	context nestiaCoreFileContext,
+	method *shimast.Node,
+	call *shimast.CallExpression,
+	segments []string,
+) []Diagnostic {
+	if call == nil || len(segments) == 0 || segments[len(segments)-1] != "WebSocketRoute" {
+		_ = call
+		return nil
+	}
+	diagnostics := []Diagnostic{}
+	accepted := false
+	methodDecl := method.AsMethodDeclaration()
+	if methodDecl == nil || methodDecl.Parameters == nil {
+		return []Diagnostic{nestiaCoreWebSocketDiagnostic(context.file, method, "WebSocketRoute", fmt.Sprintf(
+			"method %q must have at least one parameter decorated by @WebSocketRoute.Acceptor().",
+			NodeName(method),
+		))}
+	}
+	for _, param := range methodDecl.Parameters.Nodes {
+		category := nestiaCoreWebSocketParameterCategory(prog, param)
+		name := NodeName(param)
+		if category == "" {
+			diagnostics = append(diagnostics, nestiaCoreWebSocketDiagnostic(context.file, param, "WebSocketRoute", fmt.Sprintf(
+				"parameter %q is not decorated with nested function of WebSocketRoute module.",
+				name,
+			)))
+			continue
+		}
+		switch category {
+		case "Acceptor":
+			accepted = true
+			if strings.HasPrefix(nestiaCoreWebSocketParameterTypeName(param), "WebSocketAcceptor") == false {
+				diagnostics = append(diagnostics, nestiaCoreWebSocketDiagnostic(context.file, param, "WebSocketRoute", fmt.Sprintf(
+					"parameter %q must have WebSocketAcceptor<Header, Provider, Listener> type.",
+					name,
+				)))
+			}
+		case "Driver":
+			if strings.HasPrefix(nestiaCoreWebSocketParameterTypeName(param), "Driver") == false {
+				diagnostics = append(diagnostics, nestiaCoreWebSocketDiagnostic(context.file, param, "WebSocketRoute", fmt.Sprintf(
+					"parameter %q must have Driver<Listener> type.",
+					name,
+				)))
+			}
+		}
+	}
+	if accepted == false {
+		diagnostics = append(diagnostics, nestiaCoreWebSocketDiagnostic(context.file, method, "WebSocketRoute", fmt.Sprintf(
+			"method %q must have at least one parameter decorated by @WebSocketRoute.Acceptor().",
+			NodeName(method),
+		)))
+	}
+	return diagnostics
+}
+
+func nestiaCoreWebSocketParameterCategory(prog *driver.Program, param *shimast.Node) string {
+	if param == nil || len(param.Decorators()) != 1 {
+		return ""
+	}
+	call, segments, ok := nestiaCoreDecoratorCall(prog, param.Decorators()[0])
+	if ok == false || len(segments) < 2 || segments[len(segments)-2] != "WebSocketRoute" {
+		_ = call
+		return ""
+	}
+	return segments[len(segments)-1]
+}
+
+func nestiaCoreWebSocketParameterTypeName(param *shimast.Node) string {
+	if param == nil || param.AsParameterDeclaration() == nil || param.AsParameterDeclaration().Type == nil {
+		return ""
+	}
+	text := NodeText(param.AsParameterDeclaration().Type)
+	text = strings.TrimSpace(text)
+	if index := strings.Index(text, "<"); index >= 0 {
+		text = text[:index]
+	}
+	if index := strings.LastIndex(text, "."); index >= 0 {
+		text = text[index+1:]
+	}
+	return text
+}
+
+func nestiaCoreWebSocketDiagnostic(file *shimast.SourceFile, node *shimast.Node, kind string, message string) Diagnostic {
+	filePath := ""
+	line, column := 0, 0
+	if file != nil {
+		filePath = file.FileName()
+		if node != nil {
+			if pos := node.Pos(); pos >= 0 {
+				l, c := shimscanner.GetECMALineAndByteOffsetOfPosition(file, pos)
+				line, column = l+1, c+1
+			}
+		}
+	}
+	return Diagnostic{
+		File:    filePath,
+		Line:    line,
+		Column:  column,
+		Code:    "nestia.core." + kind,
+		Message: message,
+	}
+}

package/native/transform/exports.go

@@ -0,0 +1,13 @@
+package transform
+
+// NewSourceRewrite builds a SourceRewrite from another Go module (e.g. the
+// `@nestia/sdk` plugin). SourceRewrite keeps its span fields unexported so
+// that the only way to produce one is this constructor or the in-package
+// collectors — every rewrite therefore carries a validated [start,end) span.
+func NewSourceRewrite(start, end int, replacement string) SourceRewrite {
+	return SourceRewrite{
+		start:       start,
+		end:         end,
+		replacement: replacement,
+	}
+}

package/native/transform/path_rewrite.go

@@ -0,0 +1,285 @@
+package transform
+
+import (
+	"path/filepath"
+	"sort"
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimcore "github.com/microsoft/typescript-go/shim/core"
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+type pathsRewriter struct {
+	basePath    string
+	outDir      string
+	patterns    []pathsPattern
+	rootDir     string
+	sourceFiles map[string]string
+}
+
+type pathsPattern struct {
+	pattern string
+	targets []string
+}
+
+func newPathsRewriter(prog *driver.Program) *pathsRewriter {
+	out := &pathsRewriter{sourceFiles: map[string]string{}}
+	if prog == nil || prog.ParsedConfig == nil || prog.ParsedConfig.ParsedConfig == nil || prog.ParsedConfig.ParsedConfig.CompilerOptions == nil {
+		return out
+	}
+	options := prog.ParsedConfig.ParsedConfig.CompilerOptions
+	out.basePath = filepath.Clean(options.GetPathsBasePath(prog.Host.GetCurrentDirectory()))
+	out.outDir = optionalPath(options.OutDir, prog.Host.GetCurrentDirectory())
+	out.rootDir = optionalPath(options.RootDir, prog.Host.GetCurrentDirectory())
+	files := prog.SourceFiles()
+	if out.rootDir == "" {
+		out.rootDir = commonSourceDir(files)
+	}
+	for _, file := range files {
+		name := normalizePath(file.FileName())
+		out.sourceFiles[name] = name
+		out.sourceFiles[stripKnownSourceExtension(name)] = name
+	}
+	if options.Paths != nil {
+		for pattern, targets := range options.Paths.Entries() {
+			out.patterns = append(out.patterns, pathsPattern{
+				pattern: pattern,
+				targets: append([]string(nil), targets...),
+			})
+		}
+	}
+	sort.SliceStable(out.patterns, func(i, j int) bool {
+		return patternRank(out.patterns[i].pattern) > patternRank(out.patterns[j].pattern)
+	})
+	return out
+}
+
+func (r *pathsRewriter) applyAll(files []*shimast.SourceFile) {
+	if r == nil || len(r.patterns) == 0 {
+		return
+	}
+	for _, file := range files {
+		r.apply(file)
+	}
+}
+
+func (r *pathsRewriter) apply(file *shimast.SourceFile) {
+	if r == nil || file == nil || len(r.patterns) == 0 {
+		return
+	}
+	visitModuleSpecifiers(file.AsNode(), func(lit *shimast.Node) {
+		if lit == nil || lit.Kind != shimast.KindStringLiteral {
+			return
+		}
+		spec := lit.Text()
+		rewritten, ok := r.rewrite(file.FileName(), spec)
+		if ok && rewritten != spec {
+			lit.AsStringLiteral().Text = rewritten
+			lit.Flags |= shimast.NodeFlagsSynthesized
+			lit.Loc = shimcore.UndefinedTextRange()
+		}
+	})
+}
+
+func visitModuleSpecifiers(node *shimast.Node, visit func(*shimast.Node)) {
+	if node == nil {
+		return
+	}
+	switch node.Kind {
+	case shimast.KindImportDeclaration:
+		visit(node.AsImportDeclaration().ModuleSpecifier)
+	case shimast.KindExportDeclaration:
+		visit(node.AsExportDeclaration().ModuleSpecifier)
+	case shimast.KindImportEqualsDeclaration:
+		ref := node.AsImportEqualsDeclaration().ModuleReference
+		if ref != nil && ref.Kind == shimast.KindExternalModuleReference {
+			visit(ref.AsExternalModuleReference().Expression)
+		}
+	case shimast.KindImportType:
+		arg := node.AsImportTypeNode().Argument
+		if arg != nil && arg.Kind == shimast.KindLiteralType {
+			visit(arg.AsLiteralTypeNode().Literal)
+		}
+	case shimast.KindModuleDeclaration:
+		decl := node.AsModuleDeclaration()
+		if decl != nil {
+			visit(decl.Name())
+		}
+	case shimast.KindCallExpression:
+		call := node.AsCallExpression()
+		if isModuleSpecifierCall(call) && call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+			visit(call.Arguments.Nodes[0])
+		}
+	}
+	node.ForEachChild(func(child *shimast.Node) bool {
+		visitModuleSpecifiers(child, visit)
+		return false
+	})
+}
+
+func isModuleSpecifierCall(call *shimast.CallExpression) bool {
+	if call == nil || call.Expression == nil {
+		return false
+	}
+	switch call.Expression.Kind {
+	case shimast.KindImportKeyword:
+		return true
+	case shimast.KindIdentifier:
+		return call.Expression.Text() == "require"
+	default:
+		return false
+	}
+}
+
+func (r *pathsRewriter) rewrite(fromSource string, specifier string) (string, bool) {
+	if specifier == "" || strings.HasPrefix(specifier, ".") || strings.HasPrefix(specifier, "/") {
+		return specifier, false
+	}
+	targetSource, ok := r.resolveSource(specifier)
+	if !ok {
+		return specifier, false
+	}
+	fromOut := r.outputPathForSource(fromSource)
+	targetOut := r.outputPathForSource(targetSource)
+	if fromOut == "" || targetOut == "" {
+		return specifier, false
+	}
+	rel, err := filepath.Rel(filepath.Dir(fromOut), targetOut)
+	if err != nil {
+		return specifier, false
+	}
+	rel = filepath.ToSlash(rel)
+	if !strings.HasPrefix(rel, ".") {
+		rel = "./" + rel
+	}
+	return rel, true
+}
+
+func (r *pathsRewriter) resolveSource(specifier string) (string, bool) {
+	for _, pattern := range r.patterns {
+		star, ok := matchPattern(pattern.pattern, specifier)
+		if !ok {
+			continue
+		}
+		for _, target := range pattern.targets {
+			candidate := strings.Replace(target, "*", star, 1)
+			resolved := normalizePath(filepath.Join(r.basePath, candidate))
+			if source, ok := r.lookupSource(resolved); ok {
+				return source, true
+			}
+		}
+	}
+	return "", false
+}
+
+func (r *pathsRewriter) lookupSource(candidate string) (string, bool) {
+	if source, ok := r.sourceFiles[normalizePath(candidate)]; ok {
+		return source, true
+	}
+	stem := stripKnownSourceExtension(normalizePath(candidate))
+	if source, ok := r.sourceFiles[stem]; ok {
+		return source, true
+	}
+	for _, ext := range []string{".ts", ".tsx", ".mts", ".cts"} {
+		if source, ok := r.sourceFiles[stem+ext]; ok {
+			return source, true
+		}
+	}
+	for _, ext := range []string{".ts", ".tsx", ".mts", ".cts"} {
+		if source, ok := r.sourceFiles[normalizePath(filepath.Join(stem, "index"+ext))]; ok {
+			return source, true
+		}
+	}
+	return "", false
+}
+
+func (r *pathsRewriter) outputPathForSource(source string) string {
+	if r.outDir == "" || r.rootDir == "" {
+		return ""
+	}
+	rel, err := filepath.Rel(r.rootDir, source)
+	if err != nil || isOutsideRelativePath(rel) {
+		return ""
+	}
+	return normalizePath(filepath.Join(r.outDir, replaceSourceExtension(rel, emittedJavaScriptExtension(rel))))
+}
+
+func emittedJavaScriptExtension(source string) string {
+	switch strings.ToLower(filepath.Ext(source)) {
+	case ".mts":
+		return ".mjs"
+	case ".cts":
+		return ".cjs"
+	default:
+		return ".js"
+	}
+}
+
+func matchPattern(pattern string, specifier string) (string, bool) {
+	if !strings.Contains(pattern, "*") {
+		return "", pattern == specifier
+	}
+	parts := strings.SplitN(pattern, "*", 2)
+	if !strings.HasPrefix(specifier, parts[0]) || !strings.HasSuffix(specifier, parts[1]) {
+		return "", false
+	}
+	return specifier[len(parts[0]) : len(specifier)-len(parts[1])], true
+}
+
+func patternRank(pattern string) int {
+	return len(strings.ReplaceAll(pattern, "*", ""))
+}
+
+func optionalPath(value string, cwd string) string {
+	if value == "" {
+		return ""
+	}
+	if filepath.IsAbs(value) {
+		return normalizePath(value)
+	}
+	return normalizePath(filepath.Join(cwd, value))
+}
+
+func commonSourceDir(files []*shimast.SourceFile) string {
+	if len(files) == 0 {
+		return ""
+	}
+	common := normalizePath(filepath.Dir(files[0].FileName()))
+	for _, file := range files[1:] {
+		dir := normalizePath(filepath.Dir(file.FileName()))
+		for common != "" && !strings.HasPrefix(dir+"/", common+"/") {
+			next := filepath.Dir(common)
+			if next == common {
+				return common
+			}
+			common = normalizePath(next)
+		}
+	}
+	return common
+}
+
+func normalizePath(value string) string {
+	if value == "" {
+		return ""
+	}
+	return filepath.ToSlash(filepath.Clean(value))
+}
+
+func isOutsideRelativePath(rel string) bool {
+	return rel == ".." || strings.HasPrefix(filepath.ToSlash(rel), "../")
+}
+
+func stripKnownSourceExtension(value string) string {
+	lower := strings.ToLower(value)
+	for _, ext := range []string{".d.ts", ".d.mts", ".d.cts", ".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"} {
+		if strings.HasSuffix(lower, ext) {
+			return value[:len(value)-len(ext)]
+		}
+	}
+	return strings.TrimSuffix(value, filepath.Ext(value))
+}
+
+func replaceSourceExtension(value string, ext string) string {
+	return stripKnownSourceExtension(filepath.ToSlash(value)) + ext
+}

package/native/transform/path_rewrite_test.go

@@ -0,0 +1,243 @@
+package transform
+
+import "testing"
+
+// Verifies emittedJavaScriptExtension maps source-file extensions to the
+// matching JavaScript output extension that tsgo writes.
+//
+// The native rewrite scan asks for the post-emit name of every registered
+// source. A mismatch here means the rewrite searches for `.js` files when
+// the project actually emits `.mjs` (ESM packages) or `.cjs`, and the
+// "could not locate <call>" failure path then fires on legitimate
+// builds. The case-insensitive switch covers Windows-style mixed-case
+// `.MTS` paths some toolchains produce.
+//
+//  1. Cover the three explicit branches (.mts, .cts, default).
+//  2. Cover the case-insensitive variants (.MTS, .CTS).
+//  3. Cover the default fallback for unknown / extensionless inputs.
+func TestEmittedJavaScriptExtensionMapsSourceToOutput(t *testing.T) {
+	cases := []struct {
+		name   string
+		source string
+		want   string
+	}{
+		{"plain ts", "/repo/src/index.ts", ".js"},
+		{"plain tsx", "/repo/src/Component.tsx", ".js"},
+		{"esm mts", "/repo/src/index.mts", ".mjs"},
+		{"cjs cts", "/repo/src/index.cts", ".cjs"},
+		{"uppercase mts", "/repo/src/Index.MTS", ".mjs"},
+		{"uppercase cts", "/repo/src/Index.CTS", ".cjs"},
+		{"declaration only", "/repo/src/types.d.ts", ".js"},
+		{"unknown extension", "/repo/src/data.json", ".js"},
+		{"extensionless", "/repo/src/README", ".js"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := emittedJavaScriptExtension(tc.source); got != tc.want {
+				t.Fatalf("emittedJavaScriptExtension(%q) = %q, want %q", tc.source, got, tc.want)
+			}
+		})
+	}
+}
+
+// Verifies matchPattern strictly matches the literal-pattern branch and
+// returns the wildcard capture for star-bearing patterns.
+//
+// `matchPattern` underpins every `paths` resolver entry — a regression in
+// the prefix / suffix slice arithmetic would silently break tsconfig
+// `paths` aliasing for any project that uses it. The literal branch must
+// reject `pattern !== specifier`; the wildcard branch must demand BOTH
+// the prefix and suffix to anchor before extracting the capture.
+//
+//  1. Literal patterns match only on byte equality.
+//  2. Single-wildcard patterns extract the gap between prefix and suffix.
+//  3. Mismatched prefix or suffix returns no capture.
+func TestMatchPatternLiteralAndWildcardBranches(t *testing.T) {
+	cases := []struct {
+		name    string
+		pattern string
+		input   string
+		want    string
+		matched bool
+	}{
+		{"literal match", "@api", "@api", "", true},
+		{"literal mismatch", "@api", "@api/lib", "", false},
+		{"wildcard captures middle", "@api/*", "@api/users", "users", true},
+		{"wildcard captures nested", "@api/lib/*", "@api/lib/sub/file", "sub/file", true},
+		{"wildcard mismatch prefix", "@api/*", "@other/users", "", false},
+		{"wildcard mismatch suffix", "@api/*.ts", "@api/users.tsx", "", false},
+		{"wildcard between prefix and suffix", "src/*/index.ts", "src/foo/index.ts", "foo", true},
+		{"empty capture allowed", "prefix*suffix", "prefixsuffix", "", true},
+		{"second wildcard treated as literal", "@api/*/lib/*", "@api/foo/lib/*", "foo", true},
+		{"second wildcard does not expand", "@api/*/lib/*", "@api/foo/lib/bar", "", false},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			got, ok := matchPattern(tc.pattern, tc.input)
+			if ok != tc.matched {
+				t.Fatalf("matchPattern(%q, %q) ok = %v, want %v", tc.pattern, tc.input, ok, tc.matched)
+			}
+			if ok && got != tc.want {
+				t.Fatalf("matchPattern(%q, %q) capture = %q, want %q", tc.pattern, tc.input, got, tc.want)
+			}
+		})
+	}
+}
+
+// Verifies patternRank assigns longer literal-character counts higher rank
+// so the longest non-wildcard pattern wins when several match.
+//
+// tsconfig `paths` resolution sorts candidates by `patternRank` descending
+// to break ties — without this ordering the resolver could pick the
+// loosest pattern over a more specific one (e.g. `*` over `@api/*`).
+//
+//  1. A pure-wildcard pattern ranks 0.
+//  2. Each non-wildcard character adds 1 regardless of position.
+//  3. Multiple wildcards do not double-count literal segments.
+func TestPatternRankCountsNonWildcardCharacters(t *testing.T) {
+	cases := []struct {
+		pattern string
+		want    int
+	}{
+		{"*", 0},
+		{"@api/*", 5},
+		{"@api/lib/*", 9},
+		{"src/*/index.ts", 13},
+		{"prefix*suffix", 12},
+	}
+	for _, tc := range cases {
+		if got := patternRank(tc.pattern); got != tc.want {
+			t.Fatalf("patternRank(%q) = %d, want %d", tc.pattern, got, tc.want)
+		}
+	}
+}
+
+// Verifies normalizePath collapses redundant POSIX separators and
+// resolves `..` segments via filepath.Clean.
+//
+// The rewrite pipeline keys outputs and sources by their normalized
+// path. A regression here would split a single logical source into
+// multiple cache entries, defeating `nativeRewriteSet`'s deduplication.
+// `filepath.ToSlash` runs after Clean — on Linux it is a no-op for
+// already-POSIX input; backslash handling is delegated to the platform.
+//
+//  1. Empty input returns empty.
+//  2. Adjacent separators collapse.
+//  3. `..` segments are resolved relative to the preceding directory.
+//  4. A leading `./` is stripped (filepath.Clean canonicalization).
+func TestNormalizePathProducesPosixSlashes(t *testing.T) {
+	cases := []struct {
+		input string
+		want  string
+	}{
+		{"", ""},
+		{"/repo/src/index.ts", "/repo/src/index.ts"},
+		{"/repo//src///index.ts", "/repo/src/index.ts"},
+		{"/repo/src/../src/index.ts", "/repo/src/index.ts"},
+		{"./relative/path", "relative/path"},
+	}
+	for _, tc := range cases {
+		if got := normalizePath(tc.input); got != tc.want {
+			t.Fatalf("normalizePath(%q) = %q, want %q", tc.input, got, tc.want)
+		}
+	}
+}
+
+// Verifies isOutsideRelativePath flags any relative path that escapes the
+// root via `..` segments.
+//
+// `pathRewriter.outputForSource` refuses to map sources that resolve
+// outside `rootDir`. Without this guard, a controller imported from a
+// monorepo neighbor would emit into the outDir at a relative position
+// that collides with an unrelated file.
+//
+//  1. Bare `..` is outside.
+//  2. `../...` prefix is outside.
+//  3. Same-or-nested paths are inside.
+func TestIsOutsideRelativePathRejectsParentEscapes(t *testing.T) {
+	cases := []struct {
+		rel  string
+		want bool
+	}{
+		{"..", true},
+		{"../sibling", true},
+		{"../../escape", true},
+		{".", false},
+		{"nested/file.ts", false},
+		{"sub/../same.ts", false},
+	}
+	for _, tc := range cases {
+		if got := isOutsideRelativePath(tc.rel); got != tc.want {
+			t.Fatalf("isOutsideRelativePath(%q) = %v, want %v", tc.rel, got, tc.want)
+		}
+	}
+}
+
+// Verifies stripKnownSourceExtension prefers the longest known suffix and
+// falls back to filepath.Ext for unknown extensions.
+//
+// The declaration-file extensions (`.d.ts`, `.d.mts`, `.d.cts`) must be
+// matched as a whole — falling through to the simpler `.ts` strip would
+// leave the `.d` suffix on the stem and silently produce wrong virtual
+// paths for declaration emitters.
+//
+//  1. `.d.ts` strips the full three-character suffix.
+//  2. Each one-extension form (`.ts`, `.tsx`, `.mts`, …) strips cleanly.
+//  3. Unknown extensions fall back to filepath.Ext.
+//  4. Case-insensitive match on uppercase variants.
+func TestStripKnownSourceExtensionPrefersLongestMatch(t *testing.T) {
+	cases := []struct {
+		input string
+		want  string
+	}{
+		{"types.d.ts", "types"},
+		{"types.d.mts", "types"},
+		{"types.d.cts", "types"},
+		{"index.ts", "index"},
+		{"index.tsx", "index"},
+		{"index.mts", "index"},
+		{"index.cts", "index"},
+		{"index.js", "index"},
+		{"data.json", "data"},
+		{"Index.D.TS", "Index"},
+		{"README", "README"},
+	}
+	for _, tc := range cases {
+		if got := stripKnownSourceExtension(tc.input); got != tc.want {
+			t.Fatalf("stripKnownSourceExtension(%q) = %q, want %q", tc.input, got, tc.want)
+		}
+	}
+}
+
+// Verifies replaceSourceExtension swaps the known TypeScript extension
+// while preserving the rest of the path.
+//
+// Combined with `emittedJavaScriptExtension`, this drives the source ↔
+// output filename mapping the rewrite scan depends on. The declaration
+// case is load-bearing: `stripKnownSourceExtension` must prefer the full
+// `.d.ts` suffix over a plain `.ts` strip, otherwise `types.d.ts +
+// .d.ts` would silently become `types..d.ts` and the declaration
+// emitter would write a corrupt path.
+//
+//  1. `.ts` is replaced with the chosen output extension.
+//  2. Declaration suffixes (`.d.ts`) strip wholly before replacement.
+//  3. POSIX separators in the input flow through unchanged.
+//  4. `.d.ts` + `.d.ts` stays `.d.ts` (pins the longest-match prefer rule).
+func TestReplaceSourceExtensionSwapsKnownSuffix(t *testing.T) {
+	cases := []struct {
+		input string
+		ext   string
+		want  string
+	}{
+		{"src/index.ts", ".js", "src/index.js"},
+		{"src/index.mts", ".mjs", "src/index.mjs"},
+		{"src/types.d.ts", ".js", "src/types.js"},
+		{"src/nested/foo.ts", ".js", "src/nested/foo.js"},
+		{"src/types.d.ts", ".d.ts", "src/types.d.ts"},
+	}
+	for _, tc := range cases {
+		if got := replaceSourceExtension(tc.input, tc.ext); got != tc.want {
+			t.Fatalf("replaceSourceExtension(%q, %q) = %q, want %q", tc.input, tc.ext, got, tc.want)
+		}
+	}
+}