typia 13.1.1 → 13.2.0

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

@@ -0,0 +1,167 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "regexp"
+  "sort"
+  "strings"
+  "testing"
+)
+
+// TestProtobufDiagnosticCodeTransform verifies that a rejected protobuf call
+// site is named by its own API in the diagnostic code (#2285).
+//
+// `ProtobufFactory.Metadata` used to compose the code as `"typia.protobuf." +
+// props.Method`, while the encode and decode programmers pass the whole call
+// accessor (`ModuloMethodText`, the same text `TypeGuardError.method` carries).
+// Sixteen of the seventeen entry points therefore reported
+// `TS(typia.protobuf.typia.protobuf.encode)`; only `protobuf.message` was
+// correct, because its programmer passed a bare literal. The code is the only
+// machine-readable identity a typia rejection has, so a code that names no API
+// is a silent loss for anyone searching it.
+//
+// The oracle is the fixture source, not another copy of the expected string: a
+// diagnostic code is correct only when the accessor it names is literally the
+// accessor written at a call site in that file. A concatenation defect cannot
+// satisfy that, and neither can a misspelling.
+//
+//  1. Write one fixture that calls every protobuf entry point with `bigint`,
+//     which none of them supports.
+//  2. Transform it and collect every diagnostic code the transform reported.
+//  3. Require each code to be an accessor present in the fixture, and require
+//     every entry point to have been named.
+func TestProtobufDiagnosticCodeTransform(t *testing.T) {
+  methods := []string{
+    "message",
+    "encode",
+    "decode",
+    "assertEncode",
+    "assertDecode",
+    "isEncode",
+    "isDecode",
+    "validateEncode",
+    "validateDecode",
+    "createEncode",
+    "createDecode",
+    "createAssertEncode",
+    "createAssertDecode",
+    "createIsEncode",
+    "createIsDecode",
+    "createValidateEncode",
+    "createValidateDecode",
+  }
+  project, source := protobufDiagnosticCodeProject(t, methods)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+    })
+  })
+  if code == 0 {
+    t.Fatalf("protobuf fixture transformed successfully, want failure:\nstdout=%s\nstderr=%s", out, errText)
+  }
+
+  codes := map[string]bool{}
+  for _, match := range protobufDiagnosticCodePattern.FindAllStringSubmatch(out, -1) {
+    codes[match[1]] = true
+  }
+  if len(codes) == 0 {
+    t.Fatalf("no typia diagnostic code was reported:\nstdout=%s\nstderr=%s", out, errText)
+  }
+
+  unnamed := []string{}
+  for reported := range codes {
+    if !strings.Contains(source, reported+"<") {
+      unnamed = append(unnamed, reported)
+    }
+  }
+  sort.Strings(unnamed)
+  if len(unnamed) != 0 {
+    t.Fatalf(
+      "diagnostic code(s) name no call site in the fixture: %s",
+      strings.Join(unnamed, ", "),
+    )
+  }
+
+  missing := []string{}
+  for _, method := range methods {
+    if !codes["typia.protobuf."+method] {
+      missing = append(missing, method)
+    }
+  }
+  if len(missing) != 0 {
+    t.Fatalf(
+      "no diagnostic named these entry points: %s\nstdout=%s",
+      strings.Join(missing, ", "),
+      out,
+    )
+  }
+}
+
+// The command reports diagnostics as JSON, and `code` is the field ttsc renders
+// as `error TS(<code>)`; reading it here keeps the assertion on the value the
+// transform produced rather than on one renderer's formatting.
+var protobufDiagnosticCodePattern = regexp.MustCompile(`"code":"([^"]+)"`)
+
+func protobufDiagnosticCodeProject(t *testing.T, methods []string) (string, 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, "protobuf-code-")
+  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(protobufDiagnosticCodeTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  lines := []string{`import typia from "typia";`, ""}
+  for _, method := range methods {
+    lines = append(lines, protobufDiagnosticCodeCall(method))
+  }
+  source := strings.Join(lines, "\n") + "\n"
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(source), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir, source
+}
+
+// protobufDiagnosticCodeCall writes the call form each entry point takes: the
+// factories take no value argument, the encoders take the message, and the
+// decoders take the buffer.
+func protobufDiagnosticCodeCall(method string) string {
+  call := "typia.protobuf." + method + "<bigint>"
+  switch {
+  case method == "message" || strings.HasPrefix(method, "create"):
+    return call + "();"
+  case strings.HasSuffix(method, "Decode"):
+    return call + "(new Uint8Array());"
+  default:
+    return call + "(1n as any);"
+  }
+}
+
+const protobufDiagnosticCodeTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`

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

@@ -0,0 +1,98 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProtobufIsEncodeFiniteNumberTransform pins protobuf.isEncode against a bare
+// number leaf so a non-finite value cannot be encoded into the message (#2196).
+//
+// protobuf.isEncode forces Options.Finite on its inner `__is` guard, then emits
+// `__is(input) ? __encode(input) : null`. A protobuf double can hold NaN and
+// Infinity, so the guard is the only thing keeping them out of the wire. While
+// `is` dropped `finite`, that guard accepted NaN and the encoder wrote it; the
+// guard must now carry Number.isFinite on the number leaf. Because isEncode has no
+// separate error-path checker, the guard is the sole place the number leaf's
+// finite check can appear, so its presence in the emit is an unambiguous oracle.
+//
+//  1. Transform a `protobuf.isEncode<{ value: number }>` fixture with default options.
+//  2. Assert the emitted `__is` guards the number leaf with Number.isFinite.
+func TestProtobufIsEncodeFiniteNumberTransform(t *testing.T) {
+  project := protobufIsEncodeFiniteNumberProject(t)
+  js := protobufIsEncodeFiniteNumberTransform(t, project)
+  needle := "Number.isFinite(input.value)"
+  if !strings.Contains(js, needle) {
+    t.Fatalf("protobuf.isEncode did not guard the number leaf with %q:\n%s", needle, js)
+  }
+}
+
+func protobufIsEncodeFiniteNumberProject(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, "protobuf-is-encode-finite-number-")
+  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(protobufIsEncodeFiniteNumberTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(protobufIsEncodeFiniteNumberSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func protobufIsEncodeFiniteNumberTransform(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("protobuf isEncode finite transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  return out
+}
+
+const protobufIsEncodeFiniteNumberTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const protobufIsEncodeFiniteNumberSource = `import typia from "typia";
+
+interface Box {
+  value: number;
+}
+
+export const encode = (input: unknown): Uint8Array | null =>
+  typia.protobuf.isEncode<Box>(input);
+`

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

@@ -14,47 +14,70 @@ import (
 // explicit protobuf field numbers were silently replaced by auto-numbering and
 // duplicate-sequence validation never fired.
 //
+// The two messages live in separate fixtures because a duplicate-sequence
+// diagnostic now withholds the whole file's artifact (samchon/typia#2117), so one
+// combined source could no longer show the valid message's emitted numbers.
+//
 //  1. Transform a message fixture carrying explicit `Sequence<5>` / `Sequence<7>`
 //     field numbers plus an untagged property (auto-numbered after the highest
-//     explicit number).
-//  2. Require the emitted proto message to carry the explicit numbers.
-//  3. Require a message whose two properties share `Sequence<1>` to fail the
-//     transform, leaving the call untransformed.
+//     explicit number), and require the emitted proto message to carry them.
+//  2. Require a message whose two properties share `Sequence<1>` to fail the
+//     transform with a diagnostic naming the duplicate.
+//  3. Require that rejected transform to publish no artifact.
 func TestProtobufSequenceFieldNumbersTransform(t *testing.T) {
-  project := protobufSequenceFieldNumbersProject(t)
-  out, errText, code := ttscTypiaTestCapture(func() int {
-    return runTransform([]string{
-      "--cwd", project,
-      "--tsconfig", "tsconfig.json",
-      "--file", "src/main.ts",
-      "--output", "js",
-    })
-  })
+  out, errText, code := protobufSequenceFieldNumbersTransform(t, "sequenced-", protobufSequenceFieldNumbersSource)
   if code != 0 {
     t.Fatalf("protobuf sequence transform failed: code=%d stderr=\n%s", code, errText)
   }
+  // The subject is the explicit `Sequence<5>` / `Sequence<7>` field numbers and
+  // the auto-numbered `8` after them; the presence label is `optional` because
+  // proto3 has no `required`, and emitting it would make the document reject
+  // under a Protobuf compiler (samchon/typia#2155). Compiler legality itself is
+  // pinned by TestProtobufMessageDocumentCompiles.
   for _, line := range []string{
-    "required string id = 5;",
-    "required double age = 7;",
-    "required bool flag = 8;",
+    "optional string id = 5;",
+    "optional double age = 7;",
+    "optional bool flag = 8;",
   } {
     if !strings.Contains(out, line) {
       t.Fatalf("emitted proto message should contain %q:\n%s", line, out)
     }
   }
-  if !strings.Contains(out, ".protobuf.message()") {
-    t.Fatalf("duplicated sequence message should stay untransformed:\n%s", out)
+
+  dupOut, dupErr, dupCode := protobufSequenceFieldNumbersTransform(t, "duplicated-", protobufSequenceDuplicatedSource)
+  if dupCode != 3 {
+    t.Fatalf("duplicated sequence message should be rejected with code 3: code=%d stdout=\n%s\nstderr=\n%s", dupCode, dupOut, dupErr)
+  }
+  if !strings.Contains(dupErr, "error TS(typia.protobuf.message):") ||
+    !strings.Contains(dupErr, `The Sequence<1> tag is duplicated in two properties ("id" and "age")`) {
+    t.Fatalf("duplicated sequence diagnostic did not name the collision:\n%s", dupErr)
   }
+  if dupOut != "" {
+    t.Fatalf("duplicated sequence message published an artifact:\n%s", dupOut)
+  }
+}
+
+func protobufSequenceFieldNumbersTransform(t *testing.T, prefix string, source string) (string, string, int) {
+  t.Helper()
+  project := protobufSequenceFieldNumbersProject(t, prefix, source)
+  return ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
 }
 
-func protobufSequenceFieldNumbersProject(t *testing.T) string {
+func protobufSequenceFieldNumbersProject(t *testing.T, prefix string, source string) 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, "protobuf-sequence-")
+  dir, err := os.MkdirTemp(base, "protobuf-sequence-"+prefix)
   if err != nil {
     t.Fatalf("create temp fixture: %v", err)
   }
@@ -68,7 +91,7 @@ func protobufSequenceFieldNumbersProject(t *testing.T) string {
   if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(protobufSequenceFieldNumbersTSConfig), 0o644); err != nil {
     t.Fatalf("write tsconfig: %v", err)
   }
-  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(protobufSequenceFieldNumbersSource), 0o644); err != nil {
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(source), 0o644); err != nil {
     t.Fatalf("write source: %v", err)
   }
   return dir
@@ -97,11 +120,18 @@ interface Sequenced {
   flag: boolean;
 }
 
+export const sequenced = typia.protobuf.message<Sequenced>();
+`
+
+// protobufSequenceDuplicatedSource is the negative twin: the same message shape
+// whose two properties claim one `Sequence<1>` number, which typia must reject
+// rather than auto-renumber.
+const protobufSequenceDuplicatedSource = `import typia, { tags } from "typia";
+
 interface Duplicated {
   id: string & tags.Sequence<1>;
   age: number & tags.Sequence<1>;
 }
 
-export const sequenced = typia.protobuf.message<Sequenced>();
 export const duplicated = typia.protobuf.message<Duplicated>();
 `

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

@@ -0,0 +1,316 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "testing"
+)
+
+// TestSymbolIndexDomainTransform verifies a symbol index signature stays out
+// of typia's string-keyed validation and JSON Schema shape (#2240).
+//
+// TypeScript keeps string and symbol index domains distinct, including when a
+// symbol index key is intersected with a nominal brand. This regression pins
+// that boundary through the real transform because treating every checker
+// IndexInfo as a JSON string index makes unrelated Object.keys values inherit a
+// symbol index's value constraint. An ordinary string index and the explicit
+// symbol-member behavior fixed by #2226 are adjacent controls.
+//
+//  1. Compile checker-level keyof assertions for symbol and string indexes.
+//  2. Execute validators over ordinary extras and symbol-valued properties.
+//  3. Compare the symbol-index schema exactly with a plain-object control while
+//     requiring a normal string index to retain additionalProperties.
+func TestSymbolIndexDomainTransform(t *testing.T) {
+  project := symbolIndexDomainProject(t)
+  js := symbolIndexDomainTransform(t, project)
+  symbolIndexDomainRunRuntimeCases(t, project, js)
+}
+
+func symbolIndexDomainProject(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, "symbol-index-domain-")
+  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(symbolIndexDomainTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(symbolIndexDomainSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func symbolIndexDomainTransform(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("symbol index domain transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  return out
+}
+
+func symbolIndexDomainRunRuntimeCases(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(symbolIndexDomainRuntimeRunner), 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("symbol index domain runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const symbolIndexDomainTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const symbolIndexDomainSource = `import typia from "typia";
+
+declare const explicitSymbol: unique symbol;
+
+interface SymbolIndex {
+  name: string;
+  [key: symbol]: number;
+}
+
+type BrandedSymbol = symbol & {
+  readonly __brand: unique symbol;
+};
+
+interface BrandedSymbolIndex {
+  name: string;
+  [key: BrandedSymbol]: number;
+}
+
+interface PlainObject {
+  name: string;
+}
+
+interface StringIndex {
+  name: string;
+  [key: string]: string;
+}
+
+interface ExplicitSymbolMember {
+  name: string;
+  [explicitSymbol]: number;
+}
+
+type Assert<T extends true> = T;
+type _SymbolIndexHasNoStringDomain = Assert<
+  string extends keyof SymbolIndex ? false : true
+>;
+type _SymbolIndexHasNoNumberDomain = Assert<
+  number extends keyof SymbolIndex ? false : true
+>;
+type _SymbolIndexHasSymbolDomain = Assert<
+  symbol extends keyof SymbolIndex ? true : false
+>;
+type _BrandedSymbolIndexHasNoStringDomain = Assert<
+  string extends keyof BrandedSymbolIndex ? false : true
+>;
+type _BrandedSymbolIndexHasNoNumberDomain = Assert<
+  number extends keyof BrandedSymbolIndex ? false : true
+>;
+type _BrandedSymbolIndexHasBrandedDomain = Assert<
+  BrandedSymbol extends keyof BrandedSymbolIndex ? true : false
+>;
+type _StringIndexHasStringDomain = Assert<
+  string extends keyof StringIndex ? true : false
+>;
+type _StringIndexHasNumberDomain = Assert<
+  number extends keyof StringIndex ? true : false
+>;
+type _StringIndexHasNoSymbolDomain = Assert<
+  symbol extends keyof StringIndex ? false : true
+>;
+type _ExplicitSymbolMemberIsPresent = Assert<
+  typeof explicitSymbol extends keyof ExplicitSymbolMember ? true : false
+>;
+
+export const isSymbolIndex = typia.createIs<SymbolIndex>();
+export const isBrandedSymbolIndex =
+  typia.createIs<BrandedSymbolIndex>();
+export const isPlainObject = typia.createIs<PlainObject>();
+export const isStringIndex = typia.createIs<StringIndex>();
+export const isExplicitSymbolMember =
+  typia.createIs<ExplicitSymbolMember>();
+export const schemas = typia.json.schemas<[
+  SymbolIndex,
+  BrandedSymbolIndex,
+  PlainObject,
+  StringIndex,
+  ExplicitSymbolMember,
+]>();
+`
+
+const symbolIndexDomainRuntimeRunner = `const mod = require("./main.cjs");
+
+const failures = [];
+const expect = (label, actual, expected) => {
+  if (actual !== expected) {
+    failures.push(
+      label +
+        ": expected " +
+        JSON.stringify(expected) +
+        " but got " +
+        JSON.stringify(actual),
+    );
+  }
+};
+
+expect("symbol index plain", mod.isSymbolIndex({ name: "x" }), true);
+expect(
+  "symbol index ignores a numeric string extra",
+  mod.isSymbolIndex({ name: "x", extra: 1 }),
+  true,
+);
+expect(
+  "symbol index ignores a string extra",
+  mod.isSymbolIndex({ name: "x", extra: "unrelated" }),
+  true,
+);
+expect(
+  "symbol index ignores a matching symbol value",
+  mod.isSymbolIndex({ name: "x", [Symbol("key")]: 1 }),
+  true,
+);
+expect(
+  "symbol index ignores a non-matching symbol value",
+  mod.isSymbolIndex({ name: "x", [Symbol("key")]: "outside-json-shape" }),
+  true,
+);
+expect("symbol index validates named properties", mod.isSymbolIndex({ name: 1 }), false);
+
+expect(
+  "branded symbol index plain",
+  mod.isBrandedSymbolIndex({ name: "x" }),
+  true,
+);
+expect(
+  "branded symbol index ignores a string extra",
+  mod.isBrandedSymbolIndex({ name: "x", extra: "unrelated" }),
+  true,
+);
+expect(
+  "branded symbol index ignores a matching symbol value",
+  mod.isBrandedSymbolIndex({ name: "x", [Symbol("key")]: 1 }),
+  true,
+);
+expect(
+  "branded symbol index ignores a non-matching symbol value",
+  mod.isBrandedSymbolIndex({ name: "x", [Symbol("key")]: "outside-json-shape" }),
+  true,
+);
+expect(
+  "branded symbol index validates named properties",
+  mod.isBrandedSymbolIndex({ name: 1 }),
+  false,
+);
+
+expect("plain object ignores a string extra", mod.isPlainObject({ name: "x", extra: 1 }), true);
+expect("plain object validates named properties", mod.isPlainObject({ name: 1 }), false);
+
+expect("string index accepts matching extra", mod.isStringIndex({ name: "x", extra: "ok" }), true);
+expect("string index rejects mismatching extra", mod.isStringIndex({ name: "x", extra: 1 }), false);
+
+expect(
+  "explicit symbol member remains outside the JSON shape",
+  mod.isExplicitSymbolMember({ name: "x", [Symbol("member")]: "ignored" }),
+  true,
+);
+expect(
+  "explicit symbol member validates named properties",
+  mod.isExplicitSymbolMember({ name: 1 }),
+  false,
+);
+
+const schemas = mod.schemas.components.schemas;
+const plain = {
+  type: "object",
+  properties: { name: { type: "string" } },
+  required: ["name"],
+  additionalProperties: false,
+};
+const stringIndex = {
+  type: "object",
+  properties: { name: { type: "string" } },
+  required: ["name"],
+  additionalProperties: { type: "string" },
+};
+expect(
+  "plain object exact schema",
+  JSON.stringify(schemas.PlainObject),
+  JSON.stringify(plain),
+);
+expect(
+  "symbol index exact schema",
+  JSON.stringify(schemas.SymbolIndex),
+  JSON.stringify(plain),
+);
+expect(
+  "branded symbol index exact schema",
+  JSON.stringify(schemas.BrandedSymbolIndex),
+  JSON.stringify(plain),
+);
+expect(
+  "explicit symbol member exact schema",
+  JSON.stringify(schemas.ExplicitSymbolMember),
+  JSON.stringify(plain),
+);
+expect(
+  "string index exact schema",
+  JSON.stringify(schemas.StringIndex),
+  JSON.stringify(stringIndex),
+);
+if (failures.length !== 0) {
+  throw new Error("MISMATCHES:\n" + failures.join("\n"));
+}
+`