typia 15.0.0 → 15.1.0

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

@@ -5,22 +5,15 @@ import (
   "os"
   "path/filepath"
   "runtime"
-  "sort"
-  "strings"
   "testing"
 )
 
 // ttscTypiaTestTypecheck requires a fixture project to be free of TypeScript
 // errors, which is what makes an `@ts-expect-error` in a fixture load-bearing.
 //
-// It runs the build command in no-emit mode with the rewrite disabled, so the
-// only diagnostics it can report are the program's own. It used to shell out to
-// `pnpm exec ttsc --noEmit -p tsconfig.json`, which reported nothing and exited
-// 0 for a fixture under `.tmp-ttsc-typia-tests` — `const value: number = "bad"`
-// passed — so every caller was asserting against an oracle that could not fail.
-// `runBuild` is the same program these tests already drive, and
-// build_reports_semantic_diagnostics_test.go pins that it surfaces semantic
-// diagnostics as status 2.
+// It runs the build command in no-emit mode with the rewrite disabled, so fixture
+// validity is checked independently of the typia transformation. This is a
+// prerequisite for the caller's typia assertions, not a separate compiler test.
 func ttscTypiaTestTypecheck(t *testing.T, project string) {
   t.Helper()
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -122,359 +115,47 @@ func ttscTypiaTestCapture(run func() int) (string, string, int) {
   return out.String(), err.String(), code
 }
 
-func ttscTypiaTestWriteCommonRuntimeStubs(t *testing.T, runtimeDir string) {
-  t.Helper()
-  files := map[string]string{
-    "typia-stub.cjs":                   "module.exports = {};\n",
-    "validate-report-stub.cjs":         ttscTypiaTestValidateReportStub,
-    "standard-schema-stub.cjs":         ttscTypiaTestStandardSchemaStub,
-    "assert-guard-stub.cjs":            ttscTypiaTestAssertGuardStub,
-    "functional-error-stub.cjs":        ttscTypiaTestFunctionalErrorStub,
-    "access-expression-stub.cjs":       ttscTypiaTestAccessExpressionStub,
-    "string-length-stub.cjs":           ttscTypiaTestStringLengthStub,
-    "notation-stub.cjs":                ttscTypiaTestNotationStub,
-    "json-stringify-array-stub.cjs":    ttscTypiaTestJsonStringifyArrayStub,
-    "json-stringify-property-stub.cjs": ttscTypiaTestJsonStringifyPropertyStub,
-    "json-stringify-element-stub.cjs":  ttscTypiaTestJsonStringifyElementStub,
-    "json-stringify-tail-stub.cjs":     ttscTypiaTestJsonStringifyTailStub,
-    "random-string-stub.cjs":           ttscTypiaTestRandomStringStub,
-  }
-  for name, content := range files {
-    if err := os.WriteFile(filepath.Join(runtimeDir, name), []byte(content), 0o644); err != nil {
-      t.Fatalf("write %s: %v", name, err)
-    }
-  }
-}
-
-func ttscTypiaTestRewriteCommonJS(t *testing.T, js string) string {
-  t.Helper()
-  runtimeJS := strings.ReplaceAll(js, `require("typia")`, `require("./typia-stub.cjs")`)
-  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_validateReport")`, `require("./validate-report-stub.cjs")`)
-  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_createStandardSchema")`, `require("./standard-schema-stub.cjs")`)
-  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_assertGuard")`, `require("./assert-guard-stub.cjs")`)
-  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_functionalTypeGuardErrorFactory")`, `require("./functional-error-stub.cjs")`)
-  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_accessExpressionAsString")`, `require("./access-expression-stub.cjs")`)
-  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_stringLength")`, `require("./string-length-stub.cjs")`)
-  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_stringLengthGte")`, `require("./string-length-stub.cjs")`)
-  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_stringLengthLte")`, `require("./string-length-stub.cjs")`)
-  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_jsonStringifyArray")`, `require("./json-stringify-array-stub.cjs")`)
-  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_jsonStringifyProperty")`, `require("./json-stringify-property-stub.cjs")`)
-  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_jsonStringifyElement")`, `require("./json-stringify-element-stub.cjs")`)
-  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_jsonStringifyTail")`, `require("./json-stringify-tail-stub.cjs")`)
-  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_randomString")`, `require("./random-string-stub.cjs")`)
-  for _, helper := range []string{"_notationAssign", "_notationCamel", "_notationKebab", "_notationKeyCollision", "_notationPascal", "_notationSnake"} {
-    runtimeJS = strings.ReplaceAll(
-      runtimeJS,
-      `require("typia/lib/internal/`+helper+`")`,
-      `require("./notation-stub.cjs")`,
-    )
-  }
-  for _, needle := range []string{`require("typia")`, `require('typia')`, `from "typia"`, `from 'typia'`, `typia/lib/internal/`} {
-    if !strings.Contains(runtimeJS, needle) {
-      continue
-    }
-    // Name the modules that are actually unmapped. Reporting only the needle
-    // makes every new internal helper look like the same failure and sends the
-    // reader hunting through the emit for it.
-    if needle == `typia/lib/internal/` {
-      unresolved := map[string]bool{}
-      for _, part := range strings.Split(runtimeJS, needle)[1:] {
-        end := strings.IndexAny(part, "\"')")
-        if end < 0 {
-          end = len(part)
-        }
-        unresolved[part[:end]] = true
-      }
-      names := make([]string, 0, len(unresolved))
-      for name := range unresolved {
-        names = append(names, name)
-      }
-      sort.Strings(names)
-      t.Fatalf("runtime module has no stub for typia internal helpers: %s", strings.Join(names, ", "))
-    }
-    t.Fatalf("runtime module still contains unresolved typia import %q", needle)
-  }
-  return runtimeJS
+const atomicIntersectionSchemaTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
 }
-
-const ttscTypiaTestValidateReportStub = `module.exports._validateReport = (array) => {
-  const isAncestor = (ancestor, descendant) =>
-    descendant === ancestor ||
-    descendant.startsWith(ancestor + ".") ||
-    descendant.startsWith(ancestor + "[");
-  const reportable = (path) => {
-    if (array.length === 0) return true;
-    const last = array[array.length - 1].path;
-    return !isAncestor(path, last) && !isAncestor(last, path);
-  };
-  return (exceptable, error) => {
-    if (exceptable && reportable(error.path)) {
-      if (error.value === undefined && (error.description === undefined || error.description === null)) {
-        error.description = [
-          "The value at this path is " + String.fromCharCode(96) + "undefined" + String.fromCharCode(96) + ".",
-          "",
-          "Please fill the " + String.fromCharCode(96) + error.expected + String.fromCharCode(96) + " typed value next time.",
-        ].join("\n");
-      }
-      array.push(error);
-    }
-    return false;
-  };
-};
-`
-
-const ttscTypiaTestStandardSchemaStub = `module.exports._createStandardSchema = (validate) => validate;
-`
-
-// A double for packages/typia/src/internal/_assertGuard.ts that takes the same
-// branches: `exceptionable === true` and a callable-factory requirement. The
-// generated function's second parameter is caller-supplied, so a pointwise
-// hand-off (`rows.map(assertUser)`) fills it with the element index; testing
-// truthiness here would let this stub report `factory is not a function` for a
-// case the shipped helper handles. The fallback error is deliberately not a
-// TypeGuardError — a stub cannot import typia — so cases assert `props`
-// members rather than the shipped message format.
-const ttscTypiaTestAssertGuardStub = `module.exports._assertGuard = (exceptionable, props, factory) => {
-  if (exceptionable === true) {
-    const error =
-      typeof factory === "function"
-        ? factory(props)
-        : Object.assign(new Error(props.expected), props);
-    throw error;
-  }
-  return false;
-};
-`
-
-const ttscTypiaTestFunctionalErrorStub = `module.exports._functionalTypeGuardErrorFactory = (props) =>
-  Object.assign(new Error(props.expected), props);
-`
-
-// The two JSON stringify stubs mirror packages/typia/src/internal exactly. They
-// are runtime doubles for the emit these tests execute; the shipped helpers
-// themselves are exercised by the TypeScript suites against the real package.
-const ttscTypiaTestJsonStringifyArrayStub = `module.exports._jsonStringifyArray = (elements, mapper) => {
-  const length = Math.min(
-    Math.max(Math.trunc(elements.length) || 0, 0),
-    Number.MAX_SAFE_INTEGER,
-  );
-  let output = "";
-  for (let i = 0; i < length; ++i) {
-    const elem = elements[i];
-    const text = elem === undefined ? undefined : mapper(elem, i);
-    output += (i === 0 ? "" : ",") + (text === undefined ? "null" : text);
-  }
-  return output;
-};
-`
-
-const ttscTypiaTestJsonStringifyPropertyStub = `module.exports._jsonStringifyProperty = (head, text, tail) =>
-  text === undefined ? "" : head + text + tail;
-`
-
-const ttscTypiaTestJsonStringifyElementStub = `module.exports._jsonStringifyElement = (text) =>
-  text === undefined ? "null" : text;
-`
-
-// Deterministic rather than random: these runtimes assert observable behavior
-// of the emitted validators, so a generated string only has to satisfy the
-// declared bounds, and a stable one keeps a failure reproducible.
-const ttscTypiaTestJsonStringifyTailStub = `module.exports._jsonStringifyTail = (str) =>
-  str[str.length - 1] === "," ? str.substring(0, str.length - 1) : str;
-`
-
-const ttscTypiaTestRandomStringStub = `module.exports._randomString = (props) => {
-  const minimum =
-    props.minLength !== undefined
-      ? props.minLength
-      : Math.min(props.maxLength !== undefined ? props.maxLength : 5, 5);
-  const maximum = props.maxLength !== undefined ? props.maxLength : minimum + 5;
-  const length = Math.max(minimum, Math.min(minimum, maximum));
-  return "a".repeat(length);
-};
-`
-
-// Doubles for the string-length helpers. The string iterator walks code points,
-// so a surrogate pair counts once; the comparisons stop as soon as their
-// boundary determines the answer.
-const ttscTypiaTestStringLengthStub = `module.exports._stringLength = (value) => {
-  let count = 0;
-  for (const _ of value) ++count;
-  return count;
-};
-module.exports._stringLengthGte = (value, length) => {
-  let count = 0;
-  if (length <= count) return true;
-  for (const _ of value) if (length <= ++count) return true;
-  return false;
-};
-module.exports._stringLengthLte = (value, length) => {
-  let count = 0;
-  if (!(count <= length)) return false;
-  for (const _ of value) if (!(++count <= length)) return false;
-  return true;
-};
 `
 
-const ttscTypiaTestAccessExpressionStub = `const reserved = new Set([
-  "break",
-  "case",
-  "catch",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "enum",
-  "export",
-  "extends",
-  "false",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "import",
-  "in",
-  "instanceof",
-  "new",
-  "null",
-  "return",
-  "super",
-  "switch",
-  "this",
-  "throw",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-]);
-
-module.exports._accessExpressionAsString = (key) => {
-  return reserved.has(key) === false && /^[A-Za-z_$][0-9A-Za-z_$]*$/.test(key)
-    ? "." + key
-    : "[" + JSON.stringify(key) + "]";
-};
+const finiteOptionNumberLeafTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
 `
 
-// ttscTypiaTestNotationStub stands in for typia/lib/internal/_notation*, which
-// the emitted converter requires for dynamic (index-signature) keys.
-//
-// These tests assert that the statically emitted key and the runtime helper
-// agree, so this stub is that assertion's oracle and has to stay a faithful
-// transcription of packages/typia/src/internal/_notation{Camel,Pascal,Snake,
-// Kebab}.ts and private/__notationRename.ts — an approximation turns "emit ==
-// runtime" into "emit == whatever this file happens to say". Keep it a direct
-// transcription: same routing on underscore presence (not on segment count),
-// the same CamelizeSnakeString/PascalizeSnakeString recursions, and the same
-// per-segment case-boundary walk in snake. It deliberately uses string
-// concatenation rather than template literals because it is embedded in a Go
-// raw string literal, which is backtick-delimited.
-const ttscTypiaTestNotationStub = `const __notationRename = (props) => (str) => {
-  let prefix = "";
-  while (str.startsWith("_")) {
-    prefix += "_";
-    str = str.substring(1);
-  }
-  if (str.length === 0) return prefix;
-  return prefix + (str.includes("_") ? props.snake(str) : props.plain(str));
-};
-
-const _notationCamelSnake = (str) => {
-  while (str.startsWith("_")) str = str.substring(1);
-  if (str.length === 0) return "";
-  const index = str.indexOf("_");
-  if (index < 0) return str.toLowerCase();
-  const middle = str[index + 1];
-  if (middle === undefined) return str.toLowerCase();
-  return middle === "_"
-    ? _notationCamelSnake(str.substring(0, index) + "_" + str.substring(index + 2))
-    : str.substring(0, index).toLowerCase() +
-      middle.toUpperCase() +
-      _notationCamelSnake(str.substring(index + 2));
-};
-
-const _notationPascalSnake = (str) => {
-  while (str.startsWith("_")) str = str.substring(1);
-  if (str.length === 0) return "";
-  const index = str.indexOf("_");
-  return index < 0
-    ? str[0].toUpperCase() + str.substring(1).toLowerCase()
-    : str[0].toUpperCase() +
-      str.substring(1, index).toLowerCase() +
-      _notationPascalSnake(str.substring(index + 1));
-};
-
-const _notationSnakeWord = (str) => {
-  const indexes = [];
-  for (let i = 0; i < str.length; i++) {
-    const code = str.charCodeAt(i);
-    if (65 <= code && code <= 90) indexes.push(i);
-  }
-  for (let i = indexes.length - 1; i > 0; --i)
-    if (indexes[i] - indexes[i - 1] === 1) indexes.splice(i, 1);
-  if (indexes.length !== 0 && indexes[0] === 0) indexes.splice(0, 1);
-  if (indexes.length === 0) return str.toLowerCase();
-  let ret = "";
-  for (let i = 0; i < indexes.length; i++) {
-    ret += str.substring(i === 0 ? 0 : indexes[i - 1], indexes[i]).toLowerCase();
-    ret += "_";
-  }
-  ret += str.substring(indexes[indexes.length - 1]).toLowerCase();
-  return ret;
-};
-
-module.exports._notationCamel = __notationRename({
-  plain: (str) =>
-    str === str.toUpperCase()
-      ? str.toLowerCase()
-      : str[0].toLowerCase() + str.substring(1),
-  snake: _notationCamelSnake,
-});
-module.exports._notationPascal = __notationRename({
-  plain: (str) => str[0].toUpperCase() + str.substring(1),
-  snake: _notationPascalSnake,
-});
-module.exports._notationSnake = (str) => {
-  if (str.length === 0) return str;
-  let prefix = "";
-  for (let i = 0; i < str.length; i++) {
-    if (str[i] === "_") prefix += "_";
-    else break;
-  }
-  if (prefix.length !== 0) str = str.substring(prefix.length);
-  return prefix + str.split("_").map(_notationSnakeWord).join("_");
-};
-module.exports._notationKebab = (str) => {
-  let snaked = module.exports._notationSnake(str);
-  let prefix = "";
-  while (snaked.startsWith("_")) {
-    prefix += "_";
-    snaked = snaked.substring(1);
-  }
-  return prefix + snaked.replaceAll("_", "-");
-};
-module.exports._notationAssign = (output, sources, source, value, rename) => {
-  const destination = rename(source);
-  if (Object.hasOwn(output, destination))
-    module.exports._notationKeyCollision(sources[destination], source, destination);
-  Object.defineProperty(output, destination, {
-    configurable: true,
-    enumerable: true,
-    value,
-    writable: true,
-  });
-  sources[destination] = source;
-};
-module.exports._notationKeyCollision = (first, second, destination) => {
-  throw new Error(
-    "typia.notations cannot rename both " + JSON.stringify(first) +
-    " and " + JSON.stringify(second) + " to " + JSON.stringify(destination) + ".",
-  );
-};
+const notationDynamicKeysTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
 `

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

@@ -5,20 +5,17 @@ import (
   "testing"
 )
 
-// TestTransformPluginOptionsComeFromPayload verifies the transform host takes
-// typia's options from ttsc's resolved plugin entry, not from tsconfig text.
+// TestTransformPluginOptionsComeFromPayload checks the authored operation results described below.
 //
-// This host owns its own `--plugins-json` flag and its own option read, so it
-// needs its own proof: the build host passing does not show that this one is
-// wired. Every row writes a tsconfig whose raw text disagrees with the resolved
-// entry, which is exactly what samchon/typia#1887 could not tell apart -- the
-// old reader regex-matched option names over the leaf file's bytes, so it
-// enabled options the user had commented out, adopted a sibling plugin's
-// options, and ignored options inherited through `extends`.
+// The host payload configures typia transform behavior; source-project plugin options do not replace those explicit operation settings.
 //
-//  1. Materialize each matrix row as a project plus the payload ttsc resolves it into.
-//  2. Run the transform host over it.
-//  3. Assert the emitted validator honors the entry, not the file text.
+// 1. Inline, commented, sibling-owned and inherited plugin entries distinguish enabled/disabled functional payloads while retaining the same function-property fixture.
+// 2. Each subcase includes or omits the function-property guard according to the explicit typia plugin payload.
+//
+// @evidence contracts/testing.md#behavioral-verification Each subcase includes or omits the function-property guard according to the explicit typia plugin payload.
+// @evidence contracts/testing.md#independent-expectations The host payload configures typia transform behavior; source-project plugin options do not replace those explicit operation settings.
+// @evidence contracts/testing.md#distinguishing-cases Inline, commented, sibling-owned and inherited plugin entries distinguish enabled/disabled functional payloads while retaining the same function-property fixture.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestTransformPluginOptionsComeFromPayload 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 TestTransformPluginOptionsComeFromPayload(t *testing.T) {
   for _, tc := range pluginOptionsPayloadCases() {
     t.Run(tc.name, func(t *testing.T) {

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

@@ -0,0 +1,54 @@
+package main
+
+import (
+  "encoding/json"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestTransformProjectDiagnosticsPreserveDetails checks the authored operation results described below.
+//
+// The authored source coordinate and operation establish the diagnostic identity; transforming must not replace that specific error with a generic fallback.
+//
+// 1. One invalid call pins exact diagnostic cardinality, source identity, position, code and cause.
+// 2. The rejected project call returns status three and one diagnostic with main.ts line three character nine, typia.is and the missing-generic cause.
+//
+// @evidence contracts/testing.md#behavioral-verification The rejected project call returns status three and one diagnostic with main.ts line three character nine, typia.is and the missing-generic cause.
+// @evidence contracts/testing.md#independent-expectations The authored source coordinate and operation establish the diagnostic identity; transforming must not replace that specific error with a generic fallback.
+// @evidence contracts/testing.md#distinguishing-cases One invalid call pins exact diagnostic cardinality, source identity, position, code and cause.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestTransformProjectDiagnosticsPreserveDetails 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 TestTransformProjectDiagnosticsPreserveDetails(t *testing.T) {
+  project := transformDiagnosticProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+    })
+  })
+  if code != 3 {
+    t.Fatalf("generic transform should fail with code 3, got %d\nstdout=%s\nstderr=%s", code, out, errText)
+  }
+
+  var result transformProjectOutput
+  if err := json.Unmarshal([]byte(out), &result); err != nil {
+    t.Fatalf("decode transform output: %v\n%s", err, out)
+  }
+  if len(result.Diagnostics) != 1 {
+    t.Fatalf("expected one transform diagnostic, got %+v", result.Diagnostics)
+  }
+  diag := result.Diagnostics[0]
+  if diag.File == nil || !strings.HasSuffix(filepath.ToSlash(*diag.File), "src/main.ts") {
+    t.Fatalf("diagnostic file was not preserved: %+v", diag)
+  }
+  if diag.Line != 3 || diag.Character != 9 {
+    t.Fatalf("diagnostic location mismatch: %+v", diag)
+  }
+  if diag.Code != "typia.is" {
+    t.Fatalf("diagnostic code mismatch: %+v", diag)
+  }
+  if diag.MessageText == typiaTransformDiagnosticFallbackMessage ||
+    !strings.Contains(diag.MessageText, "non-specified generic argument") {
+    t.Fatalf("diagnostic message did not preserve detail: %+v", diag)
+  }
+}

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

@@ -8,19 +8,17 @@ import (
   "testing"
 )
 
-// TestTransformSingleFileFailurePreservesArtifacts verifies single-file atomicity.
+// TestTransformSingleFileFailurePreservesArtifacts checks the authored operation results described below.
 //
-// The project host returns 3 when typia's analysis produced diagnostics, but both
-// single-file hosts used to publish `--out` and exit 0 regardless, shipping the
-// untransformed `typia.is<T>(input)` call behind a success code. Publication must
-// follow the same decision as the exit code in both output modes, and a failed
-// transform must not destroy an artifact a previous run left behind.
+// Single-file publication is transactional just like project builds: rejected transforms must not replace earlier artifacts or create partial output trees.
 //
-//  1. Seed `--out` with a byte-sensitive prior artifact beside an unrelated file.
-//  2. Run the single-file transform over a typia-invalid source in `ts` and `js`.
-//  3. Require exit 3, the diagnostic on stderr, and a byte-identical output tree.
-//  4. Require a fresh `--out` parent to stay uncreated, since publishing nothing
-//     must also mean creating no directory for it.
+// 1. TypeScript and JavaScript modes cover seeded and absent output targets, distinguishing replacement from first-publication failure.
+// 2. Each rejected single-file output mode returns status three with detailed diagnostics and preserves existing seeded artifact trees; a missing output directory stays absent.
+//
+// @evidence contracts/testing.md#behavioral-verification Each rejected single-file output mode returns status three with detailed diagnostics and preserves existing seeded artifact trees; a missing output directory stays absent.
+// @evidence contracts/testing.md#independent-expectations Single-file publication is transactional just like project builds: rejected transforms must not replace earlier artifacts or create partial output trees.
+// @evidence contracts/testing.md#distinguishing-cases TypeScript and JavaScript modes cover seeded and absent output targets, distinguishing replacement from first-publication failure.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestTransformSingleFileFailurePreservesArtifacts 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 TestTransformSingleFileFailurePreservesArtifacts(t *testing.T) {
   for _, output := range []string{"ts", "js"} {
     t.Run(output, func(t *testing.T) {

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

@@ -6,16 +6,17 @@ import (
   "testing"
 )
 
-// TestTransformSingleFileFailureWritesNoStdout verifies the stdout publication path.
+// TestTransformSingleFileFailureWritesNoStdout checks the authored operation results described below.
 //
-// Without `--out` the artifact is stdout, so withholding a file is not enough:
-// the untransformed source must not reach the stream a caller pipes into a file.
-// This is also the shape the wasm host reaches through `jsTransform`, whose
-// `{ code, stdout, stderr }` response is exactly these three values.
+// Stdout is an artifact publication channel, so a rejected transform cannot emit a surviving runtime stub or partial file before reporting failure.
 //
-//  1. Transform a typia-invalid source in `ts` and `js` with no `--out`.
-//  2. Require exit 3 and the diagnostic on stderr.
-//  3. Require stdout to be empty rather than carrying the untransformed call.
+// 1. Both output formats exercise failure without an --out target, complementing seeded filesystem atomicity checks.
+// 2. Rejected TypeScript/JavaScript stdout modes return status three with the typia.is diagnostic and write no artifact bytes.
+//
+// @evidence contracts/testing.md#behavioral-verification Rejected TypeScript/JavaScript stdout modes return status three with the typia.is diagnostic and write no artifact bytes.
+// @evidence contracts/testing.md#independent-expectations Stdout is an artifact publication channel, so a rejected transform cannot emit a surviving runtime stub or partial file before reporting failure.
+// @evidence contracts/testing.md#distinguishing-cases Both output formats exercise failure without an --out target, complementing seeded filesystem atomicity checks.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestTransformSingleFileFailureWritesNoStdout 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 TestTransformSingleFileFailureWritesNoStdout(t *testing.T) {
   for _, output := range []string{"ts", "js"} {
     t.Run(output, func(t *testing.T) {

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

@@ -7,22 +7,17 @@ import (
   "testing"
 )
 
-// TestTransformSingleFileJSDistinguishesSameBasenameSources verifies the
-// collision boundary of the `--output js` artifact match.
+// TestTransformSingleFileJSDistinguishesSameBasenameSources checks the authored operation results described below.
 //
-// The comment on the old whole-path-stem match named the intended repair --
-// "match on basename stem" -- and a basename match would indeed have unblocked
-// `outDir`. It would also have made `src/alpha/main.ts` and `src/beta/main.ts`
-// indistinguishable, so whichever emitted `main.js` arrived last would win and
-// the command would publish another file's validator under an exit 0. Resolving
-// the expected output path through the compiler keeps the two apart by
-// construction, since they resolve to different artifacts.
+// Output selection follows source identity through the emit layout, not a filename stem shared by distinct source directories.
 //
-//  1. Give one project two sources that share a basename in different
-//     directories, each lowering a differently shaped validator.
-//  2. Transform each with `--output js --out` under a `rootDir`/`outDir` layout.
-//  3. Require each published artifact to carry its own validator and not its
-//     namesake's.
+// 1. Two nested sources named alike carry different literal/data checks, supplying positive selected and negative sibling content for both selections.
+// 2. Each selected same-basename source publishes its own validator and excludes the sibling validator.
+//
+// @evidence contracts/testing.md#behavioral-verification Each selected same-basename source publishes its own validator and excludes the sibling validator.
+// @evidence contracts/testing.md#independent-expectations Output selection follows source identity through the emit layout, not a filename stem shared by distinct source directories.
+// @evidence contracts/testing.md#distinguishing-cases Two nested sources named alike carry different literal/data checks, supplying positive selected and negative sibling content for both selections.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestTransformSingleFileJSDistinguishesSameBasenameSources 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 TestTransformSingleFileJSDistinguishesSameBasenameSources(t *testing.T) {
   const alphaSource = `import typia from "typia";
 export function check(input: unknown): boolean {

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

@@ -7,24 +7,17 @@ import (
   "testing"
 )
 
-// TestTransformSingleFileJSLocatesOutputAcrossLayouts verifies `--output js`
-// finds its artifact wherever the compiler places the emit.
+// TestTransformSingleFileJSLocatesOutputAcrossLayouts checks the authored operation results described below.
 //
-// `transformSingleToJavaScript` captures the emit by matching the write callback
-// against the requested source. Comparing whole path stems made that match ask
-// whether `dist/main` equals `src/main`, so every project with an `outDir` --
-// which is every realistic layout -- reported "no output produced" and exited 3
-// over a transform that had in fact succeeded (samchon/typia#2134). `outDir` is
-// only one of the settings that reposition an emit, so this pins the whole class
-// rather than the reported witness: the match must come from the compiler's own
-// output-path resolution, the same one the emitter uses to choose where to
-// write, so no combination of `outDir`, `rootDir`, `rootDirs`, or source nesting
-// can desynchronize the two.
+// Selected source identity must be matched through rootDir/outDir/rootDirs layouts and distinguished from declaration/source-map artifacts rather than inferred from coincident path stems.
 //
-//  1. Build the same typia-valid source under each output-path layout.
-//  2. Transform it with `--output js --out`.
-//  3. Require exit 0, a silent stderr, and a published artifact carrying the
-//     lowered validator rather than the untransformed call.
+// 1. The authored layout matrix retains one selected numeric shape while varying source/output identities, so layout errors cannot hide behind source changes.
+// 2. Every configured layout publishes JavaScript with its numeric validator, no diagnostic and no untransformed generic call.
+//
+// @evidence contracts/testing.md#behavioral-verification Every configured layout publishes JavaScript with its numeric validator, no diagnostic and no untransformed generic call.
+// @evidence contracts/testing.md#independent-expectations Selected source identity must be matched through rootDir/outDir/rootDirs layouts and distinguished from declaration/source-map artifacts rather than inferred from coincident path stems.
+// @evidence contracts/testing.md#distinguishing-cases The authored layout matrix retains one selected numeric shape while varying source/output identities, so layout errors cannot hide behind source changes.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestTransformSingleFileJSLocatesOutputAcrossLayouts 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 TestTransformSingleFileJSLocatesOutputAcrossLayouts(t *testing.T) {
   for _, layout := range []struct {
     name  string