@tsonic/frontend 0.0.73 → 0.0.75

package/dist/ir/validation/anonymous-type-lowering-pass.js

@@ -16,1176 +16,31 @@
  * interface __Anon_abc123 { value: number }
  * const config: __Anon_abc123 = { value: 42 };
  * ```
- */
-import { createHash } from "crypto";
-/**
- * Collect free type parameter names referenced by an IrType.
- *
- * These are used to make synthesized anonymous types generic when their
- * member types contain typeParameterType nodes (e.g., `{ value: T }`).
- */
-const collectTypeParameterNames = (type, out) => {
-    switch (type.kind) {
-        case "typeParameterType":
-            out.add(type.name);
-            return;
-        case "referenceType":
-            for (const ta of type.typeArguments ?? []) {
-                if (ta)
-                    collectTypeParameterNames(ta, out);
-            }
-            return;
-        case "arrayType":
-            collectTypeParameterNames(type.elementType, out);
-            return;
-        case "tupleType":
-            for (const el of type.elementTypes) {
-                if (el)
-                    collectTypeParameterNames(el, out);
-            }
-            return;
-        case "functionType":
-            for (const p of type.parameters) {
-                if (p.type)
-                    collectTypeParameterNames(p.type, out);
-            }
-            collectTypeParameterNames(type.returnType, out);
-            return;
-        case "unionType":
-        case "intersectionType":
-            for (const t of type.types) {
-                if (t)
-                    collectTypeParameterNames(t, out);
-            }
-            return;
-        case "dictionaryType":
-            collectTypeParameterNames(type.keyType, out);
-            collectTypeParameterNames(type.valueType, out);
-            return;
-        case "objectType":
-            for (const m of type.members) {
-                if (m.kind === "propertySignature") {
-                    collectTypeParameterNames(m.type, out);
-                }
-                else if (m.kind === "methodSignature") {
-                    for (const p of m.parameters) {
-                        if (p.type)
-                            collectTypeParameterNames(p.type, out);
-                    }
-                    if (m.returnType)
-                        collectTypeParameterNames(m.returnType, out);
-                }
-            }
-            return;
-        case "primitiveType":
-        case "literalType":
-        case "anyType":
-        case "unknownType":
-        case "voidType":
-        case "neverType":
-            return;
-    }
-};
-/**
- * Serialize an IrType to a stable string for shape signature
- */
-const serializeType = (type) => {
-    switch (type.kind) {
-        case "primitiveType":
-            return type.name;
-        case "literalType":
-            return `lit:${typeof type.value}:${String(type.value)}`;
-        case "referenceType":
-            if (type.typeArguments && type.typeArguments.length > 0) {
-                return `ref:${type.name}<${type.typeArguments.map(serializeType).join(",")}>`;
-            }
-            return `ref:${type.name}`;
-        case "arrayType":
-            return `arr:${serializeType(type.elementType)}`;
-        case "tupleType":
-            return `tup:[${type.elementTypes.map(serializeType).join(",")}]`;
-        case "functionType": {
-            const params = type.parameters
-                .map((p) => (p.type ? serializeType(p.type) : "any"))
-                .join(",");
-            return `fn:(${params})=>${serializeType(type.returnType)}`;
-        }
-        case "unionType":
-            return `union:[${type.types.map(serializeType).join("|")}]`;
-        case "typeParameterType":
-            return `tp:${type.name}`;
-        case "voidType":
-            return "void";
-        case "anyType":
-            return "any";
-        case "unknownType":
-            return "unknown";
-        case "neverType":
-            return "never";
-        case "objectType": {
-            // Serialize property signatures
-            const propMembers = type.members
-                .filter((m) => m.kind === "propertySignature")
-                .map((m) => `prop:${m.isReadonly ? "ro:" : ""}${m.name}${m.isOptional ? "?" : ""}:${serializeType(m.type)}`);
-            // Serialize method signatures
-            const methodMembers = type.members
-                .filter((m) => m.kind === "methodSignature")
-                .map((m) => {
-                const params = m.parameters
-                    .map((p) => (p.type ? serializeType(p.type) : "any"))
-                    .join(",");
-                const ret = m.returnType ? serializeType(m.returnType) : "void";
-                return `method:${m.name}(${params})=>${ret}`;
-            });
-            const allMembers = [...propMembers, ...methodMembers].sort().join(";");
-            return `obj:{${allMembers}}`;
-        }
-        case "dictionaryType":
-            return `dict:[${serializeType(type.keyType)}]:${serializeType(type.valueType)}`;
-        case "intersectionType":
-            return `intersection:[${type.types.map(serializeType).join("&")}]`;
-        default:
-            return "unknown";
-    }
-};
-/**
- * Compute shape signature for an objectType
- */
-const computeShapeSignature = (objectType) => {
-    return serializeType(objectType);
-};
-/**
- * Generate a short hash from shape signature
- */
-const generateShapeHash = (signature) => {
-    return createHash("md5").update(signature).digest("hex").slice(0, 8);
-};
-/**
- * Convert interface members to class property declarations
- */
-const interfaceMembersToClassMembers = (members) => {
-    return members
-        .filter((m) => m.kind === "propertySignature")
-        .map((m) => {
-        // For optional properties (title?: string), make type nullable and don't require
-        // For required properties (title: string), use required modifier
-        const isOptional = m.isOptional ?? false;
-        return {
-            kind: "propertyDeclaration",
-            name: m.name,
-            type: isOptional ? addUndefinedToType(m.type) : m.type,
-            initializer: undefined,
-            emitAsAutoProperty: true,
-            isStatic: false,
-            isReadonly: m.isReadonly ?? false,
-            accessibility: "public",
-            isRequired: !isOptional, // C# 11 required modifier - must be set in object initializer
-        };
-    });
-};
-/**
- * Generate a module-unique hash from file path
- */
-const generateModuleHash = (filePath) => {
-    return createHash("md5").update(filePath).digest("hex").slice(0, 4);
-};
-/**
- * Get or create a generated type name for an object type shape
- */
-const getOrCreateTypeName = (objectType, ctx) => {
-    const signature = computeShapeSignature(objectType);
-    const existing = ctx.shapeToName.get(signature);
-    if (existing) {
-        return existing;
-    }
-    // Generate name with module hash prefix to avoid collisions across modules
-    const moduleHash = generateModuleHash(ctx.moduleFilePath);
-    const shapeHash = generateShapeHash(signature);
-    // Keep a stable compiler-synthesized prefix for cross-module type tracking.
-    // Dependency/soundness passes treat __Anon_* as compiler-generated types.
-    const name = `__Anon_${moduleHash}_${shapeHash}`;
-    ctx.shapeToName.set(signature, name);
-    const typeParamNames = new Set();
-    for (const member of objectType.members) {
-        if (member.kind === "propertySignature") {
-            collectTypeParameterNames(member.type, typeParamNames);
-        }
-        else if (member.kind === "methodSignature") {
-            for (const p of member.parameters) {
-                if (p.type)
-                    collectTypeParameterNames(p.type, typeParamNames);
-            }
-            if (member.returnType)
-                collectTypeParameterNames(member.returnType, typeParamNames);
-        }
-    }
-    const orderedTypeParams = Array.from(typeParamNames).sort();
-    // Create a class declaration (not interface) so it can be instantiated
-    const declaration = {
-        kind: "classDeclaration",
-        name,
-        typeParameters: orderedTypeParams.length > 0
-            ? orderedTypeParams.map((tp) => ({
-                kind: "typeParameter",
-                name: tp,
-            }))
-            : undefined,
-        superClass: undefined,
-        implements: [],
-        members: interfaceMembersToClassMembers(objectType.members),
-        isExported: true, // Public to avoid inconsistent accessibility errors
-        isStruct: false,
-    };
-    ctx.generatedDeclarations.push(declaration);
-    return name;
-};
-const getOrCreateBehavioralObjectTypeName = (objectType, behaviorMembers, sourceLocation, ctx) => {
-    const moduleHash = generateModuleHash(ctx.moduleFilePath);
-    const locationKey = sourceLocation
-        ? `${sourceLocation.file}:${sourceLocation.line}:${sourceLocation.column}`
-        : `${ctx.moduleFilePath}:behavior`;
-    const behaviorSignature = [
-        "behavior",
-        locationKey,
-        computeShapeSignature(objectType),
-        ...behaviorMembers.map((member) => member.kind === "methodDeclaration"
-            ? `method:${member.name}`
-            : member.kind === "propertyDeclaration"
-                ? `property:${member.name}`
-                : `ctor:${member.parameters.length}`),
-    ].join("|");
-    const existing = ctx.shapeToName.get(behaviorSignature);
-    if (existing) {
-        return existing;
-    }
-    const name = `__Anon_${moduleHash}_${generateShapeHash(behaviorSignature)}`;
-    ctx.shapeToName.set(behaviorSignature, name);
-    const behaviorPropertyNames = new Set(behaviorMembers
-        .filter((member) => member.kind === "propertyDeclaration")
-        .map((member) => member.name));
-    const generatedMembers = [
-        ...interfaceMembersToClassMembers(objectType.members).filter((member) => member.kind !== "propertyDeclaration" ||
-            !behaviorPropertyNames.has(member.name)),
-        ...behaviorMembers,
-    ];
-    ctx.generatedDeclarations.push({
-        kind: "classDeclaration",
-        name,
-        typeParameters: undefined,
-        superClass: undefined,
-        implements: [],
-        members: generatedMembers,
-        isExported: true,
-        isStruct: false,
-    });
-    return name;
-};
-/**
- * Extract the non-undefined/null type from a union type.
- * For `T | undefined` or `T | null | undefined`, returns T.
- * For non-union types, returns the type as-is.
- */
-const stripNullishFromType = (type) => {
-    if (type.kind !== "unionType") {
-        return type;
-    }
-    const nonNullish = type.types.filter((t) => !(t.kind === "primitiveType" &&
-        (t.name === "undefined" || t.name === "null")));
-    if (nonNullish.length === 0) {
-        // All types were nullish, return original
-        return type;
-    }
-    if (nonNullish.length === type.types.length) {
-        // No nullish types were filtered
-        return type;
-    }
-    if (nonNullish.length === 1) {
-        // Safe: we checked length === 1
-        const first = nonNullish[0];
-        if (first !== undefined) {
-            return first;
-        }
-        return type;
-    }
-    // Return a new union with the filtered types
-    return { ...type, types: nonNullish };
-};
-/**
- * Ensure a type includes `undefined` (for optional members).
  *
- * Optional properties in TS (`foo?: T`) can carry optionality via a flag,
- * not as an explicit `T | undefined` union in IR. When we synthesize a named
- * type for an anonymous object, we must preserve optionality by materializing
- * `undefined` into the type.
- */
-const addUndefinedToType = (type) => {
-    const undefinedType = { kind: "primitiveType", name: "undefined" };
-    if (type.kind === "unionType") {
-        const hasUndefined = type.types.some((t) => t.kind === "primitiveType" && t.name === "undefined");
-        return hasUndefined
-            ? type
-            : { ...type, types: [...type.types, undefinedType] };
-    }
-    return { kind: "unionType", types: [type, undefinedType] };
-};
-/**
- * Lower a type, replacing objectType with referenceType
- */
-const lowerType = (type, ctx, _nameHint) => {
-    switch (type.kind) {
-        case "objectType": {
-            // First, recursively lower any nested object types in members
-            const loweredMembers = type.members.map((m) => {
-                if (m.kind === "propertySignature") {
-                    return {
-                        ...m,
-                        type: lowerType(m.type, ctx, m.name),
-                    };
-                }
-                else if (m.kind === "methodSignature") {
-                    return {
-                        ...m,
-                        parameters: m.parameters.map((p) => lowerParameter(p, ctx)),
-                        returnType: m.returnType ? lowerType(m.returnType, ctx) : undefined,
-                    };
-                }
-                return m;
-            });
-            const loweredObjectType = {
-                ...type,
-                members: loweredMembers,
-            };
-            // Generate name for this shape
-            const typeName = getOrCreateTypeName(loweredObjectType, ctx);
-            const typeParamNames = new Set();
-            for (const member of loweredObjectType.members) {
-                if (member.kind === "propertySignature") {
-                    collectTypeParameterNames(member.type, typeParamNames);
-                }
-                else if (member.kind === "methodSignature") {
-                    for (const p of member.parameters) {
-                        if (p.type)
-                            collectTypeParameterNames(p.type, typeParamNames);
-                    }
-                    if (member.returnType)
-                        collectTypeParameterNames(member.returnType, typeParamNames);
-                }
-            }
-            const orderedTypeParams = Array.from(typeParamNames).sort();
-            // Return reference to generated type
-            const refType = {
-                kind: "referenceType",
-                name: typeName,
-                typeArguments: orderedTypeParams.length > 0
-                    ? orderedTypeParams.map((tp) => ({
-                        kind: "typeParameterType",
-                        name: tp,
-                    }))
-                    : undefined,
-                resolvedClrType: undefined,
-                // Preserve structural members for downstream pattern lowering/type recovery.
-                structuralMembers: loweredObjectType.members,
-            };
-            return refType;
-        }
-        case "arrayType":
-            return {
-                ...type,
-                elementType: lowerType(type.elementType, ctx),
-            };
-        case "tupleType":
-            return {
-                ...type,
-                elementTypes: type.elementTypes.map((et) => lowerType(et, ctx)),
-            };
-        case "functionType":
-            return {
-                ...type,
-                parameters: type.parameters.map((p) => lowerParameter(p, ctx)),
-                returnType: lowerType(type.returnType, ctx),
-            };
-        case "unionType":
-            return {
-                ...type,
-                types: type.types.map((t) => lowerType(t, ctx)),
-            };
-        case "intersectionType":
-            return {
-                ...type,
-                types: type.types.map((t) => lowerType(t, ctx)),
-            };
-        case "dictionaryType":
-            return {
-                ...type,
-                keyType: lowerType(type.keyType, ctx),
-                valueType: lowerType(type.valueType, ctx),
-            };
-        case "referenceType": {
-            // Lower both typeArguments and structuralMembers
-            const typeArgs = type.typeArguments;
-            const structuralMembers = type.structuralMembers;
-            const hasTypeArgs = typeArgs !== undefined && typeArgs.length > 0;
-            const hasStructuralMembers = structuralMembers !== undefined && structuralMembers.length > 0;
-            if (!hasTypeArgs && !hasStructuralMembers) {
-                return type;
-            }
-            return {
-                ...type,
-                typeArguments: hasTypeArgs
-                    ? typeArgs.map((ta) => lowerType(ta, ctx))
-                    : undefined,
-                structuralMembers: hasStructuralMembers
-                    ? structuralMembers.map((m) => lowerInterfaceMember(m, ctx))
-                    : undefined,
-            };
-        }
-        // These types don't contain nested types
-        case "primitiveType":
-        case "literalType":
-        case "typeParameterType":
-        case "voidType":
-        case "anyType":
-        case "unknownType":
-        case "neverType":
-            return type;
-    }
-};
-/**
- * Lower a parameter
- */
-const lowerParameter = (param, ctx) => {
-    return {
-        ...param,
-        type: param.type ? lowerType(param.type, ctx) : undefined,
-        pattern: lowerPattern(param.pattern, ctx),
-        initializer: param.initializer
-            ? lowerExpression(param.initializer, ctx)
-            : undefined,
-    };
-};
-/**
- * Lower a type parameter
- */
-const lowerTypeParameter = (tp, ctx) => {
-    return {
-        ...tp,
-        constraint: tp.constraint ? lowerType(tp.constraint, ctx) : undefined,
-        default: tp.default ? lowerType(tp.default, ctx) : undefined,
-        structuralMembers: tp.structuralMembers?.map((m) => lowerInterfaceMember(m, ctx)),
-    };
-};
-/**
- * Lower an interface member
- *
- * IMPORTANT: We MUST lower objectType in all type positions before the emitter.
- * The emitter is not allowed to see IrObjectType nodes (soundness gate enforces this).
- */
-const lowerInterfaceMember = (member, ctx) => {
-    switch (member.kind) {
-        case "propertySignature": {
-            return {
-                ...member,
-                type: lowerType(member.type, ctx, member.name),
-            };
-        }
-        case "methodSignature":
-            return {
-                ...member,
-                typeParameters: member.typeParameters?.map((tp) => lowerTypeParameter(tp, ctx)),
-                parameters: member.parameters.map((p) => lowerParameter(p, ctx)),
-                returnType: member.returnType
-                    ? lowerType(member.returnType, ctx)
-                    : undefined,
-            };
-    }
-};
-/**
- * Lower a pattern
- */
-const lowerPattern = (pattern, ctx) => {
-    switch (pattern.kind) {
-        case "identifierPattern":
-            return {
-                ...pattern,
-                type: pattern.type ? lowerType(pattern.type, ctx) : undefined,
-            };
-        case "arrayPattern":
-            return {
-                ...pattern,
-                elements: pattern.elements.map((e) => e
-                    ? {
-                        ...e,
-                        pattern: lowerPattern(e.pattern, ctx),
-                        defaultExpr: e.defaultExpr
-                            ? lowerExpression(e.defaultExpr, ctx)
-                            : undefined,
-                    }
-                    : undefined),
-            };
-        case "objectPattern":
-            return {
-                ...pattern,
-                properties: pattern.properties.map((p) => {
-                    if (p.kind === "property") {
-                        return {
-                            ...p,
-                            value: lowerPattern(p.value, ctx),
-                            defaultExpr: p.defaultExpr
-                                ? lowerExpression(p.defaultExpr, ctx)
-                                : undefined,
-                        };
-                    }
-                    else {
-                        return {
-                            ...p,
-                            pattern: lowerPattern(p.pattern, ctx),
-                        };
-                    }
-                }),
-            };
-    }
-};
-/**
- * Lower an expression
- */
-const lowerExpression = (expr, ctx) => {
-    const lowered = (() => {
-        switch (expr.kind) {
-            case "literal":
-            case "this":
-                return expr;
-            case "identifier": {
-                // IMPORTANT: Only lower inferredType for identifiers that refer to a real declaration
-                // (locals/parameters). Imported CLR symbols often carry placeholder inferred types
-                // that are not part of emission and must not trigger anonymous type synthesis.
-                if (!expr.declId || !expr.inferredType)
-                    return expr;
-                if (expr.resolvedClrType || expr.resolvedAssembly || expr.importedFrom)
-                    return expr;
-                // Treat empty object types (`{}`) as `object`-like placeholders; do not synthesize.
-                if (expr.inferredType.kind === "objectType" &&
-                    expr.inferredType.members.length === 0) {
-                    return expr;
-                }
-                const loweredInferred = lowerType(expr.inferredType, ctx);
-                return loweredInferred === expr.inferredType
-                    ? expr
-                    : { ...expr, inferredType: loweredInferred };
-            }
-            case "array":
-                return {
-                    ...expr,
-                    inferredType: expr.inferredType
-                        ? lowerType(expr.inferredType, ctx)
-                        : undefined,
-                    elements: expr.elements.map((e) => e ? lowerExpression(e, ctx) : undefined),
-                };
-            case "object": {
-                const rawContextualType = expr.contextualType;
-                const rawInferredType = expr.inferredType;
-                const objectTypeForBehavior = (() => {
-                    if (rawContextualType?.kind === "objectType" &&
-                        rawContextualType.members.length > 0) {
-                        return rawContextualType;
-                    }
-                    if (rawInferredType?.kind === "objectType" &&
-                        rawInferredType.members.length > 0) {
-                        return rawInferredType;
-                    }
-                    return undefined;
-                })();
-                const loweredBehaviorMembers = expr.behaviorMembers?.map((member) => lowerClassMember(member, ctx));
-                const behaviorTypeName = objectTypeForBehavior &&
-                    loweredBehaviorMembers &&
-                    loweredBehaviorMembers.length > 0
-                    ? getOrCreateBehavioralObjectTypeName(objectTypeForBehavior, loweredBehaviorMembers, expr.sourceSpan, ctx)
-                    : undefined;
-                const loweredBehaviorType = behaviorTypeName !== undefined
-                    ? {
-                        kind: "referenceType",
-                        name: behaviorTypeName,
-                    }
-                    : undefined;
-                return {
-                    ...expr,
-                    behaviorMembers: loweredBehaviorMembers && loweredBehaviorMembers.length > 0
-                        ? loweredBehaviorMembers
-                        : undefined,
-                    inferredType: loweredBehaviorType
-                        ? loweredBehaviorType
-                        : expr.inferredType
-                            ? lowerType(expr.inferredType, ctx)
-                            : undefined,
-                    contextualType: loweredBehaviorType
-                        ? loweredBehaviorType
-                        : expr.contextualType
-                            ? lowerType(expr.contextualType, ctx)
-                            : undefined,
-                    properties: expr.properties.map((p) => {
-                        if (p.kind === "property") {
-                            return {
-                                ...p,
-                                key: typeof p.key === "string"
-                                    ? p.key
-                                    : lowerExpression(p.key, ctx),
-                                value: lowerExpression(p.value, ctx),
-                            };
-                        }
-                        else {
-                            return {
-                                ...p,
-                                expression: lowerExpression(p.expression, ctx),
-                            };
-                        }
-                    }),
-                };
-            }
-            case "functionExpression": {
-                const loweredParams = expr.parameters.map((p) => lowerParameter(p, ctx));
-                const loweredReturnType = expr.returnType
-                    ? lowerType(expr.returnType, ctx)
-                    : undefined;
-                const bodyCtx = {
-                    ...ctx,
-                    currentFunctionReturnType: loweredReturnType,
-                };
-                const loweredInferredType = expr.inferredType?.kind === "functionType"
-                    ? {
-                        ...expr.inferredType,
-                        parameters: loweredParams,
-                        returnType: loweredReturnType ??
-                            lowerType(expr.inferredType.returnType, ctx),
-                    }
-                    : expr.inferredType;
-                return {
-                    ...expr,
-                    parameters: loweredParams,
-                    returnType: loweredReturnType,
-                    body: lowerBlockStatement(expr.body, bodyCtx),
-                    inferredType: loweredInferredType,
-                };
-            }
-            case "arrowFunction": {
-                const loweredParams = expr.parameters.map((p) => lowerParameter(p, ctx));
-                const loweredReturnType = expr.returnType
-                    ? lowerType(expr.returnType, ctx)
-                    : undefined;
-                const bodyCtx = {
-                    ...ctx,
-                    currentFunctionReturnType: loweredReturnType,
-                };
-                const loweredInferredType = expr.inferredType?.kind === "functionType"
-                    ? {
-                        ...expr.inferredType,
-                        parameters: loweredParams,
-                        returnType: loweredReturnType ??
-                            lowerType(expr.inferredType.returnType, ctx),
-                    }
-                    : expr.inferredType;
-                // For expression body arrow functions, we need to handle inferredType directly
-                if (expr.body.kind === "blockStatement") {
-                    return {
-                        ...expr,
-                        parameters: loweredParams,
-                        returnType: loweredReturnType,
-                        body: lowerBlockStatement(expr.body, bodyCtx),
-                        inferredType: loweredInferredType,
-                    };
-                }
-                else {
-                    const loweredBody = lowerExpression(expr.body, ctx);
-                    // If arrow has expression body and return type, propagate to expression's inferredType
-                    const bodyWithType = loweredReturnType && loweredBody.inferredType?.kind === "objectType"
-                        ? { ...loweredBody, inferredType: loweredReturnType }
-                        : loweredBody;
-                    return {
-                        ...expr,
-                        parameters: loweredParams,
-                        returnType: loweredReturnType,
-                        body: bodyWithType,
-                        inferredType: loweredInferredType,
-                    };
-                }
-            }
-            case "memberAccess":
-                return {
-                    ...expr,
-                    object: lowerExpression(expr.object, ctx),
-                    property: typeof expr.property === "string"
-                        ? expr.property
-                        : lowerExpression(expr.property, ctx),
-                };
-            case "call":
-                return {
-                    ...expr,
-                    callee: lowerExpression(expr.callee, ctx),
-                    arguments: expr.arguments.map((a) => lowerExpression(a, ctx)),
-                    dynamicImportNamespace: expr.dynamicImportNamespace
-                        ? lowerExpression(expr.dynamicImportNamespace, ctx)
-                        : undefined,
-                    typeArguments: expr.typeArguments?.map((ta) => lowerType(ta, ctx)),
-                    // parameterTypes participate in expected-type threading during emission
-                    // (e.g., object literal contextual typing). They must be lowered so
-                    // IrObjectType never leaks into the emitter.
-                    parameterTypes: expr.parameterTypes?.map((pt) => pt ? lowerType(pt, ctx) : undefined),
-                    narrowing: expr.narrowing
-                        ? {
-                            ...expr.narrowing,
-                            targetType: lowerType(expr.narrowing.targetType, ctx),
-                        }
-                        : undefined,
-                };
-            case "new":
-                return {
-                    ...expr,
-                    callee: lowerExpression(expr.callee, ctx),
-                    arguments: expr.arguments.map((a) => lowerExpression(a, ctx)),
-                    typeArguments: expr.typeArguments?.map((ta) => lowerType(ta, ctx)),
-                    parameterTypes: expr.parameterTypes?.map((pt) => pt ? lowerType(pt, ctx) : undefined),
-                };
-            case "update":
-            case "unary":
-            case "await":
-                return {
-                    ...expr,
-                    expression: lowerExpression(expr.expression, ctx),
-                };
-            case "yield":
-                return {
-                    ...expr,
-                    expression: expr.expression
-                        ? lowerExpression(expr.expression, ctx)
-                        : undefined,
-                };
-            case "binary":
-            case "logical":
-                return {
-                    ...expr,
-                    left: lowerExpression(expr.left, ctx),
-                    right: lowerExpression(expr.right, ctx),
-                };
-            case "conditional":
-                return {
-                    ...expr,
-                    condition: lowerExpression(expr.condition, ctx),
-                    whenTrue: lowerExpression(expr.whenTrue, ctx),
-                    whenFalse: lowerExpression(expr.whenFalse, ctx),
-                };
-            case "assignment":
-                return {
-                    ...expr,
-                    left: expr.left.kind === "identifierPattern" ||
-                        expr.left.kind === "arrayPattern" ||
-                        expr.left.kind === "objectPattern"
-                        ? lowerPattern(expr.left, ctx)
-                        : lowerExpression(expr.left, ctx),
-                    right: lowerExpression(expr.right, ctx),
-                };
-            case "templateLiteral":
-                return {
-                    ...expr,
-                    expressions: expr.expressions.map((e) => lowerExpression(e, ctx)),
-                };
-            case "spread":
-                return {
-                    ...expr,
-                    expression: lowerExpression(expr.expression, ctx),
-                };
-            case "numericNarrowing":
-                return {
-                    ...expr,
-                    expression: lowerExpression(expr.expression, ctx),
-                    inferredType: lowerType(expr.inferredType, ctx),
-                };
-            case "typeAssertion":
-                return {
-                    ...expr,
-                    expression: lowerExpression(expr.expression, ctx),
-                    targetType: lowerType(expr.targetType, ctx),
-                    inferredType: lowerType(expr.inferredType, ctx),
-                };
-            case "asinterface":
-                return {
-                    ...expr,
-                    expression: lowerExpression(expr.expression, ctx),
-                    targetType: lowerType(expr.targetType, ctx),
-                    inferredType: lowerType(expr.inferredType, ctx),
-                };
-            case "trycast":
-                return {
-                    ...expr,
-                    expression: lowerExpression(expr.expression, ctx),
-                    targetType: lowerType(expr.targetType, ctx),
-                    inferredType: lowerType(expr.inferredType, ctx),
-                };
-            case "stackalloc":
-                return {
-                    ...expr,
-                    elementType: lowerType(expr.elementType, ctx),
-                    size: lowerExpression(expr.size, ctx),
-                    inferredType: lowerType(expr.inferredType, ctx),
-                };
-            case "defaultof":
-                return {
-                    ...expr,
-                    targetType: lowerType(expr.targetType, ctx),
-                    inferredType: lowerType(expr.inferredType, ctx),
-                };
-            case "nameof":
-                return expr;
-            case "sizeof":
-                return {
-                    ...expr,
-                    targetType: lowerType(expr.targetType, ctx),
-                    inferredType: lowerType(expr.inferredType, ctx),
-                };
-        }
-    })();
-    // Lower inferred/contextual metadata for all expression kinds so objectType
-    // cannot leak through metadata-only paths (e.g. call/member inferredType).
-    // Identifier expressions are handled explicitly above to avoid rewriting
-    // imported CLR/global placeholders.
-    if (lowered.kind !== "identifier") {
-        let nextExpr = lowered;
-        const inferredType = nextExpr.inferredType;
-        if (inferredType &&
-            !(inferredType.kind === "objectType" && inferredType.members.length === 0)) {
-            const loweredInferred = lowerType(inferredType, ctx);
-            if (loweredInferred !== inferredType) {
-                nextExpr = { ...nextExpr, inferredType: loweredInferred };
-            }
-        }
-        if ("contextualType" in nextExpr) {
-            const contextualExpr = nextExpr;
-            const contextualType = contextualExpr.contextualType;
-            if (contextualType &&
-                !(contextualType.kind === "objectType" &&
-                    contextualType.members.length === 0)) {
-                const loweredContextual = lowerType(contextualType, ctx);
-                if (loweredContextual !== contextualType) {
-                    nextExpr = {
-                        ...contextualExpr,
-                        contextualType: loweredContextual,
-                    };
-                }
-            }
-        }
-        return nextExpr;
-    }
-    return lowered;
-};
-/**
- * Lower a block statement specifically (for places that need IrBlockStatement)
- */
-const lowerBlockStatement = (stmt, ctx) => {
-    return {
-        ...stmt,
-        statements: stmt.statements.map((s) => lowerStatement(s, ctx)),
-    };
-};
-/**
- * Lower a variable declaration specifically (for forStatement initializer)
- */
-const lowerVariableDeclaration = (stmt, ctx) => {
-    return {
-        ...stmt,
-        declarations: stmt.declarations.map((d) => ({
-            ...d,
-            name: lowerPattern(d.name, ctx),
-            type: d.type ? lowerType(d.type, ctx) : undefined,
-            initializer: d.initializer
-                ? lowerExpression(d.initializer, ctx)
-                : undefined,
-        })),
-    };
-};
-/**
- * Lower a class member
+ * Implementation is split across sub-modules:
+ * - anon-type-shape-analysis.ts: serialization, hashing, reachability
+ * - anon-type-declaration-synthesis.ts: named type generation, carrier reuse
+ * - anon-type-lower-types.ts: type/param/pattern lowering + LoweringContext
+ * - anon-type-ir-rewriting.ts: expression/statement/member lowering
  */
-const lowerClassMember = (member, ctx) => {
-    switch (member.kind) {
-        case "methodDeclaration": {
-            const loweredReturnType = member.returnType
-                ? lowerType(member.returnType, ctx)
-                : undefined;
-            const bodyCtx = {
-                ...ctx,
-                currentFunctionReturnType: loweredReturnType,
-            };
-            return {
-                ...member,
-                typeParameters: member.typeParameters?.map((tp) => lowerTypeParameter(tp, ctx)),
-                parameters: member.parameters.map((p) => lowerParameter(p, ctx)),
-                returnType: loweredReturnType,
-                body: member.body
-                    ? lowerBlockStatement(member.body, bodyCtx)
-                    : undefined,
-            };
-        }
-        case "propertyDeclaration":
-            return {
-                ...member,
-                type: member.type
-                    ? lowerType(member.type, ctx, member.name)
-                    : undefined,
-                initializer: member.initializer
-                    ? lowerExpression(member.initializer, ctx)
-                    : undefined,
-                getterBody: member.getterBody
-                    ? lowerBlockStatement(member.getterBody, ctx)
-                    : undefined,
-                setterBody: member.setterBody
-                    ? lowerBlockStatement(member.setterBody, ctx)
-                    : undefined,
-            };
-        case "constructorDeclaration":
-            return {
-                ...member,
-                parameters: member.parameters.map((p) => lowerParameter(p, ctx)),
-                body: member.body ? lowerBlockStatement(member.body, ctx) : undefined,
-            };
-    }
-};
-/**
- * Lower a statement
- */
-const lowerStatement = (stmt, ctx) => {
-    switch (stmt.kind) {
-        case "variableDeclaration":
-            return {
-                ...stmt,
-                declarations: stmt.declarations.map((d) => ({
-                    ...d,
-                    name: lowerPattern(d.name, ctx),
-                    type: d.type ? lowerType(d.type, ctx) : undefined,
-                    initializer: d.initializer
-                        ? lowerExpression(d.initializer, ctx)
-                        : undefined,
-                })),
-            };
-        case "functionDeclaration": {
-            // First lower the return type
-            const loweredReturnType = stmt.returnType
-                ? lowerType(stmt.returnType, ctx)
-                : undefined;
-            // Create context with the lowered return type for return statements
-            const bodyCtx = {
-                ...ctx,
-                currentFunctionReturnType: loweredReturnType,
-            };
-            return {
-                ...stmt,
-                typeParameters: stmt.typeParameters?.map((tp) => lowerTypeParameter(tp, ctx)),
-                parameters: stmt.parameters.map((p) => lowerParameter(p, ctx)),
-                returnType: loweredReturnType,
-                body: lowerBlockStatement(stmt.body, bodyCtx),
-            };
-        }
-        case "classDeclaration":
-            return {
-                ...stmt,
-                typeParameters: stmt.typeParameters?.map((tp) => lowerTypeParameter(tp, ctx)),
-                superClass: stmt.superClass
-                    ? lowerType(stmt.superClass, ctx)
-                    : undefined,
-                implements: stmt.implements.map((i) => lowerType(i, ctx)),
-                members: stmt.members.map((m) => lowerClassMember(m, ctx)),
-            };
-        case "interfaceDeclaration":
-            return {
-                ...stmt,
-                typeParameters: stmt.typeParameters?.map((tp) => lowerTypeParameter(tp, ctx)),
-                extends: stmt.extends.map((e) => lowerType(e, ctx)),
-                members: stmt.members.map((m) => lowerInterfaceMember(m, ctx)),
-            };
-        case "enumDeclaration":
-            return {
-                ...stmt,
-                members: stmt.members.map((m) => ({
-                    ...m,
-                    initializer: m.initializer
-                        ? lowerExpression(m.initializer, ctx)
-                        : undefined,
-                })),
-            };
-        case "typeAliasDeclaration":
-            // IMPORTANT: Do NOT lower the top-level objectType in a type alias declaration.
-            // The emitter already generates a class with __Alias suffix for these.
-            // We only lower nested objectTypes within the members.
-            if (stmt.type.kind === "objectType") {
-                // Lower nested types within the object type's members, but keep objectType as-is
-                const loweredMembers = stmt.type.members.map((m) => {
-                    if (m.kind === "propertySignature") {
-                        return {
-                            ...m,
-                            type: lowerType(m.type, ctx),
-                        };
-                    }
-                    else if (m.kind === "methodSignature") {
-                        return {
-                            ...m,
-                            parameters: m.parameters.map((p) => lowerParameter(p, ctx)),
-                            returnType: m.returnType
-                                ? lowerType(m.returnType, ctx)
-                                : undefined,
-                        };
-                    }
-                    return m;
-                });
-                return {
-                    ...stmt,
-                    typeParameters: stmt.typeParameters?.map((tp) => lowerTypeParameter(tp, ctx)),
-                    type: {
-                        ...stmt.type,
-                        members: loweredMembers,
-                    },
-                };
-            }
-            // For non-objectType type aliases, lower the type normally
-            return {
-                ...stmt,
-                typeParameters: stmt.typeParameters?.map((tp) => lowerTypeParameter(tp, ctx)),
-                type: lowerType(stmt.type, ctx),
-            };
-        case "expressionStatement":
-            return {
-                ...stmt,
-                expression: lowerExpression(stmt.expression, ctx),
-            };
-        case "returnStatement": {
-            if (!stmt.expression) {
-                return stmt;
-            }
-            const loweredExpr = lowerExpression(stmt.expression, ctx);
-            // If we have a function return type and the expression's inferredType is objectType,
-            // replace it with the lowered type (stripping nullish from union if needed)
-            if (ctx.currentFunctionReturnType &&
-                loweredExpr.inferredType?.kind === "objectType") {
-                // Extract non-nullish part of return type (e.g., { title: string } from { title: string } | undefined)
-                const targetType = stripNullishFromType(ctx.currentFunctionReturnType);
-                return {
-                    ...stmt,
-                    expression: { ...loweredExpr, inferredType: targetType },
-                };
-            }
-            return {
-                ...stmt,
-                expression: loweredExpr,
-            };
-        }
-        case "ifStatement":
-            return {
-                ...stmt,
-                condition: lowerExpression(stmt.condition, ctx),
-                thenStatement: lowerStatement(stmt.thenStatement, ctx),
-                elseStatement: stmt.elseStatement
-                    ? lowerStatement(stmt.elseStatement, ctx)
-                    : undefined,
-            };
-        case "whileStatement":
-            return {
-                ...stmt,
-                condition: lowerExpression(stmt.condition, ctx),
-                body: lowerStatement(stmt.body, ctx),
-            };
-        case "forStatement":
-            return {
-                ...stmt,
-                initializer: stmt.initializer
-                    ? stmt.initializer.kind === "variableDeclaration"
-                        ? lowerVariableDeclaration(stmt.initializer, ctx)
-                        : lowerExpression(stmt.initializer, ctx)
-                    : undefined,
-                condition: stmt.condition
-                    ? lowerExpression(stmt.condition, ctx)
-                    : undefined,
-                update: stmt.update ? lowerExpression(stmt.update, ctx) : undefined,
-                body: lowerStatement(stmt.body, ctx),
-            };
-        case "forOfStatement":
-            return {
-                ...stmt,
-                variable: lowerPattern(stmt.variable, ctx),
-                expression: lowerExpression(stmt.expression, ctx),
-                body: lowerStatement(stmt.body, ctx),
-            };
-        case "forInStatement":
-            return {
-                ...stmt,
-                variable: lowerPattern(stmt.variable, ctx),
-                expression: lowerExpression(stmt.expression, ctx),
-                body: lowerStatement(stmt.body, ctx),
-            };
-        case "switchStatement":
-            return {
-                ...stmt,
-                expression: lowerExpression(stmt.expression, ctx),
-                cases: stmt.cases.map((c) => ({
-                    ...c,
-                    test: c.test ? lowerExpression(c.test, ctx) : undefined,
-                    statements: c.statements.map((s) => lowerStatement(s, ctx)),
-                })),
-            };
-        case "throwStatement":
-            return {
-                ...stmt,
-                expression: lowerExpression(stmt.expression, ctx),
-            };
-        case "tryStatement":
-            return {
-                ...stmt,
-                tryBlock: lowerBlockStatement(stmt.tryBlock, ctx),
-                catchClause: stmt.catchClause
-                    ? {
-                        ...stmt.catchClause,
-                        parameter: stmt.catchClause.parameter
-                            ? lowerPattern(stmt.catchClause.parameter, ctx)
-                            : undefined,
-                        body: lowerBlockStatement(stmt.catchClause.body, ctx),
-                    }
-                    : undefined,
-                finallyBlock: stmt.finallyBlock
-                    ? lowerBlockStatement(stmt.finallyBlock, ctx)
-                    : undefined,
-            };
-        case "blockStatement":
-            return {
-                ...stmt,
-                statements: stmt.statements.map((s) => lowerStatement(s, ctx)),
-            };
-        case "yieldStatement":
-            return {
-                ...stmt,
-                output: stmt.output ? lowerExpression(stmt.output, ctx) : undefined,
-                receiveTarget: stmt.receiveTarget
-                    ? lowerPattern(stmt.receiveTarget, ctx)
-                    : undefined,
-                receivedType: stmt.receivedType
-                    ? lowerType(stmt.receivedType, ctx)
-                    : undefined,
-            };
-        case "generatorReturnStatement":
-            return {
-                ...stmt,
-                expression: stmt.expression
-                    ? lowerExpression(stmt.expression, ctx)
-                    : undefined,
-            };
-        case "breakStatement":
-        case "continueStatement":
-        case "emptyStatement":
-            return stmt;
-    }
-};
+import { computeShapeSignature, collectPubliclyReachableAnonymousTypes, } from "./anon-type-shape-analysis.js";
+import { classMembersToInterfaceMembers, interfaceMembersToClassMembers, isReusableStructuralCarrierName, } from "./anon-type-declaration-synthesis.js";
+import { lowerExpression, lowerStatement } from "./anon-type-ir-rewriting.js";
+const SYNTHETIC_ANONYMOUS_TYPES_FILE_PATH = "__tsonic/__tsonic_anonymous_types.g.ts";
 /**
  * Lower a single module
  */
 const lowerModule = (module, shared) => {
+    const localDeclaredTypeReferences = collectLocalDeclaredTypeReferences(module);
     const ctx = {
         generatedDeclarations: shared.generatedDeclarations,
         shapeToName: shared.shapeToName,
+        shapeToExistingReference: shared.shapeToExistingReference,
+        localDeclaredTypeReferences,
         moduleFilePath: module.filePath,
         existingTypeNames: shared.existingTypeNames,
+        loweredTypeByIdentity: shared.loweredTypeByIdentity,
+        loweredReferenceByStableKey: shared.loweredReferenceByStableKey,
     };
     // Lower all statements in the module body
     const loweredBody = module.body.map((stmt) => lowerStatement(stmt, ctx));
@@ -1211,6 +66,29 @@ const lowerModule = (module, shared) => {
         exports: loweredExports,
     };
 };
+const collectLocalDeclaredTypeReferences = (module) => {
+    const references = new Map();
+    for (const stmt of module.body) {
+        switch (stmt.kind) {
+            case "classDeclaration":
+            case "interfaceDeclaration":
+            case "enumDeclaration":
+                references.set(stmt.name, {
+                    kind: "referenceType",
+                    name: stmt.name,
+                    resolvedClrType: `${module.namespace}.${stmt.name}`,
+                    typeArguments: "typeParameters" in stmt
+                        ? stmt.typeParameters?.map((parameter) => ({
+                            kind: "typeParameterType",
+                            name: parameter.name,
+                        }))
+                        : undefined,
+                });
+                break;
+        }
+    }
+    return references;
+};
 const findCommonNamespacePrefix = (namespaces) => {
     if (namespaces.length === 0)
         return "";
@@ -1229,44 +107,315 @@ const findCommonNamespacePrefix = (namespaces) => {
     }
     return first.slice(0, commonLength).join(".");
 };
+const isInstalledDependencyModule = (filePath) => filePath.includes("/node_modules/") || filePath.startsWith("node_modules/");
+const isAnonymousReferenceType = (value) => {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const record = value;
+    return (record.kind === "referenceType" &&
+        typeof record.name === "string" &&
+        record.name.startsWith("__Anon_") &&
+        Array.isArray(record.structuralMembers) &&
+        record.structuralMembers.length > 0);
+};
+const registerExistingAnonymousReference = (type, shapeToExistingReference) => {
+    const signature = computeShapeSignature({
+        kind: "objectType",
+        members: type.structuralMembers,
+    });
+    const resolvedClrType = type.resolvedClrType ?? type.typeId?.clrName ?? undefined;
+    const existing = shapeToExistingReference.get(signature);
+    if (existing &&
+        existing.resolvedClrType !== undefined &&
+        resolvedClrType === undefined) {
+        return;
+    }
+    shapeToExistingReference.set(signature, {
+        kind: "referenceType",
+        name: type.name,
+        typeArguments: type.typeArguments,
+        resolvedClrType,
+        structuralMembers: type.structuralMembers,
+    });
+};
+const collectExistingAnonymousReferences = (value, shapeToExistingReference, seen) => {
+    if (!value || typeof value !== "object") {
+        return;
+    }
+    if (seen.has(value)) {
+        return;
+    }
+    seen.add(value);
+    if (isAnonymousReferenceType(value)) {
+        registerExistingAnonymousReference(value, shapeToExistingReference);
+    }
+    const asRecord = value;
+    if (asRecord.kind === "referenceType") {
+        const typeArguments = Array.isArray(asRecord.typeArguments)
+            ? asRecord.typeArguments
+            : undefined;
+        if (typeArguments) {
+            for (const argument of typeArguments) {
+                collectExistingAnonymousReferences(argument, shapeToExistingReference, seen);
+            }
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            collectExistingAnonymousReferences(entry, shapeToExistingReference, seen);
+        }
+        return;
+    }
+    for (const entry of Object.values(value)) {
+        collectExistingAnonymousReferences(entry, shapeToExistingReference, seen);
+    }
+};
+const collectAnonymousReferenceDeclarations = (value, declarationsByName, seen) => {
+    if (!value || typeof value !== "object") {
+        return;
+    }
+    if (seen.has(value)) {
+        return;
+    }
+    seen.add(value);
+    if (isAnonymousReferenceType(value) && value.resolvedClrType === undefined) {
+        if (!declarationsByName.has(value.name)) {
+            declarationsByName.set(value.name, {
+                kind: "classDeclaration",
+                name: value.name,
+                typeParameters: value.typeArguments
+                    ?.filter((argument) => argument.kind === "typeParameterType")
+                    .map((argument) => ({
+                    kind: "typeParameter",
+                    name: argument.name,
+                })) ?? undefined,
+                superClass: undefined,
+                implements: [],
+                members: interfaceMembersToClassMembers(value.structuralMembers),
+                isExported: true,
+                isStruct: false,
+            });
+        }
+    }
+    const asRecord = value;
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            collectAnonymousReferenceDeclarations(entry, declarationsByName, seen);
+        }
+        return;
+    }
+    for (const entry of Object.values(asRecord)) {
+        collectAnonymousReferenceDeclarations(entry, declarationsByName, seen);
+    }
+};
+const collectReferencedAnonymousTypeNames = (value, referencedNames, seen, includeInferredTypeMetadata = false) => {
+    if (!value || typeof value !== "object") {
+        return;
+    }
+    if (seen.has(value)) {
+        return;
+    }
+    seen.add(value);
+    const asReference = value;
+    if (asReference.kind === "referenceType" &&
+        typeof asReference.name === "string" &&
+        asReference.name.startsWith("__Anon_")) {
+        referencedNames.add(asReference.name);
+    }
+    const asModule = value;
+    if (asModule.kind === "module") {
+        for (const entry of asModule.body ?? []) {
+            collectReferencedAnonymousTypeNames(entry, referencedNames, seen, includeInferredTypeMetadata);
+        }
+        for (const entry of asModule.exports ?? []) {
+            collectReferencedAnonymousTypeNames(entry, referencedNames, seen, includeInferredTypeMetadata);
+        }
+        return;
+    }
+    const asObjectExpression = value;
+    if (asObjectExpression.kind === "object") {
+        collectReferencedAnonymousTypeNames(asObjectExpression.inferredType, referencedNames, seen, includeInferredTypeMetadata);
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            collectReferencedAnonymousTypeNames(entry, referencedNames, seen, includeInferredTypeMetadata);
+        }
+        return;
+    }
+    for (const [key, entry] of Object.entries(value)) {
+        if (key === "inferredType" &&
+            !includeInferredTypeMetadata &&
+            !shouldTraverseInferredTypeMetadata(value, entry)) {
+            continue;
+        }
+        collectReferencedAnonymousTypeNames(entry, referencedNames, seen, includeInferredTypeMetadata);
+    }
+};
+const shouldTraverseInferredTypeMetadata = (owner, inferredType) => {
+    if (!containsAnonymousReferenceType(inferredType, new WeakSet())) {
+        return false;
+    }
+    if (!owner || typeof owner !== "object") {
+        return true;
+    }
+    const record = owner;
+    if (record.kind === "identifier" &&
+        (record.importedFrom !== undefined ||
+            record.resolvedClrType !== undefined ||
+            record.resolvedAssembly !== undefined ||
+            (typeof record.originalName === "string" &&
+                record.originalName.startsWith('"') &&
+                record.originalName.endsWith('"')))) {
+        return false;
+    }
+    return true;
+};
+const containsAnonymousReferenceType = (value, seen) => {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    if (seen.has(value)) {
+        return false;
+    }
+    seen.add(value);
+    if (isAnonymousReferenceType(value)) {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.some((entry) => containsAnonymousReferenceType(entry, seen));
+    }
+    return Object.values(value).some((entry) => containsAnonymousReferenceType(entry, seen));
+};
+const collectPriorSyntheticAnonymousDeclarations = (modules) => modules
+    .filter((module) => module.filePath === SYNTHETIC_ANONYMOUS_TYPES_FILE_PATH)
+    .flatMap((module) => module.body.filter((statement) => statement.kind === "classDeclaration" &&
+    statement.name.startsWith("__Anon_")));
 /**
  * Run anonymous type lowering pass on all modules
  */
 export const runAnonymousTypeLoweringPass = (modules) => {
+    const priorSyntheticAnonymousDeclarations = collectPriorSyntheticAnonymousDeclarations(modules);
+    const inputModules = modules.filter((module) => module.filePath !== SYNTHETIC_ANONYMOUS_TYPES_FILE_PATH);
     const existingTypeNames = new Set();
-    for (const module of modules) {
+    const shapeToExistingReference = new Map();
+    const existingReferenceTraversalSeen = new WeakSet();
+    for (const module of inputModules) {
         for (const stmt of module.body) {
             switch (stmt.kind) {
                 case "classDeclaration":
+                    if (isReusableStructuralCarrierName(stmt.name)) {
+                        const members = classMembersToInterfaceMembers(stmt.members);
+                        if (members.length > 0) {
+                            registerExistingAnonymousReference({
+                                kind: "referenceType",
+                                name: stmt.name,
+                                typeArguments: stmt.typeParameters?.map((parameter) => ({
+                                    kind: "typeParameterType",
+                                    name: parameter.name,
+                                })) ?? undefined,
+                                resolvedClrType: `${module.namespace}.${stmt.name}`,
+                                structuralMembers: members,
+                            }, shapeToExistingReference);
+                        }
+                    }
+                    existingTypeNames.add(stmt.name);
+                    break;
                 case "interfaceDeclaration":
+                    if (isReusableStructuralCarrierName(stmt.name)) {
+                        registerExistingAnonymousReference({
+                            kind: "referenceType",
+                            name: stmt.name,
+                            typeArguments: stmt.typeParameters?.map((parameter) => ({
+                                kind: "typeParameterType",
+                                name: parameter.name,
+                            })) ?? undefined,
+                            resolvedClrType: `${module.namespace}.${stmt.name}`,
+                            structuralMembers: stmt.members,
+                        }, shapeToExistingReference);
+                    }
+                    existingTypeNames.add(stmt.name);
+                    break;
                 case "enumDeclaration":
                 case "typeAliasDeclaration":
                     existingTypeNames.add(stmt.name);
                     break;
             }
         }
+        collectExistingAnonymousReferences(module, shapeToExistingReference, existingReferenceTraversalSeen);
     }
     const shared = {
         generatedDeclarations: [],
         shapeToName: new Map(),
+        shapeToExistingReference,
         existingTypeNames,
+        loweredTypeByIdentity: new WeakMap(),
+        loweredReferenceByStableKey: new Map(),
     };
-    const loweredModules = modules.map((m) => lowerModule(m, shared));
+    const loweredModules = inputModules.map((m) => lowerModule(m, shared));
+    const recoveredAnonymousDeclarations = new Map();
+    const recoveredDeclarationTraversalSeen = new WeakSet();
+    for (const module of loweredModules) {
+        collectAnonymousReferenceDeclarations(module, recoveredAnonymousDeclarations, recoveredDeclarationTraversalSeen);
+    }
+    for (const declaration of priorSyntheticAnonymousDeclarations) {
+        recoveredAnonymousDeclarations.set(declaration.name, declaration);
+    }
+    for (const declaration of shared.generatedDeclarations) {
+        recoveredAnonymousDeclarations.set(declaration.name, declaration);
+    }
+    const allAnonymousDeclarations = Array.from(recoveredAnonymousDeclarations.values());
+    const referencedAnonymousNames = new Set();
+    const referencedNameTraversalSeen = new WeakSet();
+    for (const module of loweredModules) {
+        collectReferencedAnonymousTypeNames(module, referencedAnonymousNames, referencedNameTraversalSeen, false);
+    }
+    const anonymousDeclarationByName = new Map(allAnonymousDeclarations.map((declaration) => [
+        declaration.name,
+        declaration,
+    ]));
+    const declarationQueue = Array.from(referencedAnonymousNames);
+    while (declarationQueue.length > 0) {
+        const name = declarationQueue.shift();
+        if (!name) {
+            continue;
+        }
+        const declaration = anonymousDeclarationByName.get(name);
+        if (!declaration) {
+            continue;
+        }
+        const nestedNames = new Set();
+        collectReferencedAnonymousTypeNames(declaration, nestedNames, new WeakSet(), true);
+        for (const nestedName of nestedNames) {
+            if (referencedAnonymousNames.has(nestedName)) {
+                continue;
+            }
+            referencedAnonymousNames.add(nestedName);
+            declarationQueue.push(nestedName);
+        }
+    }
+    const emittedAnonymousDeclarations = allAnonymousDeclarations.filter((declaration) => referencedAnonymousNames.has(declaration.name));
     // If any anonymous classes were generated, emit them once in a shared module
     // in the common root namespace so they are visible to all nested namespaces.
-    if (shared.generatedDeclarations.length > 0) {
-        const commonNamespace = findCommonNamespacePrefix(modules.map((m) => m.namespace)) ||
-            (modules[0]?.namespace ?? "");
+    if (emittedAnonymousDeclarations.length > 0) {
+        const publicAnonymousTypes = collectPubliclyReachableAnonymousTypes(loweredModules, emittedAnonymousDeclarations);
+        const authoredModules = inputModules.filter((module) => !isInstalledDependencyModule(module.filePath));
+        const namespaceSeedModules = authoredModules.length > 0 ? authoredModules : inputModules;
+        const commonNamespace = findCommonNamespacePrefix(namespaceSeedModules.map((module) => module.namespace));
         const anonModule = {
             kind: "module",
             // Special synthetic module prefix: downstream CLI code uses this to skip
             // source-based augmentation steps (no corresponding .ts file exists).
-            filePath: "__tsonic/__tsonic_anonymous_types.g.ts",
+            filePath: SYNTHETIC_ANONYMOUS_TYPES_FILE_PATH,
             namespace: commonNamespace,
             className: "__tsonic_anonymous_types",
             isStaticContainer: true,
             imports: [],
-            body: shared.generatedDeclarations,
+            body: emittedAnonymousDeclarations.map((declaration) => ({
+                ...declaration,
+                isExported: publicAnonymousTypes.has(declaration.name),
+            })),
             exports: [],
         };
         return {