typia 13.1.1 → 13.2.0

package/native/core/factories/IdentifierFactory.go

@@ -1,8 +1,9 @@
 package factories
 
 import (
-  "strconv"
+  "fmt"
   "strings"
+  "unicode/utf8"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimprinter "github.com/microsoft/typescript-go/shim/printer"
@@ -71,12 +72,138 @@ func (identifierFactoryNamespace) GetName(input *shimast.Expression) string {
   return "unknown"
 }
 
+// Postfix renders the accessor for `str` as JavaScript source for a string
+// literal, because callers splice the result straight into emitted text (see
+// AssertProgrammer and ValidateProgrammer building `_path + <postfix>`).
+//
+// The value of that literal must equal what the runtime helper
+// `typia/lib/internal/_accessExpressionAsString` computes for the same key,
+// since dynamic keys take that runtime path while sole-literal keys are folded
+// here at compile time. Both must produce one path grammar, which
+// `typia/lib/internal/_createStandardSchema` parses back with JSON.parse.
+//
+// So there are two nested levels, and they escape for different readers. The
+// key becomes JSON text, which is part of the path a user sees and JSON.parse
+// reads. That text is then embedded in JavaScript source. Escaping only one
+// level emits a file that does not parse; escaping both for the same reader
+// makes the reported path disagree with the runtime helper.
 func (identifierFactoryNamespace) Postfix(str string) string {
   if identifierFactory_variable(str) {
-    return "\"." + str + "\""
+    return identifierFactory_source("." + str)
   }
-  quoted := strings.ReplaceAll(strconv.Quote(str), "\"", "\\\"")
-  return "\"[" + quoted + "]\""
+  return identifierFactory_source("[" + 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
+// key back out.
+func identifierFactory_json(str string) string {
+  return identifierFactory_quote(str, false)
+}
+
+// identifierFactory_source renders `str` as JavaScript source for a string
+// literal whose value is exactly `str`.
+//
+// This is JSON's escape set plus the line separators. JSON string syntax is
+// otherwise a subset of JavaScript's: both forbid a raw `"` and `\`, and JSON
+// already escapes every character below U+0020, which covers the CR and LF that
+// JavaScript also forbids raw. U+2028 and U+2029 are the whole difference, being
+// line terminators to JavaScript but ordinary characters to JSON.
+func identifierFactory_source(str string) string {
+  return identifierFactory_quote(str, true)
+}
+
+// identifierFactory_quote writes a quoted literal, escaping the line separators
+// only when the reader is a JavaScript parser.
+//
+// strconv.Quote cannot serve either role: it escapes for Go, and Go and
+// JavaScript disagree. Quote renders U+0007 as `\a` and a non-printable astral
+// rune as `\U0001d173`; JavaScript has neither escape and decodes them as the
+// identity escapes `a` and `U`, silently corrupting the key, while JSON.parse
+// rejects both outright.
+func identifierFactory_quote(str string, source bool) string {
+  var builder strings.Builder
+  builder.Grow(len(str) + 2)
+  builder.WriteByte('"')
+  for i := 0; i < len(str); {
+    if char := str[i]; char < utf8.RuneSelf {
+      i++
+      switch char {
+      case '"':
+        builder.WriteString("\\\"")
+      case '\\':
+        builder.WriteString("\\\\")
+      case '\b':
+        builder.WriteString("\\b")
+      case '\f':
+        builder.WriteString("\\f")
+      case '\n':
+        builder.WriteString("\\n")
+      case '\r':
+        builder.WriteString("\\r")
+      case '\t':
+        builder.WriteString("\\t")
+      default:
+        // JSON forbids a raw control character in a string, and JSON.parse
+        // throws on one rather than reporting the validation issue that the
+        // path belongs to. Every other ASCII byte is safe verbatim.
+        if char < 0x20 {
+          builder.WriteString(identifierFactory_unicode_escape(rune(char)))
+        } else {
+          builder.WriteByte(char)
+        }
+      }
+      continue
+    }
+    if unit, size := identifierFactory_surrogate(str[i:]); size != 0 {
+      // A lone surrogate reaches here WTF-8 encoded and has no valid UTF-8
+      // form, so it survives only as an escape. JSON.stringify does the same.
+      builder.WriteString(identifierFactory_unicode_escape(unit))
+      i += size
+      continue
+    }
+    rune_, size := utf8.DecodeRuneInString(str[i:])
+    if rune_ == utf8.RuneError && size == 1 {
+      // Not UTF-8 at all. No escape can denote the byte, so spend the
+      // replacement character and keep the literal well-formed; the
+      // alternative is emitting a file that does not parse.
+      builder.WriteString(identifierFactory_unicode_escape(utf8.RuneError))
+      i++
+      continue
+    }
+    if source && (rune_ == '\u2028' || rune_ == '\u2029') {
+      // A line terminator to JavaScript, so a raw one would end the literal on
+      // a target below ES2019. Escaping it in the source is invisible to the
+      // reader of the path, because JavaScript decodes it straight back.
+      builder.WriteString(identifierFactory_unicode_escape(rune_))
+      i += size
+      continue
+    }
+    builder.WriteString(str[i : i+size])
+    i += size
+  }
+  builder.WriteByte('"')
+  return builder.String()
+}
+
+// identifierFactory_unicode_escape writes the `\uXXXX` form, which denotes one
+// UTF-16 code unit and so only spans the Basic Multilingual Plane. Every caller
+// passes a control character, a surrogate, or the replacement character; an
+// astral rune needs no escape and must keep taking the verbatim path, because
+// four hex digits cannot spell it.
+func identifierFactory_unicode_escape(value rune) string {
+  return fmt.Sprintf("\\u%04x", value)
+}
+
+// identifierFactory_surrogate decodes a leading WTF-8 encoded surrogate code
+// unit, which utf8.DecodeRuneInString reports as an error because no valid
+// UTF-8 sequence denotes one.
+func identifierFactory_surrogate(str string) (rune, int) {
+  if len(str) < 3 || str[0] != 0xed || str[1] < 0xa0 || str[1] > 0xbf || str[2] < 0x80 || str[2] > 0xbf {
+    return 0, 0
+  }
+  return rune(str[0]&0x0f)<<12 | rune(str[1]&0x3f)<<6 | rune(str[2]&0x3f), 3
 }
 
 func (identifierFactoryNamespace) Parameter(name any, typeNode *shimast.TypeNode, init *shimast.Node, emit ...*shimprinter.EmitContext) *shimast.Node {

package/native/core/factories/MetadataCommentTagFactory.go

@@ -207,8 +207,8 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
       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: true, Schema: map[string]any{"minItems": value}},
-      {Name: "MaxItems<" + props.Value + ">", Target: "array", Kind: "maxItems", Value: value, Validate: "$input.length <= " + props.Value, Exclusive: true, Schema: map[string]any{"maxItems": value}},
+      {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}},
     }}
   },
   "minItems": func(props struct {
@@ -220,7 +220,7 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
       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: true, Schema: map[string]any{"minItems": value}}}}
+    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}}}}
   },
   "maxItems": func(props struct {
     Report func(msg string) any
@@ -231,60 +231,60 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
       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: true, Schema: map[string]any{"maxItems": value}}}}
+    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}}}}
   },
   "uniqueItems": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    return metadataCommentTagFactory_TagRecord{"array": {{Name: "UniqueItems", Target: "array", Kind: "uniqueItems", Value: true, Validate: "$input.length <= 1 || (new Set($input).size === $input.length)", Exclusive: true, Schema: map[string]any{"uniqueItems": true}}}}
+    return metadataCommentTagFactory_TagRecord{"array": {{Name: "UniqueItems", Target: "array", Kind: "uniqueItems", Value: true, Validate: "$importInternal(\"isUniqueItems\")($input)", Exclusive: metadataCommentTagFactory_exclusive("uniqueItems"), Schema: map[string]any{"uniqueItems": true}}}}
   },
   "type": metadataCommentTagFactory_parse_type,
   "minimum": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    return metadataCommentTagFactory_numeric(props, "Minimum", "minimum", props.Value+" <= $input", props.Value+" <= $input", []string{"minimum", "exclusiveMinimum"})
+    return metadataCommentTagFactory_numeric(props, "Minimum", "minimum", props.Value+" <= $input", 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, []string{"maximum", "exclusiveMaximum"})
+    return metadataCommentTagFactory_numeric(props, "Maximum", "maximum", "$input <= "+props.Value, "$input <= "+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", []string{"minimum", "exclusiveMinimum"})
+    return metadataCommentTagFactory_numeric(props, "ExclusiveMinimum", "exclusiveMinimum", props.Value+" < $input", 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, []string{"maximum", "exclusiveMaximum"})
+    return metadataCommentTagFactory_numeric(props, "ExclusiveMaximum", "exclusiveMaximum", "$input < "+props.Value, "$input < "+props.Value)
   },
   "multipleOf": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    return metadataCommentTagFactory_numeric(props, "MultipleOf", "multipleOf", "$input % "+props.Value+" === 0", "$input % "+props.Value+"n === 0n", true)
+    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
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    matched, ok := metadataCommentTagFactory_FORMATS[props.Value]
+    name, validate, ok := formatCheatSheet_resolve(props.Value)
     if ok == false {
       return metadataCommentTagFactory_TagRecord{}
     }
-    return metadataCommentTagFactory_TagRecord{"string": {{Name: "Format<" + strconv.Quote(matched[0]) + ">", Target: "string", Kind: "format", Value: matched[0], Validate: matched[1], Exclusive: true, Schema: map[string]any{"format": matched[0]}}}}
+    return metadataCommentTagFactory_TagRecord{"string": {{Name: "Format<" + strconv.Quote(name) + ">", Target: "string", Kind: "format", Value: name, Validate: validate, Exclusive: metadataCommentTagFactory_exclusive("format"), Schema: map[string]any{"format": name}}}}
   },
   "pattern": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    return metadataCommentTagFactory_TagRecord{"string": {{Name: "Pattern<" + strconv.Quote(props.Value) + ">", Target: "string", Kind: "pattern", Value: props.Value, Validate: "RegExp(" + strconv.Quote(props.Value) + ").test($input)", Exclusive: []string{"format"}, Schema: map[string]any{"pattern": props.Value}}}}
+    return metadataCommentTagFactory_TagRecord{"string": {{Name: "Pattern<" + strconv.Quote(props.Value) + ">", Target: "string", Kind: "pattern", Value: props.Value, Validate: "RegExp(" + strconv.Quote(props.Value) + ").test($input)", Exclusive: metadataCommentTagFactory_exclusive("pattern"), Schema: map[string]any{"pattern": props.Value}}}}
   },
   "length": func(props struct {
     Report func(msg string) any
@@ -292,8 +292,8 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
   }) 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: true, Schema: map[string]any{"minLength": value}},
-      {Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$input.length <= " + props.Value, Exclusive: true, 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,17 +301,58 @@ 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: true, 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: true, 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}}}}
   },
 }
 
+// metadataCommentTagFactory_EXCLUSIVE is the single authority for every JSDoc
+// comment tag's mutual-exclusivity rule, keyed by tag kind and transcribing the
+// `exclusive` field the matching @typia/interface tag declares
+// (packages/interface/src/tags/*.ts). The JSDoc path and the type-tag path must
+// enforce the same exclusivity, because MetadataTypeTagFactory.Validate reads
+// this list for both; the type-tag path takes it straight from the declaration,
+// so the comment path must publish the identical value. Hand-copying a separate
+// list per parser is exactly what let `@format` (a bare `true`) and `@pattern`
+// (`["format"]`, missing its own kind) drift from the declared
+// `["format", "pattern"]`. Every parser now reads its list from here, so no one
+// list can diverge on its own again. Each `[]string` names its own kind plus
+// every cross-kind partner it may not share a property with, in the declaration
+// order; `true` forbids only same-kind duplication.
+var metadataCommentTagFactory_EXCLUSIVE = map[string]any{
+  "minItems":         true,
+  "maxItems":         true,
+  "uniqueItems":      true,
+  "type":             true,
+  "minimum":          []string{"minimum", "exclusiveMinimum"},
+  "maximum":          []string{"maximum", "exclusiveMaximum"},
+  "exclusiveMinimum": []string{"exclusiveMinimum", "minimum"},
+  "exclusiveMaximum": []string{"exclusiveMaximum", "maximum"},
+  "multipleOf":       true,
+  "format":           []string{"format", "pattern"},
+  "pattern":          []string{"format", "pattern"},
+  "minLength":        true,
+  "maxLength":        true,
+}
+
+// metadataCommentTagFactory_exclusive returns the declared exclusivity rule for
+// a tag kind. It panics on an unknown kind so a newly added comment tag that
+// forgets its rule fails loudly here rather than silently emitting a tag with a
+// nil `Exclusive` that the validator would never check.
+func metadataCommentTagFactory_exclusive(kind string) any {
+  value, ok := metadataCommentTagFactory_EXCLUSIVE[kind]
+  if ok == false {
+    panic("no exclusive rule for comment tag kind: " + kind)
+  }
+  return value
+}
+
 func metadataCommentTagFactory_parse_type(props struct {
   Report func(msg string) any
   Value  string
@@ -342,11 +383,15 @@ func metadataCommentTagFactory_parse_type(props struct {
   } else if value == "uint32" {
     validate = "Math.floor($input) === $input && 0 <= $input && $input <= 4294967295"
   } else if value == "int64" {
-    validate = "Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807"
+    // Delegate to the runtime helper instead of restating the bound. The 64-bit
+    // maxima are not representable as JavaScript numbers, so an inline literal
+    // here silently rounds up and admits an out-of-range value; the helper owns
+    // the one correct spelling and documents why it is exclusive.
+    validate = "$importInternal(\"isTypeInt64\")($input)"
   } else if value == "uint64" {
-    validate = "Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615"
+    validate = "$importInternal(\"isTypeUint64\")($input)"
   } else if value == "float" {
-    validate = "-1.175494351e38 <= $input && $input <= 3.4028235e38"
+    validate = "-3.4028235e38 <= $input && $input <= 3.4028235e38"
   }
   var numberSchema any
   if value == "int8" || value == "int16" || value == "int32" || value == "int64" {
@@ -359,11 +404,19 @@ func metadataCommentTagFactory_parse_type(props struct {
     bigintSchema = map[string]any{"minimum": 0}
   }
   record := metadataCommentTagFactory_TagRecord{
-    "number": {{Name: "Type<" + strconv.Quote(value) + ">", Target: "number", Kind: "type", Value: value, Validate: validate, Exclusive: true, Schema: numberSchema}},
+    "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" {
+    // The bigint form used to emit `true` for int64 and a lower bound only for
+    // uint64, so `bigint & Type<"int64">` -- the spelling the documentation
+    // recommends -- certified any magnitude at all. Both now delegate to the
+    // helper that holds the exact inclusive bound a bigint can represent.
+    bigintValidate := "$importInternal(\"isTypeUint64Bigint\")($input)"
+    if value == "int64" {
+      bigintValidate = "$importInternal(\"isTypeInt64Bigint\")($input)"
+    }
     record["bigint"] = []schemametadata.IMetadataTypeTag{
-      {Name: "Type<" + strconv.Quote(value) + ">", Target: "bigint", Kind: "type", Value: value, Validate: map[bool]string{true: "true", false: "BigInt(0) <= $input"}[value == "int64"], Exclusive: true, Schema: bigintSchema},
+      {Name: "Type<" + strconv.Quote(value) + ">", Target: "bigint", Kind: "type", Value: value, Validate: bigintValidate, Exclusive: metadataCommentTagFactory_exclusive("type"), Schema: bigintSchema},
     }
   }
   return record
@@ -372,21 +425,21 @@ func metadataCommentTagFactory_parse_type(props struct {
 func metadataCommentTagFactory_numeric(props struct {
   Report func(msg string) any
   Value  string
-}, name string, kind string, numberValidate string, bigintValidate string, exclusive any) metadataCommentTagFactory_TagRecord {
+}, 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: props.Report, Value: props.Value, Unsigned: false})
-  var bigint any
-  if integer != nil {
-    bigint = int64(*integer)
-  }
-  return metadataCommentTagFactory_TagRecord{
+  }{Report: func(string) any { return nil }, Value: props.Value, Unsigned: false})
+  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}}},
-    "bigint": {{Name: name + "<" + props.Value + "n>", Target: "bigint", Kind: kind, Value: bigint, Validate: bigintValidate, 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}}}
+  }
+  return record
 }
 
 func metadataCommentTagFactory_parse_number(props struct {
@@ -426,16 +479,6 @@ func metadataCommentTagFactory_parse_integer(props struct {
   return &value
 }
 
-var metadataCommentTagFactory_FORMATS = func() map[string][2]string {
-  output := map[string][2]string{}
-  for key, value := range FormatCheatSheet {
-    output[key] = [2]string{key, value}
-  }
-  output["datetime"] = [2]string{"date-time", "!isNaN(new Date($input).getTime())"}
-  output["dateTime"] = [2]string{"date-time", "!isNaN(new Date($input).getTime())"}
-  return output
-}()
-
 func metadataCommentTagFactory_includes(values []string, target string) bool {
   for _, value := range values {
     if value == target {

package/native/core/factories/MetadataTypeTagFactory.go

@@ -246,9 +246,21 @@ func (metadataTypeTagFactoryNamespace) Validate(props struct {
         }{Property: nil, Message: "kind '" + tag.Kind + "' can't be duplicated"})
       }
     case []string:
+      // The `exclusive` list names every kind this tag may not share a property
+      // with, itself included, and it is the authoritative spec. Reject when any
+      // other tag's kind appears in the list, matching kinds against kinds.
+      //
+      // Two bugs made this inert: it compared the list of kinds against
+      // `opposite.Name` ("minimum" against "Minimum<0>"), which never matched,
+      // and it also required `opposite.Kind == tag.Kind`, which excluded the
+      // cross-kind partners the list exists to catch. Both must go, or a
+      // forbidden combination keeps compiling: `Minimum<5> & Minimum<0>` emits
+      // `{"minimum":0}` yet its validator requires 5, and `Minimum<0> &
+      // ExclusiveMinimum<5>` or `Format<"uuid"> & Pattern<...>` coexist though
+      // the declarations forbid it.
       var some *schemametadata.IMetadataTypeTag
       for j, opposite := range props.Tags {
-        if i != j && opposite.Kind == tag.Kind && metadataTypeTagFactory_includes(exclusive, opposite.Name) {
+        if i != j && metadataTypeTagFactory_includes(exclusive, opposite.Kind) {
           copied := opposite
           some = &copied
           break

package/native/core/factories/NumericRangeFactory.go

@@ -23,30 +23,27 @@ func (numericRangeFactoryNamespace) Number(t string, input *shimast.Expression,
   case "uint64":
     return numericRangeFactory_number_uint64(input, emit...)
   case "float":
-    return numericRangeFactory_between("-1.175494351e38", "3.4028235e38", emit...)(input)
+    return numericRangeFactory_between("-3.4028235e38", "3.4028235e38", emit...)(input)
   default:
     return nativecontext.EmitFactoryOf(numericRangeFactory_factory, emit...).NewKeywordExpression(shimast.KindTrueKeyword)
   }
 }
 
+// Bigint narrows a protobuf union candidate whose atomic type is `bigint`.
+//
+// ProtobufFactory only ever routes "int64" and "uint64" here, so the fall-through
+// used to be the int64 case: it returned a bare `true`, and a `bigint &
+// Type<"int64">` candidate matched any magnitude at all. Both types are now
+// explicit, and the default is reached only by an unknown type.
 func (numericRangeFactoryNamespace) Bigint(t string, input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(numericRangeFactory_factory, emit...)
-  if t == "uint64" {
-    return f.NewBinaryExpression(
-      nil,
-      f.NewCallExpression(
-        f.NewIdentifier("BigInt"),
-        nil,
-        nil,
-        f.NewNodeList([]*shimast.Node{ExpressionFactory.Number(0, emit...)}),
-        shimast.NodeFlagsNone,
-      ),
-      nil,
-      f.NewToken(shimast.KindLessThanEqualsToken),
-      input,
-    )
+  switch t {
+  case "int64":
+    return numericRangeFactory_bigint_between("-9223372036854775808", "9223372036854775807", input, emit...)
+  case "uint64":
+    return numericRangeFactory_bigint_between("0", "18446744073709551615", input, emit...)
+  default:
+    return nativecontext.EmitFactoryOf(numericRangeFactory_factory, emit...).NewKeywordExpression(shimast.KindTrueKeyword)
   }
-  return f.NewKeywordExpression(shimast.KindTrueKeyword)
 }
 
 func numericRangeFactory_number_int32(input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
@@ -65,6 +62,8 @@ func numericRangeFactory_number_uint32(input *shimast.Expression, emit ...*shimp
   )
 }
 
+// numericRangeFactory_number_int64 bounds a `number` candidate to the int64 range.
+// The maximum is 2**63 - 1, the int64 upper bound.
 func numericRangeFactory_number_int64(input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
   return numericRangeFactory_logical_and(
     numericRangeFactory_integer(input, emit...),
@@ -73,6 +72,8 @@ func numericRangeFactory_number_int64(input *shimast.Expression, emit ...*shimpr
   )
 }
 
+// numericRangeFactory_number_uint64 bounds a `number` candidate to the uint64 range.
+// The maximum is 2**64 - 1, the uint64 upper bound.
 func numericRangeFactory_number_uint64(input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
   return numericRangeFactory_logical_and(
     numericRangeFactory_integer(input, emit...),
@@ -121,6 +122,48 @@ func numericRangeFactory_between(x string, y string, emit ...*shimprinter.EmitCo
   }
 }
 
+// numericRangeFactory_bigint_literal emits `BigInt("<value>")`.
+//
+// The argument has to stay a string literal. `BigInt(9223372036854775807)` would
+// round its number literal to 2**63 before BigInt ever parsed it -- the same
+// rounding that broke the number path -- while the string form parses the digits
+// exactly.
+func numericRangeFactory_bigint_literal(value string, emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(numericRangeFactory_factory, emit...)
+  return f.NewCallExpression(
+    f.NewIdentifier("BigInt"),
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{f.NewStringLiteral(value, shimast.TokenFlagsNone)}),
+    shimast.NodeFlagsNone,
+  )
+}
+
+// numericRangeFactory_bigint_between emits `BigInt(x) <= input && input <= BigInt(y)`.
+//
+// Both comparisons are inclusive because a bigint represents the true 64-bit
+// bounds exactly, unlike the number path's exclusive approximation.
+func numericRangeFactory_bigint_between(x string, y string, input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(numericRangeFactory_factory, emit...)
+  return numericRangeFactory_logical_and(
+    f.NewBinaryExpression(
+      nil,
+      numericRangeFactory_bigint_literal(x, emit...),
+      nil,
+      f.NewToken(shimast.KindLessThanEqualsToken),
+      input,
+    ),
+    f.NewBinaryExpression(
+      nil,
+      input,
+      nil,
+      f.NewToken(shimast.KindLessThanEqualsToken),
+      numericRangeFactory_bigint_literal(y, emit...),
+    ),
+    emit...,
+  )
+}
+
 func numericRangeFactory_logical_and(x *shimast.Expression, y *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
   return nativecontext.EmitFactoryOf(numericRangeFactory_factory, emit...).NewBinaryExpression(
     nil,

package/native/core/factories/ProtobufFactory.go

@@ -17,6 +17,11 @@ type protobufFactoryNamespace struct{}
 var ProtobufFactory = protobufFactoryNamespace{}
 
 type ProtobufFactory_IProps struct {
+  // Method is the fully qualified typia API the call site invoked, exactly as
+  // it must appear in the diagnostic code (`typia.protobuf.encode`). It is the
+  // sole source of that code: composing the code here from a shorter spelling
+  // let the encode and decode programmers, which already pass the whole call
+  // accessor, report `typia.protobuf.typia.protobuf.encode`.
   Method     string
   Checker    *shimchecker.Checker
   Components *schemametadata.MetadataCollection
@@ -40,13 +45,20 @@ func (protobufFactoryNamespace) Metadata(props ProtobufFactory_IProps) *schemame
       Code   string
       Errors []nativecontext.TransformerError_MetadataFactory_IError
     }{
-      Code:   "typia.protobuf." + props.Method,
+      Code:   props.Method,
       Errors: protobufFactory_errors(result.Errors),
     }))
   }
+  protobufFactory_emplaceObjects(props.Components.Objects())
   return result.Data
 }
 
+func protobufFactory_emplaceObjects(objects []*schemametadata.MetadataObjectType) {
+  for _, object := range objects {
+    ProtobufFactory.EmplaceObject(object)
+  }
+}
+
 func (protobufFactoryNamespace) EmplaceObject(object *schemametadata.MetadataObjectType) {
   for _, property := range object.Properties {
     protobufFactory_emplaceProperty(property)
@@ -335,10 +347,6 @@ func protobufFactory_validate() MetadataFactory_Validator {
       }
       visited[obj.Type] = true
       protobufFactory_validateObject(obj.Type, &errors)
-      func() {
-        defer func() { _ = recover() }()
-        ProtobufFactory.EmplaceObject(obj.Type)
-      }()
     }
     noSupport := func(msg string) { insert("does not support " + msg) }
     if props.Metadata.Any {

package/native/core/factories/factory_utility_coverage_test.go

@@ -499,8 +499,14 @@ export let inner!: Outer.Inner;
 		Report: typeTagReport,
 		Type:   "string",
 		Tags: []schemametadata.IMetadataTypeTag{
-			{Target: "string", Kind: "range", Name: "minimum", Exclusive: []string{"maximum"}},
-			{Target: "string", Kind: "range", Name: "maximum", Exclusive: []string{"minimum"}},
+			// Format and Pattern as they are actually declared: both list the
+			// kinds `["format", "pattern"]`, so intersecting them on one property
+			// is forbidden. The cross-kind conflict fires on the opposite's kind,
+			// not its name, and without a same-kind guard. The previous fixture
+			// named the opposite in `exclusive` by tag name, the only shape the
+			// doubly-broken check could fire on and no real declaration produces.
+			{Target: "string", Kind: "format", Name: "Format<\"uuid\">", Exclusive: []string{"format", "pattern"}},
+			{Target: "string", Kind: "pattern", Name: "Pattern<\"^x$\">", Exclusive: []string{"format", "pattern"}},
 		},
 	})
 	invalidExclusiveReports := []string{}