typia 13.1.19 → 13.2.0

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

@@ -0,0 +1,277 @@
+package main
+
+import (
+  "fmt"
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestLibReplacementNativeIdentityTransform keeps a `libReplacement` project's
+// natives native even though their declaration file lives in node_modules
+// (#2200).
+//
+// Runtime-native identity requires a runtime authority to declare the global, so
+// which files count as a TypeScript default library became load-bearing. Under
+// `libReplacement` the compiler resolves `lib.es2015.collection.d.ts` to
+// `@typescript/lib-es2015/collection`, an ordinary package file whose name does
+// not even begin with `lib.` — so a file-name rule answers "not a default
+// library" and would demote Map, Set, WeakMap, and WeakSet to structural checks
+// that accept any object. Only the program's own classification is right here,
+// and this fixture is what proves the transform consults it.
+//
+//  1. Publish `@typescript/lib-es2015/collection.d.ts` carrying the real
+//     Map/Set/WeakMap/WeakSet declarations plus a probe interface that exists
+//     nowhere else, and enable `libReplacement`.
+//  2. Transform validators for the four replaced collection natives, for Date
+//     and Uint8Array as bundled-library controls, and for the probe.
+//  3. Require the probe to transform at all, which fails unless the replacement
+//     file — not the bundled lib — is what the program loaded.
+//  4. Require every native to keep its `instanceof` check and execute all of
+//     them in Node against real instances and plain objects.
+func TestLibReplacementNativeIdentityTransform(t *testing.T) {
+  project := libReplacementNativeIdentityProject(t)
+  js, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/input.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("lib replacement transform failed: code=%d stderr=\n%s", code, errText)
+  }
+
+  failures := []string{}
+  if !strings.Contains(js, "libReplacementMarker") {
+    failures = append(failures, "emit lost the replacement-only probe member; the project did not load the replaced lib file")
+  }
+  for _, kept := range []string{
+    "instanceof Map",
+    "instanceof Set",
+    "instanceof WeakMap",
+    "instanceof WeakSet",
+    "instanceof Date",
+    "instanceof Uint8Array",
+  } {
+    if !strings.Contains(js, kept) {
+      failures = append(failures, fmt.Sprintf("replaced or bundled default library native lost %q", kept))
+    }
+  }
+
+  output, runtimeErr := libReplacementNativeIdentityRun(t, project, js)
+  if runtimeErr != nil {
+    failures = append(failures, fmt.Sprintf("runtime matrix failed: %v\n%s", runtimeErr, output))
+  }
+  if expected := "RAN 13 REPLACEMENT CASES"; !strings.Contains(output, expected) {
+    failures = append(failures, fmt.Sprintf("replacement runner did not report %q; got:\n%s", expected, output))
+  }
+  if len(failures) != 0 {
+    t.Fatalf("lib replacement native identity mismatches:\n%s\n\nemit:\n%s", strings.Join(failures, "\n"), js)
+  }
+}
+
+func libReplacementNativeIdentityProject(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, "lib-replacement-native-identity-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() {
+    _ = os.RemoveAll(dir)
+  })
+  for name, content := range map[string]string{
+    "tsconfig.json": libReplacementNativeIdentityTSConfig,
+    "node_modules/@typescript/lib-es2015/package.json":   libReplacementNativeIdentityPackageJSON,
+    "node_modules/@typescript/lib-es2015/collection.d.ts": libReplacementNativeIdentityCollectionLib,
+    "src/input.ts": libReplacementNativeIdentitySource,
+  } {
+    path := filepath.Join(dir, filepath.FromSlash(name))
+    if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+      t.Fatalf("mkdir fixture path %s: %v", filepath.Dir(path), err)
+    }
+    if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+      t.Fatalf("write fixture file %s: %v", path, err)
+    }
+  }
+  return dir
+}
+
+func libReplacementNativeIdentityRun(t *testing.T, project string, js string) (string, error) {
+  t.Helper()
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+    return "", nil
+  }
+  runtimeDir := filepath.Join(project, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  for name, content := range map[string]string{
+    "input.cjs": ttscTypiaTestRewriteCommonJS(t, js),
+    "run.cjs":   libReplacementNativeIdentityRuntimeRunner,
+  } {
+    if err := os.WriteFile(filepath.Join(runtimeDir, name), []byte(content), 0o644); err != nil {
+      t.Fatalf("write runtime file %s: %v", name, err)
+    }
+  }
+  cmd := exec.Command(node, filepath.Join(runtimeDir, "run.cjs"))
+  cmd.Dir = runtimeDir
+  output, err := cmd.CombinedOutput()
+  return string(output), err
+}
+
+const libReplacementNativeIdentityTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "lib": ["ES2022"],
+    "types": [],
+    "libReplacement": true,
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const libReplacementNativeIdentityPackageJSON = `{
+  "name": "@typescript/lib-es2015",
+  "version": "1.0.0"
+}
+`
+
+// libReplacementNativeIdentityCollectionLib is the replacement TypeScript loads
+// instead of its bundled `lib.es2015.collection.d.ts`. The collection
+// declarations are transcribed from that file so the rest of the standard
+// library still typechecks against them; `LibReplacementProbe` is the one
+// addition, and it is what proves the program loaded this file.
+const libReplacementNativeIdentityCollectionLib = `interface LibReplacementProbe {
+    libReplacementMarker: string;
+}
+
+interface Map<K, V> {
+    clear(): void;
+    delete(key: K): boolean;
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+    readonly size: number;
+}
+
+interface MapConstructor {
+    new (): Map<any, any>;
+    new <K, V>(entries?: readonly (readonly [K, V])[] | null): Map<K, V>;
+    readonly prototype: Map<any, any>;
+}
+declare var Map: MapConstructor;
+
+interface ReadonlyMap<K, V> {
+    forEach(callbackfn: (value: V, key: K, map: ReadonlyMap<K, V>) => void, thisArg?: any): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    readonly size: number;
+}
+
+interface WeakMap<K extends WeakKey, V> {
+    delete(key: K): boolean;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+}
+
+interface WeakMapConstructor {
+    new <K extends WeakKey = WeakKey, V = any>(entries?: readonly (readonly [K, V])[] | null): WeakMap<K, V>;
+    readonly prototype: WeakMap<WeakKey, any>;
+}
+declare var WeakMap: WeakMapConstructor;
+
+interface Set<T> {
+    add(value: T): this;
+    clear(): void;
+    delete(value: T): boolean;
+    forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
+    has(value: T): boolean;
+    readonly size: number;
+}
+
+interface SetConstructor {
+    new <T = any>(values?: readonly T[] | null): Set<T>;
+    readonly prototype: Set<any>;
+}
+declare var Set: SetConstructor;
+
+interface ReadonlySet<T> {
+    forEach(callbackfn: (value: T, value2: T, set: ReadonlySet<T>) => void, thisArg?: any): void;
+    has(value: T): boolean;
+    readonly size: number;
+}
+
+interface WeakSet<T extends WeakKey> {
+    add(value: T): this;
+    delete(value: T): boolean;
+    has(value: T): boolean;
+}
+
+interface WeakSetConstructor {
+    new <T extends WeakKey = WeakKey>(values?: readonly T[] | null): WeakSet<T>;
+    readonly prototype: WeakSet<WeakKey>;
+}
+declare var WeakSet: WeakSetConstructor;
+`
+
+const libReplacementNativeIdentitySource = `import typia from "typia";
+
+export const createdIsProbe = typia.createIs<LibReplacementProbe>();
+export const createdIsMap = typia.createIs<Map<string, number>>();
+export const createdIsSet = typia.createIs<Set<string>>();
+export const createdIsWeakMap = typia.createIs<WeakMap<object, string>>();
+export const createdIsWeakSet = typia.createIs<WeakSet<object>>();
+export const createdIsDate = typia.createIs<Date>();
+export const createdIsBytes = typia.createIs<Uint8Array>();
+`
+
+const libReplacementNativeIdentityRuntimeRunner = `const validators = require("./input.cjs");
+
+let ran = 0;
+const failures = [];
+const eq = (name, actual, expected) => {
+  ran += 1;
+  if (actual !== expected) {
+    failures.push(name + ": expected " + expected + " but got " + actual);
+  }
+};
+
+eq("probe structural", validators.createdIsProbe({ libReplacementMarker: "x" }), true);
+eq("Map real", validators.createdIsMap(new Map([["x", 1]])), true);
+eq("Map plain", validators.createdIsMap({}), false);
+eq("Set real", validators.createdIsSet(new Set(["x"])), true);
+eq("Set plain", validators.createdIsSet({}), false);
+eq("WeakMap real", validators.createdIsWeakMap(new WeakMap()), true);
+eq("WeakMap plain", validators.createdIsWeakMap({}), false);
+eq("WeakSet real", validators.createdIsWeakSet(new WeakSet()), true);
+eq("WeakSet plain", validators.createdIsWeakSet({}), false);
+eq("Date real", validators.createdIsDate(new Date()), true);
+eq("Date plain", validators.createdIsDate({}), false);
+eq("Uint8Array real", validators.createdIsBytes(new Uint8Array(1)), true);
+eq("Uint8Array plain", validators.createdIsBytes({}), false);
+
+console.log("RAN " + ran + " REPLACEMENT CASES");
+if (failures.length !== 0) {
+  throw new Error("MISMATCHES:\n" + failures.join("\n"));
+}
+`

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

@@ -0,0 +1,390 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestNativeNamedIntersectionUnionTransform verifies a structural intersection
+// keeps its object identity when a user declaration shares a native name.
+//
+// The standalone local Date and Date intersection already use structural
+// metadata. Union composition must retain that classification instead of
+// pruning the inhabited arm as a native/object conflict. Native-named local
+// String and Number declarations must follow the same structural path, while
+// genuine native wrappers and impossible intersections retain their existing
+// pruning paths.
+//
+//  1. Transform standalone, union, genuine-native, impossible, and colliding
+//     native-name controls.
+//  2. Inspect each union factory to prove local structural arms are retained
+//     while genuine wrappers and existing collection arms keep their emit.
+//  3. Execute both valid arms, invalid near-misses, and pruning controls.
+func TestNativeNamedIntersectionUnionTransform(t *testing.T) {
+  project := nativeNamedIntersectionUnionProject(t)
+  js := nativeNamedIntersectionUnionTransform(t, project)
+
+  localUnion := nativeNamedIntersectionUnionExport(t, js, "isLocalUnion", "isLocalMapUnion")
+  for _, retained := range []string{"input.stamp", "input.label", "input.ok"} {
+    if !strings.Contains(localUnion, retained) {
+      t.Errorf("local structural union lost %q in emitted factory:\n%s", retained, localUnion)
+    }
+  }
+  if strings.Contains(localUnion, "instanceof Date") {
+    t.Errorf("local structural union was emitted as a genuine Date:\n%s", localUnion)
+  }
+
+  localWrapperUnions := []struct {
+    name    string
+    next    string
+    members []string
+    native  string
+  }{
+    {"isLocalStringUnion", "isLocalNumberUnion", []string{"input.stringValue", "input.label", "input.stringOk"}, "String"},
+    {"isLocalNumberUnion", "isLocalMapUnion", []string{"input.numberValue", "input.label", "input.numberOk"}, "Number"},
+  }
+  for _, control := range localWrapperUnions {
+    segment := nativeNamedIntersectionUnionExport(t, js, control.name, control.next)
+    for _, retained := range control.members {
+      if !strings.Contains(segment, retained) {
+        t.Errorf("%s lost structural member %q in emitted factory:\n%s", control.name, retained, segment)
+      }
+    }
+    if strings.Contains(segment, "instanceof "+control.native) {
+      t.Errorf("%s was emitted as a genuine %s wrapper:\n%s", control.name, control.native, segment)
+    }
+  }
+
+  collectionUnions := []struct {
+    name    string
+    next    string
+    members []string
+  }{
+    {"isLocalMapUnion", "isLocalSetUnion", []string{"input.brandMap", "input.valueMap", "input.label", "input.mapOk"}},
+    {"isLocalSetUnion", "isLocalWeakMapUnion", []string{"input.brandSet", "input.label", "input.setOk"}},
+    {"isLocalWeakMapUnion", "isLocalWeakSetUnion", []string{"input.brandWeakMap", "input.valueWeakMap", "input.label", "input.weakMapOk"}},
+    {"isLocalWeakSetUnion", "isNativeDate", []string{"input.brandWeakSet", "input.label", "input.weakSetOk"}},
+  }
+  for _, control := range collectionUnions {
+    segment := nativeNamedIntersectionUnionExport(t, js, control.name, control.next)
+    for _, retained := range control.members {
+      if !strings.Contains(segment, retained) {
+        t.Fatalf("%s lost structural member %q in emitted factory:\n%s", control.name, retained, segment)
+      }
+    }
+  }
+
+  nativeDate := nativeNamedIntersectionUnionExport(t, js, "isNativeDate", "isNativeIntersectionUnion")
+  if !strings.Contains(nativeDate, "instanceof Date") {
+    t.Fatalf("genuine Date lost its native identity in emitted factory:\n%s", nativeDate)
+  }
+
+  nativeUnion := nativeNamedIntersectionUnionExport(t, js, "isNativeIntersectionUnion", "isNativeStringIntersectionUnion")
+  for _, pruned := range []string{"instanceof Date", "input.label"} {
+    if strings.Contains(nativeUnion, pruned) {
+      t.Fatalf("genuine native intersection unexpectedly survived union pruning as %q:\n%s", pruned, nativeUnion)
+    }
+  }
+  if !strings.Contains(nativeUnion, "input.ok") {
+    t.Fatalf("genuine native intersection control lost its inhabited object arm:\n%s", nativeUnion)
+  }
+
+  nativeWrapperUnions := []struct {
+    name   string
+    next   string
+    native string
+    other  string
+  }{
+    {"isNativeStringIntersectionUnion", "isNativeNumberIntersectionUnion", "String", "nativeStringOk"},
+    {"isNativeNumberIntersectionUnion", "isImpossibleUnion", "Number", "nativeNumberOk"},
+  }
+  for _, control := range nativeWrapperUnions {
+    segment := nativeNamedIntersectionUnionExport(t, js, control.name, control.next)
+    for _, pruned := range []string{"instanceof " + control.native, "input.label"} {
+      if strings.Contains(segment, pruned) {
+        t.Fatalf("genuine %s wrapper intersection unexpectedly survived union pruning as %q:\n%s", control.native, pruned, segment)
+      }
+    }
+    if !strings.Contains(segment, "input."+control.other) {
+      t.Fatalf("genuine %s wrapper control lost its inhabited object arm:\n%s", control.native, segment)
+    }
+  }
+
+  impossibleUnion := nativeNamedIntersectionUnionExport(t, js, "isImpossibleUnion", "")
+  if strings.Contains(impossibleUnion, "input.data") {
+    t.Fatalf("impossible intersection unexpectedly survived union pruning:\n%s", impossibleUnion)
+  }
+  if !strings.Contains(impossibleUnion, "input.ok") {
+    t.Fatalf("impossible intersection control lost its inhabited object arm:\n%s", impossibleUnion)
+  }
+
+  nativeNamedIntersectionUnionRunRuntimeCases(t, project, js)
+}
+
+func nativeNamedIntersectionUnionProject(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-named-intersection-union-")
+  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(nativeNamedIntersectionUnionTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(nativeNamedIntersectionUnionSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func nativeNamedIntersectionUnionTransform(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("native-named intersection union transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  return out
+}
+
+func nativeNamedIntersectionUnionExport(t *testing.T, js string, name string, next string) string {
+  t.Helper()
+  marker := "exports." + name + " = (() =>"
+  start := strings.Index(js, marker)
+  if start == -1 {
+    t.Fatalf("emitted JavaScript has no %s factory:\n%s", name, js)
+  }
+  segment := js[start:]
+  if next != "" {
+    end := strings.Index(segment, "exports."+next+" = (() =>")
+    if end == -1 {
+      t.Fatalf("emitted JavaScript has no %s boundary after %s:\n%s", next, name, js)
+    }
+    segment = segment[:end]
+  }
+  return segment
+}
+
+func nativeNamedIntersectionUnionRunRuntimeCases(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, "main.cjs"), []byte(ttscTypiaTestRewriteCommonJS(t, js)), 0o644); err != nil {
+    t.Fatalf("write runtime module: %v", err)
+  }
+  runner := filepath.Join(runtimeDir, "run.cjs")
+  if err := os.WriteFile(runner, []byte(nativeNamedIntersectionUnionRuntimeRunner), 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-named intersection union runtime cases failed: %v\n%s", err, output)
+  }
+  if !strings.Contains(string(output), "RAN 44 CASES") {
+    t.Fatalf("runtime runner did not report all cases:\n%s", output)
+  }
+}
+
+const nativeNamedIntersectionUnionTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const nativeNamedIntersectionUnionSource = `import typia from "typia";
+
+interface Date {
+  stamp: number;
+}
+interface String {
+  stringValue: string;
+}
+interface Number {
+  numberValue: number;
+}
+interface Map<K, V> {
+  brandMap: K;
+  valueMap: V;
+}
+interface Set<T> {
+  brandSet: T;
+}
+interface WeakMap<K extends object, V> {
+  brandWeakMap: K;
+  valueWeakMap: V;
+}
+interface WeakSet<T extends object> {
+  brandWeakSet: T;
+}
+type LocalIntersection = Date & { label: string };
+type LocalUnion = LocalIntersection | { ok: boolean };
+type LocalStringUnion =
+  | (String & { label: string })
+  | { stringOk: boolean };
+type LocalNumberUnion =
+  | (Number & { label: string })
+  | { numberOk: boolean };
+type LocalMapUnion =
+  | (Map<string, number> & { label: string })
+  | { mapOk: boolean };
+type LocalSetUnion =
+  | (Set<string> & { label: string })
+  | { setOk: boolean };
+type LocalWeakMapUnion =
+  | (WeakMap<object, string> & { label: string })
+  | { weakMapOk: boolean };
+type LocalWeakSetUnion =
+  | (WeakSet<object> & { label: string })
+  | { weakSetOk: boolean };
+
+type NativeDate = InstanceType<typeof globalThis.Date>;
+type NativeIntersectionUnion =
+  | (NativeDate & { label: string })
+  | { ok: boolean };
+type NativeString = InstanceType<typeof globalThis.String>;
+type NativeNumber = InstanceType<typeof globalThis.Number>;
+type NativeStringIntersectionUnion =
+  | (NativeString & { label: string })
+  | { nativeStringOk: boolean };
+type NativeNumberIntersectionUnion =
+  | (NativeNumber & { label: string })
+  | { nativeNumberOk: boolean };
+type ImpossibleUnion =
+  | (string & { data: number })
+  | { ok: boolean };
+
+export const isLocalDate = typia.createIs<Date>();
+export const isLocalIntersection = typia.createIs<LocalIntersection>();
+export const isLocalUnion = typia.createIs<LocalUnion>();
+export const isLocalStringUnion = typia.createIs<LocalStringUnion>();
+export const isLocalNumberUnion = typia.createIs<LocalNumberUnion>();
+export const isLocalMapUnion = typia.createIs<LocalMapUnion>();
+export const isLocalSetUnion = typia.createIs<LocalSetUnion>();
+export const isLocalWeakMapUnion = typia.createIs<LocalWeakMapUnion>();
+export const isLocalWeakSetUnion = typia.createIs<LocalWeakSetUnion>();
+export const isNativeDate = typia.createIs<NativeDate>();
+export const isNativeIntersectionUnion =
+  typia.createIs<NativeIntersectionUnion>();
+export const isNativeStringIntersectionUnion =
+  typia.createIs<NativeStringIntersectionUnion>();
+export const isNativeNumberIntersectionUnion =
+  typia.createIs<NativeNumberIntersectionUnion>();
+export const isImpossibleUnion = typia.createIs<ImpossibleUnion>();
+`
+
+const nativeNamedIntersectionUnionRuntimeRunner = `const mod = require("./main.cjs");
+
+let ran = 0;
+const failures = [];
+const check = (label, actual, expected) => {
+  ran += 1;
+  if (actual !== expected) {
+    failures.push(label + ": expected " + expected + " but got " + actual);
+  }
+};
+
+check("local Date valid", mod.isLocalDate({ stamp: 1 }), true);
+check("local Date native", mod.isLocalDate(new Date(0)), false);
+check("local Date missing stamp", mod.isLocalDate({}), false);
+
+check("local intersection valid", mod.isLocalIntersection({ stamp: 1, label: "x" }), true);
+check("local intersection missing label", mod.isLocalIntersection({ stamp: 1 }), false);
+check("local intersection missing stamp", mod.isLocalIntersection({ label: "x" }), false);
+
+check("local union structural arm", mod.isLocalUnion({ stamp: 1, label: "x" }), true);
+check("local union other arm", mod.isLocalUnion({ ok: true }), true);
+check("local union near-miss", mod.isLocalUnion({ stamp: 1 }), false);
+check("local union bad other arm", mod.isLocalUnion({ ok: "yes" }), false);
+
+check("local String union structural arm", mod.isLocalStringUnion({ stringValue: "x", label: "s" }), true);
+check("local String union other arm", mod.isLocalStringUnion({ stringOk: true }), true);
+check("local String union near-miss", mod.isLocalStringUnion({ stringValue: "x" }), false);
+check("local String union bad other arm", mod.isLocalStringUnion({ stringOk: "yes" }), false);
+check("local Number union structural arm", mod.isLocalNumberUnion({ numberValue: 1, label: "n" }), true);
+check("local Number union other arm", mod.isLocalNumberUnion({ numberOk: true }), true);
+check("local Number union near-miss", mod.isLocalNumberUnion({ numberValue: 1 }), false);
+check("local Number union bad other arm", mod.isLocalNumberUnion({ numberOk: "yes" }), false);
+
+check("local Map union structural arm", mod.isLocalMapUnion({ brandMap: "x", valueMap: 1, label: "m" }), true);
+check("local Map union other arm", mod.isLocalMapUnion({ mapOk: true }), true);
+check("local Map union near-miss", mod.isLocalMapUnion({ brandMap: "x", valueMap: 1 }), false);
+check("local Set union structural arm", mod.isLocalSetUnion({ brandSet: "x", label: "s" }), true);
+check("local Set union other arm", mod.isLocalSetUnion({ setOk: true }), true);
+check("local Set union near-miss", mod.isLocalSetUnion({ brandSet: "x" }), false);
+check("local WeakMap union structural arm", mod.isLocalWeakMapUnion({ brandWeakMap: {}, valueWeakMap: "x", label: "wm" }), true);
+check("local WeakMap union other arm", mod.isLocalWeakMapUnion({ weakMapOk: true }), true);
+check("local WeakMap union near-miss", mod.isLocalWeakMapUnion({ brandWeakMap: {}, valueWeakMap: "x" }), false);
+check("local WeakSet union structural arm", mod.isLocalWeakSetUnion({ brandWeakSet: {}, label: "ws" }), true);
+check("local WeakSet union other arm", mod.isLocalWeakSetUnion({ weakSetOk: true }), true);
+check("local WeakSet union near-miss", mod.isLocalWeakSetUnion({ brandWeakSet: {} }), false);
+
+check("genuine Date", mod.isNativeDate(new Date(0)), true);
+check("genuine Date plain object", mod.isNativeDate({}), false);
+check(
+  "genuine native intersection pruned",
+  mod.isNativeIntersectionUnion(Object.assign(new Date(0), { label: "x" })),
+  false,
+);
+check("genuine native union other arm", mod.isNativeIntersectionUnion({ ok: true }), true);
+check("genuine native plain near-miss", mod.isNativeIntersectionUnion({ label: "x" }), false);
+
+check(
+  "genuine String wrapper intersection pruned",
+  mod.isNativeStringIntersectionUnion(Object.assign(new String("x"), { label: "s" })),
+  false,
+);
+check("genuine String wrapper union other arm", mod.isNativeStringIntersectionUnion({ nativeStringOk: true }), true);
+check("genuine String wrapper plain near-miss", mod.isNativeStringIntersectionUnion({ label: "s" }), false);
+check(
+  "genuine Number wrapper intersection pruned",
+  mod.isNativeNumberIntersectionUnion(Object.assign(new Number(1), { label: "n" })),
+  false,
+);
+check("genuine Number wrapper union other arm", mod.isNativeNumberIntersectionUnion({ nativeNumberOk: true }), true);
+check("genuine Number wrapper plain near-miss", mod.isNativeNumberIntersectionUnion({ label: "n" }), false);
+
+check("impossible union other arm", mod.isImpossibleUnion({ ok: true }), true);
+check("impossible union primitive", mod.isImpossibleUnion("x"), false);
+check("impossible union object", mod.isImpossibleUnion({ data: 1 }), false);
+
+console.log("RAN " + ran + " CASES");
+if (failures.length !== 0) {
+  throw new Error("MISMATCHES:\n" + failures.join("\n"));
+}
+`