typia 13.2.0 → 14.0.0

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

@@ -0,0 +1,307 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestRecursiveConditionalAliasNameTransform pins the transform over a type
+// whose resolved graph names itself (issue #2331).
+//
+// `Primitive<T>` instantiated at the self-recursive union `type Node = Date |
+// Node[]` resolves to a union `X = string & Format<"date-time"> | X[]`, whose
+// array member's sole type argument is `X` itself. The name builders walked
+// union member -> array reference -> type argument and arrived back at the type
+// whose name was still being composed, so they recursed until the plugin process
+// died of a Go stack overflow: no diagnostic, no emit, and ttsc taken with it.
+// `Primitive` is only one witness -- any self-recursive conditional alias
+// produces the same graph -- so the fixture pins the bare `Rec<T>` form too.
+//
+// The names the fix produces have to stay usable, not merely terminate: the
+// cycle's placeholder is the type's own symbol with its arguments unexpanded, so
+// a JSON schema component keeps a short key instead of being named after a
+// several-hundred-character structural dump of the elided rendering.
+//
+//  1. Transform is / assert / json.schema over `Primitive<Node>`, the bare
+//     recursive conditional alias, and the recursive-JsonValue object, beside
+//     controls (named recursive union, self-recursive array alias, recursive
+//     interface) that already transformed and must keep their names.
+//  2. Require the emit to carry a recursive array validator rather than an
+//     inlined expansion.
+//  3. Execute the emitted validators over positive, negative, nested and
+//     boundary values, and require the recursive schema to self-reference
+//     through a bounded component name.
+func TestRecursiveConditionalAliasNameTransform(t *testing.T) {
+  project := recursiveConditionalAliasNameProject(t)
+  transform := func() (string, string, int) {
+    return ttscTypiaTestCapture(func() int {
+      return runTransform([]string{
+        "--cwd", project,
+        "--tsconfig", "tsconfig.json",
+        "--file", "src/main.ts",
+        "--output", "js",
+      })
+    })
+  }
+
+  out, errText, code := transform()
+  if code != 0 {
+    t.Fatalf("recursive conditional alias transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  if strings.Contains(out, "_ia0") == false {
+    t.Fatalf("expected a recursive array validator in the emit, got:\n%s", out)
+  }
+
+  // The cycle guard is a map, and the name it settles on becomes a helper
+  // identifier and a schema component key. Map iteration order must not reach
+  // either, so the same source has to emit the same bytes.
+  repeat, repeatErr, repeatCode := transform()
+  if repeatCode != 0 {
+    t.Fatalf("recursive conditional alias repeat transform failed: code=%d stderr=\n%s", repeatCode, repeatErr)
+  }
+  if repeat != out {
+    t.Fatalf("repeat transform emitted different bytes:\nfirst:\n%s\nsecond:\n%s", out, repeat)
+  }
+
+  recursiveConditionalAliasNameRunRuntimeCases(t, project, out)
+}
+
+func recursiveConditionalAliasNameProject(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, "recursive-conditional-alias-")
+  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(recursiveConditionalAliasNameTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(recursiveConditionalAliasNameSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func recursiveConditionalAliasNameRunRuntimeCases(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)
+  if err := os.WriteFile(filepath.Join(runtimeDir, "is-format-date-time-stub.cjs"), []byte(recursiveConditionalAliasNameFormatStub), 0o644); err != nil {
+    t.Fatalf("write format stub: %v", err)
+  }
+  js = strings.ReplaceAll(js, `require("typia/lib/internal/_isFormatDateTime")`, `require("./is-format-date-time-stub.cjs")`)
+  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(recursiveConditionalAliasNameRuntimeRunner), 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("recursive conditional alias runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const recursiveConditionalAliasNameTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+// The shipped helper validates the RFC 3339 date-time shape; the runtime cases
+// only need it to separate a date-time string from a plain one, and a stable
+// predicate keeps a failure reproducible.
+const recursiveConditionalAliasNameFormatStub = `module.exports._isFormatDateTime = (value) =>
+  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/.test(value);
+`
+
+const recursiveConditionalAliasNameSource = `import typia, { Primitive, tags } from "typia";
+
+// 1. the reported case: Primitive over a self-recursive union carrying Date.
+//    Primitive rewrites the Date arm to a date-time string and keeps the array
+//    arm pointing back at the whole union.
+type Node = Date | Node[];
+export const isPrimitiveNode = typia.createIs<Primitive<Node>>();
+export const assertPrimitiveNode = typia.createAssert<Primitive<Node>>();
+export const schemaPrimitiveNode = typia.json.schema<Primitive<Node>>();
+
+// 2. the same graph without Primitive: any self-recursive conditional alias
+//    instantiates to a union whose array member's type argument is that union
+type Rec<T> = T extends Date
+  ? string
+  : T extends (infer U)[]
+    ? Rec<U>[]
+    : never;
+export const isRec = typia.createIs<Rec<Node>>();
+
+// 3. the second report: the recursion sits behind an object property
+interface JsonObject {
+  [key: string]: JsonValue;
+}
+type JsonValue = string | number | boolean | null | JsonObject | JsonValue[];
+interface Output {
+  at: Date;
+  payload: JsonValue;
+}
+export const isOutput = typia.createIs<Primitive<Output>>();
+
+// controls: recursions that already named themselves through an alias or a
+// declaration must keep transforming and must not take the cycle placeholder
+type Named = (string & tags.Format<"date-time">) | Named[];
+export const isNamed = typia.createIs<Named>();
+export const schemaNamed = typia.json.schema<Named>();
+
+type SelfArray = SelfArray[];
+export const isSelfArray = typia.createIs<SelfArray>();
+
+interface ICategory {
+  name: string;
+  children: ICategory[];
+}
+export const isCategory = typia.createIs<ICategory>();
+export const schemaCategory = typia.json.schema<ICategory>();
+`
+
+const recursiveConditionalAliasNameRuntimeRunner = `const mod = require("./main.cjs");
+
+let failures = 0;
+const expect = (label, actual, expected) => {
+  if (actual !== expected) {
+    console.log("FAIL " + label + ": expected " + expected + ", got " + actual);
+    failures++;
+  }
+};
+
+const DATE = "2020-01-01T00:00:00.000Z";
+
+// --- 1. Primitive<Node>: date-time string or (recursively) an array of those ---
+expect("primitive top date-time", mod.isPrimitiveNode(DATE), true);
+expect("primitive top plain string", mod.isPrimitiveNode("nope"), false);
+expect("primitive top number", mod.isPrimitiveNode(1), false);
+expect("primitive top null", mod.isPrimitiveNode(null), false);
+expect("primitive top Date instance", mod.isPrimitiveNode(new Date(0)), false);
+expect("primitive empty array", mod.isPrimitiveNode([]), true);
+expect("primitive flat array", mod.isPrimitiveNode([DATE, DATE]), true);
+expect("primitive flat array bad member", mod.isPrimitiveNode([DATE, "nope"]), false);
+expect("primitive nested array", mod.isPrimitiveNode([[[DATE]], []]), true);
+expect("primitive nested bad leaf", mod.isPrimitiveNode([[[1]]]), false);
+expect("primitive nested Date instance", mod.isPrimitiveNode([[new Date(0)]]), false);
+
+// depth boundary: the emitted validator recurses through one function, so a
+// deep value must not need a deeper emit
+let deep = [DATE];
+for (let i = 0; i < 64; ++i) deep = [deep];
+expect("primitive deeply nested", mod.isPrimitiveNode(deep), true);
+let deepBad = [1];
+for (let i = 0; i < 64; ++i) deepBad = [deepBad];
+expect("primitive deeply nested bad leaf", mod.isPrimitiveNode(deepBad), false);
+
+// the emitted recursive validator must not be fooled by a self-referencing value
+const cyclic = [];
+cyclic.push(cyclic);
+expect("primitive cyclic value terminates", mod.isPrimitiveNode(cyclic), true);
+
+// --- 1b. assert reports the arm, and passes what is valid ---
+expect("assert passes", JSON.stringify(mod.assertPrimitiveNode([DATE])), JSON.stringify([DATE]));
+let assertPath = "";
+let assertExpected = "";
+try {
+  mod.assertPrimitiveNode(["nope"]);
+  failures++;
+  console.log("FAIL assert should have thrown");
+} catch (exp) {
+  assertPath = String(exp.path);
+  assertExpected = String(exp.expected);
+}
+expect("assert names the path", assertPath, "$input[0]");
+// The expected string is the same name the fix has to keep readable: the arm
+// itself, not a structural dump of the cycle it sits in.
+expect("assert names the arm", assertExpected.includes('Format<"date-time">'), true);
+expect("assert expectation is bounded", assertExpected.length <= 64, true);
+
+// --- 2. the bare recursive conditional alias: string or (recursively) arrays ---
+expect("rec top string", mod.isRec("anything"), true);
+expect("rec top number", mod.isRec(1), false);
+expect("rec nested array", mod.isRec([["a"], []]), true);
+expect("rec nested bad leaf", mod.isRec([[1]]), false);
+
+// --- 3. the recursion behind an object property ---
+expect("output valid", mod.isOutput({ at: DATE, payload: { a: [1, "b", null, { c: true }] } }), true);
+expect("output bad date", mod.isOutput({ at: "nope", payload: 1 }), false);
+expect("output missing key", mod.isOutput({ payload: 1 }), false);
+expect("output bad payload", mod.isOutput({ at: DATE, payload: undefined }), false);
+
+// --- controls: the recursions that already worked ---
+expect("named recursive union", mod.isNamed([[DATE]]), true);
+expect("named recursive union bad leaf", mod.isNamed([["nope"]]), false);
+expect("self array alias", mod.isSelfArray([[], [[]]]), true);
+expect("self array alias bad leaf", mod.isSelfArray([1]), false);
+expect("category valid", mod.isCategory({ name: "a", children: [{ name: "b", children: [] }] }), true);
+expect("category bad child", mod.isCategory({ name: "a", children: [{ name: 1, children: [] }] }), false);
+
+// --- the schema names the cycle without dumping its structural expansion ---
+const unit = mod.schemaPrimitiveNode;
+const keys = Object.keys(unit.components.schemas || {});
+expect("schema has one component", keys.length, 1);
+const key = keys[0];
+if (key !== undefined) {
+  // The pre-fix walk could only have produced a name built from the checker's
+  // elided rendering, which runs to several hundred characters; the placeholder
+  // keeps it in the same range as an ordinary named component.
+  expect("component name is bounded", key.length <= 64, true);
+  expect("component is an array", unit.components.schemas[key].type, "array");
+  const items = unit.components.schemas[key].items;
+  const refs = (items.oneOf || []).filter((elem) => elem.$ref !== undefined);
+  expect("array items reference the component itself", refs.length === 1 && refs[0].$ref === "#/components/schemas/" + key, true);
+  expect("array items keep the date-time arm", (items.oneOf || []).some((elem) => elem.format === "date-time"), true);
+}
+
+// controls: a recursion reached through a declaration names every component it
+// emits from that declaration, so the placeholder never applies to one
+expect("category component name", Object.keys(mod.schemaCategory.components.schemas || {})[0], "ICategory");
+const namedKeys = Object.keys(mod.schemaNamed.components.schemas || {});
+expect(
+  "named recursion names every component from its declaration",
+  namedKeys.length !== 0 && namedKeys.every((elem) => elem.includes("Named")),
+  true,
+);
+
+if (failures > 0) {
+  throw new Error(failures + " assertion(s) failed");
+}
+console.log("all recursive-conditional-alias cases passed");
+`

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

@@ -0,0 +1,152 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestShadowedTypiaModuleDeclarationDiagnostic verifies a redeclared typia call
+// is reported instead of silently skipped (#2328).
+//
+// The transformer attributes a call by the file its resolved signature is
+// declared in, which is what stops another package from claiming typia's
+// transform. A project-local `declare module "typia"` moves that declaration out
+// of typia's own files, so the identity test misses and the call used to pass
+// through untransformed with no diagnostic — `ttsc.transform()` returned
+// `type: "success"` with an empty diagnostic list, and the failure surfaced only
+// at run time as `no transform has been configured`. The identity test stays;
+// the silence does not.
+//
+//  1. Build a project with typia installed and an ambient `declare module
+//     "typia"` that redeclares `createAssert`, `json.createAssertParse`, and a
+//     `json.createAssert` that names no typia operation at all.
+//  2. Run the transform over the project.
+//  3. Require one diagnostic for each of the two real operations, at its call
+//     site, naming the operation as written and the shadowing file — and none
+//     for the third, whose spelling puts a root operation in a namespace.
+func TestShadowedTypiaModuleDeclarationDiagnostic(t *testing.T) {
+  project := shadowedTypiaModuleProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+    })
+  })
+  if code != 3 {
+    t.Fatalf("shadowed typia declaration 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)
+  }
+  // The root and namespaced spellings are looked up in different functor
+  // tables, so both have to be reported for the gate to be correct, and the
+  // code has to carry the namespace the user wrote.
+  expected := map[string]bool{
+    "typia.createAssert":           false,
+    "typia.json.createAssertParse": false,
+  }
+  if len(result.Diagnostics) != len(expected) {
+    t.Fatalf("expected %d transform diagnostics, got %+v", len(expected), result.Diagnostics)
+  }
+  for _, diag := range result.Diagnostics {
+    seen, owned := expected[diag.Code]
+    if owned == false {
+      t.Fatalf("diagnostic code did not name a shadowed operation as written: %+v", diag)
+    }
+    if seen {
+      t.Fatalf("diagnostic code reported twice: %+v", diag)
+    }
+    expected[diag.Code] = true
+    if diag.File == nil || !strings.HasSuffix(filepath.ToSlash(*diag.File), "src/main.ts") {
+      t.Fatalf("diagnostic was not reported at the call site: %+v", diag)
+    }
+    if diag.Line != shadowedTypiaCallLines[diag.Code] {
+      t.Fatalf("diagnostic line mismatch for %s: %+v", diag.Code, diag)
+    }
+    if !strings.Contains(filepath.ToSlash(diag.MessageText), "src/typia.d.ts") {
+      t.Fatalf("diagnostic did not name the shadowing declaration: %+v", diag)
+    }
+    if !strings.Contains(diag.MessageText, "no transform was applied") {
+      t.Fatalf("diagnostic did not state the consequence: %+v", diag)
+    }
+  }
+  for code, seen := range expected {
+    if seen == false {
+      t.Fatalf("no diagnostic reported %s", code)
+    }
+  }
+}
+
+// shadowedTypiaCallLines is the 1-based line of each shadowed call in
+// shadowedTypiaCallSource, so a regression that reports the whole file or the
+// wrong statement cannot pass on the file name alone.
+var shadowedTypiaCallLines = map[string]int{
+  "typia.createAssert":           7,
+  "typia.json.createAssertParse": 8,
+}
+
+func shadowedTypiaModuleProject(t *testing.T) string {
+  t.Helper()
+  dir := t.TempDir()
+  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(transformDiagnosticTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  // typia is installed as well as shadowed, matching the reporter's project: an
+  // ambient module declaration outranks node resolution, and the fixture is
+  // only faithful if there is something for it to outrank.
+  ttscTypiaTestWriteFactoryStub(t, dir)
+  for name, body := range map[string]string{
+    "typia.d.ts": shadowedTypiaAmbientDeclaration,
+    "main.ts":    shadowedTypiaCallSource,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write fixture %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const shadowedTypiaAmbientDeclaration = `declare module "typia" {
+  type ErrorFactory = (props: { method: string }) => Error;
+  export function createAssert<T>(
+    errorFactory?: ErrorFactory,
+  ): (input: unknown, errorFactory?: ErrorFactory) => T;
+  export namespace json {
+    function createAssertParse<T>(
+      errorFactory?: ErrorFactory,
+    ): (input: string, errorFactory?: ErrorFactory) => T;
+    function createAssert<T>(
+      errorFactory?: ErrorFactory,
+    ): (input: unknown, errorFactory?: ErrorFactory) => T;
+  }
+  const typia: {
+    createAssert<T>(
+      errorFactory?: ErrorFactory,
+    ): (input: unknown, errorFactory?: ErrorFactory) => T;
+    json: typeof json;
+  };
+  export default typia;
+}
+`
+
+// The third call spells a root operation inside a namespace. typia has no
+// `json.createAssert`, so nothing was shadowed and nothing may be reported.
+const shadowedTypiaCallSource = `import typia from "typia";
+
+export interface User {
+  id: number;
+}
+
+export const parseUser = typia.createAssert<User>();
+export const parseUserJson = typia.json.createAssertParse<User>();
+export const bogus = typia.json.createAssert<User>();
+`

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

@@ -20,8 +20,8 @@ import (
   nativetransform "github.com/samchon/typia/packages/typia/native/transform"
 )
 
-// runTransform is the source-to-source host the ttsc transform stage and the
-// `typia generate` wizard drive. Unlike `build` (which emits .js), it returns
+// runTransform is the source-to-source host that drives the ttsc transform
+// stage. Unlike `build` (which emits .js), it returns
 // transformed TypeScript: typia's per-file node transformer runs in an
 // EmitContext and the result SourceFile is printed back as TS (no JS script
 // transformers), so injected namespace imports stay as ES imports the caller

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

@@ -3,7 +3,6 @@ package main
 import (
   "bytes"
   "os"
-  "os/exec"
   "path/filepath"
   "runtime"
   "sort"
@@ -11,16 +10,81 @@ import (
   "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)
+  }
+}
+
+// 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",
   }
-  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)
+  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)
+    }
   }
 }
 
@@ -61,14 +125,14 @@ 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,
+    "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,
@@ -160,9 +224,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;
@@ -217,6 +292,9 @@ const ttscTypiaTestRandomStringStub = `module.exports._randomString = (props) =>
 };
 `
 
+// A double for packages/typia/src/internal/_stringLength.ts: the string
+// iterator walks code points, so a surrogate pair counts once, which is what
+// `MinLength` and `MaxLength` now mean.
 const ttscTypiaTestStringLengthStub = `module.exports._stringLength = (value) => {
   let count = 0;
   for (const _ of value) ++count;

package/native/core/factories/FormatCheatSheet.go

@@ -45,7 +45,7 @@ var FormatCheatSheet = map[string]string{
   "email":                 "/^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test($input)",
   "hostname":              "/^(?=.{1,253}\\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\\.?$/i.test($input)",
   "idn-email":             "/^(([^<>()[\\]\\.,;:\\s@\\\"]+(\\.[^<>()[\\]\\.,;:\\s@\\\"]+)*)|(\\\".+\\\"))@(([^<>()[\\]\\.,;:\\s@\\\"]+\\.)+[^<>()[\\]\\.,;:\\s@\\\"]{2,})$/i.test($input)",
-  "idn-hostname":          "/^([a-z0-9\\u00a1-\\uffff0-9]+(-[a-z0-9\\u00a1-\\uffff0-9]+)*\\.)+[a-z\\u00a1-\\uffff]{2,}$/i.test($input)",
+  "idn-hostname":          "/^(?=.{1,253}\\.?$)[a-z0-9\\u00a1-\\uffff](?:[a-z0-9\\u00a1-\\uffff-]{0,61}[a-z0-9\\u00a1-\\uffff])?(?:\\.[a-z0-9\\u00a1-\\uffff](?:[a-z0-9\\u00a1-\\uffff-]{0,61}[a-z0-9\\u00a1-\\uffff])?)*\\.?$/i.test($input)",
   "iri":                   `(() => !/[\u0000-\u0020\u007f-\u009f\ud800-\udfff"<>\\^\x60{|}]/u.test($input) && !/%(?![0-9A-Fa-f]{2})/u.test($input) && /^[A-Za-z][A-Za-z0-9+.-]*:/u.test($input))()`,
   "iri-reference":         `(() => { if (/[\u0000-\u0020\u007f-\u009f\ud800-\udfff"<>\\^\x60{|}]/u.test($input) || /%(?![0-9A-Fa-f]{2})/u.test($input)) return false; const colon = $input.indexOf(":"); const boundary = $input.search(/[/?#]/u); return colon === -1 || (boundary !== -1 && boundary < colon) || /^[A-Za-z][A-Za-z0-9+.-]*:/u.test($input); })()`,
   "ipv4":                  "/^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)$/.test($input)",
@@ -56,7 +56,7 @@ var FormatCheatSheet = map[string]string{
   "url":                   "/^(?:https?|ftp):\\/\\/(?:[^\\s/?#@]+(?::[^\\s/?#@]*)?@)?(?:(?!(?:10|127)(?:\\.\\d{1,3}){3})(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?=.{1,253}(?::\\d{2,5})?(?:\\/[^\\s]*)?$)(?:[a-z0-9\\u00a1-\\uffff](?:[-a-z0-9\\u00a1-\\uffff]{0,61}[a-z0-9\\u00a1-\\uffff])?\\.)+(?:[a-z\\u00a1-\\uffff](?:[-a-z0-9\\u00a1-\\uffff]{0,61}[a-z0-9\\u00a1-\\uffff])))(?::\\d{2,5})?(?:\\/[^\\s]*)?$/iu.test($input)",
   "date-time":             `(() => { const match = /^([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])[Tt]((?:[01][0-9]|2[0-3])):([0-5][0-9]):([0-5][0-9]|60)(?:\.[0-9]+)?(?:[Zz]|([+-])((?:[01][0-9]|2[0-3])):([0-5][0-9]))$/.exec($input); if (match === null) return false; const year = Number(match[1]); const month = Number(match[2]); const day = Number(match[3]); if (day > [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1] + (month === 2 && (year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0)) ? 1 : 0)) return false; if (match[6] !== "60") return true; const instant = new Date(0); instant.setUTCFullYear(year, month - 1, day); instant.setUTCHours(Number(match[4]), Number(match[5]), 0, 0); const offset = match[7] === undefined ? 0 : (match[7] === "+" ? 1 : -1) * (Number(match[8]) * 60 + Number(match[9])); instant.setUTCMinutes(instant.getUTCMinutes() - offset); return instant.getUTCHours() === 23 && instant.getUTCMinutes() === 59 && ((instant.getUTCMonth() === 5 && instant.getUTCDate() === 30) || (instant.getUTCMonth() === 11 && instant.getUTCDate() === 31)); })()`,
   "date":                  `(() => { const match = /^([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/.exec($input); if (match === null) return false; const year = Number(match[1]); const month = Number(match[2]); const day = Number(match[3]); return day <= [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1] + (month === 2 && (year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0)) ? 1 : 0); })()`,
-  "time":                  "/^([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](?:\\.[0-9]{1,9})?(Z|[+-]([01][0-9]|2[0-3]):[0-5][0-9])$/i.test($input)",
+  "time":                  `(() => { const match = /^([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(?:\.[0-9]+)?(?:[Zz]|([+-])((?:[01][0-9]|2[0-3])):([0-5][0-9]))$/.exec($input); if (match === null) return false; if (match[3] !== "60") return true; const offset = match[4] === undefined ? 0 : (match[4] === "+" ? 1 : -1) * (Number(match[5]) * 60 + Number(match[6])); const minutes = Number(match[1]) * 60 + Number(match[2]) - offset; return ((minutes % 1440) + 1440) % 1440 === 1439; })()`,
   "duration":              "/^P(?!$)((\\d+Y)?(\\d+M)?(\\d+D)?(T(?=\\d)(\\d+H)?(\\d+M)?(\\d+S)?)?|(\\d+W)?)$/.test($input)",
   "json-pointer":          "/^(?:\\/(?:[^~/]|~0|~1)*)*$/.test($input)",
   "relative-json-pointer": "/^(?:0|[1-9][0-9]*)(?:#|(?:\\/(?:[^~/]|~0|~1)*)*)$/.test($input)",