typia 14.0.6 → 15.0.1

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

@@ -9,6 +9,7 @@ import (
   "path/filepath"
   "sort"
   "strings"
+  "sync"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
@@ -86,6 +87,7 @@ func runTransform(args []string) int {
   transformDiags := []typiaTransformDiagnostic{}
   transformOptions := pluginOptions.TransformOptions()
   extras := nativecontext.ITypiaContext_Extras{
+    Shared: &sync.Map{},
     AddDiagnostic: func(diag *nativecontext.ITypiaDiagnostic) int {
       transformDiags = append(transformDiags, typiaTransformDiagnosticFrom(diag))
       return len(transformDiags)

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

@@ -155,6 +155,8 @@ func ttscTypiaTestRewriteCommonJS(t *testing.T, js string) string {
   runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_functionalTypeGuardErrorFactory")`, `require("./functional-error-stub.cjs")`)
   runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_accessExpressionAsString")`, `require("./access-expression-stub.cjs")`)
   runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_stringLength")`, `require("./string-length-stub.cjs")`)
+  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_stringLengthGte")`, `require("./string-length-stub.cjs")`)
+  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_stringLengthLte")`, `require("./string-length-stub.cjs")`)
   runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_jsonStringifyArray")`, `require("./json-stringify-array-stub.cjs")`)
   runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_jsonStringifyProperty")`, `require("./json-stringify-property-stub.cjs")`)
   runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_jsonStringifyElement")`, `require("./json-stringify-element-stub.cjs")`)
@@ -292,14 +294,26 @@ const ttscTypiaTestRandomStringStub = `module.exports._randomString = (props) =>
 };
 `
 
-// A double for packages/typia/src/internal/_stringLength.ts: the string
-// iterator walks code points, so a surrogate pair counts once, which is what
-// `MinLength` and `MaxLength` now mean.
+// Doubles for the string-length helpers. The string iterator walks code points,
+// so a surrogate pair counts once; the comparisons stop as soon as their
+// boundary determines the answer.
 const ttscTypiaTestStringLengthStub = `module.exports._stringLength = (value) => {
   let count = 0;
   for (const _ of value) ++count;
   return count;
 };
+module.exports._stringLengthGte = (value, length) => {
+  let count = 0;
+  if (length <= count) return true;
+  for (const _ of value) if (length <= ++count) return true;
+  return false;
+};
+module.exports._stringLengthLte = (value, length) => {
+  let count = 0;
+  if (!(count <= length)) return false;
+  for (const _ of value) if (!(++count <= length)) return false;
+  return true;
+};
 `
 
 const ttscTypiaTestAccessExpressionStub = `const reserved = new Set([

package/native/core/context/ITypiaContext.go

@@ -1,6 +1,8 @@
 package context
 
 import (
+  "sync"
+
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimchecker "github.com/microsoft/typescript-go/shim/checker"
   shimcore "github.com/microsoft/typescript-go/shim/core"
@@ -21,10 +23,12 @@ type ITypiaContext struct {
   Emit     *shimprinter.EmitContext
   Importer *ImportProgrammer
   Extras   ITypiaContext_Extras
+  Shared   *sync.Map
 }
 
 type ITypiaContext_Extras struct {
   AddDiagnostic func(diag *ITypiaDiagnostic) int
+  Shared        *sync.Map
 }
 
 type ITypiaDiagnostic struct {

package/native/core/factories/ExpressionFactory.go

@@ -57,7 +57,22 @@ var expressionFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{
 func (expressionFactoryNamespace) Number(value any, emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
   text, numeric := expressionFactory_number_text(value)
-  if numeric < 0 {
+  // Go spells the non-finite floats `NaN`, `+Inf`, and `-Inf`. Only the first
+  // happens to be JavaScript; `+Inf` evaluates an undeclared `Inf` and throws a
+  // ReferenceError when the emitted function first runs (samchon/typia#2452).
+  // Spell them as the globals, as TypeScript's own factory does.
+  if math.IsNaN(numeric) {
+    return f.NewIdentifier("NaN")
+  }
+  if math.IsInf(numeric, 0) {
+    if numeric < 0 {
+      return f.NewPrefixUnaryExpression(shimast.KindMinusToken, f.NewIdentifier("Infinity"))
+    }
+    return f.NewIdentifier("Infinity")
+  }
+  // Negative zero takes the same negation as every negative value; its text
+  // `-0` is not a numeric literal on its own.
+  if numeric < 0 || (numeric == 0 && math.Signbit(numeric)) {
     return f.NewPrefixUnaryExpression(
       shimast.KindMinusToken,
       f.NewNumericLiteral(expressionFactory_number_abs_text(numeric), shimast.TokenFlagsNone),

package/native/core/factories/IdentifierFactory.go

@@ -94,6 +94,16 @@ func (identifierFactoryNamespace) Postfix(str string) string {
   return identifierFactory_source("[" + identifierFactory_json(str) + "]")
 }
 
+// PathPostfix returns the accessor text `_accessExpressionAsString` builds at
+// runtime for the same key: `.key` for an identifier, `["key"]` otherwise. It
+// is the path text itself, not a JavaScript literal that spells it.
+func (identifierFactoryNamespace) PathPostfix(str string) string {
+  if identifierFactory_variable(str) {
+    return "." + str
+  }
+  return "[" + identifierFactory_json(str) + "]"
+}
+
 // identifierFactory_json renders `str` as JSON text, matching JSON.stringify so
 // that the path this lands in is the one _accessExpressionAsString builds for
 // the same key at runtime, and so JSON.parse in _createStandardSchema reads the

package/native/core/factories/LiteralFactory.go

@@ -18,6 +18,19 @@ type literalFactoryNamespace struct{}
 
 var LiteralFactory = literalFactoryNamespace{}
 
+// LiteralFactory_Null is an explicit JSON `null` value.
+//
+// Object writers treat a Go `nil` value as absent and skip it, which is what
+// most schema builders mean by it, so a real `null`, such as the value of
+// `tags.Example<null>`, needs its own marker to survive into the emitted
+// literal and into encoding/json output (samchon/typia#2403).
+type LiteralFactory_Null struct{}
+
+// MarshalJSON writes the marker as JSON `null`.
+func (LiteralFactory_Null) MarshalJSON() ([]byte, error) {
+  return []byte("null"), nil
+}
+
 // LiteralFactory_OrderedObject is an object literal whose property order is
 // fixed by Keys rather than inferred from a Go map's (unordered) iteration or
 // from propertyRank sorting. Use it for objects whose insertion order is
@@ -71,6 +84,9 @@ func (literalFactoryNamespace) Write(input any, emit ...*shimprinter.EmitContext
   if input == nil {
     return f.NewKeywordExpression(shimast.KindNullKeyword)
   }
+  if _, ok := input.(LiteralFactory_Null); ok {
+    return f.NewKeywordExpression(shimast.KindNullKeyword)
+  }
   if node, ok := input.(*shimast.Node); ok {
     if node.Kind == shimast.KindArrowFunction || node.Kind == shimast.KindCallExpression || node.Kind == shimast.KindIdentifier {
       return node

package/native/core/factories/MetadataCommentTagFactory.go

@@ -2,10 +2,12 @@ package factories
 
 import (
   "math"
+  "math/big"
   "strconv"
   "strings"
 
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativeutils "github.com/samchon/typia/packages/typia/native/core/utils"
 )
 
 type metadataCommentTagFactoryNamespace struct{}
@@ -51,6 +53,22 @@ func (metadataCommentTagFactoryNamespace) Analyze(props struct {
       continue
     }
     for key, value := range tagger {
+      // An empty arm names a target the tag's value cannot be stated for; see
+      // metadataCommentTagFactory_bigint. It is an error only where that target
+      // occurs, and the other arms still apply to theirs.
+      if value != nil && len(value) == 0 {
+        for _, atomic := range props.Metadata.Atomics {
+          if atomic.Type == key {
+            text := ""
+            if len(tag.Text) != 0 {
+              text = tag.Text[0].Text
+            }
+            report(key + " value " + strings.TrimSpace(text) + " is not an int64 integer that a number represents exactly")
+            break
+          }
+        }
+        continue
+      }
       filtered := []schemametadata.IMetadataTypeTag{}
       for _, elem := range value {
         filtered = append(filtered, elem)
@@ -216,11 +234,12 @@ func (metadataCommentTagFactoryNamespace) Get(props struct {
 // The rule: a template may name only a helper that every `typia` inside the
 // caret range already ships. `isTypeInt8` and its siblings satisfy it --
 // `@typia/interface` 13.0.0 named them and `typia` 13.0.0 shipped them. The
-// four this file and `Type.ts` now name do not: `_stringLength`, `_isMultipleOf`
-// (both first published in 13.1.19), `_isTypeInt64Bigint`, and
-// `_isTypeUint64Bigint` (13.1.19). They are safe only because the release that
-// carries them is a major, where the caret cannot reach a `typia` that predates
-// them. A minor or patch release of this tree reopens #2330.
+// helpers this file and the tag declarations now name do not:
+// `_stringLengthGte`, `_stringLengthLte`, `_isMultipleOf`,
+// `_isTypeInt64Bigint`, and `_isTypeUint64Bigint`. They are safe only because
+// the release that carries them is a major, where the caret cannot reach a
+// `typia` that predates them. A minor or patch release of this tree reopens
+// #2330.
 //
 // Nothing here can enforce that; the release version is the maintainer's, and a
 // campaign pull request never assigns one. This comment is the record.
@@ -229,37 +248,37 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    value := metadataCommentTagFactory_parse_integer(struct {
+    value := metadataCommentTagFactory_value(metadataCommentTagFactory_parse_integer(struct {
       Report   func(msg string) any
       Unsigned bool
       Value    string
-    }{Report: props.Report, Value: props.Value, Unsigned: true})
+    }{Report: props.Report, Value: props.Value, Unsigned: true}))
     return metadataCommentTagFactory_TagRecord{"array": {
-      {Name: "MinItems<" + props.Value + ">", Target: "array", Kind: "minItems", Value: value, Validate: props.Value + " <= $input.length", Exclusive: metadataCommentTagFactory_exclusive("minItems"), Schema: map[string]any{"minItems": value}},
-      {Name: "MaxItems<" + props.Value + ">", Target: "array", Kind: "maxItems", Value: value, Validate: "$input.length <= " + props.Value, Exclusive: metadataCommentTagFactory_exclusive("maxItems"), Schema: map[string]any{"maxItems": value}},
+      {Name: "MinItems<" + props.Value + ">", Target: "array", Kind: "minItems", Value: value, Validate: metadataCommentTagFactory_splice(props.Value) + " <= $input.length", Exclusive: metadataCommentTagFactory_exclusive("minItems"), Schema: map[string]any{"minItems": value}},
+      {Name: "MaxItems<" + props.Value + ">", Target: "array", Kind: "maxItems", Value: value, Validate: "$input.length <= " + metadataCommentTagFactory_splice(props.Value), Exclusive: metadataCommentTagFactory_exclusive("maxItems"), Schema: map[string]any{"maxItems": value}},
     }}
   },
   "minItems": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    value := metadataCommentTagFactory_parse_integer(struct {
+    value := metadataCommentTagFactory_value(metadataCommentTagFactory_parse_integer(struct {
       Report   func(msg string) any
       Unsigned bool
       Value    string
-    }{Report: props.Report, Value: props.Value, Unsigned: true})
-    return metadataCommentTagFactory_TagRecord{"array": {{Name: "MinItems<" + props.Value + ">", Target: "array", Kind: "minItems", Value: value, Validate: props.Value + " <= $input.length", Exclusive: metadataCommentTagFactory_exclusive("minItems"), Schema: map[string]any{"minItems": value}}}}
+    }{Report: props.Report, Value: props.Value, Unsigned: true}))
+    return metadataCommentTagFactory_TagRecord{"array": {{Name: "MinItems<" + props.Value + ">", Target: "array", Kind: "minItems", Value: value, Validate: metadataCommentTagFactory_splice(props.Value) + " <= $input.length", Exclusive: metadataCommentTagFactory_exclusive("minItems"), Schema: map[string]any{"minItems": value}}}}
   },
   "maxItems": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    value := metadataCommentTagFactory_parse_integer(struct {
+    value := metadataCommentTagFactory_value(metadataCommentTagFactory_parse_integer(struct {
       Report   func(msg string) any
       Unsigned bool
       Value    string
-    }{Report: props.Report, Value: props.Value, Unsigned: true})
-    return metadataCommentTagFactory_TagRecord{"array": {{Name: "MaxItems<" + props.Value + ">", Target: "array", Kind: "maxItems", Value: value, Validate: "$input.length <= " + props.Value, Exclusive: metadataCommentTagFactory_exclusive("maxItems"), Schema: map[string]any{"maxItems": value}}}}
+    }{Report: props.Report, Value: props.Value, Unsigned: true}))
+    return metadataCommentTagFactory_TagRecord{"array": {{Name: "MaxItems<" + props.Value + ">", Target: "array", Kind: "maxItems", Value: value, Validate: "$input.length <= " + metadataCommentTagFactory_splice(props.Value), Exclusive: metadataCommentTagFactory_exclusive("maxItems"), Schema: map[string]any{"maxItems": value}}}}
   },
   "uniqueItems": func(props struct {
     Report func(msg string) any
@@ -272,25 +291,25 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    return metadataCommentTagFactory_numeric(props, "Minimum", "minimum", props.Value+" <= $input", props.Value+" <= $input")
+    return metadataCommentTagFactory_numeric(props, "Minimum", "minimum", metadataCommentTagFactory_splice(props.Value)+" <= $input", metadataCommentTagFactory_splice_integer(props.Value)+" <= $input")
   },
   "maximum": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    return metadataCommentTagFactory_numeric(props, "Maximum", "maximum", "$input <= "+props.Value, "$input <= "+props.Value)
+    return metadataCommentTagFactory_numeric(props, "Maximum", "maximum", "$input <= "+metadataCommentTagFactory_splice(props.Value), "$input <= "+metadataCommentTagFactory_splice_integer(props.Value))
   },
   "exclusiveMinimum": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    return metadataCommentTagFactory_numeric(props, "ExclusiveMinimum", "exclusiveMinimum", props.Value+" < $input", props.Value+" < $input")
+    return metadataCommentTagFactory_numeric(props, "ExclusiveMinimum", "exclusiveMinimum", metadataCommentTagFactory_splice(props.Value)+" < $input", metadataCommentTagFactory_splice_integer(props.Value)+" < $input")
   },
   "exclusiveMaximum": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    return metadataCommentTagFactory_numeric(props, "ExclusiveMaximum", "exclusiveMaximum", "$input < "+props.Value, "$input < "+props.Value)
+    return metadataCommentTagFactory_numeric(props, "ExclusiveMaximum", "exclusiveMaximum", "$input < "+metadataCommentTagFactory_splice(props.Value), "$input < "+metadataCommentTagFactory_splice_integer(props.Value))
   },
   "multipleOf": func(props struct {
     Report func(msg string) any
@@ -302,7 +321,7 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
     // answers a different question than the `multipleOf` keyword this tag emits.
     // The bigint arm needs no helper: a bigint remainder is already exact.
     // `_isMultipleOf` first shipped in 13.1.19; see the doc comment above.
-    return metadataCommentTagFactory_numeric(props, "MultipleOf", "multipleOf", "$importInternal(\"_isMultipleOf\")($input, "+props.Value+")", "$input % "+props.Value+"n === 0n")
+    return metadataCommentTagFactory_numeric(props, "MultipleOf", "multipleOf", "$importInternal(\"_isMultipleOf\")($input, "+metadataCommentTagFactory_splice(props.Value)+")", "$input % "+metadataCommentTagFactory_splice_integer(props.Value)+"n === 0n")
   },
   "format": func(props struct {
     Report func(msg string) any
@@ -331,10 +350,11 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
     // `$input.length` counts UTF-16 code units, while the `minLength` and
     // `maxLength` keywords these tags emit count characters, so one astral
     // character would measure 2 against a schema that measures 1.
-    // `_stringLength` first shipped in 13.1.19; see the doc comment above.
+    // The comparison helpers keep that code-point walk but stop when the
+    // declared boundary already determines the answer.
     return metadataCommentTagFactory_TagRecord{"string": {
-      {Name: "MinLength<" + props.Value + ">", Target: "string", Kind: "minLength", Value: value, Validate: props.Value + " <= $importInternal(\"_stringLength\")($input)", Exclusive: metadataCommentTagFactory_exclusive("minLength"), Schema: map[string]any{"minLength": value}},
-      {Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$importInternal(\"_stringLength\")($input) <= " + props.Value, Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}},
+      {Name: "MinLength<" + props.Value + ">", Target: "string", Kind: "minLength", Value: value, Validate: "$importInternal(\"_stringLengthGte\")($input, " + metadataCommentTagFactory_splice(props.Value) + ")", Exclusive: metadataCommentTagFactory_exclusive("minLength"), Schema: map[string]any{"minLength": value}},
+      {Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$importInternal(\"_stringLengthLte\")($input, " + metadataCommentTagFactory_splice(props.Value) + ")", Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}},
     }}
   },
   "minLength": func(props struct {
@@ -342,14 +362,14 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
     Value  string
   }) metadataCommentTagFactory_TagRecord {
     value := metadataCommentTagFactory_parse_number(props)
-    return metadataCommentTagFactory_TagRecord{"string": {{Name: "MinLength<" + props.Value + ">", Target: "string", Kind: "minLength", Value: value, Validate: props.Value + " <= $importInternal(\"_stringLength\")($input)", Exclusive: metadataCommentTagFactory_exclusive("minLength"), Schema: map[string]any{"minLength": value}}}}
+    return metadataCommentTagFactory_TagRecord{"string": {{Name: "MinLength<" + props.Value + ">", Target: "string", Kind: "minLength", Value: value, Validate: "$importInternal(\"_stringLengthGte\")($input, " + metadataCommentTagFactory_splice(props.Value) + ")", Exclusive: metadataCommentTagFactory_exclusive("minLength"), Schema: map[string]any{"minLength": value}}}}
   },
   "maxLength": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
     value := metadataCommentTagFactory_parse_number(props)
-    return metadataCommentTagFactory_TagRecord{"string": {{Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$importInternal(\"_stringLength\")($input) <= " + props.Value, Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}}}}
+    return metadataCommentTagFactory_TagRecord{"string": {{Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$importInternal(\"_stringLengthLte\")($input, " + metadataCommentTagFactory_splice(props.Value) + ")", Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}}}}
   },
 }
 
@@ -478,31 +498,161 @@ func metadataCommentTagFactory_numeric(props struct {
   Value  string
 }, name string, kind string, numberValidate string, bigintValidate string) metadataCommentTagFactory_TagRecord {
   number := metadataCommentTagFactory_parse_number(props)
-  integer := metadataCommentTagFactory_parse_integer(struct {
-    Report   func(msg string) any
-    Unsigned bool
-    Value    string
-  }{Report: func(string) any { return nil }, Value: props.Value, Unsigned: false})
+  if number == nil {
+    // Reported as an invalid or non-finite number already; a record would only
+    // add "requires number type" on a bigint property, which is not the fault.
+    return metadataCommentTagFactory_TagRecord{}
+  }
   exclusive := metadataCommentTagFactory_exclusive(kind)
   record := metadataCommentTagFactory_TagRecord{
     "number": {{Name: name + "<" + props.Value + ">", Target: "number", Kind: kind, Value: number, Validate: numberValidate, Exclusive: exclusive, Schema: map[string]any{kind: number}}},
   }
-  if integer != nil {
-    record["bigint"] = []schemametadata.IMetadataTypeTag{{Name: name + "<" + props.Value + "n>", Target: "bigint", Kind: kind, Value: *integer, Validate: bigintValidate, Exclusive: exclusive, Schema: map[string]any{kind: number}}}
+  integer, numeric, ok := metadataCommentTagFactory_bigint(props.Value)
+  if ok {
+    record["bigint"] = []schemametadata.IMetadataTypeTag{{Name: name + "<" + props.Value + "n>", Target: "bigint", Kind: kind, Value: integer, Validate: bigintValidate, Exclusive: exclusive, Schema: map[string]any{kind: number}}}
+  } else if numeric {
+    // An empty arm: the value bounds a bigint, but not with any value this tag
+    // can state. `Analyze` reports it where a bigint occurs, so the bigint part
+    // of a `number | bigint` property is never left unconstrained silently.
+    record["bigint"] = []schemametadata.IMetadataTypeTag{}
   }
   return record
 }
 
+// metadataCommentTagFactory_bigint reads a numeric tag's value for its bigint
+// arm.
+//
+// Consumers of that arm hold the value as a double: the bound validators splice
+// a number literal, and the schema `random` draws from is numeric. The written
+// integer survives them only when a double represents it exactly, so that is
+// what the arm admits, within the int64 range its value is carried in
+// (samchon/typia#2352). Reading any integer through a double instead enforced
+// `@minimum 9007199254740993` as 9007199254740992, and let `random` generate
+// values the exact `@multipleOf` check rejects (samchon/typia#2457).
+//
+// numeric reports whether the text writes a finite number at all. One that is
+// no such integer -- `1.5`, `5.0000000000000001`, `9007199254740993`, or
+// `1e-1000001` -- is a bigint bound the tag cannot state, while text that is no
+// finite number has already been reported by the number arm.
+func metadataCommentTagFactory_bigint(text string) (value int64, numeric bool, ok bool) {
+  if reading := nativeutils.NumberUtil.Read(text); reading.Numeric == false || reading.Finite == false {
+    return 0, false, false
+  }
+  integer, exact := metadataCommentTagFactory_integer(text)
+  if exact == false || integer.IsInt64() == false {
+    return 0, true, false
+  }
+  if _, accuracy := new(big.Float).SetInt(integer).Float64(); accuracy != big.Exact {
+    return 0, true, false
+  }
+  return integer.Int64(), true, true
+}
+
+// metadataCommentTagFactory_integer is the integer a finite numeric text
+// writes exactly, if it writes one whose double lies within the int64 range. A
+// few integers just below -2^63 round to it and pass; the bigint record checks
+// the integer itself.
+//
+// Its double, which `NumberUtil.Read` rounds correctly, settles most texts
+// without expanding them. A non-integer double comes only from a non-integer
+// text, and a zero from a text with a non-zero digit is the underflow of a
+// non-integer. A double at 2^63 or above, or below -2^63, is refused too: the
+// int64 texts that round up to 2^63 (from 9223372036854775296) are no doubles,
+// so no bigint record could hold them anyway. `big.Rat` expands only what
+// remains, so a short text such as `@minimum 1e-1000000` costs nothing, on any
+// target.
+func metadataCommentTagFactory_integer(text string) (*big.Int, bool) {
+  reading := nativeutils.NumberUtil.Read(text)
+  if reading.Numeric == false ||
+    reading.Finite == false ||
+    reading.Value != math.Trunc(reading.Value) ||
+    reading.Value < metadataCommentTagFactory_INT64_MINIMUM ||
+    reading.Value >= metadataCommentTagFactory_INT64_EXCLUSIVE_MAXIMUM {
+    return nil, false
+  }
+  if reading.Value == 0 {
+    // A zero writes zero only when no digit before its exponent is non-zero;
+    // otherwise it underflowed. A radix zero has no `e`, being all zeros.
+    mantissa := text
+    if index := strings.IndexAny(text, "eE"); index != -1 {
+      mantissa = text[:index]
+    }
+    if strings.ContainsAny(mantissa, "123456789") {
+      return nil, false
+    }
+    return big.NewInt(0), true
+  }
+  rational, ok := nativeutils.NumberUtil.Rational(text)
+  if ok == false || rational.IsInt() == false {
+    return nil, false
+  }
+  return rational.Num(), true
+}
+
+// metadataCommentTagFactory_value unwraps a parsed count into the record's
+// value and schema. Storing the pointer itself let every consumer that formats
+// a value print an address: strict LLM schemas described `@minItems 2` as
+// `@minItems 0xc000012345`.
+func metadataCommentTagFactory_value(value *int64) any {
+  if value == nil {
+    return nil
+  }
+  return *value
+}
+
 func metadataCommentTagFactory_parse_number(props struct {
   Report func(msg string) any
   Value  string
 }) any {
-  parsed, err := strconv.ParseFloat(props.Value, 64)
-  if err != nil || math.IsNaN(parsed) {
+  reading := nativeutils.NumberUtil.Read(props.Value)
+  if reading.Numeric == false {
     props.Report("invalid number")
     return nil
   }
-  return parsed
+  // A JSON Schema keyword such as `minimum` must be a JSON number, and JSON has
+  // no spelling for an infinity (samchon/typia#2452).
+  if reading.Finite == false {
+    props.Report("non-finite number")
+    return nil
+  }
+  return reading.Value
+}
+
+// metadataCommentTagFactory_splice respells a numeric tag value for the
+// validator the record splices it into (`16 <= $input`, `$input % 1000n`).
+//
+// The spliced text has to be JavaScript for the value the tag was read as, in
+// both the number and the bigint target. The source spelling need not be:
+// `0x10` happens to be, but `1e3`, `1.0`, `+5`, and `007` are integers whose
+// bigint splice (`1e3n`, `1.0n`, `+5n`, `007n`) is no valid BigInt expression
+// (samchon/typia#2442). An integer spelling keeps its digits as written, so the
+// splice never rounds where the source did not: `Number()` would read
+// `9007199254740993` as ...992, while the bigint `@multipleOf` check appends
+// `n` to the digits and compares exactly.
+// Text that does not read as a finite number is passed through; the parser
+// reports it and nothing is emitted.
+func metadataCommentTagFactory_splice(value string) string {
+  if integer, ok := nativeutils.NumberUtil.Integer(value); ok {
+    return integer.String()
+  }
+  if reading := nativeutils.NumberUtil.Read(value); reading.Numeric && reading.Finite {
+    return nativeutils.NumberUtil.String(reading.Value)
+  }
+  return value
+}
+
+// metadataCommentTagFactory_splice_integer respells a tag value for a bigint
+// validator: the exact digits of the integer the text writes, whatever its
+// spelling, for every value a bigint record holds. `1.152921504606846976e18`
+// writes 2^60, while its double spells 1152921504606847000, which spliced
+// before an `n` would check a different integer (samchon/typia#2457). Text
+// that writes no integer has no bigint record, and falls back to the number
+// splice.
+func metadataCommentTagFactory_splice_integer(value string) string {
+  if integer, ok := metadataCommentTagFactory_integer(value); ok {
+    return integer.String()
+  }
+  return metadataCommentTagFactory_splice(value)
 }
 
 func metadataCommentTagFactory_parse_integer(props struct {