typia 13.3.0 → 14.0.1

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

@@ -20,8 +20,8 @@ import (
   nativetransform "github.com/samchon/typia/packages/typia/native/transform"
 )
 
-// runTransform is the source-to-source host the ttsc transform stage and the
-// `typia generate` wizard drive. Unlike `build` (which emits .js), it returns
+// runTransform is the source-to-source host that drives the ttsc transform
+// stage. Unlike `build` (which emits .js), it returns
 // transformed TypeScript: typia's per-file node transformer runs in an
 // EmitContext and the result SourceFile is printed back as TS (no JS script
 // transformers), so injected namespace imports stay as ES imports the caller
@@ -103,7 +103,7 @@ func runTransform(args []string) int {
       fmt.Fprintln(stderr, "ttsc-typia transform: --out requires --file")
       return 2
     }
-    return runTransformProject(prog, cwd, typiaTransform, &transformDiags)
+    return runTransformProject(prog, cwd, typiaTransform, &transformDiags, &extras)
   }
 
   absFile := *file
@@ -190,11 +190,25 @@ func runTransformSingle(
 // dependencies[F]), so graph is added alongside dependencies, not a replacement.
 // Every section keys through driver.TransformOutputKey, so the consumer joins
 // them by key.
+//
+// A third section, `dependenciesComplete`, names the files whose `dependencies`
+// entry is the whole story, and for those the consumer stops unioning: it
+// derives dependencies[F] ∪ configs ∪ candidates and drops reach(edges, F) and
+// globals. That is the difference between re-validating the reference closure
+// of a file and re-validating the handful of declarations typia read, paid once
+// per delivered module, and for the majority of a project's files -- the ones
+// with no typia call at all -- between the closure and nothing.
+//
+// The declaration transfers responsibility, so it is made per file and only
+// where the collector could bound the file's inputs; the dependency listener
+// and the diagnostic report this function wires are what decide that
+// (samchon/typia#2357). See transformDependencyCollector.Unbound.
 func runTransformProject(
   prog *driver.Program,
   cwd string,
   typiaTransform driver.PluginTransform,
   transformDiags *[]typiaTransformDiagnostic,
+  extras *nativecontext.ITypiaContext_Extras,
 ) int {
   out := transformProjectOutput{
     Diagnostics: []transformCompilerDiagnostic{},
@@ -209,8 +223,27 @@ func runTransformProject(
     sf := prog.SourceFile(fileName)
     return sf != nil && prog.TSProgram.IsLibFile(sf)
   })
-  schemametadata.MetadataDependency_listen(prog.Checker, collector.Touch)
+  // Only this host declares completeness, which is why only this host asks the
+  // analysis to admit what it could not bound: every such admission costs one
+  // file its declaration and nothing else.
+  schemametadata.MetadataDependency_listen(prog.Checker, schemametadata.MetadataDependency_IListener{
+    File:      collector.Touch,
+    Callee:    collector.TouchCallee,
+    Unbounded: collector.Unbound,
+  })
   defer schemametadata.MetadataDependency_release(prog.Checker)
+  // A diagnostic means typia could not finish lowering a call in the file being
+  // transformed, so what the analysis consulted before giving up is not that
+  // file's whole input set: an edit to a declaration it never reached could make
+  // the same call succeed and publish different text. The build fails either
+  // way, but a false claim is still false, so withhold the declaration rather
+  // than reason about how far the analysis got. The transformer reads `extras`
+  // on every call, so wrapping it through the pointer reaches the loop below.
+  reportDiagnostic := extras.AddDiagnostic
+  extras.AddDiagnostic = func(diag *nativecontext.ITypiaDiagnostic) int {
+    collector.Unbound()
+    return reportDiagnostic(diag)
+  }
   for _, sf := range prog.SourceFiles() {
     if sf.IsDeclarationFile {
       continue
@@ -221,8 +254,16 @@ func runTransformProject(
     }
     collector.Begin(key)
     out.TypeScript[key] = transformFileToTypeScript(prog, typiaTransform, sf)
+    collector.End()
   }
   out.Dependencies = collector.ToJSON()
+  // The config chain is the one input that stays universal for a declared file,
+  // and it reaches the consumer through this same envelope's graph. Declaring
+  // completeness without a graph would leave nothing universal behind, so a
+  // tsconfig edit would stop invalidating the files the declaration narrowed.
+  if out.Graph != nil {
+    out.DependenciesComplete = collector.ToCompleteJSON(out.TypeScript)
+  }
   for _, diag := range *transformDiags {
     out.Diagnostics = append(out.Diagnostics, transformDiagnosticToCompilerDiagnostic(diag))
   }
@@ -359,24 +400,62 @@ type transformProjectOutput struct {
   // files are excluded (toolchain-versioned, not project inputs);
   // `node_modules` declaration files are included.
   Dependencies map[string][]string `json:"dependencies,omitempty"`
+  // DependenciesComplete lists the TypeScript keys whose Dependencies entry is
+  // exhaustive: nothing outside that entry, the file itself, and the universal
+  // config chain can change the file's transformed text. The consumer stops
+  // widening those files with the reference closure and the global-scope set.
+  //
+  // Unlisted is always the safe answer, so the list carries only what the
+  // collector could bound. An older ttsc ignores the field; 0.19.3 and newer
+  // narrow on it.
+  DependenciesComplete []string `json:"dependenciesComplete,omitempty"`
 }
 
 // transformDependencyCollector accumulates the consulted-declaration files the
 // metadata dependency listener reports while one project file is transformed,
-// attributing them to that file's envelope key.
+// attributing them to that file's envelope key, and decides which of those keys
+// may be declared complete.
 type transformDependencyCollector struct {
   cwd     string
   current string
   files   map[string]map[string]bool
+  // unbounded holds the keys withheld from the completeness declaration. It is
+  // a set of exclusions rather than a set of admissions because every path that
+  // learns a file cannot be bounded runs while that file is being transformed,
+  // whereas nothing ever proves the opposite: a file is declarable exactly when
+  // no such path fired for it.
+  unbounded map[string]bool
   // isLibraryFile reports the compiler's own classification of a file as a
   // default library. Classification must come from the program, never from a
   // filename pattern: a project's own ambient declaration file may legitimately
   // be named `lib.custom.d.ts`, and dropping it by basename silently loses
   // cache invalidation for the types it declares (samchon/typia#2108).
   isLibraryFile func(fileName string) bool
-  // values memoizes fileName -> envelope value ("" for a dropped file): the
-  // listener reports the same declaration files repeatedly across call sites.
-  values map[string]string
+  // values memoizes fileName -> rendered envelope value: the listener reports
+  // the same declaration files repeatedly across call sites.
+  values map[string]transformDependencyValue
+}
+
+// transformDependencyBundledScheme is the prefix tsgo gives its embedded default
+// libraries, and the one `driver.NewTransformGraph` drops from the host-owned
+// reference graph.
+const transformDependencyBundledScheme = "bundled:///"
+
+// transformDependencyValue is one reported file rendered for the envelope: its
+// key, or the reason it was dropped. The reasons differ in what they cost a
+// completeness declaration, so they cannot both collapse to an empty value.
+type transformDependencyValue struct {
+  // key is the envelope value, empty when the file was dropped.
+  key string
+  // withhold marks a file this envelope cannot report but the host-owned bound
+  // still carries, so narrowing to the reported list would lose it.
+  withhold bool
+  // libraryOnly marks a withhold whose only cause is the compiler classifying
+  // the file as a default library. Such a file can change a consulted type and
+  // so a generated validator, but never which declaration a call resolves to,
+  // which is why the identity channel drops it without withholding
+  // (samchon/typia#2361).
+  libraryOnly bool
 }
 
 func newTransformDependencyCollector(
@@ -387,7 +466,8 @@ func newTransformDependencyCollector(
     cwd:           cwd,
     isLibraryFile: isLibraryFile,
     files:         map[string]map[string]bool{},
-    values:        map[string]string{},
+    unbounded:     map[string]bool{},
+    values:        map[string]transformDependencyValue{},
   }
 }
 
@@ -396,11 +476,61 @@ func (collector *transformDependencyCollector) Begin(key string) {
   collector.current = key
 }
 
+// End closes the attribution window Begin opened. Nothing consults the checker
+// between two files today, so this changes no output; it is what keeps that
+// true, because a touch that arrives outside a window is dropped rather than
+// charged -- or worse, withheld -- against whichever file happened to run last.
+func (collector *transformDependencyCollector) End() {
+  collector.current = ""
+}
+
+// Unbound withholds the completeness declaration from the file being
+// transformed. The file keeps its reported dependencies and falls back to the
+// host-owned reference-closure bound, which is what an unlisted file gets and
+// is always sound. Its callers name the reasons: an input the analysis could
+// only read from an inferred position, a consulted on-disk default library, and
+// a call typia could not lower.
+func (collector *transformDependencyCollector) Unbound() {
+  if collector.current == "" {
+    return
+  }
+  collector.unbounded[collector.current] = true
+}
+
 // Touch records one consulted declaration file for the current key. Default
 // library files, virtual URI sources (e.g. tsgo's `bundled:///` libraries),
 // and the transformed file itself are dropped so the envelope carries only
 // actionable project inputs.
+//
+// A drop the host-owned bound does not share also withholds the current file's
+// completeness declaration: the graph still carries that file, so a narrowed
+// file would stop watching an input the default bound watches.
 func (collector *transformDependencyCollector) Touch(fileName string) {
+  collector.touch(fileName, true)
+}
+
+// TouchCallee records one file reached while deciding WHICH declaration a call
+// resolves to, and does not let a default library withhold the current file.
+//
+// A default library is dropped from the reported list either way -- that
+// contract is samchon/typia#2108's -- but the withholding beside it belongs to
+// the type channel alone. Under `libReplacement` a replaced library can change
+// a generated validator, so a file that consulted one has to give up its
+// declaration. It can never change which declaration a call resolves to:
+// callExpressionTransformer_targetModule recognizes typia's own calls by a path
+// ending in `/typia/lib/<file>.d.ts` or `/typia/src/<file>.ts`, and a file the
+// compiler classifies as a default library satisfies neither wherever it sits
+// on disk. Withholding there cost a file its declaration for calling
+// `table.get(...)`, and under `noembed` -- where every library is a real file --
+// for calling anything at all (samchon/typia#2361).
+//
+// A virtual non-`bundled:///` scheme still withholds on both channels: that drop
+// is about being unwatchable, not about being a library.
+func (collector *transformDependencyCollector) TouchCallee(fileName string) {
+  collector.touch(fileName, false)
+}
+
+func (collector *transformDependencyCollector) touch(fileName string, library bool) {
   if collector.current == "" {
     return
   }
@@ -409,7 +539,10 @@ func (collector *transformDependencyCollector) Touch(fileName string) {
     value = collector.value(fileName)
     collector.values[fileName] = value
   }
-  if value == "" || value == collector.current {
+  if value.withhold && (library || value.libraryOnly == false) {
+    collector.Unbound()
+  }
+  if value.key == "" || value.key == collector.current {
     return
   }
   set := collector.files[collector.current]
@@ -417,19 +550,36 @@ func (collector *transformDependencyCollector) Touch(fileName string) {
     set = map[string]bool{}
     collector.files[collector.current] = set
   }
-  set[value] = true
+  set[value.key] = true
 }
 
-// value renders one reported file as its envelope value, or "" when the file
-// must be dropped: virtual URI sources (e.g. tsgo's `bundled:///` embedded
-// libraries) cannot be watched, and files the compiler classifies as default
-// libraries (on-disk in `noembed` or `libReplacement` configurations) are
-// toolchain inputs, not project inputs.
-func (collector *transformDependencyCollector) value(fileName string) string {
-  if strings.Contains(fileName, "://") || collector.isLibraryFile(fileName) {
-    return ""
-  }
-  return driver.TransformOutputKey(collector.cwd, fileName)
+// value renders one reported file as its envelope value, or records why it must
+// be dropped.
+//
+// tsgo's embedded libraries under `bundled:///` are nobody's input:
+// `driver.NewTransformGraph` skips that exact prefix, so dropping them leaves
+// the reported list and the host-owned bound in agreement and costs a
+// completeness declaration nothing. Any other URI scheme is unwatchable for us
+// but still reaches the graph, so it is dropped AND withheld -- the asymmetry
+// only runs in the safe direction.
+//
+// A file the compiler classifies as a default library is a toolchain input
+// rather than a project input, which is why the envelope has never reported one.
+// Under `noembed` or `libReplacement` it is nevertheless a real path that
+// `graph.globals` carries, so the default bound watches it while a narrowed file
+// would not. Keep dropping it from the reported list -- that contract is
+// #2108's -- and withhold the declaration from the file that consulted it.
+func (collector *transformDependencyCollector) value(fileName string) transformDependencyValue {
+  if strings.HasPrefix(fileName, transformDependencyBundledScheme) {
+    return transformDependencyValue{}
+  }
+  if strings.Contains(fileName, "://") {
+    return transformDependencyValue{withhold: true}
+  }
+  if collector.isLibraryFile(fileName) {
+    return transformDependencyValue{withhold: true, libraryOnly: true}
+  }
+  return transformDependencyValue{key: driver.TransformOutputKey(collector.cwd, fileName)}
 }
 
 // ToJSON renders the collected sets as the envelope's `dependencies` map with
@@ -456,6 +606,30 @@ func (collector *transformDependencyCollector) ToJSON() map[string][]string {
   return output
 }
 
+// ToCompleteJSON renders the envelope's `dependenciesComplete` list: every key
+// the transform published except the ones the collector could not bound.
+//
+// The published map is the input rather than the entries of ToJSON. A file typia
+// never touched reports no dependency at all, and that empty entry is the
+// strongest claim in the envelope -- nothing outside the file can change a
+// faithful re-print -- so reading the dependency map instead would drop the
+// majority of the narrowing on the floor. Taking the same map the consumer keys
+// on also makes the list a subset of it by construction.
+func (collector *transformDependencyCollector) ToCompleteJSON(published map[string]string) []string {
+  output := make([]string, 0, len(published))
+  for key := range published {
+    if collector.unbounded[key] {
+      continue
+    }
+    output = append(output, key)
+  }
+  if len(output) == 0 {
+    return nil
+  }
+  sort.Strings(output)
+  return output
+}
+
 type transformCompilerDiagnostic struct {
   File        *string `json:"file"`
   Category    string  `json:"category"`

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

@@ -131,6 +131,7 @@ func ttscTypiaTestWriteCommonRuntimeStubs(t *testing.T, runtimeDir string) {
     "assert-guard-stub.cjs":            ttscTypiaTestAssertGuardStub,
     "functional-error-stub.cjs":        ttscTypiaTestFunctionalErrorStub,
     "access-expression-stub.cjs":       ttscTypiaTestAccessExpressionStub,
+    "string-length-stub.cjs":           ttscTypiaTestStringLengthStub,
     "notation-stub.cjs":                ttscTypiaTestNotationStub,
     "json-stringify-array-stub.cjs":    ttscTypiaTestJsonStringifyArrayStub,
     "json-stringify-property-stub.cjs": ttscTypiaTestJsonStringifyPropertyStub,
@@ -153,6 +154,7 @@ func ttscTypiaTestRewriteCommonJS(t *testing.T, js string) string {
   runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_assertGuard")`, `require("./assert-guard-stub.cjs")`)
   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/_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")`)
@@ -290,6 +292,16 @@ 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.
+const ttscTypiaTestStringLengthStub = `module.exports._stringLength = (value) => {
+  let count = 0;
+  for (const _ of value) ++count;
+  return count;
+};
+`
+
 const ttscTypiaTestAccessExpressionStub = `const reserved = new Set([
   "break",
   "case",

package/native/core/factories/MetadataCommentTagFactory.go

@@ -196,6 +196,34 @@ func (metadataCommentTagFactoryNamespace) Get(props struct {
   return output
 }
 
+// metadataCommentTagFactory_PARSER maps a JSDoc tag name to the tag records it
+// produces. Each record's `Validate` is the runtime check the transform splices
+// into the emitted validator, and it must spell the same check as the matching
+// declaration in `packages/interface/src/tags` -- the two are one constraint.
+//
+// # WHEN A RECORD MAY NAME A RUNTIME HELPER
+//
+// A `Validate` may write `$importInternal("x")`, here or in the matching
+// declaration, only under the rule below.
+//
+// That call makes the emitted validator `require("typia/lib/internal/_x")`. The
+// type-tag half of each constraint is declared in `@typia/interface`, which
+// `typia` depends on through a caret range, and a caret only floats upward. So
+// inside one major an older `typia` installs a newer `@typia/interface` and
+// emits an import its own runtime never published; that is #2330, and it is why
+// #2336 and #2339 reverted these very templates to inline expressions.
+//
+// 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.
+//
+// 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.
 var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_parser{
   "items": func(props struct {
     Report func(msg string) any
@@ -268,7 +296,13 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    return metadataCommentTagFactory_numeric(props, "MultipleOf", "multipleOf", "$input % "+props.Value+" === 0", "$input % "+props.Value+"n === 0n")
+    // `@multipleOf` and `MultipleOf<N>` are two spellings of one constraint, so
+    // the number arm divides exact decimals through the same helper the type tag
+    // names. `%` would divide the binary doubles that are actually stored, which
+    // 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")
   },
   "format": func(props struct {
     Report func(msg string) any
@@ -291,9 +325,16 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
     Value  string
   }) metadataCommentTagFactory_TagRecord {
     value := metadataCommentTagFactory_parse_number(props)
+    // `@length`, `@minLength`, and `@maxLength` measure through the same helper
+    // `MinLength<N>` and `MaxLength<N>` name, because the JSDoc spelling and the
+    // type-tag spelling of one constraint must never mean different things.
+    // `$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.
     return metadataCommentTagFactory_TagRecord{"string": {
-      {Name: "MinLength<" + props.Value + ">", Target: "string", Kind: "minLength", Value: value, Validate: props.Value + " <= $input.length", Exclusive: metadataCommentTagFactory_exclusive("minLength"), Schema: map[string]any{"minLength": value}},
-      {Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$input.length <= " + props.Value, Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}},
+      {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}},
     }}
   },
   "minLength": func(props struct {
@@ -301,14 +342,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 + " <= $input.length", 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: props.Value + " <= $importInternal(\"_stringLength\")($input)", 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: "$input.length <= " + 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(\"_stringLength\")($input) <= " + props.Value, Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}}}}
   },
 }
 
@@ -407,28 +448,23 @@ func metadataCommentTagFactory_parse_type(props struct {
     "number": {{Name: "Type<" + strconv.Quote(value) + ">", Target: "number", Kind: "type", Value: value, Validate: validate, Exclusive: metadataCommentTagFactory_exclusive("type"), Schema: numberSchema}},
   }
   if value == "int64" || value == "uint64" {
-    // Both checks stay inline, spelled exactly as `Type<"int64">` and
-    // `Type<"uint64">` declare them, because `@type int64` and
-    // `bigint & Type<"int64">` are two spellings of one constraint.
+    // `@type int64` and `bigint & Type<"int64">` are two spellings of one
+    // constraint, so both delegate to the helper that holds the exact inclusive
+    // bound. The bigint form used to emit `true` for int64 and a lower bound
+    // only for uint64, which certified any magnitude at all -- and
+    // `typia.protobuf.encode` then truncated the value to 64 bits, so a
+    // certified value came back different.
     //
-    // That declaration must not name a runtime helper the way the `number` arms
-    // above do. A `$importInternal(...)` in a tag template makes the emitted
-    // validator import a `typia/lib/internal/*` module, and the declaration
-    // lives in `@typia/interface`, which `typia` depends on through a caret
-    // range that only floats upward -- so an older `typia` installs a newer
-    // `@typia/interface` and emits an import its own runtime never shipped
-    // (#2330). `isTypeInt64` and `isTypeUint64` are safe there because
-    // `@typia/interface` 13.0.0 already named them and `typia` 13.0.0 already
-    // shipped them; a helper introduced later is not, and inside one major
-    // there is no range that prevents the pairing.
+    // The bound has to live in a helper rather than an inline literal here
+    // because it is only exact as a string: `BigInt(9223372036854775807)` rounds
+    // its `number` literal to 2**63 before BigInt ever parses it.
     //
-    // The bound this leaves unenforced is real: int64 accepts any magnitude and
-    // uint64 only rejects negatives. #2338 owns restoring it, and only a major
-    // can carry it -- an inline exact comparison would name no helper, but
-    // tightening an accepted range rejects data that passes today.
-    bigintValidate := "BigInt(0) <= $input"
+    // See the `metadataCommentTagFactory_PARSER` doc comment: naming a helper
+    // here is safe only under a major bump, and `_isTypeInt64Bigint` /
+    // `_isTypeUint64Bigint` first shipped in 13.1.19.
+    bigintValidate := "$importInternal(\"isTypeUint64Bigint\")($input)"
     if value == "int64" {
-      bigintValidate = "true"
+      bigintValidate = "$importInternal(\"isTypeInt64Bigint\")($input)"
     }
     record["bigint"] = []schemametadata.IMetadataTypeTag{
       {Name: "Type<" + strconv.Quote(value) + ">", Target: "bigint", Kind: "type", Value: value, Validate: bigintValidate, Exclusive: metadataCommentTagFactory_exclusive("type"), Schema: bigintSchema},
@@ -452,7 +488,7 @@ func metadataCommentTagFactory_numeric(props struct {
     "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: int64(*integer), Validate: bigintValidate, Exclusive: exclusive, Schema: map[string]any{kind: number}}}
+    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}}}
   }
   return record
 }
@@ -473,7 +509,7 @@ func metadataCommentTagFactory_parse_integer(props struct {
   Report   func(msg string) any
   Unsigned bool
   Value    string
-}) *int {
+}) *int64 {
   parsedAny := metadataCommentTagFactory_parse_number(struct {
     Report func(msg string) any
     Value  string
@@ -490,10 +526,43 @@ func metadataCommentTagFactory_parse_integer(props struct {
     props.Report("invalid unsigned integer")
     return nil
   }
-  value := int(parsed)
+  // A float64 outside the destination range converts by an
+  // implementation-defined rule, not by wrapping: on amd64 both `1e19` and
+  // `-1e19` become -9223372036854775808, so a magnitude and its negation
+  // collapse to the same wrong number. Reject instead, because a tag whose value
+  // cannot be carried is a tag whose meaning is already lost.
+  if parsed < metadataCommentTagFactory_INT64_MINIMUM || parsed >= metadataCommentTagFactory_INT64_EXCLUSIVE_MAXIMUM {
+    props.Report("integer out of range")
+    return nil
+  }
+  value := int64(parsed)
   return &value
 }
 
+// The int64 range as float64 bounds.
+//
+// int64 rather than int, because `int` is 32 bits on the 32-bit platforms ttsc
+// publishes a binary for (`@ttsc/linux-arm`). Bounding by `int` would make the
+// same `@minimum 3000000000` on a `bigint` compile on x64 and either be rejected
+// or silently converted out of range on arm, and the value is already widened to
+// int64 at its only numeric use. Bounding by int64 is what the tag means on
+// every platform.
+//
+// The maximum is exclusive and spelled 2**63 rather than math.MaxInt64, because
+// the inclusive form does not survive the comparison. An untyped constant
+// 9223372036854775807.0 rounds to 2**63 once it meets a float64 operand, so
+// `parsed > max` compares 2**63 against 2**63 and lets the one value through
+// that int64 cannot hold. A strict `>=` against 2**63 is exact instead: no
+// float64 lies between 2**63 - 1024 and 2**63, so rejecting from 2**63 up
+// rejects exactly the magnitudes int64 cannot represent.
+//
+// The minimum needs no such care -- -2**63 is math.MinInt64 and is exactly
+// representable as a float64.
+const (
+  metadataCommentTagFactory_INT64_MINIMUM           = -9223372036854775808.0
+  metadataCommentTagFactory_INT64_EXCLUSIVE_MAXIMUM = 9223372036854775808.0
+)
+
 func metadataCommentTagFactory_includes(values []string, target string) bool {
   for _, value := range values {
     if value == target {

package/native/core/factories/metadata_comment_tag_factory_coverage_test.go

@@ -124,8 +124,8 @@ func TestMetadataCommentTagFactoryCoverage(t *testing.T) {
   if len(reports) != decimalReportCount || len(decimal["number"]) != 1 || len(decimal["bigint"]) != 0 {
     t.Fatalf("decimal multipleOf must remain a number-only JSDoc tag: %#v, reports=%#v", decimal, reports[decimalReportCount:])
   }
-  if decimal["number"][0].Validate != "$input % 0.01 === 0" {
-    t.Fatalf("decimal multipleOf must spell the same remainder check the MultipleOf type tag declares: %s", decimal["number"][0].Validate)
+  if decimal["number"][0].Validate != "$importInternal(\"_isMultipleOf\")($input, 0.01)" {
+    t.Fatalf("decimal multipleOf must use the shared exact helper: %s", decimal["number"][0].Validate)
   }
   invalidBefore := len(reports)
   _ = metadataCommentTagFactory_parse_number(struct {