@tsonic/emitter 0.0.73 → 0.0.75

package/dist/core/semantic/type-resolution.js

@@ -1,788 +1,21 @@
 /**
- * Type resolution helpers for generic null/default handling
- *
- * Provides:
- * - containsTypeParameter: Check if type contains any type parameter
- * - substituteTypeArgs: Substitute type arguments into a type
- * - getPropertyType: Look up property type from contextual type
- * - stripNullish: Remove null/undefined from union types
- * - isDefinitelyValueType: Check if type is a C# value type
- */
-/**
- * Check if a type contains any type parameter.
- *
- * Uses IR kind "typeParameterType" only.
- *
- * @param type - The IR type to check
- * @returns true if the type contains a type parameter
- */
-export const containsTypeParameter = (type) => {
-    switch (type.kind) {
-        case "typeParameterType":
-            // New IR kind - always a type parameter
-            return true;
-        case "referenceType":
-            // Recurse into type arguments
-            if (type.typeArguments) {
-                return type.typeArguments.some((arg) => containsTypeParameter(arg));
-            }
-            return false;
-        case "arrayType":
-            return containsTypeParameter(type.elementType);
-        case "dictionaryType":
-            return (containsTypeParameter(type.keyType) ||
-                containsTypeParameter(type.valueType));
-        case "unionType":
-        case "intersectionType":
-            return type.types.some((t) => containsTypeParameter(t));
-        case "tupleType":
-            return type.elementTypes.some((t) => containsTypeParameter(t));
-        case "functionType":
-            if (containsTypeParameter(type.returnType)) {
-                return true;
-            }
-            return type.parameters.some((p) => p.type && containsTypeParameter(p.type));
-        case "objectType":
-            return type.members.some((m) => {
-                if (m.kind === "propertySignature") {
-                    return containsTypeParameter(m.type);
-                }
-                if (m.kind === "methodSignature") {
-                    if (m.returnType && containsTypeParameter(m.returnType)) {
-                        return true;
-                    }
-                    return m.parameters.some((p) => p.type && containsTypeParameter(p.type));
-                }
-                return false;
-            });
-        case "primitiveType":
-        case "literalType":
-        case "anyType":
-        case "unknownType":
-        case "voidType":
-        case "neverType":
-            return false;
-        default: {
-            // Exhaustive check - this will error if a new IR type kind is added
-            const exhaustive = type;
-            void exhaustive;
-            return false;
-        }
-    }
-};
-/**
- * Substitute type arguments into a type.
- *
- * @param type - The type to substitute into
- * @param typeParamNames - List of type parameter names (in order)
- * @param typeArgs - List of type arguments (in order, parallel to typeParamNames)
- * @returns The type with type parameters substituted
- */
-export const substituteTypeArgs = (type, typeParamNames, typeArgs) => {
-    // Build mapping from name to type
-    const mapping = new Map();
-    for (let i = 0; i < typeParamNames.length && i < typeArgs.length; i++) {
-        const name = typeParamNames[i];
-        const arg = typeArgs[i];
-        if (name !== undefined && arg !== undefined) {
-            mapping.set(name, arg);
-        }
-    }
-    return substituteType(type, mapping);
-};
-/**
- * Internal helper for type substitution
- */
-const substituteType = (type, mapping) => {
-    switch (type.kind) {
-        case "typeParameterType": {
-            const substitution = mapping.get(type.name);
-            return substitution ?? type;
-        }
-        case "referenceType": {
-            // Recurse into type arguments
-            if (type.typeArguments) {
-                return {
-                    ...type,
-                    typeArguments: type.typeArguments.map((arg) => substituteType(arg, mapping)),
-                };
-            }
-            return type;
-        }
-        case "arrayType":
-            return {
-                ...type,
-                elementType: substituteType(type.elementType, mapping),
-            };
-        case "dictionaryType":
-            return {
-                ...type,
-                keyType: substituteType(type.keyType, mapping),
-                valueType: substituteType(type.valueType, mapping),
-            };
-        case "unionType":
-            return {
-                ...type,
-                types: type.types.map((t) => substituteType(t, mapping)),
-            };
-        case "tupleType":
-            return {
-                ...type,
-                elementTypes: type.elementTypes.map((t) => substituteType(t, mapping)),
-            };
-        case "intersectionType":
-            return {
-                ...type,
-                types: type.types.map((t) => substituteType(t, mapping)),
-            };
-        case "functionType":
-            return {
-                ...type,
-                returnType: substituteType(type.returnType, mapping),
-                parameters: type.parameters.map((p) => p.type ? { ...p, type: substituteType(p.type, mapping) } : p),
-            };
-        case "objectType":
-            return {
-                ...type,
-                members: type.members.map((m) => {
-                    if (m.kind === "propertySignature") {
-                        return { ...m, type: substituteType(m.type, mapping) };
-                    }
-                    if (m.kind === "methodSignature") {
-                        return {
-                            ...m,
-                            returnType: m.returnType
-                                ? substituteType(m.returnType, mapping)
-                                : undefined,
-                            parameters: m.parameters.map((p) => p.type ? { ...p, type: substituteType(p.type, mapping) } : p),
-                        };
-                    }
-                    return m;
-                }),
-            };
-        case "primitiveType":
-        case "literalType":
-        case "anyType":
-        case "unknownType":
-        case "voidType":
-        case "neverType":
-            return type;
-        default: {
-            const exhaustive = type;
-            void exhaustive;
-            return type;
-        }
-    }
-};
-/**
- * Look up property type from a contextual type.
- *
- * This handles:
- * - Local types (class/interface/typeAlias) via localTypes map
- * - Type alias chasing (follows alias.type until reaching a concrete type)
- * - Interface extends resolution (searches base interfaces)
- * - Generic type argument substitution
- *
- * @param contextualType - The contextual type (e.g., Result<T>)
- * @param propertyName - The property name to look up
- * @param context - Emitter context with localTypes
- * @returns The property type after substitution, or undefined if not found
- */
-export const getPropertyType = (contextualType, propertyName, context) => {
-    if (!contextualType) {
-        return undefined;
-    }
-    return resolvePropertyType(contextualType, propertyName, context, []);
-};
-/**
- * Internal helper for property type resolution with cycle detection
- */
-export const resolveLocalTypeInfo = (ref, context) => {
-    const direct = resolveLocalTypeInfoWithoutBindings(ref, context);
-    if (direct) {
-        return direct;
-    }
-    const rebound = resolveBindingBackedReferenceType(ref, context);
-    if (!rebound) {
-        return undefined;
-    }
-    return resolveLocalTypeInfoWithoutBindings(rebound, context);
-};
-const resolveLocalTypeInfoWithoutBindings = (ref, context) => {
-    const lookupName = ref.name.includes(".")
-        ? (ref.name.split(".").pop() ?? ref.name)
-        : ref.name;
-    const localHit = context.localTypes?.get(lookupName);
-    if (localHit) {
-        return {
-            info: localHit,
-            namespace: context.moduleNamespace ?? context.options.rootNamespace,
-        };
-    }
-    const moduleMap = context.options.moduleMap;
-    if (!moduleMap)
-        return undefined;
-    const matches = [];
-    for (const m of moduleMap.values()) {
-        const info = m.localTypes?.get(lookupName);
-        if (!info)
-            continue;
-        matches.push({ namespace: m.namespace, info });
-    }
-    if (matches.length === 0)
-        return undefined;
-    if (matches.length === 1) {
-        const onlyMatch = matches[0];
-        if (!onlyMatch) {
-            return undefined;
-        }
-        return { info: onlyMatch.info, namespace: onlyMatch.namespace };
-    }
-    const fqn = ref.resolvedClrType ?? (ref.name.includes(".") ? ref.name : undefined);
-    if (fqn && fqn.includes(".")) {
-        const namespace = fqn.slice(0, fqn.lastIndexOf("."));
-        const scoped = matches.filter((m) => m.namespace === namespace);
-        if (scoped.length === 1) {
-            const scopedMatch = scoped[0];
-            if (!scopedMatch) {
-                return undefined;
-            }
-            return {
-                info: scopedMatch.info,
-                namespace: scopedMatch.namespace,
-            };
-        }
-    }
-    return undefined;
-};
-const getReferenceBindingLookupCandidates = (ref) => {
-    const candidates = new Set();
-    const add = (value) => {
-        if (value && value.length > 0) {
-            candidates.add(value);
-        }
-    };
-    add(ref.name);
-    add(ref.resolvedClrType);
-    add(ref.typeId?.tsName);
-    add(ref.typeId?.clrName);
-    for (const value of [...candidates]) {
-        if (!value.includes("."))
-            continue;
-        add(value.split(".").pop());
-    }
-    return [...candidates];
-};
-const getBindingScopedReference = (binding, ref) => ({
-    ...ref,
-    name: binding.alias,
-    resolvedClrType: binding.name,
-});
-const resolveBindingBackedReferenceType = (ref, context) => {
-    const registry = context.bindingsRegistry;
-    if (!registry || registry.size === 0) {
-        return undefined;
-    }
-    for (const candidate of getReferenceBindingLookupCandidates(ref)) {
-        const binding = registry.get(candidate);
-        if (!binding)
-            continue;
-        const scopedRef = getBindingScopedReference(binding, ref);
-        const localInfo = resolveLocalTypeInfoWithoutBindings(scopedRef, context);
-        if (localInfo) {
-            return scopedRef;
-        }
-    }
-    return undefined;
-};
-const resolveBindingBackedPropertyType = (ref, propertyName, context) => {
-    const registry = context.bindingsRegistry;
-    if (!registry || registry.size === 0) {
-        return undefined;
-    }
-    for (const candidate of getReferenceBindingLookupCandidates(ref)) {
-        const binding = registry.get(candidate);
-        if (!binding)
-            continue;
-        const member = binding.members.find((candidateMember) => candidateMember.kind === "property" &&
-            candidateMember.alias === propertyName);
-        if (!member?.semanticType)
-            continue;
-        return withOptionalUndefined(member.semanticType, member.semanticOptional === true);
-    }
-    return undefined;
-};
-const resolveBindingBackedPropertySignatures = (ref, context) => {
-    const registry = context.bindingsRegistry;
-    if (!registry || registry.size === 0) {
-        return undefined;
-    }
-    for (const candidate of getReferenceBindingLookupCandidates(ref)) {
-        const binding = registry.get(candidate);
-        if (!binding)
-            continue;
-        const properties = binding.members
-            .filter((candidateMember) => candidateMember.kind === "property" &&
-            candidateMember.semanticType !== undefined)
-            .map((member) => ({
-            kind: "propertySignature",
-            name: member.alias,
-            type: withOptionalUndefined(member.semanticType, member.semanticOptional === true),
-            isOptional: member.semanticOptional === true,
-            isReadonly: false,
-        }));
-        if (properties.length > 0) {
-            return properties;
-        }
-    }
-    return undefined;
-};
-/**
- * Internal helper for property type resolution with cycle detection
- */
-const resolvePropertyType = (type, propertyName, context, visitedTypes) => {
-    // Handle reference types (most common case)
-    if (type.kind === "referenceType") {
-        const typeInfoResult = resolveLocalTypeInfo(type, context);
-        if (!typeInfoResult) {
-            return resolveBindingBackedPropertyType(type, propertyName, context);
-        }
-        const typeInfo = typeInfoResult.info;
-        // Prevent cycles
-        const cycleKey = type.resolvedClrType ?? type.name;
-        if (visitedTypes.includes(cycleKey)) {
-            return undefined;
-        }
-        const newVisited = [...visitedTypes, cycleKey];
-        // Chase type alias
-        if (typeInfo.kind === "typeAlias") {
-            const substituted = type.typeArguments
-                ? substituteTypeArgs(typeInfo.type, typeInfo.typeParameters, type.typeArguments)
-                : typeInfo.type;
-            return resolvePropertyType(substituted, propertyName, context, newVisited);
-        }
-        // Look up property in interface
-        if (typeInfo.kind === "interface") {
-            // Search own members first
-            const prop = findPropertyInMembers(typeInfo.members, propertyName);
-            if (prop) {
-                return type.typeArguments
-                    ? substituteTypeArgs(prop, typeInfo.typeParameters, type.typeArguments)
-                    : prop;
-            }
-            // Search extended interfaces
-            for (const base of typeInfo.extends) {
-                const baseProp = resolvePropertyType(base, propertyName, context, newVisited);
-                if (baseProp) {
-                    return type.typeArguments
-                        ? substituteTypeArgs(baseProp, typeInfo.typeParameters, type.typeArguments)
-                        : baseProp;
-                }
-            }
-            return undefined;
-        }
-        // Look up property in class
-        if (typeInfo.kind === "class") {
-            const prop = findPropertyInClassMembers(typeInfo.members, propertyName);
-            if (prop) {
-                return type.typeArguments
-                    ? substituteTypeArgs(prop, typeInfo.typeParameters, type.typeArguments)
-                    : prop;
-            }
-            return undefined;
-        }
-        return undefined;
-    }
-    // Handle object types directly
-    if (type.kind === "objectType") {
-        return findPropertyInMembers(type.members, propertyName);
-    }
-    return undefined;
-};
-/**
- * Find property type in interface members
- */
-const findPropertyInMembers = (members, propertyName) => {
-    for (const member of members) {
-        if (member.kind === "propertySignature" && member.name === propertyName) {
-            return withOptionalUndefined(member.type, member.isOptional);
-        }
-    }
-    return undefined;
-};
-const withOptionalUndefined = (type, isOptional) => {
-    if (!isOptional)
-        return type;
-    if (type.kind === "unionType" &&
-        type.types.some((t) => t.kind === "primitiveType" && t.name === "undefined")) {
-        return type;
-    }
-    return {
-        kind: "unionType",
-        types: [type, { kind: "primitiveType", name: "undefined" }],
-    };
-};
-const stripGlobalPrefix = (name) => name.startsWith("global::") ? name.slice("global::".length) : name;
-const getTypeMemberIndexCandidates = (ref, context) => {
-    const index = context.options.typeMemberIndex;
-    if (!index)
-        return undefined;
-    if (ref.resolvedClrType) {
-        return [stripGlobalPrefix(ref.resolvedClrType)];
-    }
-    if (ref.name.includes(".")) {
-        return [ref.name];
-    }
-    const matches = [];
-    for (const fqn of index.keys()) {
-        if (fqn.endsWith(`.${ref.name}`) ||
-            fqn.endsWith(`.${ref.name}__Alias`)) {
-            matches.push(fqn);
-        }
-    }
-    if (matches.length <= 1) {
-        return matches;
-    }
-    const list = matches.sort().join(", ");
-    throw new Error(`ICE: Ambiguous type member index entry for '${ref.name}'. Candidates: ${list}`);
-};
-export const hasDeterministicPropertyMembership = (type, propertyName, context) => {
-    const resolved = resolveTypeAlias(stripNullish(type), context);
-    if (resolved.kind === "objectType") {
-        return resolved.members.some((member) => member.kind === "propertySignature" && member.name === propertyName);
-    }
-    if (resolved.kind !== "referenceType") {
-        return undefined;
-    }
-    if (resolved.structuralMembers?.length) {
-        return resolved.structuralMembers.some((member) => member.kind === "propertySignature" && member.name === propertyName);
-    }
-    if (getPropertyType(resolved, propertyName, context)) {
-        return true;
-    }
-    const knownProps = getAllPropertySignatures(resolved, context);
-    if (knownProps) {
-        return knownProps.some((member) => member.name === propertyName);
-    }
-    const localInfo = resolveLocalTypeInfo(resolved, context)?.info;
-    if (localInfo?.kind === "class") {
-        return localInfo.members.some((member) => (member.kind === "propertyDeclaration" ||
-            member.kind === "methodDeclaration") &&
-            member.name === propertyName);
-    }
-    const candidates = getTypeMemberIndexCandidates(resolved, context);
-    if (!candidates || candidates.length === 0) {
-        return undefined;
-    }
-    return candidates.some((fqn) => {
-        const perType = context.options.typeMemberIndex?.get(fqn);
-        return perType?.has(propertyName) ?? false;
-    });
-};
-/**
- * Get all property signatures for a type, including inherited interface members.
- *
- * Notes:
- * - Only supports referenceType → local interface lookup (synthetic union members are always interfaces).
- * - Derived members override base members by name.
- * - Cycle-safe via visitedTypes.
- */
-export const getAllPropertySignatures = (type, context) => {
-    // We only expect nominal reference types here (Result__0<T,E>, etc.)
-    if (type.kind !== "referenceType")
-        return undefined;
-    const typeInfoResult = resolveLocalTypeInfo(type, context);
-    if (!typeInfoResult) {
-        return resolveBindingBackedPropertySignatures(type, context);
-    }
-    const typeInfo = typeInfoResult.info;
-    if (!typeInfo || typeInfo.kind !== "interface")
-        return undefined;
-    // Collect into a map so derived overrides base by name deterministically
-    const propMap = new Map();
-    collectInterfaceProps(type, typeInfo, context, propMap, []);
-    return [...propMap.values()];
-};
-/**
- * Internal: collect interface props + props from extends (cycle-safe).
- *
- * Ordering is important:
- * - Add own members first (so they override bases).
- * - Then walk extends for missing names.
- */
-const collectInterfaceProps = (ref, typeInfo, context, out, visitedTypes) => {
-    // Prevent cycles
-    const cycleKey = ref.resolvedClrType ?? ref.name;
-    if (visitedTypes.includes(cycleKey))
-        return;
-    const nextVisited = [...visitedTypes, cycleKey];
-    // Add own properties first (derived overrides base)
-    for (const m of typeInfo.members) {
-        if (m.kind === "propertySignature") {
-            out.set(m.name, m);
-        }
-    }
-    // Walk base interfaces
-    for (const base of typeInfo.extends) {
-        if (base.kind !== "referenceType")
-            continue;
-        const baseInfoResult = resolveLocalTypeInfo(base, context);
-        const baseInfo = baseInfoResult?.info;
-        if (!baseInfo || baseInfo.kind !== "interface")
-            continue;
-        // Recurse. If derived already set the name, we keep the derived one.
-        const basePropMap = new Map();
-        collectInterfaceProps(base, baseInfo, context, basePropMap, nextVisited);
-        for (const [name, sig] of basePropMap.entries()) {
-            if (!out.has(name)) {
-                out.set(name, sig);
-            }
-        }
-    }
-};
-/**
- * Select the best union member type to instantiate for an object literal.
- *
- * Example:
- *   type Result<T,E> = Result__0<T,E> | Result__1<T,E>
- *   return { ok: true, value }  // keys: ["ok","value"]
- * → choose Result__0<T,E>
- *
- * Matching rules (conservative):
- * - Only considers union members that are referenceTypes to local interfaces or classes.
- * - Object literal keys must be a subset of the candidate's property names.
- * - All *required* (non-optional) candidate properties must be present in the literal.
- *
- * Scoring (pick "most specific" deterministically):
- * 1) Fewer extra properties (candidateProps - literalKeys)
- * 2) More required properties (prefer tighter required shape)
- * 3) Fewer total properties
- * 4) Lexicographic by type name (stable tie-break)
- */
-export const selectUnionMemberForObjectLiteral = (unionType, literalKeys, context) => {
-    // Normalize keys (defensive: dedupe)
-    const keySet = new Set(literalKeys.filter((k) => k.length > 0));
-    const keys = [...keySet];
-    const candidates = [];
-    for (const member of unionType.types) {
-        if (member.kind !== "referenceType")
-            continue;
-        // If a union member is itself an alias, chase once (rare, but safe)
-        const resolved = resolveTypeAlias(member, context);
-        const ref = resolved.kind === "referenceType" ? resolved : member;
-        const infoResult = resolveLocalTypeInfo(ref, context);
-        const info = infoResult?.info;
-        if (!info)
-            continue;
-        // Interface members: use property signatures (includes inherited interfaces).
-        if (info.kind === "interface") {
-            const props = getAllPropertySignatures(ref, context);
-            if (!props)
-                continue;
-            const allProps = new Set(props.map((p) => p.name));
-            const requiredProps = new Set(props.filter((p) => !p.isOptional).map((p) => p.name));
-            candidates.push({ ref, allProps, requiredProps });
-            continue;
-        }
-        // Class members: use property declarations.
-        // Anonymous object literal synthesis (TSN7403) emits DTO-like classes with `required` properties,
-        // so unions over synthesized shapes must be matched here (not only interfaces).
-        if (info.kind === "class") {
-            const props = info.members.filter((m) => m.kind === "propertyDeclaration");
-            const allProps = new Set(props.map((p) => p.name));
-            const requiredProps = new Set(props.filter((p) => p.isRequired).map((p) => p.name));
-            candidates.push({ ref, allProps, requiredProps });
-            continue;
-        }
-    }
-    // Filter by match rules
-    const matches = candidates.filter((c) => {
-        // literal keys must exist on candidate
-        for (const k of keys) {
-            if (!c.allProps.has(k))
-                return false;
-        }
-        // candidate required props must be provided by literal
-        for (const r of c.requiredProps) {
-            if (!keySet.has(r))
-                return false;
-        }
-        return true;
-    });
-    if (matches.length === 0)
-        return undefined;
-    const firstMatch = matches[0];
-    if (matches.length === 1 && firstMatch)
-        return firstMatch.ref;
-    // Pick best by score
-    matches.sort((a, b) => {
-        const aTotal = a.allProps.size;
-        const bTotal = b.allProps.size;
-        const aExtra = aTotal - keySet.size;
-        const bExtra = bTotal - keySet.size;
-        if (aExtra !== bExtra)
-            return aExtra - bExtra; // fewer extras is better
-        const aReq = a.requiredProps.size;
-        const bReq = b.requiredProps.size;
-        if (aReq !== bReq)
-            return bReq - aReq; // more required is better
-        if (aTotal !== bTotal)
-            return aTotal - bTotal; // fewer total props is better
-        return a.ref.name.localeCompare(b.ref.name); // stable tie-break
-    });
-    const best = matches[0];
-    return best ? best.ref : undefined;
-};
-/**
- * Find property type in class members
- */
-const findPropertyInClassMembers = (members, propertyName) => {
-    for (const member of members) {
-        if (member.kind === "propertyDeclaration" && member.name === propertyName) {
-            return member.type;
-        }
-    }
-    return undefined;
-};
-/**
- * Strip null and undefined from a union type.
- *
- * Used when we need the non-nullable base type, e.g., for object instantiation
- * where `new T? { ... }` is invalid C# but `new T { ... }` is valid.
- *
- * @param type - The type to strip nullish from
- * @returns The non-nullish base type, or the original type if not a nullable union
- */
-export const stripNullish = (type) => {
-    if (type.kind !== "unionType")
-        return type;
-    const nonNullish = type.types.filter((t) => !(t.kind === "primitiveType" &&
-        (t.name === "null" || t.name === "undefined")));
-    // Single non-nullish type: return it (e.g., T | null → T)
-    if (nonNullish.length === 1 && nonNullish[0]) {
-        return nonNullish[0];
-    }
-    // Multi-type union or no non-nullish types: return original
-    return type;
-};
-/**
- * Known CLR struct types that are value types.
- */
-const CLR_VALUE_TYPES = new Set([
-    "global::System.DateTime",
-    "global::System.DateOnly",
-    "global::System.TimeOnly",
-    "global::System.TimeSpan",
-    "global::System.Guid",
-    "global::System.Decimal",
-    "System.DateTime",
-    "System.DateOnly",
-    "System.TimeOnly",
-    "System.TimeSpan",
-    "System.Guid",
-    "System.Decimal",
-]);
-/**
- * Check if a type is definitely a C# value type.
- *
- * Value types require `default` instead of `null` in object initializers
- * because `null` cannot be assigned to non-nullable value types.
- *
- * @param type - The type to check (should be non-nullish, use stripNullish first)
- * @returns true if the type is a known value type
- */
-export const isDefinitelyValueType = (type) => {
-    // Strip nullish first if caller forgot
-    const base = stripNullish(type);
-    // Primitive value types (number → double, int → int, boolean → bool, char → char)
-    if (base.kind === "primitiveType") {
-        return ["number", "int", "boolean", "char"].includes(base.name);
-    }
-    if (base.kind === "tupleType") {
-        return true;
-    }
-    // Known CLR struct types
-    if (base.kind === "referenceType") {
-        const clr = base.resolvedClrType;
-        if (clr && CLR_VALUE_TYPES.has(clr)) {
-            return true;
-        }
-    }
-    return false;
-};
-/**
- * Resolve a type alias to its underlying type.
- *
- * If the type is a reference type that points to a type alias,
- * returns the underlying type with type arguments substituted.
- *
- * @param type - The type to resolve
- * @param context - Emitter context with localTypes map
- * @returns The resolved underlying type, or the original type if not an alias
- */
-export const resolveTypeAlias = (type, context) => {
-    if (type.kind !== "referenceType") {
-        return type;
-    }
-    const localTypeInfo = context.localTypes?.get(type.name);
-    if (localTypeInfo?.kind === "typeAlias") {
-        // Substitute type arguments if present
-        if (type.typeArguments && type.typeArguments.length > 0) {
-            return substituteTypeArgs(localTypeInfo.type, localTypeInfo.typeParameters, type.typeArguments);
-        }
-        return localTypeInfo.type;
-    }
-    const aliasIndex = context.options.typeAliasIndex;
-    if (!aliasIndex) {
-        return type;
-    }
-    const stripGlobalPrefix = (name) => name.startsWith("global::") ? name.slice("global::".length) : name;
-    const name = stripGlobalPrefix(type.name);
-    const aliasEntry = name.includes(".")
-        ? aliasIndex.byFqn.get(name)
-        : (() => {
-            const matches = aliasIndex.byName.get(name) ?? [];
-            if (matches.length === 0)
-                return undefined;
-            if (matches.length === 1)
-                return matches[0];
-            const candidates = matches
-                .map((m) => m.fqn)
-                .sort()
-                .join(", ");
-            throw new Error(`ICE: Ambiguous type alias reference '${name}'. Candidates: ${candidates}`);
-        })();
-    if (!aliasEntry) {
-        return type;
-    }
-    if (type.typeArguments && type.typeArguments.length > 0) {
-        return substituteTypeArgs(aliasEntry.type, aliasEntry.typeParameters, type.typeArguments);
-    }
-    return aliasEntry.type;
-};
-/**
- * Find the index of a union member that matches a predicate target type.
- *
- * Used for union narrowing: given `isUser(account)` where account is `Union<User, Admin>`,
- * find which member index (0 or 1) corresponds to User.
- *
- * @param unionType - The union type to search
- * @param target - The predicate target type to find
- * @param context - Emitter context
- * @returns The 0-based index of the matching member, or undefined if not found
- */
-export const findUnionMemberIndex = (unionType, target, context) => {
-    const resolvedTarget = resolveTypeAlias(stripNullish(target), context);
-    // MVP: only handle reference-type targets
-    if (resolvedTarget.kind !== "referenceType")
-        return undefined;
-    for (let i = 0; i < unionType.types.length; i++) {
-        const m = unionType.types[i];
-        if (m?.kind === "referenceType" && m.name === resolvedTarget.name) {
-            // MVP: match by name; can tighten later to include typeArguments equality
-            return i;
-        }
-    }
-    return undefined;
-};
+ * Type resolution — facade re-exports.
+ *
+ * This file preserves the public import surface for the 50+ consumers that
+ * import from "./type-resolution.js". The actual implementations live in
+ * focused sub-modules:
+ *
+ * - nullish-value-helpers.ts — nullish stripping, value-type classification,
+ *   array-like element extraction, and type-alias resolution
+ * - property-member-lookup.ts — property/member lookup through type hierarchies,
+ *   binding registries, and type-member indices
+ * - structural-resolution.ts — type-parameter substitution, structural shape
+ *   matching, and structural-to-nominal type resolution
+ * - union-member-matching.ts — union member matching by typeof tags, predicate
+ *   targets, and object-literal keys
+ */
+export { stripNullish, isRuntimeNullishType, isRuntimeNullishMember, splitRuntimeNullishUnionMembers, isDefinitelyValueType, getArrayLikeElementType, resolveArrayLikeReceiverType, resolveTypeAlias, } from "./nullish-value-helpers.js";
+export { getPropertyType, resolveLocalTypeInfo, hasDeterministicPropertyMembership, getAllPropertySignatures, isTypeOnlyStructuralTarget, } from "./property-member-lookup.js";
+export { containsTypeParameter, substituteTypeArgs, isCompilerGeneratedStructuralReferenceType, resolveStructuralReferenceType, normalizeStructuralEmissionType, } from "./structural-resolution.js";
+export { matchesTypeofTag, narrowTypeByNotTypeofTag, narrowTypeByTypeofTag, selectObjectLiteralUnionMember, selectUnionMemberForObjectLiteral, findUnionMemberIndex, unionMemberMatchesTarget, } from "./union-member-matching.js";
 //# sourceMappingURL=type-resolution.js.map