typia 13.1.1 → 13.2.0

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

@@ -3,12 +3,27 @@ package main
 import (
   "bytes"
   "os"
+  "os/exec"
   "path/filepath"
   "runtime"
+  "sort"
   "strings"
   "testing"
 )
 
+func ttscTypiaTestTypecheck(t *testing.T, project string) {
+  t.Helper()
+  pnpm, err := exec.LookPath("pnpm")
+  if err != nil {
+    t.Skip("pnpm executable not found")
+  }
+  cmd := exec.Command(pnpm, "exec", "ttsc", "--noEmit", "-p", "tsconfig.json")
+  cmd.Dir = project
+  if output, err := cmd.CombinedOutput(); err != nil {
+    t.Fatalf("fixture typecheck failed: %v\n%s", err, output)
+  }
+}
+
 func ttscTypiaTestRepoRoot(t *testing.T) string {
   t.Helper()
   _, file, _, ok := runtime.Caller(0)
@@ -50,7 +65,15 @@ func ttscTypiaTestWriteCommonRuntimeStubs(t *testing.T, runtimeDir string) {
     "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 {
@@ -65,20 +88,58 @@ func ttscTypiaTestRewriteCommonJS(t *testing.T, js string) string {
   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/_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) {
-      t.Fatalf("runtime module still contains unresolved typia import %q", needle)
+    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 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 path.length > last.length || last.substring(0, path.length) !== path;
+    return !isAncestor(path, last) && !isAncestor(last, path);
   };
   return (exceptable, error) => {
     if (exceptable && reportable(error.path)) {
@@ -108,6 +169,61 @@ const ttscTypiaTestAssertGuardStub = `module.exports._assertGuard = (exceptionab
 };
 `
 
+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);
+};
+`
+
+const ttscTypiaTestStringLengthStub = `module.exports._stringLength = (value) => {
+  let count = 0;
+  for (const _ of value) ++count;
+  return count;
+};
+`
+
 const ttscTypiaTestAccessExpressionStub = `const reserved = new Set([
   "break",
   "case",
@@ -153,3 +269,120 @@ module.exports._accessExpressionAsString = (key) => {
     : "[" + JSON.stringify(key) + "]";
 };
 `
+
+// 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) + ".",
+  );
+};
+`

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

@@ -0,0 +1,43 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestTransformPluginOptionsComeFromPayload verifies the transform host takes
+// typia's options from ttsc's resolved plugin entry, not from tsconfig text.
+//
+// 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`.
+//
+//  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.
+func TestTransformPluginOptionsComeFromPayload(t *testing.T) {
+  for _, tc := range pluginOptionsPayloadCases() {
+    t.Run(tc.name, func(t *testing.T) {
+      project := pluginOptionsPayloadProject(t, tc)
+      out, errText, code := ttscTypiaTestCapture(func() int {
+        return runTransform([]string{
+          "--cwd", project,
+          "--tsconfig", "tsconfig.json",
+          "--file", filepath.Join("src", "main.ts"),
+          "--output", "ts",
+          // `=`-joined, the exact shape ttsc's createNativeBuildArgs and the
+          // wasm hosts put on the wire.
+          "--plugins-json=" + tc.payload,
+        })
+      })
+      if code != 0 {
+        t.Fatalf("transform failed with code %d\nstdout=%s\nstderr=%s", code, out, errText)
+      }
+      pluginOptionsPayloadAssert(t, tc, out)
+    })
+  }
+}

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

@@ -0,0 +1,114 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "reflect"
+  "strings"
+  "testing"
+)
+
+// TestTransformSingleFileFailurePreservesArtifacts verifies single-file atomicity.
+//
+// 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.
+//
+//  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.
+func TestTransformSingleFileFailurePreservesArtifacts(t *testing.T) {
+  for _, output := range []string{"ts", "js"} {
+    t.Run(output, func(t *testing.T) {
+      project := transformSingleFileProject(t, transformDiagnosticSource)
+      dist := filepath.Join(project, "dist")
+      outPath := filepath.Join(dist, "main."+output)
+      seeds := map[string]string{
+        outPath:                         "previous artifact\n",
+        filepath.Join(dist, "keep.txt"): "unrelated output\n",
+      }
+      for path, body := range seeds {
+        if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+          t.Fatalf("mkdir seed parent: %v", err)
+        }
+        if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
+          t.Fatalf("write seed %s: %v", path, err)
+        }
+      }
+      before := buildReadTree(t, dist)
+
+      _, errText, code := ttscTypiaTestCapture(func() int {
+        return runTransform([]string{
+          "--cwd", project,
+          "--tsconfig", "tsconfig.json",
+          "--file", filepath.Join("src", "main.ts"),
+          "--output", output,
+          "--out", outPath,
+        })
+      })
+      if code != 3 {
+        t.Fatalf("invalid single-file transform 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("single-file diagnostic did not preserve location/code/message:\n%s", errText)
+      }
+      if after := buildReadTree(t, dist); !reflect.DeepEqual(after, before) {
+        t.Fatalf("failed single-file transform mutated output tree:\nbefore=%q\nafter=%q", before, after)
+      }
+
+      // writeSingleOutput mkdirs its parent, so a guard placed after publication
+      // would leave the directory behind even with no artifact in it.
+      fresh := filepath.Join(project, "fresh", "nested")
+      _, _, code = ttscTypiaTestCapture(func() int {
+        return runTransform([]string{
+          "--cwd", project,
+          "--tsconfig", "tsconfig.json",
+          "--file", filepath.Join("src", "main.ts"),
+          "--output", output,
+          "--out", filepath.Join(fresh, "main."+output),
+        })
+      })
+      if code != 3 {
+        t.Fatalf("invalid single-file transform should fail with code 3, got %d", code)
+      }
+      if _, err := os.Stat(filepath.Join(project, "fresh")); !os.IsNotExist(err) {
+        t.Fatalf("failed single-file transform created the --out directory: %v", err)
+      }
+    })
+  }
+}
+
+// transformSingleFileProject writes a one-source project whose `src/main.ts`
+// carries the given body, sharing the typia stub the other transform diagnostic
+// fixtures use.
+func transformSingleFileProject(t *testing.T, source string) string {
+  t.Helper()
+  project := t.TempDir()
+  src := filepath.Join(project, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(project, "tsconfig.json"), []byte(transformDiagnosticTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  transformDiagnosticWriteTypiaStub(t, project)
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(source), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return project
+}
+
+// transformSingleFileValidSource is the negative twin of
+// transformDiagnosticSource: the same call shape with a resolved generic
+// argument, which typia can lower without a diagnostic.
+const transformSingleFileValidSource = `import typia from "typia";
+export function check(input: unknown): boolean {
+  return typia.is<{ value: number }>(input);
+}
+`

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

@@ -0,0 +1,43 @@
+package main
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestTransformSingleFileFailureWritesNoStdout verifies the stdout publication path.
+//
+// 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.
+//
+//  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.
+func TestTransformSingleFileFailureWritesNoStdout(t *testing.T) {
+  for _, output := range []string{"ts", "js"} {
+    t.Run(output, func(t *testing.T) {
+      project := transformSingleFileProject(t, transformDiagnosticSource)
+      outText, errText, code := ttscTypiaTestCapture(func() int {
+        return runTransform([]string{
+          "--cwd", project,
+          "--tsconfig", "tsconfig.json",
+          "--file", filepath.Join("src", "main.ts"),
+          "--output", output,
+        })
+      })
+      if code != 3 {
+        t.Fatalf("invalid single-file transform should fail with code 3, got %d\nstdout=%s\nstderr=%s", code, outText, errText)
+      }
+      if !strings.Contains(errText, "error TS(typia.is):") {
+        t.Fatalf("single-file diagnostic missing from stderr:\n%s", errText)
+      }
+      // Before the fix this carried the untransformed `typia.is<T>(input)` call.
+      if outText != "" {
+        t.Fatalf("failed single-file transform published an artifact on stdout:\n%s", outText)
+      }
+    })
+  }
+}

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

@@ -0,0 +1,81 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestTransformSingleFileJSDistinguishesSameBasenameSources verifies the
+// collision boundary of the `--output js` artifact match.
+//
+// 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.
+//
+//  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.
+func TestTransformSingleFileJSDistinguishesSameBasenameSources(t *testing.T) {
+  const alphaSource = `import typia from "typia";
+export function check(input: unknown): boolean {
+  return typia.is<{ alpha: number }>(input);
+}
+`
+  const betaSource = `import typia from "typia";
+export function check(input: unknown): boolean {
+  return typia.is<{ beta: string }>(input);
+}
+`
+  project := transformSingleFileLayoutProject(
+    t,
+    []string{`"rootDir": "src"`, `"outDir": "dist"`},
+    map[string]string{
+      "src/alpha/main.ts": alphaSource,
+      "src/beta/main.ts":  betaSource,
+    },
+  )
+  for _, probe := range []struct {
+    name    string
+    file    string
+    carries string
+    rejects string
+  }{
+    {name: "alpha", file: "src/alpha/main.ts", carries: "alpha", rejects: "beta"},
+    {name: "beta", file: "src/beta/main.ts", carries: "beta", rejects: "alpha"},
+  } {
+    t.Run(probe.name, func(t *testing.T) {
+      outPath := filepath.Join(project, "artifact", probe.name+".js")
+      _, errText, code := ttscTypiaTestCapture(func() int {
+        return runTransform([]string{
+          "--cwd", project,
+          "--tsconfig", "tsconfig.json",
+          "--file", filepath.FromSlash(probe.file),
+          "--output", "js",
+          "--out", outPath,
+        })
+      })
+      if code != 0 {
+        t.Fatalf("`--output js` should publish %s, got %d\nstderr=%s", probe.file, code, errText)
+      }
+      data, err := os.ReadFile(outPath)
+      if err != nil {
+        t.Fatalf("`--output js` published no artifact for %s: %v", probe.file, err)
+      }
+      text := string(data)
+      if !strings.Contains(text, probe.carries) {
+        t.Fatalf("published artifact does not carry %s's validator:\n%s", probe.file, text)
+      }
+      if strings.Contains(text, probe.rejects) {
+        t.Fatalf("published artifact carries the same-basename sibling's validator:\n%s", text)
+      }
+    })
+  }
+}

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

@@ -0,0 +1,100 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestTransformSingleFileJSEmptyEmitReportsNoOutput verifies the negative twin
+// of the `--output js` artifact match.
+//
+// Teaching the match where an `outDir` puts an artifact must not turn it into a
+// match that always succeeds. "No output produced" is a real outcome: a source
+// can belong to the program and still have no JavaScript of its own, and the
+// caller needs exit 3 rather than an empty file behind exit 0. Every probe puts
+// a real artifact for a sibling source through the same write callback, so a
+// check that stopped discriminating would capture that neighbor and report
+// success. The three probes reach the outcome by different routes -- an emit
+// that skips the file, an emit that withholds it, and a file the resolution
+// gives no output path at all -- so no one of them stands in for the others.
+//
+//  1. Ask for the JavaScript of a declaration source, which the emit skips.
+//  2. Ask for the JavaScript of a source outside `rootDir`, whose output would
+//     land outside `outDir` and is therefore withheld by the emit.
+//  3. Ask for the JavaScript of a JSON module that would be emitted over
+//     itself, which resolves to no JavaScript output path.
+//  4. Require exit 3, the "no output produced" report, and an unwritten `--out`
+//     in all three.
+func TestTransformSingleFileJSEmptyEmitReportsNoOutput(t *testing.T) {
+  for _, probe := range []struct {
+    name    string
+    extra   []string
+    sources map[string]string
+    file    string
+  }{
+    // A declaration source is in the program but never emitted, so no write
+    // ever arrives for the path it resolves to.
+    {
+      name:  "declaration_source",
+      extra: []string{`"rootDir": "src"`, `"outDir": "dist"`},
+      sources: map[string]string{
+        "src/types.d.ts": "export declare const value: string;\n",
+        "src/main.ts":    transformSingleFileValidSource,
+      },
+      file: "src/types.d.ts",
+    },
+    // A source outside `rootDir` resolves to an output outside `outDir`, which
+    // the emit refuses to write rather than escaping the output tree. The
+    // source is ordinary TypeScript that transforms fine, so only the absent
+    // write distinguishes it -- exactly the state the check exists to report.
+    {
+      name:  "output_escapes_out_dir",
+      extra: []string{`"rootDir": "src/deep"`, `"outDir": "dist"`},
+      sources: map[string]string{
+        "src/deep/main.ts": transformSingleFileValidSource,
+        "src/stray.ts":     transformSingleFileValidSource,
+      },
+      file: "src/stray.ts",
+    },
+    // A JSON module with no `outDir` would be emitted over its own source, so
+    // the compiler resolves it to no JavaScript output path at all. This is the
+    // one route that reaches the empty-path guard rather than an absent write.
+    {
+      name:  "json_module_emitted_over_itself",
+      extra: []string{`"resolveJsonModule": true`},
+      sources: map[string]string{
+        "src/data.json": "{ \"value\": 1 }\n",
+        "src/main.ts":   "import data from \"./data.json\";\nexport const value = data.value;\n",
+      },
+      file: "src/data.json",
+    },
+  } {
+    t.Run(probe.name, func(t *testing.T) {
+      project := transformSingleFileLayoutProject(t, probe.extra, probe.sources)
+      outPath := filepath.Join(project, "artifact", "main.js")
+      _, errText, code := ttscTypiaTestCapture(func() int {
+        return runTransform([]string{
+          "--cwd", project,
+          "--tsconfig", "tsconfig.json",
+          "--file", filepath.FromSlash(probe.file),
+          "--output", "js",
+          "--out", outPath,
+        })
+      })
+      if code != 3 {
+        t.Fatalf("an empty emit must still fail with code 3, got %d\nstderr=%s", code, errText)
+      }
+      if !strings.Contains(errText, "no output produced") {
+        t.Fatalf("an empty emit must still report the cause:\n%s", errText)
+      }
+      // An empty emit leaves runTransformSingle through `if code != 0`, a
+      // different branch than the diagnostic route the atomicity case pins, so
+      // withholding the artifact needs its own check here.
+      if _, err := os.Stat(outPath); !os.IsNotExist(err) {
+        t.Fatalf("an empty emit must publish nothing, but --out exists: %v", err)
+      }
+    })
+  }
+}