@nestia/core 14.0.0 → 14.0.2

package/native/transform/package.go

@@ -0,0 +1,55 @@
+package transform
+
+import (
+	"encoding/json"
+	"path/filepath"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// SourceFilePackageName returns the nearest package-scope manifest's name for a
+// resolved declaration source. A node_modules boundary ends the scope before
+// its manifest is read. Missing, unreadable or malformed ownership
+// returns an empty name; a foreign or invalid nearest manifest never falls
+// through to an enclosing package.
+//
+// The loaded program filesystem owns path resolution, including its overlays
+// and dependency observations. This performs one ancestor walk without retaining
+// programs or caching an owner across unrelated compilation requests.
+//
+// @evidence contracts/common.md#principled-implementation Node's LOOKUP_PACKAGE_SCOPE ends at the node_modules path component before reading a manifest there. Within that scope the nearest manifest's decoded name decides declaration identity. A present unreadable or invalid manifest also stops resolution, so neither a manifestless dependency nor an invalid foreign owner inherits an enclosing core, rxjs, tgrid or typia owner.
+// @evidence contracts/common.md#clear-and-simple-design One ancestor loop returns one decoded name, with nil, package-scope boundary and filesystem-root termination. All declaration provenance consumers share this operation rather than duplicating ownership policies.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The literal node_modules component establishes Node's documented scope boundary, not package identity. No library-directory spelling, fixture name or type name substitutes for the actual scoped manifest name. Reads use the program filesystem.
+// @evidence contracts/common.md#meaningful-documentation The comment defines scoped nearest-manifest semantics, boundary-before-read termination, empty results, overlay ownership and the absence of cross-program retention. The rule follows Node's ESM resolution LOOKUP_PACKAGE_SCOPE specification.
+// @evidence contracts/portability.md#os-neutral-implementation filepath.Dir, Base and Join represent native path components, and the driver's filesystem performs reads/existence checks. Exact node_modules component comparison follows Node's scope algorithm; no shell path or slash-substring membership test is composed.
+// @evidence contracts/performance.md#efficient-algorithms One read per ancestor and an existence check only after a failed read cost O(directory depth plus the first manifest's bytes). No source graph or dependency tree is recursively searched.
+// @evidence contracts/performance.md#reuse-equivalent-work The program filesystem supplies its own coherent read/overlay observation model. This operation shares no result across programs because manifest inputs and overlays may differ between requests.
+// @evidence contracts/performance.md#bound-retention-and-release-resources Only the current ancestor string and one manifest buffer/decoded name are retained; no program pointer, global owner map, descriptor or filesystem handle survives the call.
+func SourceFilePackageName(prog *driver.Program, source *shimast.SourceFile) string {
+	if prog == nil || prog.FS == nil || source == nil {
+		return ""
+	}
+	for directory := filepath.Dir(source.FileName()); ; {
+		if filepath.Base(directory) == "node_modules" {
+			return ""
+		}
+		manifest := filepath.Join(directory, "package.json")
+		if contents, ok := prog.FS.ReadFile(manifest); ok {
+			var pack struct {
+				Name string `json:"name"`
+			}
+			if json.Unmarshal([]byte(contents), &pack) != nil {
+				return ""
+			}
+			return pack.Name
+		} else if prog.FS.FileExists(manifest) {
+			return ""
+		}
+		parent := filepath.Dir(directory)
+		if parent == directory {
+			return ""
+		}
+		directory = parent
+	}
+}

package/native/transform/printer.go

@@ -4,8 +4,6 @@ import (
 	shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
-const nestiaKindColonToken = shimast.KindQuestionToken + 1
-
 func normalizeNestiaSyntheticTokens(node *shimast.Node) {
 	if node == nil {
 		return
@@ -17,7 +15,7 @@ func normalizeNestiaSyntheticTokens(node *shimast.Node) {
 			conditional.QuestionToken = factory.NewToken(shimast.KindQuestionToken)
 		}
 		if conditional.ColonToken == nil {
-			conditional.ColonToken = factory.NewToken(nestiaKindColonToken)
+			conditional.ColonToken = factory.NewToken(shimast.KindColonToken)
 		}
 	}
 	node.ForEachChild(func(child *shimast.Node) bool {

package/native/transform/run.go

@@ -25,6 +25,15 @@ var (
 // decorator rewrites, then runs any statically linked contributor rewrite
 // collectors such as the SDK metadata pass when the caller explicitly enables
 // them.
+//
+// @evidence contracts/common.md#principled-implementation The command runs inside a `recover`, so an unexpected panic becomes one diagnostic line with the same shape as every other diagnostic and exit code 3 instead of a raw Go stack, and the stack is printed only when `NESTIA_NATIVE_DEBUG_STACK` is set.
+// @evidence contracts/common.md#clear-and-simple-design One deferred handler around the private dispatcher.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The recovery reports the failure; it does not retry or hide it, and the exit code stays non-zero.
+// @evidence contracts/common.md#meaningful-documentation The comment explains the recovery envelope, the diagnostic shape, and the debug variable.
+// @evidence contracts/portability.md#os-neutral-implementation Argument vectors are passed as strings to Go flag parsing without shell composition. Native working directories and file outputs are handled by os/filepath and the loaded program filesystem in the dispatched commands.
+// @evidence contracts/performance.md#efficient-algorithms Dispatch itself is constant work; build/transform cost is owned by their program load, diagnostics and per-file emit passes, not by the recovery wrapper.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work This operation does not coordinate equivalent requests; its result is derived from the supplied value or the current command and compiler program.
+// @evidence contracts/performance.md#bound-retention-and-release-resources Commands defer program and publication cleanup; linked collectors remain process-owned. The debug stack is allocated only after a panic.
 func Run(args []string) (code int) {
 	defer func() {
 		if exp := recover(); exp != nil {
@@ -57,6 +66,15 @@ func Run(args []string) (code int) {
 // writers are package state, so concurrent calls would interleave; the host runs
 // one command per process and Go tests in one package run sequentially unless
 // they opt into t.Parallel.
+//
+// @evidence contracts/common.md#principled-implementation The two package writers are replaced for the duration of one call and restored by a `defer`, so a caller can observe the JSON envelope of the project-mode transform, which an exit code alone cannot show; a nil writer leaves its stream unchanged.
+// @evidence contracts/common.md#clear-and-simple-design One function that swaps the writers, calls `Run`, and restores them.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts This is a test seam kept as an exported function because the external test module cannot reach the private writers; it changes no behavior of the command, but it mutates package state and is therefore not safe for concurrent calls, as its comment says, and it is used only by the Go test modules.
+// @evidence contracts/common.md#meaningful-documentation The comment explains why the seam exists, its restore behavior, and the concurrency limit.
+// @evidence contracts/portability.md#os-neutral-implementation Streams use caller supplied io.Writer values, with native file and process boundaries handled by Run and its dispatcher.
+// @evidence contracts/performance.md#efficient-algorithms Swapping two stream references is constant work; the dispatched command determines compilation cost.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work This operation does not coordinate equivalent requests; its result is derived from the supplied value or the current command and compiler program.
+// @evidence contracts/performance.md#bound-retention-and-release-resources The call borrows writers and restores previous references on return or panic; it neither closes caller writers nor supports concurrent calls.
 func RunWithOutput(args []string, out io.Writer, errOut io.Writer) int {
 	previousOut, previousErr := stdout, stderr
 	defer func() {

package/native/transform/schemaprojection/project.go

@@ -0,0 +1,213 @@
+package schemaprojection
+
+import metadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+
+// Project gives the schema writer an isolated representation
+// of an absorbed metadata graph. Recursive tuples occupy named alias slots
+// so the writer registers their component before visiting its children. Arrays
+// retain their native recursive representation and every name remains the
+// identifier allocated by the original metadata collection.
+//
+// The returned graph shares read-only scalar annotations but no metadata or
+// component node whose traversal or name cache the writer can mutate. The raw
+// graph remains the source of reflected interop data. Callers must use the
+// returned root for both the main schema and decomposed property schemas.
+// This type-only metadata foundation lives in the stable core host module:
+// contributor packages are relocated by ttsc, while their host imports keep
+// this module identity. The SDK owns baking and calls this operation across
+// that production boundary; this package has no SDK module dependency.
+//
+// @evidence contracts/common.md#principled-implementation SDK analysis absorbs aliases, while the schema writer only breaks tuple cycles through named alias components. Replacing recursive tuple uses by aliases of the same collection-allocated semantic slot retains tuple elements and recursive edges without creating names or changing raw reflection. Memoized copies are registered before visiting edges, preserving shared and mutually recursive identities.
+// @evidence contracts/common.md#clear-and-simple-design One graph projection owns the writer representation; a private visitor copies metadata and component edges, and one tuple helper separates a named use from its inline component body.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The mapping follows recursive tuple metadata and original collection names for every input. It does not mutate foreign implementations, change absorption options, recognize fixture names, or catch schema failures.
+// @evidence contracts/common.md#meaningful-documentation The comment explains absorbed input, recursive tuple representation, original name ownership, isolation and the requirement to share the returned root with property schema generation.
+// @evidence contracts/performance.md#efficient-algorithms Pointer maps visit each metadata and component once, and copy each outgoing edge once, for O(V+E+annotation payload) work and space. The projection adds no checker analysis, compiler or host operation.
+// @evidence contracts/performance.md#reuse-equivalent-work Pointer memoization reuses each original metadata and component's projection when several edges reach the same identity within this invocation. The immutable supplied graph establishes equivalence, and the caller reuses that one returned graph for root and property schema writes against shared components. Each different invocation owns fresh maps and does not reuse a projection across changed inputs.
+// @evidence contracts/performance.md#bound-retention-and-release-resources Memo maps and copied nodes belong to one bake invocation and become reclaimable with its result; no global cache, handle or background work is retained.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation The projection visits an in-memory typia metadata graph with no native file identity or subprocess boundary.
+func Project(input *metadata.MetadataSchema) *metadata.MetadataSchema {
+	projection := &projection{
+		metadatas:    map[*metadata.MetadataSchema]*metadata.MetadataSchema{},
+		arrays:       map[*metadata.MetadataArrayType]*metadata.MetadataArrayType{},
+		tuples:       map[*metadata.MetadataTupleType]*metadata.MetadataTupleType{},
+		objects:      map[*metadata.MetadataObjectType]*metadata.MetadataObjectType{},
+		aliases:      map[*metadata.MetadataAliasType]*metadata.MetadataAliasType{},
+		tupleAliases: map[*metadata.MetadataTupleType]*metadata.MetadataAliasType{},
+	}
+	return projection.visit(input)
+}
+
+// projection retains invocation-local graph identities, including
+// separate tuple component bodies and their named recursive use sites.
+type projection struct {
+	metadatas    map[*metadata.MetadataSchema]*metadata.MetadataSchema
+	arrays       map[*metadata.MetadataArrayType]*metadata.MetadataArrayType
+	tuples       map[*metadata.MetadataTupleType]*metadata.MetadataTupleType
+	objects      map[*metadata.MetadataObjectType]*metadata.MetadataObjectType
+	aliases      map[*metadata.MetadataAliasType]*metadata.MetadataAliasType
+	tupleAliases map[*metadata.MetadataTupleType]*metadata.MetadataAliasType
+}
+
+// visit copies every metadata edge before a writer can reach it. Shared scalar
+// tag and documentation payloads are read-only to the schema writer.
+func (p *projection) visit(input *metadata.MetadataSchema) *metadata.MetadataSchema {
+	if input == nil {
+		return nil
+	}
+	if output, ok := p.metadatas[input]; ok {
+		return output
+	}
+	output := input.ShallowClone()
+	p.metadatas[input] = output
+	output.Rest = p.visit(input.Rest)
+	if input.Escaped != nil {
+		copy := *input.Escaped
+		output.Escaped = &copy
+		copy.Original, copy.Returns = p.visit(input.Escaped.Original), p.visit(input.Escaped.Returns)
+	}
+	output.Atomics = copyLeaves(input.Atomics)
+	output.Constants = copyLeaves(input.Constants)
+	output.Natives = copyLeaves(input.Natives)
+	output.Templates = copyLeaves(input.Templates)
+	for i, entry := range input.Templates {
+		if entry == nil {
+			continue
+		}
+		output.Templates[i].Row = make([]*metadata.MetadataSchema, len(entry.Row))
+		for j, child := range entry.Row {
+			output.Templates[i].Row[j] = p.visit(child)
+		}
+	}
+	output.Functions = copyLeaves(input.Functions)
+	for i, entry := range input.Functions {
+		if entry == nil {
+			continue
+		}
+		copy := output.Functions[i]
+		copy.Output = p.visit(entry.Output)
+		copy.Parameters = copyLeaves(entry.Parameters)
+		for j, parameter := range entry.Parameters {
+			if parameter != nil {
+				copy.Parameters[j].Type = p.visit(parameter.Type)
+			}
+		}
+	}
+	output.Sets = copyLeaves(input.Sets)
+	for i, entry := range input.Sets {
+		if entry != nil {
+			output.Sets[i].Value = p.visit(entry.Value)
+		}
+	}
+	output.Maps = copyLeaves(input.Maps)
+	for i, entry := range input.Maps {
+		if entry != nil {
+			output.Maps[i].Key, output.Maps[i].Value = p.visit(entry.Key), p.visit(entry.Value)
+		}
+	}
+	output.Arrays = copyLeaves(input.Arrays)
+	for i, entry := range input.Arrays {
+		if entry == nil || entry.Type == nil {
+			continue
+		}
+		component, ok := p.arrays[entry.Type]
+		if !ok {
+			copy := *entry.Type
+			component = &copy
+			p.arrays[entry.Type] = component
+			component.Value = p.visit(entry.Type.Value)
+		}
+		output.Arrays[i].Type = component
+	}
+	output.Objects = copyLeaves(input.Objects)
+	for i, entry := range input.Objects {
+		if entry == nil || entry.Type == nil {
+			continue
+		}
+		component, ok := p.objects[entry.Type]
+		if !ok {
+			copy := *entry.Type
+			component = &copy
+			p.objects[entry.Type] = component
+			component.Properties = copyLeaves(entry.Type.Properties)
+			for j, property := range entry.Type.Properties {
+				if property != nil {
+					component.Properties[j].Key, component.Properties[j].Value = p.visit(property.Key), p.visit(property.Value)
+				}
+			}
+		}
+		output.Objects[i].Type = component
+	}
+	output.Aliases = copyLeaves(input.Aliases)
+	for i, entry := range input.Aliases {
+		if entry == nil || entry.Type == nil {
+			continue
+		}
+		component, ok := p.aliases[entry.Type]
+		if !ok {
+			copy := *entry.Type
+			component = &copy
+			p.aliases[entry.Type] = component
+			component.Value = p.visit(entry.Type.Value)
+		}
+		output.Aliases[i].Type = component
+	}
+	output.Tuples = make([]*metadata.MetadataTuple, 0, len(input.Tuples))
+	for _, entry := range input.Tuples {
+		if entry == nil || entry.Type == nil {
+			output.Tuples = append(output.Tuples, entry)
+			continue
+		}
+		if entry.Type.Recursive {
+			alias, ok := p.tupleAliases[entry.Type]
+			if !ok {
+				alias = metadata.MetadataAliasType_create(metadata.MetadataAliasType{
+					Name: entry.Type.Name, DisplayName: entry.Type.DisplayName, Recursive: true, Nullables: entry.Type.Nullables,
+				})
+				p.tupleAliases[entry.Type] = alias
+				body := metadata.MetadataSchema_initialize()
+				alias.Value = body
+				copy := *entry
+				copy.Type = p.tuple(entry.Type)
+				body.Tuples = []*metadata.MetadataTuple{&copy}
+			}
+			output.Aliases = append(output.Aliases, metadata.MetadataAlias_create(metadata.MetadataAlias{Type: alias, Tags: entry.Tags}))
+		} else {
+			copy := *entry
+			copy.Type = p.tuple(entry.Type)
+			output.Tuples = append(output.Tuples, &copy)
+		}
+	}
+	return output
+}
+
+// tuple copies a structural component after registering its identity, allowing
+// its child metadata to return through the already registered named alias.
+func (p *projection) tuple(input *metadata.MetadataTupleType) *metadata.MetadataTupleType {
+	if output, ok := p.tuples[input]; ok {
+		return output
+	}
+	copy := *input
+	output := &copy
+	p.tuples[input] = output
+	output.Elements = make([]*metadata.MetadataSchema, len(input.Elements))
+	for i, element := range input.Elements {
+		output.Elements[i] = p.visit(element)
+	}
+	return output
+}
+
+// copyLeaves isolates node-local name caches. Scalar annotation
+// slices remain shared because the public schema writer only reads them.
+func copyLeaves[T any](input []*T) []*T {
+	if input == nil {
+		return nil
+	}
+	output := make([]*T, len(input))
+	for i, item := range input {
+		if item != nil {
+			copy := *item
+			output[i] = &copy
+		}
+	}
+	return output
+}

package/native/transform/transform.go

@@ -7,7 +7,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"regexp"
+	"reflect"
 	"strings"
 
 	shimast "github.com/microsoft/typescript-go/shim/ast"
@@ -169,7 +169,14 @@ func runTransformProject(
 		sf := prog.SourceFile(fileName)
 		return sf != nil && prog.TSProgram.IsLibFile(sf)
 	})
-	schemametadata.MetadataDependency_listen(prog.Checker, collector.Touch)
+	// `File` alone is the whole listener this host needs. `Callee` falls back
+	// to it, and the two channels differ only in whether a default library
+	// withholds a completeness declaration, which this host never makes;
+	// `Unbounded` is ignorable for the same reason, since an unreported input
+	// is still watched through the reference graph.
+	schemametadata.MetadataDependency_listen(prog.Checker, schemametadata.MetadataDependency_IListener{
+		File: collector.Touch,
+	})
 	defer schemametadata.MetadataDependency_release(prog.Checker)
 	for _, sf := range prog.SourceFiles() {
 		if sf.IsDeclarationFile {
@@ -245,6 +252,19 @@ func writeSingleOutput(text, outPath string) int {
 	return 0
 }
 
+// SourceFileText returns the text supplied by a present Text() provider.
+// Missing values, including typed nil receivers, and values without Text()
+// return empty text and false without invoking a method. Errors from a present
+// provider's Text() method propagate to its caller.
+//
+// @evidence contracts/common.md#principled-implementation Structural Text() support establishes the provider operation, while a guarded reflect nil-identity check establishes that a receiver exists before dispatch. Every nil-capable kind follows the same absent-source rule; non-nil providers return their own text unchanged.
+// @evidence contracts/common.md#clear-and-simple-design One structural type assertion, one constant-time receiver-presence check restricted to the kinds for which Go permits IsNil, and one method dispatch separate absent sources from actual provider behavior.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The nil rule applies to all structural providers without compiler-type names or recovery. It does not invoke missing receivers, mutate foreign providers or conceal errors raised by present providers.
+// @evidence contracts/common.md#meaningful-documentation The comment states exact absent-value behavior, typed nil receiver treatment and propagation of present-provider errors.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation The Text provider is an in-memory structural interface; the helper does not read a native source file.
+// @evidence contracts/performance.md#efficient-algorithms Type and nil checks are constant work; obtaining the string has the provider-defined cost.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work This operation does not coordinate equivalent requests; its result is derived from the supplied value or the current command and compiler program.
+// @evidence contracts/performance.md#bound-retention-and-release-resources The provider owns source text and the returned string may retain those bytes; no global provider reference is stored.
 func SourceFileText(target any) (string, bool) {
 	type sourceText interface {
 		Text() string
@@ -253,25 +273,16 @@ func SourceFileText(target any) (string, bool) {
 	if !ok {
 		return "", false
 	}
+	value := reflect.ValueOf(file)
+	switch value.Kind() {
+	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice, reflect.UnsafePointer:
+		if value.IsNil() {
+			return "", false
+		}
+	}
 	return file.Text(), true
 }
 
-// These patterns run once per transformed file in cleanupTypeScriptTransformText
-// / normalizeParenthesizedTypeAnnotations. Compiling them at package scope keeps
-// the per-file cost to a match instead of a recompile (the SDK `transform` path
-// runs this for every emitted source file).
-var (
-	cleanupImportTypeBlockPattern   = regexp.MustCompile(`(?m)^import type \{([^{}\n]+)\} from`)
-	cleanupImportTypeLinePattern    = regexp.MustCompile(`^import type \{\s*([^{}\n]+?)\s*\} from`)
-	cleanupImportBlankLinePattern   = regexp.MustCompile(`(?m)(^import [^\n]+;\n)\n+(const |let |var |export )`)
-	cleanupInputIsParenPattern      = regexp.MustCompile(`input is \(([A-Za-z_$][A-Za-z0-9_$.]*)\)`)
-	cleanupCollapseBlankCallPattern = regexp.MustCompile(`\n\n([A-Za-z_$][A-Za-z0-9_$]*\([^;\n]*\);?)`)
-)
-var (
-	normalizeParenArrowTypePattern = regexp.MustCompile(`: \(([A-Za-z_$][A-Za-z0-9_$.]*(<[^()\n;{}]*>)?)\)(\s*=>)`)
-	normalizeParenNullishPattern   = regexp.MustCompile(`\| \((null|undefined)\)`)
-)
-
 func transformDiagnosticToCompilerDiagnostic(
 	diag Diagnostic,
 ) transformCompilerDiagnostic {

package/native/transform/typia_fast.go

@@ -1,6 +1,8 @@
 package transform
 
 import (
+	"sync"
+
 	shimast "github.com/microsoft/typescript-go/shim/ast"
 	shimprinter "github.com/microsoft/typescript-go/shim/printer"
 	shimscanner "github.com/microsoft/typescript-go/shim/scanner"
@@ -22,6 +24,10 @@ func nestiaTypiaNodeTransform(
 ) driver.PluginTransform {
 	transformOptions := pluginOptions.TransformOptions()
 	extras := nativecontext.ITypiaContext_Extras{
+		// One cache for the whole program, as typia's own hosts share it: left
+		// nil, typia makes one per file, and a program-wide analysis such as
+		// `llm.evaluation`'s `@probability` scan reruns for every file.
+		Shared: &sync.Map{},
 		AddDiagnostic: func(diag *nativecontext.ITypiaDiagnostic) int {
 			addDiagnostic(nestiaTypiaDiagnosticFrom(diag))
 			return 1

package/native/transform.cjs

@@ -16,16 +16,65 @@ const path = require("node:path");
 //   - When the `@nestia/core` plugin itself is disabled, this descriptor is
 //     never evaluated, so the SDK contributor is never linked either.
 function createTtscPlugin(context) {
+  const typia = assertTypiaVersion(context);
   const plugin = {
     name: "@nestia/core",
     source: path.resolve(__dirname, "cmd", "ttsc-nestia"),
     composes: ["typia/lib/transform"],
+    // a typia upgrade must evaluate the version check again
+    hostInputs: typia,
   };
   const sdk = resolveSdkContributorSource(context);
   if (sdk !== null) plugin.contributors = [{ name: "sdk", source: sdk }];
   return plugin;
 }
 
+// The typia transform this host runs is compiled from the typia Go source
+// nestia's own `go.mod` pins, never from the typia package the project installs,
+// while the code it emits calls that installed package's runtime. A project
+// resolving another typia version would run mismatched code with no error until
+// a call reaches the difference (#1663), so the build stops and names both
+// versions. The version nestia is built for is the typia @nestia/core itself
+// resolves, which its exact dependency holds at the Go pin's release.
+//
+// Returns the typia manifests read, for ttsc to watch.
+function assertTypiaVersion(context) {
+  const expected = resolveTypiaManifest([__dirname]);
+  const actual =
+    context && typeof context.projectRoot === "string"
+      ? resolveTypiaManifest([context.projectRoot])
+      : null;
+  if (
+    expected !== null &&
+    actual !== null &&
+    expected.version !== actual.version
+  )
+    throw new Error(
+      [
+        `@nestia/core runs the typia ${expected.version} transform, but this project resolves typia ${actual.version} (${actual.file}).`,
+        `The generated code would call typia ${actual.version}'s runtime with typia ${expected.version}'s output.`,
+        `Install typia@${expected.version}, or a @nestia/core release built for typia ${actual.version}.`,
+      ].join(" "),
+    );
+  return [
+    ...new Set(
+      [expected, actual]
+        .filter((manifest) => manifest !== null)
+        .map((manifest) => manifest.file),
+    ),
+  ];
+}
+
+function resolveTypiaManifest(paths) {
+  try {
+    const file = require.resolve("typia/package.json", { paths });
+    const version = JSON.parse(fs.readFileSync(file, "utf8")).version;
+    return typeof version === "string" ? { file, version } : null;
+  } catch {
+    return null;
+  }
+}
+
 function resolveSdkContributorSource(context) {
   const paths = [__dirname];
   if (context && typeof context.projectRoot === "string")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestia/core",
-  "version": "14.0.0",
+  "version": "14.0.2",
   "description": "Super-fast validation decorators of NestJS",
   "main": "lib/index.js",
   "exports": {
@@ -8,10 +8,7 @@
       "types": "./lib/index.d.ts",
       "default": "./lib/index.js"
     },
-    "./lib/transform": {
-      "types": "./lib/transform.d.ts",
-      "default": "./lib/transform.js"
-    },
+    "./lib/transform": "./native/transform.cjs",
     "./native/transform.cjs": "./native/transform.cjs",
     "./package.json": "./package.json"
   },
@@ -49,24 +46,24 @@
     "@typia/utils": "^15.0.0",
     "get-function-location": "^2.0.0",
     "glob": "^11.0.3",
-    "path-parser": "^6.1.0",
+    "path-to-regexp": "^8.4.2",
     "raw-body": "^2.0.0",
     "reflect-metadata": ">=0.1.12",
-    "rxjs": ">=6.0.3",
+    "rxjs": ">=7.1.0",
     "tgrid": "^1.1.0",
-    "typia": "^15.0.0",
+    "typia": "15.0.0",
     "ws": "^7.5.3",
-    "@nestia/fetcher": "^14.0.0"
+    "@nestia/fetcher": "^14.0.2"
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^1.18.0",
-    "@nestjs/common": ">=7.0.1",
-    "@nestjs/core": ">=7.0.1",
+    "@nestjs/common": ">=11.0.0",
+    "@nestjs/core": ">=11.0.0",
     "reflect-metadata": ">=0.1.12",
-    "rxjs": ">=6.0.3",
+    "rxjs": ">=7.1.0",
     "ttsc": ">=0.19.2",
-    "typia": "^15.0.0",
-    "@nestia/fetcher": "^14.0.0"
+    "typia": "15.0.0",
+    "@nestia/fetcher": "^14.0.2"
   },
   "peerDependenciesMeta": {
     "@modelcontextprotocol/sdk": {
@@ -110,7 +107,8 @@
   "scripts": {
     "build": "rimraf lib && ttsc",
     "dev": "ttsc --watch",
-    "test:go": "cd test && go test ./..."
+    "test:go": "cd test && go test -count=1 ./...",
+    "evidence": "evidence"
   },
   "types": "lib/index.d.ts"
 }