typia 14.0.3 → 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

@@ -7,24 +7,26 @@ import (
   "testing"
 )
 
-// TestReflectLiteralsNonLiteralRejectionTransform is the negative twin of the
-// empty-union admission fixed for issue #2377.
+// TestReflectLiteralsNonLiteralRejectionTransform verifies every argument that
+// names no listable literal is refused at compile time.
 //
-// Widening the admission predicate so that the empty union and the bare `null`
-// flag both pass must not widen it any further: every argument that carries a
-// member the emitter cannot render still has to abort the transform. The two
-// diagnostics stay distinguishable as well, because they say different things --
-// `NO` reports that nothing literal was found at all, while `ONLY` reports that
-// something literal was found next to something that is not. Collapsing them
-// would hide which half of a mixed argument is wrong.
+// `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).
 //
-//  1. Transform arguments holding no literal at all: a bare atomic, `any`, and
-//     a tag-branded atomic, whose brand raises the member count without adding
-//     anything the emitter can render.
-//  2. Transform arguments mixing a renderable member with a non-literal one:
-//     `string | null`, the one-axis twin of the newly admitted `null`, and
-//     `boolean | number`, where the renderable member is an atomic rather than
-//     a constant.
+// 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 {
@@ -32,13 +34,17 @@ func TestReflectLiteralsNonLiteralRejectionTransform(t *testing.T) {
     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."},
-    {"nullable atomic", "string | null", "only constant literal types are allowed."},
+    {"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."},
-    {"tag branded atomic", `string & tags.Format<"uuid">`, "no constant literal type found."},
   }
   for _, tc := range cases {
     tc := tc

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,24 +29,12 @@ func (reflectLiteralsProgrammerNamespace) Write(props ReflectLiteralsProgrammer_
       Escape:   true,
       Constant: true,
       Absorb:   true,
-      // Accept exactly what the emitter below can render: constant literals,
-      // the `boolean` atomic (the `true | false` union), and `null`. `null` is
-      // a `MetadataSchema` flag rather than a bucket, so `Size()` cannot see
-      // it; weighing it on both sides keeps `length` meaning "renderable
-      // members" against `size` meaning "members", which is what lets a
-      // rejected argument carry the diagnostic its composition calls for
-      // instead of collapsing onto `NO`.
-      //
-      // Equal counts with no member at all is an uninhabited argument: the
-      // `never` keyword, an alias or `Exclude`/`Extract` that filters
-      // everything away, or an intersection whose every distributed member
-      // prunes to never. Its literal set is empty and
-      // `literals<never>(): never[]` has exactly one inhabitant, so it emits
-      // `[]` rather than a diagnostic (issue #2377). `undefined` and `void`
-      // coalesce to the same empty metadata, but neither satisfies the public
-      // `T extends Atomic.Type | null` bound, and typia refuses to transform
-      // at all without `strictNullChecks` (`transform/transform.go`), so
-      // neither reaches this predicate.
+      // 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
@@ -61,18 +49,13 @@ func (reflectLiteralsProgrammerNamespace) Write(props ReflectLiteralsProgrammer_
             length++
           }
         }
-        size := next.Metadata.Size()
-        if next.Metadata.Nullable {
-          length++
-          size++
-        }
-        if size == length {
-          return []string{}
-        }
         if length == 0 {
           return []string{string(ReflectLiteralsProgrammer_ErrorMessages_NO)}
         }
-        return []string{string(ReflectLiteralsProgrammer_ErrorMessages_ONLY)}
+        if next.Metadata.Size() != length {
+          return []string{string(ReflectLiteralsProgrammer_ErrorMessages_ONLY)}
+        }
+        return []string{}
       },
     },
     Components: nativemetadata.NewMetadataCollection(),

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.3",
+  "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.3",
-    "@typia/utils": "^14.0.3"
+    "@typia/interface": "^14.0.4",
+    "@typia/utils": "^14.0.4"
   },
   "peerDependencies": {
     "ttsc": ">=0.19.2"

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

@@ -1,161 +0,0 @@
-package main
-
-import (
-  "os"
-  "os/exec"
-  "path/filepath"
-  "testing"
-)
-
-// TestReflectLiteralsEmptyUnionTransform pins issue #2377: the literal set of an
-// empty union is the empty array, not a transform error.
-//
-// The programmer admits a type argument by counting the members it can render,
-// and it renders three kinds -- constant literals, the `boolean` atomic, and
-// `null`. `null` is a `MetadataSchema` flag rather than a bucket, so it was
-// missing from the count, which made two admissible arguments look like "no
-// constant literal type found": `never`, whose union is empty on both sides of
-// the comparison, and `null`, which the public
-// `literals<T extends Atomic.Type | null>()` signature documents. `never` is
-// vacuously literal-only and `literals<never>(): never[]` has exactly one
-// inhabitant, so both must transform and run.
-//
-//  1. Transform a module whose `reflect.literals` arguments span every
-//     uninhabited spelling a caller reaches -- the keyword, an alias, an
-//     exhaustive `Exclude`, an empty `Extract`, a TypeScript-collapsed
-//     intersection, and one typia prunes itself -- plus `null`, a fully mixed
-//     literal union, and the plain `boolean` atomic.
-//  2. Execute the emitted CommonJS.
-//  3. Assert `never` yields `[]`, `null` yields `[null]`, and the arguments that
-//     already worked keep their exact members and order, including the sort the
-//     guide documents.
-func TestReflectLiteralsEmptyUnionTransform(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-empty-")
-  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(reflectLiteralsEmptyUnionSource), 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 empty union 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(reflectLiteralsEmptyUnionRunner), 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 empty union runtime cases failed: %v\n%s", err, output)
-  }
-}
-
-const reflectLiteralsEmptyUnionSource = `import typia from "typia";
-
-type Color = "red" | "green" | "blue";
-type Empty = never;
-
-// The empty union: no member on either side of the admission comparison. Every
-// spelling a caller reaches it through has to transform, not only the keyword:
-// an alias hides it behind a name, and a conditional or an exhaustive Exclude
-// is how a generic caller produces one without writing "never" at all.
-export const empty = typia.reflect.literals<never>();
-export const emptyAlias = typia.reflect.literals<Empty>();
-export const emptyExclude = typia.reflect.literals<Exclude<Color, Color>>();
-export const emptyExtract = typia.reflect.literals<Extract<Color, "cyan">>();
-
-// Uninhabited without the keyword: TypeScript collapses one to never itself,
-// while the other stays an intersection whose every distributed member typia
-// prunes away. Both are empty on both sides of the comparison, so the rule the
-// keyword exercises has to cover them too.
-export const emptyCollapsed = typia.reflect.literals<string & number>();
-export const emptyPruned = typia.reflect.literals<(string | number) & { data: number }>();
-
-// A union whose only member is the nullable flag, which carries no bucket.
-export const onlyNull = typia.reflect.literals<null>();
-
-// Controls that already transformed: the flag must join the count without
-// displacing a constant, a boolean atomic, or their order.
-export const mixed = typia.reflect.literals<"a" | 1 | true | null>();
-export const booleanAtomic = typia.reflect.literals<boolean>();
-export const booleanAtomicNull = typia.reflect.literals<boolean | null>();
-
-// Declaration order deliberately disagrees with the emitted order: values of
-// one primitive type are sorted (iterate_metadata_sort), which is the behavior
-// the reflect.literals guide states.
-export const sorted = typia.reflect.literals<"b" | "a" | 10 | 2>();
-`
-
-const reflectLiteralsEmptyUnionRunner = `const mod = require("./main.cjs");
-
-const check = (label, actual, expected) => {
-  if (Array.isArray(actual) === false) {
-    throw new Error(label + ": expected an array, got " + JSON.stringify(actual));
-  }
-  if (
-    actual.length !== expected.length ||
-    actual.some((item, index) => item !== expected[index])
-  ) {
-    throw new Error(
-      label +
-        ": expected " +
-        JSON.stringify(expected) +
-        ", got " +
-        JSON.stringify(actual),
-    );
-  }
-};
-
-check("never", mod.empty, []);
-check("never alias", mod.emptyAlias, []);
-check("exhaustive Exclude", mod.emptyExclude, []);
-check("empty Extract", mod.emptyExtract, []);
-check("collapsed intersection", mod.emptyCollapsed, []);
-check("pruned intersection", mod.emptyPruned, []);
-check("null", mod.onlyNull, [null]);
-check("mixed", mod.mixed, ["a", 1, true, null]);
-check("booleanAtomic", mod.booleanAtomic, [true, false]);
-check("booleanAtomicNull", mod.booleanAtomicNull, [true, false, null]);
-check("sorted", mod.sorted, ["a", "b", 2, 10]);
-
-console.log("ok");
-`