typia 13.1.1 → 13.2.0

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

@@ -0,0 +1,286 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "testing"
+)
+
+// TestNotationDynamicKeysTransform verifies dynamic key rewriting and collision rejection.
+//
+// Index signatures use the dynamic object-entry branch rather than statically
+// emitted property assignments. That branch must apply the selected rename to
+// every runtime key and reject two source keys that normalize to one destination
+// before either value is silently lost.
+//
+//  1. Transform direct and factory forms of plain/assert/is/validate operations
+//     for camel, Pascal, snake, and kebab notation.
+//  2. Require valid dynamic and nested keys to use each selected convention.
+//  3. Require every operation form to throw on a dynamic destination collision.
+func TestNotationDynamicKeysTransform(t *testing.T) {
+  project := notationDynamicKeysProject(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("dynamic notation transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  notationDynamicKeysRunRuntimeCases(t, project, out)
+}
+
+func notationDynamicKeysProject(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-dynamic-")
+  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(notationDynamicKeysTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(notationDynamicKeysSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func notationDynamicKeysRunRuntimeCases(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(notationDynamicKeysRuntimeRunner), 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("dynamic notation runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const notationDynamicKeysTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const notationDynamicKeysSource = `import typia from "typia";
+
+type UnderscoreRecord = Record<string, { inner_key: string }>;
+type CamelRecord = Record<string, { innerValue: string }>;
+type NumericRecord = Record<number, { innerValue: string }>;
+type TemplateRecord = Record<` + "`item_${string}`" + `, { inner_key: string }>;
+interface SnakeLiteral { "__proto__": { innerValue: string }; }
+interface CamelMixed {
+  user_id: { inner_key: string };
+  [key: string]: { inner_key: string };
+}
+
+export const snakeLiteral = (input: SnakeLiteral) =>
+  typia.notations.snake<SnakeLiteral>(input);
+export const mixedCamel = (input: CamelMixed) =>
+  typia.notations.camel<CamelMixed>(input);
+export const numericSnake = (input: NumericRecord) =>
+  typia.notations.snake<NumericRecord>(input);
+export const templateCamel = (input: TemplateRecord) =>
+  typia.notations.camel<TemplateRecord>(input);
+
+export const camel = {
+  direct: (input: UnderscoreRecord) => typia.notations.camel<UnderscoreRecord>(input),
+  create: typia.notations.createCamel<UnderscoreRecord>(),
+  assert: (input: unknown) => typia.notations.assertCamel<UnderscoreRecord>(input),
+  createAssert: typia.notations.createAssertCamel<UnderscoreRecord>(),
+  is: (input: unknown) => typia.notations.isCamel<UnderscoreRecord>(input),
+  createIs: typia.notations.createIsCamel<UnderscoreRecord>(),
+  validate: (input: unknown) => typia.notations.validateCamel<UnderscoreRecord>(input),
+  createValidate: typia.notations.createValidateCamel<UnderscoreRecord>(),
+};
+export const pascal = {
+  direct: (input: UnderscoreRecord) => typia.notations.pascal<UnderscoreRecord>(input),
+  create: typia.notations.createPascal<UnderscoreRecord>(),
+  assert: (input: unknown) => typia.notations.assertPascal<UnderscoreRecord>(input),
+  createAssert: typia.notations.createAssertPascal<UnderscoreRecord>(),
+  is: (input: unknown) => typia.notations.isPascal<UnderscoreRecord>(input),
+  createIs: typia.notations.createIsPascal<UnderscoreRecord>(),
+  validate: (input: unknown) => typia.notations.validatePascal<UnderscoreRecord>(input),
+  createValidate: typia.notations.createValidatePascal<UnderscoreRecord>(),
+};
+export const snake = {
+  direct: (input: CamelRecord) => typia.notations.snake<CamelRecord>(input),
+  create: typia.notations.createSnake<CamelRecord>(),
+  assert: (input: unknown) => typia.notations.assertSnake<CamelRecord>(input),
+  createAssert: typia.notations.createAssertSnake<CamelRecord>(),
+  is: (input: unknown) => typia.notations.isSnake<CamelRecord>(input),
+  createIs: typia.notations.createIsSnake<CamelRecord>(),
+  validate: (input: unknown) => typia.notations.validateSnake<CamelRecord>(input),
+  createValidate: typia.notations.createValidateSnake<CamelRecord>(),
+};
+export const kebab = {
+  direct: (input: CamelRecord) => typia.notations.kebab<CamelRecord>(input),
+  create: typia.notations.createKebab<CamelRecord>(),
+  assert: (input: unknown) => typia.notations.assertKebab<CamelRecord>(input),
+  createAssert: typia.notations.createAssertKebab<CamelRecord>(),
+  is: (input: unknown) => typia.notations.isKebab<CamelRecord>(input),
+  createIs: typia.notations.createIsKebab<CamelRecord>(),
+  validate: (input: unknown) => typia.notations.validateKebab<CamelRecord>(input),
+  createValidate: typia.notations.createValidateKebab<CamelRecord>(),
+};
+`
+
+const notationDynamicKeysRuntimeRunner = `const mod = require("./main.cjs");
+
+const literalMagic = mod.snakeLiteral(
+  Object.fromEntries([["__proto__", { innerValue: "literal" }]]),
+);
+if (
+  Object.getPrototypeOf(literalMagic) !== Object.prototype ||
+  !Object.hasOwn(literalMagic, "__proto__") ||
+  !Object.hasOwn(literalMagic.__proto__, "inner_value")
+) {
+  throw new Error("snake literal __proto__ was not emitted as an own data property");
+}
+
+let mixedCollision = null;
+try {
+  mod.mixedCamel({
+    user_id: { inner_key: "literal" },
+    userId: { inner_key: "dynamic" },
+  });
+} catch (error) {
+  mixedCollision = error;
+}
+if (mixedCollision === null) {
+  throw new Error("camel mixed literal/dynamic destination collision was accepted");
+}
+for (const key of ["user_id", "userId", "userId"]) {
+  if (!String(mixedCollision.message).includes(JSON.stringify(key))) {
+    throw new Error("camel mixed collision omitted " + key + ": " + mixedCollision.message);
+  }
+}
+
+const numeric = mod.numericSnake({ 7: { innerValue: "numeric" } });
+if (!Object.hasOwn(numeric, "7") || !Object.hasOwn(numeric[7], "inner_value")) {
+  throw new Error("snake numeric index key disagreed with its mapped return type");
+}
+
+const template = mod.templateCamel({ item_user_id: { inner_key: "template" } });
+if (!Object.hasOwn(template, "itemUserId") || !Object.hasOwn(template.itemUserId, "innerKey")) {
+  throw new Error("camel template-literal index key was not converted");
+}
+
+const families = [
+  {
+    name: "camel",
+    api: mod.camel,
+    valid: { user_id: { inner_key: "u" }, account_name: { inner_key: "a" } },
+    expected: [["userId", "innerKey"], ["accountName", "innerKey"]],
+    collision: { user_id: { inner_key: "a" }, userId: { inner_key: "b" } },
+    collisionKeys: ["user_id", "userId", "userId"],
+  },
+  {
+    name: "pascal",
+    api: mod.pascal,
+    valid: { user_id: { inner_key: "u" }, account_name: { inner_key: "a" } },
+    expected: [["UserId", "InnerKey"], ["AccountName", "InnerKey"]],
+    collision: { user_id: { inner_key: "a" }, UserId: { inner_key: "b" } },
+    collisionKeys: ["user_id", "UserId", "UserId"],
+  },
+  {
+    name: "snake",
+    api: mod.snake,
+    valid: Object.fromEntries([
+      ["userId", { innerValue: "u" }],
+      ["accountName", { innerValue: "a" }],
+      ["__proto__", { innerValue: "p" }],
+    ]),
+    expected: [["user_id", "inner_value"], ["account_name", "inner_value"], ["__proto__", "inner_value"]],
+    collision: { userId: { innerValue: "a" }, user_id: { innerValue: "b" } },
+    collisionKeys: ["userId", "user_id", "user_id"],
+  },
+  {
+    name: "kebab",
+    api: mod.kebab,
+    valid: { userId: { innerValue: "u" }, account_name: { innerValue: "a" } },
+    expected: [["user-id", "inner-value"], ["account-name", "inner-value"]],
+    collision: { userId: { innerValue: "a" }, user_id: { innerValue: "b" } },
+    collisionKeys: ["userId", "user_id", "user-id"],
+  },
+];
+const variants = ["direct", "create", "assert", "createAssert", "is", "createIs", "validate", "createValidate"];
+
+for (const family of families) {
+  for (const variant of variants) {
+    const raw = family.api[variant](family.valid);
+    const converted = variant === "validate" || variant === "createValidate"
+      ? raw.success === true ? raw.data : null
+      : raw;
+    if (converted === null) {
+      throw new Error(family.name + "." + variant + " rejected valid dynamic input");
+    }
+    if (Object.keys(converted).length !== family.expected.length) {
+      throw new Error(family.name + "." + variant + " emitted unexpected keys: " + JSON.stringify(converted));
+    }
+    for (const [outer, inner] of family.expected) {
+      if (
+        !Object.hasOwn(converted, outer) ||
+        Object.keys(converted[outer]).length !== 1 ||
+        !Object.hasOwn(converted[outer], inner)
+      ) {
+        throw new Error(family.name + "." + variant + " kept an unconverted key: " + JSON.stringify(converted));
+      }
+    }
+
+    let collision = null;
+    try {
+      family.api[variant](family.collision);
+    } catch (error) {
+      collision = error;
+    }
+    if (collision === null) {
+      throw new Error(family.name + "." + variant + " silently accepted a destination collision");
+    }
+    for (const key of family.collisionKeys) {
+      if (!String(collision.message).includes(JSON.stringify(key))) {
+        throw new Error(family.name + "." + variant + " collision omitted " + key + ": " + collision.message);
+      }
+    }
+  }
+}
+`

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

@@ -36,7 +36,7 @@ func TestNotationKebabCaseTransform(t *testing.T) {
   if code != 0 {
     t.Fatalf("kebab notation transform failed: code=%d stderr=\n%s", code, errText)
   }
-  for _, key := range []string{`"user-id"`, `"user-name"`, `"_private-value"`, `xmlparser:`, `"inner-value"`} {
+  for _, key := range []string{`"user-id"`, `"user-name"`, `"_private-value"`, `"xmlparser"`, `"inner-value"`} {
     if !strings.Contains(out, key) {
       t.Fatalf("emitted converter should contain kebab key %s:\n%s", key, out)
     }

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

@@ -0,0 +1,164 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "testing"
+)
+
+// TestNotationLiteralCollisionTransform verifies static destination collisions are rejected.
+//
+// Literal property metadata exposes every source key during code emission. A
+// converter must reject two distinct literals that normalize to one result
+// instead of emitting duplicate assignments whose last value silently wins.
+//
+//  1. Transform direct and factory plain/assert/is/validate calls for all cases.
+//  2. Give each naming family two literal keys with one normalized destination.
+//  3. Execute every operation and require an error naming both source keys and destination.
+func TestNotationLiteralCollisionTransform(t *testing.T) {
+  project := notationLiteralCollisionProject(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("literal collision transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  notationLiteralCollisionRunRuntimeCases(t, project, out)
+}
+
+func notationLiteralCollisionProject(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-literal-collision-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(notationDynamicKeysTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(notationLiteralCollisionSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func notationLiteralCollisionRunRuntimeCases(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(notationLiteralCollisionRuntimeRunner), 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("literal collision runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const notationLiteralCollisionSource = `import typia from "typia";
+
+interface CamelCollision { user_id: string; userId: string; }
+interface PascalCollision { user_id: string; UserId: string; }
+interface SnakeCollision { userId: string; user_id: string; }
+interface KebabCollision { userId: string; user_id: string; }
+
+export const camel = {
+  direct: (input: CamelCollision) => typia.notations.camel<CamelCollision>(input),
+  create: typia.notations.createCamel<CamelCollision>(),
+  assert: (input: unknown) => typia.notations.assertCamel<CamelCollision>(input),
+  createAssert: typia.notations.createAssertCamel<CamelCollision>(),
+  is: (input: unknown) => typia.notations.isCamel<CamelCollision>(input),
+  createIs: typia.notations.createIsCamel<CamelCollision>(),
+  validate: (input: unknown) => typia.notations.validateCamel<CamelCollision>(input),
+  createValidate: typia.notations.createValidateCamel<CamelCollision>(),
+};
+export const pascal = {
+  direct: (input: PascalCollision) => typia.notations.pascal<PascalCollision>(input),
+  create: typia.notations.createPascal<PascalCollision>(),
+  assert: (input: unknown) => typia.notations.assertPascal<PascalCollision>(input),
+  createAssert: typia.notations.createAssertPascal<PascalCollision>(),
+  is: (input: unknown) => typia.notations.isPascal<PascalCollision>(input),
+  createIs: typia.notations.createIsPascal<PascalCollision>(),
+  validate: (input: unknown) => typia.notations.validatePascal<PascalCollision>(input),
+  createValidate: typia.notations.createValidatePascal<PascalCollision>(),
+};
+export const snake = {
+  direct: (input: SnakeCollision) => typia.notations.snake<SnakeCollision>(input),
+  create: typia.notations.createSnake<SnakeCollision>(),
+  assert: (input: unknown) => typia.notations.assertSnake<SnakeCollision>(input),
+  createAssert: typia.notations.createAssertSnake<SnakeCollision>(),
+  is: (input: unknown) => typia.notations.isSnake<SnakeCollision>(input),
+  createIs: typia.notations.createIsSnake<SnakeCollision>(),
+  validate: (input: unknown) => typia.notations.validateSnake<SnakeCollision>(input),
+  createValidate: typia.notations.createValidateSnake<SnakeCollision>(),
+};
+export const kebab = {
+  direct: (input: KebabCollision) => typia.notations.kebab<KebabCollision>(input),
+  create: typia.notations.createKebab<KebabCollision>(),
+  assert: (input: unknown) => typia.notations.assertKebab<KebabCollision>(input),
+  createAssert: typia.notations.createAssertKebab<KebabCollision>(),
+  is: (input: unknown) => typia.notations.isKebab<KebabCollision>(input),
+  createIs: typia.notations.createIsKebab<KebabCollision>(),
+  validate: (input: unknown) => typia.notations.validateKebab<KebabCollision>(input),
+  createValidate: typia.notations.createValidateKebab<KebabCollision>(),
+};
+`
+
+const notationLiteralCollisionRuntimeRunner = `const mod = require("./main.cjs");
+
+const families = [
+  { name: "camel", api: mod.camel, input: { user_id: "a", userId: "b" }, expected: ["user_id", "userId", "userId"] },
+  { name: "pascal", api: mod.pascal, input: { user_id: "a", UserId: "b" }, expected: ["user_id", "UserId", "UserId"] },
+  { name: "snake", api: mod.snake, input: { userId: "a", user_id: "b" }, expected: ["userId", "user_id", "user_id"] },
+  { name: "kebab", api: mod.kebab, input: { userId: "a", user_id: "b" }, expected: ["userId", "user_id", "user-id"] },
+];
+const variants = ["direct", "create", "assert", "createAssert", "is", "createIs", "validate", "createValidate"];
+
+for (const family of families) {
+  for (const variant of variants) {
+    let collision = null;
+    try {
+      family.api[variant](family.input);
+    } catch (error) {
+      collision = error;
+    }
+    if (collision === null) {
+      throw new Error(family.name + "." + variant + " silently accepted a literal destination collision");
+    }
+    for (const key of family.expected) {
+      if (!String(collision.message).includes(JSON.stringify(key))) {
+        throw new Error(family.name + "." + variant + " collision omitted " + key + ": " + collision.message);
+      }
+    }
+  }
+}
+`

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

@@ -0,0 +1,230 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestNotationPascalCaseTransform verifies PascalCase notation conversion.
+//
+// Issue #2183: `notations.pascal` capitalized each multi-word segment without
+// lowercasing its tail, so an all-caps or mixed-case word kept its inner
+// uppercase characters and `MAX_COUNT` became `MAXCOUNT`. Both the statically
+// emitted converter (Go, one property assignment per known key) and the dynamic
+// converter (runtime `_notationPascal`, one call per index-signature key) must
+// agree with the declared `PascalCase<T>` type — the type-level assertions live
+// in `tests/test-interface/src/typings/test_pascal_case.ts` — or the result type
+// lies about the produced keys and `.MaxCount` reads back `undefined`.
+//
+//  1. Transform a static fixture covering all-caps, mixed-case, leading
+//     underscore, single-word (routed through `plain`, tail preserved), and
+//     nested keys; require the emitted converter to reference the PascalCase
+//     keys and never the un-lowercased `MAXCOUNT` form.
+//  2. Execute the statically emitted converter and assert its runtime keys.
+//  3. Execute the dynamic `Record` converter (runtime `_notationPascal`) over
+//     the same all-caps witnesses and assert it produces the identical keys, so
+//     the compile-time emit and the runtime helper are proven byte-equal.
+func TestNotationPascalCaseTransform(t *testing.T) {
+  project := notationPascalCaseProject(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("pascal notation transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  for _, key := range []string{"MaxCount", "HttpPort", "UserId", "FoobarBaz", "InnerValue"} {
+    if !strings.Contains(out, key) {
+      t.Fatalf("emitted converter should contain PascalCase key %q:\n%s", key, out)
+    }
+  }
+  for _, bug := range []string{"MAXCOUNT", "HTTPPORT", "FooBarBaz", "INNERVALUE"} {
+    if strings.Contains(out, bug) {
+      t.Fatalf("emitted converter must not keep the un-lowercased key %q:\n%s", bug, out)
+    }
+  }
+  notationPascalCaseRunRuntimeCases(t, project, out)
+}
+
+func notationPascalCaseProject(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-pascal-")
+  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(notationPascalCaseTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(notationPascalCaseSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func notationPascalCaseRunRuntimeCases(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(notationPascalCaseRuntimeRunner), 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("pascal notation runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const notationPascalCaseTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const notationPascalCaseSource = `import typia from "typia";
+
+interface SourceRecord {
+  MAX_COUNT: number;
+  HTTP_PORT: number;
+  USER_ID: number;
+  fooBar_baz: number;
+  _MAX_COUNT: number;
+  userID: number;
+  ID: number;
+  nested: { INNER_VALUE: number };
+}
+
+type DynamicRecord = Record<string, { DEEP_VALUE: number }>;
+
+export const toPascal = typia.notations.createPascal<SourceRecord>();
+export const isPascal = typia.notations.createIsPascal<SourceRecord>();
+export const assertPascal = typia.notations.createAssertPascal<SourceRecord>();
+export const validatePascal =
+  typia.notations.createValidatePascal<SourceRecord>();
+export const toPascalDynamic = typia.notations.createPascal<DynamicRecord>();
+`
+
+const notationPascalCaseRuntimeRunner = `const mod = require("./main.cjs");
+
+const valid = {
+  MAX_COUNT: 1,
+  HTTP_PORT: 2,
+  USER_ID: 3,
+  fooBar_baz: 4,
+  _MAX_COUNT: 5,
+  userID: 6,
+  ID: 7,
+  nested: { INNER_VALUE: 8 },
+};
+// Byte-for-byte the key set of PascalCase<SourceRecord>: multi-word tails
+// lowercase (MAX_COUNT -> MaxCount), single words keep their tail through the
+// plain path (userID -> UserID, ID -> ID).
+const expectedKeys = [
+  "MaxCount", "HttpPort", "UserId", "FoobarBaz", "_MaxCount", "UserID", "ID", "Nested",
+];
+
+const converted = mod.toPascal(valid);
+const keys = Object.keys(converted).sort();
+if (JSON.stringify(keys) !== JSON.stringify([...expectedKeys].sort())) {
+  throw new Error("pascal conversion produced unexpected keys: " + JSON.stringify(keys));
+}
+if (converted.MaxCount !== 1 || converted.HttpPort !== 2 || converted.UserId !== 3) {
+  throw new Error("pascal conversion lost multi-word values: " + JSON.stringify(converted));
+}
+if (converted.FoobarBaz !== 4 || converted._MaxCount !== 5) {
+  throw new Error("mixed-case/leading-underscore keys converted incorrectly: " + JSON.stringify(converted));
+}
+if (converted.UserID !== 6 || converted.ID !== 7) {
+  throw new Error("single-word keys must keep their tail: " + JSON.stringify(converted));
+}
+if (JSON.stringify(Object.keys(converted.Nested)) !== JSON.stringify(["InnerValue"])) {
+  throw new Error("nested keys should recurse into PascalCase: " + JSON.stringify(converted.Nested));
+}
+
+if (mod.isPascal(valid) === null) {
+  throw new Error("isPascal should accept the valid input");
+}
+if (mod.isPascal({ ...valid, MAX_COUNT: "x" }) !== null) {
+  throw new Error("isPascal should reject an invalid property type");
+}
+if (mod.assertPascal(valid).MaxCount !== 1) {
+  throw new Error("assertPascal should return the converted object");
+}
+let thrown = null;
+try {
+  mod.assertPascal({ ...valid, nested: { INNER_VALUE: "x" } });
+} catch (error) {
+  thrown = error;
+}
+if (thrown === null) {
+  throw new Error("assertPascal should throw on invalid nested input");
+}
+
+const success = mod.validatePascal(valid);
+if (success.success !== true || success.data.HttpPort !== 2) {
+  throw new Error("validatePascal should succeed with converted data: " + JSON.stringify(success));
+}
+const failure = mod.validatePascal({ ...valid, ID: "x" });
+if (failure.success !== false || failure.errors.length === 0) {
+  throw new Error("validatePascal should collect errors for invalid input: " + JSON.stringify(failure));
+}
+
+// Dynamic index-signature keys route through the runtime _notationPascal helper
+// rather than statically emitted assignments. Feeding the same all-caps
+// witnesses proves the runtime helper and the compile-time emit agree.
+const dynamic = mod.toPascalDynamic({
+  MAX_COUNT: { DEEP_VALUE: 1 },
+  HTTP_PORT: { DEEP_VALUE: 2 },
+});
+const dynamicKeys = Object.keys(dynamic).sort();
+if (JSON.stringify(dynamicKeys) !== JSON.stringify(["HttpPort", "MaxCount"])) {
+  throw new Error("dynamic pascal keys disagreed with the static emit: " + JSON.stringify(dynamicKeys));
+}
+if (
+  !Object.hasOwn(dynamic.MaxCount, "DeepValue") ||
+  !Object.hasOwn(dynamic.HttpPort, "DeepValue")
+) {
+  throw new Error("dynamic pascal nested keys were not lowercased: " + JSON.stringify(dynamic));
+}
+`