typia 15.0.0 → 15.1.0

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

@@ -1,20 +1,21 @@
 package main
 
 import (
-  "os"
-  "os/exec"
-  "path/filepath"
   "strings"
   "testing"
 )
 
-// TestPlainClassifyValidatedUnionTransform stresses the VALIDATED class-type
-// union: the construction ladder in assert/validateClassify must reference its
-// OWN is-check helpers (emitted from the classify collection), NOT the __assert
-// side's helpers — whose collection (built over GetUnionType(seeds)) may dedup or
-// reorder the members, so a shared index would diverge (ReferenceError / wrong
-// class). Several members with distinct seeds, a mix of from/new, and an
-// interleaved primitive, under BOTH createAssertClassify and createValidateClassify.
+// TestPlainClassifyValidatedUnionTransform verifies reconstruction of both validated union arms.
+//
+// Validation before classification cannot erase either accepted union member reconstruction strategy; static factories and seed constructors remain different contracts.
+//
+// 1. Checked direct/factory operations combine Ann and Bob arms, complementing the unchecked union strategy case.
+// 2. The checked classify output retains Ann.from and new Bob.
+//
+// @evidence contracts/testing.md#behavioral-verification The checked classify output retains Ann.from and new Bob.
+// @evidence contracts/testing.md#independent-expectations Validation before classification cannot erase either accepted union member reconstruction strategy; static factories and seed constructors remain different contracts.
+// @evidence contracts/testing.md#distinguishing-cases Checked direct/factory operations combine Ann and Bob arms, complementing the unchecked union strategy case.
+// @evidence contracts/testing.md#execution-ownership The native Go runner executes TestPlainClassifyValidatedUnionTransform as a unit test. Captured runTransform calls operate on the isolated fixture project in process; output assertions and cleanup remain owned by these helpers without a compiler or Node subprocess.
 func TestPlainClassifyValidatedUnionTransform(t *testing.T) {
   project := plainClassifyWriteProject(t, "plain-classify-vunion-", plainClassifyValidatedUnionSource)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -31,36 +32,6 @@ func TestPlainClassifyValidatedUnionTransform(t *testing.T) {
   if !strings.Contains(out, "Ann.from(") || !strings.Contains(out, "new Bob(") {
     t.Fatalf("the validated union should construct both from- (Ann.from) and new- (new Bob) members:\n%s", out)
   }
-  plainClassifyValidatedUnionRun(t, project, out)
-}
-
-func plainClassifyValidatedUnionRun(t *testing.T, project string, js string) {
-  t.Helper()
-  node, err := exec.LookPath("node")
-  if err != nil {
-    t.Skip("node executable not found")
-  }
-  runtimeDir := filepath.Join(project, "runtime")
-  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
-    t.Fatalf("mkdir runtime dir: %v", err)
-  }
-  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
-  if err := os.WriteFile(filepath.Join(runtimeDir, "generic-internal-stub.cjs"), []byte(plainClassifyFromNewGenericStub), 0o644); err != nil {
-    t.Fatalf("write generic stub: %v", err)
-  }
-  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(plainClassifyFromNewRewrite(t, js)), 0o644); err != nil {
-    t.Fatalf("write runtime module: %v", err)
-  }
-  runner := filepath.Join(runtimeDir, "run.cjs")
-  if err := os.WriteFile(runner, []byte(plainClassifyValidatedUnionRunner), 0o644); err != nil {
-    t.Fatalf("write runner: %v", err)
-  }
-  cmd := exec.Command(node, runner)
-  cmd.Dir = runtimeDir
-  output, err := cmd.CombinedOutput()
-  if err != nil {
-    t.Fatalf("classify validated-union runtime cases failed: %v\n%s", err, output)
-  }
 }
 
 const plainClassifyValidatedUnionSource = `import typia from "typia";
@@ -104,109 +75,3 @@ export class Cal {
 export const assertShape = typia.plain.createAssertClassify<typeof Ann | typeof Bob | typeof Cal | number>();
 export const validateShape = typia.plain.createValidateClassify<typeof Ann | typeof Bob | typeof Cal>();
 `
-
-const plainClassifyValidatedUnionRunner = `const mod = require("./main.cjs");
-
-const assert = (cond, msg) => {
-  if (!cond) throw new Error(msg);
-};
-
-// assertClassify discriminates each member of the validated union and builds the
-// RIGHT class — its construction ladder must use its own _yi helpers, not the
-// assert side's (possibly reordered) _io helpers.
-const an = mod.assertShape({ a: 1 });
-assert(an instanceof mod.Ann, "seed {a} -> Ann (from), got: " + (an && an.constructor && an.constructor.name));
-assert(an.tag() === "ann:1", "Ann.from reconstruct, got: " + an.tag());
-
-const bo = mod.assertShape({ b: "x" });
-assert(bo instanceof mod.Bob, "seed {b} -> Bob (new), got: " + (bo && bo.constructor && bo.constructor.name));
-assert(bo.tag() === "bob:x", "new Bob reconstruct");
-
-const ca = mod.assertShape({ c: true });
-assert(ca instanceof mod.Cal, "seed {c} -> Cal (new), got: " + (ca && ca.constructor && ca.constructor.name));
-assert(ca.tag() === "cal:true", "new Cal reconstruct");
-
-// the interleaved primitive passes through unchanged
-assert(mod.assertShape(42) === 42, "a number must pass through the assert union unchanged");
-
-// validateClassify of the same union returns success and the right instance
-const r = mod.validateShape({ b: "y" });
-assert(r.success === true, "validateClassify should succeed on a valid seed, got: " + JSON.stringify(r.errors));
-assert(r.data instanceof mod.Bob, "validateClassify should build the Bob instance");
-assert(r.data.tag() === "bob:y", "validateClassify reconstruct");
-`
-
-// TestPlainClassifyNestedValidatedUnion exercises a VALIDATED class union whose
-// members carry a NESTED object-union — the discrimination of that nested union
-// must reference classify's own _yi helpers (emitted from the classify
-// collection), not the assert side's _io (a SEPARATE GetUnionType collection
-// that dedups/reorders), or it would `ReferenceError: _io<n> is not defined`.
-func TestPlainClassifyNestedValidatedUnion(t *testing.T) {
-  project := plainClassifyWriteProject(t, "plain-classify-nested-vunion-", plainClassifyNestedVUnionSource)
-  out, errText, code := ttscTypiaTestCapture(func() int {
-    return runTransform([]string{
-      "--cwd", project,
-      "--tsconfig", "tsconfig.json",
-      "--file", "src/main.ts",
-      "--output", "js",
-    })
-  })
-  if code != 0 {
-    t.Fatalf("nested validated-union transform failed: code=%d\n%s", code, errText)
-  }
-  plainClassifyRunNode(t, project, out, plainClassifyNestedVUnionRunner)
-}
-
-const plainClassifyNestedVUnionSource = `import typia from "typia";
-
-// Two discriminable classes (by ` + "`kind`" + `) that SHARE a nested object-union
-// payload. classify's discrimination of that nested { k1 } | { k2 } union, in the
-// VALIDATED path, must use its own _yi helpers — the assert side analyzes the
-// seeds through GetUnionType (which dedups the shared payload), so an _i index
-// would diverge.
-export class Holder {
-  kind!: "holder";
-  payload!: { k1: string } | { k2: number };
-  constructor(seed: { kind: "holder"; payload: { k1: string } | { k2: number } }) {
-    this.kind = seed.kind;
-    this.payload = seed.payload;
-  }
-  describe(): string {
-    return "holder:" + JSON.stringify(this.payload);
-  }
-}
-export class Twin {
-  kind!: "twin";
-  payload!: { k1: string } | { k2: number };
-  constructor(seed: { kind: "twin"; payload: { k1: string } | { k2: number } }) {
-    this.kind = seed.kind;
-    this.payload = seed.payload;
-  }
-  describe(): string {
-    return "twin:" + JSON.stringify(this.payload);
-  }
-}
-
-export const assertShape = typia.plain.createAssertClassify<typeof Holder | typeof Twin>();
-export const validateShape = typia.plain.createValidateClassify<typeof Holder | typeof Twin>();
-`
-
-const plainClassifyNestedVUnionRunner = `const mod = require("./main.cjs");
-
-const assert = (cond, msg) => {
-  if (!cond) throw new Error(msg);
-};
-
-// nested object-union discrimination must not ReferenceError and builds the right class
-const h = mod.assertShape({ kind: "holder", payload: { k1: "x" } });
-assert(h instanceof mod.Holder, "kind holder -> Holder, got: " + (h && h.constructor && h.constructor.name));
-assert(h.describe() === 'holder:{"k1":"x"}', "Holder payload k1, got: " + h.describe());
-
-const tw = mod.assertShape({ kind: "twin", payload: { k2: 5 } });
-assert(tw instanceof mod.Twin, "kind twin -> Twin, got: " + (tw && tw.constructor && tw.constructor.name));
-assert(tw.describe() === 'twin:{"k2":5}', "Twin payload k2, got: " + tw.describe());
-
-const r = mod.validateShape({ kind: "holder", payload: { k2: 9 } });
-assert(r.success === true, "validateClassify success, got: " + JSON.stringify(r.errors));
-assert(r.data instanceof mod.Holder && r.data.describe() === 'holder:{"k2":9}', "validate builds Holder with k2 payload");
-`

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

@@ -2,25 +2,22 @@ package main
 
 import (
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestPlainCloneBigIntWrapperTransform verifies BigInt wrapper unboxing.
+// TestPlainCloneBigIntWrapperTransform verifies unboxing BigInt wrappers in clone emission.
 //
-// Collecting TypeScript `BigInt` as native metadata routes `plain.clone` and
-// notation programmers into their native arms. Those arms must unbox the four
-// primitive wrappers through `valueOf()`; before the fix the default branch
-// emitted a bare zero-argument `BigInt()`, which throws for every input, so
-// clone of a valid `BigInt` value always failed at runtime.
+// A boxed bigint stores its value behind valueOf; calling BigInt without that value cannot reconstruct the source content.
 //
-//  1. Transform a fixture cloning `BigInt`, `bigint | BigInt`, and camelizing
-//     an object with a `BigInt` property.
-//  2. Require the emitted code to call `valueOf` and never bare `BigInt()`.
-//  3. Execute clone, assertClone, and camel notation over primitive and boxed
-//     inputs and require primitive bigint identities back.
+// 1. The wrapper fixture exercises boxed bigint while rejecting the empty-constructor spelling; primitive and deep graph clone behavior belongs to the dedicated clone cases.
+// 2. The output invokes valueOf and does not emit a bare zero-argument BigInt constructor.
+//
+// @evidence contracts/testing.md#behavioral-verification The output invokes valueOf and does not emit a bare zero-argument BigInt constructor.
+// @evidence contracts/testing.md#independent-expectations A boxed bigint stores its value behind valueOf; calling BigInt without that value cannot reconstruct the source content.
+// @evidence contracts/testing.md#distinguishing-cases The wrapper fixture exercises boxed bigint while rejecting the empty-constructor spelling; primitive and deep graph clone behavior belongs to the dedicated clone cases.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestPlainCloneBigIntWrapperTransform as a unit test. The fixture and captured Go operation execute in process; helper assertions retain the same source inputs and failure identity without launching a compiler or JavaScript subprocess.
 func TestPlainCloneBigIntWrapperTransform(t *testing.T) {
   project := plainCloneBigIntWrapperProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -40,23 +37,11 @@ func TestPlainCloneBigIntWrapperTransform(t *testing.T) {
   if strings.Contains(out, "BigInt()") {
     t.Fatalf("bigint wrapper clone must not emit a bare BigInt() call:\n%s", out)
   }
-  plainCloneBigIntWrapperRunRuntimeCases(t, project, out)
 }
 
 func plainCloneBigIntWrapperProject(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, "plain-clone-bigint-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() {
-    _ = os.RemoveAll(dir)
-  })
+  dir := ttscTypiaTestFixtureDirectory(t, "plain-clone-bigint-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -70,33 +55,6 @@ func plainCloneBigIntWrapperProject(t *testing.T) string {
   return dir
 }
 
-func plainCloneBigIntWrapperRunRuntimeCases(t *testing.T, project string, js string) {
-  t.Helper()
-  node, err := exec.LookPath("node")
-  if err != nil {
-    t.Skip("node executable not found")
-  }
-  runtimeDir := filepath.Join(project, "runtime")
-  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
-    t.Fatalf("mkdir runtime dir: %v", err)
-  }
-  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
-  runtimeJS := ttscTypiaTestRewriteCommonJS(t, js)
-  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(runtimeJS), 0o644); err != nil {
-    t.Fatalf("write runtime module: %v", err)
-  }
-  runner := filepath.Join(runtimeDir, "run.cjs")
-  if err := os.WriteFile(runner, []byte(plainCloneBigIntWrapperRuntimeRunner), 0o644); err != nil {
-    t.Fatalf("write runtime runner: %v", err)
-  }
-  cmd := exec.Command(node, runner)
-  cmd.Dir = runtimeDir
-  output, err := cmd.CombinedOutput()
-  if err != nil {
-    t.Fatalf("bigint wrapper clone runtime cases failed: %v\n%s", err, output)
-  }
-}
-
 const plainCloneBigIntWrapperTSConfig = `{
   "compilerOptions": {
     "target": "ES2022",
@@ -123,31 +81,3 @@ export const cloneUnion = typia.plain.createClone<bigint | BigInt>();
 export const assertCloneInterface = typia.plain.createAssertClone<BigInt>();
 export const camelRecord = typia.notations.createCamel<BoxedRecord>();
 `
-
-const plainCloneBigIntWrapperRuntimeRunner = `const mod = require("./main.cjs");
-
-const boxed = Object(1n);
-const expectPrimitive = (name, value, expected) => {
-  if (typeof value !== "bigint" || value !== expected) {
-    throw new Error(name + " should produce primitive " + expected + "n, got " + String(value) + " (" + typeof value + ")");
-  }
-};
-
-expectPrimitive("cloneInterface(1n)", mod.cloneInterface(1n), 1n);
-expectPrimitive("cloneInterface(Object(1n))", mod.cloneInterface(boxed), 1n);
-expectPrimitive("cloneUnion(1n)", mod.cloneUnion(1n), 1n);
-expectPrimitive("cloneUnion(Object(1n))", mod.cloneUnion(boxed), 1n);
-expectPrimitive("assertCloneInterface(1n)", mod.assertCloneInterface(1n), 1n);
-expectPrimitive("assertCloneInterface(Object(1n))", mod.assertCloneInterface(boxed), 1n);
-
-expectPrimitive(
-  "camelRecord({big_value: Object(2n)}).bigValue",
-  mod.camelRecord({ big_value: Object(2n) }).bigValue,
-  2n,
-);
-expectPrimitive(
-  "camelRecord({big_value: 3n}).bigValue",
-  mod.camelRecord({ big_value: 3n }).bigValue,
-  3n,
-);
-`

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

@@ -2,30 +2,22 @@ package main
 
 import (
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestPrivateFieldFilterIsTransform verifies an ES `#private` instance field is
-// excluded from a class's validated shape, so a real instance passes its own
-// `is`/`assert`/`validate` guard (#2213).
+// TestPrivateFieldFilterIsTransform verifies public properties without private binder keys in emitted validation.
 //
-// A `#private` field is installed only by the constructor and is unreachable via
-// index access, so it is not part of a type's structural, externally-observable
-// shape. Before the fix the member filter excluded only the TypeScript keyword
-// `private`/`protected` members, so a `#private` field leaked into the validated
-// shape as a mangled key (`input["�#1@#secret"]`) that no runtime object
-// carries — making the guard unconditionally false.
+// JavaScript private fields are not publicly accessible structural properties; including their internal binder names would emit invalid access while dropping public data would weaken validation.
 //
-//  1. Emit `is`/`assert`/`validate` for a class carrying a `#private` field
-//     alongside a public property, a subclass that adds another `#private`, an
-//     all-`#private` class, a class with `#private` method / accessor members,
-//     and a keyword `private`/`protected` class.
-//  2. Assert the emitted validators never reference a mangled `#private` key.
-//  3. Execute the validators against real instances and plain public-shape
-//     objects, proving each passes on its public shape.
+// 1. Classes with private and public members share one fixture, so exclusion is paired with positive public property preservation.
+// 2. The output retains all authored public members and contains no mangled private-key marker.
+//
+// @evidence contracts/testing.md#behavioral-verification The output retains all authored public members and contains no mangled private-key marker.
+// @evidence contracts/testing.md#independent-expectations JavaScript private fields are not publicly accessible structural properties; including their internal binder names would emit invalid access while dropping public data would weaken validation.
+// @evidence contracts/testing.md#distinguishing-cases Classes with private and public members share one fixture, so exclusion is paired with positive public property preservation.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestPrivateFieldFilterIsTransform as a unit test. The fixture and captured Go operation execute in process; helper assertions retain the same source inputs and failure identity without launching a compiler or JavaScript subprocess.
 func TestPrivateFieldFilterIsTransform(t *testing.T) {
   project := privateFieldFilterProject(t)
 
@@ -45,27 +37,11 @@ func TestPrivateFieldFilterIsTransform(t *testing.T) {
     }
   }
 
-  privateFieldFilterRunRuntimeCases(
-    t,
-    project,
-    privateFieldFilterTransform(t, project, "js"),
-  )
 }
 
 func privateFieldFilterProject(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, "private-field-filter-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() {
-    _ = os.RemoveAll(dir)
-  })
+  dir := ttscTypiaTestFixtureDirectory(t, "private-field-filter-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -95,32 +71,6 @@ func privateFieldFilterTransform(t *testing.T, project string, output string) st
   return out
 }
 
-func privateFieldFilterRunRuntimeCases(t *testing.T, project string, js string) {
-  t.Helper()
-  node, err := exec.LookPath("node")
-  if err != nil {
-    t.Skip("node executable not found")
-  }
-  runtimeDir := filepath.Join(project, "runtime")
-  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
-    t.Fatalf("mkdir runtime dir: %v", err)
-  }
-  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
-  runtimeJS := ttscTypiaTestRewriteCommonJS(t, js)
-  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(runtimeJS), 0o644); err != nil {
-    t.Fatalf("write runtime module: %v", err)
-  }
-  runner := filepath.Join(runtimeDir, "run.cjs")
-  if err := os.WriteFile(runner, []byte(privateFieldFilterRuntimeRunner), 0o644); err != nil {
-    t.Fatalf("write runtime runner: %v", err)
-  }
-  cmd := exec.Command(node, runner)
-  cmd.Dir = runtimeDir
-  if output, err := cmd.CombinedOutput(); err != nil {
-    t.Fatalf("private field filter runtime cases failed: %v\n%s", err, output)
-  }
-}
-
 const privateFieldFilterTSConfig = `{
   "compilerOptions": {
     "target": "ES2022",
@@ -199,80 +149,3 @@ export const isSolo = typia.createIs<SoloPrivate>();
 export const isMethod = typia.createIs<MethodPrivate>();
 export const isKeyword = typia.createIs<KeywordBox>();
 `
-
-const privateFieldFilterRuntimeRunner = `const mod = require("./main.cjs");
-
-class Box {
-  #secret;
-  label;
-  constructor(label, secret) {
-    this.label = label;
-    this.#secret = secret;
-  }
-}
-class SubBox extends Box {
-  #extra;
-  tag;
-  constructor() {
-    super("hi", true);
-    this.#extra = 1;
-    this.tag = "t";
-  }
-}
-class SoloPrivate {
-  #solo;
-  constructor() {
-    this.#solo = "x";
-  }
-}
-class MethodPrivate {
-  label;
-  #hidden() {
-    return 1;
-  }
-  get #view() {
-    return 2;
-  }
-  set #view(_next) {}
-  constructor(label) {
-    this.label = label;
-  }
-}
-
-const expect = (label, actual, expected) => {
-  if (actual !== expected) {
-    throw new Error(label + ": expected " + expected + " but got " + actual);
-  }
-};
-
-// A real instance carrying #private members passes its own guard.
-expect("is real Box instance", mod.isBox(new Box("hi", true)), true);
-expect("is real SubBox instance", mod.isSubBox(new SubBox()), true);
-expect("is real SoloPrivate instance", mod.isSolo(new SoloPrivate()), true);
-expect("is real MethodPrivate instance", mod.isMethod(new MethodPrivate("hi")), true);
-
-// The #private field is not part of the structural shape: a plain object with
-// only the public members is accepted, exactly like a keyword-private class.
-expect("is plain public Box shape", mod.isBox({ label: "hi" }), true);
-expect("is plain public SubBox shape", mod.isSubBox({ label: "hi", tag: "t" }), true);
-expect("is empty SoloPrivate shape", mod.isSolo({}), true);
-expect("is plain public MethodPrivate shape", mod.isMethod({ label: "hi" }), true);
-expect("is plain public KeywordBox shape", mod.isKeyword({ label: "hi" }), true);
-
-// The public shape is still validated structurally.
-expect("reject wrong public label type", mod.isBox({ label: 123 }), false);
-expect("reject missing public label", mod.isBox({}), false);
-
-// assert / validate accept a real instance without touching a mangled key.
-expect("assert real Box returns input", mod.assertBox(new Box("hi", true)) instanceof Box, true);
-expect("validate real Box succeeds", mod.validateBox(new Box("hi", true)).success, true);
-expect("validate plain public Box succeeds", mod.validateBox({ label: "hi" }).success, true);
-
-let threw = false;
-try {
-  mod.assertBox({ label: 123 });
-} catch (_exp) {
-  threw = true;
-}
-expect("assert rejects wrong public label", threw, true);
-`

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

@@ -30,6 +30,10 @@ import (
 // 2. Run project transform mode so every source file contributes call sites.
 // 3. Require JSON project output to include a TypeScript map.
 // 4. Hold each project to its own purpose's diagnostic contract.
+// @evidence contracts/testing.md#behavioral-verification Project transformation accepts eight valid public API projects, rejects the intentional error corpus with exit 3 and reports nonempty transformed sources and consistent diagnostics for debug.
+// @evidence contracts/testing.md#independent-expectations Valid projects and intentional rejection fixtures have different public contracts. Debug may contain either valid or invalid samples, but must load sources and report an exit matching its diagnostic envelope.
+// @evidence contracts/testing.md#distinguishing-cases The positive catalog, negative error corpus and content-agnostic debug cases separate source loading, success, transformation rejection and publication of a nonempty result.
+// @evidence contracts/testing.md#execution-ownership The native tagged Go runner discovers TestProjectCatalogTransformCoverage as a unit test. The command functions operate in process on project fixtures and captured output; no compiler or JavaScript subprocess is launched.
 func TestProjectCatalogTransformCoverage(t *testing.T) {
   root := transformCoverageRepoRoot(t)
   for _, project := range []string{

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

@@ -25,6 +25,11 @@ import (
 //  3. Assert `dependencies["src/a.ts"]` contains both barrels (`barrel.ts`,
 //     `inner.ts`) and the concrete module `alpha.ts`.
 //  4. Assert it does NOT contain `beta.ts`, which no consulted type reaches.
+//
+// @evidence contracts/testing.md#behavioral-verification Decoded dependencies include barrel, inner and alpha and omit the unused beta export.
+// @evidence contracts/testing.md#independent-expectations Repointing either re-export changes the validated declaration; an unconsumed sibling cannot affect it.
+// @evidence contracts/testing.md#distinguishing-cases The two-hop consumed chain is paired with beta exported by the same barrel but not consulted.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesBarrelReexportTransform 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 TestProjectDependenciesBarrelReexportTransform(t *testing.T) {
   project := projectDependenciesBarrelReexportProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -64,16 +69,7 @@ func TestProjectDependenciesBarrelReexportTransform(t *testing.T) {
 
 func projectDependenciesBarrelReexportProject(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-barrel-reexport-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-barrel-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_callee_argument_transform_test.go

@@ -38,6 +38,11 @@ import (
 //  6. Assert the tagged-template spelling of the same pass-through --
 //     “tag`x${ns}`.is<Foo>(input)“ -- reports `src/ns.ts` as well, because a
 //     template is what its tag is applied to.
+//
+// @evidence contracts/testing.md#behavioral-verification Pass-through and tagged-template calls emit validators and report ns/pick; callback-only hidden is omitted while all bounded callers remain complete.
+// @evidence contracts/testing.md#independent-expectations A namespace supplied as a callee argument selects typia identity, whereas a callback body cannot select the outer array method.
+// @evidence contracts/testing.md#distinguishing-cases Ordinary and tagged argument indirection are contrasted with a chain callback whose body names hidden.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesCalleeArgumentTransform 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 TestProjectDependenciesCalleeArgumentTransform(t *testing.T) {
   project := projectDependenciesCalleeArgumentProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -104,16 +109,7 @@ func TestProjectDependenciesCalleeArgumentTransform(t *testing.T) {
 
 func projectDependenciesCalleeArgumentProject(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-argument-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-callee-argument-")
   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_barrel_transform_test.go

@@ -28,6 +28,11 @@ import (
 //  4. Assert `dependencies["src/consumer.ts"]` contains `src/barrel.ts`, and
 //     not `src/unused.ts`, which the barrel also re-exports but this reference
 //     never traverses.
+//
+// @evidence contracts/testing.md#behavioral-verification The re-exported call is rewritten and its barrel dependency is present, while unused is absent.
+// @evidence contracts/testing.md#independent-expectations A barrel choosing typia rather than a local is function can change whether the caller is transformed; unrelated exports do not.
+// @evidence contracts/testing.md#distinguishing-cases A consumed typia re-export and an unconsumed sibling share one barrel.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesCalleeBarrelTransform 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 TestProjectDependenciesCalleeBarrelTransform(t *testing.T) {
   project := projectDependenciesCalleeBarrelProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -65,16 +70,7 @@ func TestProjectDependenciesCalleeBarrelTransform(t *testing.T) {
 
 func projectDependenciesCalleeBarrelProject(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-barrel-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-callee-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_callee_inference_transform_test.go

@@ -49,6 +49,11 @@ import (
 //     callee resolves to a local `const helper = () => ...` keeps its
 //     declaration -- that name decides nothing, and charging it costs 65 more
 //     files across the test workspaces than the fix needs.
+//
+// @evidence contracts/testing.md#behavioral-verification The emitted validators are checked before testing omission of inferred-return callers from completeness and retention of annotated twins.
+// @evidence contracts/testing.md#independent-expectations An inferred nested return can depend on initializer values outside the reported name chain; a written return type bounds that identity.
+// @evidence contracts/testing.md#distinguishing-cases Computed arguments/callees and inferred function returns contrast with annotated forms and an outer local helper. The borrowed-value overload remains an explicitly unpinned fixture limitation.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestProjectDependenciesCalleeInferenceTransform 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 TestProjectDependenciesCalleeInferenceTransform(t *testing.T) {
   project := projectDependenciesCalleeInferenceProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -133,16 +138,7 @@ func TestProjectDependenciesCalleeInferenceTransform(t *testing.T) {
 
 func projectDependenciesCalleeInferenceProject(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-inference-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "project-dependencies-callee-inference-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)