typia 13.1.1 → 13.2.0

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

@@ -0,0 +1,309 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestNotationUnicodeKeyTransform verifies the notation emit keeps a non-ASCII
+// key intact and agrees with the runtime helper.
+//
+// Issue #2227: the emit computed each renamed key by slicing one *byte*
+// (`value[:1]`) before case-converting it, so a multi-byte rune's lead byte was
+// handed to the case operation on its own, could not be decoded, and came back
+// as U+FFFD — `typia.notations.createPascal<{ "École": number }>()` emitted the
+// key `"��cole"`. The static path corrupted the key while the dynamic
+// (index-signature) path, which calls the runtime `_notationPascal`, did not, so
+// one object could carry two different renamings of the same character and the
+// emitted key did not match its declared `CamelCase<T>` / `PascalCase<T>` type.
+//
+// The same fix covers the second half of the divergence: JavaScript performs
+// Unicode *full* case conversion while Go's `strings.ToUpper`/`ToLower` perform
+// the *simple* per-rune mapping, so the emit also disagreed with the runtime on
+// `ß` -> `SS`, `İ` -> `i` + U+0307, and the word-final sigma `ΑΣ` -> `ας`. That
+// half reached `snake`/`kebab` too, which never sliced a byte.
+//
+// Every key and every expectation below is written with `\uXXXX` escapes so the
+// fixture cannot be silently renormalized (NFC/NFD) by an editor, and so the
+// combining-mark and surrogate-pair cases stay exactly what they claim to be.
+//
+//  1. Transform a fixture whose keys cover a multi-byte first character, a
+//     multi-byte character right after an underscore, a key that is a single
+//     multi-byte character, a combining mark (NFD), a surrogate pair, and the
+//     case-folding-sensitive `İ`, `ß`, and word-final sigma — plus two ASCII
+//     keys as a regression anchor.
+//  2. Require the emitted JavaScript to carry no U+FFFD at all.
+//  3. Execute each statically emitted converter and assert its key-to-value map
+//     equals the expectation derived from JavaScript's own case semantics.
+//  4. Execute the dynamic `Record` converter, which routes through the runtime
+//     `_notation*` helper, over the same keys and require an identical map, so
+//     the compile-time emit and the runtime helper are proven equal per key.
+func TestNotationUnicodeKeyTransform(t *testing.T) {
+  project := notationUnicodeKeyProject(t)
+  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("unicode notation transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  // The printer escapes every non-ASCII code unit, so a corrupted key reaches
+  // the output as the escape text rather than as the replacement rune itself.
+  // Both forms are rejected; checking only the rune would never fire.
+  if strings.Contains(out, `\uFFFD`) || strings.ContainsRune(out, '�') {
+    t.Fatalf("emitted converter must not contain U+FFFD; a key was corrupted by byte slicing:\n%s", out)
+  }
+  // Pin the exact emitted assignments for the witnesses of each half of the
+  // defect: the multi-byte first character and the post-underscore segment that
+  // byte slicing destroyed, plus the two characters that the simple per-rune
+  // case mapping got wrong. The printer escapes every non-ASCII code unit, so
+  // these are the literal bytes of the emitted JavaScript.
+  for _, assignment := range []string{
+    `["\u00E9cole"]: input["\u00C9cole"]`,
+    `["Key\u00D6lig"]: input["key_\u00D6lig"]`,
+    `["SS"]: input["\u00DF"]`,
+    `["i\u0307stanbul"]: input["\u0130stanbul"]`,
+  } {
+    if !strings.Contains(out, assignment) {
+      t.Fatalf("emitted converter should contain the assignment %s:\n%s", assignment, out)
+    }
+  }
+  notationUnicodeKeyRunRuntimeCases(t, project, out)
+}
+
+func notationUnicodeKeyProject(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, "notation-unicode-")
+  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(notationUnicodeKeyTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(notationUnicodeKeySource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func notationUnicodeKeyRunRuntimeCases(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(notationUnicodeKeyRuntimeRunner), 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("unicode notation runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const notationUnicodeKeyTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const notationUnicodeKeySource = `import typia from "typia";
+
+interface SourceRecord {
+  "\u00C9cole": number;
+  "\u00F6lwert": number;
+  "\u65E5\u672C\u8A9E": number;
+  "key_\u00D6lig": number;
+  "\u00D6": number;
+  "\u0130stanbul": number;
+  "\u00DF": number;
+  "\uD801\uDC28test": number;
+  "\u0391\u03A3_\u0391\u03A3": number;
+  "e\u0301cole": number;
+  "\u00FCber_Stra\u00DFe": number;
+  MAX_COUNT: number;
+  fooBar: number;
+}
+
+type DynamicRecord = Record<string, number>;
+
+export const toCamel = typia.notations.createCamel<SourceRecord>();
+export const toPascal = typia.notations.createPascal<SourceRecord>();
+export const toSnake = typia.notations.createSnake<SourceRecord>();
+export const toKebab = typia.notations.createKebab<SourceRecord>();
+
+export const toCamelDynamic = typia.notations.createCamel<DynamicRecord>();
+export const toPascalDynamic = typia.notations.createPascal<DynamicRecord>();
+export const toSnakeDynamic = typia.notations.createSnake<DynamicRecord>();
+export const toKebabDynamic = typia.notations.createKebab<DynamicRecord>();
+`
+
+const notationUnicodeKeyRuntimeRunner = `const mod = require("./main.cjs");
+
+// Every source key carries a distinct value, so comparing the whole
+// key-to-value map proves the per-key renaming rather than just the key set.
+const input = {
+  ["\u00C9cole"]: 1,
+  ["\u00F6lwert"]: 2,
+  ["\u65E5\u672C\u8A9E"]: 3,
+  ["key_\u00D6lig"]: 4,
+  ["\u00D6"]: 5,
+  ["\u0130stanbul"]: 6,
+  ["\u00DF"]: 7,
+  ["\uD801\uDC28test"]: 8,
+  ["\u0391\u03A3_\u0391\u03A3"]: 9,
+  ["e\u0301cole"]: 10,
+  ["\u00FCber_Stra\u00DFe"]: 11,
+  ["MAX_COUNT"]: 12,
+  ["fooBar"]: 13,
+};
+
+// Expectations are JavaScript's own case semantics, not a snapshot of the Go
+// emit: full case conversion (ß -> SS, İ -> i + U+0307, word-final
+// sigma ΑΣ -> ας) and UTF-16 code-unit indexing, under which
+// str[0] of an astral character is an uncased lone surrogate and stays put.
+const expected = {
+  camel: {
+    ["\u00E9cole"]: 1,
+    ["\u00F6lwert"]: 2,
+    ["\u65E5\u672C\u8A9E"]: 3,
+    ["key\u00D6lig"]: 4,
+    ["\u00F6"]: 5,
+    ["i\u0307stanbul"]: 6,
+    ["\u00DF"]: 7,
+    ["\uD801\uDC28test"]: 8,
+    ["\u03B1\u03C2\u0391\u03C3"]: 9,
+    ["e\u0301cole"]: 10,
+    ["\u00FCberStra\u00DFe"]: 11,
+    ["maxCount"]: 12,
+    ["fooBar"]: 13,
+  },
+  pascal: {
+    ["\u00C9cole"]: 1,
+    ["\u00D6lwert"]: 2,
+    ["\u65E5\u672C\u8A9E"]: 3,
+    ["Key\u00D6lig"]: 4,
+    ["\u00D6"]: 5,
+    ["\u0130stanbul"]: 6,
+    ["SS"]: 7,
+    ["\uD801\uDC28test"]: 8,
+    ["\u0391\u03C3\u0391\u03C3"]: 9,
+    ["E\u0301cole"]: 10,
+    ["\u00DCberStra\u00DFe"]: 11,
+    ["MaxCount"]: 12,
+    ["FooBar"]: 13,
+  },
+  snake: {
+    ["\u00E9cole"]: 1,
+    ["\u00F6lwert"]: 2,
+    ["\u65E5\u672C\u8A9E"]: 3,
+    ["key_\u00F6lig"]: 4,
+    ["\u00F6"]: 5,
+    ["i\u0307stanbul"]: 6,
+    ["\u00DF"]: 7,
+    ["\uD801\uDC28test"]: 8,
+    ["\u03B1\u03C2_\u03B1\u03C2"]: 9,
+    ["e\u0301cole"]: 10,
+    ["\u00FCber_stra\u00DFe"]: 11,
+    ["max_count"]: 12,
+    ["foo_bar"]: 13,
+  },
+  kebab: {
+    ["\u00E9cole"]: 1,
+    ["\u00F6lwert"]: 2,
+    ["\u65E5\u672C\u8A9E"]: 3,
+    ["key-\u00F6lig"]: 4,
+    ["\u00F6"]: 5,
+    ["i\u0307stanbul"]: 6,
+    ["\u00DF"]: 7,
+    ["\uD801\uDC28test"]: 8,
+    ["\u03B1\u03C2-\u03B1\u03C2"]: 9,
+    ["e\u0301cole"]: 10,
+    ["\u00FCber-stra\u00DFe"]: 11,
+    ["max-count"]: 12,
+    ["foo-bar"]: 13,
+  },
+};
+
+const normalize = (object) =>
+  JSON.stringify(
+    Object.entries(object)
+      .map(([key, value]) => [Array.from(key, (c) => c.charCodeAt(0)), value])
+      .sort((a, b) => (String(a) < String(b) ? -1 : 1)),
+  );
+
+const notations = ["camel", "pascal", "snake", "kebab"];
+const capitalize = (name) => name[0].toUpperCase() + name.substring(1);
+
+for (const notation of notations) {
+  const want = normalize(expected[notation]);
+
+  // The statically emitted converter: one property assignment per known key.
+  const staticResult = mod["to" + capitalize(notation)](input);
+  if (normalize(staticResult) !== want) {
+    throw new Error(
+      "static " + notation + " emit disagreed with JavaScript case semantics:\n" +
+        "  expected " + want + "\n" +
+        "  actual   " + normalize(staticResult),
+    );
+  }
+
+  // The dynamic converter: one runtime _notation* call per index-signature key.
+  const dynamicResult = mod["to" + capitalize(notation) + "Dynamic"](input);
+  if (normalize(dynamicResult) !== normalize(staticResult)) {
+    throw new Error(
+      "static " + notation + " emit disagreed with the runtime helper:\n" +
+        "  runtime " + normalize(dynamicResult) + "\n" +
+        "  emit    " + normalize(staticResult),
+    );
+  }
+
+  for (const key of Object.keys(staticResult)) {
+    if (key.includes("�")) {
+      throw new Error(
+        "renamed " + notation + " key contains U+FFFD: " + JSON.stringify(key),
+      );
+    }
+  }
+}
+`

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

@@ -0,0 +1,293 @@
+package main
+
+import (
+  "fmt"
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestPackageDeclarationNativeIdentityIsTransform pins runtime-native identity
+// across ordinary package declarations and the genuine global controls (#2239).
+//
+// A declaration file is a normal published TypeScript package surface, so its
+// source form cannot by itself establish that a Date/Map/Set/WeakMap symbol is
+// the JavaScript native. The package types below are checker-equivalent to local
+// structural controls and must keep their own members. Conversely, real global
+// Date/Map/Set/WeakMap/WeakSet and Node-provided File/Blob types must retain
+// their native checks.
+//
+//  1. Publish colliding structural declarations through a fixture package's
+//     index.d.ts and transform validators for them plus local controls.
+//  2. Transform genuine global validators with DOM libraries excluded, making
+//     File and Blob come from the installed @types/node declaration package.
+//  3. Inspect the emitted classification and execute all validators in Node,
+//     requiring an exact case count so an omitted branch cannot pass silently.
+func TestPackageDeclarationNativeIdentityIsTransform(t *testing.T) {
+  project := packageDeclarationNativeIdentityProject(t)
+  transform := func(file string) string {
+    t.Helper()
+    out, errText, code := ttscTypiaTestCapture(func() int {
+      return runTransform([]string{
+        "--cwd", project,
+        "--tsconfig", "tsconfig.json",
+        "--file", file,
+        "--output", "js",
+      })
+    })
+    if code != 0 {
+      t.Fatalf("package declaration native identity transform %s failed: code=%d stderr=\n%s", file, code, errText)
+    }
+    return out
+  }
+
+  packageJS := transform("src/package.ts")
+  nativeJS := transform("src/native.ts")
+  failures := []string{}
+  for _, member := range []string{"stamp", "brandMap", "brandSet", "brandWeakMap"} {
+    if !strings.Contains(packageJS, member) {
+      failures = append(failures, fmt.Sprintf("package declaration member %q was dropped", member))
+    }
+  }
+  for _, gone := range []string{"instanceof Date", "instanceof Map", "instanceof Set", "instanceof WeakMap"} {
+    if strings.Contains(packageJS, gone) {
+      failures = append(failures, fmt.Sprintf("package declaration collision kept %q", gone))
+    }
+  }
+  for _, kept := range []string{
+    "instanceof Date",
+    "instanceof Map",
+    "instanceof Set",
+    "instanceof WeakMap",
+    "instanceof WeakSet",
+    "instanceof File",
+    "instanceof Blob",
+  } {
+    if !strings.Contains(nativeJS, kept) {
+      failures = append(failures, fmt.Sprintf("genuine native path %q was dropped", kept))
+    }
+  }
+  output, runtimeErr := packageDeclarationNativeIdentityRun(t, project, packageJS, nativeJS)
+  if runtimeErr != nil {
+    failures = append(failures, fmt.Sprintf("runtime matrix failed: %v\n%s", runtimeErr, output))
+  }
+  const expected = "RAN 30 CASES"
+  if !strings.Contains(output, expected) {
+    failures = append(failures, fmt.Sprintf("runtime runner did not report %q; got:\n%s", expected, output))
+  }
+  if len(failures) != 0 {
+    t.Fatalf("package declaration native identity mismatches:\n%s\n\npackage emit:\n%s\n\nnative emit:\n%s", strings.Join(failures, "\n"), packageJS, nativeJS)
+  }
+}
+
+func packageDeclarationNativeIdentityProject(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, "package-declaration-native-identity-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() {
+    _ = os.RemoveAll(dir)
+  })
+
+  src := filepath.Join(dir, "src")
+  dependency := filepath.Join(dir, "node_modules", "native-name-package")
+  for _, path := range []string{src, dependency} {
+    if err := os.MkdirAll(path, 0o755); err != nil {
+      t.Fatalf("mkdir fixture path %s: %v", path, err)
+    }
+  }
+  files := map[string]string{
+    filepath.Join(dir, "tsconfig.json"):       packageDeclarationNativeIdentityTSConfig,
+    filepath.Join(dependency, "package.json"): packageDeclarationNativeIdentityPackageJSON,
+    filepath.Join(dependency, "index.d.ts"):   packageDeclarationNativeIdentityDeclarations,
+    filepath.Join(src, "package.ts"):          packageDeclarationNativeIdentitySource,
+    filepath.Join(src, "native.ts"):           packageDeclarationNativeIdentityNativeSource,
+  }
+  for path, content := range files {
+    if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+      t.Fatalf("write fixture file %s: %v", path, err)
+    }
+  }
+  return dir
+}
+
+func packageDeclarationNativeIdentityRun(t *testing.T, project string, packageJS string, nativeJS 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)
+  modules := map[string]string{
+    "package.cjs": ttscTypiaTestRewriteCommonJS(t, packageJS),
+    "native.cjs":  ttscTypiaTestRewriteCommonJS(t, nativeJS),
+    "run.cjs":     packageDeclarationNativeIdentityRuntimeRunner,
+  }
+  for name, content := range modules {
+    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 packageDeclarationNativeIdentityTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "lib": ["ES2022"],
+    "types": ["node"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const packageDeclarationNativeIdentityPackageJSON = `{
+  "name": "native-name-package",
+  "version": "1.0.0",
+  "types": "index.d.ts"
+}
+`
+
+const packageDeclarationNativeIdentityDeclarations = `export interface Date {
+  stamp: number;
+}
+export interface Map<K, V> {
+  brandMap: K;
+  valueMap: V;
+}
+export interface Set<T> {
+  brandSet: T;
+}
+export interface WeakMap<K extends object, V> {
+  brandWeakMap: K;
+  valueWeakMap: V;
+}
+`
+
+const packageDeclarationNativeIdentitySource = `import typia from "typia";
+import type {
+  Date as PackageDate,
+  Map as PackageMap,
+  Set as PackageSet,
+  WeakMap as PackageWeakMap,
+} from "native-name-package";
+
+interface LocalDate {
+  stamp: number;
+}
+interface LocalMap<K, V> {
+  brandMap: K;
+  valueMap: V;
+}
+interface LocalSet<T> {
+  brandSet: T;
+}
+interface LocalWeakMap<K extends object, V> {
+  brandWeakMap: K;
+  valueWeakMap: V;
+}
+
+type Assert<T extends true> = T;
+type Same<X, Y> = [X] extends [Y]
+  ? [Y] extends [X]
+    ? true
+    : false
+  : false;
+type _PackageDateIsLocal = Assert<Same<PackageDate, LocalDate>>;
+type _PackageMapIsLocal = Assert<Same<PackageMap<string, number>, LocalMap<string, number>>>;
+type _PackageSetIsLocal = Assert<Same<PackageSet<string>, LocalSet<string>>>;
+type _PackageWeakMapIsLocal = Assert<Same<PackageWeakMap<object, string>, LocalWeakMap<object, string>>>;
+
+export const isPackageDate = typia.createIs<PackageDate>();
+export const isPackageMap = typia.createIs<PackageMap<string, number>>();
+export const isPackageSet = typia.createIs<PackageSet<string>>();
+export const isPackageWeakMap = typia.createIs<PackageWeakMap<object, string>>();
+export const isLocalDate = typia.createIs<LocalDate>();
+export const isLocalMap = typia.createIs<LocalMap<string, number>>();
+export const isLocalSet = typia.createIs<LocalSet<string>>();
+export const isLocalWeakMap = typia.createIs<LocalWeakMap<object, string>>();
+`
+
+const packageDeclarationNativeIdentityNativeSource = `import typia from "typia";
+
+export const isNativeDate = typia.createIs<Date>();
+export const isNativeMap = typia.createIs<Map<string, number>>();
+export const isNativeSet = typia.createIs<Set<string>>();
+export const isNativeWeakMap = typia.createIs<WeakMap<object, string>>();
+export const isNativeWeakSet = typia.createIs<WeakSet<object>>();
+export const isNativeFile = typia.createIs<File>();
+export const isNativeBlob = typia.createIs<Blob>();
+`
+
+const packageDeclarationNativeIdentityRuntimeRunner = `const packageTypes = require("./package.cjs");
+const natives = require("./native.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("package Date valid", packageTypes.isPackageDate({ stamp: 1 }), true);
+eq("package Date invalid", packageTypes.isPackageDate({}), false);
+eq("package Date rejects native", packageTypes.isPackageDate(new Date()), false);
+eq("package Map valid", packageTypes.isPackageMap({ brandMap: "x", valueMap: 1 }), true);
+eq("package Map invalid", packageTypes.isPackageMap({ brandMap: "x" }), false);
+eq("package Map rejects native", packageTypes.isPackageMap(new Map([["x", 1]])), false);
+eq("package Set valid", packageTypes.isPackageSet({ brandSet: "x" }), true);
+eq("package Set invalid", packageTypes.isPackageSet({}), false);
+eq("package Set rejects native", packageTypes.isPackageSet(new Set(["x"])), false);
+eq("package WeakMap valid", packageTypes.isPackageWeakMap({ brandWeakMap: {}, valueWeakMap: "x" }), true);
+eq("package WeakMap invalid", packageTypes.isPackageWeakMap({ brandWeakMap: {} }), false);
+eq("package WeakMap rejects native", packageTypes.isPackageWeakMap(new WeakMap()), false);
+
+eq("local Date control", packageTypes.isLocalDate({ stamp: 1 }), true);
+eq("local Map control", packageTypes.isLocalMap({ brandMap: "x", valueMap: 1 }), true);
+eq("local Set control", packageTypes.isLocalSet({ brandSet: "x" }), true);
+eq("local WeakMap control", packageTypes.isLocalWeakMap({ brandWeakMap: {}, valueWeakMap: "x" }), true);
+
+eq("native Date real", natives.isNativeDate(new Date()), true);
+eq("native Date plain", natives.isNativeDate({}), false);
+eq("native Map real", natives.isNativeMap(new Map([["x", 1]])), true);
+eq("native Map plain", natives.isNativeMap({}), false);
+eq("native Set real", natives.isNativeSet(new Set(["x"])), true);
+eq("native Set plain", natives.isNativeSet({}), false);
+eq("native WeakMap real", natives.isNativeWeakMap(new WeakMap()), true);
+eq("native WeakMap plain", natives.isNativeWeakMap({}), false);
+eq("native WeakSet real", natives.isNativeWeakSet(new WeakSet()), true);
+eq("native WeakSet plain", natives.isNativeWeakSet({}), false);
+eq("Node File real", natives.isNativeFile(new File(["x"], "x.txt")), true);
+eq("Node File plain", natives.isNativeFile({ name: "x.txt", size: 1 }), false);
+eq("Node Blob real", natives.isNativeBlob(new Blob(["x"])), true);
+eq("Node Blob plain", natives.isNativeBlob({ size: 1, type: "text/plain" }), false);
+
+console.log("RAN " + ran + " CASES");
+if (failures.length !== 0) {
+  throw new Error("MISMATCHES:\n" + failures.join("\n"));
+}
+`