typia 15.0.0 → 15.1.0

package/native/cmd/ttsc-typia/project_dependencies_callee_shape_transform_test.go

@@ -26,6 +26,11 @@ import (
 //     IIFE body, so the walk neither charged nor withheld the body's names.
 //  4. Assert `indirect.ts` and `tagged.ts` are withheld, so a call-like form
 //     other than `()` does not quietly escape the same rule.
+//
+// @evidence contracts/testing.md#behavioral-verification Direct IIFE callers remain complete without deep body dependencies; indirect IIFE and tagged-return callers are withheld.
+// @evidence contracts/testing.md#independent-expectations A directly called literal resolves locally, but the identity of a returned callable depends on executing or analyzing that body.
+// @evidence contracts/testing.md#distinguishing-cases Direct literal invocation is paired with invoking its return and a tagged-template return.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesCalleeShapeTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesCalleeShapeTransform(t *testing.T) {
   project := projectDependenciesCalleeShapeProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -67,16 +72,7 @@ func TestProjectDependenciesCalleeShapeTransform(t *testing.T) {
 
 func projectDependenciesCalleeShapeProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-callee-shape-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-callee-shape-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)

package/native/cmd/ttsc-typia/project_dependencies_callee_untransformed_barrel_transform_test.go

@@ -26,6 +26,11 @@ import (
 //  3. Assert `plain.ts` was left untransformed, so it is a class-2 file.
 //  4. Assert it is declared complete, and that its reported list nevertheless
 //     carries `src/barrel.ts` and the `src/local.ts` the barrel resolves to.
+//
+// @evidence contracts/testing.md#behavioral-verification The local is call survives unchanged, yet its complete entry includes both barrel and local callee declarations.
+// @evidence contracts/testing.md#independent-expectations Retargeting the local re-export to typia would create a transform without editing the caller, so unchanged output still depends on the selecting barrel.
+// @evidence contracts/testing.md#distinguishing-cases An untransformed caller retains dependencies instead of receiving a falsely empty complete set.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesCalleeUntransformedBarrelTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesCalleeUntransformedBarrelTransform(t *testing.T) {
   project := projectDependenciesCalleeUntransformedBarrelProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -72,16 +77,7 @@ func TestProjectDependenciesCalleeUntransformedBarrelTransform(t *testing.T) {
 
 func projectDependenciesCalleeUntransformedBarrelProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-callee-untransformed-barrel-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-callee-untransformed-barrel-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)

package/native/cmd/ttsc-typia/project_dependencies_collapsed_alias_transform_test.go

@@ -23,6 +23,11 @@ import (
 //  2. Run project transform mode and decode the JSON envelope.
 //  3. Assert `dependencies["src/a.ts"]` contains `t.ts`, `u.ts`, and `v.ts`.
 //  4. Assert it does NOT contain `w.ts` (body-only reference).
+//
+// @evidence contracts/testing.md#behavioral-verification The envelope includes outer, property and top-level intrinsic alias files but excludes the body-only reference.
+// @evidence contracts/testing.md#independent-expectations Written aliases can be interned to intrinsic types, losing checker symbols although edits to their declarations still affect validation.
+// @evidence contracts/testing.md#distinguishing-cases Three collapsed alias positions are paired with a function-body-only name.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesCollapsedAliasTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesCollapsedAliasTransform(t *testing.T) {
   project := projectDependenciesCollapsedAliasProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -62,16 +67,7 @@ func TestProjectDependenciesCollapsedAliasTransform(t *testing.T) {
 
 func projectDependenciesCollapsedAliasProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-collapsed-alias-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-collapsed-alias-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)

package/native/cmd/ttsc-typia/project_dependencies_complete_diagnostic_transform_test.go

@@ -18,13 +18,18 @@ import (
 // explaining (samchon/typia#2357).
 //
 //  1. Build a project where `rejected.ts` asks for a protobuf message over
-//     `bigint`, which no protobuf entry point supports, beside a `control.ts`
+//     a top-level `bigint` instead of a static message object, beside `control.ts`
 //     that transforms cleanly.
 //  2. Run project transform mode; the host reports the diagnostic and exits 3
 //     after printing the envelope.
 //  3. Assert the diagnostic names `rejected.ts`, so the fixture failed for the
 //     reason the test intends.
 //  4. Assert `control.ts` is declared complete and `rejected.ts` is not.
+//
+// @evidence contracts/testing.md#behavioral-verification A rejected call produces status 3 and a diagnostic owned by rejected.ts; the clean source remains complete and rejected.ts is withheld.
+// @evidence contracts/testing.md#independent-expectations A failed lowering cannot promise a bounded successful dependency set, while a different successful file need not lose its own claim.
+// @evidence contracts/testing.md#distinguishing-cases One project contains both a clean and a rejected call, pinning per-file failure isolation.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesCompleteDiagnosticTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesCompleteDiagnosticTransform(t *testing.T) {
   project := projectDependenciesCompleteDiagnosticProject(t)
   out, _, code := ttscTypiaTestCapture(func() int {
@@ -69,16 +74,7 @@ func TestProjectDependenciesCompleteDiagnosticTransform(t *testing.T) {
 
 func projectDependenciesCompleteDiagnosticProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-complete-diagnostic-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-complete-diagnostic-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)

package/native/cmd/ttsc-typia/project_dependencies_complete_envelope_transform_test.go

@@ -29,6 +29,11 @@ import (
 //  4. Assert the declared list for `src/a.ts` still carries `src/b.ts` and
 //     `src/c.ts`, because the declaration narrows to that entry and an entry
 //     that lost a consulted file would now serve a stale validator.
+//
+// @evidence contracts/testing.md#behavioral-verification Sorted completeness keys equal the published TypeScript keys; a.ts retains direct and transitive declarations and the untouched d.ts has no dependencies.
+// @evidence contracts/testing.md#independent-expectations Complete metadata must cover every published source and every declaration consulted for it, including transitively reached properties.
+// @evidence contracts/testing.md#distinguishing-cases Transformed direct/transitive references contrast with an untouched source whose bounded set is empty.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesCompleteEnvelopeTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesCompleteEnvelopeTransform(t *testing.T) {
   project := projectDependenciesCompleteEnvelopeProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -84,16 +89,7 @@ func TestProjectDependenciesCompleteEnvelopeTransform(t *testing.T) {
 
 func projectDependenciesCompleteEnvelopeProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-complete-envelope-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-complete-envelope-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)

package/native/cmd/ttsc-typia/project_dependencies_complete_inferred_type_transform_test.go

@@ -30,6 +30,11 @@ import (
 //  4. Assert `written.ts` is declared complete and `inferred.ts` is not, and
 //     that `inferred.ts` still keeps its reported dependency entry -- it falls
 //     back to the host-owned bound, it is not stripped of what it did report.
+//
+// @evidence contracts/testing.md#behavioral-verification Both written and contextually inferred assert calls emit validators; written.ts remains complete, inferred.ts is withheld and its existing dependency entry remains populated.
+// @evidence contracts/testing.md#independent-expectations A written generic type argument bounds the consulted type graph; contextual argument typing can select a Handler declaration not represented in that graph.
+// @evidence contracts/testing.md#distinguishing-cases The same Shape contract is supplied once as an explicit generic and once through a contextually typed function parameter, distinguishing completeness without changing validation meaning.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesCompleteInferredTypeTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesCompleteInferredTypeTransform(t *testing.T) {
   project := projectDependenciesCompleteInferredTypeProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -72,16 +77,7 @@ func TestProjectDependenciesCompleteInferredTypeTransform(t *testing.T) {
 
 func projectDependenciesCompleteInferredTypeProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-complete-inferred-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-complete-inferred-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)

package/native/cmd/ttsc-typia/project_dependencies_complete_replaced_library_transform_test.go

@@ -39,6 +39,11 @@ import (
 //     (samchon/typia#2361). `nocall2.ts` is the control that only annotates the
 //     same type, and `replaced.ts` above is the twin that must stay withheld, so
 //     the fix cannot degenerate into never withholding on a library.
+//
+// @evidence contracts/testing.md#behavioral-verification Both validators emit; the project-declared control stays complete, the caller consulting replaced Map is withheld and the replacement library stays out of its narrowed dependencies. Two non-typia library method callers remain complete.
+// @evidence contracts/testing.md#independent-expectations On-disk replacement libraries are watched by the host globals bound but omitted from typia's project dependency lists. Withholding completeness retains that sound bound when validation reads the replacement; merely resolving a non-typia method cannot change a faithful reprint.
+// @evidence contracts/testing.md#distinguishing-cases Native validation through the replaced library contrasts with a project interface and two unchanged method callers, distinguishing type-analysis touches from callee-identity touches.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesCompleteReplacedLibraryTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesCompleteReplacedLibraryTransform(t *testing.T) {
   project := projectDependenciesCompleteReplacedLibraryProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -94,16 +99,7 @@ func TestProjectDependenciesCompleteReplacedLibraryTransform(t *testing.T) {
 
 func projectDependenciesCompleteReplacedLibraryProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-complete-replaced-library-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-complete-replaced-library-")
   for name, content := range map[string]string{
     "tsconfig.json": libReplacementNativeIdentityTSConfig,
     "node_modules/@typescript/lib-es2015/package.json":    libReplacementNativeIdentityPackageJSON,

package/native/cmd/ttsc-typia/project_dependencies_complete_untouched_reprint_transform_test.go

@@ -29,6 +29,11 @@ import (
 //  3. Assert the published text preserves each construct verbatim and emits no
 //     `design:type` metadata, so nothing type-driven ran.
 //  4. Assert the file is declared complete with no dependency entry at all.
+//
+// @evidence contracts/testing.md#behavioral-verification The untouched source preserves its type-only import, enum, namespace, as-const expression and decorator, emits no design:type metadata and remains complete without a dependency entry.
+// @evidence contracts/testing.md#independent-expectations A TypeScript project-envelope reprint preserves parsed syntax rather than performing JavaScript lowering or checker-driven decorator metadata emission; those operations would introduce unreported type dependencies.
+// @evidence contracts/testing.md#distinguishing-cases The fixture enables both decorator options yet contrasts preserved decorator syntax with absent design:type output, alongside constructs that ordinary JavaScript emission would lower or erase.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesCompleteUntouchedReprintTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesCompleteUntouchedReprintTransform(t *testing.T) {
   project := projectDependenciesCompleteUntouchedReprintProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -81,16 +86,7 @@ func TestProjectDependenciesCompleteUntouchedReprintTransform(t *testing.T) {
 
 func projectDependenciesCompleteUntouchedReprintProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-complete-untouched-reprint-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-complete-untouched-reprint-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)

package/native/cmd/ttsc-typia/project_dependencies_computed_key_transform_test.go

@@ -38,6 +38,11 @@ import (
 //  7. Assert `d.ts` stays declared AND reports `src/keyconst.ts`: a bare name
 //     whose constant fixes its own value is the bounded twin of `b.ts`, and it
 //     is the only case that pins both halves of the bare-name branch.
+//
+// @evidence contracts/testing.md#behavioral-verification Dependencies retain the computed property-key declaration and traversed barrel while excluding the unused sibling. Completeness is retained for the enum, literal and self-defined constant keys, withheld for a borrowed-value key, and the self-defined constant's declaration remains reported.
+// @evidence contracts/testing.md#independent-expectations Changing a consulted computed key changes the property tested by the validator, even when its primitive value is interned.
+// @evidence contracts/testing.md#distinguishing-cases The consumed enum key contrasts with an unused sibling; a borrowed-value constant key contrasts with a literal key and a constant that defines its own value. The latter also pins its declaration dependency.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesComputedKeyTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesComputedKeyTransform(t *testing.T) {
   project := projectDependenciesComputedKeyProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -98,16 +103,7 @@ func TestProjectDependenciesComputedKeyTransform(t *testing.T) {
 
 func projectDependenciesComputedKeyProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-computed-key-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-computed-key-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)

package/native/cmd/ttsc-typia/project_dependencies_custom_lib_name_transform_test.go

@@ -31,6 +31,11 @@ import (
 //     the project is not evidence of one: the envelope reports a `node_modules`
 //     declaration file like any other, and the files that decide a callee's
 //     typia identity are exactly such files.
+//
+// @evidence contracts/testing.md#behavioral-verification The envelope reports the authored src/lib.custom.d.ts ambient interface and direct src/b.ts declaration while rejecting virtual URI sources in that dependency list. It does not inspect completeness.
+// @evidence contracts/testing.md#independent-expectations The project owns CustomAmbient even though its filename resembles a compiler library; edits to its properties can change Bee validation. Date separately reaches the compiler-owned bundled library, which must stay excluded.
+// @evidence contracts/testing.md#distinguishing-cases A project-owned lib.custom.d.ts is the positive identity control against compiler-owned bundled Date declarations; the basename alone cannot decide ownership.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesCustomLibNameTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesCustomLibNameTransform(t *testing.T) {
   project := projectDependenciesCustomLibNameProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -71,16 +76,7 @@ func TestProjectDependenciesCustomLibNameTransform(t *testing.T) {
 
 func projectDependenciesCustomLibNameProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-custom-lib-name-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-custom-lib-name-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)

package/native/cmd/ttsc-typia/project_dependencies_default_barrel_transform_test.go

@@ -24,6 +24,11 @@ import (
 //  3. Assert `dependencies["src/a.ts"]` contains `barrel.ts` and `real.ts`.
 //  4. Assert it does NOT contain `unrelated.ts`, whose only tie to the walk is
 //     sharing the local name of the default import.
+//
+// @evidence contracts/testing.md#behavioral-verification The envelope checks default re-export intermediates and rejects unrelated sibling dependencies.
+// @evidence contracts/testing.md#independent-expectations A default export is still a module-selection edge whose retargeting changes the consumed type.
+// @evidence contracts/testing.md#distinguishing-cases A consumed default chain is paired with a sibling not reached by the reference.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesDefaultBarrelTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesDefaultBarrelTransform(t *testing.T) {
   project := projectDependenciesDefaultBarrelProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -60,16 +65,7 @@ func TestProjectDependenciesDefaultBarrelTransform(t *testing.T) {
 
 func projectDependenciesDefaultBarrelProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-default-barrel-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-default-barrel-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)

package/native/cmd/ttsc-typia/project_dependencies_empty_heritage_transform_test.go

@@ -20,6 +20,11 @@ import (
 //  2. Run project transform mode and decode the JSON envelope.
 //  3. Assert `dependencies["src/main.ts"]` contains both `src/doc.ts` (the
 //     declaring file) and `src/empty.ts` (the property-less heritage target).
+//
+// @evidence contracts/testing.md#behavioral-verification The envelope reports both Doc's declaration and its currently property-less Empty heritage target for the validating caller.
+// @evidence contracts/testing.md#independent-expectations Editing an empty base to add members changes validation, so absence of current properties cannot remove the heritage edge.
+// @evidence contracts/testing.md#distinguishing-cases Doc contributes its own id property while Empty contributes none, so the base edge cannot be inferred only from property symbols. Unconsumed declaration exclusion is owned by the sibling barrel cases.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesEmptyHeritageTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesEmptyHeritageTransform(t *testing.T) {
   project := projectDependenciesEmptyHeritageProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -53,16 +58,7 @@ func TestProjectDependenciesEmptyHeritageTransform(t *testing.T) {
 
 func projectDependenciesEmptyHeritageProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-empty-heritage-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-empty-heritage-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)

package/native/cmd/ttsc-typia/project_dependencies_enum_member_value_transform_test.go

@@ -27,6 +27,11 @@ import (
 //     really did reach the validator.
 //  4. Assert the caller of the self-contained enum is declared complete and the
 //     caller of the borrowing enum is not.
+//
+// @evidence contracts/testing.md#behavioral-verification Emitted comparisons retain the authored string and negative numeric literals, and the borrowed string value. The self-defined enum caller remains complete while the borrowed-value caller is withheld; this case does not assert individual dependency entries.
+// @evidence contracts/testing.md#independent-expectations The enum member constant is embedded in validation; changing that declaration changes output even when the type is represented as a literal.
+// @evidence contracts/testing.md#distinguishing-cases A self-defined string and unary-negative numeric enum contrast with an enum member initialized from another file; validator-output guards ensure both completeness assertions concern transformed callers.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesEnumMemberValueTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesEnumMemberValueTransform(t *testing.T) {
   project := projectDependenciesEnumMemberValueProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -67,16 +72,7 @@ func TestProjectDependenciesEnumMemberValueTransform(t *testing.T) {
 
 func projectDependenciesEnumMemberValueProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-enum-member-value-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-enum-member-value-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)

package/native/cmd/ttsc-typia/project_dependencies_envelope_transform_test.go

@@ -26,6 +26,11 @@ import (
 //  3. Assert `dependencies["src/a.ts"]` contains both `src/b.ts` and `src/c.ts`.
 //  4. Assert no entry exists for `src/b.ts`, `src/c.ts`, or `src/d.ts`, the
 //     entry omits `src/a.ts` itself, and no `lib.*.d.ts` value leaks.
+//
+// @evidence contracts/testing.md#behavioral-verification a.ts is published and reports b.ts and transitive c.ts; its own path and default libraries are absent, and b.ts/c.ts/d.ts without typia calls have no dependency entry.
+// @evidence contracts/testing.md#independent-expectations A consumer cache needs declaration files whose edits can change the emitted validator, using normalized project-relative identities.
+// @evidence contracts/testing.md#distinguishing-cases Direct and property-transitive type references are paired with self identity, compiler default libraries and three sources without typia calls.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesEnvelopeTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesEnvelopeTransform(t *testing.T) {
   project := projectDependenciesEnvelopeProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -78,16 +83,7 @@ func TestProjectDependenciesEnvelopeTransform(t *testing.T) {
 
 func projectDependenciesEnvelopeProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-envelope-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-envelope-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)

package/native/cmd/ttsc-typia/project_dependencies_index_signature_alias_transform_test.go

@@ -20,12 +20,18 @@ import (
 //
 //  1. Build a project where `a.ts` validates `Target` from `model.ts`, whose
 //     index signature uses the key alias `Key` (`key.ts`) and the value alias
-//     `Value` (`value.ts`), and whose unrelated property references `Kept`
-//     (`kept.ts`) while a method body alone references `BodyOnly` (`body.ts`).
+//     `Value` (`value.ts`). A separately validated Holder class has a property
+//     referencing `Kept` (`kept.ts`) and a method body alone referencing
+//     `BodyOnly` (`body.ts`).
 //  2. Run project transform mode and decode the JSON envelope.
 //  3. Assert `dependencies["src/a.ts"]` contains `key.ts`, `value.ts`, and
 //     `kept.ts`.
 //  4. Assert it does NOT contain the body-only `body.ts`.
+//
+// @evidence contracts/testing.md#behavioral-verification Index-signature aliases retain the files named by consulted key/value types and exclude unused aliases.
+// @evidence contracts/testing.md#independent-expectations Index-signature validation reads its key and value type declarations even when aliases collapse into primitive checker types.
+// @evidence contracts/testing.md#distinguishing-cases Consulted index-signature aliases are contrasted with a sibling outside the validated shape.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesIndexSignatureAliasTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesIndexSignatureAliasTransform(t *testing.T) {
   project := projectDependenciesIndexSignatureAliasProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -65,16 +71,7 @@ func TestProjectDependenciesIndexSignatureAliasTransform(t *testing.T) {
 
 func projectDependenciesIndexSignatureAliasProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-index-signature-alias-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-index-signature-alias-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)

package/native/cmd/ttsc-typia/project_dependencies_inferred_declaration_transform_test.go

@@ -35,6 +35,11 @@ import (
 //  5. Assert the destructured caller is withheld too. A binding element is a
 //     declaration kind the predicate names nowhere, so it answers through the
 //     default -- which is what pins that the default is "withhold".
+//
+// @evidence contracts/testing.md#behavioral-verification All three typeof callers emit validators; only the annotated constant caller remains complete and reports shape.ts. Inferred and destructured callers are withheld, and the inferred caller's reported dependency entry remains populated.
+// @evidence contracts/testing.md#independent-expectations An explicit annotation bounds consulted declaration identities; initializer inference and destructured bindings can depend on expression typing outside that written surface, so they cannot promise completeness.
+// @evidence contracts/testing.md#distinguishing-cases Annotated and inferred constants have the same value shape, and a destructured binding pins the unrecognized-declaration fallback separately.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesInferredDeclarationTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesInferredDeclarationTransform(t *testing.T) {
   project := projectDependenciesInferredDeclarationProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -87,16 +92,7 @@ func TestProjectDependenciesInferredDeclarationTransform(t *testing.T) {
 
 func projectDependenciesInferredDeclarationProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-inferred-declaration-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-inferred-declaration-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)

package/native/cmd/ttsc-typia/project_dependencies_jsdoc_typedef_transform_test.go

@@ -26,6 +26,11 @@ import (
 //     `src/id.js`.
 //  4. Assert `src/main.ts` is declared complete, so the narrowed bound is the
 //     one carrying them.
+//
+// @evidence contracts/testing.md#behavioral-verification doc.js and the property type id.js are retained and main.ts remains complete.
+// @evidence contracts/testing.md#independent-expectations JSDoc typedef and property annotations supply real type meaning to JavaScript sources, so editing either consulted declaration changes validation.
+// @evidence contracts/testing.md#distinguishing-cases JavaScript typedef/property references exercise the written-type path independently of TypeScript type declarations.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesJsDocTypedefTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesJsDocTypedefTransform(t *testing.T) {
   project := projectDependenciesJsDocTypedefProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -69,16 +74,7 @@ func TestProjectDependenciesJsDocTypedefTransform(t *testing.T) {
 
 func projectDependenciesJsDocTypedefProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-jsdoc-typedef-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-jsdoc-typedef-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)

package/native/cmd/ttsc-typia/project_dependencies_local_reexport_transform_test.go

@@ -25,6 +25,11 @@ import (
 //     `mid.ts`, and the concrete `real.ts`.
 //  4. Assert it does NOT contain `beta.ts`, which `barrel.ts` also imports but
 //     no consulted type reaches.
+//
+// @evidence contracts/testing.md#behavioral-verification barrel, mid and real are retained while the locally imported but unconsumed beta is excluded.
+// @evidence contracts/testing.md#independent-expectations An import followed by exporting its local binding selects the same declaration as an export-from chain, despite different AST ownership.
+// @evidence contracts/testing.md#distinguishing-cases Local-binding re-export syntax is paired with an unused local import.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesLocalReexportTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesLocalReexportTransform(t *testing.T) {
   project := projectDependenciesLocalReexportProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -64,16 +69,7 @@ func TestProjectDependenciesLocalReexportTransform(t *testing.T) {
 
 func projectDependenciesLocalReexportProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-local-reexport-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-local-reexport-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)

package/native/cmd/ttsc-typia/project_dependencies_named_tuple_member_transform_test.go

@@ -25,6 +25,11 @@ import (
 //  3. Assert `dependencies["src/a.ts"]` contains `src/id.ts` and that `a.ts` is
 //     declared complete, so the narrowed bound is the one carrying it.
 //  4. Assert it omits `src/unused.ts`, which no consulted member names.
+//
+// @evidence contracts/testing.md#behavioral-verification pair and id are retained, unused is absent and the tuple caller remains complete.
+// @evidence contracts/testing.md#independent-expectations A named tuple member annotation controls element validation even when its Id alias collapses to string.
+// @evidence contracts/testing.md#distinguishing-cases The consumed named-member alias is contrasted with another alias not named by the tuple.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesNamedTupleMemberTransform as a unit test. Its fixture project and captured runTransform call exercise the owning Go operation in process; no consumer installation or compiler subprocess is used. Fixture helpers retain their source inputs and cleanup, and assertions inspect the resulting envelope or emitted output.
 func TestProjectDependenciesNamedTupleMemberTransform(t *testing.T) {
   project := projectDependenciesNamedTupleMemberProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -71,16 +76,7 @@ func TestProjectDependenciesNamedTupleMemberTransform(t *testing.T) {
 
 func projectDependenciesNamedTupleMemberProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "project-dependencies-named-tuple-member-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-named-tuple-member-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)