@nestia/core 11.2.1 → 12.0.0-dev.20260521.1

package/native/transform/cleanup.go

@@ -0,0 +1,408 @@
+package transform
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+func cleanupTransformedText(text string) string {
+	return cleanupTransformedTextWithRuntimeAliases(text, nil)
+}
+
+func cleanupTransformedTextWithRuntimeAliases(text string, aliases []string) string {
+	text = removeUnusedTypiaImports(text)
+	if aliases == nil {
+		return injectCleanupRuntimeImports(text)
+	}
+	return injectCleanupRuntimeImportsWithAliases(text, aliases)
+}
+
+func removeUnusedTypiaImports(text string) string {
+	prefix := cleanupImportScanPrefix(text)
+	if !strings.Contains(prefix, `require("typia")`) &&
+		!strings.Contains(prefix, `require('typia')`) &&
+		!strings.Contains(prefix, `from "typia"`) &&
+		!strings.Contains(prefix, `from 'typia'`) {
+		return text
+	}
+	type removal struct {
+		start int
+		end   int
+	}
+	removals := []removal{}
+	offset := 0
+	for offset < len(prefix) {
+		next := strings.IndexByte(prefix[offset:], '\n')
+		lineEnd := len(prefix)
+		nextOffset := len(prefix)
+		if next >= 0 {
+			lineEnd = offset + next
+			nextOffset = lineEnd + 1
+		}
+		line := strings.TrimSuffix(prefix[offset:lineEnd], "\r")
+		if alias, ok := unusedTypiaImportAlias(line); ok &&
+			!cleanupIdentifierStillReferenced(text, alias, offset, nextOffset) {
+			removals = append(removals, removal{start: offset, end: nextOffset})
+		}
+		offset = nextOffset
+	}
+	for i := len(removals) - 1; i >= 0; i-- {
+		r := removals[i]
+		text = text[:r.start] + text[r.end:]
+	}
+	return text
+}
+
+func unusedTypiaImportAlias(line string) (string, bool) {
+	if strings.HasPrefix(line, "const ") {
+		index := strings.Index(line, " = ")
+		if index < 0 {
+			return "", false
+		}
+		alias := strings.TrimSpace(strings.TrimPrefix(line[:index], "const "))
+		if isTypiaImportAlias(alias) == false {
+			return "", false
+		}
+		value := strings.TrimSpace(line[index+3:])
+		return alias, value == `__importDefault(require("typia"));` ||
+			value == `__importDefault(require('typia'));` ||
+			value == `require("typia");` ||
+			value == `require('typia');`
+	}
+	if strings.HasPrefix(line, "import ") && strings.HasSuffix(line, ` from "typia";`) {
+		alias := strings.TrimSpace(strings.TrimSuffix(strings.TrimPrefix(line, "import "), ` from "typia";`))
+		return alias, isTypiaImportAlias(alias)
+	}
+	if strings.HasPrefix(line, "import ") && strings.HasSuffix(line, ` from 'typia';`) {
+		alias := strings.TrimSpace(strings.TrimSuffix(strings.TrimPrefix(line, "import "), ` from 'typia';`))
+		return alias, isTypiaImportAlias(alias)
+	}
+	return "", false
+}
+
+func isTypiaImportAlias(alias string) bool {
+	if alias == "typia" {
+		return true
+	}
+	if !strings.HasPrefix(alias, "typia_") {
+		return false
+	}
+	for _, ch := range alias[len("typia_"):] {
+		if ch < '0' || ch > '9' {
+			return false
+		}
+	}
+	return len(alias) > len("typia_")
+}
+
+func cleanupIdentifierStillReferenced(text, alias string, lineStart, lineEnd int) bool {
+	return cleanupIdentifierAppears(text[:lineStart], alias) ||
+		cleanupIdentifierAppears(text[lineEnd:], alias)
+}
+
+func cleanupIdentifierAppears(text string, alias string) bool {
+	offset := 0
+	for {
+		index := strings.Index(text[offset:], alias)
+		if index < 0 {
+			return false
+		}
+		start := offset + index
+		end := start + len(alias)
+		if (start == 0 || !isCleanupRuntimeAliasIdentifierByte(text[start-1])) &&
+			(end == len(text) || !isCleanupRuntimeAliasIdentifierByte(text[end])) {
+			return true
+		}
+		offset = end
+	}
+}
+
+func injectCleanupRuntimeImports(text string) string {
+	aliases := collectCleanupRuntimeAliases(text)
+	return injectCleanupRuntimeImportsWithAliases(text, aliases)
+}
+
+func injectCleanupRuntimeImportsWithAliases(text string, aliases []string) string {
+	if len(aliases) == 0 {
+		return text
+	}
+	esModule := isCleanupESModuleOutput(text)
+	existing := collectExistingCleanupRuntimeImports(text)
+	imports := make([]string, 0, len(aliases))
+	for _, alias := range aliases {
+		module := cleanupRuntimeModuleOf(alias)
+		if existing[cleanupRuntimeImportKey(alias, module)] {
+			continue
+		}
+		name := cleanupRuntimeNameOf(alias)
+		if esModule {
+			imports = append(imports, fmt.Sprintf(`import { %s as %s } from %q;`, name, alias, module))
+		} else {
+			imports = append(imports, fmt.Sprintf(`const { %s: %s } = require(%q);`, name, alias, module))
+		}
+	}
+	if len(imports) == 0 {
+		return text
+	}
+	index := cleanupRuntimeImportInsertionIndex(text, esModule)
+	return text[:index] + strings.Join(imports, "\n") + "\n" + text[index:]
+}
+
+func collectCleanupRuntimeAliases(text string) []string {
+	seen := map[string]bool{}
+	offset := 0
+	for {
+		index := strings.Index(text[offset:], cleanupRuntimeAliasPrefix)
+		if index < 0 {
+			break
+		}
+		start := offset + index
+		end := start + len(cleanupRuntimeAliasPrefix)
+		if start != 0 && isCleanupRuntimeAliasIdentifierByte(text[start-1]) {
+			offset = end
+			continue
+		}
+		for end < len(text) && isCleanupRuntimeAliasNameByte(text[end]) {
+			end++
+		}
+		if end != start+len(cleanupRuntimeAliasPrefix) &&
+			(end == len(text) || !isCleanupRuntimeAliasIdentifierByte(text[end])) {
+			seen[text[start:end]] = true
+		}
+		offset = end
+	}
+	return sortCleanupRuntimeAliases(seen)
+}
+
+func sortCleanupRuntimeAliases(seen map[string]bool) []string {
+	aliases := make([]string, 0, len(seen))
+	for alias := range seen {
+		aliases = append(aliases, alias)
+	}
+	sort.SliceStable(aliases, func(i, j int) bool {
+		left, right := cleanupRuntimeAliasRank(aliases[i]), cleanupRuntimeAliasRank(aliases[j])
+		if left != right {
+			return left < right
+		}
+		return aliases[i] < aliases[j]
+	})
+	return aliases
+}
+
+const cleanupRuntimeAliasPrefix = "__typia_transform_"
+
+func isCleanupRuntimeAliasNameByte(value byte) bool {
+	return (value >= 'A' && value <= 'Z') ||
+		(value >= 'a' && value <= 'z') ||
+		(value >= '0' && value <= '9') ||
+		value == '_'
+}
+
+func isCleanupRuntimeAliasIdentifierByte(value byte) bool {
+	return isCleanupRuntimeAliasNameByte(value) || value == '$'
+}
+
+func cleanupRuntimeAliasRank(alias string) int {
+	name := strings.TrimPrefix(alias, cleanupRuntimeAliasPrefix)
+	switch {
+	case strings.HasPrefix(name, "_is"):
+		return 100
+	case strings.HasPrefix(name, "_assert"):
+		return 150
+	case strings.HasPrefix(name, "_randomFormat"):
+		return 200
+	case name == "_randomString":
+		return 210
+	case name == "_randomInteger":
+		return 220
+	case name == "_randomNumber":
+		return 221
+	case strings.HasPrefix(name, "_random"):
+		return 230
+	case name == "_validateReport":
+		return 800
+	case name == "_createStandardSchema":
+		return 900
+	}
+	return 500
+}
+
+func cleanupRuntimeModuleOf(alias string) string {
+	return "typia/lib/internal/" + cleanupRuntimeNameOf(alias)
+}
+
+func cleanupRuntimeNameOf(alias string) string {
+	name := strings.TrimPrefix(alias, cleanupRuntimeAliasPrefix)
+	if !strings.HasPrefix(name, "_") {
+		name = "_" + name
+	}
+	return name
+}
+
+func collectExistingCleanupRuntimeImports(text string) map[string]bool {
+	output := map[string]bool{}
+	forEachCleanupImportLine(cleanupImportScanPrefix(text), func(line string) {
+		if !strings.Contains(line, cleanupRuntimeAliasPrefix) ||
+			!strings.Contains(line, "typia/lib/internal/") {
+			return
+		}
+		alias, ok := cleanupRuntimeImportAlias(line)
+		if !ok {
+			return
+		}
+		module, ok := cleanupRuntimeImportModule(line)
+		if !ok {
+			return
+		}
+		output[cleanupRuntimeImportKey(alias, module)] = true
+	})
+	return output
+}
+
+func cleanupImportScanPrefix(text string) string {
+	const limit = 1 << 20
+	if len(text) <= limit {
+		return text
+	}
+	return text[:limit]
+}
+
+func cleanupRuntimeImportKey(alias string, module string) string {
+	return alias + "\x00" + module
+}
+
+func forEachCleanupImportLine(text string, iterate func(string)) {
+	for len(text) > 0 {
+		next := strings.IndexByte(text, '\n')
+		line := text
+		if next >= 0 {
+			line = text[:next]
+			text = text[next+1:]
+		} else {
+			text = ""
+		}
+		iterate(strings.TrimSuffix(line, "\r"))
+	}
+}
+
+func cleanupRuntimeImportAlias(line string) (string, bool) {
+	switch {
+	case strings.HasPrefix(line, "const { "):
+		colon := strings.IndexByte(line, ':')
+		if colon < 0 {
+			return "", false
+		}
+		end := strings.IndexByte(line[colon+1:], '}')
+		if end < 0 {
+			return "", false
+		}
+		return cleanupFirstIdentifier(strings.TrimSpace(line[colon+1 : colon+1+end]))
+	case strings.HasPrefix(line, "import { "):
+		index := strings.LastIndex(line, " as ")
+		if index < 0 {
+			return "", false
+		}
+		end := strings.IndexByte(line[index+4:], '}')
+		if end < 0 {
+			return "", false
+		}
+		return cleanupFirstIdentifier(strings.TrimSpace(line[index+4 : index+4+end]))
+	case strings.HasPrefix(line, "const "):
+		rest := strings.TrimPrefix(line, "const ")
+		index := strings.Index(rest, " = require(")
+		if index < 0 {
+			return "", false
+		}
+		return cleanupFirstIdentifier(rest[:index])
+	case strings.HasPrefix(line, "import * as "):
+		rest := strings.TrimPrefix(line, "import * as ")
+		index := strings.Index(rest, " from ")
+		if index < 0 {
+			return "", false
+		}
+		return cleanupFirstIdentifier(rest[:index])
+	default:
+		return "", false
+	}
+}
+
+func cleanupFirstIdentifier(text string) (string, bool) {
+	fields := strings.Fields(text)
+	if len(fields) == 0 {
+		return "", false
+	}
+	name := strings.Trim(fields[0], " \t{}")
+	if !strings.HasPrefix(name, cleanupRuntimeAliasPrefix) {
+		return "", false
+	}
+	return name, true
+}
+
+func cleanupRuntimeImportModule(line string) (string, bool) {
+	for _, marker := range []string{`require("`, `require('`, ` from "`, ` from '`} {
+		index := strings.LastIndex(line, marker)
+		if index < 0 {
+			continue
+		}
+		start := index + len(marker)
+		quote := marker[len(marker)-1]
+		end := strings.IndexByte(line[start:], quote)
+		if end < 0 {
+			return "", false
+		}
+		module := line[start : start+end]
+		if !strings.HasPrefix(module, "typia/lib/internal/") {
+			return "", false
+		}
+		return module, true
+	}
+	return "", false
+}
+
+func isCleanupESModuleOutput(text string) bool {
+	output := false
+	forEachCleanupImportLine(cleanupImportScanPrefix(text), func(line string) {
+		if strings.HasPrefix(line, "import ") ||
+			strings.HasPrefix(line, "import{") ||
+			strings.HasPrefix(line, "import*") ||
+			strings.HasPrefix(line, "export ") {
+			output = true
+		}
+	})
+	return output
+}
+
+func cleanupRuntimeImportInsertionIndex(text string, esModule bool) int {
+	index := 0
+	if strings.HasPrefix(text, "#!") {
+		if next := strings.IndexByte(text, '\n'); next >= 0 {
+			index = next + 1
+		} else {
+			return len(text)
+		}
+	}
+	if esModule {
+		return index
+	}
+	for {
+		next := consumeCleanupRuntimeImportPrefix(text[index:])
+		if next == 0 {
+			return index
+		}
+		index += next
+	}
+}
+
+func consumeCleanupRuntimeImportPrefix(text string) int {
+	for _, prefix := range []string{
+		"\"use strict\";\n",
+		"'use strict';\n",
+		"/* @ttsc-rewritten */\n",
+	} {
+		if strings.HasPrefix(text, prefix) {
+			return len(prefix)
+		}
+	}
+	return 0
+}

package/native/transform/cleanup_test.go

@@ -0,0 +1,76 @@
+package transform
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestCleanupTransformedTextWithRuntimeAliases(t *testing.T) {
+	input := strings.Join([]string{
+		`"use strict";`,
+		`const typia_1 = require("typia");`,
+		`const value = __typia_transform__isTypeInt32(input);`,
+		``,
+	}, "\n")
+
+	output := cleanupTransformedTextWithRuntimeAliases(
+		input,
+		[]string{"__typia_transform__isTypeInt32"},
+	)
+
+	if strings.Contains(output, `require("typia");`) {
+		t.Fatalf("unused typia import was not removed:\n%s", output)
+	}
+	expected := `const { _isTypeInt32: __typia_transform__isTypeInt32 } = require("typia/lib/internal/_isTypeInt32");`
+	if strings.Contains(output, expected) == false {
+		t.Fatalf("runtime import was not injected:\n%s", output)
+	}
+	if strings.Index(output, expected) >= strings.Index(output, "const value") {
+		t.Fatalf("runtime import was inserted after usage:\n%s", output)
+	}
+}
+
+func TestCleanupTransformedTextKeepsReferencedTypiaImport(t *testing.T) {
+	input := strings.Join([]string{
+		`"use strict";`,
+		`const typia_1 = require("typia");`,
+		`const value = typia_1.default.assert(input);`,
+		``,
+	}, "\n")
+
+	output := cleanupTransformedTextWithRuntimeAliases(input, []string{})
+	if strings.Contains(output, `const typia_1 = require("typia");`) == false {
+		t.Fatalf("referenced typia import was removed:\n%s", output)
+	}
+}
+
+func TestCleanupTransformedTextDoesNotDuplicateRuntimeImport(t *testing.T) {
+	existing := `const { _isTypeInt32: __typia_transform__isTypeInt32 } = require("typia/lib/internal/_isTypeInt32");`
+	input := strings.Join([]string{
+		`"use strict";`,
+		existing,
+		`const value = __typia_transform__isTypeInt32(input);`,
+		``,
+	}, "\n")
+
+	output := cleanupTransformedTextWithRuntimeAliases(
+		input,
+		[]string{"__typia_transform__isTypeInt32"},
+	)
+	if strings.Count(output, existing) != 1 {
+		t.Fatalf("runtime import was duplicated:\n%s", output)
+	}
+}
+
+func TestNativeRewriteSetCollectsRuntimeAliasesFromAppendArguments(t *testing.T) {
+	rewrites := newNativeRewriteSet()
+	rewrites.Add(nativeRewrite{
+		FilePath:        "/project/src/controller.ts",
+		AppendArguments: []string{`__typia_transform__httpQueryParseURLSearchParams(input)`},
+	})
+
+	aliases := rewrites.RuntimeAliasesForOutput("/project/lib/controller.js")
+	if len(aliases) != 1 || aliases[0] != "__typia_transform__httpQueryParseURLSearchParams" {
+		t.Fatalf("unexpected aliases: %#v", aliases)
+	}
+}

package/native/transform/commonjs_import_alias_test.go

@@ -0,0 +1,49 @@
+package transform
+
+import "testing"
+
+// Verifies commonJSImportAliasBase produces a valid JS identifier base
+// for every module specifier the CommonJS substitution table feeds it.
+//
+// Output forms the `<base>_N.default` substitution map that the native
+// rewrite scan looks up against tsgo's CJS emit. Any input that produces
+// a non-identifier base (leading digit, contains `-`, empty after
+// extension strip) would generate a substitution that never matches
+// tsgo's emit and silently break the rewrite for that import. The
+// reverted P-8 sat on top of this helper — locking the branches now
+// guards the rewrite contract against future emit-side changes.
+//
+//  1. Letters / digits / `_` / `$` survive verbatim.
+//  2. Non-identifier characters (dashes, dots, slashes) become `_`.
+//  3. Empty or pathological bases (`.`, `/`) fall back to `mod`.
+//  4. Leading digits are prefixed with `_` so the base is identifier-safe.
+//  5. Unicode letters survive (Go's `unicode.IsLetter`).
+//  6. File extensions are stripped before sanitization.
+func TestCommonJSImportAliasBaseProducesIdentifierSafeName(t *testing.T) {
+	cases := []struct {
+		name   string
+		module string
+		want   string
+	}{
+		{"plain package", "typia", "typia"},
+		{"scoped package", "@nestia/core", "core"},
+		{"dotted package", "lodash.merge", "lodash"},
+		{"path with slashes", "@nestia/core/lib/transform", "transform"},
+		{"dashes become underscores", "kebab-case-lib", "kebab_case_lib"},
+		{"trailing extension stripped", "module.mjs", "module"},
+		{"empty becomes mod", "", "mod"},
+		{"dot becomes mod", ".", "mod"},
+		{"leading digit prefixed with underscore", "1abc", "_1abc"},
+		{"underscore start preserved", "_internal", "_internal"},
+		{"dollar start preserved", "$jq", "$jq"},
+		{"unicode letter preserved", "한글", "한글"},
+		{"mixed special chars sanitized", "foo.bar-baz", "foo"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := commonJSImportAliasBase(tc.module); got != tc.want {
+				t.Fatalf("commonJSImportAliasBase(%q) = %q, want %q", tc.module, got, tc.want)
+			}
+		})
+	}
+}

package/native/transform/core_dispatch_test.go

@@ -0,0 +1,127 @@
+package transform
+
+import "testing"
+
+// Verifies nestiaCoreParameterKind maps every supported decorator suffix
+// to the programmer kind that drives validator generation.
+//
+// The suffix table is the single source of truth for parameter-decorator
+// dispatch — a silent typo or a missing entry would silently route the
+// affected decorator to the no-op path and emit no validator. The
+// `WebSocketRoute.Header`-as-`TypedBody` and `EncryptedBody`-as-`TypedBody`
+// rows are non-obvious: WebSocket header and encrypted body re-use the
+// TypedBody programmer because their on-the-wire payload shape matches.
+//
+//  1. Every documented suffix returns the matching kind.
+//  2. Multi-segment suffixes (`TypedQuery.Body`, `WebSocketRoute.Param`)
+//     resolve only when both tail segments line up.
+//  3. Unknown suffixes return the empty string (the no-op signal).
+func TestNestiaCoreParameterKindDispatch(t *testing.T) {
+	cases := []struct {
+		name     string
+		segments []string
+		want     string
+	}{
+		{"bare TypedBody", []string{"TypedBody"}, "TypedBody"},
+		{"imported core.TypedBody", []string{"core", "TypedBody"}, "TypedBody"},
+		{"EncryptedBody maps to TypedBody", []string{"EncryptedBody"}, "TypedBody"},
+		{"TypedHeaders", []string{"TypedHeaders"}, "TypedHeaders"},
+		{"TypedParam", []string{"TypedParam"}, "TypedParam"},
+		{"TypedQuery solo", []string{"TypedQuery"}, "TypedQuery"},
+		{"PlainBody", []string{"PlainBody"}, "PlainBody"},
+		{"TypedQuery.Body", []string{"TypedQuery", "Body"}, "TypedQueryBody"},
+		{"TypedFormData.Body", []string{"TypedFormData", "Body"}, "TypedFormDataBody"},
+		{"WebSocketRoute.Header maps to TypedBody", []string{"WebSocketRoute", "Header"}, "TypedBody"},
+		{"WebSocketRoute.Param maps to TypedParam", []string{"WebSocketRoute", "Param"}, "TypedParam"},
+		{"WebSocketRoute.Query maps to TypedQuery", []string{"WebSocketRoute", "Query"}, "TypedQuery"},
+		{"unknown decorator", []string{"TypedSomethingElse"}, ""},
+		{"empty segments", []string{}, ""},
+		{"TypedQuery.Other is not TypedQueryBody", []string{"TypedQuery", "Other"}, ""},
+		{"WebSocketRoute alone is not a parameter", []string{"WebSocketRoute"}, ""},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := nestiaCoreParameterKind(tc.segments); got != tc.want {
+				t.Fatalf("nestiaCoreParameterKind(%v) = %q, want %q", tc.segments, got, tc.want)
+			}
+		})
+	}
+}
+
+// Verifies nestiaCoreMethodKind dispatches HTTP-method decorators to the
+// correct route programmer kind.
+//
+// The two-position lookup (`[..., ROOT, VERB]`) keeps `EncryptedRoute.Post`
+// distinct from `TypedQuery.Body` — both have two tail segments but only
+// the former is a route. The verb whitelist (Get/Post/Patch/Put/Delete)
+// pins the contract: any new HTTP verb would have to be added explicitly,
+// preventing accidental dispatch on a typo like `Posts`.
+//
+//  1. Each HTTP verb under `TypedRoute` or `EncryptedRoute` returns `TypedRoute`.
+//  2. Each HTTP verb under `TypedQuery` returns `TypedQueryRoute`.
+//  3. Unknown roots or unknown verbs return the empty string.
+//  4. Single-segment or empty segment lists return the empty string.
+func TestNestiaCoreMethodKindDispatch(t *testing.T) {
+	cases := []struct {
+		name     string
+		segments []string
+		want     string
+	}{
+		{"TypedRoute.Get", []string{"TypedRoute", "Get"}, "TypedRoute"},
+		{"TypedRoute.Post", []string{"TypedRoute", "Post"}, "TypedRoute"},
+		{"TypedRoute.Patch", []string{"TypedRoute", "Patch"}, "TypedRoute"},
+		{"TypedRoute.Put", []string{"TypedRoute", "Put"}, "TypedRoute"},
+		{"TypedRoute.Delete", []string{"TypedRoute", "Delete"}, "TypedRoute"},
+		{"EncryptedRoute.Post", []string{"EncryptedRoute", "Post"}, "TypedRoute"},
+		{"TypedQuery.Get", []string{"TypedQuery", "Get"}, "TypedQueryRoute"},
+		{"imported core.TypedRoute.Get", []string{"core", "TypedRoute", "Get"}, "TypedRoute"},
+		{"unknown verb", []string{"TypedRoute", "Head"}, ""},
+		{"unknown root", []string{"SomethingElse", "Get"}, ""},
+		{"single segment", []string{"Get"}, ""},
+		{"empty segments", []string{}, ""},
+		{"verb-only suffix", []string{"TypedQuery", "Body"}, ""},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := nestiaCoreMethodKind(tc.segments); got != tc.want {
+				t.Fatalf("nestiaCoreMethodKind(%v) = %q, want %q", tc.segments, got, tc.want)
+			}
+		})
+	}
+}
+
+// Verifies nestiaCoreSegmentsHaveSuffix matches the suffix slice against
+// the trailing positions of the segment slice.
+//
+// The helper underpins every decorator-dispatch lookup. Off-by-one or
+// length-clamping bugs would silently mismatch `core.TypedQuery.Body`
+// against the suffix `["TypedQuery"]` — a regression flagged by the
+// existing decorator routing tests, but cheap to anchor at the helper
+// level too.
+//
+//  1. Exact length match returns true.
+//  2. Shorter segments than the suffix never match.
+//  3. Suffix tail of a longer segment list matches; prefix tail does not.
+func TestNestiaCoreSegmentsHaveSuffix(t *testing.T) {
+	cases := []struct {
+		name     string
+		segments []string
+		suffix   []string
+		want     bool
+	}{
+		{"exact match", []string{"TypedBody"}, []string{"TypedBody"}, true},
+		{"suffix of longer", []string{"core", "TypedBody"}, []string{"TypedBody"}, true},
+		{"two-segment suffix", []string{"core", "TypedQuery", "Body"}, []string{"TypedQuery", "Body"}, true},
+		{"suffix longer than segments", []string{"TypedBody"}, []string{"core", "TypedBody"}, false},
+		{"mismatched tail", []string{"core", "TypedBody"}, []string{"TypedRoute"}, false},
+		{"empty suffix", []string{"core", "TypedBody"}, []string{}, true},
+		{"both empty", []string{}, []string{}, true},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := nestiaCoreSegmentsHaveSuffix(tc.segments, tc.suffix); got != tc.want {
+				t.Fatalf("nestiaCoreSegmentsHaveSuffix(%v, %v) = %v, want %v", tc.segments, tc.suffix, got, tc.want)
+			}
+		})
+	}
+}