typia 13.1.1 → 13.1.19

package/native/core/factories/internal/metadata/iterate_metadata_native.go

@@ -3,24 +3,49 @@ package metadata
 import (
   "strings"
 
+  nativeast "github.com/microsoft/typescript-go/shim/ast"
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 func Iterate_metadata_native(props IMetadataIteratorProps) bool {
+  var symbol *nativeast.Symbol
   name := ""
   if props.Type != nil {
+    symbol = props.Type.Symbol()
     name = metadata_type_symbol_base_name(props.Type)
   }
   if name == "" && props.Checker != nil && props.Type != nil {
-    name = metadata_type_symbol_base_name(props.Checker.GetApparentType(props.Type))
+    apparent := props.Checker.GetApparentType(props.Type)
+    if apparent != nil {
+      symbol = apparent.Symbol()
+    }
+    name = metadata_type_symbol_base_name(apparent)
   }
   name = iterate_metadata_native_getNativeName(name)
   if _, ok := iterate_metadata_native_simples[name]; ok {
+    // Match the built-in only when the type actually is the built-in, not merely
+    // a user type of the same name. A real native is declared in a `.d.ts`
+    // library, so a user `interface File { name; size }` in a `.ts` module falls
+    // through to the structural object path and is validated against its own
+    // members instead of `input instanceof File` (#2200).
+    if !metadata_symbol_from_declaration_file(symbol) {
+      return false
+    }
     iterate_metadata_native_take(props.Metadata, name)
     return true
   }
   for _, generic := range iterate_metadata_native_generics {
-    if strings.HasPrefix(name, generic.Name) {
+    if name == generic.Name || strings.HasPrefix(name, generic.Name+"<") {
+      // Classify the native generic (WeakMap/WeakSet) only when the type
+      // actually is the built-in, not merely a user type of the same name. A
+      // real WeakMap/WeakSet is declared in a `.d.ts` library, so a module-scoped
+      // user `interface WeakMap<K, V> { brandWeak }` in a `.ts` module falls
+      // through to the structural object path — the same identity gate the
+      // simples path above uses (#2200), applied to the collection generics the
+      // `+"<"` arity guard (#2181) alone left ungated (#2212).
+      if !metadata_symbol_from_declaration_file(symbol) {
+        return false
+      }
       iterate_metadata_native_take(props.Metadata, generic.Name)
       return true
     }

package/native/core/factories/internal/metadata/iterate_metadata_set.go

@@ -10,6 +10,15 @@ func Iterate_metadata_set(props IMetadataIteratorProps) bool {
   if metadata_type_symbol_base_name(typ) != "Set" {
     return false
   }
+  // Classify the native Set only when the type actually is the built-in, not
+  // merely a user type of the same name. A real Set is declared in a `.d.ts`
+  // library, so a module-scoped user `interface Set<T> { brandSet; ... }` in a
+  // `.ts` module falls through to the structural object path and is validated
+  // against its own members instead of `input instanceof Set` — the collection
+  // half of the #2200 identity gate (#2212).
+  if !metadata_symbol_from_declaration_file(typ.Symbol()) {
+    return false
+  }
   generic := metadata_get_type_arguments(props.Checker, typ)
   if len(generic) != 1 {
     return false

package/native/core/factories/internal/metadata/type_arguments_precondition_test.go

@@ -0,0 +1,70 @@
+package metadata
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestMetadataTypeArgumentsPrecondition verifies reference-only extraction.
+//
+// The checker accepts GetTypeArguments only for object-reference types. The
+// helper should identify that capability explicitly, return no arguments for a
+// primitive, and preserve generic arguments for a real reference.
+//
+//  1. Load primitive and generic reference declarations through the checker.
+//  2. Verify the primitive follows the unsupported-input fallback.
+//  3. Verify the reference returns its sole string argument.
+func TestMetadataTypeArgumentsPrecondition(t *testing.T) {
+  dir := t.TempDir()
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(`{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}`), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.MkdirAll(filepath.Join(dir, "src"), 0o755); err != nil {
+    t.Fatalf("mkdir src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "src", "main.ts"), []byte(`
+interface Box<T> { value: T; }
+let primitive!: number;
+let reference!: Box<string>;
+`), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  program, diagnostics, err := driver.LoadProgram(dir, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatalf("load program: %v", err)
+  }
+  if len(diagnostics) != 0 {
+    t.Fatalf("fixture diagnostics: %+v", diagnostics)
+  }
+  defer program.Close()
+
+  source := program.SourceFile(filepath.Join(dir, "src", "main.ts"))
+  if source == nil || source.Statements == nil || len(source.Statements.Nodes) != 3 {
+    t.Fatal("fixture declarations were not loaded")
+  }
+  variableType := func(index int) *shimchecker.Type {
+    declaration := source.Statements.Nodes[index].AsVariableStatement().DeclarationList.AsVariableDeclarationList().Declarations.Nodes[0]
+    return program.Checker.GetTypeAtLocation(declaration)
+  }
+  if args := metadata_get_type_arguments(program.Checker, variableType(1)); len(args) != 0 {
+    t.Fatalf("primitive type returned %d type arguments", len(args))
+  }
+  args := metadata_get_type_arguments(program.Checker, variableType(2))
+  if len(args) != 1 || program.Checker.TypeToString(args[0]) != "string" {
+    t.Fatalf("generic reference arguments mismatch: %#v", args)
+  }
+}

package/native/core/factories/metadata_comment_tag_factory_coverage_test.go

@@ -110,6 +110,23 @@ func TestMetadataCommentTagFactoryCoverage(t *testing.T) {
       Tag    schemametadata.IJsDocTagInfo
     }{Report: report, Tag: tag})
   }
+  decimalReportCount := len(reports)
+  decimal := metadataCommentTagFactory_parse(struct {
+    Report func(msg string) any
+    Tag    schemametadata.IJsDocTagInfo
+  }{
+    Report: report,
+    Tag: schemametadata.IJsDocTagInfo{
+      Name: "multipleOf",
+      Text: []schemametadata.IJsDocTagInfo_IText{{Text: "0.01"}},
+    },
+  })
+  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 != "$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 {
     Report func(msg string) any
@@ -193,6 +210,28 @@ func TestMetadataCommentTagFactoryCoverage(t *testing.T) {
   if len(oppositeOnly.Atomics[0].Tags) == 0 {
     t.Fatal("numeric comment tag should apply when only one numeric side exists")
   }
+  decimalOnly := schemametadata.MetadataSchema_create(schemametadata.MetadataSchema{
+    Atomics: []*schemametadata.MetadataAtomic{
+      schemametadata.MetadataAtomic_create(schemametadata.MetadataAtomic{Type: "number"}),
+    },
+  })
+  decimalErrors := []MetadataFactory_IError{}
+  MetadataCommentTagFactory.Analyze(struct {
+    Errors   *[]MetadataFactory_IError
+    Metadata *schemametadata.MetadataSchema
+    Tags     []schemametadata.IJsDocTagInfo
+    Explore  MetadataFactory_IExplore
+  }{
+    Errors:   &decimalErrors,
+    Metadata: decimalOnly,
+    Tags: []schemametadata.IJsDocTagInfo{{
+      Name: "multipleOf",
+      Text: []schemametadata.IJsDocTagInfo_IText{{Text: "0.01"}},
+    }},
+  })
+  if len(decimalErrors) != 0 || len(decimalOnly.Atomics[0].Tags) != 1 {
+    t.Fatalf("decimal number JSDoc must analyze without bigint diagnostics: errors=%#v tags=%#v", decimalErrors, decimalOnly.Atomics[0].Tags)
+  }
 
   empty := schemametadata.MetadataSchema_create(schemametadata.MetadataSchema{})
   unsupportedErrors := []MetadataFactory_IError{}

package/native/core/factories/metadata_comment_tag_factory_exclusivity_matches_interface_test.go

@@ -0,0 +1,84 @@
+package factories
+
+import (
+  "reflect"
+  "testing"
+
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestMetadataCommentTagFactoryExclusivityMatchesInterface pins every JSDoc
+// comment tag's `Exclusive` value to the @typia/interface declaration.
+//
+// The JSDoc path and the type-tag path both feed
+// MetadataTypeTagFactory.Validate, which reads a tag's `Exclusive` list to
+// reject forbidden combinations. The type-tag path takes that list straight
+// from the interface declaration, but the comment factory used to hand-copy it
+// per parser, and two copies drifted: `@format` published a bare `true` and
+// `@pattern` published `["format"]` (missing its own kind), so `@pattern ^a`
+// `@pattern ^b` compiled while `Pattern<...> & Pattern<...>` is a compile error.
+// This test transcribes the authority once via
+// metadataTypeTagFactoryTestDeclarations -- the same mirror the type-tag tests
+// use -- and asserts the comment factory now produces the identical list.
+//
+// 1. Build the array-form authority (kind -> exclusive kinds) from the shared
+//    declaration mirror, and note the kinds that declare a bare `true`.
+// 2. Parse one representative JSDoc comment per tag kind through the factory.
+// 3. Assert the produced tag's kind and `Exclusive` match the authority exactly,
+//    so `@format`/`@pattern` carry `["format", "pattern"]` and no list drifts.
+func TestMetadataCommentTagFactoryExclusivityMatchesInterface(t *testing.T) {
+  arrayForm := map[string][]string{}
+  for _, declaration := range metadataTypeTagFactoryTestDeclarations() {
+    arrayForm[declaration.kind] = declaration.exclusive
+  }
+
+  report := func(string) any { return nil }
+  cases := []struct {
+    tag  string
+    text string
+    kind string
+    key  string
+  }{
+    {tag: "minimum", text: "0", kind: "minimum", key: "number"},
+    {tag: "maximum", text: "10", kind: "maximum", key: "number"},
+    {tag: "exclusiveMinimum", text: "0", kind: "exclusiveMinimum", key: "number"},
+    {tag: "exclusiveMaximum", text: "10", kind: "exclusiveMaximum", key: "number"},
+    {tag: "format", text: "uuid", kind: "format", key: "string"},
+    {tag: "pattern", text: "^x$", kind: "pattern", key: "string"},
+    {tag: "multipleOf", text: "2", kind: "multipleOf", key: "number"},
+    {tag: "minItems", text: "1", kind: "minItems", key: "array"},
+    {tag: "maxItems", text: "2", kind: "maxItems", key: "array"},
+    {tag: "uniqueItems", text: "", kind: "uniqueItems", key: "array"},
+    {tag: "minLength", text: "1", kind: "minLength", key: "string"},
+    {tag: "maxLength", text: "2", kind: "maxLength", key: "string"},
+    {tag: "type", text: "int32", kind: "type", key: "number"},
+  }
+  for _, tuple := range cases {
+    info := schemametadata.IJsDocTagInfo{Name: tuple.tag}
+    if tuple.text != "" {
+      info.Text = []schemametadata.IJsDocTagInfo_IText{{Text: tuple.text}}
+    }
+    record := metadataCommentTagFactory_parse(struct {
+      Report func(msg string) any
+      Tag    schemametadata.IJsDocTagInfo
+    }{Report: report, Tag: info})
+    tags := record[tuple.key]
+    if len(tags) == 0 {
+      t.Fatalf("@%s should produce a %q tag", tuple.tag, tuple.key)
+    }
+    produced := tags[0]
+    if produced.Kind != tuple.kind {
+      t.Fatalf("@%s should produce kind %q, got %q", tuple.tag, tuple.kind, produced.Kind)
+    }
+    var expected any = true
+    if list, ok := arrayForm[tuple.kind]; ok {
+      expected = list
+    }
+    if reflect.DeepEqual(produced.Exclusive, expected) == false {
+      t.Fatalf(
+        "@%s exclusive drifted from the interface authority: got %#v, want %#v",
+        tuple.tag, produced.Exclusive, expected,
+      )
+    }
+  }
+}

package/native/core/factories/metadata_type_tag_factory_accepts_legal_tag_combinations_test.go

@@ -0,0 +1,60 @@
+package factories
+
+import (
+  "testing"
+
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestMetadataTypeTagFactoryAcceptsLegalTagCombinations verifies enforcing exclusivity rejects nothing a declaration permits.
+//
+// This is the negative twin of the rejection tests. Making an inert check fire
+// is only correct if it fires on exactly the declared `exclusive` pairs: a check
+// that over-matches would reject `Minimum<0> & Maximum<10>`, which neither tag's
+// `exclusive` list names and which every bounded-range type depends on.
+//
+// 1. Combine each array-form tag with a kind absent from its exclusive list.
+// 2. Combine bool-form tags of differing kinds, which the untouched branch owns.
+// 3. Require every combination, and each tag alone, to validate.
+func TestMetadataTypeTagFactoryAcceptsLegalTagCombinations(t *testing.T) {
+  declarations := metadataTypeTagFactoryTestDeclarations()
+  byKind := map[string]metadataTypeTagFactoryTestDeclaration{}
+  for _, declaration := range declarations {
+    byKind[declaration.kind] = declaration
+    success, messages := metadataTypeTagFactoryTestValidate(
+      declaration.target,
+      []schemametadata.IMetadataTypeTag{declaration.tag("A")},
+    )
+    if success == false {
+      t.Fatalf("a lone %s tag must validate, reported %#v", declaration.kind, messages)
+    }
+  }
+
+  for _, pair := range [][2]string{
+    {"minimum", "maximum"},
+    {"minimum", "exclusiveMaximum"},
+    {"exclusiveMinimum", "maximum"},
+    {"exclusiveMinimum", "exclusiveMaximum"},
+  } {
+    left := byKind[pair[0]]
+    right := byKind[pair[1]]
+    success, messages := metadataTypeTagFactoryTestValidate(
+      left.target,
+      []schemametadata.IMetadataTypeTag{left.tag("0"), right.tag("10")},
+    )
+    if success == false {
+      t.Fatalf("%s and %s bound opposite ends and must combine, reported %#v", pair[0], pair[1], messages)
+    }
+  }
+
+  boolFormTarget := "string"
+  boolForm := []schemametadata.IMetadataTypeTag{
+    {Target: boolFormTarget, Name: "MinLength<3>", Kind: "minLength", Exclusive: true},
+    {Target: boolFormTarget, Name: "MaxLength<7>", Kind: "maxLength", Exclusive: true},
+    {Target: boolFormTarget, Name: "Format<\"uuid\">", Kind: "format", Exclusive: true},
+  }
+  success, messages := metadataTypeTagFactoryTestValidate(boolFormTarget, boolForm)
+  if success == false {
+    t.Fatalf("bool-form tags of differing kinds must combine, reported %#v", messages)
+  }
+}

package/native/core/factories/metadata_type_tag_factory_declarations_test.go

@@ -0,0 +1,86 @@
+package factories
+
+import (
+  "fmt"
+
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// metadataTypeTagFactoryTestDeclaration mirrors one type tag declaration from
+// `packages/interface/src/tags`, which is the specification the native check
+// must enforce. `exclusive` names kinds, never tag names.
+type metadataTypeTagFactoryTestDeclaration struct {
+  target    string
+  kind      string
+  exclusive []string
+  name      string
+}
+
+// tag materializes the declaration as the metadata tag the factory receives.
+func (d metadataTypeTagFactoryTestDeclaration) tag(value string) schemametadata.IMetadataTypeTag {
+  return schemametadata.IMetadataTypeTag{
+    Target:    d.target,
+    Name:      fmt.Sprintf(d.name, value),
+    Kind:      d.kind,
+    Exclusive: d.exclusive,
+    Value:     value,
+  }
+}
+
+// metadataTypeTagFactoryTestDeclarations transcribes every array-form tag
+// declaration, in the exact `kind` and `exclusive` shape each publishes:
+//
+//   - Minimum          kind "minimum"          exclusive ["minimum", "exclusiveMinimum"]
+//   - Maximum          kind "maximum"          exclusive ["maximum", "exclusiveMaximum"]
+//   - ExclusiveMinimum kind "exclusiveMinimum" exclusive ["exclusiveMinimum", "minimum"]
+//   - ExclusiveMaximum kind "exclusiveMaximum" exclusive ["exclusiveMaximum", "maximum"]
+//   - Format           kind "format"           exclusive ["format", "pattern"]
+//   - Pattern          kind "pattern"          exclusive ["format", "pattern"]
+//
+// Each list names its own kind, so no tag may be duplicated, plus exactly one
+// cross-kind partner.
+func metadataTypeTagFactoryTestDeclarations() []metadataTypeTagFactoryTestDeclaration {
+  return []metadataTypeTagFactoryTestDeclaration{
+    {target: "number", kind: "minimum", exclusive: []string{"minimum", "exclusiveMinimum"}, name: "Minimum<%s>"},
+    {target: "number", kind: "maximum", exclusive: []string{"maximum", "exclusiveMaximum"}, name: "Maximum<%s>"},
+    {target: "number", kind: "exclusiveMinimum", exclusive: []string{"exclusiveMinimum", "minimum"}, name: "ExclusiveMinimum<%s>"},
+    {target: "number", kind: "exclusiveMaximum", exclusive: []string{"exclusiveMaximum", "maximum"}, name: "ExclusiveMaximum<%s>"},
+    {target: "string", kind: "format", exclusive: []string{"format", "pattern"}, name: "Format<%s>"},
+    {target: "string", kind: "pattern", exclusive: []string{"format", "pattern"}, name: "Pattern<%s>"},
+  }
+}
+
+// metadataTypeTagFactoryTestReport collects the factory's validation messages.
+func metadataTypeTagFactoryTestReport(messages *[]string) func(struct {
+  Property *string
+  Message  string
+}) bool {
+  return func(next struct {
+    Property *string
+    Message  string
+  }) bool {
+    *messages = append(*messages, next.Message)
+    return false
+  }
+}
+
+// metadataTypeTagFactoryTestValidate runs the factory check over one tag list.
+func metadataTypeTagFactoryTestValidate(
+  target string,
+  tags []schemametadata.IMetadataTypeTag,
+) (bool, []string) {
+  messages := []string{}
+  success := MetadataTypeTagFactory.Validate(struct {
+    Report func(struct {
+      Property *string
+      Message  string
+    }) bool
+    Type string
+    Tags []schemametadata.IMetadataTypeTag
+  }{
+    Report: metadataTypeTagFactoryTestReport(&messages),
+    Type:   target,
+    Tags:   tags,
+  })
+  return success, messages
+}

package/native/core/factories/metadata_type_tag_factory_keeps_bool_form_exclusivity_test.go

@@ -0,0 +1,38 @@
+package factories
+
+import (
+  "strings"
+  "testing"
+
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestMetadataTypeTagFactoryKeepsBoolFormExclusivity verifies the bool-form exclusivity branch still rejects a duplicated kind.
+//
+// The bool branch was never broken; it is the working neighbor of the inert
+// array-form branch and shares the same loop and reporting path. Repairing the
+// array-form branch must not disturb it, so this pins its behavior in both
+// directions independently of the array-form tests.
+//
+// 1. Duplicate a bool-form kind and require rejection naming the kind.
+// 2. Require an opted-out `exclusive: false` tag to permit its own duplicate.
+func TestMetadataTypeTagFactoryKeepsBoolFormExclusivity(t *testing.T) {
+  success, messages := metadataTypeTagFactoryTestValidate("string", []schemametadata.IMetadataTypeTag{
+    {Target: "string", Name: "Format<\"uuid\">", Kind: "format", Exclusive: true},
+    {Target: "string", Name: "Format<\"email\">", Kind: "format", Exclusive: true},
+  })
+  if success {
+    t.Fatal("a duplicated bool-form kind must be rejected")
+  }
+  if len(messages) != 1 || strings.Contains(messages[0], "format") == false {
+    t.Fatalf("the bool-form duplication report must name the kind, reported %#v", messages)
+  }
+
+  success, messages = metadataTypeTagFactoryTestValidate("string", []schemametadata.IMetadataTypeTag{
+    {Target: "string", Name: "Example<\"first\">", Kind: "example", Exclusive: false},
+    {Target: "string", Name: "Example<\"second\">", Kind: "example", Exclusive: false},
+  })
+  if success == false {
+    t.Fatalf("a tag opting out of exclusivity must permit its own duplicate, reported %#v", messages)
+  }
+}

package/native/core/factories/metadata_type_tag_factory_rejects_cross_kind_exclusive_tags_test.go

@@ -0,0 +1,65 @@
+package factories
+
+import (
+  "strings"
+  "testing"
+
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestMetadataTypeTagFactoryRejectsCrossKindExclusiveTags verifies each array-form tag rejects the cross-kind partner it declares.
+//
+// The cross-kind partner is the whole reason an `exclusive` list holds more
+// than the tag's own kind: `Minimum` lists `exclusiveMinimum`, `Format` lists
+// `pattern`. The declaration is the spec and it forbids the coexistence, so
+// `number & Minimum<0> & ExclusiveMinimum<5>` and
+// `string & Format<"uuid"> & Pattern<...>` must not compile. The original check
+// scanned only same-kind tags, so the two never met; dropping that same-kind
+// guard is what lets this fire, so restoring the guard turns this red while
+// leaving the same-kind duplication test green.
+//
+// 1. Derive every declared cross-kind pair from the declarations themselves.
+// 2. Validate each pair, both orders, and require rejection naming the conflict.
+// 3. Require all six declarations to contribute exactly one cross-kind partner.
+func TestMetadataTypeTagFactoryRejectsCrossKindExclusiveTags(t *testing.T) {
+  declarations := metadataTypeTagFactoryTestDeclarations()
+  byKind := map[string]metadataTypeTagFactoryTestDeclaration{}
+  for _, declaration := range declarations {
+    byKind[declaration.kind] = declaration
+  }
+
+  covered := 0
+  for _, declaration := range declarations {
+    for _, kind := range declaration.exclusive {
+      if kind == declaration.kind {
+        continue
+      }
+      opposite, ok := byKind[kind]
+      if ok == false {
+        t.Fatalf("%s declares the unknown partner kind %s", declaration.kind, kind)
+      }
+      if opposite.target != declaration.target {
+        t.Fatalf("%s and %s must share a target to ever conflict", declaration.kind, kind)
+      }
+      covered++
+
+      subject := declaration.tag("A")
+      partner := opposite.tag("B")
+      success, messages := metadataTypeTagFactoryTestValidate(
+        declaration.target,
+        []schemametadata.IMetadataTypeTag{subject, partner},
+      )
+      if success {
+        t.Fatalf("kind %s must not be used with kind %s", declaration.kind, kind)
+      }
+      if len(messages) != 1 ||
+        strings.Contains(messages[0], declaration.kind) == false ||
+        strings.Contains(messages[0], partner.Name) == false {
+        t.Fatalf("the %s and %s conflict report must name the conflict, reported %#v", declaration.kind, kind, messages)
+      }
+    }
+  }
+  if covered != len(declarations) {
+    t.Fatalf("every array-form declaration should name exactly one cross-kind partner, covered %d of %d", covered, len(declarations))
+  }
+}

package/native/core/factories/metadata_type_tag_factory_rejects_duplicated_array_form_tags_test.go

@@ -0,0 +1,41 @@
+package factories
+
+import (
+  "strings"
+  "testing"
+
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestMetadataTypeTagFactoryRejectsDuplicatedArrayFormTags verifies an array-form tag rejects a second tag of its own kind.
+//
+// Every array-form `exclusive` list names its own kind, so the tag can never be
+// duplicated. The check compared that list of kinds against the opposite tag's
+// `Name` — `"minimum"` against `"Minimum<0>"` — which never matches, so
+// `number & Minimum<5> & Minimum<0>` compiled and emitted `{"minimum": 0}`
+// while its validator required 5. This is one half of the mutation proof:
+// reverting the kind comparison back to `Name` turns this red. Restoring the
+// same-kind guard leaves this green, because a duplicate is same-kind; it reds
+// only the cross-kind rejection test instead.
+//
+// 1. Build two tags of one kind from each array-form declaration.
+// 2. Validate the pair and require rejection.
+// 3. Require the report to name the kind and the conflicting tag.
+func TestMetadataTypeTagFactoryRejectsDuplicatedArrayFormTags(t *testing.T) {
+  for _, declaration := range metadataTypeTagFactoryTestDeclarations() {
+    first := declaration.tag("A")
+    second := declaration.tag("B")
+    success, messages := metadataTypeTagFactoryTestValidate(
+      declaration.target,
+      []schemametadata.IMetadataTypeTag{first, second},
+    )
+    if success {
+      t.Fatalf("kind %s must not be duplicated on one property", declaration.kind)
+    }
+    if len(messages) != 1 ||
+      strings.Contains(messages[0], declaration.kind) == false ||
+      strings.Contains(messages[0], second.Name) == false {
+      t.Fatalf("the %s duplication report must name the conflict, reported %#v", declaration.kind, messages)
+    }
+  }
+}

package/native/core/factories/numeric_range_factory_enforces_64bit_bounds_test.go

@@ -0,0 +1,69 @@
+package factories
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestNumericRangeFactoryEnforces64BitBounds verifies 64-bit range predicates check something.
+//
+// ProtobufFactory routes only "int64" and "uint64" into the bigint path, so its
+// fall-through was the int64 case and returned a bare `true` keyword: a union
+// candidate typed `bigint & Type<"int64">` matched every magnitude. The bigint
+// path must therefore emit a real comparison, while every number predicate
+// bounds inclusively at its maximum (`2 ** 63 - 1`, `2 ** 64 - 1`, and the
+// exactly-representable 32-bit bounds).
+//
+// 1. Require neither bigint type to emit a bare `true` keyword.
+// 2. Require every number predicate to use an inclusive upper bound.
+func TestNumericRangeFactoryEnforces64BitBounds(t *testing.T) {
+  input := numericRangeFactory_factory.NewIdentifier("input")
+
+  for _, name := range []string{"int64", "uint64"} {
+    node := NumericRangeFactory.Bigint(name, input)
+    if node == nil {
+      t.Fatalf("bigint range %s returned nil", name)
+    }
+    if node.Kind == shimast.KindTrueKeyword {
+      t.Fatalf("bigint range %s emits a bare true keyword, so it checks nothing", name)
+    }
+  }
+
+  for _, name := range []string{"int32", "uint32", "int64", "uint64"} {
+    if numericRangeFactoryCountTokens(NumericRangeFactory.Number(name, input), shimast.KindLessThanToken) != 0 {
+      t.Fatalf("number range %s must bound its maximum inclusively", name)
+    }
+    if numericRangeFactoryCountTokens(NumericRangeFactory.Number(name, input), shimast.KindLessThanEqualsToken) != 2 {
+      t.Fatalf("number range %s must compare both bounds inclusively", name)
+    }
+  }
+}
+
+// numericRangeFactoryCountTokens counts binary operators of one kind in a predicate tree.
+func numericRangeFactoryCountTokens(node *shimast.Node, kind shimast.Kind) int {
+  if node == nil {
+    return 0
+  }
+  count := 0
+  var walk func(*shimast.Node)
+  walk = func(current *shimast.Node) {
+    if current == nil {
+      return
+    }
+    if current.Kind != shimast.KindBinaryExpression {
+      return
+    }
+    binary := current.AsBinaryExpression()
+    if binary == nil {
+      return
+    }
+    if binary.OperatorToken != nil && binary.OperatorToken.Kind == kind {
+      count++
+    }
+    walk(binary.Left)
+    walk(binary.Right)
+  }
+  walk(node)
+  return count
+}