typia 15.0.0 → 15.1.0

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

@@ -2,7 +2,6 @@ package main
 
 import (
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
@@ -18,33 +17,53 @@ import (
 //
 //  1. Transform a fixture mixing tagged `unknown[]`, an untagged `any[]`
 //     control, a `string[]` control, and a tagged-any union branch.
-//  2. Execute validate/is entrypoints and require the container tags to
-//     reject violating inputs with the usual per-tag expected strings.
-//  3. Require the untagged any-element array to keep accepting everything
-//     (the short circuit itself must survive).
+//  2. Inspect each emitted validator's own array and container predicates.
+//  3. Require the untagged any-element array to keep its array guard without
+//     element, minimum-length or custom-status restrictions.
+//
+// @evidence contracts/testing.md#behavioral-verification Tagged unknown-array and concrete-array exports retain the minimum length and custom status predicate. Eight union exports retain their tagged list minimum; the untagged any-array output has its array guard and no element or container restriction.
+// @evidence contracts/testing.md#independent-expectations MinItems<2> constrains the container length regardless of its element type; the authored custom tag requires one SUCCESS or FAILURE element. An untagged any[] constrains only array identity. Output predicates are derived from these type contracts, without certifying JavaScript execution.
+// @evidence contracts/testing.md#distinguishing-cases The unknown-array positive is paired with concrete strings and untagged any[] controls. Union ordering, string and tuple alternatives, two tagged alternatives and validator/serializer operation families have separate export-local assertions.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestAnyArrayTypeTagsTransform as a unit test. It transforms the temporary fixture in process and inspects each emitted export without a compiler or JavaScript subprocess; runtime counterexamples belong to the maintained TypeScript execution suite.
 func TestAnyArrayTypeTagsTransform(t *testing.T) {
   project := anyArrayTypeTagsProject(t)
   js := anyArrayTypeTagsTransform(t, project)
-  if !strings.Contains(js, "MinItems") {
-    t.Fatalf("tagged any-array fixture was not emitted:\n%s", js)
+  for _, name := range []string{"validateTagged", "isTagged", "validateConcrete"} {
+    emitted := anyArrayTypeTagsExport(t, js, name)
+    for _, guard := range []string{"Array.isArray(input)", "2 <= input.length", `input.some(elem => elem === "SUCCESS" || elem === "FAILURE")`} {
+      if !strings.Contains(emitted, guard) {
+        t.Fatalf("%s lost container predicate %q:\n%s", name, guard, emitted)
+      }
+    }
+  }
+  plain := anyArrayTypeTagsExport(t, js, "validatePlainAny")
+  if !strings.Contains(plain, "Array.isArray(input)") || strings.Contains(plain, "input.length") || strings.Contains(plain, "input.some") || strings.Contains(plain, "input.every") {
+    t.Fatalf("untagged any-array must retain the array guard without element/container restrictions:\n%s", plain)
+  }
+  for _, name := range []string{"validateUnion", "validateUnionReversed", "isUnion", "assertUnion", "equalsUnion", "validateTupleUnion", "validateTaggedAlternatives", "stringifyUnion"} {
+    emitted := anyArrayTypeTagsExport(t, js, name)
+    if !strings.Contains(emitted, "2 <= entire.length") {
+      t.Fatalf("%s lost its tagged array union branch:\n%s", name, emitted)
+    }
   }
-  anyArrayTypeTagsRunRuntimeCases(t, project, js)
 }
 
-func anyArrayTypeTagsProject(t *testing.T) string {
+func anyArrayTypeTagsExport(t *testing.T, output, name string) 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)
+  start := strings.LastIndex(output, "exports."+name+" = ")
+  if start < 0 {
+    t.Fatalf("missing emitted export %s", name)
   }
-  dir, err := os.MkdirTemp(base, "any-array-tags-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
+  segment := output[start:]
+  if end := strings.Index(segment[1:], "\nexports."); end >= 0 {
+    segment = segment[:end+1]
   }
-  t.Cleanup(func() {
-    _ = os.RemoveAll(dir)
-  })
+  return segment
+}
+
+func anyArrayTypeTagsProject(t *testing.T) string {
+  t.Helper()
+  dir := ttscTypiaTestFixtureDirectory(t, "any-array-tags-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -74,33 +93,6 @@ func anyArrayTypeTagsTransform(t *testing.T, project string) string {
   return out
 }
 
-func anyArrayTypeTagsRunRuntimeCases(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(anyArrayTypeTagsRuntimeRunner), 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("any-array tags runtime cases failed: %v\n%s", err, output)
-  }
-}
-
 const anyArrayTypeTagsTSConfig = `{
   "compilerOptions": {
     "target": "ES2022",
@@ -171,88 +163,3 @@ export const schemaUnion = typia.json.schemas<[
   (unknown[] & tags.MinItems<2>) | string[],
 ]>();
 `
-
-const anyArrayTypeTagsRuntimeRunner = `const mod = require("./main.cjs");
-
-const expectSuccess = (label, result) => {
-  if (result.success !== true) {
-    throw new Error(label + " unexpectedly failed: " + JSON.stringify(result.errors));
-  }
-};
-const expectFailure = (label, result, expectedFragment) => {
-  if (result.success !== false) {
-    throw new Error(label + " unexpectedly passed");
-  }
-  if (
-    expectedFragment !== undefined &&
-    result.errors.every((error) => error.expected.includes(expectedFragment) === false)
-  ) {
-    throw new Error(
-      label + " did not report " + expectedFragment + ": " + JSON.stringify(result.errors),
-    );
-  }
-};
-
-// 1. Tagged unknown[]: both tags enforced, element contents free.
-expectSuccess("tagged valid", mod.validateTagged(["anything", "SUCCESS"]));
-expectSuccess("tagged valid mixed", mod.validateTagged([1, { x: true }, "FAILURE"]));
-expectFailure("tagged too short", mod.validateTagged(["SUCCESS"]), "MinItems<2>");
-expectFailure("tagged no status", mod.validateTagged(["a", "b"]), "ContainsStatus");
-expectFailure("tagged non-array", mod.validateTagged("nope"));
-if (mod.isTagged(["a", "b"]) !== false) {
-  throw new Error("is accepted an array violating the custom predicate");
-}
-if (mod.isTagged(["a", "SUCCESS"]) !== true) {
-  throw new Error("is rejected a valid tagged array");
-}
-
-// 2. Untagged any[]: the wholesale skip must survive.
-expectSuccess("plain any empty", mod.validatePlainAny([]));
-expectSuccess("plain any mixed", mod.validatePlainAny([1, "x", null, undefined]));
-expectFailure("plain any non-array", mod.validatePlainAny({}));
-
-// 3. Concrete element control behaves identically for the shared cases.
-expectFailure("concrete too short", mod.validateConcrete(["SUCCESS"]), "MinItems<2>");
-expectFailure("concrete no status", mod.validateConcrete(["a", "b"]), "ContainsStatus");
-expectSuccess("concrete valid", mod.validateConcrete(["a", "SUCCESS"]));
-
-// 4. Complete branches backtrack across wrapper predicates and element types.
-expectSuccess("union via tagged any", mod.validateUnion({ list: [1, 2] }));
-expectSuccess("union via string branch", mod.validateUnion({ list: ["solo"] }));
-expectFailure("union no valid branch", mod.validateUnion({ list: [1] }), "MinItems<2>");
-expectSuccess("reversed union via tagged any", mod.validateUnionReversed({ list: [1, 2] }));
-expectSuccess("reversed union via string branch", mod.validateUnionReversed({ list: ["solo"] }));
-expectFailure("reversed union no valid branch", mod.validateUnionReversed({ list: [1] }), "MinItems<2>");
-if (mod.isUnion({ list: [1] }) !== false || mod.isUnion({ list: [1, 2] }) !== true) {
-  throw new Error("is did not honor the complete tagged union branches");
-}
-if (mod.equalsUnion({ list: [1] }) !== false || mod.equalsUnion({ list: ["solo"] }) !== true) {
-  throw new Error("equals did not honor the complete tagged union branches");
-}
-let asserted = false;
-try {
-  mod.assertUnion({ list: [1] });
-} catch (error) {
-  asserted = String(error && error.message).includes("MinItems<2>");
-}
-if (asserted !== true) {
-  throw new Error("assert did not attribute the failed wrapper tag");
-}
-
-expectSuccess("tuple branch", mod.validateTupleUnion({ list: [1] }));
-expectSuccess("tuple union tagged any", mod.validateTupleUnion({ list: [1, 2] }));
-expectSuccess("tagged alternative string", mod.validateTaggedAlternatives({ list: ["solo"] }));
-expectSuccess("tagged alternative any", mod.validateTaggedAlternatives({ list: [1, 2] }));
-expectSuccess("tagged alternative empty", mod.validateTaggedAlternatives({ list: [] }));
-expectFailure("tagged alternatives reject", mod.validateTaggedAlternatives({ list: [1] }), "MinItems<2>");
-
-const stringified = mod.stringifyUnion({ list: ["solo"] });
-if (stringified.success !== true || JSON.parse(stringified.data).list[0] !== "solo") {
-  throw new Error("validated stringify rejected a later valid branch: " + JSON.stringify(stringified));
-}
-expectFailure("validated stringify no valid branch", mod.stringifyUnion({ list: [1] }), "MinItems<2>");
-const unionSchema = JSON.stringify(mod.schemaUnion);
-if (unionSchema.includes('"minItems":2') === false) {
-  throw new Error("array union schema lost MinItems: " + unionSchema);
-}
-`

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

@@ -1,8 +1,6 @@
 package main
 
 import (
-  "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
@@ -11,46 +9,46 @@ import (
   "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
-// TestAssertGuardFactoryContract verifies factory typing and runtime shape.
+// TestAssertGuardFactoryContract verifies factory assertion-guard types and replacement of its call.
 //
-// An assertion-guard factory returns the guard itself. Its successful invocation
-// returns void while narrowing the input; it never returns another callable
-// assertion guard. The guard carries the optional call-time `errorFactory` the
-// emit really gives it, and stays assignable to the documented
-// `AssertionGuard<T>` annotation.
+// An assertion function narrows its argument and returns void, and the public AssertionGuard signature owns the optional error factory parameter. Authored Equal/Assert types and an expected-error assignment establish those static expectations.
 //
-//  1. Compile normal and equals factories with explicit and inferred types.
-//  2. Prove successful invocations narrow and have a void return type.
-//  3. Exercise custom errors and the equals-only surplus-property boundary.
+// 1. Explicit/inferred and ordinary/equals factory typings contrast with an invalid nested-guard assignment; generated runtime execution is outside this case.
+// 2. The checker verifies two inferred guards have assertion signatures rather than nested guard return types; the fixture typechecks void return/narrowing contracts.
+// 3. Require each emitted factory export to contain its generated predicate and reject an unrewritten control from the same fixture.
+//
+// @evidence contracts/testing.md#behavioral-verification The checker verifies two inferred guards have assertion signatures rather than nested guard return types and the fixture typechecks void return/narrowing contracts. Each factory export must contain its generated predicate; a no-rewrite control must lack that predicate and retain the public factory invocation.
+// @evidence contracts/testing.md#independent-expectations An assertion function narrows its argument and returns void, and the public AssertionGuard signature owns the optional error factory parameter. Authored Equal/Assert types and an expected-error assignment establish those static expectations.
+// @evidence contracts/testing.md#distinguishing-cases Explicit/inferred and ordinary/equals factory typings contrast with an invalid nested-guard assignment. Rewritten and no-rewrite emits differ only in transformation mode, so erasing generic syntax alone cannot satisfy the replacement assertion; generated runtime execution is outside this case.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestAssertGuardFactoryContract 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 TestAssertGuardFactoryContract(t *testing.T) {
   project := compareEqualCoverProject(t, "assert-guard-factory-", assertGuardFactorySource)
   ttscTypiaTestAssertGuardFactoryType(t, project)
   ttscTypiaTestTypecheck(t, project)
   js := compareEqualCoverTransform(t, project)
-  if strings.Contains(js, "createAssertGuard<") {
-    t.Fatalf("assert guard factory call was not transformed:\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)
+  for _, name := range []string{"guard", "equalsGuard", "inferred", "inferredEquals"} {
+    emitted := anyArrayTypeTagsExport(t, js, name)
+    if !strings.Contains(emitted, "__is") || strings.Contains(emitted, ".createAssertGuard(") || strings.Contains(emitted, ".createAssertGuardEquals(") {
+      t.Fatalf("%s did not replace the factory with its generated predicate:\n%s", name, emitted)
+    }
   }
-  runner := filepath.Join(runtimeDir, "run.cjs")
-  if err := os.WriteFile(runner, []byte(assertGuardFactoryRuntime), 0o644); err != nil {
-    t.Fatalf("write runtime runner: %v", err)
+  control, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+      "--rewrite-mode", "none",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("no-rewrite assertion guard control failed: code=%d stderr=%s", code, errText)
   }
-  cmd := exec.Command(node, runner)
-  cmd.Dir = runtimeDir
-  if output, err := cmd.CombinedOutput(); err != nil {
-    t.Fatalf("assert guard factory runtime cases failed: %v\n%s", err, output)
+  for _, name := range []string{"guard", "equalsGuard", "inferred", "inferredEquals"} {
+    emitted := anyArrayTypeTagsExport(t, control, name)
+    if strings.Contains(emitted, "__is") || !(strings.Contains(emitted, ".createAssertGuard(") || strings.Contains(emitted, ".createAssertGuardEquals(")) {
+      t.Fatalf("%s no-rewrite control does not distinguish factory replacement:\n%s", name, emitted)
+    }
   }
 }
 
@@ -138,28 +136,3 @@ export type FactoryCases = [
 const nested: AssertionGuard<User> = guard(input);
 void nested;
 `
-
-const assertGuardFactoryRuntime = `const mod = require("./main.cjs");
-
-const expect = (label, actual, expected) => {
-  if (actual !== expected) throw new Error(label + ": expected " + expected + ", got " + actual);
-};
-
-expect("normal success returns void", mod.guard({ id: 1 }), undefined);
-expect("equals success returns void", mod.equalsGuard({ id: 1 }), undefined);
-expect("normal permits surplus", mod.guard({ id: 1, extra: true }), undefined);
-
-for (const [label, guard, value] of [
-  ["normal invalid", mod.guard, { id: "bad" }],
-  ["equals invalid", mod.equalsGuard, { id: "bad" }],
-  ["equals surplus", mod.equalsGuard, { id: 1, extra: true }],
-]) {
-  let error;
-  try {
-    guard(value);
-  } catch (exp) {
-    error = exp;
-  }
-  expect(label + " uses custom error", error && error.message, "custom guard");
-}
-`

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

@@ -2,8 +2,8 @@ package main
 
 import (
   "os"
-  "os/exec"
   "path/filepath"
+  "strings"
   "testing"
 )
 
@@ -16,29 +16,42 @@ import (
 // constraints must also stay neutral during union/never pruning.
 //
 //  1. Transform the AtomicIntersection fixture into JavaScript.
-//  2. Execute the emitted module with typia runtime imports stubbed out.
+//  2. Decode the emitted schema literal AST without executing JavaScript.
 //  3. Assert the three tuple element component schemas are boolean, number,
 //     and string, never an empty unconstrained schema.
+//
+// @evidence contracts/testing.md#behavioral-verification The three tuple references resolve to boolean, number and string schemas in authored order; missing components, wrong tuple size and unconstrained schemas fail.
+// @evidence contracts/testing.md#independent-expectations The authored tuple wraps boolean, number and string in optional-object intersections; those primitive kinds define the ordered expected schemas rather than a previous transform snapshot. AST literal decoding interprets the emitted result but does not execute JavaScript.
+// @evidence contracts/testing.md#distinguishing-cases The three tuple references resolve to boolean, number and string schemas in authored order; missing components, wrong tuple size and unconstrained schemas fail.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestAtomicIntersectionSchemaTransform as a unit test. It runs the transform in process and parses its result through the in-memory TypeScript parser; no compiler or JavaScript subprocess is launched.
 func TestAtomicIntersectionSchemaTransform(t *testing.T) {
   project := atomicIntersectionSchemaProject(t)
   js := atomicIntersectionSchemaTransform(t, project)
-  atomicIntersectionSchemaRunRuntimeCases(t, project, js)
+  unit := ttscTypiaTestSchemaLiteral(t, js)
+  schemas := ttscTypiaTestSchemaPath(t, unit, "components", "schemas").(map[string]any)
+  tuple := schemas["AtomicIntersection"].(map[string]any)
+  ttscTypiaTestSchemaEqual(t, tuple["type"], "array")
+  items, ok := tuple["prefixItems"].([]any)
+  if !ok || len(items) != 3 {
+    t.Fatalf("expected three tuple components, got %#v", tuple)
+  }
+  for index, typ := range []string{"boolean", "number", "string"} {
+    ref, ok := items[index].(map[string]any)["$ref"].(string)
+    if !ok {
+      t.Fatalf("missing tuple reference %#v", items[index])
+    }
+    name := ref[strings.LastIndex(ref, "/")+1:]
+    target, ok := schemas[name].(map[string]any)
+    if !ok {
+      t.Fatalf("missing tuple component %s", ref)
+    }
+    ttscTypiaTestSchemaEqual(t, target["type"], typ)
+  }
 }
 
 func atomicIntersectionSchemaProject(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, "atomic-intersection-schema-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() {
-    _ = os.RemoveAll(dir)
-  })
+  dir := ttscTypiaTestFixtureDirectory(t, "atomic-intersection-schema-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -68,48 +81,6 @@ func atomicIntersectionSchemaTransform(t *testing.T, project string) string {
   return out
 }
 
-func atomicIntersectionSchemaRunRuntimeCases(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(atomicIntersectionSchemaRuntimeRunner), 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("atomic intersection schema runtime cases failed: %v\n%s", err, output)
-  }
-}
-
-const atomicIntersectionSchemaTSConfig = `{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "commonjs",
-    "moduleResolution": "bundler",
-    "ignoreDeprecations": "6.0",
-    "types": ["*"],
-    "esModuleInterop": true,
-    "strict": true,
-    "skipLibCheck": true
-  },
-  "include": ["src"]
-}
-`
-
 const atomicIntersectionSchemaSource = `import typia from "typia";
 
 export type AtomicIntersection = [
@@ -124,25 +95,3 @@ export namespace AtomicIntersection {
 
 export const schema = typia.json.schema<AtomicIntersection>();
 `
-
-const atomicIntersectionSchemaRuntimeRunner = `const unit = require("./main.cjs").schema;
-
-const schemas = unit.components?.schemas ?? {};
-const tuple = schemas.AtomicIntersection;
-if (tuple?.type !== "array" || Array.isArray(tuple.prefixItems) === false) {
-  throw new Error("AtomicIntersection tuple schema was not emitted: " + JSON.stringify(unit));
-}
-
-const schemaName = (ref) => ref.split("/").at(-1);
-const actual = tuple.prefixItems.map((item) => {
-  const target = schemas[schemaName(item.$ref)];
-  if (target === undefined) {
-    throw new Error("missing tuple component for " + item.$ref);
-  }
-  return target.type;
-});
-const expected = ["boolean", "number", "string"];
-if (JSON.stringify(actual) !== JSON.stringify(expected)) {
-  throw new Error("AtomicIntersection wrapper schemas were " + JSON.stringify(actual) + ", expected " + JSON.stringify(expected));
-}
-`

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

@@ -2,47 +2,24 @@ package main
 
 import (
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestBigintLiteralPrecisionTransform verifies a bigint literal reaches the
-// emit exactly, at any magnitude.
+// TestBigintLiteralPrecisionTransform verifies exact bigint literal construction beyond safe-number precision.
 //
-// `ExpressionFactory.Bigint` spelled its argument as a bare number literal, so
-// `9007199254740993n` was emitted as `BigInt(9007199254740993)` and JavaScript
-// rounded that literal to 9007199254740992 before `BigInt` ever parsed it. The
-// validator it built therefore accepted the wrong value: `is<9007199254740993n>`
-// returned true for 9007199254740992n and false for the literal it was asked
-// about. The repository already spells this hazard out for the two places that
-// avoided it -- `numericRangeFactory_bigint_literal` and `_isTypeInt64Bigint` --
-// and this factory is the one that did not.
+// JavaScript Number cannot exactly represent this integer while BigInt of its decimal string can; the authored literal is chosen one above the safe-integer boundary.
 //
-// The factory feeds every bigint the transform emits, so the case sweeps the
-// operations that reach it rather than `is` alone.
+// 1. Five literal validators cover the first unsafe integer, both signed 64-bit limits, an unsafe literal union and a small safe integer. Each unsafe value must retain its exact decimal text; reflection and schema conversion are not exercised here.
+// 2. The output must not pass the unsafe decimal 9007199254740993 as a Number argument to BigInt.
 //
-//  1. Build validators over bigint literals past 2**53 and at the int64 bounds.
-//  2. Require the emitted code to pass the digits as a string, never as a
-//     number literal that rounds before `BigInt` sees it.
-//  3. Execute them and assert each accepts its own literal and rejects the
-//     adjacent value a rounded literal would have collapsed onto.
+// @evidence contracts/testing.md#behavioral-verification The output must not pass the unsafe decimal 9007199254740993 as a Number argument to BigInt.
+// @evidence contracts/testing.md#independent-expectations JavaScript Number cannot exactly represent this integer while BigInt of its decimal string can; the authored literal is chosen one above the safe-integer boundary.
+// @evidence contracts/testing.md#distinguishing-cases Five literal validators cover the first unsafe integer, both signed 64-bit limits, an unsafe literal union and a small safe integer. Each unsafe value must retain its exact decimal text; reflection and schema conversion are not exercised here.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestBigintLiteralPrecisionTransform 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 TestBigintLiteralPrecisionTransform(t *testing.T) {
-  node, err := exec.LookPath("node")
-  if err != nil {
-    t.Skip("node executable not found")
-  }
-  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, "bigint-precision-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "bigint-precision-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -69,29 +46,15 @@ func TestBigintLiteralPrecisionTransform(t *testing.T) {
   // A number-literal argument is the defect itself, so reject the spelling as
   // well as the behavior: an emit that reads `BigInt(9007199254740993)` has
   // already lost the value even where a later comparison happens to agree.
-  if strings.Contains(out, "BigInt(9007199254740993)") {
-    t.Fatalf("bigint literal must be passed as a string, not a number literal:\n%s", out)
+  for _, decimal := range []string{"9007199254740993", "9223372036854775807", "-9223372036854775808", "9007199254740995", "2"} {
+    if !strings.Contains(out, `BigInt("`+decimal+`")`) {
+      t.Fatalf("bigint literal %s lost its exact string construction:\n%s", decimal, out)
+    }
+    if strings.Contains(out, "BigInt("+decimal+")") {
+      t.Fatalf("bigint literal %s must not be passed as a number literal:\n%s", decimal, out)
+    }
   }
 
-  runtimeDir := filepath.Join(dir, "runtime")
-  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
-    t.Fatalf("mkdir runtime dir: %v", err)
-  }
-  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
-  runtimeJS := ttscTypiaTestRewriteCommonJS(t, out)
-  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(bigintLiteralPrecisionRunner), 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 precision runtime cases failed: %v\n%s", err, output)
-  }
 }
 
 const bigintLiteralPrecisionSource = `import typia from "typia";
@@ -104,32 +67,3 @@ export const isInt64Min = typia.createIs<-9223372036854775808n>();
 export const isUnion = typia.createIs<9007199254740993n | 9007199254740995n>();
 export const isSafe = typia.createIs<2n>();
 `
-
-const bigintLiteralPrecisionRunner = `const mod = require("./main.cjs");
-
-const check = (label, actual, expected) => {
-  if (actual !== expected) {
-    throw new Error(label + ": expected " + expected + ", got " + actual);
-  }
-};
-
-// Each literal is accepted, and the neighbor a rounded emit would have
-// collapsed it onto is rejected.
-check("isUnsafe(exact)", mod.isUnsafe(9007199254740993n), true);
-check("isUnsafe(rounded)", mod.isUnsafe(9007199254740992n), false);
-check("isInt64Max(exact)", mod.isInt64Max(9223372036854775807n), true);
-check("isInt64Max(rounded)", mod.isInt64Max(9223372036854775808n), false);
-check("isInt64Min(exact)", mod.isInt64Min(-9223372036854775808n), true);
-check("isInt64Min(neighbor)", mod.isInt64Min(-9223372036854775807n), false);
-check("isUnion(first)", mod.isUnion(9007199254740993n), true);
-check("isUnion(second)", mod.isUnion(9007199254740995n), true);
-check("isUnion(between)", mod.isUnion(9007199254740994n), false);
-check("isUnion(rounded)", mod.isUnion(9007199254740992n), false);
-
-// A magnitude a double does hold must keep working unchanged.
-check("isSafe(exact)", mod.isSafe(2n), true);
-check("isSafe(other)", mod.isSafe(3n), false);
-check("isSafe(number)", mod.isSafe(2), false);
-
-console.log("ok");
-`

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

@@ -0,0 +1,41 @@
+package main
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestBuildDiagnosticsPreserveDetails checks the authored operation results described below.
+//
+// The same transform error must preserve its authored source coordinates and operation through build formatting rather than losing typed diagnostic detail.
+//
+// 1. Specific call failure contrasts with the forbidden empty-code fallback; project-envelope and global diagnostic representations are tested separately.
+// 2. Build status three formats main.ts line three character nine with typia.is and the missing-generic cause, never the swallowed generic fallback.
+//
+// @evidence contracts/testing.md#behavioral-verification Build status three formats main.ts line three character nine with typia.is and the missing-generic cause, never the swallowed generic fallback.
+// @evidence contracts/testing.md#independent-expectations The same transform error must preserve its authored source coordinates and operation through build formatting rather than losing typed diagnostic detail.
+// @evidence contracts/testing.md#distinguishing-cases Specific call failure contrasts with the forbidden empty-code fallback; project-envelope and global diagnostic representations are tested separately.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestBuildDiagnosticsPreserveDetails as a unit test. Its helpers call the owning Go operations in process; named subcases retain their fixture inputs, assertions and failure identities. Temporary fixtures and captured output are scoped to the test without a compiler or product-host subprocess.
+func TestBuildDiagnosticsPreserveDetails(t *testing.T) {
+  project := transformDiagnosticProject(t)
+  _, errText, code := ttscTypiaTestCapture(func() int {
+    return runBuild([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--emit",
+      "--outDir", filepath.Join(project, "dist"),
+    })
+  })
+  if code != 3 {
+    t.Fatalf("generic build should fail with code 3, got %d\nstderr=%s", code, errText)
+  }
+  normalized := filepath.ToSlash(errText)
+  if !strings.Contains(normalized, "src/main.ts:3:9 - error TS(typia.is):") ||
+    !strings.Contains(normalized, "non-specified generic argument") {
+    t.Fatalf("build diagnostic did not preserve location/code/message:\n%s", errText)
+  }
+  if strings.Contains(normalized, "error TS(): typia transform error") {
+    t.Fatalf("build diagnostic still looks like the swallowed fallback:\n%s", errText)
+  }
+}