typia 13.1.1 → 13.2.0

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

@@ -67,24 +67,61 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
       // plain.classify cannot soundly field-copy (Object.create + assign) a class
       // that has them — and the PROTOTYPE CHAIN matters: a field-copied subclass
       // of a #private-bearing base would equally throw "Cannot read private
-      // member". The type system hides #private from ApparentProperties, so detect
-      // it on the class declaration(s), walking the `extends` chain. Additive flag,
-      // read only by the classify programmer.
+      // member". A `#private` member DOES surface in ApparentProperties (as a
+      // mangled key), so the member filter below must drop it from the validated
+      // shape; here it is detected on the class declaration(s) — where its
+      // KindPrivateIdentifier name is unambiguous and statics are skippable —
+      // walking the `extends` chain. Additive flag, read only by the classify
+      // programmer.
       if emplace_metadata_object_private_fields(props.Checker, props.Type, map[*nativechecker.Type]bool{}) {
         obj.PrivateFields = true
       }
     }
   }
 
+  // Report the `extends` / `implements` chain to the dependency listener. The
+  // apparent-property walk below already registers the declaring file of every
+  // inherited member, but a base that currently contributes no property (an
+  // empty interface or class) would otherwise stay invisible — and gaining its
+  // first property is exactly the change that must invalidate the consumer.
+  if props.Type != nil && schemametadata.MetadataDependency_active(props.Checker) {
+    emplace_metadata_object_touch_heritage(props.Checker, props.Type.Symbol(), map[*nativeast.Symbol]bool{})
+  }
+
   isClass := props.Type != nil && props.Type.IsClass()
   isProperty := emplace_metadata_object_significant(props.Options.Functional, props.Options.Methods)
-  pred := func(node *nativeast.Node) bool {
+  pred := func(symbol *nativeast.Symbol, node *nativeast.Node) bool {
+    // A `symbol`-keyed member (`[uniqueSymbol]: T`, `[Symbol.toStringTag]: T`,
+    // ...) is not a string / number key: it is unreachable through the string
+    // index access typia emits, `JSON.stringify` ignores it, and JSON Schema has
+    // no representation for it. So it is not part of the structural,
+    // externally-observable shape — exclude it exactly as a `private`/`protected`
+    // keyword member and an ES `#private` one. The checker escapes such a member
+    // name with the 0xFE `InternalSymbolNamePrefix`, and ApparentProperties
+    // otherwise surfaces it under that mangled name, which no runtime object
+    // carries: every real value would fail its own guard, and the emitted schema
+    // would declare an uninhabitable required property (#2226). Checked on the
+    // SYMBOL rather than a declaration node so a late-bound member with no
+    // reachable declaration is excluded too.
+    if symbol != nil && iterate_metadata_intersection_is_symbol_name(symbol.Name) {
+      return false
+    }
     if node == nil {
       return true
     }
     if isClass && node.ModifierFlags()&(nativeast.ModifierFlagsPrivate|nativeast.ModifierFlagsProtected) != 0 {
       return false
     }
+    // An ES `#private` member (field, method, or accessor) carries no
+    // Private/Protected modifier — its identity is a KindPrivateIdentifier name.
+    // It is installed only by the constructor and is unreachable via index
+    // access, so it is not part of the structural shape; exclude it exactly as a
+    // `private`/`protected` keyword member (see ClassNonPublic). ApparentProperties
+    // otherwise surfaces it as a mangled key that no runtime object carries, so
+    // every real instance would fail its own guard (#2213).
+    if isClass && node.Name() != nil && node.Name().Kind == nativeast.KindPrivateIdentifier {
+      return false
+    }
     return isProperty(node)
   }
 
@@ -111,7 +148,7 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
     } else {
       typ = nativechecker.Checker_getTypeOfPropertyOfType(props.Checker, props.Type, symbol.Name)
     }
-    if (node != nil && pred(node) == false) || typ == nil {
+    if pred(symbol, node) == false || typ == nil {
       continue
     }
 
@@ -145,6 +182,14 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
   }
 
   for _, index := range props.Components.IndexInfos(props.Checker, props.Type) {
+    // IndexInfo keeps union domains separate, but a branded symbol key remains
+    // an intersection. Only string/number domains can describe properties seen
+    // through Object.keys or JSON Schema additionalProperties; walk nested
+    // intersections so every symbol-only form stays outside typia's structural
+    // JSON shape, just like an explicit symbol-keyed member (#2240).
+    if emplace_metadata_object_is_symbol_index_key(index.KeyType()) {
+      continue
+    }
     analyzer := func(typ *nativechecker.Type) func(any) *schemametadata.MetadataSchema {
       return func(property any) *schemametadata.MetadataSchema {
         explore := MetadataFactory_IExplore{
@@ -197,6 +242,77 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
   return obj
 }
 
+// emplace_metadata_object_touch_heritage reports every `extends` / `implements`
+// heritage target of `symbol`'s class / interface declarations to the
+// dependency listener, following the chain recursively so intermediate empty
+// bases register too. Import aliases resolve to their final target symbol,
+// whose declarations carry the real declaring files. Walking runs only while a
+// listener is active (see the call site), so ordinary analysis pays nothing.
+func emplace_metadata_object_touch_heritage(
+  checker *nativechecker.Checker,
+  symbol *nativeast.Symbol,
+  visited map[*nativeast.Symbol]bool,
+) {
+  if checker == nil || symbol == nil || visited[symbol] {
+    return
+  }
+  visited[symbol] = true
+  for _, decl := range symbol.Declarations {
+    if decl == nil {
+      continue
+    }
+    var clauses *nativeast.NodeList
+    switch decl.Kind {
+    case nativeast.KindClassDeclaration:
+      if cd := decl.AsClassDeclaration(); cd != nil {
+        clauses = cd.HeritageClauses
+      }
+    case nativeast.KindClassExpression:
+      if ce := decl.AsClassExpression(); ce != nil {
+        clauses = ce.HeritageClauses
+      }
+    case nativeast.KindInterfaceDeclaration:
+      if id := decl.AsInterfaceDeclaration(); id != nil {
+        clauses = id.HeritageClauses
+      }
+    }
+    if clauses == nil {
+      continue
+    }
+    for _, clause := range clauses.Nodes {
+      if clause == nil || clause.Kind != nativeast.KindHeritageClause {
+        continue
+      }
+      hc := clause.AsHeritageClause()
+      if hc == nil || hc.Types == nil {
+        continue
+      }
+      for _, element := range hc.Types.Nodes {
+        if element == nil {
+          continue
+        }
+        // The node walk reports the heritage expression's symbol and every
+        // reference written in its type arguments (e.g. `extends Base<Id>`).
+        schemametadata.MetadataDependency_touchTypeNode(checker, element)
+        expr := element.AsExpressionWithTypeArguments()
+        if expr == nil || expr.Expression == nil {
+          continue
+        }
+        target := checker.GetSymbolAtLocation(expr.Expression)
+        if target == nil {
+          continue
+        }
+        if target.Flags&nativeast.SymbolFlagsAlias != 0 {
+          if resolved := nativechecker.Checker_getAliasedSymbol(checker, target); resolved != nil {
+            target = resolved
+          }
+        }
+        emplace_metadata_object_touch_heritage(checker, target, visited)
+      }
+    }
+  }
+}
+
 // emplace_metadata_object_private_fields reports whether `typ` or any class in
 // its `extends` chain declares an INSTANCE ES #private member — which field-copy
 // (Object.create + assign) cannot reconstruct, so plain.classify must reject it.
@@ -350,7 +466,7 @@ func emplace_metadata_object_intersection(
   props IMetadataIteratorProps,
   obj *schemametadata.MetadataObjectType,
   insert func(emplace_metadata_object_insert) *schemametadata.MetadataProperty,
-  pred func(node *nativeast.Node) bool,
+  pred func(symbol *nativeast.Symbol, node *nativeast.Node) bool,
 ) bool {
   if props.Checker == nil ||
     props.Type == nil ||
@@ -424,7 +540,7 @@ func emplace_metadata_object_intersection_append(
   props IMetadataIteratorProps,
   child *nativechecker.Type,
   insert func(emplace_metadata_object_insert) *schemametadata.MetadataProperty,
-  pred func(node *nativeast.Node) bool,
+  pred func(symbol *nativeast.Symbol, node *nativeast.Node) bool,
 ) bool {
   if props.Checker == nil || child == nil || len(props.Components.IndexInfos(props.Checker, child)) != 0 {
     return false
@@ -443,7 +559,7 @@ func emplace_metadata_object_intersection_append(
     } else {
       typ = nativechecker.Checker_getTypeOfPropertyOfType(props.Checker, child, symbol.Name)
     }
-    if (node != nil && pred(node) == false) || typ == nil {
+    if pred(symbol, node) == false || typ == nil {
       continue
     }
 
@@ -573,6 +689,23 @@ func emplace_metadata_object_valid_dynamic_key(key *schemametadata.MetadataSchem
   return total == key.Size()
 }
 
+func emplace_metadata_object_is_symbol_index_key(key *nativechecker.Type) bool {
+  if key == nil {
+    return false
+  }
+  if key.Flags()&nativechecker.TypeFlagsESSymbolLike != 0 {
+    return true
+  }
+  if key.IsIntersection() {
+    for _, child := range key.Types() {
+      if emplace_metadata_object_is_symbol_index_key(child) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
 func iterate_optional_coalesce(props struct {
   Metadata *schemametadata.MetadataSchema
   Type     *nativechecker.Type

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

@@ -9,6 +9,12 @@ func Iterate_metadata(props IMetadataIteratorProps) {
   if props.Type == nil {
     return
   }
+  // Every type the analysis reads funnels through here (top types, union and
+  // intersection members, alias targets, array / tuple elements, generic
+  // arguments, property types), so this single touch reports the declaration
+  // files of the whole consulted type graph to the dependency listener the
+  // project transform host registers (see schemas/metadata/MetadataDependency).
+  schemametadata.MetadataDependency_touchType(props.Checker, props.Type)
   if props.Type.IsTypeParameter() == true {
     if props.Errors != nil {
       *props.Errors = append(*props.Errors, MetadataFactory_IError{

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

@@ -3,10 +3,11 @@ package metadata
 import (
   nativechecker "github.com/microsoft/typescript-go/shim/checker"
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativeutils "github.com/samchon/typia/packages/typia/native/core/utils"
 )
 
 func Iterate_metadata_function(props IMetadataIteratorProps) bool {
-  declaration := metadata_get_function_node(props.Type)
+  declaration := metadata_get_function_node(props.Checker, props.Type)
   if declaration == nil {
     return false
   }
@@ -36,16 +37,8 @@ func Iterate_metadata_function(props IMetadataIteratorProps) bool {
 
   signature := signatures[0]
   returnType := props.Checker.GetReturnTypeOfSignature(signature)
-  async := false
-  if returnType != nil {
-    if symbol := returnType.Symbol(); symbol != nil && symbol.Name == "Promise" {
-      generic := metadata_get_type_arguments(props.Checker, returnType)
-      if len(generic) != 0 {
-        returnType = generic[0]
-      }
-      async = true
-    }
-  }
+  promised := nativeutils.PromiseTypeFactory.Resolve(props.Checker, returnType)
+  returnType = promised.Type
 
   parameters := make([]*schemametadata.MetadataParameter, 0, len(signature.Parameters()))
   for _, p := range signature.Parameters() {
@@ -87,7 +80,7 @@ func Iterate_metadata_function(props IMetadataIteratorProps) bool {
   props.Metadata.Functions = append(props.Metadata.Functions, schemametadata.MetadataFunction_create(schemametadata.MetadataFunction{
     Parameters: parameters,
     Output:     output,
-    Async:      async,
+    Async:      promised.Async,
   }))
   return true
 }

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

@@ -126,6 +126,50 @@ func Iterate_metadata_intersection(props IMetadataIteratorProps) bool {
   if onlyObjects && len(tagObjects) == 0 {
     return escape(false)
   }
+  // A call-signature-only arm is dropped before the phantom-brand pass, and only
+  // while something else survives. It cannot join that pass: the "every arm was
+  // removable" guard below exists to refuse an intersection of nothing but
+  // brands, and an arm such as `Record<never, never>` is vacuously a phantom
+  // brand, so counting signatures as removable would turn
+  // `call & Record<never, never>` — which the interface spelling accepts — into a
+  // rejection.
+  if len(metadatas) > 1 {
+    kept := make([]*schemametadata.MetadataSchema, 0, len(metadatas))
+    keptIndexes := make([]int, 0, len(indexes))
+    for i, m := range metadatas {
+      if iterate_metadata_intersection_is_call_signature_only(m) {
+        continue
+      }
+      kept = append(kept, m)
+      keptIndexes = append(keptIndexes, indexes[i])
+    }
+    substantial := false
+    for _, m := range kept {
+      if iterate_metadata_intersection_is_removable_brand(m) == false {
+        substantial = true
+        break
+      }
+    }
+    if substantial {
+      // Something that carries real obligations survives, so the signatures are
+      // the part with nothing to describe and the members are what both
+      // spellings must answer for.
+      metadatas = kept
+      indexes = keptIndexes
+    } else if len(kept) == 0 {
+      // Every arm was signatures only — an overload set, a call-and-construct
+      // pair, or two constructors. That is a member-free callable, which is what
+      // the interface spelling of the same type produces, so this iterator has
+      // nothing to merge and hands the type back rather than refusing it.
+      //
+      // Widening this to "signatures were dropped and only brands remain" was
+      // tried and is wrong: `call & Record<never, never>` must reach the
+      // phantom-brand pass below, which drops the brand and leaves the call arm.
+      // Escaping instead makes the emitted validator refuse a function, which
+      // the `directPureCall*EmptyIntersection` anchors catch.
+      return escape(false)
+    }
+  }
   if len(metadatas) != 1 {
     removable := []int{}
     for i, m := range metadatas {
@@ -297,6 +341,29 @@ func Iterate_metadata_intersection(props IMetadataIteratorProps) bool {
   return true
 }
 
+// iterate_metadata_intersection_is_call_signature_only reports whether an arm
+// contributes nothing but call or construct signatures, which the intersection
+// can drop the way it drops a phantom brand.
+//
+// `((v: number) => string) & { label: string }` and
+// `interface T { (v: number): string; label: string }` are the same type, and
+// only the first reaches this function — the second is one object carrying a
+// call signature. Without this the first was refused as a nonsensible
+// intersection while the second was accepted, so the answer depended on the
+// spelling (samchon/typia#2276).
+//
+// Dropping the arm loses nothing the interface spelling keeps. #2250 settled
+// that a member-carrying callable stays structural, so neither spelling
+// validates the call signature; the members are what both must describe. An arm
+// that carries any data alongside its signatures is not this case and stays,
+// because dropping it would erase a declared obligation.
+func iterate_metadata_intersection_is_call_signature_only(m *schemametadata.MetadataSchema) bool {
+  return m != nil &&
+    len(m.Functions) != 0 &&
+    m.Nullable == false &&
+    m.Size() == len(m.Functions)
+}
+
 // iterate_metadata_intersection_is_removable_brand reports whether an explored
 // member schema is a phantom "brand" object that an intersection with a
 // non-object member may drop. A value intersected with a non-object survivor is
@@ -314,6 +381,8 @@ func Iterate_metadata_intersection(props IMetadataIteratorProps) bool {
 // a symbol-keyed property is never observable on a JSON value. Any required
 // string-keyed property (literal or not) might be real data, so it keeps the
 // intersection nonsensible rather than silently dropping a declared constraint.
+
+
 func iterate_metadata_intersection_is_removable_brand(m *schemametadata.MetadataSchema) bool {
   if m == nil || m.Size() != 1 || len(m.Objects) != 1 {
     return false
@@ -357,8 +426,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
 }
@@ -479,18 +550,15 @@ func iterate_metadata_intersection_is_removable_object_constraint(
   if nativechecker.IsTupleType(typ) || nativechecker.Checker_isArrayType(checker, typ) {
     return false
   }
-  if metadata_get_function_node(typ) != nil || len(checker.GetSignaturesOfType(typ, nativechecker.SignatureKindCall)) != 0 {
+  if metadata_get_function_node(checker, typ) != nil || len(checker.GetSignaturesOfType(typ, nativechecker.SignatureKindCall)) != 0 {
     return false
   }
-  name := iterate_metadata_native_getNativeName(metadata_type_symbol_base_name(typ))
-  if name == "" {
-    name = iterate_metadata_native_getNativeName(metadata_type_symbol_base_name(checker.GetApparentType(typ)))
-  }
-  if _, ok := iterate_metadata_native_simples[name]; ok {
+  name, symbol := iterate_metadata_intersection_type_name_and_symbol(checker, typ)
+  if _, ok := iterate_metadata_native_simples[name]; ok && metadata_symbol_is_runtime_native_type(checker, symbol, name) {
     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
     }
   }
@@ -522,6 +590,29 @@ type iterate_metadata_intersection_identity struct {
   Shareable bool
 }
 
+// iterate_metadata_intersection_type_name_and_symbol keeps the normalized name
+// paired with the symbol that supplied it, including the apparent-type fallback.
+// Intersection classifiers can then apply the same runtime-native identity gate
+// as direct native metadata without re-resolving either half independently.
+func iterate_metadata_intersection_type_name_and_symbol(
+  checker *nativechecker.Checker,
+  typ *nativechecker.Type,
+) (string, *nativeast.Symbol) {
+  if typ == nil {
+    return "", nil
+  }
+  symbol := typ.Symbol()
+  name := iterate_metadata_native_getNativeName(metadata_type_symbol_base_name(typ))
+  if name == "" && checker != nil {
+    apparent := checker.GetApparentType(typ)
+    if apparent != nil {
+      symbol = apparent.Symbol()
+      name = iterate_metadata_native_getNativeName(metadata_type_symbol_base_name(apparent))
+    }
+  }
+  return name, symbol
+}
+
 func iterate_metadata_intersection_identify(
   checker *nativechecker.Checker,
   collection *schemametadata.MetadataCollection,
@@ -541,10 +632,7 @@ func iterate_metadata_intersection_identify(
       return iterate_metadata_intersection_identity{Kind: "primitive", Name: info.name}
     }
   }
-  name := iterate_metadata_native_getNativeName(metadata_type_symbol_base_name(typ))
-  if name == "" {
-    name = iterate_metadata_native_getNativeName(metadata_type_symbol_base_name(checker.GetApparentType(typ)))
-  }
+  name, symbol := iterate_metadata_intersection_type_name_and_symbol(checker, typ)
   if atomic, ok := schemametadata.MetadataSchema_atomicLikeNative(name); ok {
     return iterate_metadata_intersection_identity{Kind: "primitive", Name: atomic}
   }
@@ -559,11 +647,11 @@ func iterate_metadata_intersection_identify(
       return iterate_metadata_intersection_identity{Kind: "tag"}
     }
   }
-  if _, ok := iterate_metadata_native_simples[name]; ok {
+  if _, ok := iterate_metadata_native_simples[name]; ok && metadata_symbol_is_runtime_native_type(checker, symbol, name) {
     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}
     }
   }
@@ -666,19 +754,16 @@ func iterate_metadata_intersection_is_plain_object_only(
   if nativechecker.IsTupleType(typ) || nativechecker.Checker_isArrayType(checker, typ) {
     return false
   }
-  if metadata_get_function_node(typ) != nil || len(checker.GetSignaturesOfType(typ, nativechecker.SignatureKindCall)) != 0 {
+  if metadata_get_function_node(checker, typ) != nil || len(checker.GetSignaturesOfType(typ, nativechecker.SignatureKindCall)) != 0 {
     return false
   }
 
-  name := iterate_metadata_native_getNativeName(metadata_type_symbol_base_name(typ))
-  if name == "" {
-    name = iterate_metadata_native_getNativeName(metadata_type_symbol_base_name(checker.GetApparentType(typ)))
-  }
-  if _, ok := iterate_metadata_native_simples[name]; ok {
+  name, symbol := iterate_metadata_intersection_type_name_and_symbol(checker, typ)
+  if _, ok := iterate_metadata_native_simples[name]; ok && metadata_symbol_is_runtime_native_type(checker, symbol, name) {
     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
     }
   }
@@ -973,28 +1058,25 @@ func iterate_metadata_intersection_category(
       return "tag"
     }
   }
-  name := iterate_metadata_native_getNativeName(metadata_type_symbol_base_name(typ))
-  if name == "" {
-    name = iterate_metadata_native_getNativeName(metadata_type_symbol_base_name(checker.GetApparentType(typ)))
-  }
+  name, symbol := iterate_metadata_intersection_type_name_and_symbol(checker, typ)
   if atomic, ok := schemametadata.MetadataSchema_atomicLikeNative(name); ok {
     return "primitive:" + atomic
   }
   if name == "Array" || name == "ReadonlyArray" {
     return "array"
   }
-  if _, ok := iterate_metadata_native_simples[name]; ok {
+  if _, ok := iterate_metadata_native_simples[name]; ok && metadata_symbol_is_runtime_native_type(checker, symbol, name) {
     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"
     }
   }
   if name == "Map" || name == "ReadonlyMap" || name == "Set" || name == "ReadonlySet" {
     return "object"
   }
-  if metadata_get_function_node(typ) != nil || len(checker.GetSignaturesOfType(typ, nativechecker.SignatureKindCall)) != 0 {
+  if metadata_get_function_node(checker, typ) != nil || len(checker.GetSignaturesOfType(typ, nativechecker.SignatureKindCall)) != 0 {
     return "object"
   }
   if typ.Flags()&nativechecker.TypeFlagsObject != 0 {

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

@@ -10,6 +10,11 @@ func Iterate_metadata_map(props IMetadataIteratorProps) bool {
   if metadata_type_symbol_base_name(typ) != "Map" {
     return false
   }
+  // The native Map is the runtime-provided global type, not any same-named
+  // package declaration or user-authored global (#2200, #2212, #2239).
+  if !metadata_symbol_is_runtime_global_type(props.Checker, typ.Symbol(), "Map") {
+    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,48 @@ 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 checker resolves this exact symbol from
+    // the global type table *and* a runtime authority provides its constructor.
+    // A colliding package declaration then falls through to its structural
+    // members regardless of whether it was authored in `.ts` or published
+    // through `.d.ts` (#2239), and so does a purely user-authored global that
+    // merely wins the same global lookup (#2200). Node's authoritative Blob and
+    // File module exports are distinct symbols for the same runtime globals, so
+    // admit only their value-bearing exact core-module declaration shape as the
+    // second identity path (#1568).
+    if !metadata_symbol_is_runtime_native_type(props.Checker, symbol, name) {
+      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+"<") {
+      // Use the same runtime-provenance identity gate for WeakMap/WeakSet. The
+      // `+"<"` arity guard (#2181) and generic metadata remain unchanged.
+      if !metadata_symbol_is_runtime_global_type(props.Checker, symbol, generic.Name) {
+        return false
+      }
       iterate_metadata_native_take(props.Metadata, generic.Name)
       return true
     }
@@ -44,6 +68,25 @@ func iterate_metadata_native_getNativeName(name string) string {
   if index := strings.Index(name, "<"); index != -1 {
     name = name[:index]
   }
+  // `global.` is the qualifier `metadata_symbol_name` produces for a symbol
+  // declared inside a `declare global` block, which is how @types/node declares
+  // the bare `Blob` and `File` globals. A project that includes the DOM library
+  // never showed it, because the DOM declares those names at file scope and the
+  // DOM declaration won the name; drop the DOM library — an ordinary Node
+  // service compiled with `"lib": ["ES2022"]` — and the only declaration left is
+  // the augmented one, so the name arrives as `global.Blob` and this lookup
+  // misses before any identity question is asked. Stripping the qualifier only
+  // restores the question; whether the declaration is a runtime-provided native
+  // or a same-named user global stays the identity gate's answer to give.
+  //
+  // An ambient module's qualifier is deliberately not stripped here: a lookalike
+  // published as `declare module "user-buffer-lookalike"` arrives as
+  // `user-buffer-lookalike.Blob` and must keep failing this lookup.
+  for _, module := range []string{"node:buffer.", "buffer.", "global."} {
+    if strings.HasPrefix(name, module) {
+      return strings.TrimPrefix(name, module)
+    }
+  }
   if strings.HasPrefix(name, "\"") && strings.Contains(name, "\".") {
     if index := strings.Index(name[1:], "\"."); index != -1 {
       name = name[index+3:]

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

@@ -10,6 +10,11 @@ func Iterate_metadata_set(props IMetadataIteratorProps) bool {
   if metadata_type_symbol_base_name(typ) != "Set" {
     return false
   }
+  // The native Set is the runtime-provided global type, not any same-named
+  // package declaration or user-authored global (#2200, #2212, #2239).
+  if !metadata_symbol_is_runtime_global_type(props.Checker, typ.Symbol(), "Set") {
+    return false
+  }
   generic := metadata_get_type_arguments(props.Checker, typ)
   if len(generic) != 1 {
     return false