typia 15.0.1 → 15.1.0

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

@@ -4,26 +4,40 @@ import (
   "bytes"
   "crypto/sha256"
   "os"
-  "os/exec"
   "path/filepath"
   "testing"
 )
 
-// TestJsonSchemaDynamicKeyDeterminismTransform verifies dynamic-key schemas emit deterministically.
+// TestJsonSchemaDynamicKeyDeterminismTransform checks the authored operation results described below.
 //
-// Multiple template and numeric index signatures used to reach a Go map before
-// their value metadata was merged. Repeating one unchanged transform therefore
-// has to compare the complete output bytes, while runtime checks ensure a stable
-// order is not achieved by losing, duplicating, or broadening schema branches.
+// Deterministic source/schema generation must not depend on Go map enumeration order. Repetition is an ordering oracle only; semantic branch-preservation checks are separate assertions on the authored fixture.
 //
-//  1. Transform unchanged tag-free dynamic-key fixtures repeatedly to TypeScript and JavaScript.
-//  2. Require every complete emit to match the first emit byte for byte.
-//  3. Execute the JavaScript and assert branch completeness plus unrelated ordering controls.
+// 1. Composite, template, key-union, fixed-property, singleton-dynamic and ordinary-union shapes coexist, and TypeScript/JavaScript outputs are checked independently.
+// 2. Both output modes produce identical complete bytes across thirty-two transforms of one unchanged dynamic-key project.
+//
+// @evidence contracts/testing.md#behavioral-verification Both output modes retain the authored fixed-property types, required keys, dynamic value-type unions, single dynamic value and ordinary primitive union, then produce identical complete bytes across thirty-two transforms of one unchanged project.
+// @evidence contracts/testing.md#independent-expectations Deterministic source/schema generation must not depend on Go map enumeration order. Repetition is an ordering oracle only; semantic branch-preservation checks are separate assertions on the authored fixture.
+// @evidence contracts/testing.md#distinguishing-cases Composite, template, key-union, fixed-property, singleton-dynamic and ordinary-union shapes coexist, and TypeScript/JavaScript outputs are checked independently.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestJsonSchemaDynamicKeyDeterminismTransform 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 TestJsonSchemaDynamicKeyDeterminismTransform(t *testing.T) {
   project := jsonSchemaDynamicKeyDeterminismProject(t)
-  var javascript string
   for _, output := range []string{"ts", "js"} {
     baseline := jsonSchemaDynamicKeyDeterminismTransform(t, project, output)
+    unit := ttscTypiaTestSchemaLiteral(t, baseline)
+    for name, expected := range map[string][]any{
+      "DynamicComposite": {map[string]any{"type": "number"}, map[string]any{"type": "string"}, map[string]any{"type": "boolean"}},
+      "DynamicTemplate":  {map[string]any{"type": "string"}, map[string]any{"type": "number"}, map[string]any{"type": "boolean"}},
+      "DynamicUnion":     {map[string]any{"type": "string"}, map[string]any{"type": "number"}},
+    } {
+      ttscTypiaTestSchemaEqual(t, ttscTypiaTestSchemaPath(t, unit, "components", "schemas", name, "additionalProperties", "oneOf"), expected)
+    }
+    ttscTypiaTestSchemaEqual(t, ttscTypiaTestSchemaPath(t, unit, "components", "schemas", "DynamicComposite", "properties"), map[string]any{"id": map[string]any{"type": "string"}, "name": map[string]any{"type": "string"}})
+    ttscTypiaTestSchemaEqual(t, ttscTypiaTestSchemaPath(t, unit, "components", "schemas", "DynamicComposite", "required"), []any{"id", "name"})
+    ttscTypiaTestSchemaEqual(t, ttscTypiaTestSchemaPath(t, unit, "components", "schemas", "LiteralOnly", "properties"), map[string]any{"z": map[string]any{"type": "string"}, "a": map[string]any{"type": "number"}})
+    ttscTypiaTestSchemaEqual(t, ttscTypiaTestSchemaPath(t, unit, "components", "schemas", "LiteralOnly", "required"), []any{"z", "a"})
+    ttscTypiaTestSchemaEqual(t, ttscTypiaTestSchemaPath(t, unit, "components", "schemas", "LiteralOnly", "additionalProperties"), false)
+    ttscTypiaTestSchemaEqual(t, ttscTypiaTestSchemaPath(t, unit, "components", "schemas", "SingleDynamic", "additionalProperties"), map[string]any{"type": "string"})
+    ttscTypiaTestSchemaEqual(t, ttscTypiaTestSchemaPath(t, unit, "components", "schemas", "OrdinaryUnion", "oneOf"), []any{map[string]any{"type": "string"}, map[string]any{"type": "number"}})
     for iteration := 1; iteration < 32; iteration++ {
       current := jsonSchemaDynamicKeyDeterminismTransform(t, project, output)
       if bytes.Equal([]byte(current), []byte(baseline)) == false {
@@ -38,27 +52,12 @@ func TestJsonSchemaDynamicKeyDeterminismTransform(t *testing.T) {
       }
     }
     t.Logf("%s emit remained byte-identical across 32 transforms: sha256=%x", output, sha256.Sum256([]byte(baseline)))
-    if output == "js" {
-      javascript = baseline
-    }
   }
-  jsonSchemaDynamicKeyDeterminismRunRuntimeCases(t, project, javascript)
 }
 
 func jsonSchemaDynamicKeyDeterminismProject(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, "json-schema-dynamic-key-determinism-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() {
-    _ = os.RemoveAll(dir)
-  })
+  dir := ttscTypiaTestFixtureDirectory(t, "json-schema-dynamic-key-determinism-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -101,33 +100,6 @@ func jsonSchemaDynamicKeyDeterminismFirstDifference(x string, y string) int {
   return limit
 }
 
-func jsonSchemaDynamicKeyDeterminismRunRuntimeCases(t *testing.T, project string, javascript 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, javascript)
-  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(jsonSchemaDynamicKeyDeterminismRuntimeRunner), 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("dynamic-key schema runtime cases failed: %v\n%s", err, output)
-  }
-}
-
 const jsonSchemaDynamicKeyDeterminismTSConfig = `{
   "compilerOptions": {
     "target": "ES2022",
@@ -187,60 +159,3 @@ export const schemas = typia.json.schemas<[
   OrdinaryUnion,
 ]>();
 `
-
-const jsonSchemaDynamicKeyDeterminismRuntimeRunner = `const unit = require("./main.cjs").schemas;
-
-const components = unit.components?.schemas ?? {};
-const assertTypes = (name, expected) => {
-  const additional = components[name]?.additionalProperties;
-  const actual = Array.isArray(additional?.oneOf)
-    ? additional.oneOf.map((schema) => schema.type)
-    : [additional?.type];
-  if (JSON.stringify(actual) !== JSON.stringify(expected)) {
-    throw new Error(name + " branches were " + JSON.stringify(actual) + ", expected " + JSON.stringify(expected));
-  }
-};
-
-assertTypes("DynamicComposite", ["number", "string", "boolean"]);
-assertTypes("DynamicTemplate", ["string", "number", "boolean"]);
-assertTypes("DynamicUnion", ["string", "number"]);
-
-const literal = components.LiteralOnly;
-const literalShape = {
-  type: literal?.type,
-  propertyKeys: Object.keys(literal?.properties ?? {}),
-  propertyTypes: Object.values(literal?.properties ?? {}).map((schema) => schema.type),
-  required: literal?.required,
-  additionalProperties: literal?.additionalProperties,
-};
-const expectedLiteralShape = {
-  type: "object",
-  propertyKeys: ["z", "a"],
-  propertyTypes: ["string", "number"],
-  required: ["z", "a"],
-  additionalProperties: false,
-};
-if (JSON.stringify(literalShape) !== JSON.stringify(expectedLiteralShape)) {
-  throw new Error("zero-dynamic literal schema changed: " + JSON.stringify(literalShape));
-}
-if (components.SingleDynamic?.additionalProperties?.type !== "string") {
-  throw new Error("single dynamic-key schema changed: " + JSON.stringify(components.SingleDynamic));
-}
-const ordinaryTypes = components.OrdinaryUnion?.oneOf?.map((schema) => schema.type) ?? [];
-if (JSON.stringify(ordinaryTypes) !== JSON.stringify(["string", "number"])) {
-  throw new Error("ordinary union branches changed: " + JSON.stringify(ordinaryTypes));
-}
-
-const refs = unit.schemas.map((schema) => schema.$ref);
-const expectedRefs = [
-  "#/components/schemas/DynamicComposite",
-  "#/components/schemas/DynamicTemplate",
-  "#/components/schemas/DynamicUnion",
-  "#/components/schemas/LiteralOnly",
-  "#/components/schemas/SingleDynamic",
-  "#/components/schemas/OrdinaryUnion",
-];
-if (JSON.stringify(refs) !== JSON.stringify(expectedRefs)) {
-  throw new Error("schema order changed: " + JSON.stringify(refs));
-}
-`

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

@@ -7,16 +7,17 @@ import (
   "testing"
 )
 
-// TestJSONSchemaNonsensibleIntersectionDiagnostic verifies that ttsc reports
-// the transform-time cause behind issue #2373.
+// TestJSONSchemaNonsensibleIntersectionDiagnostic checks the authored operation results described below.
 //
-// The runtime fallback cannot inspect a TypeScript type after transformation
-// has been skipped. This regression therefore compiles the reporter's exact
-// `Date & string` property through the real typia package and preserves the
-// actionable native diagnostic at its actual compiler boundary.
+// An unsupported intersection cannot silently emit a schema with weaker inhabitation meaning; the transform rejection must identify the failing call.
 //
-//  1. Compile a `typia.json.schema` call for the nonsensible intersection.
-//  2. Require the API diagnostic, property path, and intersection reason.
+// 1. One nonrepresentable schema intersection owns this rejection; valid phantom-branded cases are covered by the intersection backstop test.
+// 2. The unsupported JSON schema intersection returns status three and the authored operation/location/cause fragments.
+//
+// @evidence contracts/testing.md#behavioral-verification The unsupported JSON schema intersection returns status three and the authored operation/location/cause fragments.
+// @evidence contracts/testing.md#independent-expectations An unsupported intersection cannot silently emit a schema with weaker inhabitation meaning; the transform rejection must identify the failing call.
+// @evidence contracts/testing.md#distinguishing-cases One nonrepresentable schema intersection owns this rejection; valid phantom-branded cases are covered by the intersection backstop test.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestJSONSchemaNonsensibleIntersectionDiagnostic 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 TestJSONSchemaNonsensibleIntersectionDiagnostic(t *testing.T) {
   project := jsonSchemaNonsensibleIntersectionDiagnosticProject(t)
   stdout, stderr, code := ttscTypiaTestCapture(func() int {
@@ -43,20 +44,7 @@ func TestJSONSchemaNonsensibleIntersectionDiagnostic(t *testing.T) {
 
 func jsonSchemaNonsensibleIntersectionDiagnosticProject(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("create fixture base: %v", err)
-  }
-  project, err := os.MkdirTemp(base, "json-schema-nonsensible-intersection-")
-  if err != nil {
-    t.Fatalf("create fixture project: %v", err)
-  }
-  t.Cleanup(func() {
-    if err := os.RemoveAll(project); err != nil {
-      t.Errorf("remove fixture project: %v", err)
-    }
-  })
+  project := ttscTypiaTestFixtureDirectory(t, "json-schema-nonsensible-intersection-")
   src := filepath.Join(project, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("create fixture src: %v", err)

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

@@ -2,24 +2,22 @@ package main
 
 import (
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestJsonStringifyConstantAtomicUnionTransform verifies stringify union routing.
+// TestJsonStringifyConstantAtomicUnionTransform verifies string and numeric serializer helpers for record properties.
 //
-// `json.createStringify` routes constant and atomic buckets through the runtime
-// atomic predicates before emitting per-bucket serializers. Without coverage
-// here, a regression in that routing would silently drop a constant or atomic
-// union member from the emitted serializer.
+// JSON strings require quoting/escaping while numeric values emit numeric text; the record contains string-literal, number-literal and broad string/number properties.
 //
-//  1. Transform a stringify fixture whose object mixes string constants,
-//     numeric constants, and a plain numeric atomic.
-//  2. Require the emitted serializer to reference the stringify helpers.
-//  3. Execute the serializer and require JSON-equal output for every union
-//     member, including the non-finite number fallback.
+// 1. Literal unions and broad string/number properties coexist in one record, detecting loss of either serializer kind. Runtime serialized values are outside this emission case.
+// 2. Generated output contains both JSON string and JSON number serializer helpers.
+//
+// @evidence contracts/testing.md#behavioral-verification Generated output contains both JSON string and JSON number serializer helpers.
+// @evidence contracts/testing.md#independent-expectations The authored kind/name string properties require quoting while flag/count numeric properties require numeric serialization; helper presence follows these distinct JSON scalar contracts.
+// @evidence contracts/testing.md#distinguishing-cases The record combines string and numeric literal unions with broad number/string properties. Combined emission must include both helper kinds; individual serialized values are not executed here.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestJsonStringifyConstantAtomicUnionTransform 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 TestJsonStringifyConstantAtomicUnionTransform(t *testing.T) {
   project := jsonStringifyConstantAtomicUnionProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -36,23 +34,11 @@ func TestJsonStringifyConstantAtomicUnionTransform(t *testing.T) {
   if !strings.Contains(out, "_jsonStringifyString") || !strings.Contains(out, "_jsonStringifyNumber") {
     t.Fatalf("stringify union serializer was not emitted:\n%s", out)
   }
-  jsonStringifyConstantAtomicUnionRunRuntimeCases(t, project, out)
 }
 
 func jsonStringifyConstantAtomicUnionProject(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, "json-stringify-union-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() {
-    _ = os.RemoveAll(dir)
-  })
+  dir := ttscTypiaTestFixtureDirectory(t, "json-stringify-union-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -66,46 +52,6 @@ func jsonStringifyConstantAtomicUnionProject(t *testing.T) string {
   return dir
 }
 
-func jsonStringifyConstantAtomicUnionRunRuntimeCases(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)
-  stubs := map[string]string{
-    "json-stringify-string-stub.cjs":  jsonStringifyConstantAtomicUnionStringStub,
-    "json-stringify-number-stub.cjs":  jsonStringifyConstantAtomicUnionNumberStub,
-    "throw-type-guard-error-stub.cjs": jsonStringifyConstantAtomicUnionThrowStub,
-  }
-  for name, content := range stubs {
-    if err := os.WriteFile(filepath.Join(runtimeDir, name), []byte(content), 0o644); err != nil {
-      t.Fatalf("write %s: %v", name, err)
-    }
-  }
-  runtimeJS := strings.ReplaceAll(js, `require("typia/lib/internal/_jsonStringifyString")`, `require("./json-stringify-string-stub.cjs")`)
-  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_jsonStringifyNumber")`, `require("./json-stringify-number-stub.cjs")`)
-  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_throwTypeGuardError")`, `require("./throw-type-guard-error-stub.cjs")`)
-  runtimeJS = ttscTypiaTestRewriteCommonJS(t, runtimeJS)
-  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(jsonStringifyConstantAtomicUnionRuntimeRunner), 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("stringify union runtime cases failed: %v\n%s", err, output)
-  }
-}
-
 const jsonStringifyConstantAtomicUnionTSConfig = `{
   "compilerOptions": {
     "target": "ES2022",
@@ -132,40 +78,3 @@ interface SerializedRecord {
 
 export const stringifyRecord = typia.json.createStringify<SerializedRecord>();
 `
-
-const jsonStringifyConstantAtomicUnionStringStub = `module.exports._jsonStringifyString = (str) => JSON.stringify(str);
-`
-
-const jsonStringifyConstantAtomicUnionNumberStub = `module.exports._jsonStringifyNumber = (value) => (isFinite(value) ? value : null);
-`
-
-const jsonStringifyConstantAtomicUnionThrowStub = `module.exports._throwTypeGuardError = (props) => {
-  const error = new Error(props.expected);
-  Object.assign(error, props);
-  throw error;
-};
-`
-
-const jsonStringifyConstantAtomicUnionRuntimeRunner = `const mod = require("./main.cjs");
-
-const expectEqual = (name, input) => {
-  const text = mod.stringifyRecord(input);
-  const parsed = JSON.parse(text);
-  for (const key of Object.keys(input)) {
-    if (parsed[key] !== input[key]) {
-      throw new Error(name + " mismatched property " + key + ": " + text);
-    }
-  }
-  if (Object.keys(parsed).length !== Object.keys(input).length) {
-    throw new Error(name + " emitted unexpected property count: " + text);
-  }
-};
-
-expectEqual("kind=a flag=1", { kind: "a", flag: 1, count: 0.5, name: "first" });
-expectEqual("kind=b flag=2", { kind: "b", flag: 2, count: -3, name: "second" });
-
-const infinite = JSON.parse(mod.stringifyRecord({ kind: "a", flag: 1, count: Infinity, name: "edge" }));
-if (infinite.count !== null) {
-  throw new Error("non-finite count should serialize as null: " + JSON.stringify(infinite));
-}
-`

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

@@ -3,34 +3,22 @@ package main
 import (
   "fmt"
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestLibReplacementNativeIdentityTransform keeps a `libReplacement` project's
-// natives native even though their declaration file lives in node_modules
-// (#2200).
+// TestLibReplacementNativeIdentityTransform verifies native ownership in an installed default-library replacement.
 //
-// Runtime-native identity requires a runtime authority to declare the global, so
-// which files count as a TypeScript default library became load-bearing. Under
-// `libReplacement` the compiler resolves `lib.es2015.collection.d.ts` to
-// `@typescript/lib-es2015/collection`, an ordinary package file whose name does
-// not even begin with `lib.` — so a file-name rule answers "not a default
-// library" and would demote Map, Set, WeakMap, and WeakSet to structural checks
-// that accept any object. Only the program's own classification is right here,
-// and this fixture is what proves the transform consults it.
+// Compiler-recognized replacement libraries carry the supported standard native declaration ownership; the authored probe proves the replacement file is actually loaded.
 //
-//  1. Publish `@typescript/lib-es2015/collection.d.ts` carrying the real
-//     Map/Set/WeakMap/WeakSet declarations plus a probe interface that exists
-//     nowhere else, and enable `libReplacement`.
-//  2. Transform validators for the four replaced collection natives, for Date
-//     and Uint8Array as bundled-library controls, and for the probe.
-//  3. Require the probe to transform at all, which fails unless the replacement
-//     file — not the bundled lib — is what the program loaded.
-//  4. Require every native to keep its `instanceof` check and execute all of
-//     them in Node against real instances and plain objects.
+// 1. An installed collection replacement is paired with bundled native controls and a replacement-only probe, avoiding a filename-only identity assumption.
+// 2. Emission retains the replacement probe member while Date, Uint8Array and Map retain their genuine native paths.
+//
+// @evidence contracts/testing.md#behavioral-verification Emission retains the replacement probe member while Date, Uint8Array and Map retain their genuine native paths.
+// @evidence contracts/testing.md#independent-expectations Compiler-recognized replacement libraries carry the supported standard native declaration ownership; the authored probe proves the replacement file is actually loaded.
+// @evidence contracts/testing.md#distinguishing-cases An installed collection replacement is paired with bundled native controls and a replacement-only probe, avoiding a filename-only identity assumption.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestLibReplacementNativeIdentityTransform 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 TestLibReplacementNativeIdentityTransform(t *testing.T) {
   project := libReplacementNativeIdentityProject(t)
   js, errText, code := ttscTypiaTestCapture(func() int {
@@ -62,13 +50,6 @@ func TestLibReplacementNativeIdentityTransform(t *testing.T) {
     }
   }
 
-  output, runtimeErr := libReplacementNativeIdentityRun(t, project, js)
-  if runtimeErr != nil {
-    failures = append(failures, fmt.Sprintf("runtime matrix failed: %v\n%s", runtimeErr, output))
-  }
-  if expected := "RAN 13 REPLACEMENT CASES"; !strings.Contains(output, expected) {
-    failures = append(failures, fmt.Sprintf("replacement runner did not report %q; got:\n%s", expected, output))
-  }
   if len(failures) != 0 {
     t.Fatalf("lib replacement native identity mismatches:\n%s\n\nemit:\n%s", strings.Join(failures, "\n"), js)
   }
@@ -76,21 +57,10 @@ func TestLibReplacementNativeIdentityTransform(t *testing.T) {
 
 func libReplacementNativeIdentityProject(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, "lib-replacement-native-identity-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() {
-    _ = os.RemoveAll(dir)
-  })
+  dir := ttscTypiaTestFixtureDirectory(t, "lib-replacement-native-identity-")
   for name, content := range map[string]string{
     "tsconfig.json": libReplacementNativeIdentityTSConfig,
-    "node_modules/@typescript/lib-es2015/package.json":   libReplacementNativeIdentityPackageJSON,
+    "node_modules/@typescript/lib-es2015/package.json":    libReplacementNativeIdentityPackageJSON,
     "node_modules/@typescript/lib-es2015/collection.d.ts": libReplacementNativeIdentityCollectionLib,
     "src/input.ts": libReplacementNativeIdentitySource,
   } {
@@ -105,32 +75,6 @@ func libReplacementNativeIdentityProject(t *testing.T) string {
   return dir
 }
 
-func libReplacementNativeIdentityRun(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":   libReplacementNativeIdentityRuntimeRunner,
-  } {
-    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 libReplacementNativeIdentityTSConfig = `{
   "compilerOptions": {
     "target": "ES2022",
@@ -244,34 +188,3 @@ export const createdIsWeakSet = typia.createIs<WeakSet<object>>();
 export const createdIsDate = typia.createIs<Date>();
 export const createdIsBytes = typia.createIs<Uint8Array>();
 `
-
-const libReplacementNativeIdentityRuntimeRunner = `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);
-  }
-};
-
-eq("probe structural", validators.createdIsProbe({ libReplacementMarker: "x" }), true);
-eq("Map real", validators.createdIsMap(new Map([["x", 1]])), true);
-eq("Map plain", validators.createdIsMap({}), false);
-eq("Set real", validators.createdIsSet(new Set(["x"])), true);
-eq("Set plain", validators.createdIsSet({}), false);
-eq("WeakMap real", validators.createdIsWeakMap(new WeakMap()), true);
-eq("WeakMap plain", validators.createdIsWeakMap({}), false);
-eq("WeakSet real", validators.createdIsWeakSet(new WeakSet()), true);
-eq("WeakSet plain", validators.createdIsWeakSet({}), false);
-eq("Date real", validators.createdIsDate(new Date()), true);
-eq("Date plain", validators.createdIsDate({}), false);
-eq("Uint8Array real", validators.createdIsBytes(new Uint8Array(1)), true);
-eq("Uint8Array plain", validators.createdIsBytes({}), false);
-
-console.log("RAN " + ran + " REPLACEMENT CASES");
-if (failures.length !== 0) {
-  throw new Error("MISMATCHES:\n" + failures.join("\n"));
-}
-`

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

@@ -11,6 +11,11 @@ import "testing"
 //  1. Declare an aliased boolean and a probability-annotated enum.
 //  2. Put probability one on the final boolean decision property.
 //  3. Require successful compilation.
+//
+// @evidence contracts/testing.md#behavioral-verification The evaluation build succeeds when a final boolean property and enum members carry supported probability annotations.
+// @evidence contracts/testing.md#independent-expectations Only final decision properties and enum member declarations retain the annotations read by evaluation; probability one is the supported inclusive upper bound.
+// @evidence contracts/testing.md#distinguishing-cases An aliased boolean uses a property-level requirement of one, beside enum members requiring one and 0.2; invalid declaration placements are owned by the rejection cases.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestLlmEvaluationAcceptsPropertyAndEnumMemberProbability as a unit test. Its fixture helpers and captured Go command calls exercise the owning operation in process without a compiler subprocess. Named subcases retain their inputs and failure identities; temporary project cleanup belongs to the helper.
 func TestLlmEvaluationAcceptsPropertyAndEnumMemberProbability(t *testing.T) {
   llmEvaluationAccepts(t, "property-probability-valid", `import typia from "typia";
 

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

@@ -11,6 +11,11 @@ import "testing"
 //  1. Declare an annotated and an unannotated source property.
 //  2. Extract the unannotated property's type for an evaluation decision.
 //  3. Require successful compilation.
+//
+// @evidence contracts/testing.md#behavioral-verification The evaluation build accepts an indexed-access decision selecting the unannotated Source property.
+// @evidence contracts/testing.md#independent-expectations Indexed access extracts the selected value type, not a different property declaration or its JSDoc requirement.
+// @evidence contracts/testing.md#distinguishing-cases The source has both an annotated ignored boolean and an unannotated selected boolean, so leaking unrelated property comments would reject the control.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestLlmEvaluationAcceptsUnselectedSourceProbability as a unit test. Its fixture helpers and captured Go command calls exercise the owning operation in process without a compiler subprocess. Named subcases retain their inputs and failure identities; temporary project cleanup belongs to the helper.
 func TestLlmEvaluationAcceptsUnselectedSourceProbability(t *testing.T) {
   llmEvaluationAccepts(t, "unselected-source-probability", `import typia from "typia";
 interface Source {

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

@@ -7,6 +7,11 @@ import (
 
 // Evaluation promises to decode the entire T. Every required member must
 // become a question or fail compilation, including inherited/nested members.
+//
+// @evidence contracts/testing.md#behavioral-verification Accepted getter/setter shapes emit urgent and threshold one; unsupported required-member shapes must produce their authored diagnostics.
+// @evidence contracts/testing.md#independent-expectations Evaluation promises to reconstruct the entire declared decision object, including inherited/accessor members, so each supported leaf must become a question and unsupported members cannot vanish silently.
+// @evidence contracts/testing.md#distinguishing-cases Getter-only, class, inherited, interface and nested accessors contrast with required members the evaluator cannot decode; named subtests retain each shape identity.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestLlmEvaluationCompleteObjectShape as a unit test. Its fixture helpers and captured Go command calls exercise the owning operation in process without a compiler subprocess. Named subcases retain their inputs and failure identities; temporary project cleanup belongs to the helper.
 func TestLlmEvaluationCompleteObjectShape(t *testing.T) {
   accepted := map[string]string{
     "getter only": `class Decision {

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

@@ -0,0 +1,53 @@
+package main
+
+import (
+  "regexp"
+  "testing"
+)
+
+// TestLlmEvaluationEmitsConfiguredDecimals verifies the configured decimals,
+// two by default, reach the runtime helper as its second argument.
+//
+// `decode()` derives its rounding tolerance from that number, so a config that
+// never reached the helper would leave the decoder on the wrong precision.
+//
+//  1. Transform a decision type with `decimals: 3`.
+//  2. Transform the same type without a config.
+//  3. Assert the helper call ends with 3 in the first output and 2 in the second.
+//
+// @evidence contracts/testing.md#behavioral-verification The generated helper call receives three for configured decimals and two when omitted.
+// @evidence contracts/testing.md#independent-expectations The public evaluation config sets the decoder rounding grid; a fixed literal helper argument pins transport of that setting independently of the emitted plan body.
+// @evidence contracts/testing.md#distinguishing-cases The same boolean decision is transformed with explicit three and with no config, separating configured and default precision.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestLlmEvaluationEmitsConfiguredDecimals as a unit test. Its fixture helpers and captured Go command calls exercise the owning operation in process without a compiler subprocess. Named subcases retain their inputs and failure identities; temporary project cleanup belongs to the helper.
+func TestLlmEvaluationEmitsConfiguredDecimals(t *testing.T) {
+  transform := func(name string, config string) string {
+    project := llmEvaluationProject(t, name, `import typia from "typia";
+
+export const evaluation = typia.llm.evaluation<{
+  /** Urgent? */
+  urgent: boolean;
+}`+config+`>();
+`)
+    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("llm.evaluation transform failed: code=%d stderr=\n%s", code, errText)
+    }
+    return out
+  }
+  for _, tc := range []struct{ name, config, decimals string }{
+    {"configured-decimals", `, { decimals: 3 }`, "3"},
+    {"default-decimals", ``, "2"},
+  } {
+    out := transform(tc.name, tc.config)
+    if !regexp.MustCompile(`\]\s*,\s*` + tc.decimals + `\s*\)`).MatchString(out) {
+      t.Fatalf("emission must pass %s decimals to the helper:\n%s", tc.decimals, out)
+    }
+  }
+}

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

@@ -11,6 +11,11 @@ import "testing"
 //  1. Declare a tagged primitive alias.
 //  2. Omit every evaluation call.
 //  3. Require successful compilation.
+//
+// @evidence contracts/testing.md#behavioral-verification An ordinary program declaring a probability-annotated alias compiles when no evaluation operation exists.
+// @evidence contracts/testing.md#independent-expectations Evaluation-specific placement requirements belong to calls that request an evaluation plan, not to arbitrary TypeScript JSDoc annotations.
+// @evidence contracts/testing.md#distinguishing-cases The no-call program is the negative twin of the neighboring declaration-placement rejection case.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestLlmEvaluationIgnoresDeclarationProbabilityWithoutCall as a unit test. Its fixture helpers and captured Go command calls exercise the owning operation in process without a compiler subprocess. Named subcases retain their inputs and failure identities; temporary project cleanup belongs to the helper.
 func TestLlmEvaluationIgnoresDeclarationProbabilityWithoutCall(t *testing.T) {
   llmEvaluationAccepts(t, "no-evaluation-call", `/** @probability 0.8 */
 export type Urgency = boolean;