@tsonic/frontend 0.0.74 → 0.0.75

package/dist/ir/binding/binding-factory.js

@@ -1,13 +1,17 @@
 /**
- * Binding Layer — Factory Function
+ * Binding Layer — Factory Function (Facade)
  *
- * Contains the createBinding() factory which creates a BindingInternal instance.
- * The factory uses a closure pattern with internal registries mapping handles
- * to underlying TypeScript objects.
+ * Creates a BindingInternal instance by composing sub-modules:
+ * - binding-registry.ts: Registry management and simple resolution
+ * - binding-call-resolution.ts: Call/constructor signature resolution
+ *
+ * This module assembles the final BindingInternal object, the handle registry,
+ * and the remaining simple accessor/capture methods.
  */
 import ts from "typescript";
-import { makeDeclId, makeSignatureId, makeMemberId, makeTypeSyntaxId, } from "../type-system/types.js";
-import { getTypeNodeFromDeclaration, getMemberTypeAnnotation, getDeclKind, getReturnTypeNode, extractThisParameterTypeNode, extractParameterNodes, extractTypeParameterNodes, extractTypePredicate, extractDeclaringIdentity, extractClassMemberNames, isOptionalMember, isReadonlyMember, convertTypeParameterDeclarations, } from "./binding-helpers.js";
+import { makeTypeSyntaxId, } from "../type-system/types.js";
+import { createBindingContext, getOrCreateDeclId, resolveTransparentAliases, resolveIdentifier as resolveIdentifierImpl, resolveTypeReference as resolveTypeReferenceImpl, resolvePropertyAccess as resolvePropertyAccessImpl, resolveElementAccess as resolveElementAccessImpl, getBindingAliasFromDeclaration, } from "./binding-registry.js";
+import { resolveCallSignature as resolveCallSignatureImpl, resolveCallSignatureCandidates as resolveCallSignatureCandidatesImpl, resolveConstructorSignature as resolveConstructorSignatureImpl, resolveConstructorSignatureCandidates as resolveConstructorSignatureCandidatesImpl, } from "./binding-call-resolution.js";
 // ═══════════════════════════════════════════════════════════════════════════
 // BINDING IMPLEMENTATION
 // ═══════════════════════════════════════════════════════════════════════════
@@ -18,821 +22,25 @@ import { getTypeNodeFromDeclaration, getMemberTypeAnnotation, getDeclKind, getRe
  * Cast to Binding when passing to regular converters.
  */
 export const createBinding = (checker) => {
-    // Internal registries mapping handles to underlying TS objects
-    const declMap = new Map();
-    const signatureMap = new Map();
-    const memberMap = new Map(); // key: "declId:name"
-    const typeSyntaxMap = new Map(); // TypeSyntaxId → TypeNode
-    // Auto-increment IDs
-    const nextDeclId = { value: 0 };
-    const nextSignatureId = { value: 0 };
-    const nextTypeSyntaxId = { value: 0 };
-    // Symbol to DeclId cache (avoid duplicate DeclIds for same symbol)
-    const symbolToDeclId = new Map();
-    const signatureToId = new Map();
-    // ─────────────────────────────────────────────────────────────────────────
-    // INTERNAL HELPERS
-    // ─────────────────────────────────────────────────────────────────────────
-    const isSyntheticBindingMarkerName = (name) => name.startsWith("__tsonic_type_") ||
-        name.startsWith("__tsonic_binding_alias_");
-    const getStaticPropertyName = (name) => {
-        if (ts.isIdentifier(name) || ts.isStringLiteral(name))
-            return name.text;
-        return undefined;
-    };
-    const getBindingAliasFromDeclaration = (decl) => {
-        const members = ts.isTypeAliasDeclaration(decl)
-            ? ts.isTypeLiteralNode(decl.type)
-                ? decl.type.members
-                : undefined
-            : decl.members;
-        if (!members)
-            return undefined;
-        for (const member of members) {
-            if (!ts.isPropertySignature(member) &&
-                !ts.isPropertyDeclaration(member) &&
-                !ts.isGetAccessorDeclaration(member) &&
-                !ts.isSetAccessorDeclaration(member)) {
-                continue;
-            }
-            if (!member.name)
-                continue;
-            const name = getStaticPropertyName(member.name);
-            if (!name || !name.startsWith("__tsonic_binding_alias_"))
-                continue;
-            return name.slice("__tsonic_binding_alias_".length) || undefined;
-        }
-        return undefined;
-    };
-    const getOrCreateDeclId = (symbol) => {
-        const existing = symbolToDeclId.get(symbol);
-        if (existing)
-            return existing;
-        const id = makeDeclId(nextDeclId.value++);
-        symbolToDeclId.set(symbol, id);
-        // Get declaration info.
-        //
-        // IMPORTANT:
-        // Some symbols (notably tsbindgen facades) intentionally merge a value export
-        // and a type export under the same name, e.g.:
-        //   export const Task: typeof Internal.Task;
-        //   export type Task<T1 = __> = ... Internal.Task_1<T1> ...
-        //
-        // For expression identifiers we want the value declaration, while for type
-        // references we must be able to access the type declaration. We capture both.
-        const decls = symbol.getDeclarations() ?? [];
-        const valueDecl = decls.find((d) => ts.isVariableDeclaration(d) ||
-            ts.isFunctionDeclaration(d) ||
-            ts.isParameter(d) ||
-            ts.isPropertyDeclaration(d) ||
-            ts.isPropertySignature(d) ||
-            ts.isMethodDeclaration(d) ||
-            ts.isMethodSignature(d));
-        const typeDecl = decls.find((d) => ts.isTypeAliasDeclaration(d) ||
-            ts.isInterfaceDeclaration(d) ||
-            ts.isClassDeclaration(d) ||
-            ts.isEnumDeclaration(d) ||
-            ts.isTypeParameterDeclaration(d));
-        const decl = valueDecl ?? typeDecl ?? decls[0];
-        // Capture class member names for override detection (TS-version safe)
-        const classMemberNames = decl && ts.isClassDeclaration(decl)
-            ? extractClassMemberNames(decl)
-            : undefined;
-        const entry = {
-            symbol,
-            decl,
-            typeDeclNode: typeDecl,
-            valueDeclNode: valueDecl,
-            typeNode: decl ? getTypeNodeFromDeclaration(decl) : undefined,
-            kind: decl ? getDeclKind(decl) : "variable",
-            fqName: typeDecl &&
-                (ts.isTypeAliasDeclaration(typeDecl) ||
-                    ts.isInterfaceDeclaration(typeDecl) ||
-                    ts.isClassDeclaration(typeDecl))
-                ? (getBindingAliasFromDeclaration(typeDecl) ?? symbol.getName())
-                : symbol.getName(),
-            classMemberNames,
-        };
-        declMap.set(id.id, entry);
-        return id;
-    };
-    const getOrCreateSignatureId = (signature) => {
-        const existing = signatureToId.get(signature);
-        if (existing)
-            return existing;
-        const id = makeSignatureId(nextSignatureId.value++);
-        signatureToId.set(signature, id);
-        // Extract signature info from declaration
-        const decl = signature.getDeclaration();
-        // Extract declaring identity (CRITICAL for Alice's spec: resolveCall needs this)
-        const declaringIdentity = extractDeclaringIdentity(decl);
-        const declaringTypeParameterNames = (() => {
-            if (!decl)
-                return undefined;
-            const parent = decl.parent;
-            if ((ts.isInterfaceDeclaration(parent) || ts.isClassDeclaration(parent)) &&
-                parent.typeParameters &&
-                parent.typeParameters.length > 0) {
-                return parent.typeParameters.map((tp) => tp.name.text);
-            }
-            return undefined;
-        })();
-        // Extract type predicate from return type (ALICE'S SPEC: pure syntax inspection)
-        const returnTypeNode = getReturnTypeNode(decl);
-        const typePredicate = extractTypePredicate(returnTypeNode, decl);
-        const entry = {
-            signature,
-            decl,
-            parameters: extractParameterNodes(decl),
-            thisTypeNode: extractThisParameterTypeNode(decl),
-            returnTypeNode,
-            typeParameters: extractTypeParameterNodes(decl),
-            declaringTypeTsName: declaringIdentity?.typeTsName,
-            declaringTypeParameterNames,
-            declaringMemberName: declaringIdentity?.memberName,
-            typePredicate,
-        };
-        signatureMap.set(id.id, entry);
-        return id;
-    };
-    const getOrCreateMemberId = (ownerDeclId, memberName, memberSymbol) => {
-        const key = `${ownerDeclId.id}:${memberName}`;
-        const existing = memberMap.get(key);
-        if (existing)
-            return existing.memberId;
-        const id = makeMemberId(ownerDeclId, memberName);
-        const decl = memberSymbol.getDeclarations()?.[0];
-        const entry = {
-            memberId: id,
-            symbol: memberSymbol,
-            decl,
-            name: memberName,
-            typeNode: decl ? getMemberTypeAnnotation(decl) : undefined,
-            isOptional: isOptionalMember(memberSymbol),
-            isReadonly: isReadonlyMember(decl),
-        };
-        memberMap.set(key, entry);
-        return id;
-    };
+    const ctx = createBindingContext(checker);
     // ─────────────────────────────────────────────────────────────────────────
-    // BINDING IMPLEMENTATION
+    // SIMPLE RESOLUTION METHODS (remaining methods not in sub-modules)
     // ─────────────────────────────────────────────────────────────────────────
-    const resolveIdentifier = (node) => {
-        const symbol = checker.getSymbolAtLocation(node);
-        if (!symbol)
-            return undefined;
-        // Follow aliases for imports
-        const resolvedSymbol = symbol.flags & ts.SymbolFlags.Alias
-            ? checker.getAliasedSymbol(symbol)
-            : symbol;
-        return getOrCreateDeclId(resolvedSymbol);
-    };
-    const resolveTypeReference = (node) => {
-        const resolveEntityNameSymbol = (typeName) => {
-            const symbol = ts.isIdentifier(typeName)
-                ? checker.getSymbolAtLocation(typeName)
-                : checker.getSymbolAtLocation(typeName.right);
-            if (!symbol)
-                return undefined;
-            return symbol.flags & ts.SymbolFlags.Alias
-                ? checker.getAliasedSymbol(symbol)
-                : symbol;
-        };
-        let symbol = resolveEntityNameSymbol(node.typeName);
-        if (!symbol)
-            return undefined;
-        // Follow type aliases that are pure renames to another type reference:
-        //   type Foo<T> = Bar<T>
-        //
-        // This is required for tsbindgen facades, where ergonomic types are often
-        // exported as aliases to arity-qualified internal CLR types.
-        //
-        // DETERMINISTIC: AST inspection only (no ts.Type queries).
-        const seen = new Set();
-        while (!seen.has(symbol)) {
-            seen.add(symbol);
-            const decls = symbol.getDeclarations() ?? [];
-            const typeAliasDecl = decls.find(ts.isTypeAliasDeclaration);
-            if (!typeAliasDecl)
-                break;
-            const aliasedType = typeAliasDecl.type;
-            if (!ts.isTypeReferenceNode(aliasedType))
-                break;
-            // Only follow aliases that forward type parameters 1:1.
-            //
-            // SAFE EXAMPLES:
-            //   type Foo<T> = Bar<T>
-            //   type Foo<T1, T2> = Bar<T1, T2>
-            //   type Foo = Bar
-            //
-            // UNSAFE (requires substitution / rewrapping, so we must NOT follow):
-            //   type Foo<T> = Bar<Baz<T>>
-            //   type Foo<T, U> = Bar<U, T>              // reorders args
-            //   type Foo = Bar<string>                  // applies args
-            const aliasTypeParams = typeAliasDecl.typeParameters ?? [];
-            const rhsArgs = aliasedType.typeArguments ?? [];
-            if (aliasTypeParams.length === 0) {
-                if (rhsArgs.length > 0)
-                    break;
-            }
-            else {
-                if (rhsArgs.length !== aliasTypeParams.length)
-                    break;
-                let forwardsIdentity = true;
-                for (let i = 0; i < aliasTypeParams.length; i++) {
-                    const p = aliasTypeParams[i];
-                    const a = rhsArgs[i];
-                    if (!p || !a) {
-                        forwardsIdentity = false;
-                        break;
-                    }
-                    if (!ts.isTypeReferenceNode(a) || !ts.isIdentifier(a.typeName)) {
-                        forwardsIdentity = false;
-                        break;
-                    }
-                    if (a.typeArguments && a.typeArguments.length > 0) {
-                        forwardsIdentity = false;
-                        break;
-                    }
-                    if (a.typeName.text !== p.name.text) {
-                        forwardsIdentity = false;
-                        break;
-                    }
-                }
-                if (!forwardsIdentity)
-                    break;
-            }
-            const next = resolveEntityNameSymbol(aliasedType.typeName);
-            if (!next)
-                break;
-            symbol = next;
-        }
-        return getOrCreateDeclId(symbol);
-    };
-    const resolvePropertyAccess = (node) => {
-        const rawPropSymbol = checker.getSymbolAtLocation(node.name);
-        if (!rawPropSymbol)
-            return undefined;
-        const propSymbol = rawPropSymbol.flags & ts.SymbolFlags.Alias
-            ? checker.getAliasedSymbol(rawPropSymbol)
-            : rawPropSymbol;
-        // Get owner type's declaration
-        const rawOwnerSymbol = checker.getSymbolAtLocation(node.expression);
-        // Note: `getSymbolAtLocation(node.expression)` can be undefined for receivers
-        // that are not identifiers/member-accesses (e.g., `xs.where(...).select`).
-        // In that case we still want a stable MemberId for the member symbol itself,
-        // so we key the member entry off the member symbol's own DeclId.
-        const ownerSymbol = rawOwnerSymbol
-            ? rawOwnerSymbol.flags & ts.SymbolFlags.Alias
-                ? checker.getAliasedSymbol(rawOwnerSymbol)
-                : rawOwnerSymbol
-            : undefined;
-        const ownerDeclId = getOrCreateDeclId(ownerSymbol ?? propSymbol);
-        return getOrCreateMemberId(ownerDeclId, node.name.text, propSymbol);
-    };
-    const resolveElementAccess = (_node) => {
-        // Element access member resolution requires type-level analysis
-        // Return undefined (member not resolved via handles)
-        return undefined;
-    };
-    const resolveCallSignature = (node) => {
-        const signature = checker.getResolvedSignature(node);
-        if (!signature)
-            return undefined;
-        // TypeScript can produce a resolved signature without a declaration for
-        // implicit default constructors (e.g., `super()` when the base class has
-        // no explicit constructor). We still want a SignatureId so TypeSystem can
-        // treat this call deterministically as `void`.
-        if (signature.declaration === undefined) {
-            // Special case: `super()` implicit base constructor
-            if (node.expression.kind === ts.SyntaxKind.SuperKeyword) {
-                return getOrCreateSignatureId(signature);
-            }
-            // Recovery: calls through variables/properties typed as functions can
-            // yield signatures without declarations. Attempt to re-anchor to a
-            // function-like declaration we can capture syntactically.
-            const symbol = (() => {
-                const expr = node.expression;
-                if (ts.isIdentifier(expr))
-                    return checker.getSymbolAtLocation(expr);
-                if (ts.isPropertyAccessExpression(expr)) {
-                    return checker.getSymbolAtLocation(expr.name);
-                }
-                return undefined;
-            })();
-            const resolvedSymbol = symbol && symbol.flags & ts.SymbolFlags.Alias
-                ? checker.getAliasedSymbol(symbol)
-                : symbol;
-            const decls = resolvedSymbol?.getDeclarations() ?? [];
-            for (const decl of decls) {
-                // Direct function-like declarations (function/method/signature)
-                if (ts.isFunctionLike(decl)) {
-                    const sig = checker.getSignatureFromDeclaration(decl);
-                    if (sig)
-                        return getOrCreateSignatureId(sig);
-                    continue;
-                }
-                // Variable initializers: const f = (x) => ...
-                if (ts.isVariableDeclaration(decl)) {
-                    const init = decl.initializer;
-                    if (init &&
-                        (ts.isArrowFunction(init) || ts.isFunctionExpression(init))) {
-                        const sig = checker.getSignatureFromDeclaration(init);
-                        if (sig)
-                            return getOrCreateSignatureId(sig);
-                    }
-                }
-            }
-            return undefined;
-        }
-        const resolvedId = getOrCreateSignatureId(signature);
-        // Airplane-grade overload selection for erased TS types:
-        // In TypeScript, `char` is `string`, so overload sets that differ only by
-        // `char` vs `string` can be resolved "wrong" due to declaration order
-        // (e.g., string.split("/") picking the `char` overload).
-        //
-        // We apply a deterministic, syntax-driven tie-breaker:
-        // - Prefer `string` parameters for non-charish arguments (string literals, etc.)
-        // - Prefer `char` parameters only when the argument is explicitly marked char
-        //   (e.g., `expr as char`, or identifier declared `: char`).
-        const candidates = resolveCallSignatureCandidates(node);
-        if (!candidates || candidates.length < 2)
-            return resolvedId;
-        const stripParens = (expr) => {
-            let current = expr;
-            while (ts.isParenthesizedExpression(current)) {
-                current = current.expression;
-            }
-            return current;
-        };
-        const isCharTypeNode = (typeNode) => {
-            if (ts.isTypeReferenceNode(typeNode)) {
-                const tn = typeNode.typeName;
-                if (ts.isIdentifier(tn))
-                    return tn.text === "char";
-                return tn.right.text === "char";
-            }
-            return false;
-        };
-        const isCharishArgument = (arg) => {
-            const expr = stripParens(arg);
-            // Explicit `as char` / `<char>` assertions.
-            if (ts.isAsExpression(expr) || ts.isTypeAssertionExpression(expr)) {
-                return isCharTypeNode(expr.type);
-            }
-            // Identifier declared with `: char`.
-            if (ts.isIdentifier(expr)) {
-                const sym = checker.getSymbolAtLocation(expr);
-                if (!sym)
-                    return false;
-                const resolvedSym = sym.flags & ts.SymbolFlags.Alias
-                    ? checker.getAliasedSymbol(sym)
-                    : sym;
-                const decls = resolvedSym.getDeclarations() ?? [];
-                for (const decl of decls) {
-                    const typeNode = getTypeNodeFromDeclaration(decl);
-                    if (typeNode && isCharTypeNode(typeNode))
-                        return true;
-                }
-            }
-            return false;
-        };
-        const stringType = checker.getStringType();
-        const prefersStringOverChar = (arg) => {
-            const expr = stripParens(arg);
-            if (isCharishArgument(expr))
-                return false;
-            // In TS, `char` is erased to `string`, so we must prefer `string` overloads
-            // for *any* string-typed argument unless the user explicitly marks it as char.
-            //
-            // This keeps common code like `Console.WriteLine(condition ? "OK" : "BAD")`
-            // from accidentally binding to `WriteLine(char)` (due to declaration order).
-            const t = checker.getTypeAtLocation(expr);
-            return checker.isTypeAssignableTo(t, stringType);
-        };
-        const getStaticPropertyName = (name) => {
-            if (ts.isIdentifier(name))
-                return name.text;
-            if (ts.isStringLiteral(name) ||
-                ts.isNumericLiteral(name) ||
-                ts.isNoSubstitutionTemplateLiteral(name)) {
-                return name.text;
-            }
-            if (ts.isComputedPropertyName(name)) {
-                const expr = stripParens(name.expression);
-                if (ts.isStringLiteral(expr) ||
-                    ts.isNumericLiteral(expr) ||
-                    ts.isNoSubstitutionTemplateLiteral(expr)) {
-                    return expr.text;
-                }
-            }
-            return undefined;
-        };
-        const getObjectLiteralKeys = (arg) => {
-            const expr = stripParens(arg);
-            if (!ts.isObjectLiteralExpression(expr))
-                return undefined;
-            const keys = [];
-            for (const property of expr.properties) {
-                if (ts.isSpreadAssignment(property))
-                    return undefined;
-                if (ts.isShorthandPropertyAssignment(property)) {
-                    keys.push(property.name.text);
-                    continue;
-                }
-                if (ts.isPropertyAssignment(property) ||
-                    ts.isMethodDeclaration(property) ||
-                    ts.isGetAccessorDeclaration(property) ||
-                    ts.isSetAccessorDeclaration(property)) {
-                    const key = getStaticPropertyName(property.name);
-                    if (!key)
-                        return undefined;
-                    keys.push(key);
-                    continue;
-                }
-                return undefined;
-            }
-            return keys;
-        };
-        const isUnknownTypeNode = (typeNode) => !!typeNode && typeNode.kind === ts.SyntaxKind.UnknownKeyword;
-        const isObviouslyNonObjectTypeNode = (typeNode) => {
-            if (!typeNode)
-                return false;
-            const node = ts.isParenthesizedTypeNode(typeNode)
-                ? typeNode.type
-                : typeNode;
-            return (node.kind === ts.SyntaxKind.StringKeyword ||
-                node.kind === ts.SyntaxKind.NumberKeyword ||
-                node.kind === ts.SyntaxKind.BooleanKeyword ||
-                node.kind === ts.SyntaxKind.BigIntKeyword ||
-                node.kind === ts.SyntaxKind.VoidKeyword ||
-                node.kind === ts.SyntaxKind.NullKeyword ||
-                node.kind === ts.SyntaxKind.UndefinedKeyword ||
-                node.kind === ts.SyntaxKind.UnknownKeyword ||
-                node.kind === ts.SyntaxKind.AnyKeyword);
-        };
-        const mergePropertySets = (left, right) => new Set([...left, ...right]);
-        const collectDeclaredPropertyNames = (typeNode, seenSymbols = new Set(), seenNodes = new Set()) => {
-            if (!typeNode)
-                return undefined;
-            if (seenNodes.has(typeNode))
-                return undefined;
-            seenNodes.add(typeNode);
-            const node = ts.isParenthesizedTypeNode(typeNode)
-                ? typeNode.type
-                : typeNode;
-            if (ts.isTypeLiteralNode(node)) {
-                const names = new Set();
-                for (const member of node.members) {
-                    if (ts.isPropertySignature(member) ||
-                        ts.isMethodSignature(member) ||
-                        ts.isGetAccessorDeclaration(member) ||
-                        ts.isSetAccessorDeclaration(member)) {
-                        if (!member.name)
-                            continue;
-                        const name = getStaticPropertyName(member.name);
-                        if (!name || isSyntheticBindingMarkerName(name))
-                            continue;
-                        names.add(name);
-                    }
-                }
-                return names;
-            }
-            if (ts.isIntersectionTypeNode(node)) {
-                let merged;
-                for (const part of node.types) {
-                    const partNames = collectDeclaredPropertyNames(part, seenSymbols, seenNodes);
-                    if (!partNames)
-                        continue;
-                    merged = merged ? mergePropertySets(merged, partNames) : partNames;
-                }
-                return merged;
-            }
-            if (!ts.isTypeReferenceNode(node)) {
-                return undefined;
-            }
-            const rawSymbol = ts.isIdentifier(node.typeName)
-                ? checker.getSymbolAtLocation(node.typeName)
-                : checker.getSymbolAtLocation(node.typeName.right);
-            if (!rawSymbol)
-                return undefined;
-            const symbol = rawSymbol.flags & ts.SymbolFlags.Alias
-                ? checker.getAliasedSymbol(rawSymbol)
-                : rawSymbol;
-            if (seenSymbols.has(symbol))
-                return undefined;
-            seenSymbols.add(symbol);
-            let merged;
-            for (const decl of symbol.getDeclarations() ?? []) {
-                if (ts.isTypeAliasDeclaration(decl)) {
-                    const aliasNames = collectDeclaredPropertyNames(decl.type, seenSymbols, seenNodes);
-                    if (aliasNames) {
-                        merged = merged
-                            ? mergePropertySets(merged, aliasNames)
-                            : aliasNames;
-                    }
-                    continue;
-                }
-                if (!ts.isInterfaceDeclaration(decl) && !ts.isClassDeclaration(decl)) {
-                    continue;
-                }
-                let names = new Set();
-                for (const member of decl.members) {
-                    if (ts.isPropertySignature(member) ||
-                        ts.isMethodSignature(member) ||
-                        ts.isPropertyDeclaration(member) ||
-                        ts.isMethodDeclaration(member) ||
-                        ts.isGetAccessorDeclaration(member) ||
-                        ts.isSetAccessorDeclaration(member)) {
-                        if (!member.name)
-                            continue;
-                        const name = getStaticPropertyName(member.name);
-                        if (!name || isSyntheticBindingMarkerName(name))
-                            continue;
-                        names.add(name);
-                    }
-                }
-                for (const heritage of decl.heritageClauses ?? []) {
-                    for (const heritageType of heritage.types) {
-                        const heritageNames = collectDeclaredPropertyNames(heritageType, seenSymbols, seenNodes);
-                        if (heritageNames) {
-                            names = new Set([...names, ...heritageNames]);
-                        }
-                    }
-                }
-                merged = merged ? mergePropertySets(merged, names) : names;
-            }
-            return merged;
-        };
-        const classifyParamTypeNode = (typeNode) => {
-            if (!typeNode)
-                return "other";
-            const node = typeNode;
-            if (node.kind === ts.SyntaxKind.StringKeyword)
-                return "string";
-            if (isCharTypeNode(node))
-                return "char";
-            if (ts.isArrayTypeNode(node)) {
-                return isCharTypeNode(node.elementType) ? "char" : "other";
-            }
-            return "other";
-        };
-        const paramClassForArgIndex = (entry, argIndex) => {
-            const params = entry.parameters;
-            const direct = params[argIndex];
-            if (direct)
-                return classifyParamTypeNode(direct.typeNode);
-            // Rest parameter: map extra args to last param if it is rest.
-            const last = params[params.length - 1];
-            if (last && last.isRest)
-                return classifyParamTypeNode(last.typeNode);
-            return "other";
-        };
-        const args = node.arguments;
-        const wantsStringAt = [];
-        const wantsCharAt = [];
-        const objectLiteralArgs = new Map();
-        for (let i = 0; i < args.length; i++) {
-            const arg = args[i];
-            if (!arg)
-                continue;
-            if (ts.isSpreadElement(arg))
-                continue;
-            if (isCharishArgument(arg)) {
-                wantsCharAt.push(i);
-            }
-            else if (prefersStringOverChar(arg)) {
-                wantsStringAt.push(i);
-            }
-            const objectKeys = getObjectLiteralKeys(arg);
-            if (objectKeys && objectKeys.length > 0) {
-                objectLiteralArgs.set(i, objectKeys);
-            }
-        }
-        if (wantsStringAt.length === 0 &&
-            wantsCharAt.length === 0 &&
-            objectLiteralArgs.size === 0) {
-            return resolvedId;
-        }
-        const objectLiteralScoreForArg = (entry, argIndex, keys) => {
-            const direct = entry.parameters[argIndex];
-            const last = entry.parameters[entry.parameters.length - 1];
-            const param = direct ?? (last?.isRest ? last : undefined);
-            if (!param?.typeNode)
-                return -4;
-            const typeNode = param.typeNode;
-            if (isUnknownTypeNode(typeNode))
-                return -10;
-            if (isObviouslyNonObjectTypeNode(typeNode))
-                return -6;
-            const propertyNames = collectDeclaredPropertyNames(typeNode);
-            if (!propertyNames || propertyNames.size === 0) {
-                return 0;
-            }
-            for (const key of keys) {
-                if (!propertyNames.has(key)) {
-                    return -6;
-                }
-            }
-            const extraPropertyCount = Math.max(0, propertyNames.size - keys.length);
-            return 10 - Math.min(extraPropertyCount, 5);
-        };
-        const scoreSignature = (sigId) => {
-            const entry = signatureMap.get(sigId.id);
-            if (!entry)
-                return 0;
-            let score = 0;
-            for (const i of wantsStringAt) {
-                const pc = paramClassForArgIndex(entry, i);
-                if (pc === "string")
-                    score += 2;
-                if (pc === "char")
-                    score -= 2;
-            }
-            for (const i of wantsCharAt) {
-                const pc = paramClassForArgIndex(entry, i);
-                if (pc === "char")
-                    score += 2;
-                if (pc === "string")
-                    score -= 2;
-            }
-            for (const [argIndex, keys] of objectLiteralArgs) {
-                score += objectLiteralScoreForArg(entry, argIndex, keys);
-            }
-            return score;
-        };
-        const resolvedScore = scoreSignature(resolvedId);
-        let bestId = resolvedId;
-        let bestScore = resolvedScore;
-        for (const candidate of candidates) {
-            const s = scoreSignature(candidate);
-            if (s > bestScore) {
-                bestScore = s;
-                bestId = candidate;
-            }
-        }
-        return bestId;
-    };
-    const resolveCallSignatureCandidates = (node) => {
-        const collectSignatureCandidates = (signatures) => {
-            const argCount = node.arguments.length;
-            const candidates = [];
-            for (const sig of signatures) {
-                const decl = sig.getDeclaration();
-                if (decl && ts.isFunctionLike(decl)) {
-                    if (ts.isConstructSignatureDeclaration(decl) ||
-                        ts.isConstructorDeclaration(decl)) {
-                        continue;
-                    }
-                    const params = extractParameterNodes(decl);
-                    const required = params.filter((p) => !p.isOptional && !p.isRest).length;
-                    const hasRest = params.some((p) => p.isRest);
-                    if (argCount < required)
-                        continue;
-                    if (!hasRest && argCount > params.length)
-                        continue;
-                }
-                candidates.push(getOrCreateSignatureId(sig));
-            }
-            return candidates.length > 0 ? candidates : undefined;
-        };
-        const expr = node.expression;
-        const symbol = (() => {
-            if (ts.isIdentifier(expr))
-                return checker.getSymbolAtLocation(expr);
-            if (ts.isPropertyAccessExpression(expr)) {
-                return checker.getSymbolAtLocation(expr.name);
-            }
-            return undefined;
-        })();
-        if (!symbol)
-            return undefined;
-        const resolvedSymbol = symbol.flags & ts.SymbolFlags.Alias
-            ? checker.getAliasedSymbol(symbol)
-            : symbol;
-        const decls = resolvedSymbol.getDeclarations();
-        if (decls && decls.length > 0) {
-            const directSignatures = decls.flatMap((decl) => {
-                if (!ts.isFunctionLike(decl))
-                    return [];
-                const sig = checker.getSignatureFromDeclaration(decl);
-                return sig ? [sig] : [];
-            });
-            const directCandidates = collectSignatureCandidates(directSignatures);
-            if (directCandidates)
-                return directCandidates;
-        }
-        const expressionType = checker.getTypeAtLocation(expr);
-        return collectSignatureCandidates(expressionType.getCallSignatures());
-    };
-    const resolveConstructorSignature = (node) => {
-        const signature = checker.getResolvedSignature(node);
-        if (!signature)
-            return undefined;
-        const sigId = getOrCreateSignatureId(signature);
-        // For implicit default constructors, TypeScript may return a signature with no declaration.
-        // We still need a SignatureEntry that identifies the constructed type so TypeSystem can
-        // synthesize the constructor return type deterministically.
-        const entry = signatureMap.get(sigId.id);
-        if (entry && !entry.decl) {
-            const expr = node.expression;
-            const symbol = (() => {
-                if (ts.isIdentifier(expr))
-                    return checker.getSymbolAtLocation(expr);
-                if (ts.isPropertyAccessExpression(expr)) {
-                    return checker.getSymbolAtLocation(expr.name);
-                }
-                return undefined;
-            })();
-            const resolvedSymbol = symbol && symbol.flags & ts.SymbolFlags.Alias
-                ? checker.getAliasedSymbol(symbol)
-                : symbol;
-            const decl = resolvedSymbol?.getDeclarations()?.[0];
-            const declaringTypeTsName = (() => {
-                if (decl && ts.isClassDeclaration(decl) && decl.name)
-                    return decl.name.text;
-                if (resolvedSymbol)
-                    return resolvedSymbol.getName();
-                if (ts.isIdentifier(expr))
-                    return expr.text;
-                if (ts.isPropertyAccessExpression(expr))
-                    return expr.name.text;
-                return undefined;
-            })();
-            if (declaringTypeTsName) {
-                signatureMap.set(sigId.id, {
-                    ...entry,
-                    declaringTypeTsName,
-                    declaringMemberName: "constructor",
-                    typeParameters: decl && ts.isClassDeclaration(decl)
-                        ? convertTypeParameterDeclarations(decl.typeParameters)
-                        : undefined,
-                    declaringTypeParameterNames: decl && ts.isClassDeclaration(decl) && decl.typeParameters
-                        ? decl.typeParameters.map((tp) => tp.name.text)
-                        : undefined,
-                });
-            }
-        }
-        return sigId;
-    };
-    const resolveConstructorSignatureCandidates = (node) => {
-        const expr = node.expression;
-        const symbol = (() => {
-            if (ts.isIdentifier(expr))
-                return checker.getSymbolAtLocation(expr);
-            if (ts.isPropertyAccessExpression(expr)) {
-                return checker.getSymbolAtLocation(expr.name);
-            }
-            return undefined;
-        })();
-        if (!symbol)
-            return undefined;
-        const resolvedSymbol = symbol.flags & ts.SymbolFlags.Alias
-            ? checker.getAliasedSymbol(symbol)
-            : symbol;
-        const decls = resolvedSymbol.getDeclarations();
-        if (!decls || decls.length === 0)
-            return undefined;
-        const argCount = node.arguments?.length ?? 0;
-        const candidates = [];
-        for (const decl of decls) {
-            if (!ts.isFunctionLike(decl))
-                continue;
-            // Only include construct signatures / constructors for new expressions.
-            if (!ts.isConstructSignatureDeclaration(decl) &&
-                !ts.isConstructorDeclaration(decl)) {
-                continue;
-            }
-            const params = extractParameterNodes(decl);
-            const required = params.filter((p) => !p.isOptional && !p.isRest).length;
-            const hasRest = params.some((p) => p.isRest);
-            if (argCount < required)
-                continue;
-            if (!hasRest && argCount > params.length)
-                continue;
-            const sig = checker.getSignatureFromDeclaration(decl);
-            if (!sig)
-                continue;
-            candidates.push(getOrCreateSignatureId(sig));
-        }
-        return candidates.length > 0 ? candidates : undefined;
-    };
     const resolveImport = (node) => {
         const symbol = checker.getSymbolAtLocation(node.name);
         if (!symbol)
             return undefined;
-        const aliased = checker.getAliasedSymbol(symbol);
-        return getOrCreateDeclId(aliased);
+        return getOrCreateDeclId(ctx, resolveTransparentAliases(ctx, symbol));
     };
     const resolveShorthandAssignment = (node) => {
         const symbol = checker.getShorthandAssignmentValueSymbol(node);
         if (!symbol)
             return undefined;
-        return getOrCreateDeclId(symbol);
+        return getOrCreateDeclId(ctx, symbol);
     };
     const getDeclaringTypeNameOfMember = (member) => {
         const key = `${member.declId.id}:${member.name}`;
-        const entry = memberMap.get(key);
+        const entry = ctx.memberMap.get(key);
         const decl = entry?.decl;
         if (!decl)
             return undefined;
@@ -860,14 +68,14 @@ export const createBinding = (checker) => {
     };
     const getSourceFilePathOfMember = (member) => {
         const key = `${member.declId.id}:${member.name}`;
-        const entry = memberMap.get(key);
+        const entry = ctx.memberMap.get(key);
         const decl = entry?.decl;
         if (!decl)
             return undefined;
         return decl.getSourceFile().fileName;
     };
     const getSourceFilePathOfDecl = (declId) => {
-        const entry = declMap.get(declId.id);
+        const entry = ctx.declMap.get(declId.id);
         if (!entry)
             return undefined;
         const decl = entry.decl ?? entry.typeDeclNode ?? entry.valueDeclNode;
@@ -876,13 +84,13 @@ export const createBinding = (checker) => {
         return decl.getSourceFile().fileName;
     };
     const getFullyQualifiedName = (declId) => {
-        const entry = declMap.get(declId.id);
+        const entry = ctx.declMap.get(declId.id);
         if (!entry)
             return undefined;
         return checker.getFullyQualifiedName(entry.symbol);
     };
     const getTypePredicateOfSignature = (sigId) => {
-        const entry = signatureMap.get(sigId.id);
+        const entry = ctx.signatureMap.get(sigId.id);
         if (!entry)
             return undefined;
         const predicate = checker.getTypePredicateOfSignature(entry.signature);
@@ -892,17 +100,17 @@ export const createBinding = (checker) => {
         return {
             kind: "typePredicate",
             parameterIndex: predicate.parameterIndex ?? 0,
-            typeNode: predicate.type
-                ? checker.typeToTypeNode(predicate.type, undefined, ts.NodeBuilderFlags.None)
+            typeNode: entry.typePredicate?.kind === "param"
+                ? entry.typePredicate.targetTypeNode
                 : undefined,
         };
     };
     const getThisTypeNodeOfSignature = (sigId) => {
-        const entry = signatureMap.get(sigId.id);
+        const entry = ctx.signatureMap.get(sigId.id);
         return entry?.thisTypeNode;
     };
     const getDeclaringTypeNameOfSignature = (sigId) => {
-        const entry = signatureMap.get(sigId.id);
+        const entry = ctx.signatureMap.get(sigId.id);
         return entry?.declaringTypeTsName;
     };
     // ─────────────────────────────────────────────────────────────────────────
@@ -910,7 +118,7 @@ export const createBinding = (checker) => {
     // ─────────────────────────────────────────────────────────────────────────
     const handleRegistry = {
         getDecl: (id) => {
-            const entry = declMap.get(id.id);
+            const entry = ctx.declMap.get(id.id);
             if (!entry)
                 return undefined;
             return {
@@ -924,11 +132,12 @@ export const createBinding = (checker) => {
             };
         },
         getSignature: (id) => {
-            const entry = signatureMap.get(id.id);
+            const entry = ctx.signatureMap.get(id.id);
             if (!entry)
                 return undefined;
             return {
                 parameters: entry.parameters,
+                resolvedParameters: entry.resolvedParameters,
                 thisTypeNode: entry.thisTypeNode,
                 returnTypeNode: entry.returnTypeNode,
                 typeParameters: entry.typeParameters,
@@ -943,7 +152,7 @@ export const createBinding = (checker) => {
         },
         getMember: (id) => {
             const key = `${id.declId.id}:${id.name}`;
-            const entry = memberMap.get(key);
+            const entry = ctx.memberMap.get(key);
             if (!entry)
                 return undefined;
             return {
@@ -955,7 +164,7 @@ export const createBinding = (checker) => {
             };
         },
         getTypeSyntax: (id) => {
-            const entry = typeSyntaxMap.get(id.id);
+            const entry = ctx.typeSyntaxMap.get(id.id);
             if (!entry)
                 return undefined;
             return {
@@ -974,8 +183,14 @@ export const createBinding = (checker) => {
      * that cannot be captured at catalog-build time.
      */
     const captureTypeSyntax = (node) => {
-        const id = makeTypeSyntaxId(nextTypeSyntaxId.value++);
-        typeSyntaxMap.set(id.id, { typeNode: node });
+        const id = makeTypeSyntaxId(ctx.nextTypeSyntaxId.value++);
+        const referenceDeclId = ts.isTypeReferenceNode(node)
+            ? resolveTypeReferenceImpl(ctx, node)
+            : undefined;
+        ctx.typeSyntaxMap.set(id.id, {
+            typeNode: node,
+            ...(referenceDeclId ? { referenceDeclId } : {}),
+        });
         return id;
     };
     /**
@@ -987,14 +202,14 @@ export const createBinding = (checker) => {
         return nodes.map((node) => captureTypeSyntax(node));
     };
     return {
-        resolveIdentifier,
-        resolveTypeReference,
-        resolvePropertyAccess,
-        resolveElementAccess,
-        resolveCallSignature,
-        resolveCallSignatureCandidates,
-        resolveConstructorSignature,
-        resolveConstructorSignatureCandidates,
+        resolveIdentifier: (node) => resolveIdentifierImpl(ctx, node),
+        resolveTypeReference: (node) => resolveTypeReferenceImpl(ctx, node),
+        resolvePropertyAccess: (node) => resolvePropertyAccessImpl(ctx, node),
+        resolveElementAccess: (node) => resolveElementAccessImpl(node),
+        resolveCallSignature: (node) => resolveCallSignatureImpl(ctx, node),
+        resolveCallSignatureCandidates: (node) => resolveCallSignatureCandidatesImpl(ctx, node),
+        resolveConstructorSignature: (node) => resolveConstructorSignatureImpl(ctx, node),
+        resolveConstructorSignatureCandidates: (node) => resolveConstructorSignatureCandidatesImpl(ctx, node),
         resolveImport,
         resolveShorthandAssignment,
         getDeclaringTypeNameOfMember,