typia 15.0.0 → 15.1.0

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

@@ -1,9 +1,6 @@
 package main
 
 import (
-  "os"
-  "os/exec"
-  "path/filepath"
   "strings"
   "testing"
 )
@@ -16,36 +13,26 @@ import (
 // numeric or Date values.
 //
 //  1. Transform direct and factory comparators over scalars and containers.
-//  2. Exercise NaN, infinities, signed zero, and invalid Date boundaries.
-//  3. Verify antisymmetry and sort composition across nested sibling paths.
+//  2. Require the scalar comparator to distinguish self-unequal operands before
+//     relational comparison, placing NaN after ordinary values.
+//  3. Require Date comparison to retain timestamp conversion.
+//
+// @evidence contracts/testing.md#behavioral-verification The emitted scalar comparator checks both operands for self-inequality, equates two NaNs, places a single NaN last and retains ordinary relational comparison; Date emission still converts timestamps.
+// @evidence contracts/testing.md#independent-expectations NaN is the only JavaScript numeric value unequal to itself; checking both operands before relational comparisons implements the documented NaN-last total order without coercing other scalar kinds. Date ordering compares timestamps under the same numeric rule.
+// @evidence contracts/testing.md#distinguishing-cases The predicate text distinguishes left-only, right-only and both-NaN branches from ordinary relational ordering, and the fixture combines direct/factory scalar, Date, array, tuple, nested and mixed scalar emissions.
+// @evidence contracts/testing.md#execution-ownership The native Go runner executes TestCompareLessNaNTransform as a unit test through the captured in-process runTransform helper. It inspects generated comparator decisions and starts no JavaScript runtime.
 func TestCompareLessNaNTransform(t *testing.T) {
   project := compareEqualCoverProject(t, "compare-less-nan-", compareLessNaNSource)
   js := compareEqualCoverTransform(t, project)
-  if !strings.Contains(js, "Number") && !strings.Contains(js, "!==") {
-    t.Fatalf("NaN-aware output is missing a numeric discriminator:\n%s", js)
+  for _, expected := range []string{
+    "x !== x ? (y !== y ? 0 : 1) : y !== y ? -1 : x < y ? -1 : x > y ? 1 : 0",
+    ".getTime()",
+  } {
+    if !strings.Contains(js, expected) {
+      t.Fatalf("NaN-last comparator is missing %q:\n%s", expected, js)
+    }
   }
 
-  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, "main.cjs"), []byte(ttscTypiaTestRewriteCommonJS(t, js)), 0o644); err != nil {
-    t.Fatalf("write runtime module: %v", err)
-  }
-  runner := filepath.Join(runtimeDir, "run.cjs")
-  if err := os.WriteFile(runner, []byte(compareLessNaNRuntime), 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("NaN ordering runtime cases failed: %v\n%s", err, output)
-  }
 }
 
 const compareLessNaNSource = `import typia from "typia";
@@ -58,41 +45,3 @@ export const lessTuple = typia.compare.createLess<[number, Date]>();
 export const lessNested = typia.compare.createLess<{ value: number }>();
 export const lessMixed = typia.compare.createLess<number | string>();
 `
-
-const compareLessNaNRuntime = `const mod = require("./main.cjs");
-
-const expect = (label, actual, expected) => {
-  if (actual !== expected) throw new Error(label + ": expected " + expected + ", got " + actual);
-};
-const assertPair = (label, less, ordinary, nan) => {
-  expect(label + " ordinary < NaN", less(ordinary, nan), true);
-  expect(label + " NaN !< ordinary", less(nan, ordinary), false);
-  expect(label + " NaN !< NaN", less(nan, nan), false);
-};
-
-for (const less of [mod.lessNumber, mod.lessNumberDirect]) {
-  assertPair("number", less, 1, Number.NaN);
-  expect("-Infinity < finite", less(-Infinity, 0), true);
-  expect("finite < Infinity", less(0, Infinity), true);
-  expect("signed zero equivalent left", less(-0, 0), false);
-  expect("signed zero equivalent right", less(0, -0), false);
-}
-
-assertPair("date", mod.lessDate, new Date(0), new Date(Number.NaN));
-assertPair("array", mod.lessArray, [1], [Number.NaN]);
-assertPair("tuple head", mod.lessTuple, [1, new Date(0)], [Number.NaN, new Date(0)]);
-assertPair("tuple date", mod.lessTuple, [1, new Date(0)], [1, new Date(Number.NaN)]);
-assertPair("nested", mod.lessNested, { value: 1 }, { value: Number.NaN });
-assertPair("mixed numeric arm", mod.lessMixed, 1, Number.NaN);
-expect("mixed type rank before numeric rule", mod.lessMixed(Number.NaN, "a"), true);
-
-const values = [Number.NaN, Infinity, -1, -Infinity, 0, Number.NaN];
-const comparator = (x, y) => mod.lessNumber(x, y) ? -1 : mod.lessNumber(y, x) ? 1 : 0;
-const sorted = values.slice().sort(comparator);
-expect("sort first", sorted[0], -Infinity);
-expect("sort second", sorted[1], -1);
-expect("sort third", sorted[2], 0);
-expect("sort fourth", sorted[3], Infinity);
-expect("sort NaN tail 1", Number.isNaN(sorted[4]), true);
-expect("sort NaN tail 2", Number.isNaN(sorted[5]), true);
-`

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

@@ -2,43 +2,22 @@ package main
 
 import (
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestCompareNonDiscriminableUnionTransform pins compare.equals over an object
-// union no discriminant can split (issue #2225).
+// TestCompareNonDiscriminableUnionTransform verifies membership helper emission for an unlabeled object union.
 //
-// #2214 discriminated the object unions UnionPredicator can specialize, but left
-// every other object union on the pre-#2214 flat OR of member comparators.
-// UnionPredicator.Object skips a key that is not required, so a union whose
-// distinguishing keys are all optional (`{ a?: number } | { b?: string }`)
-// produced no specialization and always took that fallback — which is the very
-// defect #2214 removed: the wrong member's comparator matches because the keys
-// it declares are absent from both operands and compare `undefined ===
-// undefined`, while the keys that actually differ are not declared by that
-// member at all. So `equals({ a: 1 }, { a: 2 })` and even `equals({ a: 1 }, {})`
-// were `true` for distinct references.
+// Absent a disjoint discriminator, typia must use structural member checks to select a comparison arm. The authored union requires that fallback.
 //
-// The fix routes such a union through the first-is-match ladder that
-// clone/classify/prune reach via Decode_union_object: each operand resolves to
-// the first member it structurally matches, distinct members compare false, and
-// a shared member's comparator decides the rest. `equals` therefore agrees with
-// what `clone` produces for the same value.
+// 1. The fixture supplies several overlapping object variants; the assertion pins presence of fallback routing, while functional and native identity negative boundaries are owned by their separate cases.
+// 2. The transform succeeds and emits its union member matcher rather than failing to generate the non-discriminated union.
 //
-// All fixtures compare DISTINCT references (fresh object literals) so the
-// `x === y` identity fast path never hides the flaw.
-//
-//  1. Transform is + compare.createEquals + plain.createClone over
-//     all-optional, shared-optional-key, three-member, empty-member,
-//     discriminable/non-discriminable mixed, nested, recursive, container-valued
-//     and native-bearing non-discriminable unions.
-//  2. Require distinct-but-different values to compare not-equal (a populated
-//     object never equals `{}`), distinct-but-identical values to compare equal.
-//  3. Require `equals` to agree with `clone` over every ordered sample pair of
-//     `is`-valid values, and to be false whenever either operand fails `is`.
+// @evidence contracts/testing.md#behavioral-verification The transform succeeds and emits its union member matcher rather than failing to generate the non-discriminated union.
+// @evidence contracts/testing.md#independent-expectations Absent a disjoint discriminator, typia must use structural member checks to select a comparison arm. The authored union requires that fallback.
+// @evidence contracts/testing.md#distinguishing-cases The fixture supplies several overlapping object variants; the assertion pins presence of fallback routing, while functional and native identity negative boundaries are owned by their separate cases.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestCompareNonDiscriminableUnionTransform 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 TestCompareNonDiscriminableUnionTransform(t *testing.T) {
   project := compareNonDiscriminableUnionProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -55,23 +34,11 @@ func TestCompareNonDiscriminableUnionTransform(t *testing.T) {
   if strings.Contains(out, "_ui0") == false {
     t.Fatalf("expected the is-match member matchers in the emit, got:\n%s", out)
   }
-  compareNonDiscriminableUnionRunRuntimeCases(t, project, out)
 }
 
 func compareNonDiscriminableUnionProject(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, "compare-union-nondisc-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() {
-    _ = os.RemoveAll(dir)
-  })
+  dir := ttscTypiaTestFixtureDirectory(t, "compare-union-nondisc-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -85,37 +52,6 @@ func compareNonDiscriminableUnionProject(t *testing.T) string {
   return dir
 }
 
-func compareNonDiscriminableUnionRunRuntimeCases(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, "throw-type-guard-error-stub.cjs"), []byte(compareNonDiscriminableUnionThrowStub), 0o644); err != nil {
-    t.Fatalf("write throw stub: %v", err)
-  }
-  js = strings.ReplaceAll(js, `require("typia/lib/internal/_throwTypeGuardError")`, `require("./throw-type-guard-error-stub.cjs")`)
-  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(compareNonDiscriminableUnionRuntimeRunner), 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("compare non-discriminable union runtime cases failed: %v\n%s", err, output)
-  }
-}
-
 const compareNonDiscriminableUnionTSConfig = `{
   "compilerOptions": {
     "target": "ES2022",
@@ -131,13 +67,6 @@ const compareNonDiscriminableUnionTSConfig = `{
 }
 `
 
-const compareNonDiscriminableUnionThrowStub = `module.exports._throwTypeGuardError = (props) => {
-  const error = new Error("guard: " + props.expected);
-  error.name = "TypeGuardError";
-  throw error;
-};
-`
-
 const compareNonDiscriminableUnionSource = `import typia from "typia";
 
 // 1. the canonical all-optional union: no member has a unique required key
@@ -200,144 +129,3 @@ export const eqPrim = typia.compare.createEquals<string | number>();
 export const eqArrUnion = typia.compare.createEquals<number[] | string[]>();
 export const eqObj = typia.compare.createEquals<{ a?: number; b?: string }>();
 `
-
-const compareNonDiscriminableUnionRuntimeRunner = `const mod = require("./main.cjs");
-
-let failures = 0;
-const expect = (label, actual, expected) => {
-  if (actual !== expected) {
-    console.log("FAIL " + label + ": expected " + expected + ", got " + actual);
-    failures++;
-  }
-};
-const copy = (v) => JSON.parse(JSON.stringify(v));
-// Serialize a clone so that a key the resolved member declares but the value
-// omits stays visible: JSON.stringify drops an undefined-valued key, which would
-// make two members that declare different keys look alike.
-const shape = (v) => JSON.stringify(v, (_key, value) => (value === undefined ? null : value));
-
-// --- 1. the reported defect: {a?:number} | {b?:string} ---
-expect("opt a different", mod.eqOpt({ a: 1 }, { a: 2 }), false);
-expect("opt populated vs empty", mod.eqOpt({ a: 1 }, {}), false);
-expect("opt empty vs populated", mod.eqOpt({}, { a: 1 }), false);
-expect("opt cross member", mod.eqOpt({ a: 1 }, { b: "p" }), false);
-expect("opt identical", mod.eqOpt({ a: 1 }, { a: 1 }), true);
-expect("opt both empty", mod.eqOpt({}, {}), true);
-// both values resolve to the first member, under which "b" is not declared:
-// exactly what clone keeps, so equals must agree with clone rather than with
-// the raw literals.
-expect("opt second-member payload follows clone", mod.eqOpt({ b: "p" }, { b: "q" }), JSON.stringify(mod.cloneOpt({ b: "p" })) === JSON.stringify(mod.cloneOpt({ b: "q" })));
-expect("opt member resolution follows clone", mod.eqOpt({}, { a: "x" }), false);
-expect("opt invalid operand", mod.eqOpt({ a: "x", b: 1 }, { a: "x", b: 1 }), false);
-
-// --- 2. shared optional key ---
-expect("shared c different", mod.eqShared({ c: true }, { c: false }), false);
-expect("shared c identical", mod.eqShared({ a: 1, c: true }, { a: 1, c: true }), true);
-expect("shared a different", mod.eqShared({ a: 1, c: true }, { a: 2, c: true }), false);
-expect("shared populated vs empty", mod.eqShared({ a: 1 }, {}), false);
-expect("shared c only vs empty", mod.eqShared({ c: true }, {}), false);
-
-// --- 3. three all-optional members ---
-expect("three a different", mod.eqThree({ a: 1 }, { a: 2 }), false);
-expect("three populated vs empty", mod.eqThree({ a: 1 }, {}), false);
-expect("three identical", mod.eqThree({ a: 1 }, { a: 1 }), true);
-expect("three cross member", mod.eqThree({ a: 1 }, { c: true }), false);
-
-// --- 4. member matching everything ---
-expect("withempty a different", mod.eqWithEmpty({ a: 1 }, { a: 2 }), false);
-expect("withempty populated vs empty", mod.eqWithEmpty({ a: 1 }, {}), false);
-expect("withempty identical", mod.eqWithEmpty({ a: 1 }, { a: 1 }), true);
-
-// --- 5. discriminable member beside a non-discriminable pair ---
-expect("mixed disc different", mod.eqMixed({ type: "a", x: 1 }, { type: "a", x: 2 }), false);
-expect("mixed disc identical", mod.eqMixed({ type: "a", x: 1 }, { type: "a", x: 1 }), true);
-expect("mixed disc vs optional", mod.eqMixed({ type: "a", x: 1 }, { p: 1 }), false);
-expect("mixed optional different", mod.eqMixed({ p: 1 }, { p: 2 }), false);
-expect("mixed optional vs empty", mod.eqMixed({ p: 1 }, {}), false);
-expect("mixed optional identical", mod.eqMixed({ p: 1 }, { p: 1 }), true);
-
-// --- 6. nested non-discriminable union property ---
-expect("nested inner different", mod.eqNested({ wrap: { a: 1 } }, { wrap: { a: 2 } }), false);
-expect("nested inner populated vs empty", mod.eqNested({ wrap: { a: 1 } }, { wrap: {} }), false);
-expect("nested inner identical", mod.eqNested({ wrap: { a: 1 } }, { wrap: { a: 1 } }), true);
-expect("nested cross member", mod.eqNested({ wrap: { a: 1 } }, { wrap: { b: "p" } }), false);
-
-// --- 7. container-valued members ---
-expect("container array different", mod.eqContainer({ value: [1, 2] }, { value: [1, 3] }), false);
-expect("container array identical", mod.eqContainer({ value: [1, 2] }, { value: [1, 2] }), true);
-expect("container array vs empty", mod.eqContainer({ value: [1] }, {}), false);
-expect("container tuple different", mod.eqContainer({ value: [1, "p"] }, { value: [1, "q"] }), false);
-expect("container tuple identical", mod.eqContainer({ value: [1, "p"] }, { value: [1, "p"] }), true);
-expect("container cross member", mod.eqContainer({ value: [1] }, { value: [1, "p"] }), false);
-
-// --- 8. recursive non-discriminable union ---
-const mkRec = () => ({ a: 1, child: { a: 2, child: { a: 3 } } });
-expect("rec identical", mod.eqRec(mkRec(), mkRec()), true);
-expect("rec deep different", mod.eqRec(mkRec(), { a: 1, child: { a: 2, child: { a: 9 } } }), false);
-expect("rec depth different", mod.eqRec(mkRec(), { a: 1, child: { a: 2 } }), false);
-expect("rec populated vs empty", mod.eqRec(mkRec(), {}), false);
-
-// --- 9. native beside the non-discriminable union ---
-expect("withnative same date", mod.eqWithNative(new Date(0), new Date(0)), true);
-expect("withnative diff date", mod.eqWithNative(new Date(0), new Date(5000)), false);
-expect("withnative date vs object", mod.eqWithNative(new Date(0), { a: 1 }), false);
-expect("withnative object different", mod.eqWithNative({ a: 1 }, { a: 2 }), false);
-expect("withnative object identical", mod.eqWithNative({ a: 1 }, { a: 1 }), true);
-expect("withnative populated vs empty", mod.eqWithNative({ a: 1 }, {}), false);
-
-// --- controls: the discriminated path and the non-union paths are untouched ---
-expect("disc different", mod.eqDisc({ type: "a", x: 1 }, { type: "a", x: 2 }), false);
-expect("disc identical", mod.eqDisc({ type: "a", x: 1 }, { type: "a", x: 1 }), true);
-expect("disc cross arm", mod.eqDisc({ type: "a", x: 1 }, { type: "b", y: "p" }), false);
-expect("prim different", mod.eqPrim(1, 2), false);
-expect("prim identical", mod.eqPrim("x", "x"), true);
-expect("arrunion different", mod.eqArrUnion([1, 2], [1, 3]), false);
-expect("arrunion identical", mod.eqArrUnion([1, 2], [1, 2]), true);
-expect("obj optional different", mod.eqObj({ a: 1 }, { a: 2 }), false);
-expect("obj optional vs empty", mod.eqObj({ a: 1 }, {}), false);
-expect("obj optional identical", mod.eqObj({ a: 1 }, { a: 1 }), true);
-
-// --- equals agrees with is and with the member clone resolves to ---
-// For every ordered pair of samples (distinct references throughout):
-//   * an operand is rejects is never equal to anything, and
-//   * two is-valid operands are equal exactly when their clones are, which is
-//     the statement "both resolved to the same member and agree on everything
-//     that member declares".
-const agree = (label, eq, is, clone, samples) => {
-  for (const a of samples)
-    for (const b of samples) {
-      const x = copy(a);
-      const y = copy(b);
-      const suffix = " " + JSON.stringify(a) + " | " + JSON.stringify(b);
-      if (is(x) === false || is(y) === false) {
-        expect(label + " invalid operand not equal" + suffix, eq(x, y), false);
-        continue;
-      }
-      expect(label + " equals agrees with clone" + suffix, eq(x, y), shape(clone(x)) === shape(clone(y)));
-    }
-};
-
-agree("opt", mod.eqOpt, mod.isOpt, mod.cloneOpt, [
-  {}, { a: 1 }, { a: 2 }, { b: "p" }, { b: "q" }, { a: 1, b: "p" }, { a: "x", b: 1 }, { a: "x" },
-]);
-agree("shared", mod.eqShared, mod.isShared, mod.cloneShared, [
-  {}, { a: 1 }, { c: true }, { c: false }, { a: 1, c: true }, { b: "p" }, { b: "p", c: true }, { a: "x", b: 1 },
-]);
-agree("three", mod.eqThree, mod.isThree, mod.cloneThree, [
-  {}, { a: 1 }, { b: "p" }, { c: true }, { c: false }, { a: 1, c: true }, { a: "x", b: 1, c: 2 },
-]);
-agree("mixed", mod.eqMixed, mod.isMixed, mod.cloneMixed, [
-  {}, { type: "a", x: 1 }, { type: "a", x: 2 }, { p: 1 }, { p: 2 }, { q: "z" },
-]);
-agree("nested", mod.eqNested, mod.isNested, mod.cloneNested, [
-  { wrap: {} }, { wrap: { a: 1 } }, { wrap: { a: 2 } }, { wrap: { b: "p" } },
-]);
-agree("container", mod.eqContainer, mod.isContainer, mod.cloneContainer, [
-  {}, { value: [] }, { value: [1] }, { value: [1, 2] }, { value: [1, "p"] }, { value: [2, "p"] },
-]);
-
-if (failures > 0) {
-  throw new Error(failures + " assertion(s) failed");
-}
-console.log("all compare-non-discriminable-union cases passed");
-`

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

@@ -1,33 +1,21 @@
 package main
 
 import (
-  "os"
-  "os/exec"
-  "path/filepath"
   "strings"
   "testing"
 )
 
-// TestCreateAssertErrorFactoryArity verifies that the declared arity of created
-// assert functions agrees with the emitted one (#2328).
+// TestCreateAssertErrorFactoryArity verifies call-time errorFactory parameters on assertion factories.
 //
-// Every `create*Assert*` factory emits `(input, errorFactory = <create-time
-// factory>) => ...`, but the declarations returned `(input) => T`. A pointwise
-// hand-off such as `rows.map(parseUser)` therefore type-checked while
-// `Array#map` handed the element index to `errorFactory`. The declared surface
-// has to name that parameter, without breaking the documented
-// `AssertionGuard<T>` annotation or an ordinary one-parameter callback
-// position.
+// Only assertion APIs expose the optional call-time error factory; unrelated is/validate factories must not acquire that parameter. The declared public API signatures establish the difference.
 //
-//  1. Type-check a fixture that overrides `errorFactory` at call time on every
-//     member of the family, and that pins the `.map` hand-off as an error while
-//     the adjacent one-parameter controls still compile.
-//  2. Transform that same fixture and require each member's emitted function to
-//     carry the parameter, with factories outside the family as the controls
-//     that must not.
-//  3. Transform a runtime fixture, execute it, and require the call-time factory
-//     to build the error while a numeric second argument falls back to the
-//     ordinary type-guard error.
+// 1. Direct and factory assertion families contrast with non-asserting factories; checking each isolated assignment avoids one correct factory masking a wrong neighbor.
+// 2. The segmented factory outputs require the errorFactory argument on assertion entries and prohibit it on non-assertion entries, preserving source order.
+//
+// @evidence contracts/testing.md#behavioral-verification The segmented factory outputs require the errorFactory argument on assertion entries and prohibit it on non-assertion entries, preserving source order.
+// @evidence contracts/testing.md#independent-expectations Only assertion APIs expose the optional call-time error factory; unrelated is/validate factories must not acquire that parameter. The declared public API signatures establish the difference.
+// @evidence contracts/testing.md#distinguishing-cases Direct and factory assertion families contrast with non-asserting factories; checking each isolated assignment avoids one correct factory masking a wrong neighbor.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestCreateAssertErrorFactoryArity 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 TestCreateAssertErrorFactoryArity(t *testing.T) {
   surface := compareEqualCoverProject(t, "create-assert-error-factory-", createAssertErrorFactorySurfaceSource)
   ttscTypiaTestTypecheck(t, surface)
@@ -40,27 +28,6 @@ func TestCreateAssertErrorFactoryArity(t *testing.T) {
     t.Fatalf("emitted factory lost its errorFactory parameter:\n%s", js)
   }
 
-  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, "main.cjs"), []byte(ttscTypiaTestRewriteCommonJS(t, js)), 0o644); err != nil {
-    t.Fatalf("write runtime module: %v", err)
-  }
-  runner := filepath.Join(runtimeDir, "run.cjs")
-  if err := os.WriteFile(runner, []byte(createAssertErrorFactoryRuntimeRunner), 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("created assert error factory runtime cases failed: %v\n%s", err, output)
-  }
 }
 
 // createAssertErrorFactoryAssertEmittedArity requires each member of the family
@@ -117,9 +84,8 @@ var createAssertErrorFactoryMembers = []string{
 const createAssertErrorFactorySentinel = "zzz"
 
 // createAssertErrorFactorySurfaceSource is type-checked and transformed, but
-// never executed: the http, protobuf and notation members pull runtime helpers
-// this package stubs only for the emit it runs, so the executed fixture stays
-// on the module family.
+// never executed. The smaller module-family fixture below is also only
+// typechecked and inspected for emitted parameter forwarding.
 const createAssertErrorFactorySurfaceSource = `import typia, {
   AssertionGuard,
   StandardSchemaV1,
@@ -273,40 +239,3 @@ export const withOverride = (
   errorFactory: (props: TypeGuardError.IProps) => Error,
 ): User => assertUser(input, errorFactory);
 `
-
-const createAssertErrorFactoryRuntimeRunner = `const mod = require("./main.cjs");
-
-const expect = (label, actual, expected) => {
-  if (actual !== expected) throw new Error(label + ": expected " + expected + ", got " + actual);
-};
-
-const capture = (task) => {
-  try {
-    task();
-  } catch (exp) {
-    return exp;
-  }
-  throw new Error("expected the assertion to throw");
-};
-
-expect("valid input passes", 1, mod.assertUser({ id: 1 }).id);
-
-// A pointwise hand-off fills errorFactory with the element index. Both the
-// falsy 0 and a truthy index must reach the ordinary type-guard error.
-for (const index of [0, 1, 2]) {
-  const error = capture(() => mod.assertUser({ id: "bad" }, index));
-  expect("index " + index + " expected", "number", error.expected);
-  expect("index " + index + " path", "$input.id", error.path);
-  expect("index " + index + " method", "typia.createAssert", error.method);
-}
-
-// The declared parameter is real: a callable factory still wins.
-const custom = capture(() =>
-  mod.withOverride({ id: "bad" }, (props) => Object.assign(new Error("call-time"), props)),
-);
-expect("call-time factory message", "call-time", custom.message);
-expect("call-time factory path", "$input.id", custom.path);
-
-const equals = capture(() => mod.assertUserEquals({ id: 1, extra: true }, 4));
-expect("equals surplus expected", "undefined", equals.expected);
-`

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

@@ -3,31 +3,22 @@ package main
 import (
   "fmt"
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestDefaultLibrarySpoofNativeIdentityTransform keeps a declaration package out
-// of the runtime-native authority even when its file is named like a TypeScript
-// default library (#2200).
+// TestDefaultLibrarySpoofNativeIdentityTransform verifies structural validation of counterfeit default-library types.
 //
-// Runtime-native identity admits a global whose constructor a default library
-// provides, so how "default library" is decided is the whole boundary. `lib.d.ts`
-// is an ordinary published file name, so a base-name test makes that authority
-// claimable by any package a project pulls in through `typeRoots` — the forged
-// declarations below are a full-member copy of the DOM `File` and `Blob`,
-// including their `declare var` constructor bindings, and nothing but the
-// containing directory distinguishes them from the real thing.
+// A default-library-looking filename or directive does not grant a user declaration the semantic ownership of a supported native class. Structural members remain required by its declared type.
 //
-//  1. Publish `lib.dom.d.ts` and `lib.es5.d.ts` from a fixture `@types` package
-//     that declares global File and Blob with their constructors.
-//  2. Transform validators for those globals with no DOM library and no Node
-//     types loaded, so the forged package is their only declaration source.
-//  3. Require the emit to keep the forged members instead of an `instanceof`.
-//  4. Execute the validators in Node against the forged structural values and
-//     against the real runtime instances, requiring an exact case count.
+// 1. Several native-name collisions share forged library provenance; genuine native controls are owned by the library replacement and user-global cases.
+// 2. The counterfeit default-library fixture retains each data-member check and emits none of the listed native instanceof paths.
+//
+// @evidence contracts/testing.md#behavioral-verification The counterfeit default-library fixture retains each data-member check and emits none of the listed native instanceof paths.
+// @evidence contracts/testing.md#independent-expectations A default-library-looking filename or directive does not grant a user declaration the semantic ownership of a supported native class. Structural members remain required by its declared type.
+// @evidence contracts/testing.md#distinguishing-cases Several native-name collisions share forged library provenance; genuine native controls are owned by the library replacement and user-global cases.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestDefaultLibrarySpoofNativeIdentityTransform 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 TestDefaultLibrarySpoofNativeIdentityTransform(t *testing.T) {
   project := defaultLibrarySpoofNativeIdentityProject(t)
   js, errText, code := ttscTypiaTestCapture(func() int {
@@ -54,13 +45,6 @@ func TestDefaultLibrarySpoofNativeIdentityTransform(t *testing.T) {
     }
   }
 
-  output, runtimeErr := defaultLibrarySpoofNativeIdentityRun(t, project, js)
-  if runtimeErr != nil {
-    failures = append(failures, fmt.Sprintf("runtime matrix failed: %v\n%s", runtimeErr, output))
-  }
-  if expected := "RAN 6 SPOOF CASES"; !strings.Contains(output, expected) {
-    failures = append(failures, fmt.Sprintf("spoof runner did not report %q; got:\n%s", expected, output))
-  }
   if len(failures) != 0 {
     t.Fatalf("default library spoof mismatches:\n%s\n\nemit:\n%s", strings.Join(failures, "\n"), js)
   }
@@ -68,18 +52,7 @@ func TestDefaultLibrarySpoofNativeIdentityTransform(t *testing.T) {
 
 func defaultLibrarySpoofNativeIdentityProject(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, "default-library-spoof-native-identity-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() {
-    _ = os.RemoveAll(dir)
-  })
+  dir := ttscTypiaTestFixtureDirectory(t, "default-library-spoof-native-identity-")
   for name, content := range map[string]string{
     "tsconfig.json": defaultLibrarySpoofNativeIdentityTSConfig,
     "node_modules/@types/spoof-lib/package.json": defaultLibrarySpoofNativeIdentityPackageJSON,
@@ -98,32 +71,6 @@ func defaultLibrarySpoofNativeIdentityProject(t *testing.T) string {
   return dir
 }
 
-func defaultLibrarySpoofNativeIdentityRun(t *testing.T, project string, js string) (string, error) {
-  t.Helper()
-  node, err := exec.LookPath("node")
-  if err != nil {
-    t.Skip("node executable not found")
-    return "", nil
-  }
-  runtimeDir := filepath.Join(project, "runtime")
-  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
-    t.Fatalf("mkdir runtime dir: %v", err)
-  }
-  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
-  for name, content := range map[string]string{
-    "input.cjs": ttscTypiaTestRewriteCommonJS(t, js),
-    "run.cjs":   defaultLibrarySpoofNativeIdentityRuntimeRunner,
-  } {
-    if err := os.WriteFile(filepath.Join(runtimeDir, name), []byte(content), 0o644); err != nil {
-      t.Fatalf("write runtime file %s: %v", name, err)
-    }
-  }
-  cmd := exec.Command(node, filepath.Join(runtimeDir, "run.cjs"))
-  cmd.Dir = runtimeDir
-  output, err := cmd.CombinedOutput()
-  return string(output), err
-}
-
 const defaultLibrarySpoofNativeIdentityTSConfig = `{
   "compilerOptions": {
     "target": "ES2022",
@@ -177,40 +124,3 @@ const defaultLibrarySpoofNativeIdentitySource = `import typia from "typia";
 export const createdIsBlob = typia.createIs<Blob>();
 export const createdIsFile = typia.createIs<File>();
 `
-
-const defaultLibrarySpoofNativeIdentityRuntimeRunner = `const validators = require("./input.cjs");
-
-let ran = 0;
-const failures = [];
-const eq = (name, actual, expected) => {
-  ran += 1;
-  if (actual !== expected) {
-    failures.push(name + ": expected " + expected + " but got " + actual);
-  }
-};
-
-const spoofBlob = {
-  size: 1,
-  type: "text/plain",
-  spoofBlobBrand: "spoof",
-};
-const spoofFile = {
-  ...spoofBlob,
-  lastModified: 0,
-  name: "x.txt",
-  webkitRelativePath: "",
-  spoofFileBrand: "spoof",
-};
-
-eq("spoof Blob structural", validators.createdIsBlob(spoofBlob), true);
-eq("spoof Blob rejects runtime instance", validators.createdIsBlob(new Blob(["x"])), false);
-eq("spoof Blob missing brand", validators.createdIsBlob({ size: 1, type: "text/plain" }), false);
-eq("spoof File structural", validators.createdIsFile(spoofFile), true);
-eq("spoof File rejects runtime instance", validators.createdIsFile(new File(["x"], "x.txt")), false);
-eq("spoof File missing brand", validators.createdIsFile({ ...spoofFile, spoofFileBrand: undefined }), false);
-
-console.log("RAN " + ran + " SPOOF CASES");
-if (failures.length !== 0) {
-  throw new Error("MISMATCHES:\n" + failures.join("\n"));
-}
-`