typia 13.1.19 → 13.3.0

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

@@ -0,0 +1,316 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "testing"
+)
+
+// TestSymbolIndexDomainTransform verifies a symbol index signature stays out
+// of typia's string-keyed validation and JSON Schema shape (#2240).
+//
+// TypeScript keeps string and symbol index domains distinct, including when a
+// symbol index key is intersected with a nominal brand. This regression pins
+// that boundary through the real transform because treating every checker
+// IndexInfo as a JSON string index makes unrelated Object.keys values inherit a
+// symbol index's value constraint. An ordinary string index and the explicit
+// symbol-member behavior fixed by #2226 are adjacent controls.
+//
+//  1. Compile checker-level keyof assertions for symbol and string indexes.
+//  2. Execute validators over ordinary extras and symbol-valued properties.
+//  3. Compare the symbol-index schema exactly with a plain-object control while
+//     requiring a normal string index to retain additionalProperties.
+func TestSymbolIndexDomainTransform(t *testing.T) {
+  project := symbolIndexDomainProject(t)
+  js := symbolIndexDomainTransform(t, project)
+  symbolIndexDomainRunRuntimeCases(t, project, js)
+}
+
+func symbolIndexDomainProject(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, "symbol-index-domain-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() {
+    _ = os.RemoveAll(dir)
+  })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(symbolIndexDomainTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(symbolIndexDomainSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func symbolIndexDomainTransform(t *testing.T, project string) string {
+  t.Helper()
+  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("symbol index domain transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  return out
+}
+
+func symbolIndexDomainRunRuntimeCases(t *testing.T, project string, js string) {
+  t.Helper()
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+  }
+  runtimeDir := filepath.Join(project, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  runtimeJS := ttscTypiaTestRewriteCommonJS(t, js)
+  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(runtimeJS), 0o644); err != nil {
+    t.Fatalf("write runtime module: %v", err)
+  }
+  runner := filepath.Join(runtimeDir, "run.cjs")
+  if err := os.WriteFile(runner, []byte(symbolIndexDomainRuntimeRunner), 0o644); err != nil {
+    t.Fatalf("write runtime runner: %v", err)
+  }
+  cmd := exec.Command(node, runner)
+  cmd.Dir = runtimeDir
+  if output, err := cmd.CombinedOutput(); err != nil {
+    t.Fatalf("symbol index domain runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const symbolIndexDomainTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const symbolIndexDomainSource = `import typia from "typia";
+
+declare const explicitSymbol: unique symbol;
+
+interface SymbolIndex {
+  name: string;
+  [key: symbol]: number;
+}
+
+type BrandedSymbol = symbol & {
+  readonly __brand: unique symbol;
+};
+
+interface BrandedSymbolIndex {
+  name: string;
+  [key: BrandedSymbol]: number;
+}
+
+interface PlainObject {
+  name: string;
+}
+
+interface StringIndex {
+  name: string;
+  [key: string]: string;
+}
+
+interface ExplicitSymbolMember {
+  name: string;
+  [explicitSymbol]: number;
+}
+
+type Assert<T extends true> = T;
+type _SymbolIndexHasNoStringDomain = Assert<
+  string extends keyof SymbolIndex ? false : true
+>;
+type _SymbolIndexHasNoNumberDomain = Assert<
+  number extends keyof SymbolIndex ? false : true
+>;
+type _SymbolIndexHasSymbolDomain = Assert<
+  symbol extends keyof SymbolIndex ? true : false
+>;
+type _BrandedSymbolIndexHasNoStringDomain = Assert<
+  string extends keyof BrandedSymbolIndex ? false : true
+>;
+type _BrandedSymbolIndexHasNoNumberDomain = Assert<
+  number extends keyof BrandedSymbolIndex ? false : true
+>;
+type _BrandedSymbolIndexHasBrandedDomain = Assert<
+  BrandedSymbol extends keyof BrandedSymbolIndex ? true : false
+>;
+type _StringIndexHasStringDomain = Assert<
+  string extends keyof StringIndex ? true : false
+>;
+type _StringIndexHasNumberDomain = Assert<
+  number extends keyof StringIndex ? true : false
+>;
+type _StringIndexHasNoSymbolDomain = Assert<
+  symbol extends keyof StringIndex ? false : true
+>;
+type _ExplicitSymbolMemberIsPresent = Assert<
+  typeof explicitSymbol extends keyof ExplicitSymbolMember ? true : false
+>;
+
+export const isSymbolIndex = typia.createIs<SymbolIndex>();
+export const isBrandedSymbolIndex =
+  typia.createIs<BrandedSymbolIndex>();
+export const isPlainObject = typia.createIs<PlainObject>();
+export const isStringIndex = typia.createIs<StringIndex>();
+export const isExplicitSymbolMember =
+  typia.createIs<ExplicitSymbolMember>();
+export const schemas = typia.json.schemas<[
+  SymbolIndex,
+  BrandedSymbolIndex,
+  PlainObject,
+  StringIndex,
+  ExplicitSymbolMember,
+]>();
+`
+
+const symbolIndexDomainRuntimeRunner = `const mod = require("./main.cjs");
+
+const failures = [];
+const expect = (label, actual, expected) => {
+  if (actual !== expected) {
+    failures.push(
+      label +
+        ": expected " +
+        JSON.stringify(expected) +
+        " but got " +
+        JSON.stringify(actual),
+    );
+  }
+};
+
+expect("symbol index plain", mod.isSymbolIndex({ name: "x" }), true);
+expect(
+  "symbol index ignores a numeric string extra",
+  mod.isSymbolIndex({ name: "x", extra: 1 }),
+  true,
+);
+expect(
+  "symbol index ignores a string extra",
+  mod.isSymbolIndex({ name: "x", extra: "unrelated" }),
+  true,
+);
+expect(
+  "symbol index ignores a matching symbol value",
+  mod.isSymbolIndex({ name: "x", [Symbol("key")]: 1 }),
+  true,
+);
+expect(
+  "symbol index ignores a non-matching symbol value",
+  mod.isSymbolIndex({ name: "x", [Symbol("key")]: "outside-json-shape" }),
+  true,
+);
+expect("symbol index validates named properties", mod.isSymbolIndex({ name: 1 }), false);
+
+expect(
+  "branded symbol index plain",
+  mod.isBrandedSymbolIndex({ name: "x" }),
+  true,
+);
+expect(
+  "branded symbol index ignores a string extra",
+  mod.isBrandedSymbolIndex({ name: "x", extra: "unrelated" }),
+  true,
+);
+expect(
+  "branded symbol index ignores a matching symbol value",
+  mod.isBrandedSymbolIndex({ name: "x", [Symbol("key")]: 1 }),
+  true,
+);
+expect(
+  "branded symbol index ignores a non-matching symbol value",
+  mod.isBrandedSymbolIndex({ name: "x", [Symbol("key")]: "outside-json-shape" }),
+  true,
+);
+expect(
+  "branded symbol index validates named properties",
+  mod.isBrandedSymbolIndex({ name: 1 }),
+  false,
+);
+
+expect("plain object ignores a string extra", mod.isPlainObject({ name: "x", extra: 1 }), true);
+expect("plain object validates named properties", mod.isPlainObject({ name: 1 }), false);
+
+expect("string index accepts matching extra", mod.isStringIndex({ name: "x", extra: "ok" }), true);
+expect("string index rejects mismatching extra", mod.isStringIndex({ name: "x", extra: 1 }), false);
+
+expect(
+  "explicit symbol member remains outside the JSON shape",
+  mod.isExplicitSymbolMember({ name: "x", [Symbol("member")]: "ignored" }),
+  true,
+);
+expect(
+  "explicit symbol member validates named properties",
+  mod.isExplicitSymbolMember({ name: 1 }),
+  false,
+);
+
+const schemas = mod.schemas.components.schemas;
+const plain = {
+  type: "object",
+  properties: { name: { type: "string" } },
+  required: ["name"],
+  additionalProperties: false,
+};
+const stringIndex = {
+  type: "object",
+  properties: { name: { type: "string" } },
+  required: ["name"],
+  additionalProperties: { type: "string" },
+};
+expect(
+  "plain object exact schema",
+  JSON.stringify(schemas.PlainObject),
+  JSON.stringify(plain),
+);
+expect(
+  "symbol index exact schema",
+  JSON.stringify(schemas.SymbolIndex),
+  JSON.stringify(plain),
+);
+expect(
+  "branded symbol index exact schema",
+  JSON.stringify(schemas.BrandedSymbolIndex),
+  JSON.stringify(plain),
+);
+expect(
+  "explicit symbol member exact schema",
+  JSON.stringify(schemas.ExplicitSymbolMember),
+  JSON.stringify(plain),
+);
+expect(
+  "string index exact schema",
+  JSON.stringify(schemas.StringIndex),
+  JSON.stringify(stringIndex),
+);
+if (failures.length !== 0) {
+  throw new Error("MISMATCHES:\n" + failures.join("\n"));
+}
+`

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

@@ -34,9 +34,7 @@ func TestTemplateLiteralTypeTagsTransform(t *testing.T) {
   if code != 0 {
     t.Fatalf("template literal tags transform failed: code=%d stderr=\n%s", code, errText)
   }
-  if !strings.Contains(out, `require("typia/lib/internal/_stringLength")`) ||
-    !strings.Contains(out, "._stringLength(input) <= 30") ||
-    !strings.Contains(out, "RegExp(/^prefix(.*)postfix$/)") {
+  if !strings.Contains(out, "length <= 30") || !strings.Contains(out, "RegExp(/^prefix(.*)postfix$/)") {
     t.Fatalf("emitted checker should combine the template pattern with its tags:\n%s", out)
   }
   templateLiteralTypeTagsRunRuntimeCases(t, project, out)

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

@@ -80,6 +80,8 @@ func runTransform(args []string) int {
     return 2
   }
   defer prog.Close()
+  registerTypiaDefaultLibraryClassifier(prog)
+  defer schemametadata.MetadataDefaultLibrary_release(prog.Checker)
 
   transformDiags := []typiaTransformDiagnostic{}
   transformOptions := pluginOptions.TransformOptions()
@@ -122,6 +124,27 @@ func runTransform(args []string) int {
   })
 }
 
+// registerTypiaDefaultLibraryClassifier hands metadata analysis the program's
+// own default-library classification, which runtime-native identity is decided
+// from: a global is the JavaScript built-in only when a runtime authority
+// declares it (#2200). `prog.TSProgram.IsLibFile` is the same oracle the
+// dependency collector above uses, and for the same reason — a default library
+// is not recognizable from its file name under `bundled:///`, `noembed`, or
+// `libReplacement` (#2108).
+//
+// Every program-loading host registers it against the checker whose types the
+// analysis reads, and releases it when that program closes, so no closed
+// program's checker stays reachable from the registry.
+func registerTypiaDefaultLibraryClassifier(prog *driver.Program) {
+  if prog == nil || prog.TSProgram == nil {
+    return
+  }
+  program := prog.TSProgram
+  schemametadata.MetadataDefaultLibrary_register(prog.Checker, func(source *shimast.SourceFile) bool {
+    return source != nil && program.IsLibFile(source)
+  })
+}
+
 // runTransformSingle is the single-file counterpart of runTransformProject's
 // diagnostic decision: produce the artifact into memory, then publish it only
 // when typia's analysis reported nothing. Every single-file output mode routes

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

@@ -3,23 +3,88 @@ package main
 import (
   "bytes"
   "os"
-  "os/exec"
   "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.
 func ttscTypiaTestTypecheck(t *testing.T, project string) {
   t.Helper()
-  pnpm, err := exec.LookPath("pnpm")
-  if err != nil {
-    t.Skip("pnpm executable not found")
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runBuild([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--noEmit",
+      "--rewrite-mode", "none",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("fixture typecheck failed: code=%d\nstdout=%s\nstderr=%s", code, out, errText)
   }
-  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)
+}
+
+// ttscTypiaTestWriteFactoryStub installs a typia whose declaration file sits at
+// the path the transformer's identity test accepts, so a fixture that also
+// carries an ambient or augmenting `declare module "typia"` differs from a
+// plain one only in that declaration.
+func ttscTypiaTestWriteFactoryStub(t *testing.T, project string) {
+  t.Helper()
+  root := filepath.Join(project, "node_modules", "typia")
+  lib := filepath.Join(root, "lib")
+  if err := os.MkdirAll(lib, 0o755); err != nil {
+    t.Fatalf("mkdir typia stub: %v", err)
+  }
+  files := map[string]string{
+    "package.json": `{
+  "name": "typia",
+  "version": "0.0.0-test",
+  "main": "./lib/module.js",
+  "types": "./lib/module.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/module.d.ts",
+      "default": "./lib/module.js"
+    },
+    "./lib/transform": "./lib/transform.js"
+  },
+  "ttsc": {
+    "plugin": { "transform": "typia/lib/transform" }
+  }
+}
+`,
+    filepath.Join("lib", "module.d.ts"): `declare namespace typia {
+  function createAssert<T>(): (input: unknown) => T;
+  function createIs<T>(): (input: unknown) => input is T;
+}
+declare const typia: {
+  createAssert: typeof typia.createAssert;
+  createIs: typeof typia.createIs;
+};
+export default typia;
+export declare function createAssert<T>(): (input: unknown) => T;
+export declare function createIs<T>(): (input: unknown) => input is T;
+`,
+    filepath.Join("lib", "module.js"):      "exports.createAssert = () => () => undefined;\nexports.createIs = () => () => false;\n",
+    filepath.Join("lib", "transform.js"):   "module.exports = {};\n",
+    filepath.Join("lib", "transform.d.ts"): "export {};\n",
+  }
+  for name, body := range files {
+    if err := os.WriteFile(filepath.Join(root, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write typia stub %s: %v", name, err)
+    }
   }
 }
 
@@ -60,14 +125,18 @@ func ttscTypiaTestCapture(run func() int) (string, string, int) {
 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,
+    "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,
+    "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 {
@@ -84,7 +153,11 @@ func ttscTypiaTestRewriteCommonJS(t *testing.T, js string) string {
   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,
@@ -93,9 +166,29 @@ func ttscTypiaTestRewriteCommonJS(t *testing.T, js string) string {
     )
   }
   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
 }
@@ -129,9 +222,20 @@ const ttscTypiaTestValidateReportStub = `module.exports._validateReport = (array
 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) {
-    const error = factory ? factory(props) : Object.assign(new Error(props.expected), props);
+  if (exceptionable === true) {
+    const error =
+      typeof factory === "function"
+        ? factory(props)
+        : Object.assign(new Error(props.expected), props);
     throw error;
   }
   return false;
@@ -142,10 +246,47 @@ const ttscTypiaTestFunctionalErrorStub = `module.exports._functionalTypeGuardErr
   Object.assign(new Error(props.expected), props);
 `
 
-const ttscTypiaTestStringLengthStub = `module.exports._stringLength = (value) => {
-  let count = 0;
-  for (const _ of value) ++count;
-  return count;
+// 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);
 };
 `