typia 13.1.19 → 13.2.0

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

@@ -139,7 +139,7 @@ func metadata_get_type_arguments(checker *nativechecker.Checker, typ *nativechec
   return checker.GetTypeArguments(typ)
 }
 
-func metadata_get_function_node(typ *nativechecker.Type) *nativeast.Node {
+func metadata_get_function_node(checker *nativechecker.Checker, typ *nativechecker.Type) *nativeast.Node {
   if typ == nil {
     return nil
   }
@@ -166,6 +166,9 @@ func metadata_get_function_node(typ *nativechecker.Type) *nativeast.Node {
   if metadata_is_global_function_interface(symbol, node) {
     return node
   }
+  if metadata_is_pure_function_declaration(checker, typ, node) {
+    return node
+  }
   if nativeast.IsPropertyAssignment(node) {
     initializer := node.AsPropertyAssignment().Initializer
     if nativeast.IsFunctionLike(initializer) {
@@ -287,8 +290,7 @@ func metadata_node_type_js_doc_tags(symbol *nativeast.Symbol) []schemametadata.I
 // first declaration is an `InterfaceDeclaration`, and that declaration lives in a
 // `lib.*.d.ts` — so it recognizes only the lib `Function` and never a
 // user-declared `interface Function`, a `function Function()` value, or any
-// other callable object type (a hybrid `interface Foo { (): void; x: number }`
-// keeps its data properties). See metadata_get_function_node for why the lib
+// other callable object type. See metadata_get_function_node for why the lib
 // `Function` must be treated as a function type (#2178).
 func metadata_is_global_function_interface(symbol *nativeast.Symbol, node *nativeast.Node) bool {
   if symbol == nil || symbol.Name != "Function" {
@@ -300,50 +302,203 @@ func metadata_is_global_function_interface(symbol *nativeast.Symbol, node *nativ
   return metadata_symbol_from_default_lib(symbol)
 }
 
+// metadata_is_pure_function_declaration reports whether an object-type
+// declaration describes only call and/or construct signatures. TypeScript
+// augments every callable object's apparent properties with the global Function
+// members, so the raw properties and index infos are the boundary: a declaration
+// that carries members of its own keeps its declared data shape, while a
+// member-free callable or constructable one follows the same metadata path as
+// the function type alias it is mutually assignable with (#2238).
+//
+// An interface body and a type literal are the two spellings TypeScript has for
+// one object-type body, and `interface F { (v: number): string }`, `type F = { (v:
+// number): string }`, and the anonymous `{ (v: number): string }` written at a
+// call site are one type. The declaration's node kind is the only thing that
+// separates them, so answering them differently is exactly the
+// declaration-spelling dependency this predicate exists to remove. Both kinds
+// are admitted and nothing else is: a function type or constructor type is
+// already `IsFunctionLike` and never reaches here, and every other declaration
+// kind that can back a callable type carries a runtime value binding whose
+// declared shape is a different question.
+//
+// No member class is admitted, not even one the emitted validator ignores.
+// #2238's invariant is that mutually assignable spellings agree, and a
+// member-carrying callable has no plain function type to be assignable with:
+// `{ (): void; cancel(): void }` accepts no bare `() => void`, so routing it
+// through the function path would answer against no twin while erasing `cancel`
+// from the declaration. It would also split two spellings that are mutually
+// assignable with each other — `cancel(): void` and `cancel: () => void` are the
+// same type, and only the first carries SymbolFlagsMethod — so admitting methods
+// would make the method form a function while the property form stayed
+// structural. Hybrid callables are #2250's merged boundary and #2238's declared
+// negative boundary; both leave them structural.
+func metadata_is_pure_function_declaration(
+  checker *nativechecker.Checker,
+  typ *nativechecker.Type,
+  node *nativeast.Node,
+) bool {
+  if checker == nil || typ == nil || node == nil ||
+    (node.Kind != nativeast.KindInterfaceDeclaration && node.Kind != nativeast.KindTypeLiteral) {
+    return false
+  }
+  if len(nativechecker.Checker_getPropertiesOfType(checker, typ)) != 0 ||
+    len(nativechecker.Checker_getIndexInfosOfType(checker, typ)) != 0 {
+    return false
+  }
+  return len(checker.GetSignaturesOfType(typ, nativechecker.SignatureKindCall)) != 0 ||
+    len(checker.GetSignaturesOfType(typ, nativechecker.SignatureKindConstruct)) != 0
+}
+
 // metadata_symbol_from_default_lib reports whether the symbol's first locatable
-// declaration lives in a TypeScript default library file. Default library files
-// are always named `lib.<target>.d.ts` regardless of the install directory, so
-// the base name alone is a stable signal.
+// declaration lives in a TypeScript default library file, judged by file name
+// alone because its callers answer without a checker. Default library files are
+// conventionally named `lib.<target>.d.ts`, which is enough for the JSDoc and
+// global-`Function` questions that use this: both are about what a library
+// declaration means, and neither grants a type an identity a lookalike could
+// claim. Runtime-native identity does grant one, so it asks the program instead
+// through schemametadata.MetadataDefaultLibrary_is.
 func metadata_symbol_from_default_lib(symbol *nativeast.Symbol) bool {
   for _, node := range metadata_node_declarations(symbol) {
     src := nativeast.GetSourceFileOfNode(node)
     if src == nil {
       continue
     }
-    return metadata_is_default_lib_file_name(src.FileName())
+    return schemametadata.MetadataDefaultLibrary_isFileNamed(src.FileName())
   }
   return false
 }
 
-// metadata_symbol_from_declaration_file reports whether the symbol's first
-// locatable declaration lives in a `.d.ts` declaration file. It widens
-// metadata_symbol_from_default_lib beyond the TypeScript default libraries
-// (lib.*.d.ts) to any ambient declaration file, because a built-in native can be
-// declared by an ambient package rather than a default lib — the `File` and
-// `Blob` globals Node adds through @types/node are declared in `.d.ts` files that
-// are not `lib.*.d.ts`. Native classification uses this to keep a real built-in
-// native (declared in a `.d.ts`, whichever library) native, while a user type
-// that merely shares a native's name — an `interface File { name; size }` in a
-// `.ts` module — is not a declaration and falls through to the structural object
-// path (#2200).
-func metadata_symbol_from_declaration_file(symbol *nativeast.Symbol) bool {
-  for _, node := range metadata_node_declarations(symbol) {
-    src := nativeast.GetSourceFileOfNode(node)
-    if src == nil {
-      continue
+// metadata_symbol_is_global_type reports whether symbol is the type that the
+// checker resolves from its global symbol table under name. Pointer identity is
+// deliberate: default-library natives and ambient-package globals such as
+// Node's File and Blob resolve to that shared global symbol, while an exported
+// package declaration remains a distinct module symbol even when its name and
+// `.d.ts` source form are identical (#2239).
+func metadata_symbol_is_global_type(checker *nativechecker.Checker, symbol *nativeast.Symbol, name string) bool {
+  if checker == nil || symbol == nil || name == "" {
+    return false
+  }
+  return checker.ResolveName(name, nil, nativeast.SymbolFlagsType, false) == symbol
+}
+
+// metadata_symbol_is_runtime_global_type reports whether a global name is the
+// runtime built-in rather than a user-authored global of the same name.
+//
+// Global-table resolution alone answers a weaker question than the one native
+// classification asks. `declare global { interface File { ... } }` in a project
+// with neither DOM nor Node declarations also wins that lookup, so a
+// resolution-only gate promotes a purely user-authored type to native identity:
+// its members are erased, `input instanceof File` replaces them, and the check
+// throws `ReferenceError` wherever no runtime provides that constructor (#2200).
+//
+// The added question is therefore provenance of the runtime constructor, not the
+// existence of a declaration: a global qualifies only when one of the two
+// authorities that actually describe a JavaScript runtime — a TypeScript default
+// library, or Node's `node:buffer` / `buffer` core module — puts it in scope.
+func metadata_symbol_is_runtime_global_type(checker *nativechecker.Checker, symbol *nativeast.Symbol, name string) bool {
+  return metadata_symbol_is_global_type(checker, symbol, name) &&
+    metadata_symbol_has_runtime_provider(checker, symbol)
+}
+
+// metadata_symbol_is_runtime_native_type applies the shared identity boundary
+// for simple runtime-native classes. Most natives are the runtime-provided
+// symbol resolved from the checker's global type table. Node's Blob and File
+// module exports are a second symbol for those same runtime constructors, so
+// their declarations qualify through the value-bearing shape shared by the
+// supported Node type definitions (#1568, #2200, #2239).
+func metadata_symbol_is_runtime_native_type(checker *nativechecker.Checker, symbol *nativeast.Symbol, name string) bool {
+  return metadata_symbol_is_runtime_global_type(checker, symbol, name) ||
+    metadata_symbol_is_node_buffer_native_export(symbol, name)
+}
+
+// metadata_symbol_has_runtime_provider reports whether a runtime authority is
+// what puts this symbol's constructor in scope.
+//
+// A provider does not have to declare the interface itself. @types/node bridges
+// its module classes to the bare globals with `interface Blob extends _Blob {}`
+// plus `var Blob: ... typeof buffer.Blob` in an ordinary package `.d.ts`, so the
+// interface declaration carries no runtime provenance at all while the value
+// binding resolves straight into the ambient `node:buffer` module. Reading the
+// constructor binding therefore recognizes that bridge — and every respelling of
+// it, including the 18/20 `typeof NodeBlob` class alias and the 25 `typeof
+// buffer.Blob` variable alias — without matching declaration text or package
+// paths, which node_modules placement, custom typeRoots, symlinks, and
+// virtualized package layouts all make unreliable.
+//
+// A user-authored global fails both halves: its interface lives in the user's
+// own file, and any `declare var` it pairs with resolves to the user's own type
+// literal rather than into a default library or the Node core module.
+func metadata_symbol_has_runtime_provider(checker *nativechecker.Checker, symbol *nativeast.Symbol) bool {
+  if symbol == nil {
+    return false
+  }
+  for _, declaration := range metadata_node_declarations(symbol) {
+    if metadata_declaration_is_runtime_provided(checker, declaration) {
+      return true
+    }
+  }
+  if checker == nil || symbol.Flags&nativeast.SymbolFlagsValue == 0 {
+    return false
+  }
+  constructor := checker.GetTypeOfSymbol(symbol)
+  if constructor == nil {
+    return false
+  }
+  for _, declaration := range metadata_node_declarations(constructor.Symbol()) {
+    if metadata_declaration_is_runtime_provided(checker, declaration) {
+      return true
+    }
+  }
+  return false
+}
+
+// metadata_declaration_is_runtime_provided reports whether a declaration belongs
+// to one of the two authorities that describe a runtime-native global: a
+// TypeScript default library file, or the `node:buffer` / `buffer` core module
+// that owns Node's Blob and File constructors. The default-library half comes
+// from the program (see schemametadata.MetadataDefaultLibrary) rather than from
+// the declaration's file name, which under `libReplacement` is an ordinary
+// `node_modules/@typescript/lib-*/index.d.ts` and which any dependency may
+// otherwise imitate.
+func metadata_declaration_is_runtime_provided(checker *nativechecker.Checker, declaration *nativeast.Node) bool {
+  if declaration == nil {
+    return false
+  }
+  if schemametadata.MetadataDefaultLibrary_is(checker, nativeast.GetSourceFileOfNode(declaration)) {
+    return true
+  }
+  return metadata_node_in_node_buffer_module(declaration)
+}
+
+func metadata_node_in_node_buffer_module(node *nativeast.Node) bool {
+  for current := node; current != nil; current = current.Parent {
+    if current.Kind == nativeast.KindModuleDeclaration && current.Name() != nil {
+      module := strings.Trim(current.Name().Text(), "\"'")
+      if module == "node:buffer" || module == "buffer" {
+        return true
+      }
+    }
+    if current.Kind == nativeast.KindSourceFile {
+      return false
     }
-    return src.IsDeclarationFile
   }
   return false
 }
 
-func metadata_is_default_lib_file_name(fileName string) bool {
-  slash := strings.ReplaceAll(fileName, "\\", "/")
-  base := slash
-  if idx := strings.LastIndex(slash, "/"); idx >= 0 {
-    base = slash[idx+1:]
+func metadata_symbol_is_node_buffer_native_export(symbol *nativeast.Symbol, name string) bool {
+  if symbol == nil || symbol.ValueDeclaration == nil || (name != "Blob" && name != "File") {
+    return false
+  }
+  declaration := symbol.ValueDeclaration
+  if declaration.Kind != nativeast.KindClassDeclaration && declaration.Kind != nativeast.KindVariableDeclaration {
+    return false
   }
-  return strings.HasPrefix(base, "lib.") && strings.HasSuffix(base, ".d.ts")
+  // @types/node 18/20 declare these constructor values as classes and 25
+  // declares merged interface/var pairs. The value declaration and exact core
+  // module together distinguish those runtime constructors from structural
+  // same-name interfaces without depending on node_modules placement, custom
+  // typeRoots, symlink targets, or virtualized package paths.
+  return metadata_node_in_node_buffer_module(declaration)
 }
 
 func metadata_is_internal(symbol *nativeast.Symbol) bool {

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

@@ -182,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{
@@ -681,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_function.go

@@ -7,7 +7,7 @@ import (
 )
 
 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
   }

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
@@ -481,14 +550,11 @@ 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 {
@@ -524,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,
@@ -543,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}
   }
@@ -561,7 +647,7 @@ 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 {
@@ -668,15 +754,12 @@ 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 {
@@ -975,17 +1058,14 @@ 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 {
@@ -996,7 +1076,7 @@ func iterate_metadata_intersection_category(
   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,13 +10,9 @@ 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()) {
+  // 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)

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

@@ -23,12 +23,16 @@ func Iterate_metadata_native(props IMetadataIteratorProps) bool {
   }
   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) {
+    // 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)
@@ -36,14 +40,9 @@ func Iterate_metadata_native(props IMetadataIteratorProps) bool {
   }
   for _, generic := range iterate_metadata_native_generics {
     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) {
+      // 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)
@@ -69,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,13 +10,9 @@ 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()) {
+  // 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)