@nestia/core 12.0.0-dev.20260520.1 → 12.0.0-dev.20260521.1

package/native/{cmd/ttsc-nestia → transform}/core_transform.go

@@ -1,4 +1,4 @@
-package main
+package transform
 
 import (
 	"fmt"
@@ -79,7 +79,7 @@ func newNestiaCoreTransformState(prog *driver.Program, options nestiaCoreOptions
 
 var nestiaCoreFactory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
-const nestiaCoreKindDecorator = shimast.KindDecorator
+const NestiaCoreKindDecorator = shimast.KindDecorator
 
 type nestiaCoreFileContext struct {
 	file        *shimast.SourceFile
@@ -121,18 +121,18 @@ func collectNestiaCoreSourceRewriteMap(
 	prog *driver.Program,
 	plan plugin.Plan,
 	onlyFile string,
-) (map[string][]transformSourceRewrite, []typiaTransformDiagnostic) {
+) (map[string][]SourceRewrite, []Diagnostic) {
 	if plan.Core == false {
-		return map[string][]transformSourceRewrite{}, nil
+		return map[string][]SourceRewrite{}, nil
 	}
 	options := readNestiaCoreOptions(plan)
 	sites, diagnostics := collectNestiaCoreSites(newNestiaCoreTransformState(prog, options))
-	rewrites := map[string][]transformSourceRewrite{}
+	rewrites := map[string][]SourceRewrite{}
 	for _, site := range sites {
 		if onlyFile != "" && filepath.ToSlash(site.FilePath) != filepath.ToSlash(onlyFile) {
 			continue
 		}
-		source, ok := sourceFileText(site.File)
+		source, ok := SourceFileText(site.File)
 		if !ok {
 			diagnostics = append(diagnostics, nestiaCoreDiagnostic(site, "source text is unavailable"))
 			continue
@@ -143,7 +143,7 @@ func collectNestiaCoreSourceRewriteMap(
 			continue
 		}
 		replacement := appendArgumentsText(source[open+1:close], site.Arguments)
-		rewrites[filepath.ToSlash(site.FilePath)] = append(rewrites[filepath.ToSlash(site.FilePath)], transformSourceRewrite{
+		rewrites[filepath.ToSlash(site.FilePath)] = append(rewrites[filepath.ToSlash(site.FilePath)], SourceRewrite{
 			start:       open + 1,
 			end:         close,
 			replacement: replacement,
@@ -156,7 +156,7 @@ func collectNestiaCoreBuildRewrites(
 	prog *driver.Program,
 	plan plugin.Plan,
 	rewrites *nativeRewriteSet,
-) []typiaTransformDiagnostic {
+) []Diagnostic {
 	if plan.Core == false {
 		return nil
 	}
@@ -180,7 +180,7 @@ func collectNestiaCoreBuildRewrites(
 }
 
 func nestiaCoreOriginalArgumentText(site nestiaCoreSite) string {
-	source, ok := sourceFileText(site.File)
+	source, ok := SourceFileText(site.File)
 	if !ok {
 		return ""
 	}
@@ -199,9 +199,9 @@ func nestiaCoreStableOriginalArgumentText(site nestiaCoreSite) string {
 	return text
 }
 
-func collectNestiaCoreSites(state *nestiaCoreTransformState) ([]nestiaCoreSite, []typiaTransformDiagnostic) {
+func collectNestiaCoreSites(state *nestiaCoreTransformState) ([]nestiaCoreSite, []Diagnostic) {
 	sites := []nestiaCoreSite{}
-	diagnostics := []typiaTransformDiagnostic{}
+	diagnostics := []Diagnostic{}
 	prog := state.prog
 	if nestiaCoreStrictMode(prog) == false {
 		diagnostics = append(diagnostics, nestiaCoreGlobalDiagnostic("@nestia/core", "strict mode is required."))
@@ -227,7 +227,7 @@ func visitNestiaCoreNode(
 	context nestiaCoreFileContext,
 	node *shimast.Node,
 	sites *[]nestiaCoreSite,
-	diagnostics *[]typiaTransformDiagnostic,
+	diagnostics *[]Diagnostic,
 ) {
 	if node == nil {
 		return
@@ -317,7 +317,7 @@ func visitNestiaCoreNode(
 		if len(candidates) == 0 {
 			break
 		}
-		typ := nestiaCoreMethodReturnType(state.prog, node)
+		typ := NestiaCoreMethodReturnType(state.prog, node)
 		if typ != nil {
 			for _, candidate := range candidates {
 				site, ok, err := transformNestiaCoreMethodDecorator(
@@ -489,7 +489,7 @@ func (state *nestiaCoreTransformState) cacheKey(
 }
 
 func nestiaCoreRawDecoratorCall(decorator *shimast.Node) (*shimast.CallExpression, []string, bool) {
-	if decorator == nil || decorator.Kind != nestiaCoreKindDecorator {
+	if decorator == nil || decorator.Kind != NestiaCoreKindDecorator {
 		return nil, nil, false
 	}
 	expression := decorator.AsDecorator().Expression
@@ -497,7 +497,7 @@ func nestiaCoreRawDecoratorCall(decorator *shimast.Node) (*shimast.CallExpressio
 		return nil, nil, false
 	}
 	call := expression.AsCallExpression()
-	segments := nestiaCoreExpressionSegments(call.Expression)
+	segments := NestiaCoreExpressionSegments(call.Expression)
 	if len(segments) == 0 {
 		return nil, nil, false
 	}
@@ -600,7 +600,7 @@ func nestiaCoreDecoratorReference(
 	if nestiaCorePotentialDecoratorSegments(canonical) == false {
 		return false
 	}
-	return isNestiaCoreCall(prog, decorator.AsDecorator().Expression)
+	return IsNestiaCoreCall(prog, decorator.AsDecorator().Expression)
 }
 
 func nestiaCorePotentialDecoratorSegments(segments []string) bool {
@@ -609,7 +609,7 @@ func nestiaCorePotentialDecoratorSegments(segments []string) bool {
 		(len(segments) != 0 && segments[len(segments)-1] == "WebSocketRoute")
 }
 
-func isNestiaCoreCall(prog *driver.Program, node *shimast.Node) bool {
+func IsNestiaCoreCall(prog *driver.Program, node *shimast.Node) bool {
 	signature := prog.Checker.GetResolvedSignature(node)
 	if signature == nil || signature.Declaration() == nil {
 		return false
@@ -1406,7 +1406,7 @@ func cleanupNestiaCorePrintedExpression(text string) string {
 
 var nestiaCoreSingleParameterArrowPattern = regexp.MustCompile(`(^|[\s(=,:?])([A-Za-z_$][A-Za-z0-9_$]*) =>`)
 
-func nestiaCoreMethodReturnType(prog *driver.Program, node *shimast.Node) *shimchecker.Type {
+func NestiaCoreMethodReturnType(prog *driver.Program, node *shimast.Node) *shimchecker.Type {
 	signature := prog.Checker.GetSignatureFromDeclaration(node)
 	if signature == nil {
 		return nil
@@ -1449,7 +1449,7 @@ func nestiaCoreShouldSkipMethodDecorator(prog *driver.Program, call *shimast.Cal
 }
 
 func nestiaCoreHasPathLiteralArgument(call *shimast.CallExpression) bool {
-	source, ok := sourceFileText(shimast.GetSourceFileOfNode(call.AsNode()))
+	source, ok := SourceFileText(shimast.GetSourceFileOfNode(call.AsNode()))
 	if !ok {
 		return false
 	}
@@ -1498,7 +1498,7 @@ func appendArgumentsText(current string, arguments []string) string {
 	return current + ", " + next
 }
 
-func nestiaCoreExpressionSegments(node *shimast.Node) []string {
+func NestiaCoreExpressionSegments(node *shimast.Node) []string {
 	if node == nil {
 		return nil
 	}
@@ -1512,7 +1512,7 @@ func nestiaCoreExpressionSegments(node *shimast.Node) []string {
 		if access == nil {
 			return nil
 		}
-		left := nestiaCoreExpressionSegments(access.Expression)
+		left := NestiaCoreExpressionSegments(access.Expression)
 		name := access.Name()
 		if len(left) == 0 || name == nil || name.Kind != shimast.KindIdentifier {
 			return nil
@@ -1523,7 +1523,7 @@ func nestiaCoreExpressionSegments(node *shimast.Node) []string {
 }
 
 func nestiaCoreModuloNode(node *shimast.Node) *shimast.Node {
-	segments := nestiaCoreExpressionSegments(node)
+	segments := NestiaCoreExpressionSegments(node)
 	if len(segments) == 0 {
 		return nestiaCoreFactory.NewIdentifier("nestia_core_transform")
 	}
@@ -1688,7 +1688,7 @@ func commonJSImportAliasBase(module string) string {
 	return text
 }
 
-func nestiaCoreDiagnostic(site nestiaCoreSite, message string) typiaTransformDiagnostic {
+func nestiaCoreDiagnostic(site nestiaCoreSite, message string) Diagnostic {
 	line, column := 0, 0
 	if site.File != nil && site.Call != nil {
 		if pos := site.Call.AsNode().Pos(); pos >= 0 {
@@ -1696,7 +1696,7 @@ func nestiaCoreDiagnostic(site nestiaCoreSite, message string) typiaTransformDia
 			line, column = l+1, c+1
 		}
 	}
-	return typiaTransformDiagnostic{
+	return Diagnostic{
 		File:    site.FilePath,
 		Line:    line,
 		Column:  column,
@@ -1705,8 +1705,8 @@ func nestiaCoreDiagnostic(site nestiaCoreSite, message string) typiaTransformDia
 	}
 }
 
-func nestiaCoreGlobalDiagnostic(code string, message string) typiaTransformDiagnostic {
-	return typiaTransformDiagnostic{
+func nestiaCoreGlobalDiagnostic(code string, message string) Diagnostic {
+	return Diagnostic{
 		Code:    code,
 		Message: message,
 	}

package/native/{cmd/ttsc-nestia → transform}/core_websocket.go

@@ -1,4 +1,4 @@
-package main
+package transform
 
 import (
 	"fmt"
@@ -15,23 +15,23 @@ func validateNestiaCoreWebSocketRoute(
 	method *shimast.Node,
 	call *shimast.CallExpression,
 	segments []string,
-) []typiaTransformDiagnostic {
+) []Diagnostic {
 	if call == nil || len(segments) == 0 || segments[len(segments)-1] != "WebSocketRoute" {
 		_ = call
 		return nil
 	}
-	diagnostics := []typiaTransformDiagnostic{}
+	diagnostics := []Diagnostic{}
 	accepted := false
 	methodDecl := method.AsMethodDeclaration()
 	if methodDecl == nil || methodDecl.Parameters == nil {
-		return []typiaTransformDiagnostic{nestiaCoreWebSocketDiagnostic(context.file, method, "WebSocketRoute", fmt.Sprintf(
+		return []Diagnostic{nestiaCoreWebSocketDiagnostic(context.file, method, "WebSocketRoute", fmt.Sprintf(
 			"method %q must have at least one parameter decorated by @WebSocketRoute.Acceptor().",
-			nestiaSDKMethodName(method),
+			NodeName(method),
 		))}
 	}
 	for _, param := range methodDecl.Parameters.Nodes {
 		category := nestiaCoreWebSocketParameterCategory(prog, param)
-		name := nestiaSDKParameterName(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.",
@@ -60,7 +60,7 @@ func validateNestiaCoreWebSocketRoute(
 	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().",
-			nestiaSDKMethodName(method),
+			NodeName(method),
 		)))
 	}
 	return diagnostics
@@ -82,7 +82,7 @@ func nestiaCoreWebSocketParameterTypeName(param *shimast.Node) string {
 	if param == nil || param.AsParameterDeclaration() == nil || param.AsParameterDeclaration().Type == nil {
 		return ""
 	}
-	text := nestiaSDKTypeNodeText(param.AsParameterDeclaration().Type)
+	text := NodeText(param.AsParameterDeclaration().Type)
 	text = strings.TrimSpace(text)
 	if index := strings.Index(text, "<"); index >= 0 {
 		text = text[:index]
@@ -93,7 +93,7 @@ func nestiaCoreWebSocketParameterTypeName(param *shimast.Node) string {
 	return text
 }
 
-func nestiaCoreWebSocketDiagnostic(file *shimast.SourceFile, node *shimast.Node, kind string, message string) typiaTransformDiagnostic {
+func nestiaCoreWebSocketDiagnostic(file *shimast.SourceFile, node *shimast.Node, kind string, message string) Diagnostic {
 	filePath := ""
 	line, column := 0, 0
 	if file != nil {
@@ -105,7 +105,7 @@ func nestiaCoreWebSocketDiagnostic(file *shimast.SourceFile, node *shimast.Node,
 			}
 		}
 	}
-	return typiaTransformDiagnostic{
+	return Diagnostic{
 		File:    filePath,
 		Line:    line,
 		Column:  column,

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/{cmd/ttsc-nestia → transform}/path_rewrite.go

@@ -1,4 +1,4 @@
-package main
+package transform
 
 import (
 	"path/filepath"

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)
+		}
+	}
+}

package/native/{cmd/ttsc-nestia → transform}/printer.go

@@ -1,4 +1,4 @@
-package main
+package transform
 
 import (
 	shimast "github.com/microsoft/typescript-go/shim/ast"

package/native/{cmd/ttsc-nestia → transform}/rewrite.go

@@ -1,4 +1,4 @@
-package main
+package transform
 
 import (
 	"fmt"
@@ -163,7 +163,7 @@ func (rs *nativeRewriteSet) findSourceForOutput(outputName string) (string, bool
 	outSlash := strings.TrimSuffix(filepath.ToSlash(outputName), filepath.Ext(outputName))
 	for path := range rs.byPath {
 		srcStem := strings.TrimSuffix(filepath.ToSlash(path), filepath.Ext(path))
-		if outputMatchesSourceStem(outSlash, srcStem) {
+		if OutputMatchesSourceStem(outSlash, srcStem) {
 			return path, true
 		}
 	}
@@ -208,7 +208,7 @@ func outputHasBuildMarker(stem string) bool {
 	return false
 }
 
-func outputMatchesSourceStem(outputStem string, sourceStem string) bool {
+func OutputMatchesSourceStem(outputStem string, sourceStem string) bool {
 	if outputStem == sourceStem {
 		return true
 	}

package/native/transform/rewrite_test.go

@@ -0,0 +1,118 @@
+package transform
+
+import "testing"
+
+// Verifies OutputMatchesSourceStem accepts virtual-fs same-stem mirrors and
+// rejects single-segment suffix collisions across the source tree.
+//
+// Regression: a top-level `src/index.ts` produced a one-segment relative
+// ("index") that the HasSuffix fallback matched against every output ending
+// in `/index.js`. The native rewrite scan then trawled unrelated files for
+// typia call sites that only existed in the root entry, raising
+// "could not locate typia.reflect.schemas(...) call".
+//
+//  1. Mirror a src/index virtual fs — must match.
+//  2. Compare top-level src/index against nested src/api/health/index — must reject.
+//  3. Cover the package src->lib mapping and an unrelated stem pair.
+func TestOutputMatchesSourceStem(t *testing.T) {
+	cases := []struct {
+		name   string
+		output string
+		source string
+		want   bool
+	}{
+		{
+			name:   "virtual fs mirrors src tree",
+			output: "/cache/.ttsc/project/1/fs/posix/repo/tests/foo/src/index",
+			source: "/repo/tests/foo/src/index",
+			want:   true,
+		},
+		{
+			name:   "top-level src/index does not match nested src/api/health/index",
+			output: "/cache/.ttsc/project/1/fs/posix/repo/tests/foo/src/api/functional/health/index",
+			source: "/repo/tests/foo/src/index",
+			want:   false,
+		},
+		{
+			name:   "src/api source matches nested api output",
+			output: "/cache/.ttsc/project/1/fs/posix/repo/tests/foo/src/api/functional/health/index",
+			source: "/repo/tests/foo/src/api/functional/health/index",
+			want:   true,
+		},
+		{
+			name:   "package src maps to lib output",
+			output: "/repo/packages/core/lib/decorators/TypedBody",
+			source: "/repo/packages/core/src/decorators/TypedBody",
+			want:   true,
+		},
+		{
+			name:   "unrelated stems",
+			output: "/repo/packages/core/lib/decorators/TypedBody",
+			source: "/repo/packages/sdk/src/generates/Foo",
+			want:   false,
+		},
+		{
+			name:   "top-level src/index does not match nested src/api/index",
+			output: "/cache/.ttsc/project/1/fs/posix/repo/tests/foo/src/api/index",
+			source: "/repo/tests/foo/src/index",
+			want:   false,
+		},
+	}
+	for _, tc := range cases {
+		got := OutputMatchesSourceStem(tc.output, tc.source)
+		if got != tc.want {
+			t.Errorf("%s: OutputMatchesSourceStem(%q, %q) = %v, want %v",
+				tc.name, tc.output, tc.source, got, tc.want)
+		}
+	}
+}
+
+func TestCountNativeArgumentsBasic(t *testing.T) {
+	cases := []struct {
+		name string
+		in   string
+		want int
+	}{
+		{"empty", "", 0},
+		{"single", "x", 1},
+		{"two simple", "a, b", 2},
+		{"three with object", "a, { b: 1, c: 2 }, d", 3},
+		{"comma in string", `"a, b", c`, 2},
+		{"comma in single quote", `'a, b', c, d`, 3},
+		{"escaped quote", `"a\"b", c`, 2},
+		{"comma in template", "`a,b`, c", 2},
+		{"nested call", "foo(a, b), c", 2},
+		{"nested array", "[1, 2, 3], y", 2},
+	}
+	for _, tc := range cases {
+		got := countNativeArguments(tc.in)
+		if got != tc.want {
+			t.Errorf("%s: countNativeArguments(%q) = %d, want %d", tc.name, tc.in, got, tc.want)
+		}
+	}
+}
+
+// Regression: template-literal `${...}` substitutions contain real expressions
+// — any '(' / ')' / ',' inside a substitution must be treated as expression
+// tokens, not template-string content. Prior implementation skipped the entire
+// backtick range as if it were a flat string and miscounted arguments when a
+// substitution contained quote-shaped characters or nested templates.
+func TestCountNativeArgumentsTemplateSubstitution(t *testing.T) {
+	cases := []struct {
+		name string
+		in   string
+		want int
+	}{
+		{"quote-inside-substitution", "`x${\")\"}y`, foo", 2},
+		{"comma-inside-substitution-grouped", "`x${(1, 2)}y`, foo", 2},
+		{"nested-template", "`a${`b${1}c`}d`, foo", 2},
+		{"substitution-with-object", "`x${{ a: 1, b: 2 }}y`, foo", 2},
+		{"call-inside-substitution", "`x${ f(1, 2) }y`, foo", 2},
+	}
+	for _, tc := range cases {
+		got := countNativeArguments(tc.in)
+		if got != tc.want {
+			t.Errorf("%s: countNativeArguments(%q) = %d, want %d", tc.name, tc.in, got, tc.want)
+		}
+	}
+}