@tsonic/frontend 0.0.73 → 0.0.75

package/dist/program/binding-registry.js

@@ -1,9 +1,17 @@
 /**
  * Binding Registry - runtime registry of all loaded bindings
  * Supports simple (global/module) and hierarchical (namespace/type/member) formats
+ *
+ * This file is a thin facade. Heavy logic lives in:
+ *   - binding-registry-resolution.ts  (member & extension-method resolution)
+ *   - binding-registry-loading.ts     (addBindings ingestion)
  */
-import { tsbindgenClrTypeNameToTsTypeName } from "../tsbindgen/names.js";
-import { isFullBindingManifest, isTsbindgenBindingFile, } from "./binding-types.js";
+import { resolveLookupAlias, resolveMemberOverloads, resolveExtensionMethod, resolveExtensionMethodByKey, isTypeOrSubtype, } from "./binding-registry-resolution.js";
+import { makeClrMemberKey } from "./binding-registry-loading.js";
+import { addBindingsToState } from "./binding-registry-loading.js";
+// ---------------------------------------------------------------------------
+// Simple-binding helpers (used by getEmitterTypeMap and external callers)
+// ---------------------------------------------------------------------------
 export const simpleBindingContributesTypeIdentity = (descriptor) => {
     const explicit = descriptor.typeSemantics?.contributesTypeIdentity;
     if (explicit !== undefined) {
@@ -11,6 +19,10 @@ export const simpleBindingContributesTypeIdentity = (descriptor) => {
     }
     return false;
 };
+const getSimpleBindingIdentityClrType = (descriptor) => descriptor.staticType ?? descriptor.type;
+// ---------------------------------------------------------------------------
+// BindingRegistry class (facade)
+// ---------------------------------------------------------------------------
 /**
  * Registry of all loaded bindings
  * Supports simple (global/module) and hierarchical (namespace/type/member) formats
@@ -18,9 +30,11 @@ export const simpleBindingContributesTypeIdentity = (descriptor) => {
 export class BindingRegistry {
     constructor() {
         this.loadedBindingFiles = new Set();
+        this.sourceOwnedTypeAliases = new Set();
         // Simple format: global/module bindings for identifiers like console, Math, fs
         this.simpleBindings = new Map();
-        this.simpleBindingsLowercase = new Map();
+        this.simpleGlobalBindings = new Map();
+        this.simpleModuleBindings = new Map();
         // Hierarchical format: namespace/type/member bindings
         this.namespaces = new Map();
         this.types = new Map(); // Flat lookup by TS name
@@ -28,8 +42,10 @@ export class BindingRegistry {
         this.members = new Map(); // Flat lookup by "type.member"
         this.memberOverloads = new Map(); // Overload-aware lookup by "type.member"
         this.clrMemberOverloads = new Map(); // Overload-aware lookup by CLR target key
+        this.clrTypeNamesByAlias = new Map();
         this.tsbindgenExports = new Map();
         this.tsSupertypes = new Map();
+        this.tsBaseTypes = new Map();
         this.clrTypeNames = new Set();
         /**
          * Extension method index for instance-style calls.
@@ -43,433 +59,71 @@ export class BindingRegistry {
          */
         this.extensionMethods = new Map();
     }
-    getExtensionMethodCandidates(namespaceKey, receiverTypeName, methodTsName) {
-        return this.extensionMethods
-            .get(namespaceKey)
-            ?.get(receiverTypeName)
-            ?.get(methodTsName);
-    }
-    addSupertype(typeAlias, superAlias) {
-        if (!typeAlias || !superAlias)
-            return;
-        if (typeAlias === superAlias)
-            return;
-        const set = this.tsSupertypes.get(typeAlias) ?? new Set();
-        set.add(superAlias);
-        this.tsSupertypes.set(typeAlias, set);
-    }
-    getDirectSupertypes(typeAlias) {
-        const set = this.tsSupertypes.get(typeAlias);
-        if (!set || set.size === 0)
-            return [];
-        return Array.from(set).sort((a, b) => a.localeCompare(b));
-    }
-    /**
-     * Resolve an extension method binding target by extension interface name.
-     *
-     * @param extensionInterfaceName - e.g. "__Ext_System_Linq_IEnumerable_1"
-     * @param methodTsName - e.g. "where"
-     */
-    resolveExtensionMethod(extensionInterfaceName, methodTsName, callArgumentCount) {
-        const parsed = this.parseExtensionInterfaceName(extensionInterfaceName);
-        if (!parsed)
-            return undefined;
-        return this.resolveExtensionMethodByKey(parsed.namespaceKey, parsed.receiverTypeName, methodTsName, callArgumentCount);
-    }
-    /**
-     * Resolve an extension method binding target by explicit (namespaceKey, receiverTypeName).
-     *
-     * Used when extension methods are emitted as method-table members with explicit `this:`
-     * receiver constraints (the declaring interface name no longer encodes the receiver type).
-     */
-    resolveExtensionMethodByKey(namespaceKey, receiverTypeName, methodTsName, callArgumentCount) {
-        const getParameterCount = (binding) => {
-            if (typeof binding.parameterCount === "number") {
-                return binding.parameterCount;
-            }
-            const sig = binding.signature;
-            if (!sig)
-                return undefined;
-            const paramsMatch = sig.match(/\|\(([^)]*)\):/);
-            const paramsStr = paramsMatch?.[1]?.trim();
-            if (!paramsStr)
-                return undefined;
-            return splitSignatureTypeList(paramsStr).length;
-        };
-        const getModifiersKey = (binding) => {
-            const mods = (binding.parameterModifiers ??
-                []);
-            if (!Array.isArray(mods) || mods.length === 0)
-                return "";
-            return [...mods]
-                .slice()
-                .sort((a, b) => a.index - b.index)
-                .map((m) => `${m.index}:${m.modifier}`)
-                .join(",");
-        };
-        const resolveForReceiver = (receiverTypeName) => {
-            const candidates = this.getExtensionMethodCandidates(namespaceKey, receiverTypeName, methodTsName);
-            if (!candidates || candidates.length === 0)
-                return { kind: "none" };
-            let filteredCandidates = candidates;
-            if (typeof callArgumentCount === "number") {
-                const desiredParamCount = callArgumentCount + 1;
-                const exact = candidates.filter((c) => getParameterCount(c) === desiredParamCount);
-                if (exact.length > 0) {
-                    filteredCandidates = exact;
-                }
-                else {
-                    // Optional-parameter safety: if no exact arity match, choose the smallest
-                    // candidate arity that can still accept the provided arguments.
-                    const larger = candidates
-                        .map((c) => ({ c, count: getParameterCount(c) }))
-                        .filter((x) => typeof x.count === "number" && x.count > desiredParamCount);
-                    if (larger.length === 0)
-                        return { kind: "none" };
-                    const minCount = Math.min(...larger.map((x) => x.count));
-                    filteredCandidates = larger
-                        .filter((x) => x.count === minCount)
-                        .map((x) => x.c);
-                }
-            }
-            // If multiple candidates map to different CLR targets, treat as unresolved (unsafe).
-            const first = filteredCandidates[0];
-            if (!first)
-                return { kind: "none" };
-            const firstTarget = `${first.binding.type}::${first.binding.member}`;
-            const firstModsKey = getModifiersKey(first);
-            for (const c of filteredCandidates) {
-                const target = `${c.binding.type}::${c.binding.member}`;
-                if (target !== firstTarget) {
-                    return { kind: "ambiguous" };
-                }
-                if (getModifiersKey(c) !== firstModsKey) {
-                    return { kind: "ambiguous" };
-                }
-            }
-            return { kind: "resolved", binding: first };
+    /** Snapshot of mutable state for use by extracted pure resolution functions. */
+    get state() {
+        return {
+            types: this.types,
+            memberOverloads: this.memberOverloads,
+            clrTypeNamesByAlias: this.clrTypeNamesByAlias,
+            extensionMethods: this.extensionMethods,
+            tsSupertypes: this.tsSupertypes,
+            tsBaseTypes: this.tsBaseTypes,
+            simpleBindings: this.simpleBindings,
+            simpleGlobalBindings: this.simpleGlobalBindings,
+            simpleModuleBindings: this.simpleModuleBindings,
+            typeLookupAliasMap: this.typeLookupAliasMap,
+            clrTypeNames: this.clrTypeNames,
         };
-        // 1) Exact receiver match.
-        const direct = resolveForReceiver(receiverTypeName);
-        if (direct.kind === "resolved")
-            return direct.binding;
-        if (direct.kind === "ambiguous")
-            return undefined;
-        // 2) Airplane-grade fallback: CLR interface/base-type inheritance.
-        // This allows instance-style calls to resolve when TS surface selects a method
-        // declared on a derived type's extension bucket (e.g., IQueryable<T>.ToList)
-        // but the CLR binding is declared on a base interface (e.g., IEnumerable<T>).
-        //
-        // Determinism rules:
-        // - Prefer the closest base match (BFS).
-        // - If multiple matches exist at the same depth with different CLR targets,
-        //   treat as unresolved (unsafe).
-        const visited = new Set([receiverTypeName]);
-        let frontier = [receiverTypeName];
-        for (let depth = 0; depth < 20; depth++) {
-            const next = [];
-            for (const t of frontier) {
-                for (const sup of this.getDirectSupertypes(t)) {
-                    if (visited.has(sup))
-                        continue;
-                    visited.add(sup);
-                    next.push(sup);
-                }
-            }
-            if (next.length === 0)
-                break;
-            const resolvedAtDepth = [];
-            let sawAmbiguous = false;
-            for (const sup of next) {
-                const res = resolveForReceiver(sup);
-                if (res.kind === "ambiguous")
-                    sawAmbiguous = true;
-                if (res.kind === "resolved")
-                    resolvedAtDepth.push(res.binding);
-            }
-            if (resolvedAtDepth.length > 0 || sawAmbiguous) {
-                // If any ambiguity exists at the closest depth, do not guess.
-                if (sawAmbiguous)
-                    return undefined;
-                const first = resolvedAtDepth[0];
-                if (!first)
-                    return undefined;
-                const target0 = `${first.binding.type}::${first.binding.member}`;
-                const mods0 = getModifiersKey(first);
-                for (const b of resolvedAtDepth) {
-                    const target = `${b.binding.type}::${b.binding.member}`;
-                    if (target !== target0)
-                        return undefined;
-                    if (getModifiersKey(b) !== mods0)
-                        return undefined;
-                }
-                return first;
-            }
-            frontier = next;
-        }
-        return undefined;
-    }
-    parseExtensionInterfaceName(extensionInterfaceName) {
-        if (!extensionInterfaceName.startsWith("__Ext_"))
-            return undefined;
-        const rest = extensionInterfaceName.slice("__Ext_".length);
-        // Find the longest namespaceKey prefix we have indexed.
-        let bestNamespaceKey;
-        for (const namespaceKey of this.extensionMethods.keys()) {
-            if (rest.startsWith(`${namespaceKey}_`)) {
-                if (!bestNamespaceKey ||
-                    namespaceKey.length > bestNamespaceKey.length) {
-                    bestNamespaceKey = namespaceKey;
-                }
-            }
-        }
-        if (!bestNamespaceKey)
-            return undefined;
-        const receiverTypeName = rest.slice(bestNamespaceKey.length + 1);
-        if (!receiverTypeName)
-            return undefined;
-        return { namespaceKey: bestNamespaceKey, receiverTypeName };
     }
     /**
      * Load a binding manifest file and add its bindings to the registry
      * Supports simple, full, and tsbindgen formats
      */
     addBindings(_filePath, manifest) {
-        // Airplane-grade: a given bindings file must be loaded exactly once per
-        // ProgramContext. Some converters perform on-demand bindings.json loading
-        // based on Binding-resolved MemberIds; without this guard, overload sets
-        // can silently duplicate and become ambiguous.
-        if (this.loadedBindingFiles.has(_filePath))
-            return;
-        this.loadedBindingFiles.add(_filePath);
-        const addMemberOverload = (key, member) => {
-            const existing = this.memberOverloads.get(key) ?? [];
-            existing.push(member);
-            this.memberOverloads.set(key, existing);
-        };
-        const addClrMemberOverload = (member) => {
-            if (member.kind !== "method")
-                return;
-            const clrTargetKey = makeClrMemberKey(member.binding.assembly, member.binding.type, member.binding.member);
-            const existing = this.clrMemberOverloads.get(clrTargetKey) ?? [];
-            existing.push(member);
-            this.clrMemberOverloads.set(clrTargetKey, existing);
-        };
-        if (isFullBindingManifest(manifest)) {
-            // Full format: hierarchical namespace/type/member structure
-            // Index by alias (TS identifier) for quick lookup
-            for (const ns of manifest.namespaces) {
-                this.namespaces.set(ns.alias, ns);
-                // Index types for quick lookup by TS alias
-                for (const type of ns.types) {
-                    this.clrTypeNames.add(type.name);
-                    this.types.set(type.alias, type);
-                    // Index members for quick lookup (keyed by "typeAlias.memberAlias")
-                    for (const member of type.members) {
-                        const key = `${type.alias}.${member.alias}`;
-                        this.members.set(key, member);
-                        addMemberOverload(key, member);
-                        addClrMemberOverload(member);
-                    }
-                }
-            }
-        }
-        else if (isTsbindgenBindingFile(manifest)) {
-            // tsbindgen format: convert to internal format
-            const namespaceTypes = [];
-            const derivedAliasCounts = new Map();
-            for (const tsbType of manifest.types) {
-                const derivedAlias = tsbindgenClrTypeNameToTsTypeName(tsbType.clrName);
-                derivedAliasCounts.set(derivedAlias, (derivedAliasCounts.get(derivedAlias) ?? 0) + 1);
-            }
-            for (const tsbType of manifest.types) {
-                // Create members from methods, properties, and fields
-                const members = [];
-                for (const method of tsbType.methods) {
-                    const memberBinding = {
-                        kind: "method",
-                        name: method.clrName,
-                        // No naming policy: TS member names are the CLR names as authored.
-                        alias: method.clrName,
-                        signature: method.normalizedSignature,
-                        semanticSignature: method.semanticSignature,
-                        parameterCount: method.parameterCount,
-                        binding: {
-                            assembly: method.declaringAssemblyName,
-                            type: method.declaringClrType,
-                            // member = clrName (what C# emits, e.g., "Add")
-                            member: method.clrName,
-                        },
-                        // Include parameter modifiers for ref/out/in parameters
-                        parameterModifiers: method.parameterModifiers,
-                        isExtensionMethod: method.isExtensionMethod ?? false,
-                        emitSemantics: method.emitSemantics,
-                    };
-                    members.push(memberBinding);
-                    addClrMemberOverload(memberBinding);
-                    // Index extension methods by (declaring namespace, receiver type, method name).
-                    if (method.isExtensionMethod && method.normalizedSignature) {
-                        const receiverTypeName = extractExtensionReceiverType(method.normalizedSignature);
-                        const namespaceKey = extractNamespaceKey(method.declaringClrType);
-                        if (receiverTypeName && namespaceKey) {
-                            const nsMap = this.extensionMethods.get(namespaceKey) ??
-                                new Map();
-                            if (!this.extensionMethods.has(namespaceKey)) {
-                                this.extensionMethods.set(namespaceKey, nsMap);
-                            }
-                            const receiverMap = nsMap.get(receiverTypeName) ??
-                                new Map();
-                            if (!nsMap.has(receiverTypeName)) {
-                                nsMap.set(receiverTypeName, receiverMap);
-                            }
-                            const list = receiverMap.get(memberBinding.alias) ?? [];
-                            list.push(memberBinding);
-                            receiverMap.set(memberBinding.alias, list);
-                        }
-                    }
-                }
-                for (const prop of tsbType.properties) {
-                    members.push({
-                        kind: "property",
-                        signature: prop.normalizedSignature,
-                        semanticType: prop.semanticType,
-                        semanticOptional: prop.semanticOptional,
-                        name: prop.clrName,
-                        alias: prop.clrName,
-                        binding: {
-                            assembly: prop.declaringAssemblyName,
-                            type: prop.declaringClrType,
-                            member: prop.clrName,
-                        },
-                    });
-                }
-                for (const field of tsbType.fields) {
-                    // Fields are treated as properties for binding purposes
-                    members.push({
-                        kind: "property",
-                        signature: field.normalizedSignature,
-                        semanticType: field.semanticType,
-                        semanticOptional: field.semanticOptional,
-                        name: field.clrName,
-                        alias: field.clrName,
-                        binding: {
-                            assembly: field.declaringAssemblyName,
-                            type: field.declaringClrType,
-                            member: field.clrName,
-                        },
-                    });
-                }
-                const derivedAlias = tsbindgenClrTypeNameToTsTypeName(tsbType.clrName);
-                const tsAlias = tsbType.alias ?? derivedAlias;
-                const uniqueDerivedAlias = (derivedAliasCounts.get(derivedAlias) ?? 0) === 1;
-                // Record CLR inheritance relationships (base type + interfaces) so extension-method
-                // binding lookup can follow the CLR graph deterministically.
-                const baseAlias = tsbType.baseType?.clrName
-                    ? tsbindgenClrTypeNameToTsTypeName(tsbType.baseType.clrName)
-                    : undefined;
-                if (baseAlias)
-                    this.addSupertype(tsAlias, baseAlias);
-                for (const iface of tsbType.interfaces ?? []) {
-                    if (!iface?.clrName)
-                        continue;
-                    const ifaceAlias = tsbindgenClrTypeNameToTsTypeName(iface.clrName);
-                    this.addSupertype(tsAlias, ifaceAlias);
-                }
-                const kindFromBindings = (() => {
-                    switch (tsbType.kind) {
-                        case "Interface":
-                            return "interface";
-                        case "Struct":
-                            return "struct";
-                        case "Enum":
-                            return "enum";
-                        case "Class":
-                        default:
-                            return "class";
-                    }
-                })();
-                // Create TypeBinding - TS alias is derived deterministically from CLR name.
-                const typeBinding = {
-                    name: tsbType.clrName,
-                    alias: tsAlias,
-                    kind: kindFromBindings,
-                    members,
-                };
-                this.clrTypeNames.add(tsbType.clrName);
-                this.typeLookupAliasMap.set(tsbType.clrName, typeBinding.alias);
-                if (!typeBinding.alias.includes(".")) {
-                    this.typeLookupAliasMap.set(`${manifest.namespace}.${typeBinding.alias}`, typeBinding.alias);
-                }
-                namespaceTypes.push(typeBinding);
-                // Index the type by its TS name.
-                this.types.set(typeBinding.alias, typeBinding);
-                if (uniqueDerivedAlias && derivedAlias !== typeBinding.alias) {
-                    this.types.set(derivedAlias, typeBinding);
-                    this.typeLookupAliasMap.set(derivedAlias, typeBinding.alias);
-                }
-                // Also index by simple name if ts alias has arity suffix (e.g., "List_1" -> also index as "List")
-                // This is needed because TS exports both List_1 and List as aliases, and TS code uses List<T>
-                // IMPORTANT: Only set if not already present - non-generic versions should take precedence
-                // (e.g., Action should resolve to System.Action, not System.Action`9)
-                const arityMatch = derivedAlias.match(/^(.+)_(\d+)$/);
-                const simpleAlias = arityMatch ? arityMatch[1] : null;
-                if (simpleAlias &&
-                    simpleAlias !== typeBinding.alias &&
-                    !this.types.has(simpleAlias)) {
-                    this.types.set(simpleAlias, typeBinding);
-                }
-                // Index members for direct lookup.
-                for (const member of members) {
-                    // Key by canonical TS alias.
-                    const tsKey = `${typeBinding.alias}.${member.alias}`;
-                    this.members.set(tsKey, member);
-                    addMemberOverload(tsKey, member);
-                    // Also key by the derived/simple alias when it is uniquely owned.
-                    if (uniqueDerivedAlias && derivedAlias !== typeBinding.alias) {
-                        const derivedKey = `${derivedAlias}.${member.alias}`;
-                        this.members.set(derivedKey, member);
-                        addMemberOverload(derivedKey, member);
-                    }
-                    // Also key by simple alias if applicable (e.g., "List.Add")
-                    if (simpleAlias) {
-                        const simpleKey = `${simpleAlias}.${member.alias}`;
-                        this.members.set(simpleKey, member);
-                        addMemberOverload(simpleKey, member);
-                    }
-                }
-            }
-            // Optional flattened named exports.
-            // These are stable value exports for CLR namespace facade modules and are
-            // resolved by Tsonic during import binding (so `import { x }` maps to
-            // `global::<DeclaringType>.<member>` in C#).
-            if (manifest.exports) {
-                const nsExports = this.tsbindgenExports.get(manifest.namespace) ??
-                    new Map();
-                for (const [exportName, exp] of Object.entries(manifest.exports)) {
-                    nsExports.set(exportName, exp);
-                }
-                this.tsbindgenExports.set(manifest.namespace, nsExports);
-            }
-            this.namespaces.set(manifest.namespace, {
-                name: manifest.namespace,
-                alias: manifest.namespace,
-                types: namespaceTypes,
-            });
-        }
-        else {
-            // Simple format: global/module bindings
-            for (const [name, descriptor] of Object.entries(manifest.bindings)) {
-                this.simpleBindings.set(name, descriptor);
-                this.simpleBindingsLowercase.set(name.toLowerCase(), descriptor);
-            }
-        }
+        addBindingsToState({
+            loadedBindingFiles: this.loadedBindingFiles,
+            sourceOwnedTypeAliases: this.sourceOwnedTypeAliases,
+            simpleBindings: this.simpleBindings,
+            simpleGlobalBindings: this.simpleGlobalBindings,
+            simpleModuleBindings: this.simpleModuleBindings,
+            namespaces: this.namespaces,
+            types: this.types,
+            typeLookupAliasMap: this.typeLookupAliasMap,
+            members: this.members,
+            memberOverloads: this.memberOverloads,
+            clrMemberOverloads: this.clrMemberOverloads,
+            clrTypeNamesByAlias: this.clrTypeNamesByAlias,
+            extensionMethods: this.extensionMethods,
+            tsbindgenExports: this.tsbindgenExports,
+            tsSupertypes: this.tsSupertypes,
+            tsBaseTypes: this.tsBaseTypes,
+            clrTypeNames: this.clrTypeNames,
+        }, _filePath, manifest);
     }
     /**
      * Look up a simple global/module binding
      */
+    getExactBinding(name) {
+        return this.simpleBindings.get(name);
+    }
+    getExactBindingByKind(name, kind) {
+        return kind === "global"
+            ? this.simpleGlobalBindings.get(name)
+            : this.simpleModuleBindings.get(name);
+    }
+    /**
+     * Look up a simple global/module binding by exact authored name.
+     */
     getBinding(name) {
-        return (this.simpleBindings.get(name) ??
-            this.simpleBindingsLowercase.get(name.toLowerCase()));
+        return this.simpleBindings.get(name);
+    }
+    getBindingByKind(name, kind) {
+        return kind === "global"
+            ? this.simpleGlobalBindings.get(name)
+            : this.simpleModuleBindings.get(name);
+    }
+    hasSourceOwnedTypeAlias(typeAlias) {
+        return this.sourceOwnedTypeAliases.has(typeAlias);
     }
     /**
      * Look up a namespace binding by TS alias
@@ -481,7 +135,7 @@ export class BindingRegistry {
      * Look up a type binding by TS alias
      */
     getType(tsAlias) {
-        return this.types.get(this.resolveLookupAlias(tsAlias));
+        return this.types.get(resolveLookupAlias(this.state, tsAlias));
     }
     /**
      * Check whether a CLR type name exists in loaded bindings.
@@ -493,31 +147,8 @@ export class BindingRegistry {
      * Look up a member binding by TS type alias and member alias
      */
     getMember(typeAlias, memberAlias) {
-        const normalizedTypeAlias = this.resolveLookupAlias(typeAlias);
-        const key = `${normalizedTypeAlias}.${memberAlias}`;
-        const direct = this.members.get(key);
-        if (direct)
-            return direct;
-        // tsbindgen encodes protected CLR members on a synthetic `${TypeName}$protected` class.
-        // Those members are still declared on the real CLR type, so bindings must resolve
-        // through the owning type alias.
-        if (normalizedTypeAlias.endsWith("$protected")) {
-            const ownerAlias = normalizedTypeAlias.slice(0, -"$protected".length);
-            return this.members.get(`${ownerAlias}.${memberAlias}`);
-        }
-        const mappedAlias = this.resolveSimpleBindingAlias(normalizedTypeAlias);
-        if (mappedAlias) {
-            const mapped = this.members.get(`${mappedAlias}.${memberAlias}`);
-            if (mapped)
-                return mapped;
-            if (mappedAlias.endsWith("$protected")) {
-                const ownerAlias = mappedAlias.slice(0, -"$protected".length);
-                const owner = this.members.get(`${ownerAlias}.${memberAlias}`);
-                if (owner)
-                    return owner;
-            }
-        }
-        return undefined;
+        const overloads = this.getMemberOverloads(typeAlias, memberAlias);
+        return overloads?.[0];
     }
     /**
      * Look up all member bindings for a TS type alias + member alias.
@@ -526,35 +157,8 @@ export class BindingRegistry {
      * modifiers (tsbindgen provides these via `parameterModifiers`). This accessor
      * preserves overload sets so the call converter can select the correct one.
      */
-    getMemberOverloads(typeAlias, memberAlias) {
-        const normalizedTypeAlias = this.resolveLookupAlias(typeAlias);
-        const key = `${normalizedTypeAlias}.${memberAlias}`;
-        const direct = this.memberOverloads.get(key);
-        if (direct && direct.length > 0)
-            return direct;
-        // See getMember(): map `${TypeName}$protected` to `${TypeName}` for CLR binding lookup.
-        if (normalizedTypeAlias.endsWith("$protected")) {
-            const ownerAlias = normalizedTypeAlias.slice(0, -"$protected".length);
-            const ownerKey = `${ownerAlias}.${memberAlias}`;
-            const owner = this.memberOverloads.get(ownerKey);
-            if (owner && owner.length > 0)
-                return owner;
-        }
-        const mappedAlias = this.resolveSimpleBindingAlias(normalizedTypeAlias);
-        if (mappedAlias) {
-            const mappedKey = `${mappedAlias}.${memberAlias}`;
-            const mapped = this.memberOverloads.get(mappedKey);
-            if (mapped && mapped.length > 0)
-                return mapped;
-            if (mappedAlias.endsWith("$protected")) {
-                const ownerAlias = mappedAlias.slice(0, -"$protected".length);
-                const ownerKey = `${ownerAlias}.${memberAlias}`;
-                const owner = this.memberOverloads.get(ownerKey);
-                if (owner && owner.length > 0)
-                    return owner;
-            }
-        }
-        return undefined;
+    getMemberOverloads(typeAlias, memberAlias, preferredClrOwner) {
+        return resolveMemberOverloads(this.state, typeAlias, memberAlias, preferredClrOwner);
     }
     /**
      * Look up all member bindings for a CLR member target.
@@ -564,6 +168,24 @@ export class BindingRegistry {
     getClrMemberOverloads(assembly, clrType, clrMember) {
         return this.clrMemberOverloads.get(makeClrMemberKey(assembly, clrType, clrMember));
     }
+    /**
+     * Resolve an extension method binding target by extension interface name.
+     *
+     * @param extensionInterfaceName - e.g. "__Ext_System_Linq_IEnumerable_1"
+     * @param methodTsName - e.g. "where"
+     */
+    resolveExtensionMethod(extensionInterfaceName, methodTsName, callArgumentCount) {
+        return resolveExtensionMethod(this.state, extensionInterfaceName, methodTsName, callArgumentCount);
+    }
+    /**
+     * Resolve an extension method binding target by explicit (namespaceKey, receiverTypeName).
+     *
+     * Used when extension methods are emitted as method-table members with explicit `this:`
+     * receiver constraints (the declaring interface name no longer encodes the receiver type).
+     */
+    resolveExtensionMethodByKey(namespaceKey, receiverTypeName, methodTsName, callArgumentCount) {
+        return resolveExtensionMethodByKey(this.state, namespaceKey, receiverTypeName, methodTsName, callArgumentCount);
+    }
     /**
      * Look up a tsbindgen flattened named export by CLR namespace + export name.
      */
@@ -576,6 +198,9 @@ export class BindingRegistry {
     getAllBindings() {
         return Array.from(this.simpleBindings.entries());
     }
+    isTypeOrSubtype(typeAlias, superAlias) {
+        return isTypeOrSubtype(this.state, typeAlias, superAlias);
+    }
     /**
      * Get all loaded namespaces
      */
@@ -606,14 +231,15 @@ export class BindingRegistry {
             if (!simpleBindingContributesTypeIdentity(descriptor)) {
                 continue;
             }
-            if (result.has(alias))
-                continue;
-            result.set(alias, {
-                alias,
-                name: descriptor.type,
-                kind: "class",
-                members: [],
-            });
+            const identityClrType = getSimpleBindingIdentityClrType(descriptor);
+            if (!result.has(alias)) {
+                result.set(alias, {
+                    alias,
+                    name: identityClrType,
+                    kind: "class",
+                    members: [],
+                });
+            }
         }
         return result;
     }
@@ -623,97 +249,20 @@ export class BindingRegistry {
     clear() {
         this.loadedBindingFiles.clear();
         this.simpleBindings.clear();
-        this.simpleBindingsLowercase.clear();
+        this.simpleGlobalBindings.clear();
+        this.simpleModuleBindings.clear();
         this.namespaces.clear();
         this.types.clear();
         this.typeLookupAliasMap.clear();
         this.members.clear();
         this.memberOverloads.clear();
         this.clrMemberOverloads.clear();
+        this.clrTypeNamesByAlias.clear();
         this.extensionMethods.clear();
         this.tsbindgenExports.clear();
         this.tsSupertypes.clear();
+        this.tsBaseTypes.clear();
         this.clrTypeNames.clear();
     }
-    resolveLookupAlias(typeAlias) {
-        return this.typeLookupAliasMap.get(typeAlias) ?? typeAlias;
-    }
-    resolveSimpleBindingAlias(typeAlias) {
-        const descriptor = this.simpleBindings.get(typeAlias) ??
-            this.simpleBindingsLowercase.get(typeAlias.toLowerCase());
-        if (!descriptor)
-            return undefined;
-        const mapped = tsbindgenClrTypeNameToTsTypeName(descriptor.type);
-        if (!mapped || mapped === typeAlias)
-            return undefined;
-        return mapped;
-    }
 }
-const makeClrMemberKey = (assembly, clrType, clrMember) => `${assembly}:${clrType}::${clrMember}`;
-/**
- * Extract CLR namespace key ('.' → '_') from a full CLR type name.
- * Example: "System.Linq.Enumerable" → "System_Linq"
- */
-const extractNamespaceKey = (clrType) => {
-    const lastDot = clrType.lastIndexOf(".");
-    if (lastDot <= 0)
-        return undefined;
-    return clrType.slice(0, lastDot).replace(/\./g, "_");
-};
-/**
- * Extract the extension receiver TS type name from a tsbindgen normalized signature.
- *
- * Format: "Name|(ParamTypes):ReturnType|static=true"
- * Example: "Where|(IEnumerable_1,Func_2):IEnumerable_1|static=true"
- *
- * Returns the first parameter type name (stripped of byref suffix and namespace prefix).
- */
-const extractExtensionReceiverType = (normalizedSignature) => {
-    const paramsMatch = normalizedSignature.match(/\|\(([^)]*)\):/);
-    const paramsStr = paramsMatch?.[1]?.trim();
-    if (!paramsStr)
-        return undefined;
-    const [first] = splitSignatureTypeList(paramsStr);
-    if (!first)
-        return undefined;
-    let receiver = first.trim();
-    if (receiver.endsWith("&"))
-        receiver = receiver.slice(0, -1);
-    if (receiver.endsWith("[]"))
-        receiver = receiver.slice(0, -2);
-    const lastDot = receiver.lastIndexOf(".");
-    if (lastDot >= 0)
-        receiver = receiver.slice(lastDot + 1);
-    return receiver || undefined;
-};
-/**
- * Split a comma-delimited type list, respecting nested bracket depth.
- * tsbindgen signatures use CLR-style nested generic brackets in some contexts.
- */
-const splitSignatureTypeList = (str) => {
-    const result = [];
-    let depth = 0;
-    let current = "";
-    for (const char of str) {
-        if (char === "[") {
-            depth++;
-            current += char;
-        }
-        else if (char === "]") {
-            depth--;
-            current += char;
-        }
-        else if (char === "," && depth === 0) {
-            result.push(current.trim());
-            current = "";
-        }
-        else {
-            current += char;
-        }
-    }
-    if (current.trim()) {
-        result.push(current.trim());
-    }
-    return result;
-};
 //# sourceMappingURL=binding-registry.js.map