typia 13.1.1 → 13.2.0

package/native/core/factories/format_alias_resolves_to_cheat_sheet_test.go

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

package/native/core/factories/format_alias_table_targets_the_cheat_sheet_test.go

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

package/native/core/factories/identifier_factory_postfix_escapes_every_key_test.go

@@ -0,0 +1,147 @@
+package factories
+
+import (
+  "encoding/json"
+  "strings"
+  "testing"
+)
+
+// TestIdentifierFactoryPostfixEscapesEveryKey verifies emitted accessor paths.
+//
+// Postfix returns JavaScript source that callers splice into the emit as
+// `_path + <postfix>`, so it carries two nested escaping levels: the key becomes
+// a JSON literal, and that literal sits inside the JavaScript literal returned.
+// Escaping one level and not the other emitted a file that does not parse for a
+// `"` key, and a path that JSON.parse rejects inside _createStandardSchema for a
+// control-character key. The expected strings below come from the contract that
+// typia's own runtime helper _accessExpressionAsString implements for dynamic
+// keys, `variable(str) ? ".{str}" : "[{JSON.stringify(str)}]"`, not from what
+// the emitter happens to produce.
+//
+//  1. Assert the exact source text Postfix returns for identifier keys, quoting
+//     keys, escape-sensitive keys, control characters, and non-ASCII keys.
+//  2. Decode every result as JSON twice and assert the original key survives.
+//  3. Assert the identifier fast path stays a dotted accessor, so ordinary keys
+//     and prototype-shadowing keys keep their existing output.
+func TestIdentifierFactoryPostfixEscapesEveryKey(t *testing.T) {
+  for _, item := range []struct {
+    name     string
+    key      string
+    expected string
+  }{
+    // Identifier fast path: no escaping is possible, so output is unchanged.
+    {"identifier", "field", `".field"`},
+    {"underscore", "_private", `"._private"`},
+    {"dollar", "$ref", `".$ref"`},
+    // A prototype-shadowing key is still a plain property access, because the
+    // emitted accessor reads the property and never the prototype.
+    {"proto", "__proto__", `".__proto__"`},
+    {"constructor", "constructor", `".constructor"`},
+    {"toString", "toString", `".toString"`},
+    // Ordinary quoted keys: byte-identical to the pre-fix output.
+    {"hyphen", "a-b", `"[\"a-b\"]"`},
+    {"space", "not valid", `"[\"not valid\"]"`},
+    {"empty", "", `"[\"\"]"`},
+    {"digit first", "0abc", `"[\"0abc\"]"`},
+    {"dotted", "a.b", `"[\"a.b\"]"`},
+    {"bracket", "a[0]", `"[\"a[0]\"]"`},
+    {"reserved", "for", `"[\"for\"]"`},
+    // Neither quote nor backslash, so no escape applies at either level.
+    {"single quote", "a'b", `"[\"a'b\"]"`},
+    {"backtick", "a`b", "\"[\\\"a`b\\\"]\""},
+    {"template hole", "a${b}c", `"[\"a${b}c\"]"`},
+    // The double quote is escaped once per level: `"` -> `\"` -> `\\\"`.
+    {"double quote", `a"b`, `"[\"a\\\"b\"]"`},
+    {"only double quote", `"`, `"[\"\\\"\"]"`},
+    // The backslash likewise. Escaping it once left the emitted path saying
+    // `["a\b"]`, which JSON.parse reads back as a backspace, not a backslash.
+    {"backslash", `a\b`, `"[\"a\\\\b\"]"`},
+    {"only backslash", `\`, `"[\"\\\\\"]"`},
+    {"quote and backslash", `a"\b`, `"[\"a\\\"\\\\b\"]"`},
+    // Control characters need a JSON escape; a raw one makes JSON.parse throw.
+    {"newline", "a\nb", `"[\"a\\nb\"]"`},
+    {"tab", "a\tb", `"[\"a\\tb\"]"`},
+    {"carriage return", "a\rb", `"[\"a\\rb\"]"`},
+    {"backspace", "a\bb", `"[\"a\\bb\"]"`},
+    {"form feed", "a\fb", `"[\"a\\fb\"]"`},
+    {"null", "a\x00b", `"[\"a\\u0000b\"]"`},
+    {"unit separator", "a\x1fb", `"[\"a\\u001fb\"]"`},
+    // strconv.Quote wrote `\a` and `\v` here. JavaScript has no `\a`, so it
+    // decoded to a plain "a" and silently changed the key.
+    {"bell", "a\x07b", `"[\"a\\u0007b\"]"`},
+    {"vertical tab", "a\x0bb", `"[\"a\\u000bb\"]"`},
+    // A line terminator to JavaScript but an ordinary character to JSON, so the
+    // escape belongs in the source and must not reach the path itself: the
+    // emitted `\u2028` decodes back to the raw character JSON.stringify writes.
+    {"line separator", "a\u2028b", `"[\"a\u2028b\"]"`},
+    {"paragraph separator", "a\u2029b", `"[\"a\u2029b\"]"`},
+    // Printable non-ASCII stays raw, exactly as JSON.stringify leaves it.
+    {"non ascii", "한글", `"[\"한글\"]"`},
+    {"emoji", "a\U0001F600b", "\"[\\\"a\U0001F600b\\\"]\""},
+    // strconv.Quote wrote `\U0001d173` for a non-printable astral rune, and
+    // JavaScript has no `\U` escape at all; it read back as "U0001d173".
+    {"astral format", "a\U0001D173b", "\"[\\\"a\U0001D173b\\\"]\""},
+    // A lone surrogate arrives WTF-8 encoded and has no valid UTF-8 form, so an
+    // escape is the only way to carry it.
+    {"lone surrogate", "a\xed\xa0\x80b", `"[\"a\\ud800b\"]"`},
+    // No escape denotes a byte that is not UTF-8 at all.
+    {"invalid utf8", "a\xffb", `"[\"a\\ufffdb\"]"`},
+  } {
+    t.Run(item.name, func(t *testing.T) {
+      output := IdentifierFactory.Postfix(item.key)
+      if output != item.expected {
+        t.Fatalf("Postfix(%q)\n got: %s\nwant: %s", item.key, output, item.expected)
+      }
+      identifierFactoryPostfixRoundTrip(t, item.key, output)
+    })
+  }
+}
+
+// identifierFactoryPostfixRoundTrip decodes the emitted source the way the
+// runtime does: JavaScript reads the outer literal, then _createStandardSchema
+// hands the bracketed key to JSON.parse. encoding/json stands in for both,
+// which makes this an independent check that the escaping is real rather than a
+// restatement of the emitter's own logic.
+func identifierFactoryPostfixRoundTrip(t *testing.T, key string, output string) {
+  t.Helper()
+  var path string
+  if err := json.Unmarshal([]byte(output), &path); err != nil {
+    t.Fatalf("Postfix(%q) is not a JavaScript string literal: %s (%v)", key, output, err)
+  }
+  if strings.HasPrefix(path, ".") {
+    if path[1:] != key {
+      t.Fatalf("Postfix(%q) dotted accessor lost the key: %q", key, path)
+    }
+    return
+  }
+  if !strings.HasPrefix(path, "[") || !strings.HasSuffix(path, "]") {
+    t.Fatalf("Postfix(%q) is neither a dotted nor a bracketed accessor: %q", key, path)
+  }
+  var decoded string
+  if err := json.Unmarshal([]byte(path[1:len(path)-1]), &decoded); err != nil {
+    t.Fatalf("Postfix(%q) bracketed key is not JSON: %q (%v)", key, path, err)
+  }
+  if want := identifierFactoryPostfixDecodable(key); decoded != want {
+    t.Fatalf("Postfix(%q) round-tripped to %q, want %q", key, decoded, want)
+  }
+}
+
+// identifierFactoryPostfixDecodable states what a JSON decoder can return for
+// `key`. encoding/json replaces an unpaired surrogate and never yields invalid
+// UTF-8, so those two inputs come back as the replacement character even though
+// the emitted escape itself is exact.
+func identifierFactoryPostfixDecodable(key string) string {
+  var builder strings.Builder
+  for i := 0; i < len(key); {
+    // Detect a WTF-8 surrogate here rather than calling the factory's own
+    // helper, so this expectation stays independent of the code under test.
+    if len(key)-i >= 3 && key[i] == 0xed && key[i+1] >= 0xa0 && key[i+1] <= 0xbf {
+      builder.WriteRune('�')
+      i += 3
+      continue
+    }
+    builder.WriteByte(key[i])
+    i++
+  }
+  return strings.ToValidUTF8(builder.String(), "�")
+}

package/native/core/factories/identifier_factory_postfix_survives_every_code_point_test.go

@@ -0,0 +1,86 @@
+package factories
+
+import (
+  "encoding/json"
+  "fmt"
+  "strings"
+  "testing"
+  "unicode/utf8"
+)
+
+// TestIdentifierFactoryPostfixSurvivesEveryCodePoint verifies total escaping.
+//
+// The emitted accessor is spliced into the emit as source text, and nothing
+// downstream parses the file, so a key the escaper mishandles ships as a broken
+// artifact behind a successful build. The table-driven case list pins the
+// characters that actually regressed; this one closes the class by sweeping the
+// whole input space, because the escape decision is per rune and a sampled
+// matrix cannot prove a per-rune rule. encoding/json decodes the result, which
+// is an implementation typia does not own and therefore a real oracle: JSON
+// string syntax is a subset of JavaScript string syntax, so a literal it accepts
+// also parses in the emitted file.
+//
+//  1. Sweep every scalar value and assert the key round-trips exactly.
+//  2. Sweep every surrogate code unit and assert the WTF-8 form survives as an
+//     escape rather than corrupting the literal.
+//  3. Sweep every single byte, including the ones that are not UTF-8, and assert
+//     the emitted literal still decodes.
+func TestIdentifierFactoryPostfixSurvivesEveryCodePoint(t *testing.T) {
+  for code := rune(0); code <= utf8.MaxRune; code++ {
+    if code >= 0xd800 && code <= 0xdfff {
+      continue // Not a scalar value; covered by the surrogate sweep below.
+    }
+    key := "a" + string(code) + "b"
+    if decoded := identifierFactoryPostfixDecode(t, key); decoded != key {
+      t.Fatalf("U+%04X: Postfix round-tripped to %q, want %q", code, decoded, key)
+    }
+  }
+
+  for unit := rune(0xd800); unit <= 0xdfff; unit++ {
+    key := "a" + string([]byte{
+      0xe0 | byte(unit>>12),
+      0x80 | byte((unit>>6)&0x3f),
+      0x80 | byte(unit&0x3f),
+    }) + "b"
+    output := IdentifierFactory.Postfix(key)
+    // The inner level writes `\ud800` and the outer level escapes that
+    // backslash, so the emitted source carries `\\ud800`.
+    if want := fmt.Sprintf(`\\u%04x`, unit); !strings.Contains(output, want) {
+      t.Fatalf("U+%04X: lone surrogate was not escaped as %s: %s", unit, want, output)
+    }
+    // The decoder replaces an unpaired surrogate, so assert the literal stays
+    // well formed rather than demanding the original bytes back.
+    identifierFactoryPostfixDecode(t, key)
+  }
+
+  for value := 0; value <= 0xff; value++ {
+    key := "a" + string([]byte{byte(value)}) + "b"
+    decoded := identifierFactoryPostfixDecode(t, key)
+    if utf8.ValidString(key) && decoded != key {
+      t.Fatalf("byte 0x%02X: Postfix round-tripped to %q, want %q", value, decoded, key)
+    }
+  }
+}
+
+// identifierFactoryPostfixDecode reads the emitted source the way the runtime
+// does and fails the test if any layer rejects it: JavaScript parses the outer
+// literal, then _createStandardSchema hands the bracketed key to JSON.parse.
+func identifierFactoryPostfixDecode(t *testing.T, key string) string {
+  t.Helper()
+  output := IdentifierFactory.Postfix(key)
+  var path string
+  if err := json.Unmarshal([]byte(output), &path); err != nil {
+    t.Fatalf("Postfix(%q) is not a string literal: %s (%v)", key, output, err)
+  }
+  if strings.HasPrefix(path, ".") {
+    return path[1:]
+  }
+  if !strings.HasPrefix(path, "[") || !strings.HasSuffix(path, "]") {
+    t.Fatalf("Postfix(%q) is not an accessor: %q", key, path)
+  }
+  var decoded string
+  if err := json.Unmarshal([]byte(path[1:len(path)-1]), &decoded); err != nil {
+    t.Fatalf("Postfix(%q) bracketed key is not JSON: %q (%v)", key, path, err)
+  }
+  return decoded
+}

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

@@ -129,19 +129,17 @@ func metadata_explore_symbol_name(node *nativeast.Node, name string) string {
   return name
 }
 
-func metadata_get_type_arguments(checker *nativechecker.Checker, typ *nativechecker.Type) (output []*nativechecker.Type) {
+func metadata_get_type_arguments(checker *nativechecker.Checker, typ *nativechecker.Type) []*nativechecker.Type {
   if checker == nil || typ == nil {
     return nil
   }
-  defer func() {
-    if recover() != nil {
-      output = nil
-    }
-  }()
+  if typ.Flags()&nativechecker.TypeFlagsObject == 0 || typ.ObjectFlags()&nativechecker.ObjectFlagsReference == 0 {
+    return nil
+  }
   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
   }
@@ -153,6 +151,24 @@ func metadata_get_function_node(typ *nativechecker.Type) *nativeast.Node {
   if nativeast.IsFunctionLike(node) {
     return node
   }
+  // The global `Function` interface (declared in a default `lib.*.d.ts`) is
+  // callable and newable at runtime, so a `Function`-typed member is a function,
+  // not a structural object: `constructor: Function` on the global `Object`
+  // interface, an explicit `x: Function`, or any member inherited through
+  // `extends Object`. Its symbol resolves to an `InterfaceDeclaration` rather
+  // than a function-like node, so without this branch it is expanded
+  // structurally (`{ prototype, length, arguments, caller, name }`) and its
+  // `typeof` is checked as `"object"` even though a real function reports
+  // `"function"`, making `is<Object>` universally false (#2178). Returning the
+  // interface declaration routes the member through the same function path typia
+  // already uses for `() => void` members: a lenient pass under default options
+  // and a signature-based check under `functional`.
+  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) {
@@ -268,28 +284,221 @@ func metadata_node_type_js_doc_tags(symbol *nativeast.Symbol) []schemametadata.I
   return metadata_node_js_doc_tags(symbol)
 }
 
+// metadata_is_global_function_interface reports whether the type behind `symbol`
+// is the global `Function` interface from a TypeScript default library. The
+// match is intentionally narrow — the symbol name is exactly `"Function"`, its
+// 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. 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" {
+    return false
+  }
+  if node == nil || node.Kind != nativeast.KindInterfaceDeclaration {
+    return false
+  }
+  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_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
 }
 
-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:]
+// 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 false
+}
+
+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 {