typia 13.1.0 → 13.1.19

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

@@ -357,8 +357,10 @@ func iterate_metadata_intersection_is_symbol_key(key *schemametadata.MetadataSch
 // name is a computed `symbol` member. The TypeScript checker prefixes such names
 // with a 0xFE byte (`InternalSymbolNamePrefix`), an invalid UTF-8 lead unit that
 // never begins a real string property name. This runs on the raw checker symbol
-// name (`is_removable_object_constraint`) as well as the metadata key literal
-// (`is_symbol_key`), so both the type-level and schema-level brand checks agree.
+// name (`is_removable_object_constraint`, and the member filter in
+// `Emplace_metadata_object` that keeps such a member out of the validated shape)
+// as well as the metadata key literal (`is_symbol_key`), so the type-level,
+// member-level, and schema-level checks all agree on what a symbol key is.
 func iterate_metadata_intersection_is_symbol_name(name string) bool {
   return len(name) != 0 && name[0] == 0xFE
 }
@@ -490,7 +492,7 @@ func iterate_metadata_intersection_is_removable_object_constraint(
     return false
   }
   for _, generic := range iterate_metadata_native_generics {
-    if strings.HasPrefix(name, generic.Name) {
+    if name == generic.Name || strings.HasPrefix(name, generic.Name+"<") {
       return false
     }
   }
@@ -563,7 +565,7 @@ func iterate_metadata_intersection_identify(
     return iterate_metadata_intersection_identity{Kind: "native", Name: name}
   }
   for _, generic := range iterate_metadata_native_generics {
-    if strings.HasPrefix(name, generic.Name) {
+    if name == generic.Name || strings.HasPrefix(name, generic.Name+"<") {
       return iterate_metadata_intersection_identity{Kind: "native", Name: generic.Name}
     }
   }
@@ -678,7 +680,7 @@ func iterate_metadata_intersection_is_plain_object_only(
     return false
   }
   for _, generic := range iterate_metadata_native_generics {
-    if strings.HasPrefix(name, generic.Name) {
+    if name == generic.Name || strings.HasPrefix(name, generic.Name+"<") {
       return false
     }
   }
@@ -987,7 +989,7 @@ func iterate_metadata_intersection_category(
     return "native:" + name
   }
   for _, generic := range iterate_metadata_native_generics {
-    if strings.HasPrefix(name, generic.Name) {
+    if name == generic.Name || strings.HasPrefix(name, generic.Name+"<") {
       return "object"
     }
   }

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

@@ -10,6 +10,15 @@ func Iterate_metadata_map(props IMetadataIteratorProps) bool {
   if metadata_type_symbol_base_name(typ) != "Map" {
     return false
   }
+  // Classify the native Map only when the type actually is the built-in, not
+  // merely a user type of the same name. A real Map is declared in a `.d.ts`
+  // library, so a module-scoped user `interface Map<K, V> { brandMap; ... }` in a
+  // `.ts` module falls through to the structural object path and is validated
+  // against its own members instead of `input instanceof Map` — 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) != 2 {
     return false

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/js_doc_link_text_test.go

@@ -0,0 +1,69 @@
+//go:build typia_native_internal
+// +build typia_native_internal
+
+package metadata
+
+import (
+  "path/filepath"
+  "testing"
+
+  nativeast "github.com/microsoft/typescript-go/shim/ast"
+  nativecore "github.com/microsoft/typescript-go/shim/core"
+  nativeparser "github.com/microsoft/typescript-go/shim/parser"
+)
+
+// TestJsDocLinkText verifies the metadata helper renders visible inline links.
+//
+// JSDoc link nodes split their entity target into Name() and their optional
+// display label into Text(). This test pins the shared renderer directly so all
+// metadata consumers keep qualified targets, normalized labels, call suffixes,
+// URLs, and tag comments without depending only on an application-programmer
+// integration.
+//
+// 1. Parse a property comment containing plain, qualified, labeled, URL, and
+// unresolved and malformed links, empty labels, call suffixes, plus a link
+// inside a JSDoc tag.
+// 2. Reflect the property's description and tags through the metadata helpers.
+// 3. Assert the visible text and punctuation are preserved deterministically.
+func TestJsDocLinkText(t *testing.T) {
+  file := nativeparser.ParseSourceFile(
+    nativeast.SourceFileParseOptions{FileName: filepath.ToSlash(filepath.Join(t.TempDir(), "links.ts"))},
+    `interface ITarget {
+  value: string;
+}
+interface IBox {
+  /**
+   * Plain; {@link ITarget}; {@link ITarget.value};
+   * {@link ITarget | label}; {@linkcode ITarget};
+   * {@linkplain ITarget.value}; {@link MissingTarget};
+   * {@link https://example.com/docs}; {@link https://example.com/docs | docs}.
+   * {@link ITarget | }; {@link makeTarget()}; {@link makeTarget() | maker}.
+   * {@link Missing.};
+   * @title {@link ITarget titled target}
+   */
+  field: string;
+}
+`,
+    nativecore.ScriptKindTS,
+  )
+  member := file.Statements.Nodes[1].AsInterfaceDeclaration().Members.Nodes[0]
+  symbol := &nativeast.Symbol{
+    Name:             "field",
+    ValueDeclaration: member,
+    Declarations:     []*nativeast.Node{member},
+  }
+  description := metadata_node_description(symbol)
+  if description == nil {
+    t.Fatal("description was not reflected")
+  }
+  if *description != "Plain; ITarget; ITarget.value;\nlabel; ITarget;\nITarget.value; MissingTarget;\nhttps://example.com/docs; docs.\nITarget; makeTarget(); maker.\nMissing.;" {
+    t.Fatalf("unexpected description: %q", *description)
+  }
+  tags := metadata_node_js_doc_tags(symbol)
+  if len(tags) != 1 || tags[0].Name != "title" || len(tags[0].Text) != 1 || tags[0].Text[0].Text != "titled target" {
+    t.Fatalf("unexpected tags: %#v", tags)
+  }
+  if metadata_js_doc_link_text(nil) != "" {
+    t.Fatal("nil JSDoc link should render empty text")
+  }
+}

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))
+  }
+}