typia 14.0.2 → 14.0.4

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

@@ -0,0 +1,135 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestBigintLiteralPrecisionTransform verifies a bigint literal reaches the
+// emit exactly, at any magnitude.
+//
+// `ExpressionFactory.Bigint` spelled its argument as a bare number literal, so
+// `9007199254740993n` was emitted as `BigInt(9007199254740993)` and JavaScript
+// rounded that literal to 9007199254740992 before `BigInt` ever parsed it. The
+// validator it built therefore accepted the wrong value: `is<9007199254740993n>`
+// returned true for 9007199254740992n and false for the literal it was asked
+// about. The repository already spells this hazard out for the two places that
+// avoided it -- `numericRangeFactory_bigint_literal` and `_isTypeInt64Bigint` --
+// and this factory is the one that did not.
+//
+// The factory feeds every bigint the transform emits, so the case sweeps the
+// operations that reach it rather than `is` alone.
+//
+//  1. Build validators over bigint literals past 2**53 and at the int64 bounds.
+//  2. Require the emitted code to pass the digits as a string, never as a
+//     number literal that rounds before `BigInt` sees it.
+//  3. Execute them and assert each accepts its own literal and rejects the
+//     adjacent value a rounded literal would have collapsed onto.
+func TestBigintLiteralPrecisionTransform(t *testing.T) {
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+  }
+  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, "bigint-precision-")
+  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(atomicIntersectionSchemaTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(bigintLiteralPrecisionSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  ttscTypiaTestTypecheck(t, dir)
+
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", dir,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("bigint precision transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  // A number-literal argument is the defect itself, so reject the spelling as
+  // well as the behavior: an emit that reads `BigInt(9007199254740993)` has
+  // already lost the value even where a later comparison happens to agree.
+  if strings.Contains(out, "BigInt(9007199254740993)") {
+    t.Fatalf("bigint literal must be passed as a string, not a number literal:\n%s", out)
+  }
+
+  runtimeDir := filepath.Join(dir, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  runtimeJS := ttscTypiaTestRewriteCommonJS(t, out)
+  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(bigintLiteralPrecisionRunner), 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("bigint precision runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const bigintLiteralPrecisionSource = `import typia from "typia";
+
+// 2**53 + 1 is the smallest integer a double cannot represent; rounding it
+// lands on 2**53, the value each validator below must reject.
+export const isUnsafe = typia.createIs<9007199254740993n>();
+export const isInt64Max = typia.createIs<9223372036854775807n>();
+export const isInt64Min = typia.createIs<-9223372036854775808n>();
+export const isUnion = typia.createIs<9007199254740993n | 9007199254740995n>();
+export const isSafe = typia.createIs<2n>();
+`
+
+const bigintLiteralPrecisionRunner = `const mod = require("./main.cjs");
+
+const check = (label, actual, expected) => {
+  if (actual !== expected) {
+    throw new Error(label + ": expected " + expected + ", got " + actual);
+  }
+};
+
+// Each literal is accepted, and the neighbor a rounded emit would have
+// collapsed it onto is rejected.
+check("isUnsafe(exact)", mod.isUnsafe(9007199254740993n), true);
+check("isUnsafe(rounded)", mod.isUnsafe(9007199254740992n), false);
+check("isInt64Max(exact)", mod.isInt64Max(9223372036854775807n), true);
+check("isInt64Max(rounded)", mod.isInt64Max(9223372036854775808n), false);
+check("isInt64Min(exact)", mod.isInt64Min(-9223372036854775808n), true);
+check("isInt64Min(neighbor)", mod.isInt64Min(-9223372036854775807n), false);
+check("isUnion(first)", mod.isUnion(9007199254740993n), true);
+check("isUnion(second)", mod.isUnion(9007199254740995n), true);
+check("isUnion(between)", mod.isUnion(9007199254740994n), false);
+check("isUnion(rounded)", mod.isUnion(9007199254740992n), false);
+
+// A magnitude a double does hold must keep working unchanged.
+check("isSafe(exact)", mod.isSafe(2n), true);
+check("isSafe(other)", mod.isSafe(3n), false);
+check("isSafe(number)", mod.isSafe(2), false);
+
+console.log("ok");
+`

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

@@ -0,0 +1,148 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "testing"
+)
+
+// TestReflectLiteralsBigintTransform verifies a bigint member comes back as a
+// bigint, exactly.
+//
+// typescript-go hands a bigint literal back as a `jsnum.PseudoBigInt`, a struct
+// in an internal package the shim does not re-export. Nothing downstream could
+// name that type, so `LiteralFactory` reflected its fields and emitted
+// `{ base10Value: "2", negative: false }` where `literals<2n>(): 2n[]` promises
+// a bigint. Normalizing the constant to `*big.Int` at the metadata boundary
+// gives every consumer a nameable exact value.
+//
+// Magnitude is the part a happy-path case would miss. A bigint exists precisely
+// to hold what a `number` cannot, so the emit is only correct if it survives
+// past 2**53.
+//
+//  1. Transform a module whose `reflect.literals` arguments span a bigint union,
+//     a bigint mixed with other literal kinds, and magnitudes on both sides of
+//     the double-precision limit including the int64 bounds.
+//  2. Execute the emitted CommonJS.
+//  3. Assert every member is `typeof "bigint"` and equal to the literal the
+//     source declared, digit for digit.
+func TestReflectLiteralsBigintTransform(t *testing.T) {
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+  }
+  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, "reflect-literals-bigint-")
+  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(atomicIntersectionSchemaTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(reflectLiteralsBigintSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  ttscTypiaTestTypecheck(t, dir)
+
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", dir,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("reflect.literals bigint transform failed: code=%d stderr=\n%s", code, errText)
+  }
+
+  runtimeDir := filepath.Join(dir, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  runtimeJS := ttscTypiaTestRewriteCommonJS(t, out)
+  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(reflectLiteralsBigintRunner), 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("reflect.literals bigint runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const reflectLiteralsBigintSource = `import typia from "typia";
+
+export const small = typia.reflect.literals<1n | 2n>();
+export const mixed = typia.reflect.literals<"A" | "B" | 1 | 2n>();
+export const negative = typia.reflect.literals<-5n | 5n>();
+export const zero = typia.reflect.literals<0n>();
+
+// 2**53 + 1 is the smallest integer a double cannot hold, and the int64 bounds
+// are where a rounded literal would land on the wrong side of the range.
+export const unsafe = typia.reflect.literals<9007199254740993n>();
+export const int64 = typia.reflect.literals<-9223372036854775808n | 9223372036854775807n>();
+`
+
+const reflectLiteralsBigintRunner = `const mod = require("./main.cjs");
+
+const render = (value) =>
+  typeof value === "bigint" ? value.toString() + "n" : JSON.stringify(value);
+
+const check = (label, actual, expected) => {
+  if (Array.isArray(actual) === false) {
+    throw new Error(label + ": expected an array, got " + render(actual));
+  }
+  if (actual.length !== expected.length) {
+    throw new Error(
+      label +
+        ": expected " +
+        expected.map(render).join(", ") +
+        ", got " +
+        actual.map(render).join(", "),
+    );
+  }
+  actual.forEach((item, index) => {
+    // typeof is asserted separately: a rounded BigInt(9007199254740993) is
+    // still a bigint, and an object literal is still deep-equal to nothing, so
+    // neither check alone catches both defects.
+    if (typeof item !== typeof expected[index]) {
+      throw new Error(
+        label + "[" + index + "]: expected typeof " + typeof expected[index] +
+          ", got " + typeof item + " (" + render(item) + ")",
+      );
+    }
+    if (item !== expected[index]) {
+      throw new Error(
+        label + "[" + index + "]: expected " + render(expected[index]) +
+          ", got " + render(item),
+      );
+    }
+  });
+};
+
+check("small", mod.small, [1n, 2n]);
+check("mixed", mod.mixed, ["A", "B", 1, 2n]);
+check("negative", mod.negative, [-5n, 5n]);
+check("zero", mod.zero, [0n]);
+check("unsafe", mod.unsafe, [9007199254740993n]);
+check("int64", mod.int64, [-9223372036854775808n, 9223372036854775807n]);
+
+console.log("ok");
+`

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

@@ -0,0 +1,98 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestReflectLiteralsNonLiteralRejectionTransform verifies every argument that
+// names no listable literal is refused at compile time.
+//
+// `reflect.literals` hands back the members of a union, so an argument it
+// cannot enumerate has no answer to give. Refusing it is the point: emitting an
+// empty array for `never`, or dropping the half it cannot render from a mixed
+// argument, would hand the caller a list that silently disagrees with the type
+// it was derived from (issue #2377).
+//
+// The two diagnostics stay distinguishable because they say different things:
+// `NO` reports that nothing listable was found at all, while `ONLY` reports
+// that something listable was found beside something that is not. Collapsing
+// them would hide which half of a mixed argument is wrong.
+//
+//  1. Transform arguments naming no listable member: `never` and the bare
+//     `null` flag, which carry nothing, and `string`, `any`, and a tag-branded
+//     atomic, which carry a member that cannot be enumerated.
+//  2. Transform arguments mixing a listable member with one that is not,
+//     including `boolean | number`, where the listable half is an atomic rather
+//     than a constant.
+//  3. Assert each fails, and with the diagnostic its composition calls for.
+func TestReflectLiteralsNonLiteralRejectionTransform(t *testing.T) {
+  cases := []struct {
+    Name     string
+    Argument string
+    Message  string
+  }{
+    {"never", "never", "no constant literal type found."},
+    {"never alias", "Empty", "no constant literal type found."},
+    {"exhaustive exclude", `Exclude<"a" | "b", "a" | "b">`, "no constant literal type found."},
+    {"bare null", "null", "no constant literal type found."},
+    {"atomic", "string", "no constant literal type found."},
+    {"any", "any", "no constant literal type found."},
+    {"tag branded atomic", `string & tags.Format<"uuid">`, "no constant literal type found."},
+    {"nullable atomic", "string | null", "no constant literal type found."},
+    {"literal beside atomic", `"a" | number`, "only constant literal types are allowed."},
+    {"literal beside template", "`prefix${number}` | \"a\"", "only constant literal types are allowed."},
+    {"renderable atomic beside atomic", "boolean | number", "only constant literal types are allowed."},
+  }
+  for _, tc := range cases {
+    tc := tc
+    t.Run(tc.Name, func(t *testing.T) {
+      project := reflectLiteralsRejectionProject(t, tc.Argument)
+      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("reflect.literals<%s> transformed successfully, want rejection:\n%s", tc.Argument, out)
+      }
+      if !strings.Contains(errText, "typia transform error") {
+        t.Fatalf("reflect.literals<%s> diagnostics missing:\nstdout=%s\nstderr=%s", tc.Argument, out, errText)
+      }
+      if !strings.Contains(errText, tc.Message) {
+        t.Fatalf("reflect.literals<%s> reported the wrong reason, want %q:\n%s", tc.Argument, tc.Message, errText)
+      }
+    })
+  }
+}
+
+func reflectLiteralsRejectionProject(t *testing.T, argument 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, "reflect-literals-reject-")
+  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(atomicIntersectionSchemaTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  source := "import typia, { tags } from \"typia\";\n\nexport const values = typia.reflect.literals<" + argument + ">();\n"
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(source), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}

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

@@ -0,0 +1,173 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "testing"
+)
+
+// TestReflectSchemaBigintTransform verifies the metadata a reflect operation
+// hands back carries a bigint constant as a bigint.
+//
+// `IMetadataSchema.IValue<Atomic.Type>` declares `value: bigint` for a bigint
+// constant, but this transformer lowered the whole metadata tree through
+// `encoding/json` before writing it. JSON has no bigint, so that one member
+// could not survive the trip: it arrived as whatever object its fields happened
+// to spell. The trip was also redundant -- it marshaled structs into maps and
+// lowercased each key's initial, which is what `LiteralFactory` already does
+// when it reflects a struct -- so writing the tree directly both fixes the
+// value and removes the step.
+//
+// `literals` and `schema` reach the emit by different routes, so a case on one
+// says nothing about the other.
+//
+//  1. Reflect a bigint constant union through `schema` and through `schemas`.
+//  2. Execute the emitted CommonJS.
+//  3. Assert each reported value is `typeof "bigint"` and exact, and that the
+//     surrounding metadata still reports the constant and its neighbors.
+func TestReflectSchemaBigintTransform(t *testing.T) {
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+  }
+  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, "reflect-schema-bigint-")
+  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(atomicIntersectionSchemaTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(reflectSchemaBigintSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  ttscTypiaTestTypecheck(t, dir)
+
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", dir,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("reflect.schema bigint transform failed: code=%d stderr=\n%s", code, errText)
+  }
+
+  runtimeDir := filepath.Join(dir, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  runtimeJS := ttscTypiaTestRewriteCommonJS(t, out)
+  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(reflectSchemaBigintRunner), 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("reflect.schema bigint runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const reflectSchemaBigintSource = `import typia, { tags } from "typia";
+
+export const unit = typia.reflect.schema<1n | 9007199254740993n>();
+export const collection = typia.reflect.schemas<[2n, "a" | 3]>();
+export const objects = typia.reflect.schema<{ big: 7n; name: string }>();
+
+// A tag reaches a constant by matching the child's value against the merged
+// parent's, so the constant value has to compare by value. The number and
+// string constants are the controls that were never at risk.
+export const tagged = typia.reflect.schema<(1n | 2n) & tags.Type<"int64">>();
+export const taggedNumber = typia.reflect.schema<(1 | 2) & tags.Type<"uint32">>();
+`
+
+const reflectSchemaBigintRunner = `const mod = require("./main.cjs");
+
+const render = (value) =>
+  typeof value === "bigint" ? value.toString() + "n" : JSON.stringify(value);
+
+const constantsOf = (schema, type) => {
+  const constant = (schema.constants ?? []).find((c) => c.type === type);
+  return constant === undefined ? [] : constant.values.map((v) => v.value);
+};
+
+const check = (label, actual, expected) => {
+  if (actual.length !== expected.length) {
+    throw new Error(
+      label + ": expected " + expected.map(render).join(", ") +
+        ", got " + actual.map(render).join(", "),
+    );
+  }
+  actual.forEach((item, index) => {
+    if (typeof item !== typeof expected[index] || item !== expected[index]) {
+      throw new Error(
+        label + "[" + index + "]: expected " + render(expected[index]) +
+          " (" + typeof expected[index] + "), got " + render(item) +
+          " (" + typeof item + ")",
+      );
+    }
+  });
+};
+
+check("schema", constantsOf(mod.unit.schema, "bigint"), [1n, 9007199254740993n]);
+check("schemas[0]", constantsOf(mod.collection.schemas[0], "bigint"), [2n]);
+
+// A neighboring constant kind must keep its own representation.
+check("schemas[1] string", constantsOf(mod.collection.schemas[1], "string"), ["a"]);
+check("schemas[1] number", constantsOf(mod.collection.schemas[1], "number"), [3]);
+
+// The surrounding tree still reports the object and its members.
+const object = mod.objects.components.objects[0];
+if (object === undefined || object.properties.length !== 2) {
+  throw new Error("object metadata was not emitted: " + JSON.stringify(mod.objects, (k, v) => typeof v === "bigint" ? v.toString() : v));
+}
+const big = object.properties.find(
+  (p) => constantsOf(p.key, "string")[0] === "big",
+);
+if (big === undefined) {
+  throw new Error("the 'big' property is missing from the object metadata");
+}
+check("object property", constantsOf(big.value, "bigint"), [7n]);
+
+const tagNames = (schema, type) => {
+  const constant = (schema.constants ?? []).find((c) => c.type === type);
+  if (constant === undefined) {
+    throw new Error("no " + type + " constant was emitted");
+  }
+  return constant.values.map((v) =>
+    (v.tags ?? []).flat().map((t) => t.name).join(","),
+  );
+};
+
+// Every member keeps the tag the intersection put on it.
+const expectTags = (label, actual, expected) => {
+  if (actual.length === 0 || actual.some((names) => names !== expected)) {
+    throw new Error(
+      label + ": expected every member tagged " + expected +
+        ", got " + JSON.stringify(actual),
+    );
+  }
+};
+expectTags("bigint constant", tagNames(mod.tagged.schema, "bigint"), 'Type<"int64">');
+expectTags("number constant", tagNames(mod.taggedNumber.schema, "number"), 'Type<"uint32">');
+
+console.log("ok");
+`

package/native/core/factories/ExpressionFactory.go

@@ -66,6 +66,16 @@ func (expressionFactoryNamespace) Number(value any, emit ...*shimprinter.EmitCon
   return f.NewNumericLiteral(text, shimast.TokenFlagsNone)
 }
 
+// Bigint emits `BigInt("<value>")` for a bigint literal.
+//
+// The argument has to stay a string literal. This used to spell the digits as a
+// bare `number` literal, so `9007199254740993n` reached the emit as
+// `BigInt(9007199254740993)` and JavaScript rounded the literal to
+// 9007199254740992 before `BigInt` ever parsed it -- exactly the rounding
+// `numericRangeFactory_bigint_literal` and `_isTypeInt64Bigint` already spell
+// out and avoid. Every bigint an argument can carry is exact in base 10, and
+// `BigInt` parses the digits of a string directly, so the string form is exact
+// at any magnitude.
 func (expressionFactoryNamespace) Bigint(value any, emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
   return f.NewCallExpression(
@@ -73,7 +83,7 @@ func (expressionFactoryNamespace) Bigint(value any, emit ...*shimprinter.EmitCon
     nil,
     nil,
     f.NewNodeList([]*shimast.Node{
-      f.NewIdentifier(fmt.Sprint(value)),
+      f.NewStringLiteral(fmt.Sprint(value), shimast.TokenFlagsNone),
     }),
     shimast.NodeFlagsNone,
   )

package/native/core/factories/LiteralFactory.go

@@ -11,6 +11,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimprinter "github.com/microsoft/typescript-go/shim/printer"
   nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type literalFactoryNamespace struct{}
@@ -93,6 +94,8 @@ func (literalFactoryNamespace) Write(input any, emit ...*shimprinter.EmitContext
   switch value := input.(type) {
   case bool:
     return literalFactory_writeBoolean(value, emit...)
+  case schemametadata.MetadataBigint:
+    return literalFactory_writeBigint(value, emit...)
   case *big.Int:
     return literalFactory_writeBigint(value, emit...)
   case int:

package/native/core/factories/internal/metadata/iterate_metadata_constant.go

@@ -50,6 +50,9 @@ func Iterate_metadata_constant(props IMetadataIteratorProps) bool {
       typ = "number"
     } else if filter(nativechecker.TypeFlagsBigIntLiteral) {
       typ = "bigint"
+      // Normalize away the checker's unnameable `jsnum.PseudoBigInt`; see
+      // MetadataBigint for why the stand-in has to be a comparable value.
+      value = schemametadata.MetadataBigint{Text: fmt.Sprint(value)}
     }
     constant := iterate_metadata_constant_take(props.Metadata, typ)
     info := comment()

package/native/core/programmers/reflect/ReflectLiteralsProgrammer.go

@@ -29,6 +29,12 @@ func (reflectLiteralsProgrammerNamespace) Write(props ReflectLiteralsProgrammer_
       Escape:   true,
       Constant: true,
       Absorb:   true,
+      // Only a constant literal, the `boolean` atomic (which stands for the
+      // `true | false` constants), and `null` beside them are members this
+      // operation can hand back. Anything else -- an unconstrained atomic, a
+      // template, a bucket of any other kind -- is rejected, and so is an
+      // argument carrying no member at all: `never` has no literal to list, so
+      // it is a compile error rather than an empty array (issue #2377).
       Validate: func(next struct {
         Metadata *nativemetadata.MetadataSchema
         Explore  nativefactories.MetadataFactory_IExplore

package/native/core/schemas/metadata/MetadataBigint.go

@@ -0,0 +1,37 @@
+package metadata
+
+// MetadataBigint is the value of a `bigint` constant.
+//
+// typescript-go reports a bigint literal as a `jsnum.PseudoBigInt`, a struct in
+// an internal package the shim does not re-export. Nothing downstream could
+// name it, so consumers that had to render the value reflected its fields
+// instead and emitted `{ base10Value: "2", negative: false }` where the caller
+// declared `bigint`. This is the nameable stand-in.
+//
+// It is a comparable struct on purpose. Every other value a
+// `MetadataConstantValue` carries -- `string`, `bool`, the number -- is
+// comparable, and the factories compare those values with `==`; the
+// intersection tag assigner is one such site. A pointer type such as
+// `*math/big.Int` would compare identity there and, for bigints alone,
+// silently drop whatever the comparison decides.
+type MetadataBigint struct {
+  // Text is the exact value in base 10, prefixed with `-` when negative. A
+  // bigint exists to hold what a float64 cannot, so the digits are the only
+  // representation that stays exact at every magnitude.
+  Text string
+}
+
+// String renders the base-10 digits, which is what every consumer that lowers a
+// bigint into emitted code reads through `fmt.Sprint`.
+func (obj MetadataBigint) String() string {
+  return obj.Text
+}
+
+// MarshalJSON writes the digits unquoted, so metadata marshaled by a
+// downstream tool carries the same JSON number a plain integer would.
+func (obj MetadataBigint) MarshalJSON() ([]byte, error) {
+  if obj.Text == "" {
+    return []byte("0"), nil
+  }
+  return []byte(obj.Text), nil
+}

package/native/core/schemas/metadata/metadata_bigint_is_comparable_test.go

@@ -0,0 +1,65 @@
+package metadata
+
+import (
+  "encoding/json"
+  "fmt"
+  "testing"
+)
+
+// TestMetadataBigintIsComparable pins the property the whole representation
+// rests on: two independently built values of the same bigint are `==`.
+//
+// A `MetadataConstantValue.Value` is compared with `==` inside the factories --
+// the intersection tag assigner matches a child's constant against the merged
+// parent's that way -- and every other value it can hold (`string`, `bool`, the
+// number) is a comparable value. A pointer stand-in such as `*math/big.Int`
+// builds a fresh allocation per literal, so those comparisons would test
+// identity and, for bigints alone, silently decide "not the same constant":
+// `(1n | 2n) & tags.Type<"int64">` lost its tag that way. This is the guard,
+// held one level below the transform so a future change to the representation
+// fails here rather than as a dropped tag three packages away.
+//
+//  1. Build the same value twice, independently, and compare with `==`.
+//  2. Compare a different value, and a negative against its positive.
+//  3. Check the two renderings every consumer reads: `fmt.Sprint` for the emit
+//     and `encoding/json` for metadata a downstream tool marshals.
+func TestMetadataBigintIsComparable(t *testing.T) {
+  const digits = "9007199254740993"
+  left := MetadataBigint{Text: digits}
+  right := MetadataBigint{Text: digits}
+  if left != right {
+    t.Fatalf("two values of the same bigint must be ==: %v vs %v", left, right)
+  }
+  var boxed any = left
+  if boxed != any(right) {
+    t.Fatalf("the same bigint must stay == once boxed in the `any` a constant value holds")
+  }
+  if left == (MetadataBigint{Text: "9007199254740992"}) {
+    t.Fatalf("distinct bigints must not compare equal")
+  }
+  if left == (MetadataBigint{Text: "-" + digits}) {
+    t.Fatalf("a negative must not compare equal to its positive")
+  }
+
+  if got := fmt.Sprint(left); got != digits {
+    t.Fatalf("fmt.Sprint must render the base-10 digits, got %q", got)
+  }
+  if got := fmt.Sprint(MetadataBigint{Text: "-5"}); got != "-5" {
+    t.Fatalf("a negative must keep its sign, got %q", got)
+  }
+
+  encoded, err := json.Marshal(left)
+  if err != nil {
+    t.Fatalf("marshal bigint: %v", err)
+  }
+  if string(encoded) != digits {
+    t.Fatalf("marshaled bigint must be the unquoted digits, got %s", encoded)
+  }
+  zero, err := json.Marshal(MetadataBigint{})
+  if err != nil {
+    t.Fatalf("marshal zero bigint: %v", err)
+  }
+  if string(zero) != "0" {
+    t.Fatalf("the zero value must marshal as 0, got %s", zero)
+  }
+}

package/native/transform/features/reflect/ReflectSchemaTransformer.go

@@ -1,10 +1,7 @@
 package reflect
 
 import (
-  "encoding/json"
   "strings"
-  "unicode"
-  "unicode/utf8"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimprinter "github.com/microsoft/typescript-go/shim/printer"
@@ -67,50 +64,22 @@ func (reflectSchemaTransformerNamespace) Transform(props nativetransform.ITransf
   }, props.Context.Emit)
 }
 
+// reflectTransformer_literal lowers a metadata tree into its object literal.
+//
+// This used to round-trip the tree through `encoding/json` and then lowercase
+// each key's initial, which is exactly what `LiteralFactory` already does when
+// it reflects a struct. The round trip was not merely redundant: JSON has no
+// bigint, so a `bigint` constant -- the one value in the tree that is neither
+// a string nor a JSON number -- could not survive it. It came back as the
+// object its fields happened to spell, and `IMetadataSchema.IValue` declares
+// `bigint` there.
+//
+// Writing the tree directly leaves every other member identical (diffed over a
+// metadata tree spanning objects, optional and nullable members, tags, arrays,
+// tuples, sets, maps, natives, functions, aliases, and unions: the bigint
+// values were the only difference) and lets a bigint stay a bigint.
 func reflectTransformer_literal(value any, emit ...*shimprinter.EmitContext) *shimast.Node {
-  return nativefactories.LiteralFactory.Write(reflectTransformer_toPrimitive(value), emit...)
-}
-
-func reflectTransformer_toPrimitive(value any) any {
-  data, err := json.Marshal(value)
-  if err != nil {
-    return nil
-  }
-  var decoded any
-  if err := json.Unmarshal(data, &decoded); err != nil {
-    return nil
-  }
-  return reflectTransformer_lowerKeys(decoded)
-}
-
-func reflectTransformer_lowerKeys(value any) any {
-  switch v := value.(type) {
-  case map[string]any:
-    output := map[string]any{}
-    for key, elem := range v {
-      output[reflectTransformer_lowerInitial(key)] = reflectTransformer_lowerKeys(elem)
-    }
-    return output
-  case []any:
-    output := make([]any, 0, len(v))
-    for _, elem := range v {
-      output = append(output, reflectTransformer_lowerKeys(elem))
-    }
-    return output
-  default:
-    return value
-  }
-}
-
-func reflectTransformer_lowerInitial(str string) string {
-  if str == "" {
-    return str
-  }
-  r, size := utf8.DecodeRuneInString(str)
-  if r == utf8.RuneError && size == 0 {
-    return str
-  }
-  return string(unicode.ToLower(r)) + str[size:]
+  return nativefactories.LiteralFactory.Write(value, emit...)
 }
 
 func reflectTransformer_errors(errors []nativefactories.MetadataFactory_IError) []nativetransform.TransformerError_MetadataFactory_IError {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "14.0.2",
+  "version": "14.0.4",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {
@@ -43,8 +43,8 @@
   "homepage": "https://typia.io",
   "dependencies": {
     "randexp": "^0.5.3",
-    "@typia/interface": "^14.0.2",
-    "@typia/utils": "^14.0.2"
+    "@typia/interface": "^14.0.4",
+    "@typia/utils": "^14.0.4"
   },
   "peerDependencies": {
     "ttsc": ">=0.19.2"