typia 13.1.1 → 13.1.19

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

@@ -44,9 +44,16 @@ func (protobufFactoryNamespace) Metadata(props ProtobufFactory_IProps) *schemame
       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 +342,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{}

package/native/core/factories/format_alias_resolves_to_cheat_sheet_test.go

@@ -0,0 +1,57 @@
+package factories
+
+import (
+  "testing"
+
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestFormatAliasResolvesToCheatSheet verifies every `@format` alias generates the cheat sheet validator it emits.
+//
+// An alias that carries its own validator string is not an alias; it is a
+// second implementation sharing a name, free to drift from the format it
+// claims. `@format datetime` did exactly that: it emitted `format: "date-time"`
+// while validating with `!isNaN(new Date($input).getTime())`, so it accepted
+// February 30th and rejected the RFC 3339 leap second the cheat sheet handles.
+// This pins the alias to the cheat sheet as the single owner of the validator.
+//
+// 1. Parse each alias spelling of the `date-time` format as a JSDoc comment tag.
+// 2. Require the emitted format name, schema, and tag name to be the canonical one.
+// 3. Require the generated validator to be the cheat sheet entry verbatim.
+func TestFormatAliasResolvesToCheatSheet(t *testing.T) {
+  canonical := "date-time"
+  expected, ok := FormatCheatSheet[canonical]
+  if ok == false {
+    t.Fatalf("the cheat sheet must own the %s format", canonical)
+  }
+  for _, alias := range []string{"datetime", "dateTime", "date-time"} {
+    record := metadataCommentTagFactory_parse(struct {
+      Report func(msg string) any
+      Tag    schemametadata.IJsDocTagInfo
+    }{
+      Report: func(msg string) any { return nil },
+      Tag: schemametadata.IJsDocTagInfo{
+        Name: "format",
+        Text: []schemametadata.IJsDocTagInfo_IText{{Text: alias}},
+      },
+    })
+    tags := record["string"]
+    if len(tags) != 1 {
+      t.Fatalf("@format %s should generate exactly one string tag, generated %d", alias, len(tags))
+    }
+    tag := tags[0]
+    if tag.Value != canonical {
+      t.Fatalf("@format %s should carry the canonical %s value, carried %v", alias, canonical, tag.Value)
+    }
+    if tag.Name != "Format<\""+canonical+"\">" {
+      t.Fatalf("@format %s should name the canonical format tag, named %s", alias, tag.Name)
+    }
+    schema, ok := tag.Schema.(map[string]any)
+    if ok == false || schema["format"] != canonical {
+      t.Fatalf("@format %s should emit format %s, emitted %v", alias, canonical, tag.Schema)
+    }
+    if tag.Validate != expected {
+      t.Fatalf("@format %s must validate as the cheat sheet %s entry does, validated with %s", alias, canonical, tag.Validate)
+    }
+  }
+}

package/native/core/factories/format_alias_table_targets_the_cheat_sheet_test.go

@@ -0,0 +1,44 @@
+package factories
+
+import "testing"
+
+// TestFormatAliasTableTargetsTheCheatSheet verifies every declared `@format` alias names a real cheat sheet format.
+//
+// The original defect was structural, not arithmetic: the aliases were appended
+// after a loop that copied the cheat sheet, so they were invisible to any sweep
+// that enumerated the cheat sheet's entries and could drift from the format they
+// emit without contradicting anything. The alias table now holds only cheat
+// sheet keys, and this pins that shape — an alias pointing nowhere, or shadowing
+// a real format with a different meaning, fails here rather than at a user's
+// call site.
+//
+// 1. Require every alias to resolve to an existing cheat sheet entry.
+// 2. Require no alias to shadow a cheat sheet key of its own name.
+// 3. Require resolution to reject a format the cheat sheet does not own.
+func TestFormatAliasTableTargetsTheCheatSheet(t *testing.T) {
+  if len(formatCheatSheet_ALIASES) == 0 {
+    t.Fatal("the alias table should stay the enumerable owner of every alternative spelling")
+  }
+  for alias, canonical := range formatCheatSheet_ALIASES {
+    expected, ok := FormatCheatSheet[canonical]
+    if ok == false {
+      t.Fatalf("the alias %s targets %s, which the cheat sheet does not own", alias, canonical)
+    }
+    if _, ok := FormatCheatSheet[alias]; ok {
+      t.Fatalf("the alias %s shadows a cheat sheet format of the same name", alias)
+    }
+    name, validate, ok := formatCheatSheet_resolve(alias)
+    if ok == false || name != canonical || validate != expected {
+      t.Fatalf("the alias %s must resolve to the cheat sheet %s entry, resolved to %s", alias, canonical, name)
+    }
+  }
+  for name, validate := range FormatCheatSheet {
+    resolvedName, resolvedValidate, ok := formatCheatSheet_resolve(name)
+    if ok == false || resolvedName != name || resolvedValidate != validate {
+      t.Fatalf("the canonical format %s must resolve to itself", name)
+    }
+  }
+  if _, _, ok := formatCheatSheet_resolve("not-a-format"); ok {
+    t.Fatal("an unsupported format must not resolve")
+  }
+}