typia 13.1.0 → 13.1.19

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

@@ -0,0 +1,219 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "testing"
+)
+
+// TestPlainPruneUnionObjectOvermatchTransform pins prune over mixed unions.
+//
+// PlainPruneProgrammer emits one independent `if` per union member, and the
+// object arm's guard is `IsObject` with `CheckArray:false`, which also matches
+// arrays and native instances. With no `else` the array/native arm AND the
+// object arm both run, so `Object.keys(input)` on a value another arm already
+// owns gets its slots deleted: a typed array throws on `delete input[0]`, a
+// plain array collapses to holes, and a native's own properties are stripped.
+// clone/classify resolve the same unions with a mutually exclusive ladder, so
+// the object arm is only reached when the value is a plain object. This test
+// drives every native kind unioned with an object in both orders, plus an
+// object∪tuple, and requires the native/array/tuple value to survive intact.
+//
+//  1. Transform prune factories over native|object, object|native, array|object
+//     and object|tuple unions.
+//  2. Execute prune against a typed array, Date, Map, Set, RegExp, plain array,
+//     and tuple, requiring each to keep its identity and own state.
+//  3. Require the object arm still prunes an ordinary object member.
+func TestPlainPruneUnionObjectOvermatchTransform(t *testing.T) {
+  project := plainPruneUnionObjectOvermatchProject(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("prune union/object over-match transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  plainPruneUnionObjectOvermatchRunRuntimeCases(t, project, out)
+}
+
+func plainPruneUnionObjectOvermatchProject(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, "plain-prune-union-object-")
+  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(plainPruneUnionObjectOvermatchTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(plainPruneUnionObjectOvermatchSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func plainPruneUnionObjectOvermatchRunRuntimeCases(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(plainPruneUnionObjectOvermatchRuntimeRunner), 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("prune union/object over-match runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const plainPruneUnionObjectOvermatchTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const plainPruneUnionObjectOvermatchSource = `import typia from "typia";
+
+interface IBox {
+  x: number;
+}
+interface IElem {
+  y: number;
+}
+
+export const pruneBytesFirst = typia.plain.createPrune<Uint8Array | IBox>();
+export const pruneBytesLast = typia.plain.createPrune<IBox | Uint8Array>();
+export const pruneDateFirst = typia.plain.createPrune<Date | IBox>();
+export const pruneDateLast = typia.plain.createPrune<IBox | Date>();
+export const pruneMap = typia.plain.createPrune<Map<string, number> | IBox>();
+export const pruneSet = typia.plain.createPrune<IBox | Set<number>>();
+export const pruneRegExp = typia.plain.createPrune<RegExp | IBox>();
+export const pruneArray = typia.plain.createPrune<IElem[] | IBox>();
+export const pruneTuple = typia.plain.createPrune<IBox | [IElem, IElem]>();
+`
+
+const plainPruneUnionObjectOvermatchRuntimeRunner = `const mod = require("./main.cjs");
+
+const fail = (label, detail) => {
+  throw new Error(label + ": " + detail);
+};
+
+// 1. A typed array must survive prune untouched (the buggy object arm throws
+//    "Cannot delete property '0'" while deleting its integer-indexed slots).
+for (const [label, prune] of [
+  ["Uint8Array | IBox", mod.pruneBytesFirst],
+  ["IBox | Uint8Array", mod.pruneBytesLast],
+]) {
+  const bytes = new Uint8Array([1, 2, 3]);
+  prune(bytes);
+  if (!(bytes instanceof Uint8Array) || bytes.length !== 3 || bytes[0] !== 1 || bytes[1] !== 2 || bytes[2] !== 3)
+    fail(label, "typed array corrupted -> " + JSON.stringify(Array.from(bytes)));
+}
+
+// 2. A Date must keep its time and its own state; the object arm strips own keys.
+for (const [label, prune] of [
+  ["Date | IBox", mod.pruneDateFirst],
+  ["IBox | Date", mod.pruneDateLast],
+]) {
+  const date = new Date(1000);
+  date.tag = "keep";
+  prune(date);
+  if (!(date instanceof Date) || date.getTime() !== 1000)
+    fail(label, "Date time corrupted -> " + date.getTime());
+  if (date.tag !== "keep")
+    fail(label, "Date own property stripped");
+}
+
+// 3. A Map / Set must keep their contents and own state.
+{
+  const map = new Map([["a", 1]]);
+  map.tag = "keep";
+  mod.pruneMap(map);
+  if (!(map instanceof Map) || map.size !== 1 || map.get("a") !== 1 || map.tag !== "keep")
+    fail("Map<string,number> | IBox", "Map corrupted");
+}
+{
+  const set = new Set([7]);
+  set.tag = "keep";
+  mod.pruneSet(set);
+  if (!(set instanceof Set) || set.size !== 1 || set.has(7) === false || set.tag !== "keep")
+    fail("IBox | Set<number>", "Set corrupted");
+}
+
+// 4. A RegExp with equal source but its own state must survive.
+{
+  const re = /abc/gi;
+  re.tag = "keep";
+  mod.pruneRegExp(re);
+  if (!(re instanceof RegExp) || re.source !== "abc" || re.flags !== "gi" || re.tag !== "keep")
+    fail("RegExp | IBox", "RegExp corrupted");
+}
+
+// 5. A plain array must be pruned element-by-element, not deleted to holes.
+{
+  const arr = [{ y: 1, extra: 2 }, { y: 3, extra: 4 }];
+  mod.pruneArray(arr);
+  if (!Array.isArray(arr) || arr.length !== 2)
+    fail("IElem[] | IBox", "array shape corrupted -> " + JSON.stringify(arr));
+  if (arr[0] === undefined || arr[1] === undefined)
+    fail("IElem[] | IBox", "array slot deleted -> " + JSON.stringify(arr));
+  if (arr[0].y !== 1 || arr[1].y !== 3 || "extra" in arr[0] || "extra" in arr[1])
+    fail("IElem[] | IBox", "array elements not pruned as objects -> " + JSON.stringify(arr));
+}
+
+// 6. An object∪tuple must prune the tuple positionally, not delete its slots.
+{
+  const tuple = [{ y: 1, extra: 2 }, { y: 3, extra: 4 }];
+  mod.pruneTuple(tuple);
+  if (!Array.isArray(tuple) || tuple.length !== 2 || tuple[0] === undefined || tuple[1] === undefined)
+    fail("IBox | [IElem, IElem]", "tuple slot deleted -> " + JSON.stringify(tuple));
+  if (tuple[0].y !== 1 || tuple[1].y !== 3 || "extra" in tuple[0] || "extra" in tuple[1])
+    fail("IBox | [IElem, IElem]", "tuple elements not pruned -> " + JSON.stringify(tuple));
+}
+
+// 7. The object arm must still prune an ordinary object member (nothing lost).
+{
+  const box = { x: 1, junk: "drop" };
+  mod.pruneBytesFirst(box);
+  if (box.x !== 1 || "junk" in box)
+    fail("Uint8Array | IBox", "object member not pruned -> " + JSON.stringify(box));
+}
+`

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

@@ -0,0 +1,181 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// pluginOptionsPayloadCase is one row of the #1887 regression matrix: a project
+// whose tsconfig the user wrote a particular way, the payload ttsc resolves that
+// tsconfig into and hands the plugin, and whether typia's `functional` option is
+// on as a result.
+//
+// `functional` is the probe because its effect is visible in the transform's own
+// output: with the option on, a function-typed property becomes significant and
+// the emitted validator checks it; with the option off, the property is skipped.
+type pluginOptionsPayloadCase struct {
+  name string
+  // base is a base tsconfig the leaf `extends`, or "" for a single-file project.
+  base string
+  // leafPlugins is the `compilerOptions.plugins` text of the leaf tsconfig, or
+  // "" when the leaf declares no plugins at all.
+  leafPlugins string
+  // payload is the `--plugins-json` manifest ttsc sends for this project.
+  payload string
+  // functional is whether the emitted validator must check the function-typed
+  // property.
+  functional bool
+}
+
+// pluginOptionsPayloadCases returns the matrix every host must satisfy.
+//
+// Each row pairs the tsconfig the user wrote with the payload the host resolves
+// it into, so the oracle is ttsc's plugin contract rather than typia's current
+// output. The rows are the reproduction table of samchon/typia#1887: the
+// comment and sibling-entry rows prove typia no longer matches option names
+// against raw tsconfig text, and the `extends` row proves it no longer ignores
+// the entry that loaded it.
+func pluginOptionsPayloadCases() []pluginOptionsPayloadCase {
+  return []pluginOptionsPayloadCase{
+    {
+      // The documented shape, and the only one the old scrape read correctly.
+      // Pins behavior that must not change.
+      name:        "option inline on typia's entry",
+      leafPlugins: `[{ "transform": "typia/lib/transform", "functional": true }]`,
+      payload:     `[{"config":{"transform":"typia/lib/transform","functional":true},"name":"typia","stage":"transform"}]`,
+      functional:  true,
+    },
+    {
+      // The user disabled the option. tsconfig is JSONC, so the host drops the
+      // comment and typia's entry carries nothing.
+      name: "option commented out with a line comment",
+      leafPlugins: `[{
+        "transform": "typia/lib/transform"
+        // "functional": true
+      }]`,
+      payload:    `[{"config":{"transform":"typia/lib/transform"},"name":"typia","stage":"transform"}]`,
+      functional: false,
+    },
+    {
+      name: "option commented out with a block comment",
+      leafPlugins: `[{
+        "transform": "typia/lib/transform"
+        /* "functional": true */
+      }]`,
+      payload:    `[{"config":{"transform":"typia/lib/transform"},"name":"typia","stage":"transform"}]`,
+      functional: false,
+    },
+    {
+      // A transform host carries every transform-stage plugin's entry. The
+      // option belongs to the sibling, and reading it would be reading someone
+      // else's configuration.
+      name: "option owned by another plugin's entry",
+      leafPlugins: `[
+        { "transform": "other/lib/transform", "functional": true },
+        { "transform": "typia/lib/transform" }
+      ]`,
+      payload: `[
+        {"config":{"transform":"other/lib/transform","functional":true},"name":"other","stage":"transform"},
+        {"config":{"transform":"typia/lib/transform"},"name":"typia","stage":"transform"}
+      ]`,
+      functional: false,
+    },
+    {
+      // The standard monorepo layout: a shared base declares the plugin and its
+      // options, the leaf only extends it. The host resolved the chain and sent
+      // the merged entry -- which is why the plugin is running at all.
+      name: "option declared in a base tsconfig the leaf extends",
+      base: `{
+  "compilerOptions": {
+    "plugins": [{ "transform": "typia/lib/transform", "functional": true }]
+  }
+}
+`,
+      payload:    `[{"config":{"transform":"typia/lib/transform","functional":true},"name":"typia","stage":"transform"}]`,
+      functional: true,
+    },
+  }
+}
+
+// pluginOptionsPayloadProject materializes one matrix row as a real project: the
+// tsconfig exactly as the user wrote it (comments, sibling entries, `extends`
+// chain and all), a typia stub to resolve the import against, and a source file
+// with a function-typed property for the option to act on.
+func pluginOptionsPayloadProject(t *testing.T, tc pluginOptionsPayloadCase) string {
+  t.Helper()
+  project := t.TempDir()
+  src := filepath.Join(project, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+
+  extends := ""
+  if tc.base != "" {
+    if err := os.WriteFile(filepath.Join(project, "tsconfig.base.json"), []byte(tc.base), 0o644); err != nil {
+      t.Fatalf("write base tsconfig: %v", err)
+    }
+    extends = `"extends": "./tsconfig.base.json",
+  `
+  }
+  plugins := ""
+  if tc.leafPlugins != "" {
+    plugins = `,
+    "plugins": ` + tc.leafPlugins
+  }
+  config := `{
+  ` + extends + `"compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "rootDir": "src",
+    "outDir": "dist"` + plugins + `
+  },
+  "include": ["src"]
+}
+`
+  if err := os.WriteFile(filepath.Join(project, "tsconfig.json"), []byte(config), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  transformDiagnosticWriteTypiaStub(t, project)
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(pluginOptionsPayloadSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return project
+}
+
+// pluginOptionsPayloadAssert checks one host's output against the row's expected
+// option state.
+func pluginOptionsPayloadAssert(t *testing.T, tc pluginOptionsPayloadCase, output string) {
+  t.Helper()
+  checked := pluginOptionsPayloadFunctionalCheck(output)
+  if checked == tc.functional {
+    return
+  }
+  if tc.functional {
+    t.Fatalf("functional is configured on but the validator skipped the function property:\n%s", output)
+  }
+  t.Fatalf("functional is not configured but the validator checked the function property:\n%s", output)
+}
+
+func pluginOptionsPayloadFunctionalCheck(output string) bool {
+  return strings.Contains(output, pluginOptionsPayloadFunctionalNeedle)
+}
+
+// pluginOptionsPayloadFunctionalNeedle is the guard typia emits for the
+// function-typed property only when `functional` is enabled.
+const pluginOptionsPayloadFunctionalNeedle = `"function" === typeof input.cb`
+
+const pluginOptionsPayloadSource = `import typia from "typia";
+export interface IX {
+  value: number;
+  cb: () => void;
+}
+export const check = (input: unknown): boolean => typia.is<IX>(input);
+`

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

@@ -0,0 +1,278 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestPrivateFieldFilterIsTransform verifies an ES `#private` instance field is
+// excluded from a class's validated shape, so a real instance passes its own
+// `is`/`assert`/`validate` guard (#2213).
+//
+// A `#private` field is installed only by the constructor and is unreachable via
+// index access, so it is not part of a type's structural, externally-observable
+// shape. Before the fix the member filter excluded only the TypeScript keyword
+// `private`/`protected` members, so a `#private` field leaked into the validated
+// shape as a mangled key (`input["�#1@#secret"]`) that no runtime object
+// carries — making the guard unconditionally false.
+//
+//  1. Emit `is`/`assert`/`validate` for a class carrying a `#private` field
+//     alongside a public property, a subclass that adds another `#private`, an
+//     all-`#private` class, a class with `#private` method / accessor members,
+//     and a keyword `private`/`protected` class.
+//  2. Assert the emitted validators never reference a mangled `#private` key.
+//  3. Execute the validators against real instances and plain public-shape
+//     objects, proving each passes on its public shape.
+func TestPrivateFieldFilterIsTransform(t *testing.T) {
+  project := privateFieldFilterProject(t)
+
+  ts := privateFieldFilterTransform(t, project, "ts")
+  // A `#private` member surfaces in a validator only as a mangled key —
+  // `input["�#1@#secret"]`. The class SOURCE (echoed above the validators)
+  // also spells `#secret`, so the bare name is not a defect marker; the `@#`
+  // infix is unique to the mangled key and never appears in class source, so it
+  // is the exact byte signature of the leak.
+  if strings.Contains(ts, "@#") {
+    t.Fatalf("emit references a mangled #private key (leaked into validated shape):\n%s", ts)
+  }
+  // The public shape must still be validated.
+  for _, needle := range []string{"input.label", "input.tag"} {
+    if !strings.Contains(ts, needle) {
+      t.Fatalf("emit dropped a public property %q:\n%s", needle, ts)
+    }
+  }
+
+  privateFieldFilterRunRuntimeCases(
+    t,
+    project,
+    privateFieldFilterTransform(t, project, "js"),
+  )
+}
+
+func privateFieldFilterProject(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, "private-field-filter-")
+  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(privateFieldFilterTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(privateFieldFilterSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func privateFieldFilterTransform(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("private field filter transform failed: output=%s code=%d stderr=\n%s", output, code, errText)
+  }
+  return out
+}
+
+func privateFieldFilterRunRuntimeCases(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(privateFieldFilterRuntimeRunner), 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("private field filter runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const privateFieldFilterTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const privateFieldFilterSource = `import typia from "typia";
+
+export class Box {
+  #secret: boolean;
+  public label: string;
+  constructor(label: string, secret: boolean) {
+    this.label = label;
+    this.#secret = secret;
+  }
+}
+
+export class SubBox extends Box {
+  #extra: number;
+  public tag: string;
+  constructor() {
+    super("hi", true);
+    this.#extra = 1;
+    this.tag = "t";
+  }
+}
+
+export class SoloPrivate {
+  #solo: string;
+  constructor() {
+    this.#solo = "x";
+  }
+}
+
+export class MethodPrivate {
+  public label: string;
+  #hidden(): number {
+    return 1;
+  }
+  get #view(): number {
+    return 2;
+  }
+  set #view(_next: number) {}
+  constructor(label: string) {
+    this.label = label;
+    void this.#hidden();
+    this.#view = this.#view;
+  }
+}
+
+export class KeywordBox {
+  private secret: boolean;
+  protected token: string;
+  public label: string;
+  constructor(label: string, secret: boolean, token: string) {
+    this.label = label;
+    this.secret = secret;
+    this.token = token;
+  }
+}
+
+export const isBox = typia.createIs<Box>();
+export const assertBox = typia.createAssert<Box>();
+export const validateBox = typia.createValidate<Box>();
+export const isSubBox = typia.createIs<SubBox>();
+export const isSolo = typia.createIs<SoloPrivate>();
+export const isMethod = typia.createIs<MethodPrivate>();
+export const isKeyword = typia.createIs<KeywordBox>();
+`
+
+const privateFieldFilterRuntimeRunner = `const mod = require("./main.cjs");
+
+class Box {
+  #secret;
+  label;
+  constructor(label, secret) {
+    this.label = label;
+    this.#secret = secret;
+  }
+}
+class SubBox extends Box {
+  #extra;
+  tag;
+  constructor() {
+    super("hi", true);
+    this.#extra = 1;
+    this.tag = "t";
+  }
+}
+class SoloPrivate {
+  #solo;
+  constructor() {
+    this.#solo = "x";
+  }
+}
+class MethodPrivate {
+  label;
+  #hidden() {
+    return 1;
+  }
+  get #view() {
+    return 2;
+  }
+  set #view(_next) {}
+  constructor(label) {
+    this.label = label;
+  }
+}
+
+const expect = (label, actual, expected) => {
+  if (actual !== expected) {
+    throw new Error(label + ": expected " + expected + " but got " + actual);
+  }
+};
+
+// A real instance carrying #private members passes its own guard.
+expect("is real Box instance", mod.isBox(new Box("hi", true)), true);
+expect("is real SubBox instance", mod.isSubBox(new SubBox()), true);
+expect("is real SoloPrivate instance", mod.isSolo(new SoloPrivate()), true);
+expect("is real MethodPrivate instance", mod.isMethod(new MethodPrivate("hi")), true);
+
+// The #private field is not part of the structural shape: a plain object with
+// only the public members is accepted, exactly like a keyword-private class.
+expect("is plain public Box shape", mod.isBox({ label: "hi" }), true);
+expect("is plain public SubBox shape", mod.isSubBox({ label: "hi", tag: "t" }), true);
+expect("is empty SoloPrivate shape", mod.isSolo({}), true);
+expect("is plain public MethodPrivate shape", mod.isMethod({ label: "hi" }), true);
+expect("is plain public KeywordBox shape", mod.isKeyword({ label: "hi" }), true);
+
+// The public shape is still validated structurally.
+expect("reject wrong public label type", mod.isBox({ label: 123 }), false);
+expect("reject missing public label", mod.isBox({}), false);
+
+// assert / validate accept a real instance without touching a mangled key.
+expect("assert real Box returns input", mod.assertBox(new Box("hi", true)) instanceof Box, true);
+expect("validate real Box succeeds", mod.validateBox(new Box("hi", true)).success, true);
+expect("validate plain public Box succeeds", mod.validateBox({ label: "hi" }).success, true);
+
+let threw = false;
+try {
+  mod.assertBox({ label: 123 });
+} catch (_exp) {
+  threw = true;
+}
+expect("assert rejects wrong public label", threw, true);
+`