@tsonic/frontend 0.0.74 → 0.0.75

package/dist/ir/type-system/type-system-inference.js

@@ -1,1321 +1,24 @@
 /**
- * TypeSystem Inference — Expression Type Inference, Declaration/Member Queries,
- * and Declaration Inspection Utilities
+ * TypeSystem Inference — Facade
  *
- * Extracted from the monolithic type-system.ts. Contains:
- * - Expression type inference (inferExpressionType, inferLambdaType)
- * - Declaration type queries (typeOfDecl, typeOfMember, typeOfMemberId)
- * - Initializer inference (tryInferTypeFromLiteralInitializer, tryInferTypeFromInitializer)
- * - Call return type inference (tryInferReturnTypeFromCallExpression)
- * - Declaration inspection utilities (hasTypeParameters, isTypeDecl, etc.)
+ * Re-exports all inference sub-modules to preserve the original import path.
+ * The implementation is split into focused sub-modules:
+ * - inference-utilities.ts: shared helpers (deriveTypeFromNumericKind, unwrapParens, etc.)
+ * - inference-expressions.ts: inferExpressionType, inferLambdaType
+ * - inference-initializers.ts: tryInferTypeFromLiteralInitializer, tryInferReturnTypeFromCallExpression, tryInferTypeFromInitializer
+ * - inference-member-resolution.ts: typeOfMember, typeOfMemberId, getIndexerInfo, parseIndexerKeyClrType
+ * - inference-declarations.ts: typeOfDecl, typeOfValueRead, hasTypeParameters, isTypeDecl, etc.
  *
  * DAG position: depends on type-system-state, type-system-relations, type-system-call-resolution
  */
-import * as ts from "typescript";
-import { substituteIrType as irSubstitute, } from "../types/ir-substitution.js";
-import { inferNumericKindFromRaw } from "../types/numeric-helpers.js";
-import { getBinaryResultKind, TSONIC_TO_NUMERIC_KIND, } from "../types/numeric-kind.js";
-import { unknownType, voidType } from "./types.js";
-import { emitDiagnostic, normalizeToNominal, isNullishPrimitive, makeMemberCacheKey, stripNullishForInference, } from "./type-system-state.js";
-import { typesEqual, containsTypeParameter } from "./type-system-relations.js";
-import { convertTypeNode, resolveCall, delegateToFunctionType, } from "./type-system-call-resolution.js";
-import { resolveDynamicImportNamespace } from "../../resolver/dynamic-import.js";
-// ─────────────────────────────────────────────────────────────────────────
-// typeOfDecl — Get declared type of a declaration
-// ─────────────────────────────────────────────────────────────────────────
-/**
- * Derive IrType from NumericKind (deterministic, no TypeScript).
- * Mirrors the logic in literals.ts deriveTypeFromNumericIntent.
- */
-export const deriveTypeFromNumericKind = (kind) => {
-    if (kind === "Int32")
-        return { kind: "referenceType", name: "int" };
-    if (kind === "Int64")
-        return { kind: "referenceType", name: "long" };
-    if (kind === "Double")
-        return { kind: "primitiveType", name: "number" };
-    if (kind === "Single")
-        return { kind: "referenceType", name: "float" };
-    if (kind === "Byte")
-        return { kind: "referenceType", name: "byte" };
-    if (kind === "Int16")
-        return { kind: "referenceType", name: "short" };
-    if (kind === "UInt32")
-        return { kind: "referenceType", name: "uint" };
-    if (kind === "UInt64")
-        return { kind: "referenceType", name: "ulong" };
-    if (kind === "UInt16")
-        return { kind: "referenceType", name: "ushort" };
-    if (kind === "SByte")
-        return { kind: "referenceType", name: "sbyte" };
-    // Default to double for unknown
-    return { kind: "primitiveType", name: "number" };
-};
-export const unwrapParens = (expr) => {
-    let current = expr;
-    while (ts.isParenthesizedExpression(current)) {
-        current = current.expression;
-    }
-    return current;
-};
-export const isLambdaExpression = (expr) => {
-    const unwrapped = unwrapParens(expr);
-    return ts.isArrowFunction(unwrapped) || ts.isFunctionExpression(unwrapped);
-};
-export const getNumericKindFromIrType = (type) => {
-    if (type.kind === "primitiveType" && type.name === "number")
-        return "Double";
-    if (type.kind === "primitiveType") {
-        return TSONIC_TO_NUMERIC_KIND.get(type.name);
-    }
-    if (type.kind === "referenceType") {
-        return TSONIC_TO_NUMERIC_KIND.get(type.name);
-    }
-    return undefined;
-};
-export const unwrapAwaitedForInference = (type) => {
-    if (type.kind === "unionType") {
-        return {
-            kind: "unionType",
-            types: type.types.map((t) => (t ? unwrapAwaitedForInference(t) : t)),
-        };
-    }
-    if (type.kind === "referenceType" &&
-        (type.name === "Promise" || type.name === "PromiseLike")) {
-        const inner = type.typeArguments?.[0];
-        if (inner)
-            return unwrapAwaitedForInference(inner);
-    }
-    if (type.kind === "referenceType") {
-        const clrName = type.typeId?.clrName;
-        if (clrName === "System.Threading.Tasks.Task" ||
-            clrName === "System.Threading.Tasks.ValueTask") {
-            return voidType;
-        }
-        if (clrName?.startsWith("System.Threading.Tasks.Task`") ||
-            clrName?.startsWith("System.Threading.Tasks.ValueTask`")) {
-            const inner = type.typeArguments?.[0];
-            if (inner)
-                return unwrapAwaitedForInference(inner);
-        }
-    }
-    return type;
-};
-/**
- * Deterministically infer an expression's type using only:
- * - local lambda parameter environment
- * - declaration types (typeOfDecl)
- * - numeric literal lexeme rules
- *
- * This is intentionally small: it's used only to type lambda bodies for
- * initializer-driven generic inference (e.g., `Enumerable.select(..., x => x * 2)`).
- */
-export const inferExpressionType = (state, expr, env) => {
-    const unwrapped = unwrapParens(expr);
-    if (ts.isAsExpression(unwrapped) || ts.isTypeAssertionExpression(unwrapped)) {
-        return convertTypeNode(state, unwrapped.type);
-    }
-    if (ts.isNonNullExpression(unwrapped)) {
-        const inner = inferExpressionType(state, unwrapped.expression, env);
-        if (!inner || inner.kind === "unknownType")
-            return undefined;
-        return stripNullishForInference(inner);
-    }
-    if (ts.isAwaitExpression(unwrapped)) {
-        const inner = inferExpressionType(state, unwrapped.expression, env);
-        if (!inner || inner.kind === "unknownType")
-            return undefined;
-        return unwrapAwaitedForInference(inner);
-    }
-    if (ts.isCallExpression(unwrapped)) {
-        return tryInferReturnTypeFromCallExpression(state, unwrapped, env);
-    }
-    if (ts.isNewExpression(unwrapped)) {
-        const sigId = state.resolveConstructorSignature(unwrapped);
-        if (!sigId)
-            return undefined;
-        const explicitTypeArgs = unwrapped.typeArguments && unwrapped.typeArguments.length > 0
-            ? unwrapped.typeArguments.map((ta) => convertTypeNode(state, ta))
-            : undefined;
-        const argumentCount = unwrapped.arguments?.length ?? 0;
-        const argTypesWorking = Array(argumentCount).fill(undefined);
-        const args = unwrapped.arguments ?? [];
-        for (let i = 0; i < args.length; i++) {
-            const arg = args[i];
-            if (!arg)
-                continue;
-            if (ts.isSpreadElement(arg))
-                continue;
-            if (isLambdaExpression(arg))
-                continue;
-            const t = inferExpressionType(state, arg, env);
-            if (t && t.kind !== "unknownType") {
-                argTypesWorking[i] = t;
-            }
-        }
-        const resolved = resolveCall(state, {
-            sigId,
-            argumentCount,
-            explicitTypeArgs,
-            argTypes: argTypesWorking,
-        });
-        return resolved.returnType.kind === "unknownType"
-            ? undefined
-            : resolved.returnType;
-    }
-    if (ts.isPropertyAccessExpression(unwrapped)) {
-        const receiverType = inferExpressionType(state, unwrapped.expression, env);
-        if (!receiverType || receiverType.kind === "unknownType")
-            return undefined;
-        const memberType = typeOfMember(state, receiverType, {
-            kind: "byName",
-            name: unwrapped.name.text,
-        });
-        return memberType.kind === "unknownType" ? undefined : memberType;
-    }
-    if (ts.isElementAccessExpression(unwrapped)) {
-        const objectType = inferExpressionType(state, unwrapped.expression, env);
-        if (!objectType || objectType.kind === "unknownType")
-            return undefined;
-        if (objectType.kind === "arrayType") {
-            return objectType.elementType;
-        }
-        if (objectType.kind === "dictionaryType") {
-            return objectType.valueType;
-        }
-        if (objectType.kind === "primitiveType" && objectType.name === "string") {
-            return { kind: "primitiveType", name: "string" };
-        }
-        if (objectType.kind === "referenceType") {
-            return getIndexerInfo(state, objectType)?.valueType;
-        }
-        return undefined;
-    }
-    if (ts.isIdentifier(unwrapped)) {
-        const fromEnv = env.get(unwrapped.text);
-        if (fromEnv)
-            return fromEnv;
-        const declId = state.resolveIdentifier(unwrapped);
-        if (!declId)
-            return undefined;
-        const t = typeOfDecl(state, declId);
-        return t.kind === "unknownType" ? undefined : t;
-    }
-    if (ts.isNumericLiteral(unwrapped)) {
-        const numericKind = inferNumericKindFromRaw(unwrapped.getText());
-        return deriveTypeFromNumericKind(numericKind);
-    }
-    if (ts.isStringLiteral(unwrapped)) {
-        return { kind: "primitiveType", name: "string" };
-    }
-    if (ts.isNoSubstitutionTemplateLiteral(unwrapped) ||
-        ts.isTemplateExpression(unwrapped)) {
-        return { kind: "primitiveType", name: "string" };
-    }
-    if (unwrapped.kind === ts.SyntaxKind.TrueKeyword ||
-        unwrapped.kind === ts.SyntaxKind.FalseKeyword) {
-        return { kind: "primitiveType", name: "boolean" };
-    }
-    if (ts.isPrefixUnaryExpression(unwrapped)) {
-        if (unwrapped.operator === ts.SyntaxKind.ExclamationToken) {
-            return { kind: "primitiveType", name: "boolean" };
-        }
-        return inferExpressionType(state, unwrapped.operand, env);
-    }
-    if (ts.isBinaryExpression(unwrapped)) {
-        const op = unwrapped.operatorToken.kind;
-        // Comparisons / equality always return boolean.
-        if (op === ts.SyntaxKind.EqualsEqualsToken ||
-            op === ts.SyntaxKind.EqualsEqualsEqualsToken ||
-            op === ts.SyntaxKind.ExclamationEqualsToken ||
-            op === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
-            op === ts.SyntaxKind.LessThanToken ||
-            op === ts.SyntaxKind.LessThanEqualsToken ||
-            op === ts.SyntaxKind.GreaterThanToken ||
-            op === ts.SyntaxKind.GreaterThanEqualsToken) {
-            return { kind: "primitiveType", name: "boolean" };
-        }
-        if (op === ts.SyntaxKind.AmpersandAmpersandToken ||
-            op === ts.SyntaxKind.BarBarToken) {
-            return { kind: "primitiveType", name: "boolean" };
-        }
-        if (op === ts.SyntaxKind.PlusToken ||
-            op === ts.SyntaxKind.MinusToken ||
-            op === ts.SyntaxKind.AsteriskToken ||
-            op === ts.SyntaxKind.SlashToken ||
-            op === ts.SyntaxKind.PercentToken) {
-            const leftType = inferExpressionType(state, unwrapped.left, env);
-            const rightType = inferExpressionType(state, unwrapped.right, env);
-            if (!leftType || !rightType)
-                return undefined;
-            // String concatenation
-            if (op === ts.SyntaxKind.PlusToken &&
-                ((leftType.kind === "primitiveType" && leftType.name === "string") ||
-                    (rightType.kind === "primitiveType" && rightType.name === "string"))) {
-                return { kind: "primitiveType", name: "string" };
-            }
-            const leftKind = getNumericKindFromIrType(leftType);
-            const rightKind = getNumericKindFromIrType(rightType);
-            if (!leftKind || !rightKind)
-                return undefined;
-            return deriveTypeFromNumericKind(getBinaryResultKind(leftKind, rightKind));
-        }
-    }
-    return undefined;
-};
-export const inferLambdaType = (state, expr, expectedType) => {
-    const unwrapped = unwrapParens(expr);
-    if (!ts.isArrowFunction(unwrapped) && !ts.isFunctionExpression(unwrapped)) {
-        return undefined;
-    }
-    const expectedFnType = expectedType?.kind === "functionType"
-        ? expectedType
-        : expectedType
-            ? delegateToFunctionType(state, expectedType)
-            : undefined;
-    const parameters = unwrapped.parameters.map((p, index) => {
-        const name = ts.isIdentifier(p.name) ? p.name.text : `arg${index}`;
-        const paramType = p.type
-            ? convertTypeNode(state, p.type)
-            : expectedFnType?.parameters[index]?.type;
-        return {
-            kind: "parameter",
-            pattern: {
-                kind: "identifierPattern",
-                name,
-            },
-            type: paramType,
-            initializer: undefined,
-            isOptional: !!p.questionToken,
-            isRest: !!p.dotDotDotToken,
-            passing: "value",
-        };
-    });
-    const env = new Map();
-    for (const p of parameters) {
-        if (p.pattern.kind === "identifierPattern" && p.pattern.name && p.type) {
-            env.set(p.pattern.name, p.type);
-        }
-    }
-    const explicitReturnType = "type" in unwrapped && unwrapped.type
-        ? convertTypeNode(state, unwrapped.type)
-        : undefined;
-    const expectedReturnType = expectedFnType?.returnType;
-    const inferredReturnType = explicitReturnType ??
-        (expectedReturnType && !containsTypeParameter(expectedReturnType)
-            ? expectedReturnType
-            : undefined) ??
-        (() => {
-            if (ts.isBlock(unwrapped.body)) {
-                const returns = [];
-                const visit = (n) => {
-                    if (ts.isFunctionLike(n) && n !== unwrapped)
-                        return;
-                    if (ts.isReturnStatement(n) && n.expression) {
-                        returns.push(n.expression);
-                    }
-                    n.forEachChild(visit);
-                };
-                unwrapped.body.forEachChild(visit);
-                if (returns.length === 0)
-                    return { kind: "voidType" };
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                const first = inferExpressionType(state, returns[0], env);
-                if (!first)
-                    return undefined;
-                for (let i = 1; i < returns.length; i++) {
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    const t = inferExpressionType(state, returns[i], env);
-                    if (!t || !typesEqual(t, first))
-                        return undefined;
-                }
-                return first;
-            }
-            return inferExpressionType(state, unwrapped.body, env);
-        })();
-    if (!inferredReturnType)
-        return undefined;
-    return {
-        kind: "functionType",
-        parameters,
-        returnType: inferredReturnType,
-    };
-};
-/**
- * Try to infer type from a variable declaration's literal initializer.
- *
- * DETERMINISM: Uses the raw lexeme form of the literal, not TS computed types.
- * Only handles simple literal initializers:
- * - Numeric literals → inferred via inferNumericKindFromRaw
- * - String literals → primitiveType("string")
- * - Boolean literals → primitiveType("boolean")
- *
- * Returns undefined if the initializer is not a simple literal.
- */
-export const tryInferTypeFromLiteralInitializer = (_state, declNode) => {
-    // TypeScript's VariableDeclaration has an `initializer` property
-    const decl = declNode;
-    // Must have an initializer
-    if (!decl.initializer)
-        return undefined;
-    const init = decl.initializer;
-    if (init.kind === ts.SyntaxKind.NumericLiteral && init.getText) {
-        const raw = init.getText();
-        const numericKind = inferNumericKindFromRaw(raw);
-        return deriveTypeFromNumericKind(numericKind);
-    }
-    if (init.kind === ts.SyntaxKind.StringLiteral) {
-        return { kind: "primitiveType", name: "string" };
-    }
-    if (init.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral ||
-        init.kind === ts.SyntaxKind.TemplateExpression) {
-        return { kind: "primitiveType", name: "string" };
-    }
-    if (init.kind === ts.SyntaxKind.TrueKeyword ||
-        init.kind === ts.SyntaxKind.FalseKeyword) {
-        return { kind: "primitiveType", name: "boolean" };
-    }
-    // Not a simple literal - cannot infer
-    return undefined;
-};
-/**
- * Try to infer type from a variable declaration's initializer using only
- * deterministic sources (declarations + explicit syntax).
- *
- * Handles:
- * - simple literals (delegates to tryInferTypeFromLiteralInitializer)
- * - call expressions where the callee has an explicit declared return type
- * - new expressions with explicit type arguments (or best-effort nominal type)
- * - identifier initializers (propagate deterministically)
- */
-export const tryInferReturnTypeFromCallExpression = (state, call, env) => {
-    if (call.expression.kind === ts.SyntaxKind.ImportKeyword) {
-        const resolution = resolveDynamicImportNamespace(call, call.getSourceFile().fileName, {
-            checker: state.checker,
-            compilerOptions: state.tsCompilerOptions,
-            sourceFilesByPath: state.sourceFilesByPath,
-        });
-        if (resolution.ok) {
-            const members = resolution.entries.flatMap((entry) => {
-                const declId = state.resolveIdentifier(entry.declarationName);
-                if (!declId)
-                    return [];
-                const memberType = typeOfDecl(state, declId);
-                if (memberType.kind === "unknownType")
-                    return [];
-                return [
-                    {
-                        kind: "propertySignature",
-                        name: entry.exportName,
-                        type: memberType,
-                        isOptional: false,
-                        isReadonly: true,
-                    },
-                ];
-            });
-            return {
-                kind: "referenceType",
-                name: "Promise",
-                typeArguments: [
-                    members.length === 0
-                        ? { kind: "referenceType", name: "object" }
-                        : {
-                            kind: "objectType",
-                            members,
-                        },
-                ],
-            };
-        }
-    }
-    const sigId = state.resolveCallSignature(call);
-    if (!sigId)
-        return undefined;
-    const explicitTypeArgs = call.typeArguments && call.typeArguments.length > 0
-        ? call.typeArguments.map((ta) => convertTypeNode(state, ta))
-        : undefined;
-    const receiverType = (() => {
-        if (!ts.isPropertyAccessExpression(call.expression))
-            return undefined;
-        const receiverExpr = call.expression.expression;
-        const receiver = inferExpressionType(state, receiverExpr, env);
-        return receiver && receiver.kind !== "unknownType" ? receiver : undefined;
-    })();
-    const argumentCount = call.arguments.length;
-    // Two-pass: resolve once to get expected parameter types, then infer non-lambda args,
-    // then infer lambda arg types (from expected types + body), then final resolve.
-    const initialResolved = resolveCall(state, {
-        sigId,
-        argumentCount,
-        receiverType,
-        explicitTypeArgs,
-    });
-    const initialParameterTypes = initialResolved.parameterTypes;
-    const argTypesWorking = Array(argumentCount).fill(undefined);
-    for (let index = 0; index < call.arguments.length; index++) {
-        const arg = call.arguments[index];
-        if (!arg)
-            continue;
-        if (ts.isSpreadElement(arg))
-            continue;
-        if (isLambdaExpression(arg))
-            continue;
-        if (ts.isNumericLiteral(arg)) {
-            const numericKind = inferNumericKindFromRaw(arg.getText());
-            argTypesWorking[index] = deriveTypeFromNumericKind(numericKind);
-            continue;
-        }
-        if (ts.isStringLiteral(arg)) {
-            argTypesWorking[index] = { kind: "primitiveType", name: "string" };
-            continue;
-        }
-        if (arg.kind === ts.SyntaxKind.TrueKeyword ||
-            arg.kind === ts.SyntaxKind.FalseKeyword) {
-            argTypesWorking[index] = {
-                kind: "primitiveType",
-                name: "boolean",
-            };
-            continue;
-        }
-        if (ts.isIdentifier(arg)) {
-            const argDeclId = state.resolveIdentifier(arg);
-            if (!argDeclId)
-                continue;
-            const t = typeOfDecl(state, argDeclId);
-            if (t.kind !== "unknownType") {
-                argTypesWorking[index] = t;
-            }
-            continue;
-        }
-        if (ts.isCallExpression(arg)) {
-            const t = tryInferReturnTypeFromCallExpression(state, arg, env);
-            if (t) {
-                argTypesWorking[index] = t;
-            }
-            continue;
-        }
-        if (ts.isNewExpression(arg)) {
-            const nestedSigId = state.resolveConstructorSignature(arg);
-            if (!nestedSigId)
-                continue;
-            const nestedExplicitTypeArgs = arg.typeArguments && arg.typeArguments.length > 0
-                ? arg.typeArguments.map((ta) => convertTypeNode(state, ta))
-                : undefined;
-            const nestedResolved = resolveCall(state, {
-                sigId: nestedSigId,
-                argumentCount: arg.arguments?.length ?? 0,
-                explicitTypeArgs: nestedExplicitTypeArgs,
-            });
-            if (nestedResolved.returnType.kind !== "unknownType") {
-                argTypesWorking[index] = nestedResolved.returnType;
-            }
-            continue;
-        }
-        // Fallback: infer from a small deterministic expression set (identifiers, literals,
-        // arithmetic, nested member/index access, calls, etc).
-        const t = inferExpressionType(state, arg, env);
-        if (t && t.kind !== "unknownType") {
-            argTypesWorking[index] = t;
-            continue;
-        }
-    }
-    const lambdaContextResolved = resolveCall(state, {
-        sigId,
-        argumentCount,
-        receiverType,
-        explicitTypeArgs,
-        argTypes: argTypesWorking,
-    });
-    const parameterTypesForLambdaContext = lambdaContextResolved.parameterTypes ?? initialParameterTypes;
-    for (let index = 0; index < call.arguments.length; index++) {
-        const arg = call.arguments[index];
-        if (!arg)
-            continue;
-        if (ts.isSpreadElement(arg))
-            continue;
-        if (!isLambdaExpression(arg))
-            continue;
-        const expectedType = parameterTypesForLambdaContext[index];
-        const lambdaType = inferLambdaType(state, arg, expectedType);
-        if (lambdaType) {
-            argTypesWorking[index] = lambdaType;
-        }
-    }
-    const finalResolved = resolveCall(state, {
-        sigId,
-        argumentCount,
-        receiverType,
-        explicitTypeArgs,
-        argTypes: argTypesWorking,
-    });
-    return finalResolved.returnType.kind === "unknownType"
-        ? undefined
-        : finalResolved.returnType;
-};
-export const tryInferTypeFromInitializer = (state, declNode) => {
-    const literalType = tryInferTypeFromLiteralInitializer(state, declNode);
-    if (literalType)
-        return literalType;
-    if (!declNode || typeof declNode !== "object")
-        return undefined;
-    const node = declNode;
-    if (!ts.isVariableDeclaration(node))
-        return undefined;
-    let init = node.initializer;
-    if (!init)
-        return undefined;
-    while (ts.isParenthesizedExpression(init)) {
-        init = init.expression;
-    }
-    // Explicit type assertions are deterministic sources for variable typing.
-    // This supports patterns like:
-    //   const xs = numbers as unknown as LinqSeq<int>;
-    // where the user intentionally supplies the type at the assertion site.
-    if (ts.isAsExpression(init) || ts.isTypeAssertionExpression(init)) {
-        return convertTypeNode(state, init.type);
-    }
-    if (ts.isNonNullExpression(init)) {
-        const inner = inferExpressionType(state, init.expression, new Map());
-        if (!inner || inner.kind === "unknownType")
-            return undefined;
-        return stripNullishForInference(inner);
-    }
-    if (ts.isAwaitExpression(init)) {
-        const inner = inferExpressionType(state, init.expression, new Map());
-        if (!inner || inner.kind === "unknownType")
-            return undefined;
-        return unwrapAwaitedForInference(inner);
-    }
-    if (ts.isCallExpression(init)) {
-        return tryInferReturnTypeFromCallExpression(state, init, new Map());
-    }
-    if (ts.isArrayLiteralExpression(init)) {
-        // Deterministic array literal typing for variable declarations:
-        // infer `T[]` only when all element types are deterministically known and equal.
-        const elementTypes = [];
-        const emptyEnv = new Map();
-        for (const el of init.elements) {
-            if (ts.isOmittedExpression(el)) {
-                return undefined;
-            }
-            if (ts.isSpreadElement(el)) {
-                return undefined;
-            }
-            const t = inferExpressionType(state, el, emptyEnv);
-            if (!t || t.kind === "unknownType") {
-                return undefined;
-            }
-            elementTypes.push(t);
-        }
-        if (elementTypes.length === 0)
-            return undefined;
-        const first = elementTypes[0];
-        if (first && elementTypes.every((t) => typesEqual(t, first))) {
-            return { kind: "arrayType", elementType: first };
-        }
-        return undefined;
-    }
-    // Phase 15: NewExpression branch - use constructor signature with argTypes
-    if (ts.isNewExpression(init)) {
-        const sigId = state.resolveConstructorSignature(init);
-        if (!sigId)
-            return undefined;
-        const explicitTypeArgs = init.typeArguments && init.typeArguments.length > 0
-            ? init.typeArguments.map((ta) => convertTypeNode(state, ta))
-            : undefined;
-        // Derive argTypes conservatively from syntax (same pattern as CallExpression)
-        const args = init.arguments ?? [];
-        const argTypes = args.map((arg) => {
-            if (ts.isSpreadElement(arg))
-                return undefined;
-            if (ts.isNumericLiteral(arg)) {
-                const numericKind = inferNumericKindFromRaw(arg.getText());
-                return deriveTypeFromNumericKind(numericKind);
-            }
-            if (ts.isStringLiteral(arg)) {
-                return { kind: "primitiveType", name: "string" };
-            }
-            if (arg.kind === ts.SyntaxKind.TrueKeyword ||
-                arg.kind === ts.SyntaxKind.FalseKeyword) {
-                return { kind: "primitiveType", name: "boolean" };
-            }
-            if (ts.isIdentifier(arg)) {
-                const argDeclId = state.resolveIdentifier(arg);
-                if (!argDeclId)
-                    return undefined;
-                const t = typeOfDecl(state, argDeclId);
-                return t.kind === "unknownType" ? undefined : t;
-            }
-            // Recursive handling for nested new expressions
-            if (ts.isNewExpression(arg)) {
-                const nestedSigId = state.resolveConstructorSignature(arg);
-                if (!nestedSigId)
-                    return undefined;
-                const nestedExplicitTypeArgs = arg.typeArguments && arg.typeArguments.length > 0
-                    ? arg.typeArguments.map((ta) => convertTypeNode(state, ta))
-                    : undefined;
-                const nestedResolved = resolveCall(state, {
-                    sigId: nestedSigId,
-                    argumentCount: arg.arguments?.length ?? 0,
-                    explicitTypeArgs: nestedExplicitTypeArgs,
-                });
-                return nestedResolved.returnType.kind === "unknownType"
-                    ? undefined
-                    : nestedResolved.returnType;
-            }
-            return undefined;
-        });
-        // Resolve constructor call with argTypes for inference
-        const resolved = resolveCall(state, {
-            sigId,
-            argumentCount: args.length,
-            explicitTypeArgs,
-            argTypes,
-        });
-        return resolved.returnType.kind === "unknownType"
-            ? undefined
-            : resolved.returnType;
-    }
-    if (ts.isIdentifier(init)) {
-        const sourceDeclId = state.resolveIdentifier(init);
-        if (!sourceDeclId)
-            return undefined;
-        const sourceType = typeOfDecl(state, sourceDeclId);
-        return sourceType.kind === "unknownType" ? undefined : sourceType;
-    }
-    // Property access: const output = response.outputStream
-    // DETERMINISTIC: Infer via TypeSystem member lookup on a deterministically typed receiver.
-    if (ts.isPropertyAccessExpression(init)) {
-        const receiverType = inferExpressionType(state, init.expression, new Map());
-        if (!receiverType || receiverType.kind === "unknownType")
-            return undefined;
-        const memberType = typeOfMember(state, receiverType, {
-            kind: "byName",
-            name: init.name.text,
-        });
-        return memberType.kind === "unknownType" ? undefined : memberType;
-    }
-    // Element access: const first = items[0]
-    // DETERMINISTIC: Infer element type from a deterministically typed receiver.
-    if (ts.isElementAccessExpression(init)) {
-        const inferred = inferExpressionType(state, init, new Map());
-        return inferred && inferred.kind !== "unknownType" ? inferred : undefined;
-    }
-    const inferred = inferExpressionType(state, init, new Map());
-    if (inferred && inferred.kind !== "unknownType") {
-        return inferred;
-    }
-    return undefined;
-};
-export const typeOfDecl = (state, declId) => {
-    // Check cache first
-    const cached = state.declTypeCache.get(declId.id);
-    if (cached)
-        return cached;
-    const declInfo = state.handleRegistry.getDecl(declId);
-    if (!declInfo) {
-        emitDiagnostic(state, "TSN5203", "Cannot resolve declaration");
-        const result = unknownType;
-        state.declTypeCache.set(declId.id, result);
-        return result;
-    }
-    let result;
-    if (declInfo.typeNode) {
-        // Explicit type annotation - convert to IR
-        result = convertTypeNode(state, declInfo.typeNode);
-    }
-    else if (declInfo.kind === "class" ||
-        declInfo.kind === "interface" ||
-        declInfo.kind === "enum") {
-        // Class/interface/enum - return reference type
-        result = {
-            kind: "referenceType",
-            name: declInfo.fqName ?? "unknown",
-        };
-    }
-    else if (declInfo.kind === "function") {
-        // Function without type annotation - need to build function type from signature
-        // For now, return unknownType as we need the signature ID
-        emitDiagnostic(state, "TSN5201", `Function '${declInfo.fqName ?? "unknown"}' requires explicit return type`);
-        result = unknownType;
-    }
-    else if (declInfo.kind === "variable" && declInfo.declNode) {
-        // Variable without type annotation - infer from deterministic initializer
-        const inferred = tryInferTypeFromInitializer(state, declInfo.declNode);
-        if (inferred) {
-            result = inferred;
-        }
-        else {
-            // Not a simple literal - require explicit type annotation
-            emitDiagnostic(state, "TSN5201", `Declaration requires explicit type annotation`);
-            result = unknownType;
-        }
-    }
-    else {
-        // Parameter or other declaration without type annotation
-        emitDiagnostic(state, "TSN5201", `Declaration requires explicit type annotation`);
-        result = unknownType;
-    }
-    state.declTypeCache.set(declId.id, result);
-    return result;
-};
-// ─────────────────────────────────────────────────────────────────────────
-// typeOfMember — Get declared type of a member (with inheritance substitution)
-// ─────────────────────────────────────────────────────────────────────────
-const resolveMemberTypeNoDiag = (state, receiver, memberName) => {
-    // Built-in dictionary pseudo-members used by TS-side ergonomics.
-    // Record<K, V> lowers to dictionaryType, and callers often use:
-    // - dict.Keys[i]
-    // - dict.Values[i]
-    // - dict.Count / dict.Length
-    //
-    // Resolve these deterministically at TypeSystem level so downstream passes
-    // (numeric proof, element access typing) don't receive unknownType poison.
-    if (receiver.kind === "dictionaryType") {
-        if (memberName === "Keys") {
-            return {
-                kind: "arrayType",
-                elementType: receiver.keyType,
-            };
-        }
-        if (memberName === "Values") {
-            return {
-                kind: "arrayType",
-                elementType: receiver.valueType,
-            };
-        }
-        if (memberName === "Count" || memberName === "Length") {
-            return { kind: "primitiveType", name: "int" };
-        }
-        return receiver.valueType;
-    }
-    // Built-in array pseudo-members.
-    // Arrays are structural IR types and may not resolve via nominal lookup.
-    //
-    // Support both CLR-style `Length`/`Count` and TS/JS-style `length`.
-    // The latter is required for JS surfaces even when the underlying runtime
-    // value is an explicit CLR array (for example `Encoding.UTF8.GetBytes(...).length`).
-    if (receiver.kind === "arrayType") {
-        if (memberName === "Length" ||
-            memberName === "Count" ||
-            memberName === "length") {
-            return { kind: "primitiveType", name: "int" };
-        }
-    }
-    // Tuples behave like fixed-size arrays for length access.
-    if (receiver.kind === "tupleType") {
-        if (memberName === "Length" ||
-            memberName === "Count" ||
-            memberName === "length") {
-            return { kind: "primitiveType", name: "int" };
-        }
-    }
-    // 1. Normalize receiver to nominal form
-    const normalized = normalizeToNominal(state, receiver);
-    if (!normalized) {
-        // Handle structural types (objectType)
-        if (receiver.kind === "objectType") {
-            const member = receiver.members.find((m) => m.name === memberName);
-            if (!member)
-                return undefined;
-            if (member.kind === "propertySignature") {
-                if (!member.isOptional)
-                    return member.type;
-                return {
-                    kind: "unionType",
-                    types: [member.type, { kind: "primitiveType", name: "undefined" }],
-                };
-            }
-            return {
-                kind: "functionType",
-                parameters: member.parameters,
-                returnType: member.returnType ?? voidType,
-            };
-        }
-        if (receiver.kind === "referenceType" &&
-            receiver.structuralMembers &&
-            receiver.structuralMembers.length > 0) {
-            const member = receiver.structuralMembers.find((m) => m.name === memberName);
-            if (!member)
-                return undefined;
-            if (member.kind === "propertySignature") {
-                if (!member.isOptional)
-                    return member.type;
-                return {
-                    kind: "unionType",
-                    types: [member.type, { kind: "primitiveType", name: "undefined" }],
-                };
-            }
-            return {
-                kind: "functionType",
-                parameters: member.parameters,
-                returnType: member.returnType ?? voidType,
-            };
-        }
-        return undefined;
-    }
-    // 2. Check cache
-    const cacheKey = makeMemberCacheKey(normalized.typeId.stableId, memberName, normalized.typeArgs);
-    const cached = state.memberDeclaredTypeCache.get(cacheKey);
-    if (cached)
-        return cached;
-    // 3. Use NominalEnv to find declaring type + substitution (Phase 6: TypeId-based)
-    const lookupResult = state.nominalEnv.findMemberDeclaringType(normalized.typeId, normalized.typeArgs, memberName);
-    // 4a. If NominalEnv found the member, get its declared type from Universe
-    if (lookupResult) {
-        const memberEntry = state.unifiedCatalog.getMember(lookupResult.declaringTypeId, memberName);
-        // Property/field member: return its declared type.
-        const memberType = memberEntry?.type;
-        if (memberType) {
-            const result = irSubstitute(memberType, lookupResult.substitution);
-            state.memberDeclaredTypeCache.set(cacheKey, result);
-            return result;
-        }
-        // Method member: materialize a callable function type from the first signature.
-        // Call resolution (resolveCall) uses SignatureId for overload selection; this
-        // type is used only to keep member access expressions deterministic.
-        const firstSig = memberEntry?.signatures?.[0];
-        if (firstSig) {
-            const funcType = {
-                kind: "functionType",
-                parameters: firstSig.parameters.map((p) => ({
-                    kind: "parameter",
-                    pattern: {
-                        kind: "identifierPattern",
-                        name: p.name,
-                    },
-                    type: p.type,
-                    initializer: undefined,
-                    isOptional: p.isOptional,
-                    isRest: p.isRest,
-                    passing: p.mode,
-                })),
-                returnType: firstSig.returnType,
-            };
-            const result = irSubstitute(funcType, lookupResult.substitution);
-            state.memberDeclaredTypeCache.set(cacheKey, result);
-            return result;
-        }
-    }
-    return undefined;
-};
-export const typeOfMember = (state, receiver, member, site) => {
-    const memberName = member.kind === "byName" ? member.name : "unknown"; // MemberId.name not defined yet
-    // Common nullish unions (T | undefined | null) should behave like T for member lookup.
-    // This preserves deterministic typing for patterns like:
-    //   const url = request.url; if (!url) return; url.absolutePath
-    const effectiveReceiver = receiver.kind === "unionType"
-        ? (() => {
-            const nonNullish = receiver.types.filter((t) => t && !isNullishPrimitive(t));
-            return nonNullish.length === 1 && nonNullish[0]
-                ? nonNullish[0]
-                : receiver;
-        })()
-        : receiver;
-    if (effectiveReceiver.kind === "unionType") {
-        const nonNullish = effectiveReceiver.types.filter((t) => t && !isNullishPrimitive(t));
-        if (nonNullish.length > 1) {
-            let resolved;
-            for (const part of nonNullish) {
-                const partType = resolveMemberTypeNoDiag(state, part, memberName);
-                if (!partType) {
-                    emitDiagnostic(state, "TSN5203", `Member '${memberName}' not found`, site);
-                    return unknownType;
-                }
-                if (!resolved) {
-                    resolved = partType;
-                    continue;
-                }
-                if (!typesEqual(resolved, partType)) {
-                    emitDiagnostic(state, "TSN5203", `Member '${memberName}' has incompatible types across union constituents`, site);
-                    return unknownType;
-                }
-            }
-            if (resolved)
-                return resolved;
-        }
-    }
-    const resolved = resolveMemberTypeNoDiag(state, effectiveReceiver, memberName);
-    if (resolved)
-        return resolved;
-    emitDiagnostic(state, "TSN5203", `Member '${memberName}' not found`, site);
-    return unknownType;
-};
-export const parseIndexerKeyClrType = (stableId) => {
-    const memberSep = stableId.indexOf("::");
-    if (memberSep < 0)
-        return undefined;
-    const bracketStart = stableId.indexOf("[", memberSep);
-    if (bracketStart < 0)
-        return undefined;
-    let depth = 0;
-    let bracketEnd = -1;
-    for (let i = bracketStart; i < stableId.length; i++) {
-        const ch = stableId[i];
-        if (ch === "[")
-            depth++;
-        if (ch === "]") {
-            depth--;
-            if (depth === 0) {
-                bracketEnd = i;
-                break;
-            }
-        }
-    }
-    if (bracketEnd < 0)
-        return undefined;
-    const rawParams = stableId.slice(bracketStart + 1, bracketEnd);
-    // Split on top-level commas to support nested generic types.
-    const splitTopLevel = (value) => {
-        const parts = [];
-        let start = 0;
-        let bracketDepth = 0;
-        for (let i = 0; i < value.length; i++) {
-            const c = value[i];
-            if (c === "[")
-                bracketDepth++;
-            else if (c === "]" && bracketDepth > 0)
-                bracketDepth--;
-            else if (c === "," && bracketDepth === 0) {
-                parts.push(value.slice(start, i).trim());
-                start = i + 1;
-            }
-        }
-        parts.push(value.slice(start).trim());
-        return parts.filter((p) => p.length > 0);
-    };
-    const params = splitTopLevel(rawParams);
-    if (params.length !== 1)
-        return undefined;
-    const first = params[0];
-    if (!first)
-        return undefined;
-    // Strip assembly qualification (", Assembly, Version=..., ...") if present.
-    const withoutAsm = first.includes(",")
-        ? (first.split(",")[0] ?? first)
-        : first;
-    return withoutAsm.trim();
-};
-export const getIndexerInfo = (state, receiver, _site) => {
-    const normalized = normalizeToNominal(state, receiver);
-    if (!normalized)
-        return undefined;
-    // Walk inheritance chain to find the first indexer property.
-    const chain = state.nominalEnv.getInheritanceChain(normalized.typeId);
-    for (const typeId of chain) {
-        const members = state.unifiedCatalog.getMembers(typeId);
-        const indexers = Array.from(members.values()).filter((m) => m.memberKind === "property" && m.isIndexer);
-        if (indexers.length === 0)
-            continue;
-        if (indexers.length > 1)
-            return undefined;
-        const indexer = indexers[0];
-        if (!indexer?.type)
-            return undefined;
-        const keyClrType = parseIndexerKeyClrType(indexer.stableId);
-        if (!keyClrType)
-            return undefined;
-        const inst = state.nominalEnv.getInstantiation(normalized.typeId, normalized.typeArgs, typeId);
-        const valueType = inst && inst.size > 0
-            ? irSubstitute(indexer.type, inst)
-            : indexer.type;
-        return { keyClrType, valueType };
-    }
-    return undefined;
-};
-// ─────────────────────────────────────────────────────────────────────────
-// hasTypeParameters — Check if declaration has type parameters
-// ─────────────────────────────────────────────────────────────────────────
-export const hasTypeParameters = (state, declId) => {
-    const declInfo = state.handleRegistry.getDecl(declId);
-    if (!declInfo?.declNode)
-        return false;
-    // Check the declaration node for type parameters
-    // We need to import ts to check for type parameter declarations
-    // Access the declNode as any to check for typeParameters property
-    const declNode = declInfo.declNode;
-    return !!(declNode.typeParameters && declNode.typeParameters.length > 0);
-};
-// ─────────────────────────────────────────────────────────────────────────
-// typeOfMemberId — Get type of member by handle
-// ─────────────────────────────────────────────────────────────────────────
-export const typeOfMemberId = (state, memberId, receiverType) => {
-    const memberInfo = state.handleRegistry.getMember(memberId);
-    if (!memberInfo) {
-        return unknownType;
-    }
-    // Otherwise, attempt to recover type deterministically from the member declaration.
-    // This is required for namespace imports (`import * as X`) where members are
-    // function declarations / const declarations (no typeNode captured by Binding).
-    const decl = memberInfo.declNode;
-    if (decl) {
-        const normalizeDeclaringTypeName = (name) => name
-            .replace(/\$instance$/, "")
-            .replace(/^__(.+)\$views$/, "$1")
-            .replace(/_\d+$/, "")
-            .replace(/`\d+$/, "");
-        const getDeclaringTypeSubstitution = () => {
-            if (!receiverType)
-                return undefined;
-            const extractReceiverRef = (type) => {
-                if (type.kind === "referenceType")
-                    return type;
-                if (type.kind === "intersectionType") {
-                    return type.types.find((part) => part.kind === "referenceType");
-                }
-                if (type.kind === "unionType") {
-                    const nonNullish = type.types.filter((part) => !(part.kind === "primitiveType" &&
-                        (part.name === "null" || part.name === "undefined")));
-                    const onlyNonNullish = nonNullish[0];
-                    return nonNullish.length === 1 && onlyNonNullish
-                        ? extractReceiverRef(onlyNonNullish)
-                        : undefined;
-                }
-                return undefined;
-            };
-            const receiverRef = extractReceiverRef(receiverType);
-            if (!receiverRef?.typeArguments ||
-                receiverRef.typeArguments.length === 0) {
-                return undefined;
-            }
-            const parent = decl.parent;
-            const declaringType = ts.isInterfaceDeclaration(parent) ||
-                ts.isClassDeclaration(parent) ||
-                ts.isTypeAliasDeclaration(parent)
-                ? parent
-                : undefined;
-            if (!declaringType?.name || !declaringType.typeParameters) {
-                return undefined;
-            }
-            if (normalizeDeclaringTypeName(receiverRef.name) !==
-                normalizeDeclaringTypeName(declaringType.name.text)) {
-                return undefined;
-            }
-            const typeParams = declaringType.typeParameters;
-            if (typeParams.length !== receiverRef.typeArguments.length) {
-                return undefined;
-            }
-            const receiverTypeArguments = receiverRef.typeArguments;
-            if (!receiverTypeArguments) {
-                return undefined;
-            }
-            const entries = [];
-            for (const [index, param] of typeParams.entries()) {
-                const arg = receiverTypeArguments[index];
-                if (!arg) {
-                    return undefined;
-                }
-                entries.push([param.name.text, arg]);
-            }
-            return new Map(entries);
-        };
-        const substitution = getDeclaringTypeSubstitution();
-        const applySubstitution = (type) => substitution
-            ? irSubstitute(type, substitution)
-            : type;
-        if (ts.isMethodDeclaration(decl) || ts.isMethodSignature(decl)) {
-            if (!decl.type)
-                return unknownType;
-            if (decl.parameters.some((p) => p.type === undefined))
-                return unknownType;
-            const parameters = decl.parameters.map((p) => ({
-                kind: "parameter",
-                pattern: {
-                    kind: "identifierPattern",
-                    name: ts.isIdentifier(p.name) ? p.name.text : "param",
-                },
-                type: p.type
-                    ? applySubstitution(convertTypeNode(state, p.type))
-                    : undefined,
-                initializer: undefined,
-                isOptional: !!p.questionToken || !!p.initializer,
-                isRest: !!p.dotDotDotToken,
-                passing: "value",
-            }));
-            return {
-                kind: "functionType",
-                parameters,
-                returnType: applySubstitution(convertTypeNode(state, decl.type)),
-            };
-        }
-        // If the member has a type node, convert it with any available declaring-type substitution.
-        if (memberInfo.typeNode) {
-            return applySubstitution(convertTypeNode(state, memberInfo.typeNode));
-        }
-        if (ts.isFunctionDeclaration(decl)) {
-            // Determinism: require explicit parameter + return annotations.
-            if (!decl.type)
-                return unknownType;
-            if (decl.parameters.some((p) => p.type === undefined))
-                return unknownType;
-            const parameters = decl.parameters.map((p) => ({
-                kind: "parameter",
-                pattern: {
-                    kind: "identifierPattern",
-                    name: ts.isIdentifier(p.name) ? p.name.text : "param",
-                },
-                type: p.type ? convertTypeNode(state, p.type) : undefined,
-                initializer: undefined,
-                isOptional: !!p.questionToken || !!p.initializer,
-                isRest: !!p.dotDotDotToken,
-                passing: "value",
-            }));
-            const returnType = convertTypeNode(state, decl.type);
-            const fnType = {
-                kind: "functionType",
-                parameters,
-                returnType,
-            };
-            return fnType;
-        }
-        if (ts.isVariableDeclaration(decl)) {
-            if (decl.type)
-                return convertTypeNode(state, decl.type);
-            const inferred = tryInferTypeFromInitializer(state, decl);
-            return inferred ?? unknownType;
-        }
-    }
-    if (memberInfo.typeNode) {
-        return convertTypeNode(state, memberInfo.typeNode);
-    }
-    return unknownType;
-};
-// ─────────────────────────────────────────────────────────────────────────
-// getFQNameOfDecl — Get fully-qualified name of declaration
-// ─────────────────────────────────────────────────────────────────────────
-export const getFQNameOfDecl = (state, declId) => {
-    const declInfo = state.handleRegistry.getDecl(declId);
-    return declInfo?.fqName;
-};
-// ─────────────────────────────────────────────────────────────────────────
-// isTypeDecl — Check if declaration is a type
-// ─────────────────────────────────────────────────────────────────────────
-export const isTypeDecl = (state, declId) => {
-    const declInfo = state.handleRegistry.getDecl(declId);
-    if (!declInfo)
-        return false;
-    const typeKinds = [
-        "interface",
-        "class",
-        "typeAlias",
-        "enum",
-    ];
-    return typeKinds.includes(declInfo.kind);
-};
-// ─────────────────────────────────────────────────────────────────────────
-// isInterfaceDecl — Check if declaration is an interface
-// ─────────────────────────────────────────────────────────────────────────
-export const isInterfaceDecl = (state, declId) => {
-    const declInfo = state.handleRegistry.getDecl(declId);
-    return declInfo?.kind === "interface";
-};
-// ─────────────────────────────────────────────────────────────────────────
-// isTypeAliasToObjectLiteral — Check if type alias points to object literal
-// ─────────────────────────────────────────────────────────────────────────
-export const isTypeAliasToObjectLiteral = (state, declId) => {
-    const declInfo = state.handleRegistry.getDecl(declId);
-    if (!declInfo || declInfo.kind !== "typeAlias")
-        return false;
-    // Check if the typeNode is a type literal node
-    // We need to access the declNode to get the type alias declaration
-    const declNode = declInfo.declNode;
-    if (!declNode?.type)
-        return false;
-    return declNode.type.kind === ts.SyntaxKind.TypeLiteral;
-};
-// ─────────────────────────────────────────────────────────────────────────
-// signatureHasConditionalReturn — Check for conditional return type
-// ─────────────────────────────────────────────────────────────────────────
-export const signatureHasConditionalReturn = (state, sigId) => {
-    const sigInfo = state.handleRegistry.getSignature(sigId);
-    if (!sigInfo)
-        return false;
-    const returnTypeNode = sigInfo.returnTypeNode;
-    if (!returnTypeNode)
-        return false;
-    return returnTypeNode.kind === ts.SyntaxKind.ConditionalType;
-};
-// ─────────────────────────────────────────────────────────────────────────
-// signatureHasVariadicTypeParams — Check for variadic type parameters
-// ─────────────────────────────────────────────────────────────────────────
-export const signatureHasVariadicTypeParams = (state, sigId) => {
-    const sigInfo = state.handleRegistry.getSignature(sigId);
-    if (!sigInfo)
-        return false;
-    if (!sigInfo.typeParameters)
-        return false;
-    for (const typeParam of sigInfo.typeParameters) {
-        const constraintNode = typeParam.constraintNode;
-        if (!constraintNode)
-            continue;
-        // Check if constraint is an array type (variadic pattern: T extends unknown[])
-        if (constraintNode.kind === ts.SyntaxKind.ArrayType) {
-            const elementType = constraintNode.elementType;
-            if (!elementType)
-                continue;
-            // Check for unknown[] or any[] constraint
-            if (elementType.kind === ts.SyntaxKind.UnknownKeyword ||
-                elementType.kind === ts.SyntaxKind.AnyKeyword) {
-                return true;
-            }
-            // Also check for type reference to "unknown" or "any"
-            const typeName = elementType.typeName?.text;
-            if (typeName === "unknown" || typeName === "any") {
-                return true;
-            }
-        }
-    }
-    return false;
-};
-// ─────────────────────────────────────────────────────────────────────────
-// declHasTypeAnnotation — Check if declaration has explicit type
-// ─────────────────────────────────────────────────────────────────────────
-export const declHasTypeAnnotation = (state, declId) => {
-    const declInfo = state.handleRegistry.getDecl(declId);
-    return declInfo?.typeNode !== undefined;
-};
-// ─────────────────────────────────────────────────────────────────────────
-// checkTsClassMemberOverride — Check if member can be overridden
-// ─────────────────────────────────────────────────────────────────────────
-/**
- * Check if a class member overrides a base class member.
- *
- * ALICE'S SPEC: Uses captured ClassMemberNames (pure data) from Binding.
- * No TS AST inspection, no SyntaxKind numbers. TS-version safe.
- */
-export const checkTsClassMemberOverride = (state, declId, memberName, memberKind) => {
-    const declInfo = state.handleRegistry.getDecl(declId);
-    const members = declInfo?.classMemberNames;
-    // No class member info available
-    if (!members) {
-        return { isOverride: false, isShadow: false };
-    }
-    // Check if base class has this member
-    const has = memberKind === "method"
-        ? members.methods.has(memberName)
-        : members.properties.has(memberName);
-    // In TypeScript, all methods can be overridden (no `final` keyword)
-    return has
-        ? { isOverride: true, isShadow: false }
-        : { isOverride: false, isShadow: false };
-};
-// ─────────────────────────────────────────────────────────────────────────
-// typeFromSyntax — Convert captured type syntax to IrType
-// ─────────────────────────────────────────────────────────────────────────
-/**
- * Convert a captured type syntax to IrType.
- *
- * This method takes a TypeSyntaxId handle (opaque to caller) and looks up
- * the captured TypeNode in the HandleRegistry, then converts it.
- *
- * ALICE'S SPEC (Phase 2): TypeSystem receives opaque handles, not ts.TypeNode.
- */
-export const typeFromSyntax = (state, typeSyntaxId) => {
-    const syntaxInfo = state.handleRegistry.getTypeSyntax(typeSyntaxId);
-    if (!syntaxInfo) {
-        // Invalid handle - return unknownType
-        return { kind: "unknownType" };
-    }
-    // Phase 5: convertTypeNode accepts unknown, cast is inside type-system/internal
-    return convertTypeNode(state, syntaxInfo.typeNode);
-};
+// ── Inference Utilities ──────────────────────────────────────────────────
+export { deriveTypeFromNumericKind, unwrapParens, isLambdaExpression, getNumericKindFromIrType, unwrapAwaitedForInference, } from "./inference-utilities.js";
+// ── Expression Type Inference ────────────────────────────────────────────
+export { inferExpressionType, inferLambdaType, } from "./inference-expressions.js";
+// ── Initializer & Call Return Type Inference ─────────────────────────────
+export { tryInferTypeFromLiteralInitializer, tryInferReturnTypeFromCallExpression, tryInferTypeFromInitializer, } from "./inference-initializers.js";
+// ── Member Type Resolution ───────────────────────────────────────────────
+export { typeOfMember, typeOfMemberId, parseIndexerKeyClrType, getIndexerInfo, } from "./inference-member-resolution.js";
+// ── Declaration Type Queries & Inspection ────────────────────────────────
+export { typeOfDecl, typeOfValueRead, getFQNameOfDecl, hasTypeParameters, isTypeDecl, isInterfaceDecl, isTypeAliasToObjectLiteral, signatureHasConditionalReturn, signatureHasVariadicTypeParams, declHasTypeAnnotation, checkTsClassMemberOverride, typeFromSyntax, } from "./inference-declarations.js";
 //# sourceMappingURL=type-system-inference.js.map