typia 13.1.1 → 13.2.0

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

@@ -0,0 +1,234 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestNativeCollectionIdentityIsTransform pins the runtime and emit behavior of
+// typia.is for a user type whose name collides with a built-in collection native
+// (#2212, the collection half of #2200).
+//
+// Collection-native classification matched Map/Set (iterate_metadata_map.go /
+// iterate_metadata_set.go) and WeakMap/WeakSet (the generics loop in
+// iterate_metadata_native.go) by base name alone, so a module-scoped user
+// `interface Map<K, V> { brandMap; keyMap; valMap }` yielded the base name "Map"
+// and was emitted as `input instanceof Map && [...]` — its own members dropped,
+// byte-identical to the real-lib Map. Every valid structural value was rejected
+// and the emit could throw where no such global exists.
+//
+// After the fix, collection-native classification (like the simples path #2200
+// already gated) requires the matched symbol to be declared in a `.d.ts`
+// declaration file, which a real built-in always is and a user type in a `.ts`
+// module never is. A colliding user type then falls through to the structural
+// object path and validates against its declared members, while the genuine
+// natives keep their `instanceof` check.
+//
+//  1. Transform is for user interfaces named Map/Set/WeakMap/WeakSet (main.ts,
+//     module-scoped, shadowing the globals) and for the genuine globals of the
+//     same names (real.ts, unshadowed).
+//  2. Assert the user emit is structural (its own brand members survive, no
+//     `instanceof`) while the genuine natives keep their `instanceof` path.
+//  3. Execute both emitted modules in Node against the boundary matrix, requiring
+//     the runner to report the exact executed case count so a runner that
+//     silently skipped cases cannot pass as a false green.
+func TestNativeCollectionIdentityIsTransform(t *testing.T) {
+  project := nativeCollectionIdentityProject(t)
+  transform := func(file string) string {
+    out, errText, code := ttscTypiaTestCapture(func() int {
+      return runTransform([]string{
+        "--cwd", project,
+        "--tsconfig", "tsconfig.json",
+        "--file", file,
+        "--output", "js",
+      })
+    })
+    if code != 0 {
+      t.Fatalf("collection identity transform %s failed: code=%d stderr=\n%s", file, code, errText)
+    }
+    return out
+  }
+  userJS := transform("src/main.ts")
+  realJS := transform("src/real.ts")
+
+  // The colliding user types must validate structurally: their own members
+  // survive and no native instanceof is emitted for them.
+  for _, member := range []string{"brandMap", "brandSet", "brandWeakMap", "brandWeakSet"} {
+    if !strings.Contains(userJS, member) {
+      t.Fatalf("expected user collection type member %q to survive structurally, but it was dropped in:\n%s", member, userJS)
+    }
+  }
+  for _, gone := range []string{"instanceof Map", "instanceof Set", "instanceof WeakMap", "instanceof WeakSet"} {
+    if strings.Contains(userJS, gone) {
+      t.Fatalf("expected user collection collision %q to be reclassified structurally, but it survived in:\n%s", gone, userJS)
+    }
+  }
+  // The genuine globals of the same names must stay native.
+  for _, kept := range []string{"instanceof Map", "instanceof Set", "instanceof WeakMap", "instanceof WeakSet"} {
+    if !strings.Contains(realJS, kept) {
+      t.Fatalf("expected genuine native path %q to remain in transform output:\n%s", kept, realJS)
+    }
+  }
+  nativeCollectionIdentityRunRuntimeCases(t, project, userJS, realJS)
+}
+
+func nativeCollectionIdentityProject(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, "native-collection-identity-")
+  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(finiteOptionNumberLeafTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(nativeCollectionIdentityUserSource), 0o644); err != nil {
+    t.Fatalf("write user source: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "real.ts"), []byte(nativeCollectionIdentityRealSource), 0o644); err != nil {
+    t.Fatalf("write real source: %v", err)
+  }
+  return dir
+}
+
+func nativeCollectionIdentityRunRuntimeCases(t *testing.T, project string, userJS string, realJS 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, "main.cjs"), []byte(ttscTypiaTestRewriteCommonJS(t, userJS)), 0o644); err != nil {
+    t.Fatalf("write user runtime module: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(runtimeDir, "real.cjs"), []byte(ttscTypiaTestRewriteCommonJS(t, realJS)), 0o644); err != nil {
+    t.Fatalf("write real runtime module: %v", err)
+  }
+  runner := filepath.Join(runtimeDir, "run.cjs")
+  if err := os.WriteFile(runner, []byte(nativeCollectionIdentityRuntimeRunner), 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("collection identity runtime cases failed: %v\n%s", err, output)
+  }
+  const expected = "RAN 27 CASES"
+  if !strings.Contains(string(output), expected) {
+    t.Fatalf("collection identity runner did not report %q; got:\n%s", expected, output)
+  }
+}
+
+// main.ts declares module-scoped interfaces named exactly Map/Set/WeakMap/WeakSet
+// that shadow the globals within this module, so their base name is exactly the
+// native name (the #2212 collision). Their type parameters are their own.
+const nativeCollectionIdentityUserSource = `import typia from "typia";
+
+interface Map<K, V> {
+  brandMap: string;
+  keyMap: K;
+  valMap: V;
+}
+interface Set<T> {
+  brandSet: string;
+  elemSet: T;
+}
+interface WeakMap<K extends object, V> {
+  brandWeakMap: string;
+}
+interface WeakSet<T extends object> {
+  brandWeakSet: string;
+}
+
+export const isUserMap = typia.createIs<Map<string, number>>();
+export const isUserSet = typia.createIs<Set<number>>();
+export const isUserWeakMap = typia.createIs<WeakMap<object, number>>();
+export const isUserWeakSet = typia.createIs<WeakSet<object>>();
+`
+
+// real.ts declares no local shadow, so its Map/Set/WeakMap/WeakSet resolve to the
+// genuine globals declared in a lib `.d.ts` and must stay native.
+const nativeCollectionIdentityRealSource = `import typia from "typia";
+
+export const isRealMap = typia.createIs<Map<string, number>>();
+export const isRealSet = typia.createIs<Set<number>>();
+export const isRealWeakMap = typia.createIs<WeakMap<object, number>>();
+export const isRealWeakSet = typia.createIs<WeakSet<object>>();
+`
+
+const nativeCollectionIdentityRuntimeRunner = `const user = require("./main.cjs");
+const real = require("./real.cjs");
+
+let ran = 0;
+const eq = (name, actual, expected) => {
+  ran += 1;
+  if (actual !== expected) {
+    throw new Error(name + ": expected " + expected + " but got " + actual);
+  }
+};
+
+// A user interface named Map must validate against its own members, not the
+// native Map instanceof path (#2212).
+eq("isUserMap valid", user.isUserMap({ brandMap: "x", keyMap: "k", valMap: 1 }), true);
+eq("isUserMap missing brand", user.isUserMap({ keyMap: "k", valMap: 1 }), false);
+eq("isUserMap wrong valMap type", user.isUserMap({ brandMap: "x", keyMap: "k", valMap: "1" }), false);
+eq("isUserMap rejects a real Map", user.isUserMap(new Map([["k", 1]])), false);
+eq("isUserMap null", user.isUserMap(null), false);
+eq("isUserMap empty object", user.isUserMap({}), false);
+
+// A user interface named Set is structural too.
+eq("isUserSet valid", user.isUserSet({ brandSet: "s", elemSet: 2 }), true);
+eq("isUserSet missing brand", user.isUserSet({ elemSet: 2 }), false);
+eq("isUserSet rejects a real Set", user.isUserSet(new Set([1])), false);
+
+// A user interface named WeakMap is structural, not instanceof WeakMap.
+eq("isUserWeakMap valid", user.isUserWeakMap({ brandWeakMap: "w" }), true);
+eq("isUserWeakMap missing brand", user.isUserWeakMap({}), false);
+eq("isUserWeakMap rejects a real WeakMap", user.isUserWeakMap(new WeakMap()), false);
+
+// A user interface named WeakSet is structural, not instanceof WeakSet.
+eq("isUserWeakSet valid", user.isUserWeakSet({ brandWeakSet: "z" }), true);
+eq("isUserWeakSet missing brand", user.isUserWeakSet({}), false);
+eq("isUserWeakSet rejects a real WeakSet", user.isUserWeakSet(new WeakSet()), false);
+
+// The genuine globals keep their instanceof check and accept a real instance
+// while rejecting a plain object of the same shape.
+eq("isRealMap real", real.isRealMap(new Map([["a", 1]])), true);
+eq("isRealMap empty real", real.isRealMap(new Map()), true);
+eq("isRealMap plain object", real.isRealMap({}), false);
+eq("isRealMap user Map shape", real.isRealMap({ brandMap: "x", keyMap: "k", valMap: 1 }), false);
+
+eq("isRealSet real", real.isRealSet(new Set([1, 2])), true);
+eq("isRealSet plain object", real.isRealSet({}), false);
+
+eq("isRealWeakMap real", real.isRealWeakMap(new WeakMap()), true);
+eq("isRealWeakMap plain object", real.isRealWeakMap({}), false);
+
+eq("isRealWeakSet real", real.isRealWeakSet(new WeakSet()), true);
+eq("isRealWeakSet plain object", real.isRealWeakSet({}), false);
+
+// Real collections stay disjoint from one another.
+eq("isRealMap rejects a real Set", real.isRealMap(new Set()), false);
+eq("isRealWeakMap rejects a real WeakSet", real.isRealWeakMap(new WeakSet()), false);
+
+console.log("RAN " + ran + " CASES");
+`

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

@@ -0,0 +1,194 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestNativeGenericNameGuardIsTransform verifies that a user type whose name
+// begins with WeakMap/WeakSet is not misdetected as the native generic.
+//
+// Native generic detection matched WeakMap/WeakSet with a bare
+// strings.HasPrefix(name, generic.Name) while the Map/Set siblings require the
+// name to be exactly the generic. A user interface named WeakMapLike therefore
+// took the native path and emitted `input instanceof WeakMap`, so
+// typia.is<WeakMapLike>({...}) returned false (issue #2181). The guard now
+// admits a native only when the stripped name equals the generic, so a genuine
+// WeakMap<K, V>/WeakSet<T> stays native while WeakMapLike validates its shape.
+//
+//  1. Transform typia.is calls for WeakMapLike, WeakSetLike, WeakMapEntry, a
+//     MapLike control, and genuine WeakMap<object, number>/WeakSet<object>.
+//  2. Assert the emitted TypeScript keeps the native `instanceof` path for the
+//     genuine generics.
+//  3. Execute the emitted validators so the user-named objects validate as
+//     their shape while the genuine natives still accept only their instance.
+func TestNativeGenericNameGuardIsTransform(t *testing.T) {
+  project := nativeGenericNameGuardProject(t)
+  ts := nativeGenericNameGuardTransform(t, project, "ts")
+  for _, needle := range []string{"instanceof WeakMap", "instanceof WeakSet"} {
+    if !strings.Contains(ts, needle) {
+      t.Fatalf("expected genuine native path %q in transform output:\n%s", needle, ts)
+    }
+  }
+  nativeGenericNameGuardRunRuntimeCases(t, project, nativeGenericNameGuardTransform(t, project, "js"))
+}
+
+func nativeGenericNameGuardProject(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, "native-generic-name-guard-")
+  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(nativeGenericNameGuardTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(nativeGenericNameGuardSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func nativeGenericNameGuardTransform(t *testing.T, project string, output string) string {
+  t.Helper()
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", output,
+    })
+  })
+  if code != 0 {
+    t.Fatalf("native generic name guard transform failed: output=%s code=%d stderr=\n%s", output, code, errText)
+  }
+  return out
+}
+
+func nativeGenericNameGuardRunRuntimeCases(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(nativeGenericNameGuardRuntimeRunner), 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("native generic name guard runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const nativeGenericNameGuardTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const nativeGenericNameGuardSource = `import typia from "typia";
+
+interface WeakMapLike {
+  id: number;
+  count: number;
+}
+interface WeakSetLike {
+  id: number;
+  count: number;
+}
+interface WeakMapEntry {
+  id: number;
+  count: number;
+}
+interface MapLike {
+  id: number;
+  count: number;
+}
+
+export const isWeakMapLike = (input: unknown): boolean =>
+  typia.is<WeakMapLike>(input);
+export const isWeakSetLike = (input: unknown): boolean =>
+  typia.is<WeakSetLike>(input);
+export const isWeakMapEntry = (input: unknown): boolean =>
+  typia.is<WeakMapEntry>(input);
+export const isMapLike = (input: unknown): boolean =>
+  typia.is<MapLike>(input);
+export const isNativeWeakMap = (input: unknown): boolean =>
+  typia.is<WeakMap<object, number>>(input);
+export const isNativeWeakSet = (input: unknown): boolean =>
+  typia.is<WeakSet<object>>(input);
+`
+
+const nativeGenericNameGuardRuntimeRunner = `const mod = require("./main.cjs");
+
+const expect = (label, actual, expected) => {
+  if (actual !== expected) {
+    throw new Error(label + ": expected " + expected + ", got " + actual);
+  }
+};
+
+const shaped = { id: 1, count: 2 };
+
+// A user interface whose name is merely prefixed by a native generic must
+// validate against its declared shape, not the native instanceof path.
+expect("WeakMapLike accepts its shape", mod.isWeakMapLike(shaped), true);
+expect("WeakMapLike rejects a missing property", mod.isWeakMapLike({ id: 1 }), false);
+expect("WeakMapLike rejects a wrong property type", mod.isWeakMapLike({ id: 1, count: "2" }), false);
+expect("WeakMapLike rejects a real WeakMap", mod.isWeakMapLike(new WeakMap()), false);
+
+expect("WeakSetLike accepts its shape", mod.isWeakSetLike(shaped), true);
+expect("WeakSetLike rejects a missing property", mod.isWeakSetLike({ id: 1 }), false);
+expect("WeakSetLike rejects a real WeakSet", mod.isWeakSetLike(new WeakSet()), false);
+
+expect("WeakMapEntry accepts its shape", mod.isWeakMapEntry(shaped), true);
+expect("WeakMapEntry rejects a missing property", mod.isWeakMapEntry({ id: 1 }), false);
+
+// MapLike is the already-guarded control: it stays a plain object exactly as
+// the WeakMap*/WeakSet* names now do.
+expect("MapLike control accepts its shape", mod.isMapLike(shaped), true);
+expect("MapLike control rejects a missing property", mod.isMapLike({ id: 1 }), false);
+
+// Genuine native generics always carry angle brackets, so the exact-name guard
+// keeps them on the native instanceof path unchanged.
+expect("native WeakMap accepts an instance", mod.isNativeWeakMap(new WeakMap()), true);
+expect("native WeakMap rejects a plain object", mod.isNativeWeakMap(shaped), false);
+expect("native WeakMap rejects a WeakSet", mod.isNativeWeakMap(new WeakSet()), false);
+
+expect("native WeakSet accepts an instance", mod.isNativeWeakSet(new WeakSet()), true);
+expect("native WeakSet rejects a plain object", mod.isNativeWeakSet(shaped), false);
+expect("native WeakSet rejects a WeakMap", mod.isNativeWeakSet(new WeakMap()), false);
+`

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

@@ -0,0 +1,204 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestNativeNameCollisionIsTransform pins the runtime and emit behavior of
+// typia.is / assert / validate for a user type whose name collides with a
+// built-in native (#2200).
+//
+// Native classification matched a type against the simples table by name alone,
+// so a user `interface File { name; size }` yielded the base name "File", matched
+// iterate_metadata_native_simples["File"], and emitted `input instanceof File` —
+// ignoring the user's own members. Every valid `File` value was therefore
+// rejected, and in a runtime without the DOM/File global the check threw a
+// ReferenceError. The same struck `Blob`, `Date`, the typed arrays, and every
+// other simples name.
+//
+// After the fix native classification requires the matched symbol to be declared
+// in a `.d.ts` declaration file (a TypeScript default library or an ambient
+// package such as @types/node), which a real built-in always is and a user type
+// in a `.ts` module never is. A colliding user type then falls through to the
+// structural object path and validates against its declared members, while a
+// genuine native (`Date`, `Uint8Array`) keeps its native `instanceof` check.
+//
+//  1. Transform is / validate for user interfaces named File and Blob, a near-miss
+//     control (Filer), and the genuine natives Date and Uint8Array.
+//  2. Assert the emitted TypeScript drops `instanceof File` / `instanceof Blob`
+//     for the user types while keeping `instanceof Date` / `instanceof Uint8Array`
+//     for the real natives.
+//  3. Execute the emitted validators in Node against the boundary matrix, and
+//     require the runner to report the exact executed case count so a runner that
+//     silently skipped cases cannot pass as a false green.
+func TestNativeNameCollisionIsTransform(t *testing.T) {
+  project := nativeNameCollisionProject(t)
+  js := nativeNameCollisionTransform(t, project)
+  for _, gone := range []string{"instanceof File", "instanceof Blob"} {
+    if strings.Contains(js, gone) {
+      t.Fatalf("expected user type collision %q to be reclassified structurally, but it survived in:\n%s", gone, js)
+    }
+  }
+  for _, kept := range []string{"instanceof Date", "instanceof Uint8Array"} {
+    if !strings.Contains(js, kept) {
+      t.Fatalf("expected genuine native path %q to remain in transform output:\n%s", kept, js)
+    }
+  }
+  nativeNameCollisionRunRuntimeCases(t, project, js)
+}
+
+func nativeNameCollisionProject(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, "native-name-collision-")
+  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(finiteOptionNumberLeafTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(nativeNameCollisionSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func nativeNameCollisionTransform(t *testing.T, project string) string {
+  t.Helper()
+  payload := `[{"config":{"transform":"typia/lib/transform"},"name":"typia","stage":"transform"}]`
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+      "--plugins-json", payload,
+    })
+  })
+  if code != 0 {
+    t.Fatalf("native name collision transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  return out
+}
+
+func nativeNameCollisionRunRuntimeCases(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(nativeNameCollisionRuntimeRunner), 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("native name collision runtime cases failed: %v\n%s", err, output)
+  }
+  const expected = "RAN 23 CASES"
+  if !strings.Contains(string(output), expected) {
+    t.Fatalf("native name collision runner did not report %q; got:\n%s", expected, output)
+  }
+}
+
+const nativeNameCollisionSource = `import typia from "typia";
+
+interface File {
+  name: string;
+  size: number;
+}
+interface Blob {
+  size: number;
+  type: string;
+}
+interface Filer {
+  name: string;
+}
+
+export const isFile = typia.createIs<File>();
+export const validateFile = typia.createValidate<File>();
+export const isBlob = typia.createIs<Blob>();
+export const isFiler = typia.createIs<Filer>();
+
+export const isDate = typia.createIs<Date>();
+export const isU8 = typia.createIs<Uint8Array>();
+`
+
+const nativeNameCollisionRuntimeRunner = `const mod = require("./main.cjs");
+
+let ran = 0;
+const eq = (name, actual, expected) => {
+  ran += 1;
+  if (actual !== expected) {
+    throw new Error(name + ": expected " + expected + " but got " + actual);
+  }
+};
+
+// A user interface named File must validate against its own members, not the
+// native File instanceof path (#2200 core cases).
+eq("isFile valid", mod.isFile({ name: "a", size: 1 }), true);
+eq("isFile missing size", mod.isFile({ name: "a" }), false);
+eq("isFile missing name", mod.isFile({ size: 1 }), false);
+eq("isFile wrong size type", mod.isFile({ name: "a", size: "1" }), false);
+eq("isFile null", mod.isFile(null), false);
+eq("isFile primitive", mod.isFile(5), false);
+
+// validate shares the structural object path, so it agrees with is and names no
+// File expected type.
+eq("validateFile valid", mod.validateFile({ name: "a", size: 1 }).success, true);
+eq("validateFile invalid", mod.validateFile({ name: "a" }).success, false);
+
+// A user interface named Blob is structural too.
+eq("isBlob valid", mod.isBlob({ size: 1, type: "x" }), true);
+eq("isBlob missing type", mod.isBlob({ size: 1 }), false);
+eq("isBlob null", mod.isBlob(null), false);
+
+// A near-miss name that is not a native was always structural and stays so.
+eq("isFiler valid", mod.isFiler({ name: "a" }), true);
+eq("isFiler invalid", mod.isFiler({}), false);
+
+// Genuine natives keep their instanceof check and accept a real instance while
+// rejecting a plain object of the same shape.
+eq("isDate real", mod.isDate(new Date()), true);
+eq("isDate plain object", mod.isDate({}), false);
+eq("isDate null", mod.isDate(null), false);
+
+eq("isU8 real", mod.isU8(new Uint8Array(4)), true);
+eq("isU8 plain object", mod.isU8({}), false);
+eq("isU8 array", mod.isU8([1, 2, 3]), false);
+eq("isU8 null", mod.isU8(null), false);
+
+// A user File/Blob value is not a real native instance, and a real native is not
+// a user shape: the two classifications stay disjoint.
+eq("isFile rejects a real Date", mod.isFile(new Date()), false);
+eq("isDate rejects a user File shape", mod.isDate({ name: "a", size: 1 }), false);
+eq("isBlob rejects a real Date", mod.isBlob(new Date()), false);
+
+console.log("RAN " + ran + " CASES");
+`