@flighthq/tool-compiler 0.5.1-edge.1687.b63c819

package/dist/packages/compiler-backend-rs/src/rustCompilerBackend.js

@@ -0,0 +1,4555 @@
+import path from 'node:path';
+import { analyzeIrModuleClosureEvidence } from '../../compiler-closure/src/index.js';
+import { collectIrModuleNullableBindingIds, createBackendEmissionFailure, createCompilerGeneratedFileHeader, createIrModuleTargetNameAllocation, getIrUnionTypeStringLiteralValues, hasIrTypeAbsentMember, indentSourceLines, normalizeSourceTextGrouping, isCompilerTargetNameAllocationFailure, } from '../../compiler-emission/src/index.js';
+import { analyzeIrModuleTraversal, analyzeIrStatementSubtreeTraversal, getIrModuleTraversalPathValue, } from '../../compiler-ir-traversal/src/index.js';
+import { createIrClassInitializationPlan, createCompilerLoweringPassAwaitConditionHoisting, createCompilerLoweringPassBindingPattern, createCompilerLoweringPassCStyleFor, createCompilerLoweringPassExtraArgumentErasure, createCompilerLoweringPassInterfaceInheritance, createCompilerLoweringPassSwitchFallthrough, createCompilerLoweringPassSwitchSuspension, createCompilerLoweringPassVariableHoisting, lowerIrModuleWithCompilerPasses, } from '../../compiler-lowering/src/index.js';
+import { analyzeCompilerRuntimeExternalConstructorAbiCompleteness, analyzeCompilerRuntimeExternalSymbolCompleteness, collectIrModulesRuntimeExternalConstructorInvocations, collectIrModulesRuntimeExternalSymbolIdentities, } from '../../compiler-runtime-contract/src/index.js';
+import { analyzeIrModuleStructuralObjectCompatibilityAcrossModules, analyzeIrTypeStructuralAssignability, createIrObjectTypeShapeIdentity, createIrTypeParameterSubstitutionPlan, isCompilerStructuralTypeSubstitutionFailure, resolveIrTypeStructuralSubstitution, } from '../../compiler-structural/src/index.js';
+import { analyzeIrModuleAsyncStateMachines } from '../../compiler-task/src/index.js';
+import { getCompilerRustAmbientMemberBinding } from './rustAmbientMemberBinding.js';
+import { convertPackageNameToRustCrateName, convertSourcePathToRustModuleName, isRustCompilerKeyword, } from './rustCompilerIdentity.js';
+import { analyzeIrModuleOwnershipEvidenceRust, collectIrModuleMovedBindingIdsRust, collectIrModuleReferentMutatedParameterIdsRust, } from './rustOwnershipEvidence.js';
+import { createCompilerRuntimeExternalConstructorAbiPlanRust } from './rustRuntimeExternalConstructorAbi.js';
+import { createCompilerRuntimeExternalSymbolBindingPlanRust, getCompilerRuntimeExternalMemberTargetRust, getCompilerRuntimeExternalSymbolTargetRust, isCompilerRuntimeExternalSymbolProvidedRust, } from './rustRuntimeExternalSymbolBinding.js';
+export function createRustCompilerBackend() {
+    return {
+        emitModule(module, { moduleResolution, modules, options }) {
+            return [emitIrModuleRustWithContext(module, modules, moduleResolution, options)];
+        },
+        name: 'rust',
+    };
+}
+export function emitIrModuleRust(sourceModule, options = {}) {
+    return emitIrModuleRustWithContext(sourceModule, [sourceModule], undefined, options);
+}
+function createCompilerLoweringPassInterfaceInheritanceRust(modules, moduleResolution) {
+    return createCompilerLoweringPassInterfaceInheritance(modules, moduleResolution, {
+        // TypeScript has already materialized every selected ambient member on the interface. The
+        // shared pass verifies that evidence before it erases the otherwise nonlocal DOM heritage.
+        eraseAmbientUtilityHeritage: (reference) => reference.reference.kind === 'ambient' && reference.reference.name === 'Pick',
+    });
+}
+function emitIrModuleRustWithContext(sourceModule, sourceModules, moduleResolution, options) {
+    const module = lowerIrModuleWithCompilerPasses(sourceModule, [
+        createCompilerLoweringPassExtraArgumentErasure(),
+        createCompilerLoweringPassAwaitConditionHoisting(),
+        createCompilerLoweringPassBindingPattern(),
+        createCompilerLoweringPassVariableHoisting(),
+        createCompilerLoweringPassCStyleFor(),
+        createCompilerLoweringPassInterfaceInheritanceRust(sourceModules, moduleResolution),
+        createCompilerLoweringPassSwitchFallthrough(),
+        createCompilerLoweringPassSwitchSuspension(),
+    ]);
+    assertStructuralObjectCompatibilityRust(module, replaceIrModuleBackendContext(sourceModules, module), moduleResolution);
+    assertRuntimeExternalSymbolBindingsRust(module, options);
+    assertRuntimeExternalConstructorAbiRust(module);
+    const asyncAnalysis = analyzeIrModuleAsyncStateMachines(module);
+    const asyncTryStatements = collectAsyncTryStatementsRust(module, asyncAnalysis);
+    const constantIdentities = new Set(module.declarations.flatMap((declaration) => declaration.kind === 'variable' && !declaration.mutable && !('pattern' in declaration)
+        ? [declaration.binding.id]
+        : []));
+    let targetNames;
+    try {
+        targetNames = new Map(createIrModuleTargetNameAllocation(module, (binding) => ({
+            namespace: 'identifier',
+            preferredName: getPreferredBindingNameRust(binding, constantIdentities),
+        })).map((allocation) => [allocation.identity, allocation.name]));
+    }
+    catch (error) {
+        if (isCompilerTargetNameAllocationFailure(error)) {
+            throw createBackendEmissionFailure('rust', module, `public declarations share fixed Rust target name ${error.targetName}`);
+        }
+        throw error;
+    }
+    const closureEvidence = analyzeIrModuleClosureEvidence(module);
+    const bindingTypes = collectIrModuleBindingTypesRust(module);
+    const allCellWrappedIds = closureEvidence.closures
+        .filter((closure) => closure.origin.kind === 'functionExpression' &&
+        !closure.valueUses.every((use) => use.kind === 'directInvocation'))
+        .flatMap((closure) => closure.captures.filter((capture) => capture.mutation !== 'none').map((capture) => capture.binding.id));
+    const cellWrappedBindingIds = new Set(allCellWrappedIds.filter((id) => {
+        const type = bindingTypes.get(id);
+        return !type || isIrTypeCopyRust(type);
+    }));
+    const refCellWrappedBindingIds = new Set(allCellWrappedIds.filter((id) => {
+        const type = bindingTypes.get(id);
+        return type !== undefined && !isIrTypeCopyRust(type);
+    }));
+    const accessorClassNames = new Map();
+    const classBindingNames = new Map();
+    const borrowedParameterPositions = new Map();
+    const primitiveUnionEnums = new Map();
+    const primitiveUnionBindingIds = new Map();
+    const taggedUnionBindingNames = new Map();
+    const numericEnumNamespaceNames = new Map(module.declarations.flatMap((declaration) => declaration.kind === 'enum' && getIrEnumNamespaceFunctionsRust(declaration, module).length > 0
+        ? [
+            [
+                declaration.binding.id,
+                targetNames.get(declaration.binding.id) ?? safeRustTypeName(declaration.binding.name),
+            ],
+        ]
+        : []));
+    const context = {
+        abstractFieldNames: new Set(),
+        activeTypeParameters: [],
+        assertedUnknownBindingTypes: collectAssertedUnknownBindingTypesRust(module, bindingTypes),
+        accessorClassNames,
+        anonymousObjectRecords: new Map(),
+        anonymousUnionEnums: new Map(),
+        apiReferencedBindingIds: collectIrModuleApiReferencedBindingIdsRust(module),
+        arrayElementBindingIds: collectIrModuleArrayElementBindingIdsRust(module),
+        asyncTryStatements,
+        cellWrappedBindingIds,
+        refCellWrappedBindingIds,
+        classBindingNames,
+        borrowedParameterPositions,
+        callableObjectRecords: new Map(),
+        deferredBindingIds: new Set(analyzeIrModuleOwnershipEvidenceRust(module).bindings.flatMap((evidence) => evidence.uses.filter((use) => use.kind === 'rebind').length === 1 ? [evidence.binding.id] : [])),
+        primitiveUnionEnums,
+        primitiveUnionBindingIds,
+        runtimeTypeNames: new Set(),
+        reboundBindingIds: new Set(analyzeIrModuleOwnershipEvidenceRust(module).bindings.flatMap((evidence) => evidence.mutation !== 'none' ? [evidence.binding.id] : [])),
+        generatedNames: new Set(targetNames.values()),
+        movedBindingIds: collectIrModuleMovedBindingIdsRust(module),
+        referentMutatedBindingIds: new Set(analyzeIrModuleOwnershipEvidenceRust(module).bindings.flatMap((evidence) => evidence.mutation === 'referentMutated' || evidence.mutation === 'bindingAndReferent'
+            ? [evidence.binding.id]
+            : [])),
+        referentMutatedParameterIds: collectIrModuleReferentMutatedParameterIdsRust(module),
+        taggedUnionBindingNames,
+        bindingTypes,
+        module,
+        moduleResolution,
+        sourceModules: replaceIrModuleBackendContext(sourceModules, module),
+        needsCellImport: new Set(),
+        needsRcImport: new Set(),
+        needsRefCellImport: new Set(),
+        nullableBindingIds: collectIrModuleNullableBindingIds(module),
+        numericEnumNamespaceNames,
+        objectRestRecords: new Map(),
+        options,
+        returnsAbsent: false,
+        targetNames,
+    };
+    // Which bindings hold a union this module lowered to an enum. The type is on the binding, not on
+    // the member access, so the access site can only tell that its object is an enum by asking here.
+    for (const evidence of analyzeIrModuleOwnershipEvidenceRust(module).bindings) {
+        if (evidence.type.kind !== 'named' || evidence.type.reference.kind !== 'binding')
+            continue;
+        const reference = evidence.type.reference;
+        const alias = module.declarations.find((candidate) => candidate.kind === 'typeAlias' && candidate.binding.name === reference.binding.name);
+        if (alias?.kind === 'typeAlias' &&
+            alias.type.kind === 'union' &&
+            getIrUnionTypeMemberRecordsRust(alias.type, context)) {
+            taggedUnionBindingNames.set(evidence.binding.id, getBindingTargetNameRust(alias.binding, context));
+            continue;
+        }
+        // Which bindings hold a class with accessors. Rust has no properties, so a source-level field
+        // read of one is a call, and the access site can only tell by asking what the binding holds.
+        const classDeclaration = module.declarations.find((candidate) => candidate.kind === 'class' && candidate.binding.name === reference.binding.name);
+        if (classDeclaration?.kind !== 'class')
+            continue;
+        classBindingNames.set(evidence.binding.id, classDeclaration.binding.name);
+        if (classDeclaration.methods.some((method) => method.accessor)) {
+            accessorClassNames.set(evidence.binding.id, classDeclaration.binding.name);
+        }
+    }
+    // Which positions each module-local function borrows. Rust does not take a reference for an
+    // argument the way it does for a method receiver, so the call site has to lend explicitly, and only
+    // the callee's own declaration knows which positions those are.
+    for (const declaration of module.declarations) {
+        if (declaration.kind !== 'function')
+            continue;
+        const borrowed = new Set(declaration.parameters.flatMap((parameter, index) => context.referentMutatedParameterIds.has(parameter.binding.id) ? [index] : []));
+        if (borrowed.size > 0)
+            borrowedParameterPositions.set(declaration.binding.id, borrowed);
+    }
+    collectPrimitiveUnionBindingsRust(module, context);
+    const lines = [createCompilerGeneratedFileHeader(module, '//', options.upstreamCommit), '#![forbid(unsafe_code)]'];
+    const imports = [...emitImports(module.imports, context), ...emitReexportsRust(module.exports, context)];
+    const declarations = module.declarations
+        .filter((declaration) => declaration.kind !== 'function' || !declaration.namespaceMember)
+        .map((declaration) => emitDeclaration(declaration, context));
+    // The runtime contract's types are named bare in emitted source, so the module has to bring them
+    // into scope. Which ones it needs is only known once everything is emitted, which is why the use
+    // line is assembled here rather than beside the source's own imports.
+    const runtimeImports = context.runtimeTypeNames.size > 0
+        ? [`use ${options.runtimeCrate ?? 'flight_runtime'}::${emitUseTreeRust([...context.runtimeTypeNames].sort())};`]
+        : [];
+    const stdImports = [];
+    if (context.needsCellImport.size > 0)
+        stdImports.push('use std::cell::Cell;');
+    if (context.needsRefCellImport.size > 0)
+        stdImports.push('use std::cell::RefCell;');
+    if (context.needsRcImport.size > 0)
+        stdImports.push('use std::rc::Rc;');
+    if (runtimeImports.length > 0 || imports.length > 0 || stdImports.length > 0)
+        lines.push('', ...stdImports, ...runtimeImports, ...imports);
+    context.anonymousObjectRecords.forEach((record) => {
+        lines.push('', ...emitRecord(record.name, record.properties, [], false, context));
+    });
+    context.objectRestRecords.forEach((record) => {
+        lines.push('', ...emitRecord(record.name, record.properties, [], false, context));
+    });
+    context.primitiveUnionEnums.forEach((union) => {
+        lines.push('', ...emitPrimitiveUnionEnumRust(union));
+    });
+    context.anonymousUnionEnums.forEach((union) => {
+        lines.push('', ...emitGeneralUnionRust(union.name, union.variants, union.typeParameters, true, context));
+    });
+    context.callableObjectRecords.forEach((record) => {
+        lines.push('', ...emitCallableObjectRecordRust(record, context));
+    });
+    declarations.forEach((declaration) => lines.push('', ...declaration));
+    return {
+        contents: lines.join('\n'),
+        path: getRustModuleFilePath(module, context.sourceModules),
+    };
+}
+function emitClass(declaration, context) {
+    // Rust has no inheritance of state, so a base that carries fields has nothing to inherit into. A
+    // stateless abstract base is a different thing: it is a set of methods, which is a trait, and the
+    // subclass implements it.
+    const abstractBase = getIrClassStatelessAbstractBaseRust(declaration, context);
+    const concreteBase = !abstractBase ? getIrClassConcreteBaseRust(declaration, context) : undefined;
+    if (declaration.extends && !abstractBase && !concreteBase) {
+        emissionError(context, `class ${declaration.binding.name} inheritance requires Rust ownership lowering`);
+    }
+    // An abstract class declares behaviour and holds no state, which is what a Rust trait is. A method
+    // it implements becomes the trait's default body, so a subclass inherits it by implementing nothing.
+    if (declaration.abstract)
+        return emitAbstractClassTraitRust(declaration, context);
+    const inheritedTraits = abstractBase ? [getBindingTargetNameRust(abstractBase.binding, context)] : [];
+    const implementedTraits = declaration.implements.map((reference) => {
+        if (reference.kind !== 'named' || reference.reference.kind !== 'binding') {
+            return emissionError(context, `class ${declaration.binding.name} implements a type with no Rust trait`);
+        }
+        const target = context.module.declarations.find((candidate) => candidate.kind === 'interface' &&
+            reference.reference.kind === 'binding' &&
+            candidate.binding.id === reference.reference.binding.id);
+        if (!target) {
+            return emissionError(context, `class ${declaration.binding.name} implements an interface declared outside this module`);
+        }
+        return emitType(reference, context);
+    });
+    const compositionInit = concreteBase && declaration.classConstructor
+        ? getIrClassCompositionConstructorRust(declaration, concreteBase)
+        : undefined;
+    const constructorFields = !concreteBase && declaration.classConstructor
+        ? getIrClassConstructorFieldAssignmentsRust(declaration, abstractBase !== undefined)
+        : undefined;
+    if (declaration.classConstructor &&
+        !constructorFields &&
+        !compositionInit &&
+        (declaration.classConstructor.parameters.length > 0 || declaration.classConstructor.body.length > 0)) {
+        emissionError(context, `class ${declaration.binding.name} constructor requires Rust initialization lowering`);
+    }
+    // A static field is one value shared by the type, which Rust spells as an associated constant —
+    // but only where the source's initializer is a constant. Anything computed needs a place to run,
+    // and an associated constant has none.
+    const staticFields = declaration.fields.filter((field) => field.static);
+    if (staticFields.some((field) => field.initializer?.kind !== 'literal')) {
+        emissionError(context, `class ${declaration.binding.name} static fields require a constant initializer`);
+    }
+    const constructed = !declaration.classConstructor ||
+        (declaration.classConstructor.parameters.length === 0 && declaration.classConstructor.body.length === 0);
+    const instanceFields = declaration.fields.filter((field) => !field.static);
+    if (instanceFields.some((field) => field.initializer) && !constructed && !constructorFields && !compositionInit) {
+        emissionError(context, `class ${declaration.binding.name} field initializers require constructor lowering`);
+    }
+    if (instanceFields.some((field) => field.initializer) &&
+        instanceFields.some((field) => !field.initializer && !field.declare)) {
+        emissionError(context, `class ${declaration.binding.name} partially initializes its fields`);
+    }
+    const structVisibility = declaration.exported || context.apiReferencedBindingIds.has(declaration.binding.id) ? 'pub ' : '';
+    const lines = [
+        emitRustRecordDerive([...instanceFields.map((field) => field.type), ...(declaration.extends ? [declaration.extends] : [])], context),
+        `${structVisibility}struct ${getBindingTargetNameRust(declaration.binding, context)}${emitTypeParameters(declaration.typeParameters, context)} {`,
+    ];
+    if (concreteBase) {
+        lines.push(`    ${safeRustValueName('base')}: ${getBindingTargetNameRust(concreteBase.binding, context)},`);
+    }
+    for (const field of instanceFields) {
+        lines.push(`    ${field.visibility === 'public' ? 'pub ' : ''}${safeRustValueName(field.name)}: ${emitType(field.type, context)},`);
+    }
+    lines.push('}');
+    // A field initializer is a constructor obligation, and the neutral plan already decides when each
+    // field is initialized. Rust has no implicit constructor, so the plan becomes an associated `new`.
+    const initialization = instanceFields.every((field) => field.initializer || field.declare) && instanceFields.length > 0 && constructed
+        ? createIrClassInitializationPlan(declaration)
+        : undefined;
+    const associated = staticFields.map((field) => `  ${field.visibility === 'public' ? 'pub ' : ''}const ${constantRustName(field.name)}: ${emitType(field.type, context)} = ${emitExpression(field.initializer, context)};`);
+    if (constructorFields && declaration.classConstructor) {
+        associated.push(`  ${structVisibility}fn new(${declaration.classConstructor.parameters.map((parameter) => emitParameter(parameter, context)).join(', ')}) -> Self {`, '    Self {', ...constructorFields.map((field) => `      ${safeRustValueName(field.name)}: ${emitOwnedOperandRust(field.value, context)},`), '    }', '  }');
+    }
+    if (compositionInit && concreteBase && declaration.classConstructor) {
+        associated.push(`  ${structVisibility}fn new(${declaration.classConstructor.parameters.map((parameter) => emitParameter(parameter, context)).join(', ')}) -> Self {`, '    Self {', `      ${safeRustValueName('base')}: ${getBindingTargetNameRust(concreteBase.binding, context)}::new(${compositionInit.superArguments.map((argument) => emitOwnedOperandRust(argument, context)).join(', ')}),`, ...compositionInit.childFields.map((field) => `      ${safeRustValueName(field.name)}: ${emitOwnedOperandRust(field.value, context)},`), '    }', '  }');
+    }
+    if (initialization) {
+        const instanceOrder = initialization.fields.filter((field) => declaration.fields[field.fieldIndex] && !declaration.fields[field.fieldIndex].static);
+        associated.push(`  ${structVisibility}fn new() -> Self {`, '    Self {', ...instanceOrder.map((field) => {
+            const source = declaration.fields[field.fieldIndex];
+            if (source.declare)
+                return `      ${safeRustValueName(source.name)}: Default::default(),`;
+            return `      ${safeRustValueName(source.name)}: ${emitExpression(source.initializer, context)},`;
+        }), '    }', '  }');
+    }
+    const mutatingMethodNames = getIrClassMutatingMethodNamesRust(declaration);
+    // A trait's methods belong in its `impl` block, not in the inherent one, so the two are split by
+    // which trait declares each method name.
+    const traitMethodNames = new Map();
+    for (const reference of declaration.implements) {
+        if (reference.kind !== 'named' || reference.reference.kind !== 'binding')
+            continue;
+        const target = context.module.declarations.find((candidate) => candidate.kind === 'interface' &&
+            reference.reference.kind === 'binding' &&
+            candidate.binding.id === reference.reference.binding.id);
+        if (target?.kind !== 'interface')
+            continue;
+        for (const property of target.properties)
+            traitMethodNames.set(property.name, emitType(reference, context));
+    }
+    const traitAbstractFields = new Map();
+    if (abstractBase) {
+        const traitName = getBindingTargetNameRust(abstractBase.binding, context);
+        for (const method of abstractBase.methods)
+            traitMethodNames.set(method.name, traitName);
+        const abstractFields = abstractBase.fields.filter((field) => field.abstract);
+        if (abstractFields.length > 0)
+            traitAbstractFields.set(traitName, abstractFields);
+    }
+    const traitDataProperties = new Map();
+    for (const reference of declaration.implements) {
+        if (reference.kind !== 'named' || reference.reference.kind !== 'binding')
+            continue;
+        const target = context.module.declarations.find((candidate) => candidate.kind === 'interface' &&
+            reference.reference.kind === 'binding' &&
+            candidate.binding.id === reference.reference.binding.id);
+        if (target?.kind !== 'interface')
+            continue;
+        traitDataProperties.set(emitType(reference, context), target.properties.filter((property) => property.type.kind !== 'function'));
+    }
+    if (concreteBase) {
+        context.compositionBase = {
+            baseDeclaration: concreteBase,
+            fieldName: 'base',
+        };
+    }
+    const inherentMethods = declaration.methods.filter((method) => !traitMethodNames.has(method.name));
+    const emitMethodLines = (method) => {
+        // Rust has no properties, so an accessor is a method. A setter takes the receiver mutably and is
+        // named apart from the getter, because Rust has one namespace for both and the source had two.
+        const target = getIrClassMethodTargetNameRust(method);
+        const receiver = method.accessor === 'set' || mutatingMethodNames.has(target) ? '&mut self' : '&self';
+        const parameters = [
+            ...(method.static ? [] : [receiver]),
+            ...method.parameters.map((parameter) => emitParameter(parameter, context)),
+        ].join(', ');
+        // A setter yields nothing. The source wrote no return type and the neutral model kept that
+        // unknown, but the accessor contract already decides it.
+        const returns = method.accessor === 'set' ? '()' : emitType(method.returns, context);
+        return [
+            `  ${method.visibility === 'public' && !traitMethodNames.has(method.name) ? 'pub ' : ''}fn ${target}${emitTypeParameters(method.typeParameters, context)}(${parameters}) -> ${returns} {`,
+            ...indentSourceLines(emitStatements(method.body, context), 2),
+            '  }',
+        ];
+    };
+    for (const trait of [...inheritedTraits, ...implementedTraits]) {
+        const traitMethods = declaration.methods.filter((method) => traitMethodNames.get(method.name) === trait);
+        lines.push('', `impl${emitTypeParameters(declaration.typeParameters, context)} ${trait} for ${getBindingTargetNameRust(declaration.binding, context)}${emitTypeArguments(declaration.typeParameters, context)} {`);
+        const traitAccessors = traitDataProperties.get(trait) ?? [];
+        const abstractFields = traitAbstractFields.get(trait) ?? [];
+        let emittedCount = 0;
+        abstractFields.forEach((field) => {
+            if (emittedCount > 0)
+                lines.push('');
+            const owned = isIrTypeCopyValueRust(field.type) ? '' : '.clone()';
+            lines.push(`  fn ${safeRustValueName(field.name)}(&self) -> ${emitType(field.type, context)} {`, `    self.${safeRustValueName(field.name)}${owned}`, '  }');
+            emittedCount++;
+        });
+        traitMethods.forEach((method) => {
+            if (emittedCount > 0)
+                lines.push('');
+            lines.push(...emitMethodLines(method));
+            emittedCount++;
+        });
+        traitAccessors.forEach((property) => {
+            if (emittedCount > 0)
+                lines.push('');
+            lines.push(`  fn ${safeRustValueName(property.name)}(&self) -> ${emitType(property.type, context)} {`, `    self.${safeRustValueName(property.name)}.clone()`, '  }');
+            emittedCount++;
+        });
+        lines.push('}');
+    }
+    if (inherentMethods.length > 0 || associated.length > 0) {
+        lines.push('', `impl${emitTypeParameters(declaration.typeParameters, context)} ${getBindingTargetNameRust(declaration.binding, context)}${emitTypeArguments(declaration.typeParameters, context)} {`, ...associated);
+        inherentMethods.forEach((method, index) => {
+            if (index > 0 || associated.length > 0)
+                lines.push('');
+            lines.push(...emitMethodLines(method));
+        });
+        lines.push('}');
+    }
+    if (concreteBase) {
+        context.compositionBase = undefined;
+    }
+    return lines;
+}
+function emitDeclaration(declaration, context) {
+    switch (declaration.kind) {
+        case 'class':
+            return emitClass(declaration, context);
+        case 'enum':
+            return emitEnum(declaration, context);
+        case 'function':
+            return emitFunction(declaration, context);
+        case 'interface':
+            return emitInterface(declaration, context);
+        case 'typeAlias':
+            return emitTypeAlias(declaration, context);
+        case 'variable':
+            return emitVariableDeclaration(declaration, context);
+    }
+}
+function emitEnum(declaration, context) {
+    const values = declaration.members.map((member) => member.value);
+    const namespaceFunctions = getIrEnumNamespaceFunctionsRust(declaration, context.module);
+    if (namespaceFunctions.length > 0) {
+        if (values.some((value) => typeof value !== 'number' || !Number.isInteger(value))) {
+            emissionError(context, `enum ${declaration.binding.name} value namespace requires integer discriminants`);
+        }
+        if (values.some((value) => Number(value) < -2_147_483_648 || Number(value) > 2_147_483_647)) {
+            emissionError(context, `enum ${declaration.binding.name} has a discriminant outside the Rust i32 range`);
+        }
+        return emitNumericEnumNamespaceWrapperRust(declaration, namespaceFunctions, context);
+    }
+    if (values.every((value) => typeof value === 'string'))
+        return emitStringEnumRust(declaration, context);
+    if (values.some((value) => typeof value !== 'number' || !Number.isInteger(value))) {
+        emissionError(context, `enum ${declaration.binding.name} requires one discriminant domain for Rust`);
+    }
+    if (values.some((value) => Number(value) < -2_147_483_648 || Number(value) > 2_147_483_647)) {
+        emissionError(context, `enum ${declaration.binding.name} has a discriminant outside the Rust i32 range`);
+    }
+    const visibility = declaration.exported || context.apiReferencedBindingIds.has(declaration.binding.id) ? 'pub ' : '';
+    const lines = [
+        '#[derive(Clone, Copy, Debug, PartialEq, Eq)]',
+        '#[repr(i32)]',
+        `${visibility}enum ${getBindingTargetNameRust(declaration.binding, context)} {`,
+    ];
+    declaration.members.forEach((member) => {
+        lines.push(`  ${safeRustTypeName(member.name)} = ${String(member.value)},`);
+    });
+    lines.push('}');
+    return lines;
+}
+function getIrEnumNamespaceFunctionsRust(declaration, module) {
+    return module.declarations.filter((candidate) => candidate.kind === 'function' &&
+        candidate.namespaceMember?.kind === 'binding' &&
+        candidate.namespaceMember.binding.id === declaration.binding.id &&
+        candidate.namespaceMember.path.length === 1);
+}
+function emitNumericEnumNamespaceWrapperRust(declaration, namespaceFunctions, context) {
+    const name = getBindingTargetNameRust(declaration.binding, context);
+    const visibility = declaration.exported || context.apiReferencedBindingIds.has(declaration.binding.id) ? 'pub ' : '';
+    const lines = [
+        '#[derive(Clone, Copy, Debug, PartialEq, Eq)]',
+        `${visibility}struct ${name}(i32);`,
+        '',
+        `impl ${name} {`,
+        ...declaration.members.map((member) => `  ${visibility}const ${safeRustTypeName(member.name)}: Self = Self(${String(member.value)});`),
+    ];
+    for (const namespaceFunction of namespaceFunctions) {
+        lines.push('', ...indentSourceLines(emitEnumNamespaceFunctionRust(namespaceFunction, context)));
+    }
+    lines.push('}');
+    return lines;
+}
+function emitEnumNamespaceFunctionRust(declaration, outer) {
+    const context = {
+        ...outer,
+        activeTypeParameters: declaration.typeParameters,
+        enclosingReturnType: declaration.returns,
+        returnsAbsent: hasIrTypeAbsentMember(declaration.returns),
+    };
+    if (declaration.async)
+        emissionError(context, 'async enum namespace functions require Rust task lowering');
+    return [
+        `pub fn ${safeRustValueName(declaration.binding.name)}${emitTypeParameters(declaration.typeParameters, context)}(${declaration.parameters.map((parameter) => emitParameter(parameter, context)).join(', ')}) -> ${emitType(declaration.returns, context)} {`,
+        ...indentSourceLines(emitStatements(declaration.body, context)),
+        '}',
+    ];
+}
+// Rust discriminants are integers, so a string enum keeps unit variants and carries its source
+// values as an explicit mapping. Both directions are emitted because the source language treats the
+// value as the enum: code compares against it and constructs from it.
+function emitStringEnumRust(declaration, context) {
+    const name = getBindingTargetNameRust(declaration.binding, context);
+    const visibility = declaration.exported || context.apiReferencedBindingIds.has(declaration.binding.id) ? 'pub ' : '';
+    return [
+        '#[derive(Clone, Copy, Debug, PartialEq, Eq)]',
+        `${visibility}enum ${name} {`,
+        ...declaration.members.map((member) => `  ${safeRustTypeName(member.name)},`),
+        '}',
+        '',
+        `impl ${name} {`,
+        `  ${visibility}fn as_str(&self) -> &'static str {`,
+        '    match self {',
+        ...declaration.members.map((member) => `      ${name}::${safeRustTypeName(member.name)} => ${JSON.stringify(String(member.value))},`),
+        '    }',
+        '  }',
+        '',
+        `  ${visibility}fn from_str(value: &str) -> Option<Self> {`,
+        '    match value {',
+        ...declaration.members.map((member) => `      ${JSON.stringify(String(member.value))} => Some(${name}::${safeRustTypeName(member.name)}),`),
+        '      _ => None,',
+        '    }',
+        '  }',
+        '}',
+    ];
+}
+function emitExpression(expression, context) {
+    switch (expression.kind) {
+        case 'array':
+            return `vec![${expression.elements.map((element) => (element ? emitOwnedOperandRust(element, context) : 'Default::default()')).join(', ')}]`;
+        case 'assignment': {
+            const typedArrayAssignment = emitTypedArrayElementAssignmentRust(expression, context);
+            if (typedArrayAssignment)
+                return typedArrayAssignment;
+            if (expression.left.kind === 'identifier' &&
+                expression.left.reference.kind === 'binding' &&
+                context.cellWrappedBindingIds.has(expression.left.reference.binding.id)) {
+                const name = emitIdentifierReferenceRust(expression.left.reference, context);
+                const right = emitExpression(expression.right, context);
+                if (expression.operator === '=')
+                    return `${name}.set(${right})`;
+                if (expression.operator === '**=' &&
+                    expression.semantics.left.flow === 'number' &&
+                    expression.semantics.right.flow === 'number') {
+                    return `${name}.set(f64::powf(${name}.get(), ${right}))`;
+                }
+                if (expression.operator === '>>>=' &&
+                    expression.semantics.left.flow === 'number' &&
+                    expression.semantics.right.flow === 'number') {
+                    return `${name}.set(((((${name}.get() as i32) as u32) >> (${right} as u32)) as f64))`;
+                }
+                if ((expression.operator === '&=' ||
+                    expression.operator === '|=' ||
+                    expression.operator === '^=' ||
+                    expression.operator === '<<=' ||
+                    expression.operator === '>>=') &&
+                    expression.semantics.left.flow === 'number' &&
+                    expression.semantics.right.flow === 'number') {
+                    const binaryOp = expression.operator.slice(0, -1);
+                    return `${name}.set((((${name}.get() as i32) ${binaryOp} (${right} as i32)) as f64))`;
+                }
+                if (expression.operator === '||=' || expression.operator === '&&=') {
+                    if (expression.semantics.left.flow === 'boolean') {
+                        const condition = expression.operator === '||=' ? `!${name}.get()` : `${name}.get()`;
+                        return `{ if ${condition} { ${name}.set(${right}); } ${name}.get() }`;
+                    }
+                    if (expression.semantics.left.flow === 'number') {
+                        const condition = expression.operator === '||='
+                            ? `${name}.get() == 0.0 || ${name}.get().is_nan()`
+                            : `${name}.get() != 0.0 && !${name}.get().is_nan()`;
+                        return `{ if ${condition} { ${name}.set(${right}); } ${name}.get() }`;
+                    }
+                }
+                if (expression.operator === '??=') {
+                    if (context.nullableBindingIds.has(expression.left.reference.binding.id) &&
+                        (expression.semantics.right.flow === 'number' || expression.semantics.right.flow === 'boolean')) {
+                        return `{ if ${name}.get().is_none() { ${name}.set(Some(${right})); } ${name}.get().clone().unwrap() }`;
+                    }
+                    emissionError(context, `operator ${expression.operator} on ${expression.semantics.left.flow} and ${expression.semantics.right.flow} requires Rust type-directed lowering`);
+                }
+                if (!isAssignmentOperatorDirectRust(expression.operator, expression.semantics)) {
+                    emissionError(context, `operator ${expression.operator} on ${expression.semantics.left.flow} and ${expression.semantics.right.flow} requires Rust type-directed lowering`);
+                }
+                const op = expression.operator.slice(0, -1);
+                return `${name}.set(${name}.get() ${op} ${normalizeSourceTextGrouping(right)})`;
+            }
+            if (expression.left.kind === 'identifier' &&
+                expression.left.reference.kind === 'binding' &&
+                context.refCellWrappedBindingIds.has(expression.left.reference.binding.id)) {
+                const name = emitIdentifierReferenceRust(expression.left.reference, context);
+                const right = emitExpression(expression.right, context);
+                if (expression.operator === '=')
+                    return `${name}.replace(${right})`;
+                if (expression.operator === '??=') {
+                    if (context.nullableBindingIds.has(expression.left.reference.binding.id)) {
+                        return `{ if ${name}.borrow().is_none() { *${name}.borrow_mut() = Some(${right}); } ${name}.borrow().clone().unwrap() }`;
+                    }
+                    emissionError(context, 'operator ??= on ref-cell-wrapped binding requires a nullable Rust target');
+                }
+                emissionError(context, `operator ${expression.operator} on non-Copy ref-cell-wrapped binding requires Rust type-directed lowering`);
+            }
+            if (expression.operator === '=' &&
+                expression.left.kind === 'property' &&
+                getIrExpressionClassAccessorRust(expression.left.object, expression.left.name, 'set', context)) {
+                return `${emitExpression(expression.left.object, context)}.set_${safeRustValueName(expression.left.name)}(${emitOwnedOperandRust(expression.right, context)})`;
+            }
+            if (expression.operator === '+=' &&
+                expression.semantics.left.flow === 'string' &&
+                expression.semantics.right.flow === 'string') {
+                const left = emitExpression(expression.left, context);
+                const right = emitExpression(expression.right, context);
+                return `${left}.push_str(&${normalizeSourceTextGrouping(right)})`;
+            }
+            if ((expression.operator === '&=' ||
+                expression.operator === '|=' ||
+                expression.operator === '^=' ||
+                expression.operator === '<<=' ||
+                expression.operator === '>>=') &&
+                expression.semantics.left.flow === 'number' &&
+                expression.semantics.right.flow === 'number') {
+                const left = emitExpression(expression.left, context);
+                const right = emitExpression(expression.right, context);
+                const binaryOp = expression.operator.slice(0, -1);
+                return `${left} = (((${left} as i32) ${binaryOp} (${right} as i32)) as f64)`;
+            }
+            if (expression.operator === '**=' &&
+                expression.semantics.left.flow === 'number' &&
+                expression.semantics.right.flow === 'number') {
+                const left = emitExpression(expression.left, context);
+                const right = emitExpression(expression.right, context);
+                return `${left} = f64::powf(${left}, ${right})`;
+            }
+            if (expression.operator === '>>>=' &&
+                expression.semantics.left.flow === 'number' &&
+                expression.semantics.right.flow === 'number') {
+                const left = emitExpression(expression.left, context);
+                const right = emitExpression(expression.right, context);
+                return `${left} = ((((${left} as i32) as u32) >> (${right} as u32)) as f64)`;
+            }
+            if (expression.operator === '||=' || expression.operator === '&&=') {
+                const left = emitExpression(expression.left, context);
+                const right = emitExpression(expression.right, context);
+                if (expression.semantics.left.flow === 'boolean') {
+                    const condition = expression.operator === '||=' ? `!${left}` : left;
+                    return `{ if ${condition} { ${left} = ${right}; } ${left} }`;
+                }
+                if (expression.semantics.left.flow === 'number') {
+                    const condition = expression.operator === '||='
+                        ? `${left} == 0.0 || ${left}.is_nan()`
+                        : `${left} != 0.0 && !${left}.is_nan()`;
+                    return `{ if ${condition} { ${left} = ${right}; } ${left} }`;
+                }
+                if (expression.semantics.left.flow === 'string') {
+                    const condition = expression.operator === '||=' ? `${left}.is_empty()` : `!${left}.is_empty()`;
+                    return `{ if ${condition} { ${left} = ${right}; } ${left} }`;
+                }
+                emissionError(context, `operator ${expression.operator} on ${expression.semantics.left.flow} requires Rust semantic lowering`);
+            }
+            if (expression.operator === '??=') {
+                const left = emitExpression(expression.left, context);
+                const right = emitExpression(expression.right, context);
+                if (expression.left.kind === 'identifier' &&
+                    expression.left.reference.kind === 'binding' &&
+                    context.nullableBindingIds.has(expression.left.reference.binding.id)) {
+                    return `{ if ${left}.is_none() { ${left} = Some(${right}); } ${left}.clone().unwrap() }`;
+                }
+                emissionError(context, 'operator ??= requires a nullable Rust target');
+            }
+            if (expression.operator === '=' &&
+                expression.left.kind === 'identifier' &&
+                expression.left.reference.kind === 'binding') {
+                const targetType = context.bindingTypes.get(expression.left.reference.binding.id);
+                const dualSentinelUnion = targetType ? resolveDualSentinelUnionEnumRust(targetType, context) : undefined;
+                if (dualSentinelUnion) {
+                    const wrapped = emitDualSentinelUnionConstructionRust(expression.right, dualSentinelUnion, context);
+                    if (wrapped)
+                        return `${emitExpression(expression.left, context)} = ${wrapped}`;
+                }
+                const enumName = context.primitiveUnionBindingIds.get(expression.left.reference.binding.id);
+                if (enumName) {
+                    const targetEnum = [...context.primitiveUnionEnums.values()].find((e) => e.name === enumName);
+                    if (targetEnum) {
+                        const wrapped = emitPrimitiveUnionConstructionRust(expression.right, targetEnum, context);
+                        if (wrapped) {
+                            return `${emitExpression(expression.left, context)} = ${wrapped}`;
+                        }
+                    }
+                }
+            }
+            const left = emitExpression(expression.left, context);
+            const right = emitOptionalTargetOperandRust(expression.left, expression.right, context);
+            return `${left} ${emitAssignmentOperatorRust(expression.operator, expression.semantics, context)} ${normalizeSourceTextGrouping(right)}`;
+        }
+        case 'await':
+            // `.await` consumes the future it is given, while the source language's await does not consume
+            // the promise: a promise settles once and every await sees that settlement. A task reached more
+            // than once is therefore cloned, which the runtime contract's first-call-wins settlement is
+            // what makes equivalent.
+            return `${emitOwnedOperandRust(expression.expression, context)}.await`;
+        case 'binary': {
+            if (expression.semantics.nullishComparison) {
+                const evidence = expression.semantics.nullishComparison;
+                // A single absent member uses `Option`. When both source sentinels are possible the binding
+                // instead carries a generated enum, so strict comparison selects one unit variant while
+                // loose comparison deliberately accepts either.
+                if (evidence.admitsNull && evidence.admitsUndefined) {
+                    const operand = expression.left.kind === 'identifier' && expression.left.reference.kind === 'ambient'
+                        ? expression.right
+                        : expression.left;
+                    const union = getIrExpressionDualSentinelUnionRust(operand, context);
+                    if (!union) {
+                        emissionError(context, 'dual-sentinel nullish comparison requires Rust union representation evidence');
+                    }
+                    const strict = expression.operator === '===' || expression.operator === '!==';
+                    const patterns = strict
+                        ? [`${union.name}::${evidence.literal === 'null' ? 'Null' : 'Undefined'}`]
+                        : [`${union.name}::Null`, `${union.name}::Undefined`];
+                    const test = `matches!(&${emitExpression(operand, context)}, ${patterns.join(' | ')})`;
+                    return expression.operator === '!=' || expression.operator === '!==' ? `!${test}` : test;
+                }
+                const operand = expression.left.kind === 'identifier' && expression.left.reference.kind === 'ambient'
+                    ? expression.right
+                    : expression.left;
+                const negated = expression.operator === '!=' || expression.operator === '!==';
+                return `${emitExpression(operand, context)}.${negated ? 'is_some' : 'is_none'}()`;
+            }
+            if (expression.operator === '??') {
+                // Rust has no `??`. The shape is `Option::unwrap_or_else`, which needs the left operand to
+                // already be an Option — an optional chain produces one, an ordinary value does not.
+                // A coalesce whose left cannot be absent is its left: the default is unreachable, and the
+                // source's own types are what say so.
+                if (expression.left.kind === 'property' && expression.left.optionalChain?.receiverNullish === 'excluded') {
+                    return emitExpression(expression.left, context);
+                }
+                if (!isIrExpressionOptionShapedRust(expression.left, context)) {
+                    emissionError(context, 'operator ?? requires an Option-shaped left operand for Rust');
+                }
+                return `${emitOptionShapedOperandRust(expression.left, context)}.unwrap_or_else(|| ${emitExpression(expression.right, context)})`;
+            }
+            if (expression.operator === '+' &&
+                expression.semantics.left.flow === 'string' &&
+                expression.semantics.right.flow === 'string') {
+                return emitStringConcatenationRust(expression, context);
+            }
+            if ((expression.operator === '==' ||
+                expression.operator === '===' ||
+                expression.operator === '!=' ||
+                expression.operator === '!==') &&
+                ((isIrExpressionTypedArrayRust(expression.left, context) &&
+                    isIrExpressionTypedArrayRust(expression.right, context)) ||
+                    (isIrExpressionDataViewRust(expression.left, context) &&
+                        isIrExpressionDataViewRust(expression.right, context)) ||
+                    (isIrExpressionArrayBufferRust(expression.left, context) &&
+                        isIrExpressionArrayBufferRust(expression.right, context)))) {
+                const operator = expression.operator === '!=' || expression.operator === '!==' ? '!=' : '==';
+                return `(${emitExpression(expression.left, context)} ${operator} ${emitExpression(expression.right, context)})`;
+            }
+            const typeofTest = getTypeofTypeTestRust(expression, context);
+            if (typeofTest) {
+                const operand = emitExpression(typeofTest.operand, context);
+                const test = `matches!(${operand}, ${typeofTest.enumName}::${typeofTest.variantName}(_))`;
+                return typeofTest.negated ? `!${test}` : test;
+            }
+            if (expression.operator === '**' &&
+                expression.semantics.left.flow === 'number' &&
+                expression.semantics.right.flow === 'number') {
+                const left = emitExpression(expression.left, context);
+                const right = emitExpression(expression.right, context);
+                return `f64::powf(${left}, ${right})`;
+            }
+            if (expression.operator === '>>>' &&
+                expression.semantics.left.flow === 'number' &&
+                expression.semantics.right.flow === 'number') {
+                const left = emitExpression(expression.left, context);
+                const right = emitExpression(expression.right, context);
+                return `((((${left} as i32) as u32) >> (${right} as u32)) as f64)`;
+            }
+            const op = emitBinaryOperatorRust(expression.operator, expression.semantics, context);
+            const bitwise = expression.operator === '&' ||
+                expression.operator === '|' ||
+                expression.operator === '^' ||
+                expression.operator === '<<' ||
+                expression.operator === '>>';
+            const left = emitNumericEnumOperandRust(expression.left, context);
+            const right = emitNumericEnumOperandRust(expression.right, context);
+            if (bitwise)
+                return `(((${left} as i32) ${op} (${right} as i32)) as f64)`;
+            return `(${left} ${op} ${right})`;
+        }
+        case 'call':
+            if (expression.semantics.statementValue)
+                return emitStatementValueExpressionRust(expression, context);
+            if (expression.optional)
+                return emitOptionalCallExpressionRust(expression, context);
+            // Rust joins a slice of strings with a borrowed separator, while the source hands it an owned
+            // one. The separator is the only argument, so the borrow is decided here rather than by a
+            // general rule about where an owned string may stand.
+            if (expression.callee.kind === 'property' &&
+                expression.callee.member?.receiver === 'array' &&
+                expression.callee.member.name === 'join') {
+                const separator = expression.arguments[0];
+                if (expression.arguments.length !== 1 || !separator) {
+                    emissionError(context, 'joining a collection requires exactly one separator argument');
+                }
+                return `${emitExpression(expression.callee.object, context)}.join(${emitBorrowedTextRust(separator, context)})`;
+            }
+            // Typed arrays use runtime views rather than Vec: slice copies storage, while subarray creates
+            // a distinct view sharing storage. Their bounds stay numeric until the runtime applies source
+            // relative-index rules (including negative and infinite bounds).
+            if (expression.callee.kind === 'property' &&
+                expression.callee.member?.receiver === 'typedArray' &&
+                (expression.callee.member.name === 'slice' || expression.callee.member.name === 'subarray')) {
+                if (expression.arguments.length > 2) {
+                    emissionError(context, `${expression.callee.member.name} on a typed array takes at most a start and an end`);
+                }
+                const receiver = emitExpression(expression.callee.object, context);
+                const method = expression.callee.member.name;
+                if (expression.arguments.length === 0)
+                    return `${receiver}.${method}(0.0)`;
+                const start = emitExpression(expression.arguments[0], context);
+                if (expression.arguments.length === 1)
+                    return `${receiver}.${method}(${start})`;
+                return `${receiver}.${method}_range(${start}, ${emitExpression(expression.arguments[1], context)})`;
+            }
+            if (expression.semantics.typedArraySet) {
+                assertOneIrTypedArrayReceiverRust(expression.semantics.typedArraySet.receivers, context);
+                if (expression.callee.kind !== 'property' ||
+                    expression.arguments.length < 1 ||
+                    expression.arguments.length > 2) {
+                    emissionError(context, 'setting a typed array requires a source and an optional offset');
+                }
+                const receiver = emitExpression(expression.callee.object, context);
+                const source = emitOwnedOperandRust(expression.arguments[0], context);
+                const offset = expression.arguments[1] ? emitExpression(expression.arguments[1], context) : '0.0';
+                return `${receiver}.copy_from(${source}, ${offset})`;
+            }
+            // An ordinary array slice is a Rust range copied back into an owned Vec.
+            if (expression.callee.kind === 'property' &&
+                expression.callee.member?.receiver === 'array' &&
+                expression.callee.member.name === 'slice') {
+                const receiver = emitExpression(expression.callee.object, context);
+                if (expression.arguments.length === 0)
+                    return `${receiver}.clone()`;
+                if (expression.arguments.length > 2) {
+                    emissionError(context, 'slicing a collection takes at most a start and an end');
+                }
+                const bounds = expression.arguments
+                    .map((argument) => `${emitExpression(argument, context)} as usize`)
+                    .join('..');
+                return `${receiver}[${expression.arguments.length === 1 ? `${bounds}..` : bounds}].to_vec()`;
+            }
+            if (expression.callee.kind === 'property' &&
+                expression.callee.member?.receiver === 'array' &&
+                expression.callee.member.name === 'concat' &&
+                expression.arguments.length === 1) {
+                const receiver = emitExpression(expression.callee.object, context);
+                const other = emitExpression(expression.arguments[0], context);
+                return `{ let mut __concat = ${receiver}; __concat.extend(${other}); __concat }`;
+            }
+            if (expression.callee.kind === 'property' &&
+                expression.callee.member?.receiver === 'string' &&
+                expression.callee.member.name === 'charAt' &&
+                expression.arguments.length === 1) {
+                const receiver = emitExpression(expression.callee.object, context);
+                const index = emitExpression(expression.arguments[0], context);
+                return `${receiver}.chars().nth(${index} as usize).map(|c| c.to_string()).unwrap_or_default()`;
+            }
+            if (expression.callee.kind === 'property' &&
+                expression.callee.member?.receiver === 'string' &&
+                expression.callee.member.name === 'charCodeAt' &&
+                expression.arguments.length === 1) {
+                const receiver = emitExpression(expression.callee.object, context);
+                const index = emitExpression(expression.arguments[0], context);
+                return `${receiver}.chars().nth(${index} as usize).map(|c| c as u32 as f64).unwrap_or(f64::NAN)`;
+            }
+            if (expression.callee.kind === 'property' &&
+                expression.callee.member?.receiver === 'string' &&
+                expression.callee.member.name === 'substring') {
+                const receiver = emitExpression(expression.callee.object, context);
+                if (expression.arguments.length === 0 || expression.arguments.length > 2) {
+                    emissionError(context, 'string substring takes a start index and an optional end index');
+                }
+                const bounds = expression.arguments
+                    .map((argument) => `${emitExpression(argument, context)} as usize`)
+                    .join('..');
+                return `${receiver}[${expression.arguments.length === 1 ? `${bounds}..` : bounds}].to_string()`;
+            }
+            if (expression.callee.kind === 'property' && expression.callee.member) {
+                const binding = getCompilerRustAmbientMemberBinding(expression.callee.member);
+                if (binding && binding.kind !== 'countingMethod' && binding.kind !== 'propertyMethod') {
+                    const receiver = emitPrimitiveUnionNarrowedReceiverRust(expression.callee.object, context) ??
+                        emitExpression(expression.callee.object, context);
+                    const borrows = binding.kind === 'borrowedMethod' || binding.kind === 'sentinelSearch' || binding.kind === 'splitCollect';
+                    const values = expression.callee.member.receiver === 'dataView'
+                        ? emitCallArgumentsRust(expression, context)
+                        : expression.arguments.map((argument) => borrows ? emitBorrowedTextRust(argument, context) : emitExpression(argument, context));
+                    if (binding.kind === 'runtimeMethod') {
+                        const target = recordRuntimeTypeRust(binding.targetName, context);
+                        return `${target}(&${receiver}${values.length > 0 ? `, ${values.join(', ')}` : ''})`;
+                    }
+                    if (binding.kind === 'predicatePosition') {
+                        return emitArrayPredicatePositionRust(receiver, expression.arguments[0], values[0], binding.targetName, context);
+                    }
+                    if (binding.kind === 'iterator') {
+                        const firstArg = expression.arguments[0];
+                        const closure = binding.borrowsElement
+                            ? emitBorrowedElementClosureRust(firstArg, context)
+                            : firstArg && firstArg.kind !== 'function'
+                                ? emitIteratorCallbackWrapperRust(firstArg, values[0], context)
+                                : values[0];
+                        const ordered = binding.argumentOrder
+                            ? binding.argumentOrder.map((position) => values[position] ?? '')
+                            : [closure ?? ''];
+                        return `${receiver}.into_iter().${binding.targetName}(${ordered.join(', ')})${binding.collect ? '.collect::<Vec<_>>()' : ''}`;
+                    }
+                    if (binding.kind === 'positionSearch') {
+                        const borrowed = expression.arguments.map((argument) => emitBorrowedTextRust(argument, context));
+                        return `${receiver}.iter().${binding.targetName}(|x| x == ${borrowed.join(', ')}).map(|i| i as f64).unwrap_or(-1.0)`;
+                    }
+                    if (binding.kind === 'sentinelSearch') {
+                        return `${receiver}.${binding.targetName}(${values.join(', ')}).map(|i| i as f64).unwrap_or(-1.0)`;
+                    }
+                    if (binding.kind === 'splitCollect') {
+                        return `${receiver}.${binding.targetName}(${values.join(', ')}).map(|s| s.to_string()).collect::<Vec<String>>()`;
+                    }
+                    if (binding.kind === 'optionalLookup') {
+                        const borrowed = expression.arguments.map((argument) => emitBorrowedTextRust(argument, context));
+                        return `${receiver}.${binding.targetName}(${borrowed.join(', ')}).cloned()`;
+                    }
+                    const leading = binding.kind === 'method' ? (binding.leadingArguments ?? []) : [];
+                    const trailing = binding.kind === 'borrowedMethod' ? (binding.trailingArguments ?? []) : [];
+                    return `${receiver}.${binding.targetName}(${[...leading, ...values, ...trailing].join(', ')})${binding.owns ? '.to_owned()' : ''}`;
+                }
+            }
+            if (expression.arguments.length === 1 &&
+                expression.arguments[0].kind === 'spread' &&
+                expression.callee.kind === 'property' &&
+                expression.callee.object.kind === 'identifier' &&
+                expression.callee.object.reference.kind === 'ambient' &&
+                expression.callee.object.reference.name === 'Math') {
+                const foldTarget = rustMathSpreadFoldTargets[expression.callee.name];
+                if (foldTarget) {
+                    const spreadOperand = emitExpression(expression.arguments[0].expression, context);
+                    return `${spreadOperand}.iter().cloned().fold(${foldTarget.identity}, ${foldTarget.folder})`;
+                }
+            }
+            if (expression.callee.kind === 'identifier' &&
+                expression.callee.reference.kind === 'ambient' &&
+                expression.callee.reference.name === 'String' &&
+                expression.arguments.length === 1) {
+                const operand = emitExpression(expression.arguments[0], context);
+                return operand.startsWith('*') ? `(${operand}).to_string()` : `${operand}.to_string()`;
+            }
+            return `${expression.callee.kind === 'function' ? `(${emitExpression(expression.callee, context)})` : emitExpression(expression.callee, context)}(${emitCallArgumentsRust(expression, context).join(', ')})`;
+        case 'cast': {
+            const assertedUnknownType = expression.expression.kind === 'identifier' && expression.expression.reference.kind === 'binding'
+                ? context.assertedUnknownBindingTypes.get(expression.expression.reference.binding.id)
+                : undefined;
+            if (assertedUnknownType &&
+                expression.expression.kind === 'identifier' &&
+                expression.expression.reference.kind === 'binding' &&
+                areIrAssertedUnknownRepresentationsEqualRust(assertedUnknownType, expression.type)) {
+                return emitOwnedOperandRust(expression.expression, context);
+            }
+            const unionCast = emitPrimitiveUnionCastRust(expression, context);
+            if (unionCast)
+                return unionCast;
+            if (!isIrCastTargetNumericRust(expression.type)) {
+                emissionError(context, `cast to ${expression.type.kind} requires Rust type-directed lowering`);
+            }
+            return `(${emitExpression(expression.expression, context)} as ${emitType(expression.type, context)})`;
+        }
+        case 'conditional':
+            return `if ${emitExpression(expression.condition, context)} { ${emitExpression(expression.whenTrue, context)} } else { ${emitExpression(expression.whenFalse, context)} }`;
+        case 'element':
+            if (expression.optional)
+                return emitOptionalElementExpressionRust(expression, context);
+            {
+                const closedSelection = emitClosedKeyElementSelectionRust(expression, context);
+                if (closedSelection)
+                    return closedSelection;
+            }
+            if (expression.semantics.receivers.includes('object')) {
+                emissionError(context, 'computed object access requires JavaScript property-key coercion lowering');
+            }
+            if (expression.semantics.receivers.includes('tuple')) {
+                const index = getElementAccessTupleIndexRust(expression, context);
+                return `${emitExpression(expression.object, context)}.${String(index)}`;
+            }
+            if (hasOnlyIrTypedArrayReceiversRust(expression.semantics.receivers)) {
+                assertOneIrTypedArrayReceiverRust(expression.semantics.receivers, context);
+                return `${emitExpression(expression.object, context)}.get_index(${emitNumericEnumOperandRust(expression.index, context)})`;
+            }
+            // A written index is already a whole number; sending it through the neutral numeric type and
+            // back is noise the source never asked for.
+            return `${emitExpression(expression.object, context)}[${emitIndexOperandRust(expression.index, context)}]`;
+        case 'function':
+            if (expression.async)
+                emissionError(context, 'async closures require Flight task lowering');
+            if (expression.typeParameters.length > 0)
+                emissionError(context, 'generic closures require monomorphization');
+            return expression.expression
+                ? `|${expression.parameters.map((parameter) => getBindingTargetNameRust(parameter.binding, context)).join(', ')}| ${normalizeSourceTextGrouping(emitExpression(expression.expression, context))}`
+                : `|${expression.parameters.map((parameter) => getBindingTargetNameRust(parameter.binding, context)).join(', ')}| {\n${indentSourceLines(emitStatements(expression.body, context)).join('\n')}\n}`;
+        case 'identifier': {
+            if (expression.reference.kind === 'binding' && context.cellWrappedBindingIds.has(expression.reference.binding.id))
+                return `${emitIdentifierReferenceRust(expression.reference, context)}.get()`;
+            if (expression.reference.kind === 'binding' &&
+                context.refCellWrappedBindingIds.has(expression.reference.binding.id)) {
+                const target = emitIdentifierReferenceRust(expression.reference, context);
+                if (expression.presence === 'narrowedPresent' &&
+                    context.nullableBindingIds.has(expression.reference.binding.id))
+                    return `${target}.borrow().clone().unwrap()`;
+                return `${target}.borrow().clone()`;
+            }
+            const dualSentinelUnion = getIrExpressionDualSentinelUnionRust(expression, context);
+            if (expression.presence === 'narrowedPresent' && dualSentinelUnion) {
+                const payloads = dualSentinelUnion.variants.filter((variant) => variant.kind === 'tuple');
+                if (payloads.length !== 1) {
+                    emissionError(context, 'present dual-sentinel union requires one Rust payload alternative');
+                }
+                const target = emitIdentifierReferenceRust(expression.reference, context);
+                return `match &${target} { ${dualSentinelUnion.name}::${payloads[0].name}(value) => value.clone(), _ => unreachable!() }`;
+            }
+            if (expression.presence === 'narrowedPresent' &&
+                expression.reference.kind === 'binding' &&
+                context.nullableBindingIds.has(expression.reference.binding.id))
+                return `${emitIdentifierReferenceRust(expression.reference, context)}.clone().unwrap()`;
+            const narrowedReceiver = emitPrimitiveUnionNarrowedReceiverRust(expression, context);
+            if (narrowedReceiver)
+                return expression.narrowedMember === 'string' ? `${narrowedReceiver}.clone()` : `*${narrowedReceiver}`;
+            return emitIdentifierReferenceRust(expression.reference, context);
+        }
+        case 'literal':
+            return emitLiteral(expression.value);
+        case 'new':
+            if (expression.callee.kind !== 'identifier') {
+                emissionError(context, 'qualified constructors require Rust type-path lowering');
+            }
+            assertIrConstructorInvocationAbiRust(expression, context);
+            {
+                const constructor = emitConstructorReferenceRust(expression.callee.reference, context);
+                if (expression.callee.reference.kind === 'ambient' &&
+                    rustTypedArrayConstructorNames.has(expression.callee.reference.name)) {
+                    const oneArgument = expression.arguments[0];
+                    const method = expression.arguments.length === 1 && oneArgument && isIrExpressionArrayBufferRust(oneArgument, context)
+                        ? 'from_buffer'
+                        : ['empty', 'from_source', 'from_buffer_offset', 'from_buffer_range'][expression.arguments.length];
+                    if (!method)
+                        emissionError(context, 'typed-array construction supports zero through three arguments');
+                    return `${constructor}::${method}(${expression.arguments.map((argument) => emitOwnedOperandRust(argument, context)).join(', ')})`;
+                }
+                if (expression.callee.reference.kind === 'ambient' && expression.callee.reference.name === 'DataView') {
+                    const method = [undefined, 'from_buffer', 'from_buffer_offset', 'from_buffer_range'][expression.arguments.length];
+                    if (!method)
+                        emissionError(context, 'DataView construction supports one through three arguments');
+                    return `${constructor}::${method}(${expression.arguments.map((argument) => emitOwnedOperandRust(argument, context)).join(', ')})`;
+                }
+                return `${constructor}::new(${expression.arguments.map((argument) => emitOwnedOperandRust(argument, context)).join(', ')})`;
+            }
+        case 'object':
+            return emitObjectExpressionRust(expression, context);
+        case 'objectRest':
+            return emitObjectRestExpressionRust(expression, context);
+        case 'property': {
+            if (expression.optional)
+                return emitOptionalPropertyExpressionRust(expression, context);
+            const namespaceMember = expression.namespaceMember;
+            if (namespaceMember?.kind === 'binding') {
+                const owner = context.numericEnumNamespaceNames.get(namespaceMember.binding.id);
+                const namespaceFunction = context.module.declarations.some((declaration) => declaration.kind === 'function' &&
+                    declaration.binding.name === expression.name &&
+                    declaration.namespaceMember?.kind === 'binding' &&
+                    declaration.namespaceMember.binding.id === namespaceMember.binding.id);
+                if (owner && namespaceFunction)
+                    return `${owner}::${safeRustValueName(expression.name)}`;
+            }
+            // Rust spells a collection's length `len()`, and it counts in `usize` while the neutral numeric
+            // domain is one type. The cast is what keeps the comparison it feeds well typed.
+            // A member of the ambient surface is spelled by the table, not by the source's name. Rust
+            // counts in `usize`, so a counting member is cast back into the neutral numeric domain.
+            if (expression.member) {
+                const binding = getCompilerRustAmbientMemberBinding(expression.member);
+                if (!binding) {
+                    emissionError(context, `${expression.member.receiver} member ${expression.member.name} has no Rust binding`);
+                }
+                if (binding.kind === 'countingMethod') {
+                    const countingReceiver = emitPrimitiveUnionNarrowedReceiverRust(expression.object, context) ??
+                        emitExpression(expression.object, context);
+                    return `(${countingReceiver}.${binding.targetName}() as f64)`;
+                }
+                if (binding.kind === 'propertyMethod') {
+                    return `${emitExpression(expression.object, context)}.${binding.targetName}()`;
+                }
+            }
+            // A union is a closed set of alternatives in Rust, so its fields are not reachable by name.
+            // A reference control flow narrowed to one alternative reads that alternative's own field; an
+            // unnarrowed one can only read what every alternative agrees on, through the shared accessor.
+            // A class's static members belong to the type, not to a value of it, so Rust paths into the
+            // type: an associated constant for a field and an associated function for a method. Reading
+            // either off a value is the source language's spelling, not Rust's.
+            const classDeclaration = getIrExpressionClassDeclarationRust(expression.object, context);
+            if (classDeclaration) {
+                const field = classDeclaration.fields.find((candidate) => candidate.static && candidate.name === expression.name);
+                const method = classDeclaration.methods.find((candidate) => candidate.static && candidate.name === expression.name);
+                if (field || method) {
+                    return `${getBindingTargetNameRust(classDeclaration.binding, context)}::${field ? constantRustName(expression.name) : safeRustValueName(expression.name)}`;
+                }
+            }
+            // An enum member is a variant, not a field: Rust paths into the type rather than reading off a
+            // value, and the variant keeps the source's own spelling.
+            const enumeration = getIrExpressionEnumDeclarationRust(expression.object, context);
+            if (enumeration) {
+                return `${getBindingTargetNameRust(enumeration.binding, context)}::${safeRustTypeName(expression.name)}`;
+            }
+            // Reading a member of a narrowed `Option` only needs to look at it, so it is borrowed open
+            // rather than copied out.
+            const borrowedNarrow = emitBorrowedNarrowedReceiverRust(expression.object, context);
+            if (borrowedNarrow !== undefined) {
+                return `${borrowedNarrow}.${safeRustValueName(expression.name)}`;
+            }
+            const accessor = getIrExpressionClassAccessorRust(expression.object, expression.name, 'get', context);
+            if (accessor)
+                return `${emitExpression(expression.object, context)}.${safeRustValueName(expression.name)}()`;
+            const union = getIrExpressionTaggedUnionRust(expression.object, context);
+            if (union) {
+                const object = emitExpression(expression.object, context);
+                return expression.object.kind === 'identifier' && expression.object.narrowedMember
+                    ? `${object}.as_${safeRustValueName(expression.object.narrowedMember)}().${safeRustValueName(expression.name)}`
+                    : `${object}.${safeRustValueName(expression.name)}()`;
+            }
+            // A namespace-like ambient symbol has no target name of its own, so the member decides the
+            // whole spelling: `Math.max` is `f64::max`, not `Math::max`.
+            if (expression.object.kind === 'identifier' && expression.object.reference.kind === 'ambient') {
+                const member = getCompilerRuntimeExternalMemberTargetRust(expression.object.reference.name, expression.name, context.options.hostBindings);
+                if (member)
+                    return member;
+            }
+            if (expression.object.kind === 'identifier' &&
+                expression.object.reference.kind === 'this' &&
+                context.abstractFieldNames.has(expression.name)) {
+                return `self.${safeRustValueName(expression.name)}()`;
+            }
+            if (expression.object.kind === 'identifier' &&
+                expression.object.reference.kind === 'this' &&
+                context.compositionBase &&
+                isIrCompositionBaseMemberRust(expression.name, context.compositionBase.baseDeclaration)) {
+                const baseField = context.compositionBase.baseDeclaration.fields.find((candidate) => !candidate.static && candidate.name === expression.name);
+                const cloneSuffix = baseField && !isIrTypeCopyValueRust(baseField.type) ? '.clone()' : '';
+                return `self.${safeRustValueName(context.compositionBase.fieldName)}.${safeRustValueName(expression.name)}${cloneSuffix}`;
+            }
+            const needsClone = expression.object.kind === 'element' ||
+                (expression.object.kind === 'identifier' &&
+                    expression.object.reference.kind === 'this' &&
+                    isIrSelfFieldNonCopyRust(expression.name, context));
+            const owned = needsClone ? '.clone()' : '';
+            return `${emitExpression(expression.object, context)}${isAmbientIdentifier(expression.object) ? '::' : '.'}${safeRustValueName(expression.name)}${owned}`;
+        }
+        case 'regexp':
+            emissionError(context, 'regular expressions require a downstream standard-library mapping');
+        case 'spread':
+            // As in Haxe: a fixed tuple spread is already normalized away, so what reaches here spreads an
+            // unbounded collection into a fixed-arity callee, and Rust has no variadic call to lower it to.
+            emissionError(context, 'spreading an unbounded collection requires a fold or a variadic target');
+        case 'template': {
+            const format = expression.parts
+                .map((part) => (typeof part === 'string' ? part.replaceAll('{', '{{').replaceAll('}', '}}') : '{}'))
+                .join('');
+            const values = expression.parts.flatMap((part) => typeof part === 'string' ? [] : [emitExpression(part, context)]);
+            return `format!(${JSON.stringify(format)}${values.length > 0 ? `, ${values.join(', ')}` : ''})`;
+        }
+        case 'tuple': {
+            const elements = expression.elements.map((element) => {
+                if (!element.expression)
+                    return 'None';
+                const emitted = emitExpression(element.expression, context);
+                return element.optional ? `Some(${emitted})` : emitted;
+            });
+            return `(${elements.join(', ')}${elements.length === 1 ? ',' : ''})`;
+        }
+        case 'tupleSpread':
+            return emitTupleSpreadExpressionRust(expression, context);
+        case 'tupleRest':
+            return `${emitExpression(expression.object, context)}.${String(expression.start)}`;
+        case 'tupleSuffix': {
+            const object = emitExpression(expression.object, context);
+            const elements = Array.from({ length: expression.width }, (_, offset) => `${object}.${String(expression.start + offset)}`);
+            return `(${elements.join(', ')}${elements.length === 1 ? ',' : ''})`;
+        }
+        case 'unary': {
+            if (expression.operator === '++' || expression.operator === '--') {
+                return emitNumericUpdateUnaryRust(expression, context);
+            }
+            if (expression.operator === 'void') {
+                return `{ ${emitExpression(expression.operand, context)}; () }`;
+            }
+            if (expression.operator === 'typeof') {
+                const sourceName = getStaticTypeofNameRust(expression.semantics.operand.flow);
+                if (!sourceName) {
+                    emissionError(context, `typeof on ${expression.semantics.operand.flow} requires Rust runtime representation evidence`);
+                }
+                if (expression.semantics.operand.flow === 'undefined')
+                    return '"undefined".to_owned()';
+                return `{ let _ = &${emitExpression(expression.operand, context)}; ${JSON.stringify(sourceName)}.to_owned() }`;
+            }
+            const operand = expression.semantics.operand.flow === 'number'
+                ? emitNumericEnumOperandRust(expression.operand, context)
+                : emitExpression(expression.operand, context);
+            const operator = emitPrefixUnaryOperatorRust(expression.operator, expression.semantics, context);
+            if (expression.operator === '~')
+                return `(!(${operand} as i32) as f64)`;
+            if (expression.operator === '+' && expression.semantics.operand.flow === 'number')
+                return operand;
+            return `${operator}${operand}`;
+        }
+        case 'undefinedValue':
+            getIrTypeOptionalPayloadRust(expression.type, 'contextual undefined value', context);
+            return 'None';
+        case 'undefinedDefault':
+            return `${emitExpression(expression.value, context)}.unwrap_or_else(|| ${emitExpression(expression.fallback, context)})`;
+    }
+}
+function emitTypedArrayElementAssignmentRust(expression, context) {
+    if (expression.left.kind !== 'element' || !hasOnlyIrTypedArrayReceiversRust(expression.left.semantics.receivers)) {
+        return undefined;
+    }
+    assertOneIrTypedArrayReceiverRust(expression.left.semantics.receivers, context);
+    if (expression.semantics.right.flow !== 'number' ||
+        (expression.operator !== '=' && expression.semantics.left.flow !== 'number')) {
+        emissionError(context, `operator ${expression.operator} on a typed-array element requires numeric Rust lowering`);
+    }
+    const receiverName = getGeneratedTargetNameRust('typed_array', context);
+    const indexName = getGeneratedTargetNameRust('typed_index', context);
+    const valueName = getGeneratedTargetNameRust('typed_value', context);
+    const receiver = emitExpression(expression.left.object, context);
+    const index = emitNumericEnumOperandRust(expression.left.index, context);
+    if (expression.operator === '=') {
+        const right = expression.semantics.right.flow === 'number'
+            ? emitNumericEnumOperandRust(expression.right, context)
+            : emitExpression(expression.right, context);
+        return `{ let ${receiverName} = &${receiver}; let ${indexName} = ${index}; let ${valueName} = ${right}; ${receiverName}.set_index(${indexName}, ${valueName}) }`;
+    }
+    const currentName = getGeneratedTargetNameRust('typed_current', context);
+    const rightName = getGeneratedTargetNameRust('typed_right', context);
+    const right = emitNumericEnumOperandRust(expression.right, context);
+    if (expression.operator === '||=' || expression.operator === '&&=') {
+        const assignCondition = expression.operator === '||='
+            ? `${currentName} == 0.0 || ${currentName}.is_nan()`
+            : `${currentName} != 0.0 && !${currentName}.is_nan()`;
+        return `{ let ${receiverName} = &${receiver}; let ${indexName} = ${index}; let ${currentName} = ${receiverName}.get_index(${indexName}); if ${assignCondition} { let ${valueName} = ${right}; ${receiverName}.set_index(${indexName}, ${valueName}) } else { ${currentName} } }`;
+    }
+    if (expression.operator === '??=') {
+        emissionError(context, 'operator ??= on a typed-array element requires absent-index lowering');
+    }
+    let operation;
+    if (expression.operator === '**=') {
+        operation = `f64::powf(${currentName}, ${rightName})`;
+    }
+    else if (expression.operator === '>>>=') {
+        operation = `(((((${currentName} as i32) as u32) >> (${rightName} as u32)) as f64))`;
+    }
+    else if (expression.operator === '&=' ||
+        expression.operator === '|=' ||
+        expression.operator === '^=' ||
+        expression.operator === '<<=' ||
+        expression.operator === '>>=') {
+        operation = `(((${currentName} as i32) ${expression.operator.slice(0, -1)} (${rightName} as i32)) as f64)`;
+    }
+    else if (expression.operator === '+=' ||
+        expression.operator === '-=' ||
+        expression.operator === '*=' ||
+        expression.operator === '/=' ||
+        expression.operator === '%=') {
+        operation = `${currentName} ${expression.operator.slice(0, -1)} ${rightName}`;
+    }
+    else {
+        emissionError(context, `operator ${expression.operator} on a typed-array element requires Rust lowering`);
+    }
+    return `{ let ${receiverName} = &${receiver}; let ${indexName} = ${index}; let ${currentName} = ${receiverName}.get_index(${indexName}); let ${rightName} = ${right}; let ${valueName} = ${operation}; ${receiverName}.set_index(${indexName}, ${valueName}) }`;
+}
+function hasOnlyIrTypedArrayReceiversRust(receivers) {
+    return receivers.every((receiver) => rustTypedArrayReceiverNames.has(receiver));
+}
+function assertOneIrTypedArrayReceiverRust(receivers, context) {
+    if (receivers.length !== 1) {
+        emissionError(context, 'mixed typed-array receivers require Rust representation-union lowering');
+    }
+}
+function isIrExpressionTypedArrayRust(expression, context) {
+    let type;
+    if (expression.kind === 'identifier' && expression.reference.kind === 'binding') {
+        type = context.bindingTypes.get(expression.reference.binding.id);
+    }
+    else if (expression.kind === 'call') {
+        if (expression.callee.kind === 'property' &&
+            expression.callee.member?.receiver === 'typedArray' &&
+            (expression.callee.member.name === 'slice' || expression.callee.member.name === 'subarray')) {
+            return true;
+        }
+        type = expression.semantics.resultType;
+    }
+    else if (expression.kind === 'cast') {
+        type = expression.type;
+    }
+    else if (expression.kind === 'new' &&
+        expression.callee.kind === 'identifier' &&
+        expression.callee.reference.kind === 'ambient') {
+        return rustTypedArrayConstructorNames.has(expression.callee.reference.name);
+    }
+    return isIrTypeTypedArrayRust(type);
+}
+function isIrExpressionArrayBufferRust(expression, context) {
+    if (expression.kind === 'identifier' && expression.reference.kind === 'binding') {
+        const type = context.bindingTypes.get(expression.reference.binding.id);
+        return type?.kind === 'named' && type.reference.kind === 'ambient' && type.reference.name === 'ArrayBuffer';
+    }
+    if (expression.kind === 'property' &&
+        expression.name === 'buffer' &&
+        (expression.member?.receiver === 'dataView' || expression.member?.receiver === 'typedArray')) {
+        return true;
+    }
+    if (expression.kind === 'cast') {
+        return (expression.type.kind === 'named' &&
+            expression.type.reference.kind === 'ambient' &&
+            expression.type.reference.name === 'ArrayBuffer');
+    }
+    return (expression.kind === 'new' &&
+        expression.callee.kind === 'identifier' &&
+        expression.callee.reference.kind === 'ambient' &&
+        expression.callee.reference.name === 'ArrayBuffer');
+}
+function isIrExpressionDataViewRust(expression, context) {
+    let type;
+    if (expression.kind === 'identifier' && expression.reference.kind === 'binding') {
+        type = context.bindingTypes.get(expression.reference.binding.id);
+    }
+    else if (expression.kind === 'cast') {
+        type = expression.type;
+    }
+    else if (expression.kind === 'new' &&
+        expression.callee.kind === 'identifier' &&
+        expression.callee.reference.kind === 'ambient') {
+        return expression.callee.reference.name === 'DataView';
+    }
+    return type?.kind === 'named' && type.reference.kind === 'ambient' && type.reference.name === 'DataView';
+}
+function isIrTypeTypedArrayRust(type) {
+    return (type?.kind === 'named' &&
+        type.reference.kind === 'ambient' &&
+        rustTypedArrayConstructorNames.has(type.reference.name));
+}
+// `Promise<T>` in the return position of an `async fn` is the future Rust already builds, so the
+// emitted signature carries `T`. Anywhere else the task type has no native spelling yet.
+function getIrTaskAwaitedTypeRust(type, context) {
+    if (type.kind !== 'named' || type.reference.kind !== 'ambient' || type.reference.name !== 'Promise') {
+        emissionError(context, 'an async function must return a task type');
+    }
+    const awaited = type.typeArguments[0];
+    if (type.typeArguments.length !== 1 || !awaited) {
+        emissionError(context, 'a task type requires one awaited type argument');
+    }
+    return awaited;
+}
+// Rust distinguishes a method that observes its receiver from one that changes it, and the two are
+// not interchangeable to a caller. Taking `&mut self` everywhere is the conservative choice that
+// makes every method exclusive, so a shared read of one value blocks a read of another. The mutation
+// evidence is already in the body: an assignment whose target reaches `this`, or a bare rebinding of
+// it, is what requires exclusivity.
+// Which methods need an exclusive receiver. Writing through `this` is the direct case; calling a
+// method that writes is the transitive one, and missing it emits a `&self` method that calls a
+// `&mut self` method — which Rust rejects. The relation is closed to a fixed point because a caller
+// of a caller needs the same receiver.
+// Keyed by the name the method is emitted under, not the name it was written under: a getter and a
+// setter share one source name and Rust gives them two, so keying by the source name would hand the
+// getter the setter's mutable receiver.
+function getIrClassMutatingMethodNamesRust(declaration) {
+    const mutating = new Set(declaration.methods
+        .filter((method) => hasIrFunctionSignatureThisMutationRust(method))
+        .map((method) => getIrClassMethodTargetNameRust(method)));
+    const calls = new Map(declaration.methods.map((method) => [getIrClassMethodTargetNameRust(method), getIrFunctionSignatureSelfCallNamesRust(method)]));
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const method of declaration.methods) {
+            const target = getIrClassMethodTargetNameRust(method);
+            if (mutating.has(target))
+                continue;
+            if ((calls.get(target) ?? []).some((name) => mutating.has(safeRustValueName(name)))) {
+                mutating.add(target);
+                changed = true;
+            }
+        }
+    }
+    return mutating;
+}
+function getIrFunctionSignatureSelfCallNamesRust(method) {
+    const names = [];
+    const observer = {
+        expression(expression) {
+            if (expression.kind === 'call' &&
+                expression.callee.kind === 'property' &&
+                expression.callee.object.kind === 'identifier' &&
+                expression.callee.object.reference.kind === 'this') {
+                names.push(expression.callee.name);
+            }
+            return undefined;
+        },
+    };
+    method.body.forEach((statement) => analyzeIrStatementSubtreeTraversal(statement, observer));
+    return names;
+}
+function hasIrFunctionSignatureThisMutationRust(method) {
+    let mutates = false;
+    const reachesThis = (expression) => {
+        if (expression.kind === 'identifier')
+            return expression.reference.kind === 'this';
+        if (expression.kind === 'property' || expression.kind === 'element')
+            return reachesThis(expression.object);
+        return false;
+    };
+    const observer = {
+        expression(expression) {
+            // An assignment and an update both write through their target. `this.count++` is a mutation
+            // as much as `this.count = 1`, and the untyped walk this replaced missed it entirely.
+            const target = expression.kind === 'assignment'
+                ? expression.left
+                : expression.kind === 'unary'
+                    ? expression.operand
+                    : undefined;
+            if (!target || !reachesThis(target))
+                return undefined;
+            mutates = true;
+            return false;
+        },
+    };
+    method.body.forEach((statement) => analyzeIrStatementSubtreeTraversal(statement, observer));
+    return mutates;
+}
+function emitFunction(declaration, outer) {
+    if (declaration.namespaceMember) {
+        emissionError(outer, `value namespace function ${declaration.binding.name} requires Rust namespace lowering`);
+    }
+    const context = {
+        ...outer,
+        activeTypeParameters: declaration.typeParameters,
+        enclosingReturnType: declaration.returns,
+        returnsAbsent: hasIrTypeAbsentMember(declaration.returns),
+    };
+    // Rust has native suspension, so it declines the neutral state-machine lowering that Haxe elects
+    // and emits `async fn` instead. The awaited type of an async function is its return type: the
+    // future is implied by `async`, so the task wrapper is dropped rather than named.
+    return [
+        `${declaration.exported ? 'pub ' : ''}${declaration.async ? 'async ' : ''}fn ${getBindingTargetNameRust(declaration.binding, context)}${emitTypeParameters(declaration.typeParameters, context)}(${declaration.parameters.map((parameter) => emitParameter(parameter, context)).join(', ')}) -> ${emitType(declaration.async ? getIrTaskAwaitedTypeRust(declaration.returns, context) : declaration.returns, context)} {`,
+        ...indentSourceLines([
+            ...declaration.parameters.flatMap((parameter) => parameter.initializer
+                ? [
+                    `let ${getBindingTargetNameRust(parameter.binding, context)} = ${getBindingTargetNameRust(parameter.binding, context)}.unwrap_or_else(|| ${emitExpression(parameter.initializer, context)});`,
+                ]
+                : []),
+            ...emitStatements(declaration.body, context),
+        ]),
+        '}',
+    ];
+}
+function emitImports(imports, context) {
+    const lines = new Set();
+    for (const imported of imports) {
+        if (imported.bindings.length === 0)
+            continue;
+        const module = rustImportModule(imported.specifier, context);
+        const names = imported.bindings.map((binding) => {
+            if (binding.imported === '*' || binding.imported === 'default') {
+                emissionError(context, `${binding.imported} imports require explicit Rust mapping for ${imported.specifier}`);
+            }
+            const importedName = binding.binding.space === 'type' || /^[A-Z]/u.test(binding.imported)
+                ? safeRustTypeName(binding.imported)
+                : safeRustValueName(binding.imported);
+            const localName = getBindingTargetNameRust(binding.binding, context);
+            return importedName === localName ? importedName : `${importedName} as ${localName}`;
+        });
+        lines.add(`use ${module}::${emitUseTreeRust(names.sort())};`);
+    }
+    return [...lines].sort();
+}
+// A facade module names what it re-exports and where it came from, which is exactly what Rust's
+// `pub use` says. The name a target spells it by depends on which space it lives in, so a re-export
+// carries the same value-versus-type decision an import does.
+function emitReexportsRust(exports, context) {
+    const lines = new Set();
+    for (const exported of exports) {
+        if (exported.kind === 'local')
+            continue;
+        if (exported.kind === 'all') {
+            lines.add(`pub use ${rustImportModule(exported.specifier, context)}::*;`);
+            continue;
+        }
+        if (exported.kind === 'namespace') {
+            const target = safeRustValueName(exported.exported);
+            lines.add(`pub use ${rustImportModule(exported.specifier, context)} as ${target};`);
+            continue;
+        }
+        if (exported.kind !== 'reexport')
+            emissionError(context, 'default exports require Rust module-facade lowering');
+        const module = rustImportModule(exported.specifier, context);
+        const source = exported.typeOnly || /^[A-Z]/u.test(exported.imported)
+            ? safeRustTypeName(exported.imported)
+            : safeRustValueName(exported.imported);
+        const target = exported.typeOnly || /^[A-Z]/u.test(exported.exported)
+            ? safeRustTypeName(exported.exported)
+            : safeRustValueName(exported.exported);
+        lines.add(`pub use ${module}::${emitUseTreeRust([source === target ? source : `${source} as ${target}`])};`);
+    }
+    return [...lines].sort();
+}
+function emitInterface(declaration, context) {
+    if (declaration.extends.length > 0)
+        emissionError(context, `interface ${declaration.binding.name} inheritance requires record flattening`);
+    // A shape a class implements is a contract on behaviour, which Rust spells as a trait. A shape
+    // nothing implements is data, which Rust spells as a struct — and emitting the second as the first
+    // would make an ordinary object type unconstructible.
+    if (hasIrModuleClassImplementingRust(declaration, context)) {
+        return emitTraitRust(declaration, context);
+    }
+    return emitRecord(getBindingTargetNameRust(declaration.binding, context), declaration.properties, declaration.typeParameters, declaration.exported, context);
+}
+function emitTraitRust(declaration, context) {
+    const visibility = declaration.exported || context.apiReferencedBindingIds.has(declaration.binding.id) ? 'pub ' : '';
+    return [
+        `${visibility}trait ${getBindingTargetNameRust(declaration.binding, context)}${emitTypeParameters(declaration.typeParameters, context)} {`,
+        ...declaration.properties.map((property) => {
+            // A Rust trait holds no data, so a data property becomes the accessor that reads it. Fields and
+            // methods live in different namespaces, so the accessor keeps the property's own name.
+            if (property.type.kind !== 'function') {
+                if (property.optional) {
+                    return emissionError(context, `interface ${declaration.binding.name} property ${property.name} requires Rust optional accessor lowering`);
+                }
+                return `  fn ${safeRustValueName(property.name)}(&self) -> ${emitType(property.type, context)};`;
+            }
+            const parameters = property.type.parameters
+                .map((parameter, index) => `${safeRustValueName(parameter.name ?? `argument${String(index)}`)}: ${emitType(parameter.type, context)}`)
+                .join(', ');
+            return `  fn ${safeRustValueName(property.name)}(&self${parameters ? `, ${parameters}` : ''}) -> ${emitType(property.type.returns, context)};`;
+        }),
+        '}',
+    ];
+}
+function hasIrModuleClassImplementingRust(declaration, context) {
+    return context.module.declarations.some((candidate) => candidate.kind === 'class' &&
+        candidate.implements.some((implemented) => implemented.kind === 'named' &&
+            implemented.reference.kind === 'binding' &&
+            implemented.reference.binding.id === declaration.binding.id));
+}
+function emitConstructorReferenceRust(reference, context) {
+    if (reference.kind === 'super')
+        emissionError(context, 'super cannot be used as a Rust constructor value');
+    if (reference.kind === 'this')
+        emissionError(context, 'this cannot be used as a Rust constructor');
+    if (reference.kind !== 'ambient')
+        return getBindingTargetNameRust(reference.binding, context);
+    const targetName = getCompilerRuntimeExternalSymbolTargetRust(reference.name, 'value', context.options.hostBindings);
+    if (!targetName)
+        emissionError(context, `external constructor ${reference.name} has no Rust binding`);
+    return isCompilerRuntimeExternalSymbolProvidedRust(reference.name, 'value', context.options.hostBindings)
+        ? recordRuntimeTypeRust(targetName, context)
+        : targetName;
+}
+function assertIrConstructorInvocationAbiRust(expression, context) {
+    if (expression.callee.kind === 'identifier' && expression.callee.reference.kind === 'ambient')
+        return;
+    // A class this module declares has an associated `new` whenever its constructor was lowered to one,
+    // so the call is emitted; a class whose constructor was refused has nothing to call.
+    if (expression.callee.kind === 'identifier' && expression.callee.reference.kind === 'binding') {
+        const target = context.module.declarations.find((candidate) => candidate.kind === 'class' &&
+            expression.callee.kind === 'identifier' &&
+            expression.callee.reference.kind === 'binding' &&
+            candidate.binding.id === expression.callee.reference.binding.id);
+        if (target?.kind === 'class') {
+            const abstractBase = getIrClassStatelessAbstractBaseRust(target, context);
+            if (getIrClassConstructorFieldAssignmentsRust(target, abstractBase !== undefined))
+                return;
+            const concreteBase = !abstractBase ? getIrClassConcreteBaseRust(target, context) : undefined;
+            if (concreteBase && getIrClassCompositionConstructorRust(target, concreteBase))
+                return;
+        }
+    }
+    emissionError(context, 'class constructor calls require Rust initialization lowering');
+}
+function emitIdentifierReferenceRust(reference, context) {
+    if (reference.kind === 'super')
+        emissionError(context, 'super requires Rust inheritance lowering');
+    if (reference.kind === 'this')
+        return 'self';
+    if (reference.kind === 'ambient') {
+        if (reference.name === 'undefined') {
+            emissionError(context, 'undefined expressions require Rust Option-aware lowering');
+        }
+        const targetName = getCompilerRuntimeExternalSymbolTargetRust(reference.name, 'value', context.options.hostBindings);
+        if (!targetName)
+            emissionError(context, `external value ${reference.name} has no Rust binding`);
+        return isCompilerRuntimeExternalSymbolProvidedRust(reference.name, 'value', context.options.hostBindings)
+            ? recordRuntimeTypeRust(targetName, context)
+            : targetName;
+    }
+    return getBindingTargetNameRust(reference.binding, context);
+}
+function emitLiteral(value) {
+    if (typeof value === 'string')
+        return `${JSON.stringify(value)}.to_owned()`;
+    if (value === null)
+        return 'None';
+    if (typeof value === 'number' && Number.isInteger(value) && !/[eE]/u.test(String(value))) {
+        return `${String(value)}.0`;
+    }
+    return String(value);
+}
+function emitCallArgumentsRust(expression, context) {
+    const signature = expression.semantics.signature;
+    if (signature &&
+        signature.restParameter === undefined &&
+        typeof signature.providedArgumentCount === 'number' &&
+        signature.providedArgumentCount > signature.parameterCount) {
+        emissionError(context, 'extra JavaScript call arguments require target-neutral erasure lowering');
+    }
+    const borrowed = getIrCallBorrowedPositionsRust(expression, context);
+    const defaults = expression.semantics.defaultParameters;
+    const optionals = expression.semantics.optionalParameters;
+    if (!defaults && !optionals) {
+        return expression.arguments.map((argument, index) => borrowed.has(index) ? emitLentOperandRust(argument, context) : emitOwnedOperandRust(argument, context));
+    }
+    const plan = defaults ?? optionals;
+    if (!plan)
+        return expression.arguments.map((argument) => emitOwnedOperandRust(argument, context));
+    if (plan.providedArgumentCount === 'dynamic') {
+        emissionError(context, 'spread calls into optional or default parameters require Rust ABI expansion lowering');
+    }
+    if (expression.arguments.length > plan.parameterCount) {
+        emissionError(context, 'extra JavaScript call arguments require Rust ABI erasure lowering');
+    }
+    const wrapped = new Set([...(defaults?.defaulted ?? []), ...(optionals?.optional ?? [])]);
+    const defaultProvided = new Map(defaults?.provided.map((provided) => [provided.position, provided]) ?? []);
+    const optionalProvided = new Map(optionals?.provided.map((provided) => [provided.position, provided]) ?? []);
+    return Array.from({ length: plan.parameterCount }, (_, index) => {
+        const argument = expression.arguments[index];
+        if (!argument) {
+            if (!wrapped.has(index)) {
+                emissionError(context, `missing required call argument at position ${String(index)}`);
+            }
+            return 'None';
+        }
+        const providedEvidence = defaultProvided.get(index) ?? optionalProvided.get(index);
+        if (providedEvidence?.value === 'undefined' || argument.kind === 'undefinedValue')
+            return 'None';
+        const emitted = emitExpression(argument, context);
+        const optionalEvidence = optionalProvided.get(index);
+        if (optionalEvidence && hasIrTypeNullMemberRust(optionalEvidence.parameterType)) {
+            return isNullableType(optionalEvidence.argumentType) ? `Some(${emitted})` : `Some(Some(${emitted}))`;
+        }
+        if (optionalEvidence &&
+            isNullableType(optionalEvidence.parameterType) &&
+            isNullableType(optionalEvidence.argumentType)) {
+            return emitted;
+        }
+        return wrapped.has(index) ? `Some(${emitted})` : emitted;
+    });
+}
+function emitOptionalCallExpressionRust(expression, context) {
+    const semantics = expression.semantics.optionalChain;
+    if (!semantics)
+        emissionError(context, 'optional call lacks neutral optional-chain evidence');
+    const arguments_ = emitCallArgumentsRust(expression, context).join(', ');
+    const callee = emitExpression(expression.callee, context);
+    if (semantics.receiverNullish === 'excluded')
+        return `${callee}(${arguments_})`;
+    getIrTypeOptionalPayloadRust(semantics.receiverType, 'optional call receiver', context);
+    const operation = isNullableType(semantics.valueType) ? 'and_then' : 'map';
+    return `${callee}.as_ref().${operation}(|optional_chain_value| optional_chain_value(${arguments_}))`;
+}
+function emitOptionalElementExpressionRust(expression, context) {
+    const semantics = expression.semantics.optionalChain;
+    if (!semantics)
+        emissionError(context, 'optional element access lacks neutral optional-chain evidence');
+    if (semantics.receiverNullish === 'excluded') {
+        return emitRequiredElementExpressionRust(expression, context);
+    }
+    const receiver = getIrTypeOptionalPayloadRust(semantics.receiverType, 'optional element receiver', context);
+    const object = emitExpression(expression.object, context);
+    const value = 'optional_chain_value';
+    if (receiver.kind === 'tuple') {
+        const index = getElementAccessTupleIndexRust(expression, context);
+        const operation = receiver.elements[index]?.optional ? 'and_then' : 'map';
+        return `${object}.as_ref().${operation}(|${value}| ${value}.${String(index)}.clone())`;
+    }
+    if (receiver.kind === 'array') {
+        return `${object}.as_ref().and_then(|${value}| ${value}.get(${emitExpression(expression.index, context)} as usize).cloned())`;
+    }
+    emissionError(context, 'optional element access requires array or fixed-tuple receiver evidence');
+}
+function emitOptionalPropertyExpressionRust(expression, context) {
+    const semantics = expression.optionalChain;
+    if (!semantics)
+        emissionError(context, 'optional property access lacks neutral optional-chain evidence');
+    const object = emitExpression(expression.object, context);
+    const property = safeRustValueName(expression.name);
+    if (semantics.receiverNullish === 'excluded') {
+        // Indexing yields a place the caller does not own, so the field read out of it is a copy.
+        const owned = expression.object.kind === 'element' ? '.clone()' : '';
+        return `${object}${isAmbientIdentifier(expression.object) ? '::' : '.'}${property}${owned}`;
+    }
+    getIrTypeOptionalPayloadRust(semantics.receiverType, 'optional property receiver', context);
+    const operation = isNullableType(semantics.valueType) ? 'and_then' : 'map';
+    return `${object}.as_ref().${operation}(|optional_chain_value| optional_chain_value.${property}.clone())`;
+}
+function emitRequiredElementExpressionRust(expression, context) {
+    const closedSelection = emitClosedKeyElementSelectionRust(expression, context);
+    if (closedSelection)
+        return closedSelection;
+    if (expression.semantics.receivers.includes('object')) {
+        emissionError(context, 'computed object access requires JavaScript property-key coercion lowering');
+    }
+    if (expression.semantics.receivers.includes('tuple')) {
+        const index = getElementAccessTupleIndexRust(expression, context);
+        return `${emitExpression(expression.object, context)}.${String(index)}`;
+    }
+    return `${emitExpression(expression.object, context)}[${emitExpression(expression.index, context)} as usize]`;
+}
+// A finite string-key domain identifies every field this access can reach. Rust records have no
+// string subscript, so select the represented field explicitly while evaluating the receiver and key
+// once, in source order. Borrowing the receiver keeps the selection from moving a source binding; the
+// selected field is cloned into the expression's owned result.
+function emitClosedKeyElementSelectionRust(expression, context) {
+    const keys = expression.semantics.closedKeys;
+    if (!keys)
+        return undefined;
+    let objectType = inferIrExpressionTypeRust(expression.object, context);
+    if (objectType?.kind === 'union' &&
+        'presence' in expression.object &&
+        expression.object.presence === 'narrowedPresent') {
+        const present = objectType.types.filter((member) => member.kind !== 'null' && member.kind !== 'undefined');
+        if (present.length === 1)
+            objectType = present[0];
+    }
+    const properties = objectType ? getIrObjectTypePropertiesRust(objectType, context) : undefined;
+    if (!objectType || !properties) {
+        emissionError(context, 'closed-key element access requires represented Rust object storage');
+    }
+    const members = new Map(properties
+        .filter((property) => !property.computedKey && !property.phantom)
+        .map((property) => [property.name, property]));
+    const selections = keys.map((key) => ({ key, property: members.get(key) }));
+    const absent = selections.find((selection) => !selection.property);
+    if (absent) {
+        emissionError(context, `closed key ${absent.key} is not a represented Rust object member`);
+    }
+    const memberTypes = selections.map(({ property }) => {
+        const emitted = emitType(property.type, context);
+        return property.optional ? `Option<${emitted}>` : emitted;
+    });
+    const distinctTypes = [...new Set(memberTypes)];
+    if (distinctTypes.length !== 1) {
+        emissionError(context, `closed-key selection over ${String(distinctTypes.length)} member types requires one Rust representation`);
+    }
+    const receiver = getGeneratedTargetNameRust('selection_receiver', context);
+    const selectionKey = getGeneratedTargetNameRust('selection_key', context);
+    const branches = selections.map(({ key, property }) => `${JSON.stringify(key)} => ${receiver}.${safeRustValueName(property.name)}.clone(),`);
+    return `{ let ${receiver} = &${emitExpression(expression.object, context)}; let ${selectionKey} = &${emitExpression(expression.index, context)}; match ${selectionKey}.as_str() { ${branches.join(' ')} _ => unreachable!("Flight finite-key selection reached no member"), } }`;
+}
+function getIrTypeOptionalPayloadRust(type, subject, context) {
+    if (type.kind !== 'union')
+        emissionError(context, `${subject} requires one concrete Rust Option payload`);
+    const concrete = type.types.filter((member) => member.kind !== 'null' && member.kind !== 'undefined');
+    if (concrete.length !== 1)
+        emissionError(context, `${subject} requires one concrete Rust Option payload`);
+    return concrete[0];
+}
+function emitObjectRestExpressionRust(expression, context) {
+    if (expression.excluded.some((key) => key.kind === 'computed')) {
+        emissionError(context, 'computed object rest requires Rust property-key and record projection lowering');
+    }
+    const properties = getIrObjectRestPropertiesRust(expression, context);
+    if (!properties)
+        emissionError(context, 'object rest requires closed residual-record type evidence');
+    const shape = createIrObjectTypeShapeIdentity(properties);
+    const existing = context.objectRestRecords.get(shape);
+    const recordName = existing?.name ?? getGeneratedTargetNameRust('ObjectRestRecord', context);
+    if (!existing)
+        context.objectRestRecords.set(shape, { name: recordName, properties });
+    const object = emitExpression(expression.object, context);
+    const fields = properties.map((property) => {
+        const name = safeRustValueName(property.name);
+        return {
+            initializer: `${name}: ${object}.${name}.clone(),`,
+        };
+    });
+    return `${recordName} { ${fields.map((field) => field.initializer).join(' ')} }`;
+}
+function getIrObjectRestPropertiesRust(expression, context) {
+    const explicit = getIrObjectTypePropertiesRust(expression.type, context);
+    if (explicit)
+        return explicit;
+    if (expression.object.reference.kind !== 'binding')
+        return undefined;
+    const sourceType = context.bindingTypes.get(expression.object.reference.binding.id);
+    if (!sourceType)
+        return undefined;
+    const sourceProperties = getIrObjectTypePropertiesRust(sourceType, context);
+    if (!sourceProperties)
+        return undefined;
+    const excluded = new Set(expression.excluded.flatMap((key) => (key.kind === 'named' ? [key.name] : [])));
+    return sourceProperties.filter((property) => !excluded.has(property.name));
+}
+function emitObjectExpressionRust(expression, context) {
+    if (expression.members.some((member) => member.kind === 'getAccessor')) {
+        emissionError(context, 'object getters require target-specific accessor lowering');
+    }
+    const target = emitType(expression.type, context);
+    const properties = getIrObjectConstructionPropertiesRust(expression.type, context);
+    const members = expression.members.filter((member) => member.kind === 'property');
+    const names = new Set();
+    const fields = members.map((member) => {
+        names.add(member.name);
+        const property = properties?.find((candidate) => candidate.name === member.name);
+        const value = emitExpression(member.value, context);
+        return `${safeRustValueName(member.name)}: ${property?.optional ? `Some(${value})` : value},`;
+    });
+    for (const property of properties ?? []) {
+        if (names.has(property.name))
+            continue;
+        fields.push(`${safeRustValueName(property.name)}: None,`);
+    }
+    return `${target} { ${fields.join(' ')} }`;
+}
+function inferIrExpressionTypeRust(expression, context) {
+    switch (expression.kind) {
+        case 'literal':
+            if (expression.value === null)
+                return { kind: 'null' };
+            return typeof expression.value === 'string'
+                ? { kind: 'primitive', name: 'string' }
+                : typeof expression.value === 'number'
+                    ? { kind: 'primitive', name: 'number' }
+                    : { kind: 'primitive', name: 'boolean' };
+        case 'cast':
+            return expression.type;
+        case 'call':
+            return expression.semantics.resultType;
+        case 'identifier':
+            return expression.reference.kind === 'binding'
+                ? context.bindingTypes.get(expression.reference.binding.id)
+                : undefined;
+        case 'binary':
+        case 'unary': {
+            const domain = expression.semantics.result;
+            return domain === 'bigint' ||
+                domain === 'boolean' ||
+                domain === 'number' ||
+                domain === 'string' ||
+                domain === 'symbol'
+                ? { kind: 'primitive', name: domain }
+                : domain === 'null'
+                    ? { kind: 'null' }
+                    : domain === 'undefined'
+                        ? { kind: 'undefined' }
+                        : undefined;
+        }
+        case 'object':
+            return expression.type;
+        case 'property': {
+            const binding = expression.member ? getCompilerRustAmbientMemberBinding(expression.member) : undefined;
+            return binding?.kind === 'countingMethod' ? { kind: 'primitive', name: 'number' } : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+function getIrObjectConstructionPropertiesRust(type, context) {
+    return getIrObjectTypePropertiesRust(type, context);
+}
+function getIrObjectTypeTargetNameRust(properties, context) {
+    const shape = createIrObjectTypeShapeIdentity(properties);
+    const existing = context.anonymousObjectRecords.get(shape);
+    if (existing)
+        return existing.name;
+    const name = getGeneratedTargetNameRust('AnonymousObjectRecord', context);
+    context.anonymousObjectRecords.set(shape, { name, properties });
+    return name;
+}
+function getOrCreateCallableObjectRecordRust(type, context) {
+    const callables = type.types.filter((member) => member.kind === 'function');
+    if (callables.length !== 1)
+        return undefined;
+    const callable = callables[0];
+    if (callable.typeParameters.length > 0) {
+        emissionError(context, 'generic callable-object intersections require Rust monomorphization');
+    }
+    const shapes = type.types
+        .filter((member) => member !== callable)
+        .map((member) => getIrObjectTypePropertiesRust(member, context));
+    if (shapes.length === 0 || shapes.some((shape) => !shape))
+        return undefined;
+    const properties = mergeIrObjectTypePropertiesRust(shapes.flatMap((shape) => shape));
+    if (!properties)
+        return undefined;
+    const key = JSON.stringify({
+        callable,
+        parameters: context.activeTypeParameters.map((parameter) => parameter.binding.id),
+        shape: createIrObjectTypeShapeIdentity(properties),
+    });
+    const existing = context.callableObjectRecords.get(key);
+    if (existing)
+        return existing;
+    context.needsRcImport.add('Rc');
+    const record = {
+        callable: {
+            parameters: callable.parameters.map((parameter) => {
+                const emitted = emitType(parameter.type, context);
+                return parameter.optional ? `Option<${emitted}>` : emitted;
+            }),
+            returns: emitType(callable.returns, context),
+        },
+        fields: properties.map((property) => ({
+            name: safeRustValueName(property.name),
+            optional: property.optional,
+            rustType: emitType(property.type, context),
+        })),
+        name: getGeneratedTargetNameRust('AnonymousCallableObject', context),
+        typeParameters: context.activeTypeParameters,
+    };
+    context.callableObjectRecords.set(key, record);
+    return record;
+}
+function emitCallableObjectRecordRust(record, context) {
+    const parameters = record.callable.parameters.join(', ');
+    const signature = `dyn Fn(${parameters}) -> ${record.callable.returns}`;
+    const typeParameters = emitTypeParameters(record.typeParameters, context);
+    const typeArguments = emitTypeArguments(record.typeParameters, context);
+    return [
+        '#[derive(Clone)]',
+        `pub struct ${record.name}${typeParameters} {`,
+        `  pub callback: Rc<${signature}>,`,
+        ...record.fields.map((field) => `  pub ${field.name}: ${field.optional ? `Option<${field.rustType}>` : field.rustType},`),
+        '}',
+        '',
+        `impl${typeParameters} std::ops::Deref for ${record.name}${typeArguments} {`,
+        `  type Target = ${signature};`,
+        '',
+        '  fn deref(&self) -> &Self::Target {',
+        '    self.callback.as_ref()',
+        '  }',
+        '}',
+    ];
+}
+// A value Rust moves is invalidated at the site that consumes it, so a binding the source still
+// needs afterwards is cloned into the consuming position rather than handed over. Every emitted
+// record derives `Clone`, so this is always available. The election is per binding rather than per
+// use, so the last consumption clones as well: correct, at the cost of one copy the source did not
+// need, and a binding consumed once is left to move.
+function emitOwnedOperandRust(expression, context) {
+    const source = emitExpression(expression, context);
+    if (expression.kind === 'identifier' &&
+        expression.reference.kind === 'binding' &&
+        context.movedBindingIds.has(expression.reference.binding.id))
+        return `${source}.clone()`;
+    if (expression.kind === 'element' && !expression.optional && expression.semantics.receivers.includes('array'))
+        return `${source}.clone()`;
+    return source;
+}
+function emitReturnedExpressionRust(expression, context) {
+    const source = emitExpression(expression, context);
+    if (expression.kind === 'element' && !expression.optional && expression.semantics.receivers.includes('array'))
+        return `${source}.clone()`;
+    if (context.enclosingReturnType?.kind === 'function' && expression.kind === 'function') {
+        context.needsRcImport.add('Rc');
+        return emitCellCloneBlockRust(`Rc::new(move ${source})`, expression, context);
+    }
+    return source;
+}
+function collectIrModuleApiReferencedBindingIdsRust(module) {
+    const ids = new Set();
+    function collectFromType(type) {
+        switch (type.kind) {
+            case 'named':
+                if (type.reference.kind === 'binding')
+                    ids.add(type.reference.binding.id);
+                for (const arg of type.typeArguments)
+                    collectFromType(arg);
+                break;
+            case 'array':
+                collectFromType(type.element);
+                break;
+            case 'conditionalFacet':
+                collectFromType(type.check);
+                collectFromType(type.facet);
+                break;
+            case 'function':
+                for (const parameter of type.parameters)
+                    collectFromType(parameter.type);
+                collectFromType(type.returns);
+                break;
+            case 'intersection':
+            case 'union':
+                for (const member of type.types)
+                    collectFromType(member);
+                break;
+            case 'object':
+                for (const property of type.properties)
+                    collectFromType(property.type);
+                break;
+            case 'tuple':
+                for (const element of type.elements)
+                    collectFromType(element.type);
+                break;
+            case 'indexedAccess':
+                collectFromType(type.object);
+                collectFromType(type.index);
+                break;
+            case 'keyof':
+                collectFromType(type.type);
+                break;
+        }
+    }
+    for (const declaration of module.declarations) {
+        if (!declaration.exported)
+            continue;
+        if (declaration.kind === 'function') {
+            for (const parameter of declaration.parameters)
+                collectFromType(parameter.type);
+            collectFromType(declaration.returns);
+        }
+        else if (declaration.kind === 'class') {
+            for (const field of declaration.fields)
+                if (field.visibility === 'public')
+                    collectFromType(field.type);
+            for (const method of declaration.methods) {
+                if (method.visibility !== 'public')
+                    continue;
+                for (const parameter of method.parameters)
+                    collectFromType(parameter.type);
+                collectFromType(method.returns);
+            }
+        }
+    }
+    return ids;
+}
+function collectIrModuleArrayElementBindingIdsRust(module) {
+    const candidates = new Set();
+    const coalesceTargets = new Set();
+    analyzeIrModuleTraversal(module, {
+        variable(variable) {
+            if ('binding' in variable &&
+                variable.initializer?.kind === 'element' &&
+                !variable.initializer.optional &&
+                variable.initializer.semantics.receivers.includes('array')) {
+                candidates.add(variable.binding.id);
+            }
+            return undefined;
+        },
+        expression(expression) {
+            if (expression.kind === 'binary' &&
+                expression.operator === '??' &&
+                expression.left.kind === 'identifier' &&
+                expression.left.reference.kind === 'binding') {
+                coalesceTargets.add(expression.left.reference.binding.id);
+            }
+            return undefined;
+        },
+    });
+    const ids = new Set();
+    for (const id of candidates) {
+        if (coalesceTargets.has(id))
+            ids.add(id);
+    }
+    return ids;
+}
+function collectIrModuleBindingTypesRust(module) {
+    const result = new Map();
+    analyzeIrModuleTraversal(module, {
+        parameter(parameter) {
+            result.set(parameter.binding.id, parameter.type);
+        },
+        variable(variable) {
+            if ('binding' in variable && variable.type) {
+                result.set(variable.binding.id, variable.type);
+            }
+        },
+    });
+    return result;
+}
+// `unknown` has no single native Rust representation. A binding used exclusively through one
+// explicit source assertion does, however: the Rust API can expose that asserted type directly and
+// erase the assertion. Any unasserted use or disagreement leaves the binding opaque, so this never
+// guesses a dynamic conversion that the source did not perform.
+function collectAssertedUnknownBindingTypesRust(module, bindingTypes) {
+    const candidates = new Map();
+    const disqualified = new Set();
+    const parameters = new Set();
+    analyzeIrModuleTraversal(module, {
+        parameter(parameter) {
+            if (parameter.type.kind === 'unknown')
+                parameters.add(parameter.binding.id);
+        },
+    });
+    analyzeIrModuleTraversal(module, {
+        expression(expression, path) {
+            if (expression.kind !== 'identifier' || expression.reference.kind !== 'binding')
+                return;
+            const id = expression.reference.binding.id;
+            if (!parameters.has(id) || bindingTypes.get(id)?.kind !== 'unknown')
+                return;
+            const parent = path.length > 0 ? getIrModuleTraversalPathValue(module, path.slice(0, -1)) : undefined;
+            const asserted = parent &&
+                typeof parent === 'object' &&
+                'kind' in parent &&
+                parent.kind === 'cast' &&
+                'expression' in parent &&
+                parent.expression === expression &&
+                'type' in parent &&
+                isIrTypeAssertedUnknownRepresentationRust(parent.type)
+                ? parent.type
+                : undefined;
+            if (!asserted) {
+                disqualified.add(id);
+                return;
+            }
+            const existing = candidates.get(id);
+            if (existing && !areIrAssertedUnknownRepresentationsEqualRust(existing, asserted)) {
+                disqualified.add(id);
+                return;
+            }
+            candidates.set(id, asserted);
+        },
+    });
+    for (const id of disqualified)
+        candidates.delete(id);
+    return candidates;
+}
+function isIrTypeAssertedUnknownRepresentationRust(type) {
+    if (!type || typeof type !== 'object' || !('kind' in type) || type.kind !== 'primitive')
+        return false;
+    return 'name' in type && (type.name === 'boolean' || type.name === 'number' || type.name === 'string');
+}
+function areIrAssertedUnknownRepresentationsEqualRust(left, right) {
+    return left.kind === 'primitive' && right.kind === 'primitive' && left.name === right.name;
+}
+function resolvePrimitiveUnionEnumRust(type, context) {
+    if (type.kind !== 'union')
+        return undefined;
+    const concrete = type.types.filter((t) => t.kind !== 'null' && t.kind !== 'undefined');
+    if (concrete.length < 2)
+        return undefined;
+    return getOrCreatePrimitiveUnionEnumRust(concrete, context);
+}
+function resolveDualSentinelUnionEnumRust(type, context) {
+    return type.kind === 'union' && hasIrTypeNullMemberRust(type) && hasIrTypeUndefinedMemberRust(type)
+        ? getOrCreateAnonymousUnionEnumRust(type.types, context)
+        : undefined;
+}
+function getIrExpressionDualSentinelUnionRust(expression, context) {
+    if (expression.kind !== 'identifier' || expression.reference.kind !== 'binding')
+        return undefined;
+    const type = context.bindingTypes.get(expression.reference.binding.id);
+    return type ? resolveDualSentinelUnionEnumRust(type, context) : undefined;
+}
+function emitDualSentinelUnionConstructionRust(expression, targetEnum, context) {
+    if (expression.kind === 'conditional') {
+        const condition = emitExpression(expression.condition, context);
+        const whenTrue = emitDualSentinelUnionConstructionRust(expression.whenTrue, targetEnum, context);
+        const whenFalse = emitDualSentinelUnionConstructionRust(expression.whenFalse, targetEnum, context);
+        return whenTrue && whenFalse ? `if ${condition} { ${whenTrue} } else { ${whenFalse} }` : undefined;
+    }
+    if (expression.kind === 'literal' && expression.value === null)
+        return `${targetEnum.name}::Null`;
+    if (expression.kind === 'undefinedValue' ||
+        (expression.kind === 'identifier' &&
+            expression.reference.kind === 'ambient' &&
+            expression.reference.name === 'undefined')) {
+        return `${targetEnum.name}::Undefined`;
+    }
+    const sourceUnion = getIrExpressionDualSentinelUnionRust(expression, context);
+    if (sourceUnion?.name === targetEnum.name)
+        return emitOwnedOperandRust(expression, context);
+    const payloads = targetEnum.variants.filter((variant) => variant.kind === 'tuple');
+    if (payloads.length === 1) {
+        return `${targetEnum.name}::${payloads[0].name}(${emitOwnedOperandRust(expression, context)})`;
+    }
+    const primitiveKind = inferIrExpressionPrimitiveKindRust(expression, context);
+    const preferred = primitiveKind
+        ? getGeneralUnionVariantNameRust({ kind: 'primitive', name: primitiveKind }, context)
+        : undefined;
+    const payload = preferred ? payloads.find((variant) => variant.name === preferred) : undefined;
+    return payload ? `${targetEnum.name}::${payload.name}(${emitOwnedOperandRust(expression, context)})` : undefined;
+}
+function inferIrExpressionPrimitiveKindRust(expression, context) {
+    switch (expression.kind) {
+        case 'literal':
+            return typeof expression.value === 'string'
+                ? 'string'
+                : typeof expression.value === 'number'
+                    ? 'number'
+                    : typeof expression.value === 'boolean'
+                        ? 'boolean'
+                        : undefined;
+        case 'template':
+            return 'string';
+        case 'binary': {
+            const result = expression.semantics.result;
+            return result === 'string' || result === 'number' || result === 'boolean' ? result : undefined;
+        }
+        case 'unary': {
+            const result = expression.semantics.result;
+            return result === 'string' || result === 'number' || result === 'boolean' ? result : undefined;
+        }
+        case 'call': {
+            const resultType = expression.semantics.resultType;
+            return resultType.kind === 'primitive' &&
+                (resultType.name === 'string' || resultType.name === 'number' || resultType.name === 'boolean')
+                ? resultType.name
+                : undefined;
+        }
+        case 'cast':
+            return expression.type.kind === 'primitive' &&
+                (expression.type.name === 'string' || expression.type.name === 'number' || expression.type.name === 'boolean')
+                ? expression.type.name
+                : undefined;
+        case 'identifier': {
+            if (expression.reference.kind !== 'binding')
+                return undefined;
+            const bindingType = context.bindingTypes.get(expression.reference.binding.id);
+            if (!bindingType || bindingType.kind !== 'primitive')
+                return undefined;
+            return bindingType.name === 'string' || bindingType.name === 'number' || bindingType.name === 'boolean'
+                ? bindingType.name
+                : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+function emitPrimitiveUnionConstructionRust(expression, targetEnum, context) {
+    if (expression.kind === 'conditional') {
+        const condition = emitExpression(expression.condition, context);
+        const whenTrue = emitPrimitiveUnionConstructionRust(expression.whenTrue, targetEnum, context);
+        const whenFalse = emitPrimitiveUnionConstructionRust(expression.whenFalse, targetEnum, context);
+        if (whenTrue === undefined || whenFalse === undefined)
+            return undefined;
+        return `if ${condition} { ${whenTrue} } else { ${whenFalse} }`;
+    }
+    const emitted = normalizeSourceTextGrouping(emitOwnedOperandRust(expression, context));
+    const primitiveKind = inferIrExpressionPrimitiveKindRust(expression, context);
+    if (!primitiveKind)
+        return undefined;
+    const variant = targetEnum.variants.find((v) => v.primitiveKind === primitiveKind);
+    if (!variant)
+        return undefined;
+    return `${targetEnum.name}::${variant.variantName}(${emitted})`;
+}
+function collectCellCapturedBindingIdsRust(expression, context) {
+    if (expression.kind !== 'function' ||
+        (context.cellWrappedBindingIds.size === 0 && context.refCellWrappedBindingIds.size === 0))
+        return [];
+    const found = new Set();
+    const observer = {
+        expression(expr) {
+            if (expr.kind === 'identifier' &&
+                expr.reference.kind === 'binding' &&
+                (context.cellWrappedBindingIds.has(expr.reference.binding.id) ||
+                    context.refCellWrappedBindingIds.has(expr.reference.binding.id))) {
+                found.add(expr.reference.binding.id);
+            }
+            if (expr.kind === 'function')
+                return false;
+            return undefined;
+        },
+    };
+    expression.body.forEach((stmt) => analyzeIrStatementSubtreeTraversal(stmt, observer));
+    return [...found];
+}
+function emitCellCloneBlockRust(rcExpression, closureExpression, context) {
+    const capturedCellIds = collectCellCapturedBindingIdsRust(closureExpression, context);
+    if (capturedCellIds.length === 0)
+        return rcExpression;
+    const clones = capturedCellIds.map((id) => {
+        const name = context.targetNames.get(id) ?? id;
+        return `  let ${name} = Rc::clone(&${name});`;
+    });
+    return `{\n${clones.join('\n')}\n  ${rcExpression}\n}`;
+}
+function emitClosureWithCellClonesRust(expression, context) {
+    const source = emitExpression(expression, context);
+    return emitCellCloneBlockRust(`Rc::new(move ${source})`, expression, context);
+}
+// A value lent to a callee that mutates through it. An argument that is already a mutable borrow is
+// passed as it stands, because Rust reborrows it: taking a reference to it again would hand the
+// callee a reference to the reference.
+function emitLentOperandRust(expression, context) {
+    const source = emitExpression(expression, context);
+    return expression.kind === 'identifier' &&
+        expression.reference.kind === 'binding' &&
+        context.referentMutatedParameterIds.has(expression.reference.binding.id)
+        ? source
+        : `&mut ${source}`;
+}
+// A closure an iterator adaptor hands a reference to. The source wrote it for the element, so the
+// reference is destructured away at the binding — which Rust allows for a value it can copy, and
+// which is why an element it cannot copy is refused rather than silently borrowed.
+function emitBorrowedElementClosureRust(expression, context) {
+    if (expression?.kind !== 'function') {
+        return emissionError(context, 'filtering requires a closure written where the predicate is passed');
+    }
+    const parameters = expression.parameters.map((parameter, index) => {
+        if (index > 0)
+            return getBindingTargetNameRust(parameter.binding, context);
+        if (!isIrTypeCopyValueRust(parameter.type)) {
+            emissionError(context, 'filtering an element Rust cannot copy requires a borrowed predicate lowering');
+        }
+        return `&${getBindingTargetNameRust(parameter.binding, context)}`;
+    });
+    const body = expression.expression
+        ? normalizeSourceTextGrouping(emitExpression(expression.expression, context))
+        : `{\n${indentSourceLines(emitStatements(expression.body, context)).join('\n')}\n}`;
+    return `|${parameters.join(', ')}| ${body}`;
+}
+function emitIteratorCallbackWrapperRust(expression, emittedCallee, context) {
+    const name = getGeneratedTargetNameRust('x', context);
+    return `|${name}| ${emittedCallee}(${name})`;
+}
+function emitArrayPredicatePositionRust(receiver, callback, emittedCallback, targetName, context) {
+    let parameterCount;
+    if (callback?.kind === 'function') {
+        parameterCount = callback.parameters.length;
+    }
+    else if (callback?.kind === 'identifier' && callback.reference.kind === 'binding') {
+        const callbackType = context.bindingTypes.get(callback.reference.binding.id);
+        if (callbackType?.kind === 'function')
+            parameterCount = callbackType.parameters.length;
+    }
+    if (!callback || !emittedCallback || parameterCount === undefined || parameterCount < 1 || parameterCount > 2) {
+        emissionError(context, 'array findIndex requires a statically known one- or two-parameter Rust predicate');
+    }
+    const index = getGeneratedTargetNameRust('predicate_index', context);
+    const element = getGeneratedTargetNameRust('predicate_element', context);
+    const arguments_ = [`${element}.clone()`, ...(parameterCount === 2 ? [`${index} as f64`] : [])];
+    return `${receiver}.iter().enumerate().${targetName}(|(${index}, ${element})| (${emittedCallback})(${arguments_.join(', ')})).map(|i| i as f64).unwrap_or(-1.0)`;
+}
+function isIrSelfFieldNonCopyRust(fieldName, context) {
+    for (const declaration of context.module.declarations) {
+        if (declaration.kind !== 'class')
+            continue;
+        const field = declaration.fields.find((candidate) => !candidate.static && candidate.name === fieldName);
+        if (field)
+            return !isIrTypeCopyValueRust(field.type);
+    }
+    return false;
+}
+function isIrTypeCopyValueRust(type) {
+    return type.kind === 'primitive' && (type.name === 'boolean' || type.name === 'number');
+}
+// An index, in the form Rust counts with. A literal whole number is written as one; anything else is
+// a value in the neutral numeric type and has to be converted.
+function emitIndexOperandRust(expression, context) {
+    return expression.kind === 'literal' && typeof expression.value === 'number' && Number.isInteger(expression.value)
+        ? String(expression.value)
+        : `${emitExpression(expression, context)} as usize`;
+}
+function emitBorrowedNarrowedReceiverRust(object, context) {
+    if (object.kind !== 'identifier' || object.reference.kind !== 'binding')
+        return undefined;
+    if (object.presence !== 'narrowedPresent')
+        return undefined;
+    if (!context.nullableBindingIds.has(object.reference.binding.id))
+        return undefined;
+    return `${emitIdentifierReferenceRust(object.reference, context)}.as_ref().unwrap()`;
+}
+// A value on its way into a binding that can hold nothing. The source language stores a value and an
+// absence in one place without saying so; Rust's `Option` says so, and a present value has to be
+// wrapped to enter it. A value that is already optional passes through: it is already the shape.
+function emitOptionalTargetOperandRust(target, value, context) {
+    const source = emitExpression(value, context);
+    if (target.kind !== 'identifier' || target.reference.kind !== 'binding')
+        return source;
+    if (!context.nullableBindingIds.has(target.reference.binding.id))
+        return source;
+    const alreadyOptional = isIrExpressionOptionShapedRust(value, context);
+    return alreadyOptional ? source : `Some(${source})`;
+}
+// Text in a position Rust borrows rather than owns. A literal is already a `&str` before it is
+// owned, so the ownership is simply not taken; anything else is borrowed from the value it names.
+function emitBorrowedTextRust(expression, context) {
+    return expression.kind === 'literal' && typeof expression.value === 'string'
+        ? JSON.stringify(expression.value)
+        : `&${emitExpression(expression, context)}`;
+}
+// A constructor that does nothing but fill its own fields is a Rust struct literal, which is the one
+// constructor shape Rust has. The body must assign every instance field exactly once and read none of
+// them back: a field literal cannot see a field the same literal is still building.
+function getIrClassConstructorFieldAssignmentsRust(declaration, statelessBase) {
+    const constructor = declaration.classConstructor;
+    const instanceFields = declaration.fields.filter((field) => !field.static);
+    if (!constructor || instanceFields.length === 0)
+        return undefined;
+    if (instanceFields.some((field) => field.initializer))
+        return undefined;
+    const assigned = [];
+    for (const statement of constructor.body) {
+        // A base that holds no state has nothing to initialize, so the call that would have initialized
+        // it does nothing and leaves nothing for the struct literal to say.
+        if (statelessBase && isIrStatementSuperConstructorCallRust(statement))
+            continue;
+        if (statement.kind !== 'expression' || statement.expression.kind !== 'assignment')
+            return undefined;
+        const { left, operator, right } = statement.expression;
+        if (operator !== '=' || left.kind !== 'property' || left.object.kind !== 'identifier')
+            return undefined;
+        if (left.object.reference.kind !== 'this' || left.optional)
+            return undefined;
+        if (assigned.some((field) => field.name === left.name))
+            return undefined;
+        if (hasIrExpressionThisReferenceRust(right))
+            return undefined;
+        assigned.push({ name: left.name, value: right });
+    }
+    return assigned.length === instanceFields.length &&
+        instanceFields.every((field) => assigned.some((entry) => entry.name === field.name))
+        ? assigned
+        : undefined;
+}
+function getIrClassCompositionConstructorRust(declaration, base) {
+    const constructor = declaration.classConstructor;
+    const instanceFields = declaration.fields.filter((field) => !field.static);
+    if (!constructor || instanceFields.length === 0)
+        return undefined;
+    let superArguments;
+    const childFields = [];
+    for (const statement of constructor.body) {
+        if (!superArguments && isIrStatementSuperConstructorCallRust(statement)) {
+            const call = statement.expression;
+            superArguments = call.arguments;
+            continue;
+        }
+        if (statement.kind !== 'expression' || statement.expression.kind !== 'assignment')
+            return undefined;
+        const { left, operator, right } = statement.expression;
+        if (operator !== '=' || left.kind !== 'property' || left.object.kind !== 'identifier')
+            return undefined;
+        if (left.object.reference.kind !== 'this' || left.optional)
+            return undefined;
+        if (base.fields.some((field) => !field.static && field.name === left.name))
+            return undefined;
+        if (childFields.some((field) => field.name === left.name))
+            return undefined;
+        if (hasIrExpressionThisReferenceRust(right))
+            return undefined;
+        childFields.push({ name: left.name, value: right });
+    }
+    if (!superArguments)
+        return undefined;
+    return childFields.length === instanceFields.length &&
+        instanceFields.every((field) => childFields.some((entry) => entry.name === field.name))
+        ? { superArguments, childFields }
+        : undefined;
+}
+function isIrCompositionBaseMemberRust(name, base) {
+    return (base.fields.some((field) => !field.static && field.name === name) ||
+        base.methods.some((method) => !method.static && method.name === name));
+}
+function isIrStatementSuperConstructorCallRust(statement) {
+    return (statement.kind === 'expression' &&
+        statement.expression.kind === 'call' &&
+        statement.expression.callee.kind === 'identifier' &&
+        statement.expression.callee.reference.kind === 'super');
+}
+function collectAsyncTryStatementsRust(module, analysis) {
+    const result = new Set();
+    for (const machine of analysis.machines) {
+        for (const state of machine.states) {
+            for (const step of state.steps) {
+                if (step.kind !== 'suspend' || step.rejectState === undefined)
+                    continue;
+                const tryStatement = getEnclosingTryStatementRust(module, step.path);
+                if (tryStatement)
+                    result.add(tryStatement);
+            }
+        }
+    }
+    return result;
+}
+function getEnclosingTryStatementRust(module, suspensionPath) {
+    for (let i = suspensionPath.length - 1; i >= 0; i--) {
+        if (suspensionPath[i] === 'tryBody') {
+            return getIrModuleTraversalPathValue(module, suspensionPath.slice(0, i));
+        }
+    }
+    return undefined;
+}
+function emitAsyncTryCatchRust(statement, context) {
+    const tryStatements = statement.tryBody.kind === 'block' ? statement.tryBody.statements : [statement.tryBody];
+    const awaitIndex = tryStatements.findIndex((s) => (s.kind === 'expression' && s.expression.kind === 'assignment' && s.expression.right.kind === 'await') ||
+        (s.kind === 'return' && s.expression?.kind === 'await'));
+    if (awaitIndex === -1) {
+        emissionError(context, 'async try/catch requires a recognizable await assignment or return');
+        return [];
+    }
+    const awaitStatement = tryStatements[awaitIndex];
+    const preStatements = tryStatements.slice(0, awaitIndex);
+    const postStatements = tryStatements.slice(awaitIndex + 1);
+    const isReturn = awaitStatement.kind === 'return';
+    let awaitTarget;
+    let assignmentExpression;
+    if (awaitStatement.kind === 'return' && awaitStatement.expression?.kind === 'await') {
+        awaitTarget = awaitStatement.expression.expression;
+    }
+    else if (awaitStatement.kind === 'expression' &&
+        awaitStatement.expression.kind === 'assignment' &&
+        awaitStatement.expression.right.kind === 'await') {
+        assignmentExpression = awaitStatement.expression;
+        awaitTarget = awaitStatement.expression.right.expression;
+    }
+    if (!awaitTarget) {
+        emissionError(context, 'async try/catch requires a direct await expression');
+        return [];
+    }
+    const settleExpr = `${emitOwnedOperandRust(awaitTarget, context)}.settle()`;
+    const lines = [];
+    lines.push(...emitStatements(preStatements, context));
+    if (statement.catchClause) {
+        const catchBinding = statement.catchClause.binding ? safeRustValueName(statement.catchClause.binding.name) : '_';
+        lines.push(`match ${settleExpr} {`);
+        if (isReturn) {
+            lines.push(...indentSourceLines([
+                'Ok(__value) => {',
+                ...indentSourceLines([...emitStatements(postStatements, context), 'return __value;']),
+                '}',
+            ]));
+        }
+        else {
+            const okBody = [];
+            if (assignmentExpression) {
+                okBody.push(`${emitExpression(assignmentExpression.left, context)} ${emitAssignmentOperatorRust(assignmentExpression.operator, assignmentExpression.semantics, context)} __value;`);
+            }
+            okBody.push(...emitStatements(postStatements, context));
+            lines.push(...indentSourceLines(['Ok(__value) => {', ...indentSourceLines(okBody), '}']));
+        }
+        lines.push(...indentSourceLines([
+            `Err(${catchBinding}) => {`,
+            ...indentSourceLines(emitStatementBody(statement.catchClause.body, context)),
+            '}',
+        ]));
+        lines.push('}');
+        if (statement.finallyBody) {
+            lines.push(...emitStatementBody(statement.finallyBody, context));
+        }
+    }
+    else if (statement.finallyBody) {
+        lines.push(`let __try_result = ${settleExpr};`);
+        lines.push(...emitStatementBody(statement.finallyBody, context));
+        if (isReturn) {
+            lines.push('match __try_result {');
+            lines.push(...indentSourceLines([
+                'Ok(__value) => return __value,',
+                'Err(__error) => panic!("unhandled task rejection: {}", __error),',
+            ]));
+            lines.push('}');
+        }
+        else {
+            lines.push('match __try_result {');
+            const okBody = [];
+            if (assignmentExpression) {
+                okBody.push(`${emitExpression(assignmentExpression.left, context)} ${emitAssignmentOperatorRust(assignmentExpression.operator, assignmentExpression.semantics, context)} __value;`);
+            }
+            okBody.push(...emitStatements(postStatements, context));
+            lines.push(...indentSourceLines([
+                'Ok(__value) => {',
+                ...indentSourceLines(okBody),
+                '}',
+                'Err(__error) => panic!("unhandled task rejection: {}", __error),',
+            ]));
+            lines.push('}');
+        }
+    }
+    else {
+        emissionError(context, 'async try without catch or finally');
+    }
+    return lines;
+}
+function hasIrExpressionThisReferenceRust(expression) {
+    let found = false;
+    analyzeIrStatementSubtreeTraversal({ expression, kind: 'expression' }, {
+        expression(node) {
+            if (node.kind === 'identifier' && node.reference.kind === 'this')
+                found = true;
+            return undefined;
+        },
+    });
+    return found;
+}
+function emitParameter(parameter, context) {
+    const parameterType = context.assertedUnknownBindingTypes.get(parameter.binding.id) ?? parameter.type;
+    // The source mutates what this parameter names, and the caller sees the change. Moving the value in
+    // would mutate a copy and drop it — the same source, a different meaning — so the parameter is
+    // borrowed mutably and every call site lends rather than gives.
+    if (context.referentMutatedParameterIds.has(parameter.binding.id)) {
+        if (parameter.initializer || parameter.optional || parameter.rest) {
+            emissionError(context, `parameter ${parameter.binding.name} is mutated through and cannot also be optional or variadic in Rust`);
+        }
+        return `${getBindingTargetNameRust(parameter.binding, context)}: &mut ${emitType(parameterType, context)}`;
+    }
+    // A parameter the body assigns to is a local binding in Rust as much as in the source language, and
+    // Rust will not accept the assignment without `mut`. Emitting it unconditionally would instead earn
+    // an unused-mut warning on every parameter that is only read.
+    const binding = `${context.reboundBindingIds.has(parameter.binding.id) ? 'mut ' : ''}${getBindingTargetNameRust(parameter.binding, context)}`;
+    if (parameter.initializer) {
+        return `${binding}: Option<${emitType(parameterType, context)}>`;
+    }
+    if (parameter.optional) {
+        const type = emitType(parameterType, context);
+        if (hasIrTypeNullMemberRust(parameter.type) && hasIrTypeUndefinedMemberRust(parameter.type)) {
+            emissionError(context, 'optional parameters containing both null and undefined require distinct Rust sentinels');
+        }
+        const optionalType = hasIrTypeUndefinedMemberRust(parameter.type) && !hasIrTypeNullMemberRust(parameter.type)
+            ? type
+            : `Option<${type}>`;
+        return `${binding}: ${optionalType}`;
+    }
+    if (parameter.rest)
+        return `${binding}: ${emitType(parameterType, context)}`;
+    return `${binding}: ${emitType(parameterType, context)}`;
+}
+function emitRecord(targetName, properties, typeParameters, exported, context) {
+    // A record a public function names has to be at least as visible as that function, and a record
+    // the source did not export is still named by one often enough that hiding it only produces a
+    // private-interface warning. What leaves the crate is the crate root's decision, not this module's.
+    void exported;
+    const typeContext = { ...context, activeTypeParameters: typeParameters };
+    const lines = [
+        emitRustRecordDerive(properties.map((property) => property.type), typeContext),
+        `pub struct ${targetName}${emitTypeParameters(typeParameters, context)} {`,
+    ];
+    for (const property of properties) {
+        const type = emitType(property.type, typeContext);
+        lines.push(`  pub ${safeRustValueName(property.name)}: ${property.optional ? `Option<${type}>` : type},`);
+    }
+    lines.push('}');
+    return lines;
+}
+function emitStatementValueExpressionRust(expression, context) {
+    if (expression.callee.kind !== 'function' || expression.arguments.length > 0) {
+        emissionError(context, 'statement-value call requires a zero-argument function carrier');
+    }
+    const completion = expression.callee.body.at(-1);
+    if (completion?.kind !== 'return' || !completion.expression) {
+        emissionError(context, 'statement-value call requires a final value return');
+    }
+    const statements = emitStatements(expression.callee.body.slice(0, -1), context);
+    return `{ ${[...statements, emitExpression(completion.expression, context)].join(' ')} }`;
+}
+function emitStatement(statement, context) {
+    switch (statement.kind) {
+        case 'block':
+            return [
+                `${emitControlFlowLabelRust(statement.label)}{`,
+                ...indentSourceLines(emitStatements(statement.statements, context)),
+                '}',
+            ];
+        case 'break':
+            return [`break${statement.target ? ` ${emitControlFlowTargetRust(statement.target)}` : ''};`];
+        case 'continue':
+            return [`continue${statement.target ? ` ${emitControlFlowTargetRust(statement.target)}` : ''};`];
+        case 'do':
+            return [
+                `${emitControlFlowLabelRust(statement.label)}loop {`,
+                ...indentSourceLines(emitStatementBody(statement.body, context)),
+                `  if !(${emitExpression(statement.condition, context)}) { break; }`,
+                '}',
+            ];
+        case 'expression':
+            return [`${emitExpression(statement.expression, context)};`];
+        case 'for':
+            emissionError(context, 'C-style for loops require control-flow lowering before Rust emission');
+        case 'forIn':
+            if ('pattern' in statement.variable)
+                emissionError(context, 'binding patterns require destructuring lowering before Rust emission');
+            if (!statement.keyPlan) {
+                emissionError(context, 'object key iteration requires closed key evidence');
+            }
+            if (statement.keyPlan.evaluation === 'preserve') {
+                emissionError(context, 'effectful object key iteration requires Rust structural-object evaluation lowering');
+            }
+            return [
+                `${emitControlFlowLabelRust(statement.label)}for ${statement.variable.mutable ? 'mut ' : ''}${getBindingTargetNameRust(statement.variable.binding, context)} in [${statement.keyPlan.keys.map((key) => `${JSON.stringify(key)}.to_owned()`).join(', ')}] {`,
+                ...indentSourceLines(emitStatementBody(statement.body, context)),
+                '}',
+            ];
+        case 'forOf': {
+            if (statement.await)
+                emissionError(context, 'async iteration requires Flight task lowering');
+            if ('pattern' in statement.variable)
+                emissionError(context, 'binding patterns require destructuring lowering before Rust emission');
+            const iterableRust = emitExpression(statement.iterable, context);
+            const borrowPrefix = statement.iterable.kind === 'element' ? '&' : '';
+            return [
+                `${emitControlFlowLabelRust(statement.label)}for ${statement.variable.mutable ? 'mut ' : ''}${getBindingTargetNameRust(statement.variable.binding, context)} in ${borrowPrefix}${iterableRust} {`,
+                ...indentSourceLines(emitStatementBody(statement.body, context)),
+                '}',
+            ];
+        }
+        case 'if': {
+            const lines = [
+                `if ${normalizeSourceTextGrouping(emitExpression(statement.condition, context))} {`,
+                ...indentSourceLines(emitStatementBody(statement.consequent, context)),
+                '}',
+            ];
+            if (statement.otherwise)
+                lines.push('else {', ...indentSourceLines(emitStatementBody(statement.otherwise, context)), '}');
+            return lines;
+        }
+        case 'return':
+            // Comparing against `None` is not narrowing. Returning a binding that can be absent from a
+            // function that cannot return one is Rust that does not compile, so it refuses here.
+            if (!context.returnsAbsent &&
+                statement.expression?.kind === 'identifier' &&
+                statement.expression.reference.kind === 'binding' &&
+                statement.expression.presence !== 'narrowedPresent' &&
+                context.nullableBindingIds.has(statement.expression.reference.binding.id)) {
+                emissionError(context, 'returning a nullable binding requires Rust narrowing evidence');
+            }
+            if (statement.expression && context.enclosingReturnType) {
+                const dualSentinelUnion = resolveDualSentinelUnionEnumRust(context.enclosingReturnType, context);
+                if (dualSentinelUnion) {
+                    const wrapped = emitDualSentinelUnionConstructionRust(statement.expression, dualSentinelUnion, context);
+                    if (wrapped)
+                        return [`return ${wrapped};`];
+                }
+                const numericEnum = getIrTypeNumericEnumNamespaceNameRust(context.enclosingReturnType, context);
+                if (numericEnum) {
+                    const expressionEnum = getIrExpressionNumericEnumNamespaceNameRust(statement.expression, context);
+                    const emitted = emitReturnedExpressionRust(statement.expression, context);
+                    return [`return ${expressionEnum === numericEnum ? emitted : `${numericEnum}((${emitted}) as i32)`};`];
+                }
+                const targetEnum = resolvePrimitiveUnionEnumRust(context.enclosingReturnType, context);
+                if (targetEnum) {
+                    if (statement.expression.kind === 'identifier' &&
+                        statement.expression.reference.kind === 'binding' &&
+                        context.primitiveUnionBindingIds.get(statement.expression.reference.binding.id) === targetEnum.name) {
+                        return [`return ${emitIdentifierReferenceRust(statement.expression.reference, context)};`];
+                    }
+                    const wrapped = emitPrimitiveUnionConstructionRust(statement.expression, targetEnum, context);
+                    if (wrapped)
+                        return [`return ${wrapped};`];
+                }
+            }
+            return [
+                `return${statement.expression ? ` ${normalizeSourceTextGrouping(emitReturnedExpressionRust(statement.expression, context))}` : ''};`,
+            ];
+        case 'switch': {
+            const name = getGeneratedTargetNameRust('switch_value', context);
+            const cases = statement.cases.filter((switchCase) => switchCase.expression);
+            const otherwise = statement.cases.find((switchCase) => !switchCase.expression);
+            const lines = [`let ${name} = ${emitExpression(statement.expression, context)};`];
+            cases.forEach((switchCase, index) => {
+                lines.push(`${index > 0 ? 'else ' : ''}if ${name} == ${emitExpression(switchCase.expression, context)} {`, ...indentSourceLines(emitIrSwitchCaseStatementsRust(switchCase, statement.label, context)), '}');
+            });
+            if (otherwise) {
+                if (cases.length > 0)
+                    lines.push('else {');
+                lines.push(...indentSourceLines(emitIrSwitchCaseStatementsRust(otherwise, statement.label, context), cases.length > 0 ? 1 : 0));
+                if (cases.length > 0)
+                    lines.push('}');
+            }
+            else if (cases.length > 0) {
+                lines.push('else {', '  unreachable!();', '}');
+            }
+            return [`${emitControlFlowLabelRust(statement.label)}{`, ...indentSourceLines(lines), '}'];
+        }
+        case 'throw': {
+            const thrown = statement.expression;
+            if (thrown.kind === 'new' && thrown.callee.kind === 'identifier' && thrown.arguments.length === 1) {
+                return [`panic!("{}", ${emitExpression(thrown.arguments[0], context)});`];
+            }
+            return [`panic!("{:?}", ${emitExpression(thrown, context)});`];
+        }
+        case 'try': {
+            if (context.asyncTryStatements.has(statement)) {
+                return emitAsyncTryCatchRust(statement, context);
+            }
+            if (statement.finallyBody) {
+                emissionError(context, 'synchronous try/finally requires catch_unwind with resume_unwind');
+            }
+            const catchBinding = statement.catchClause
+                ? statement.catchClause.binding
+                    ? safeRustValueName(statement.catchClause.binding.name)
+                    : '_'
+                : '_';
+            const matchArms = statement.catchClause
+                ? [
+                    'Ok(__catch_result) => return __catch_result,',
+                    `Err(${catchBinding}) => {`,
+                    ...indentSourceLines(emitStatementBody(statement.catchClause.body, context)),
+                    '}',
+                ]
+                : ['Ok(_) => {}', 'Err(_) => {}'];
+            return [
+                'match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {',
+                ...indentSourceLines(emitStatementBody(statement.tryBody, context)),
+                '})) {',
+                ...indentSourceLines(matchArms),
+                '}',
+            ];
+        }
+        case 'variable':
+            return statement.declarations.map((variable) => emitVariable(variable, context));
+        case 'while':
+            // Rust spells a loop with no exit condition `loop`, and warns on `while true` because the two
+            // differ to the borrow checker: only `loop` tells it the body always runs.
+            const condition = normalizeSourceTextGrouping(emitExpression(statement.condition, context));
+            return [
+                `${emitControlFlowLabelRust(statement.label)}${condition === 'true' ? 'loop' : `while ${condition}`} {`,
+                ...indentSourceLines(emitStatementBody(statement.body, context)),
+                '}',
+            ];
+    }
+}
+function emitIrSwitchCaseStatementsRust(switchCase, switchLabel, context) {
+    const last = switchCase.statements.at(-1);
+    const localBreak = last?.kind === 'break' && (!last.target || (switchLabel && last.target.id === switchLabel.id));
+    return emitStatements(localBreak ? switchCase.statements.slice(0, -1) : switchCase.statements, context);
+}
+function emitControlFlowLabelRust(label) {
+    return label ? `${emitControlFlowTargetRust(label)}: ` : '';
+}
+function emitControlFlowTargetRust(label) {
+    return `'${safeRustValueName(label.name)}`;
+}
+function emitStatementBody(statement, context) {
+    return statement.kind === 'block'
+        ? emitStatements(statement.statements, context)
+        : emitStatements([statement], context);
+}
+function emitStatements(statements, context) {
+    return statements.flatMap((statement) => emitStatement(statement, context));
+}
+function emitType(type, context) {
+    switch (type.kind) {
+        case 'array':
+            return `Vec<${emitType(type.element, context)}>`;
+        case 'function': {
+            context.needsRcImport.add('Rc');
+            const parameters = type.parameters.map((parameter) => emitType(parameter.type, context));
+            const returns = emitType(type.returns, context);
+            return `Rc<dyn Fn(${parameters.join(', ')}) -> ${returns}>`;
+        }
+        case 'indexedAccess':
+        case 'conditionalFacet':
+        case 'typeOf':
+            return opaqueHostType(context);
+        case 'keyof': {
+            const resolved = getIrKeyofTypeRust(type.type, context);
+            if (!resolved)
+                return opaqueHostType(context);
+            return emitType(resolved, context);
+        }
+        case 'intersection': {
+            const scalarDomain = getIrTypePrimitiveDomainRust(type, context);
+            if (scalarDomain)
+                return emitType({ kind: 'primitive', name: scalarDomain }, context);
+            const callableObject = getOrCreateCallableObjectRecordRust(type, context);
+            if (callableObject) {
+                return `${callableObject.name}${emitTypeArguments(callableObject.typeParameters, context)}`;
+            }
+            const properties = getIrObjectTypePropertiesRust(type, context);
+            if (properties)
+                return getIrObjectTypeTargetNameRust(properties, context);
+            emissionError(context, 'intersection types require Rust record or trait lowering');
+        }
+        case 'literal':
+            return typeof type.value === 'boolean' ? 'bool' : typeof type.value === 'number' ? 'f64' : 'String';
+        case 'named': {
+            const sourceName = type.reference.kind === 'ambient' ? type.reference.name : undefined;
+            if ((sourceName === 'Readonly' || sourceName === 'Required') && type.typeArguments[0]) {
+                return emitType(type.typeArguments[0], context);
+            }
+            if (sourceName === 'NoInfer' && type.typeArguments.length === 1 && type.typeArguments[0]) {
+                return emitType(type.typeArguments[0], context);
+            }
+            if (sourceName === 'Exclude' || sourceName === 'Extract') {
+                const projected = getIrFilteredTypeRust(sourceName, type.typeArguments, context);
+                if (!projected)
+                    emissionError(context, `${sourceName} types require closed Rust type computation lowering`);
+                return emitType(projected, context);
+            }
+            if (sourceName === 'Partial' || sourceName === 'Pick' || sourceName === 'Omit') {
+                const properties = getIrObjectTypePropertiesRust(type, context);
+                if (!properties)
+                    emissionError(context, `${sourceName}<T> requires a statically resolvable Rust object shape`);
+                return getIrObjectTypeTargetNameRust(properties, context);
+            }
+            const mapped = getTypeReferenceTargetNameRust(type, context);
+            const arguments_ = type.typeArguments.map((argument) => emitType(argument, context));
+            return `${mapped}${arguments_.length > 0 ? `<${arguments_.join(', ')}>` : ''}`;
+        }
+        case 'never':
+            return '!';
+        case 'null':
+        case 'undefined':
+            return '()';
+        case 'object':
+            return getIrObjectTypeTargetNameRust(type.properties, context);
+        case 'primitive':
+            if (type.name === 'symbol')
+                return recordRuntimeTypeRust('FlightSymbol', context);
+            return { bigint: 'i64', boolean: 'bool', number: 'f64', string: 'String', symbol: 'FlightSymbol', void: '()' }[type.name];
+        case 'tuple': {
+            const elements = type.elements.map((element) => {
+                const emitted = emitType(element.type, context);
+                return element.optional ? `Option<${emitted}>` : emitted;
+            });
+            return `(${elements.join(', ')}${elements.length === 1 ? ',' : ''})`;
+        }
+        case 'union': {
+            const concrete = type.types.filter((item) => item.kind !== 'null' && item.kind !== 'undefined');
+            const optional = concrete.length !== type.types.length;
+            if (hasIrTypeNullMemberRust(type) && hasIrTypeUndefinedMemberRust(type)) {
+                const union = getOrCreateAnonymousUnionEnumRust(type.types, context);
+                return `${union.name}${emitTypeArguments(union.typeParameters, context)}`;
+            }
+            if (concrete.length === 1 && concrete.length !== type.types.length)
+                return `Option<${emitType(concrete[0], context)}>`;
+            const primitiveDomain = getIrUnionPrimitiveDomainRust(concrete, context);
+            if (primitiveDomain) {
+                const emitted = emitType({ kind: 'primitive', name: primitiveDomain }, context);
+                return optional ? `Option<${emitted}>` : emitted;
+            }
+            const primitiveEnum = getOrCreatePrimitiveUnionEnumRust(concrete, context);
+            if (primitiveEnum)
+                return optional ? `Option<${primitiveEnum.name}>` : primitiveEnum.name;
+            const generalEnum = getOrCreateAnonymousUnionEnumRust(concrete, context);
+            const emitted = `${generalEnum.name}${emitTypeArguments(generalEnum.typeParameters, context)}`;
+            return optional ? `Option<${emitted}>` : emitted;
+        }
+        case 'unknown':
+            return opaqueHostType(context);
+    }
+}
+// TypeScript's object utilities and intersections are representation decisions in Rust: once every
+// participating declaration is closed, the result is one concrete record. Keep the resolver local
+// to the backend because it decides Rust storage, but consume the shared substitution machinery so
+// generic aliases and inherited interfaces do not acquire a second set of type-argument rules.
+function getIrObjectTypePropertiesRust(type, context, module = context.module, resolving = new Set()) {
+    if (type.kind === 'object')
+        return type.properties;
+    if (type.kind === 'intersection') {
+        const shapes = type.types.map((member) => getIrObjectTypePropertiesRust(member, context, module, resolving));
+        return shapes.some((shape) => !shape)
+            ? undefined
+            : mergeIrObjectTypePropertiesRust(shapes.flatMap((shape) => shape));
+    }
+    if (type.kind !== 'named')
+        return undefined;
+    if (type.reference.kind === 'ambient') {
+        const utility = type.reference.name;
+        if (utility === 'Record') {
+            if (type.typeArguments.length !== 2 || !type.typeArguments[0] || !type.typeArguments[1])
+                return undefined;
+            const keys = getIrObjectProjectionKeysRust(type.typeArguments[0], context, module, resolving);
+            if (!keys)
+                return undefined;
+            return [...keys].map((name) => ({
+                name,
+                optional: false,
+                readonly: false,
+                type: type.typeArguments[1],
+            }));
+        }
+        if (utility === 'NoInfer' || utility === 'Partial' || utility === 'Readonly' || utility === 'Required') {
+            if (type.typeArguments.length !== 1 || !type.typeArguments[0])
+                return undefined;
+            const properties = getIrObjectTypePropertiesRust(type.typeArguments[0], context, module, resolving);
+            if (!properties)
+                return undefined;
+            return properties.map((property) => ({
+                ...property,
+                ...(utility === 'Partial' ? { optional: true } : {}),
+                ...(utility === 'Readonly' ? { readonly: true } : {}),
+                ...(utility === 'Required' ? { optional: false } : {}),
+            }));
+        }
+        if (utility === 'Exclude' || utility === 'Extract') {
+            const projected = getIrFilteredTypeRust(utility, type.typeArguments, context, module, resolving);
+            return projected ? getIrObjectTypePropertiesRust(projected, context, module, resolving) : undefined;
+        }
+        if (utility !== 'Omit' && utility !== 'Pick')
+            return undefined;
+        if (type.typeArguments.length !== 2 || !type.typeArguments[0] || !type.typeArguments[1])
+            return undefined;
+        const properties = getIrObjectTypePropertiesRust(type.typeArguments[0], context, module, resolving);
+        const keys = getIrObjectProjectionKeysRust(type.typeArguments[1], context, module, resolving);
+        if (!properties || !keys)
+            return undefined;
+        return properties.filter((property) => (utility === 'Pick') === keys.has(property.name));
+    }
+    if (type.reference.path.length > 0)
+        return undefined;
+    if (type.reference.binding.space !== 'type' || type.reference.binding.kind === 'typeParameter')
+        return undefined;
+    const location = getIrNamedTypeDeclarationLocationRust(type.reference.binding, context, module);
+    if (!location)
+        return undefined;
+    const key = `${location.module.packageName}\0${location.module.source}\0${location.declaration.binding.id}`;
+    if (resolving.has(key))
+        return undefined;
+    const active = new Set(resolving).add(key);
+    let plan;
+    try {
+        plan = createIrTypeParameterSubstitutionPlan(location.declaration.typeParameters, type.typeArguments);
+    }
+    catch (error) {
+        if (isCompilerStructuralTypeSubstitutionFailure(error))
+            return undefined;
+        throw error;
+    }
+    if (location.declaration.kind === 'typeAlias') {
+        let resolved;
+        try {
+            resolved = resolveIrTypeStructuralSubstitution(location.declaration.type, plan);
+        }
+        catch (error) {
+            if (isCompilerStructuralTypeSubstitutionFailure(error))
+                return undefined;
+            throw error;
+        }
+        return getIrObjectTypePropertiesRust(resolved, context, location.module, active);
+    }
+    const inherited = location.declaration.extends.map((reference) => {
+        let resolved;
+        try {
+            resolved = resolveIrTypeStructuralSubstitution(reference, plan);
+        }
+        catch (error) {
+            if (isCompilerStructuralTypeSubstitutionFailure(error))
+                return undefined;
+            throw error;
+        }
+        return getIrObjectTypePropertiesRust(resolved, context, location.module, active);
+    });
+    if (inherited.some((properties) => !properties))
+        return undefined;
+    let own;
+    try {
+        own = location.declaration.properties.map((property) => ({
+            ...property,
+            type: resolveIrTypeStructuralSubstitution(property.type, plan),
+        }));
+    }
+    catch (error) {
+        if (isCompilerStructuralTypeSubstitutionFailure(error))
+            return undefined;
+        throw error;
+    }
+    return mergeIrObjectTypePropertiesRust([...inherited.flatMap((properties) => properties), ...own]);
+}
+function mergeIrObjectTypePropertiesRust(properties) {
+    const merged = new Map();
+    for (const property of properties) {
+        const existing = merged.get(property.name);
+        if (!existing) {
+            merged.set(property.name, { ...property });
+            continue;
+        }
+        if (JSON.stringify(existing.computedKey) !== JSON.stringify(property.computedKey) ||
+            existing.phantom !== property.phantom ||
+            existing.role !== property.role) {
+            return undefined;
+        }
+        const type = JSON.stringify(existing.type) === JSON.stringify(property.type)
+            ? existing.type
+            : createIrIntersectionTypeRust(existing.type, property.type);
+        merged.set(property.name, {
+            ...existing,
+            optional: existing.optional && property.optional,
+            readonly: existing.readonly && property.readonly,
+            type,
+        });
+    }
+    return [...merged.values()];
+}
+function getIrObjectProjectionKeysRust(type, context, module, resolving) {
+    const members = getIrClosedTypeMembersRust(type, context, module, resolving);
+    if (!members || members.some((member) => member.kind !== 'literal' || typeof member.value === 'boolean')) {
+        return undefined;
+    }
+    return new Set(members.map((member) => String(member.value)));
+}
+function getIrKeyofTypeRust(type, context) {
+    const properties = getIrObjectTypePropertiesRust(type, context);
+    if (!properties)
+        return undefined;
+    const keys = [];
+    if (properties.some((property) => !property.computedKey && !property.phantom)) {
+        keys.push({ kind: 'primitive', name: 'string' });
+    }
+    if (properties.some((property) => property.computedKey && !property.phantom)) {
+        keys.push({ kind: 'primitive', name: 'symbol' });
+    }
+    return createIrClosedTypeUnionRust(keys);
+}
+function getIrFilteredTypeRust(utility, typeArguments, context, module = context.module, resolving = new Set()) {
+    if (typeArguments.length !== 2 || !typeArguments[0] || !typeArguments[1])
+        return undefined;
+    const included = getIrClosedTypeMembersRust(typeArguments[0], context, module, resolving);
+    const filters = getIrClosedTypeMembersRust(typeArguments[1], context, module, resolving);
+    if (!included || !filters)
+        return undefined;
+    const retained = [];
+    for (const member of included) {
+        const matches = filters.map((filter) => isIrTypeAssignableForFilterRust(member, filter, context, module, resolving));
+        if (!matches.includes(true) && matches.includes(undefined))
+            return undefined;
+        const matched = matches.includes(true);
+        if ((utility === 'Extract') === matched)
+            retained.push(member);
+    }
+    return createIrClosedTypeUnionRust(retained);
+}
+function getIrClosedTypeMembersRust(type, context, module = context.module, resolving = new Set()) {
+    if (type.kind === 'never')
+        return [];
+    if (type.kind === 'union') {
+        const members = type.types.map((member) => getIrClosedTypeMembersRust(member, context, module, resolving));
+        return members.some((member) => !member) ? undefined : members.flatMap((member) => member);
+    }
+    if (type.kind === 'keyof') {
+        const resolved = getIrKeyofTypeRustInModule(type.type, context, module, resolving);
+        return resolved ? getIrClosedTypeMembersRust(resolved, context, module, resolving) : undefined;
+    }
+    if (type.kind === 'typeOf') {
+        const resolved = getIrTypeOfValueTypeRust(type, context, module);
+        return resolved ? getIrClosedTypeMembersRust(resolved, context, module, resolving) : undefined;
+    }
+    if (type.kind === 'named' && type.reference.kind === 'binding' && type.reference.path.length === 0) {
+        if (type.reference.binding.space !== 'type' || type.reference.binding.kind === 'typeParameter')
+            return undefined;
+        const location = getIrNamedTypeDeclarationLocationRust(type.reference.binding, context, module);
+        if (location?.declaration.kind === 'typeAlias') {
+            const key = `${location.module.packageName}\0${location.module.source}\0${location.declaration.binding.id}`;
+            if (resolving.has(key))
+                return undefined;
+            try {
+                const plan = createIrTypeParameterSubstitutionPlan(location.declaration.typeParameters, type.typeArguments);
+                const resolved = resolveIrTypeStructuralSubstitution(location.declaration.type, plan);
+                return getIrClosedTypeMembersRust(resolved, context, location.module, new Set(resolving).add(key));
+            }
+            catch (error) {
+                if (isCompilerStructuralTypeSubstitutionFailure(error))
+                    return undefined;
+                throw error;
+            }
+        }
+    }
+    if (type.kind === 'conditionalFacet' || type.kind === 'indexedAccess' || type.kind === 'unknown') {
+        return undefined;
+    }
+    return [type];
+}
+function getIrTypeOfValueTypeRust(type, context, module) {
+    if (type.reference.kind !== 'binding' || type.reference.path.length > 0)
+        return undefined;
+    const binding = type.reference.binding;
+    const local = module.declarations.find((declaration) => declaration.kind === 'variable' && 'binding' in declaration && declaration.binding.id === binding.id);
+    if (local?.kind === 'variable' && 'binding' in local)
+        return getIrVariableTypeRust(local);
+    const imported = module.imports
+        .flatMap((item) => item.bindings.map((candidate) => ({ candidate, specifier: item.specifier })))
+        .find(({ candidate }) => candidate.binding.id === binding.id);
+    if (!imported || imported.candidate.imported === '*' || imported.candidate.imported === 'default')
+        return undefined;
+    const targetModule = resolveImportModuleRust(imported.specifier, imported.candidate.imported, context, module);
+    const declaration = targetModule?.declarations.find((candidate) => candidate.kind === 'variable' && 'binding' in candidate && candidate.binding.name === imported.candidate.imported);
+    return declaration?.kind === 'variable' && 'binding' in declaration ? getIrVariableTypeRust(declaration) : undefined;
+}
+function getIrVariableTypeRust(variable) {
+    if ('pattern' in variable)
+        return undefined;
+    if (variable.type && variable.type.kind !== 'unknown')
+        return variable.type;
+    const initializer = variable.initializer;
+    if (initializer?.kind !== 'call')
+        return variable.type;
+    const directSymbol = initializer.callee.kind === 'identifier' &&
+        initializer.callee.reference.kind === 'ambient' &&
+        initializer.callee.reference.name === 'Symbol';
+    const symbolMember = initializer.callee.kind === 'property' &&
+        initializer.callee.object.kind === 'identifier' &&
+        initializer.callee.object.reference.kind === 'ambient' &&
+        initializer.callee.object.reference.name === 'Symbol';
+    return directSymbol || symbolMember ? { kind: 'primitive', name: 'symbol' } : variable.type;
+}
+function getIrKeyofTypeRustInModule(type, context, module, resolving) {
+    const properties = getIrObjectTypePropertiesRust(type, context, module, resolving);
+    if (!properties)
+        return undefined;
+    const keys = [];
+    if (properties.some((property) => !property.computedKey && !property.phantom)) {
+        keys.push({ kind: 'primitive', name: 'string' });
+    }
+    if (properties.some((property) => property.computedKey && !property.phantom)) {
+        keys.push({ kind: 'primitive', name: 'symbol' });
+    }
+    return createIrClosedTypeUnionRust(keys);
+}
+function isIrTypeAssignableForFilterRust(source, target, context, module, resolving) {
+    if (target.kind === 'primitive') {
+        if (source.kind === 'primitive')
+            return source.name === target.name;
+        if (source.kind !== 'literal')
+            return false;
+        return typeof source.value === target.name;
+    }
+    if (target.kind === 'literal')
+        return source.kind === 'literal' && Object.is(source.value, target.value);
+    if (target.kind === 'null' || target.kind === 'undefined')
+        return source.kind === target.kind;
+    const sourceProperties = getIrObjectTypePropertiesRust(source, context, module, resolving);
+    const targetProperties = getIrObjectTypePropertiesRust(target, context, module, resolving);
+    if (!sourceProperties || !targetProperties)
+        return undefined;
+    // Discriminant filters are closed even when the wider structural comparison is indeterminate.
+    // `Extract<Union, { kind: "x" }>` only asks whether each alternative's named literal slot is
+    // compatible; unrelated fields and their host types cannot affect that decision.
+    if (targetProperties.length > 0 && targetProperties.every((property) => property.type.kind === 'literal')) {
+        const decisions = targetProperties.map((targetProperty) => {
+            const sourceProperty = sourceProperties.find((property) => property.name === targetProperty.name);
+            if (!sourceProperty || sourceProperty.optional)
+                return false;
+            const members = getIrClosedTypeMembersRust(sourceProperty.type, context, module, resolving);
+            if (!members)
+                return undefined;
+            return members.every((member) => member.kind === 'literal' &&
+                targetProperty.type.kind === 'literal' &&
+                Object.is(member.value, targetProperty.type.value));
+        });
+        if (decisions.includes(false))
+            return false;
+        if (decisions.every((decision) => decision === true))
+            return true;
+    }
+    const report = analyzeIrTypeStructuralAssignability({ kind: 'object', properties: sourceProperties }, { kind: 'object', properties: targetProperties });
+    return report.status === 'indeterminate' ? undefined : report.status === 'compatible';
+}
+function createIrClosedTypeUnionRust(types) {
+    const unique = [...new Map(types.map((type) => [JSON.stringify(type), type])).values()];
+    if (unique.length === 0)
+        return { kind: 'never' };
+    if (unique.length === 1)
+        return unique[0];
+    return { kind: 'union', types: [unique[0], unique[1], ...unique.slice(2)] };
+}
+function createIrIntersectionTypeRust(left, right) {
+    const types = [
+        ...(left.kind === 'intersection' ? left.types : [left]),
+        ...(right.kind === 'intersection' ? right.types : [right]),
+    ];
+    return { kind: 'intersection', types: [types[0], types[1], ...types.slice(2)] };
+}
+function getIrUnionPrimitiveDomainRust(types, context) {
+    const domains = types.map((type) => getIrTypePrimitiveDomainRust(type, context));
+    const domain = domains[0];
+    return domain !== undefined && domains.every((candidate) => candidate === domain) ? domain : undefined;
+}
+function getIrTypePrimitiveDomainRust(type, context, module = context.module, resolving = new Set()) {
+    if (type.kind === 'literal') {
+        const domain = typeof type.value;
+        return domain === 'boolean' || domain === 'number' || domain === 'string' ? domain : undefined;
+    }
+    if (type.kind === 'primitive' && (type.name === 'boolean' || type.name === 'number' || type.name === 'string')) {
+        return type.name;
+    }
+    if (type.kind === 'typeOf') {
+        const resolved = getIrTypeOfValueTypeRust(type, context, module);
+        return resolved ? getIrTypePrimitiveDomainRust(resolved, context, module, resolving) : undefined;
+    }
+    if (type.kind === 'intersection') {
+        const meaningful = type.types.filter((member) => member.kind !== 'object' && getIrObjectTypePropertiesRust(member, context, module, resolving) === undefined);
+        const domains = meaningful.map((member) => getIrTypePrimitiveDomainRust(member, context, module, resolving));
+        const domain = domains[0];
+        return domain !== undefined && domains.every((candidate) => candidate === domain) ? domain : undefined;
+    }
+    if (type.kind !== 'named' ||
+        type.reference.kind !== 'binding' ||
+        type.reference.path.length > 0 ||
+        type.reference.binding.space !== 'type' ||
+        type.reference.binding.kind === 'typeParameter') {
+        return undefined;
+    }
+    const location = getIrNamedTypeDeclarationLocationRust(type.reference.binding, context, module);
+    if (location?.declaration.kind !== 'typeAlias')
+        return undefined;
+    const key = `${location.module.packageName}\0${location.module.source}\0${location.declaration.binding.id}`;
+    if (resolving.has(key))
+        return undefined;
+    try {
+        const plan = createIrTypeParameterSubstitutionPlan(location.declaration.typeParameters, type.typeArguments);
+        const resolved = resolveIrTypeStructuralSubstitution(location.declaration.type, plan);
+        return getIrTypePrimitiveDomainRust(resolved, context, location.module, new Set(resolving).add(key));
+    }
+    catch (error) {
+        if (isCompilerStructuralTypeSubstitutionFailure(error))
+            return undefined;
+        throw error;
+    }
+}
+// A union of string literals is how the source language spells a closed set of names, and the source
+// treats a value of it as a string everywhere: comparing it, returning it, storing it in a string
+// field. Rust has no implicit conversion, so a unit-variant enum would need a coercion inserted at
+// every one of those positions — type-directed work this backend does not do yet.
+//
+// So the set becomes the string it is made of, and the closed-ness is what is lost. Haxe keeps the
+// enum because `from String to String` gives it exactly those coercions for free; that the two
+// targets diverge here is a property of the targets, not an inconsistency in the compiler.
+function emitStringLiteralUnionRust(declaration, context) {
+    return [
+        `${declaration.exported ? 'pub ' : ''}type ${getBindingTargetNameRust(declaration.binding, context)} = String;`,
+    ];
+}
+function emitTypeAlias(declaration, context) {
+    if (getIrUnionTypeStringLiteralValues(declaration.type))
+        return emitStringLiteralUnionRust(declaration, context);
+    if (declaration.type.kind === 'union' && getIrUnionTypeMemberRecordsRust(declaration.type, context)) {
+        return emitTaggedUnionRust(getBindingTargetNameRust(declaration.binding, context), declaration.type, declaration.exported, context);
+    }
+    const typeContext = { ...context, activeTypeParameters: declaration.typeParameters };
+    if (declaration.type.kind === 'union' &&
+        !hasIrTypeNullMemberRust(declaration.type) &&
+        !hasIrTypeUndefinedMemberRust(declaration.type) &&
+        !getIrUnionPrimitiveDomainRust(declaration.type.types, typeContext)) {
+        return emitGeneralUnionRust(getBindingTargetNameRust(declaration.binding, context), createGeneralUnionVariantsRust(declaration.type.types, typeContext), declaration.typeParameters, declaration.exported, typeContext);
+    }
+    const recordProperties = isIrTypeRecordMaterializationRust(declaration.type)
+        ? getIrObjectTypePropertiesRust(declaration.type, context)
+        : undefined;
+    if (recordProperties) {
+        return emitRecord(getBindingTargetNameRust(declaration.binding, context), recordProperties, declaration.typeParameters, declaration.exported, context);
+    }
+    return [
+        `${declaration.exported ? 'pub ' : ''}type ${getBindingTargetNameRust(declaration.binding, context)}${emitTypeParameters(declaration.typeParameters, context)} = ${emitType(declaration.type, typeContext)};`,
+    ];
+}
+function isIrTypeRecordMaterializationRust(type) {
+    if (type.kind === 'object' || type.kind === 'intersection')
+        return true;
+    return (type.kind === 'named' &&
+        type.reference.kind === 'ambient' &&
+        ['Exclude', 'Extract', 'Omit', 'Partial', 'Pick', 'Required'].includes(type.reference.name));
+}
+function emitTupleSpreadExpressionRust(expression, context) {
+    const declarations = [];
+    const elements = [];
+    let resultIndex = 0;
+    for (const segment of expression.segments) {
+        if (segment.kind === 'element') {
+            const target = expression.type.elements[resultIndex];
+            if (!segment.element.expression) {
+                elements.push('None');
+            }
+            else {
+                const name = getGeneratedTargetNameRust('tuple_spread_element', context);
+                declarations.push(`let ${name} = ${emitExpression(segment.element.expression, context)};`);
+                elements.push(target.optional ? `Some(${name})` : name);
+            }
+            resultIndex += 1;
+            continue;
+        }
+        segment.type.elements.forEach((element, offset) => {
+            if (!isIrTypeCloneSafeRust(element.type)) {
+                emissionError(context, `fixed tuple spread source index ${String(offset)} lacks clone-safe Rust ownership evidence`);
+            }
+        });
+        const name = getGeneratedTargetNameRust('tuple_spread_value', context);
+        declarations.push(`let ${name} = &(${emitExpression(segment.expression, context)});`);
+        segment.type.elements.forEach((element, offset) => {
+            const value = `${name}.${String(offset)}.clone()`;
+            const target = expression.type.elements[resultIndex + offset];
+            elements.push(target.optional && !element.optional ? `Some(${value})` : value);
+        });
+        resultIndex += segment.type.elements.length;
+    }
+    const tuple = `(${elements.join(', ')}${elements.length === 1 ? ',' : ''})`;
+    return `({ ${declarations.join(' ')} ${tuple} })`;
+}
+function emitTypeArguments(parameters, context) {
+    return parameters.length === 0
+        ? ''
+        : `<${parameters.map((parameter) => getBindingTargetNameRust(parameter.binding, context)).join(', ')}>`;
+}
+function emitTypeParameters(parameters, context) {
+    if (parameters.length === 0)
+        return '';
+    return `<${parameters
+        .map((parameter) => {
+        const name = getBindingTargetNameRust(parameter.binding, context);
+        // A TypeScript constraint is a value shape, not a Rust trait. Spelling `T extends string` as
+        // `T: String` produces invalid Rust because `String` is a concrete type. Generated records do
+        // clone generic storage, so Clone is the one target capability this declaration can require
+        // without claiming that a source value type is a trait.
+        return `${name}: Clone`;
+    })
+        .join(', ')}>`;
+}
+function emitVariable(variable, context) {
+    if ('pattern' in variable)
+        emissionError(context, 'binding patterns require destructuring lowering before Rust emission');
+    const representationType = variable.type?.kind === 'unknown' && variable.initializer
+        ? (inferIrExpressionTypeRust(variable.initializer, context) ?? variable.type)
+        : variable.type;
+    if (variable.initialValue === 'undefined') {
+        if (!variable.type || !isNullableType(variable.type)) {
+            emissionError(context, 'observable undefined function-entry value requires a nullable Rust type domain');
+        }
+        const dualSentinelUnion = resolveDualSentinelUnionEnumRust(variable.type, context);
+        const initial = dualSentinelUnion ? `${dualSentinelUnion.name}::Undefined` : 'None';
+        return `let ${variable.mutable ? 'mut ' : ''}${getBindingTargetNameRust(variable.binding, context)}: ${emitType(variable.type, context)} = ${initial};`;
+    }
+    if (context.cellWrappedBindingIds.has(variable.binding.id)) {
+        context.needsCellImport.add('Cell');
+        context.needsRcImport.add('Rc');
+        const name = getBindingTargetNameRust(variable.binding, context);
+        const type = variable.type ? emitType(variable.type, context) : 'f64';
+        const init = variable.initializer ? emitExpression(variable.initializer, context) : '0.0';
+        return `let ${name}: Rc<Cell<${type}>> = Rc::new(Cell::new(${init}));`;
+    }
+    if (context.refCellWrappedBindingIds.has(variable.binding.id)) {
+        context.needsRefCellImport.add('RefCell');
+        context.needsRcImport.add('Rc');
+        const name = getBindingTargetNameRust(variable.binding, context);
+        const type = variable.type ? emitType(variable.type, context) : 'String';
+        const init = variable.initializer ? emitExpression(variable.initializer, context) : 'Default::default()';
+        return `let ${name}: Rc<RefCell<${type}>> = Rc::new(RefCell::new(${init}));`;
+    }
+    if (variable.type && variable.initializer) {
+        const dualSentinelUnion = resolveDualSentinelUnionEnumRust(variable.type, context);
+        if (dualSentinelUnion) {
+            const wrapped = emitDualSentinelUnionConstructionRust(variable.initializer, dualSentinelUnion, context);
+            if (wrapped) {
+                const mutable = variable.mutable ||
+                    (context.referentMutatedBindingIds.has(variable.binding.id) && !isIrTypeTypedArrayRust(variable.type));
+                return `let ${mutable ? 'mut ' : ''}${getBindingTargetNameRust(variable.binding, context)}: ${emitType(variable.type, context)} = ${wrapped};`;
+            }
+        }
+        const targetEnum = resolvePrimitiveUnionEnumRust(variable.type, context);
+        if (targetEnum) {
+            const wrapped = emitPrimitiveUnionConstructionRust(variable.initializer, targetEnum, context);
+            if (wrapped) {
+                const deferred = !variable.initializer && context.deferredBindingIds.has(variable.binding.id);
+                const mutable = (variable.mutable && !deferred) ||
+                    (context.referentMutatedBindingIds.has(variable.binding.id) && !isIrTypeTypedArrayRust(variable.type));
+                return `let ${mutable ? 'mut ' : ''}${getBindingTargetNameRust(variable.binding, context)}: ${emitType(variable.type, context)} = ${wrapped};`;
+            }
+        }
+    }
+    const isArrayElementBinding = 'binding' in variable && context.arrayElementBindingIds.has(variable.binding.id);
+    const type = representationType && !(variable.initializer?.kind === 'objectRest' && representationType.kind === 'object')
+        ? `: ${isArrayElementBinding ? `Option<${emitType(representationType, context)}>` : emitType(representationType, context)}`
+        : '';
+    const isCallbackInitializer = variable.type?.kind === 'function' && variable.initializer?.kind === 'function';
+    if (isCallbackInitializer)
+        context.needsRcImport.add('Rc');
+    const isNullableArrayElement = 'binding' in variable &&
+        (context.nullableBindingIds.has(variable.binding.id) || isArrayElementBinding) &&
+        variable.initializer?.kind === 'element' &&
+        !variable.initializer.optional &&
+        variable.initializer.semantics.receivers.includes('array');
+    const initializer = variable.initializer
+        ? ` = ${normalizeSourceTextGrouping(isCallbackInitializer ? emitClosureWithCellClonesRust(variable.initializer, context) : isNullableArrayElement ? emitOptionShapedOperandRust(variable.initializer, context) : emitOwnedOperandRust(variable.initializer, context))}`
+        : '';
+    // A binding declared without a value and written once afterwards is Rust's deferred
+    // initialization, not a mutation: the source hoisted the declaration above the assignment, and
+    // `mut` on it would claim a rebinding that never happens.
+    const deferred = !variable.initializer && context.deferredBindingIds.has(variable.binding.id);
+    // Rust asks for `mut` to reach a value's own fields through a method, where the source language
+    // only asks for it to rebind the name. A `const` the source mutates through is still `mut` here.
+    const mutable = (variable.mutable && !deferred) ||
+        (context.referentMutatedBindingIds.has(variable.binding.id) && !isIrTypeTypedArrayRust(variable.type));
+    return `let ${mutable ? 'mut ' : ''}${getBindingTargetNameRust(variable.binding, context)}${type}${initializer};`;
+}
+function emitVariableDeclaration(declaration, context) {
+    if ('pattern' in declaration)
+        emissionError(context, 'binding patterns require destructuring lowering before Rust emission');
+    if (!declaration.initializer || !declaration.type) {
+        emissionError(context, `module variable ${declaration.binding.name} requires an initializer and type`);
+    }
+    if (declaration.mutable)
+        emissionError(context, `mutable module variable ${declaration.binding.name} requires synchronization lowering`);
+    return [
+        `${declaration.exported ? 'pub ' : ''}const ${getBindingTargetNameRust(declaration.binding, context)}: ${emitType(declaration.type, context)} = ${emitExpression(declaration.initializer, context)};`,
+    ];
+}
+function getBindingTargetNameRust(binding, context) {
+    const targetName = context.targetNames.get(binding.id);
+    if (!targetName)
+        emissionError(context, `binding ${binding.name} has no Rust target name allocation`);
+    return targetName;
+}
+function getGeneratedTargetNameRust(preferredName, context) {
+    let name = preferredName;
+    const separator = /^[A-Z]/u.test(preferredName) ? '' : '_';
+    for (let suffix = 2; context.generatedNames.has(name); suffix += 1) {
+        name = `${preferredName}${separator}${String(suffix)}`;
+    }
+    context.generatedNames.add(name);
+    return name;
+}
+function getElementAccessTupleIndexRust(expression, context) {
+    if (expression.semantics.receivers.length !== 1 ||
+        expression.index.kind !== 'literal' ||
+        typeof expression.index.value !== 'number' ||
+        !Number.isSafeInteger(expression.index.value) ||
+        expression.index.value < 0) {
+        emissionError(context, 'tuple projection requires one statically known nonnegative integer index');
+    }
+    return expression.index.value;
+}
+function getPreferredBindingNameRust(binding, constants) {
+    if (constants.has(binding.id))
+        return screamingSnakeCase(binding.name);
+    return binding.space === 'type' ||
+        binding.kind === 'class' ||
+        binding.kind === 'enum' ||
+        (binding.kind === 'import' && /^[A-Z]/u.test(binding.name))
+        ? safeRustTypeName(binding.name)
+        : safeRustValueName(binding.name);
+}
+function getTypeReferenceTargetNameRust(type, context) {
+    if (type.reference.kind === 'ambient') {
+        const targetName = getCompilerRuntimeExternalSymbolTargetRust(type.reference.name, 'type', context.options.hostBindings);
+        if (!targetName)
+            emissionError(context, `external type ${type.reference.name} has no Rust binding`);
+        return isCompilerRuntimeExternalSymbolProvidedRust(type.reference.name, 'type', context.options.hostBindings)
+            ? recordRuntimeTypeRust(targetName, context)
+            : targetName;
+    }
+    return [
+        getTypeBindingTargetNameRust(type.reference.binding, context),
+        ...type.reference.path.map(safeRustTypeName),
+    ].join('::');
+}
+function getTypeBindingTargetNameRust(binding, context) {
+    const allocated = context.targetNames.get(binding.id);
+    if (allocated)
+        return allocated;
+    for (const module of context.sourceModules) {
+        const declaration = module.declarations.find((candidate) => 'binding' in candidate && candidate.binding.id === binding.id);
+        if (declaration && 'binding' in declaration) {
+            return getRustQualifiedTypeName(module, declaration.binding.name, context);
+        }
+        const imported = module.imports
+            .flatMap((item) => item.bindings.map((candidate) => ({ candidate, specifier: item.specifier })))
+            .find(({ candidate }) => candidate.binding.id === binding.id);
+        if (!imported || imported.candidate.imported === '*' || imported.candidate.imported === 'default')
+            continue;
+        const target = resolveImportModuleRust(imported.specifier, imported.candidate.imported, context, module);
+        if (target)
+            return getRustQualifiedTypeName(target, imported.candidate.imported, context);
+    }
+    emissionError(context, `binding ${binding.name} has no Rust type target resolution`);
+}
+function getRustQualifiedTypeName(module, name, context) {
+    const targetName = safeRustTypeName(name);
+    if (module.packageName === context.module.packageName) {
+        return `crate::${getRustModuleName(module)}::${targetName}`;
+    }
+    return `${convertPackageNameToRustCrateName(module.packageName).replaceAll('-', '_')}::${targetName}`;
+}
+function assertStructuralObjectCompatibilityRust(module, modules, resolution) {
+    const diagnostics = analyzeIrModuleStructuralObjectCompatibilityAcrossModules(module, modules, resolution).diagnostics;
+    const diagnostic = diagnostics.find((candidate) => candidate.disposition !== 'indeterminate') ??
+        diagnostics.find((candidate) => candidate.code !== 'unresolved-named-construction-target');
+    if (diagnostic) {
+        throw createBackendEmissionFailure('rust', module, `structural object compatibility ${diagnostic.code} at ${JSON.stringify(diagnostic.path)}: ${diagnostic.message}`);
+    }
+}
+function replaceIrModuleBackendContext(modules, replacement) {
+    return modules.map((module) => module.packageName === replacement.packageName &&
+        module.source === replacement.source &&
+        module.name === replacement.name
+        ? replacement
+        : module);
+}
+function assertRuntimeExternalSymbolBindingsRust(module, options) {
+    const completeness = analyzeCompilerRuntimeExternalSymbolCompleteness(collectIrModulesRuntimeExternalSymbolIdentities([module]), createCompilerRuntimeExternalSymbolBindingPlanRust(options.hostBindings));
+    if (completeness.kind === 'complete')
+        return;
+    const problems = [
+        completeness.missingExternalSymbols.length > 0
+            ? `missing: ${completeness.missingExternalSymbols.map(formatRuntimeExternalSymbolIdentity).join(', ')}`
+            : undefined,
+        completeness.duplicateExternalSymbols.length > 0
+            ? `duplicate: ${completeness.duplicateExternalSymbols.map(formatRuntimeExternalSymbolIdentity).join(', ')}`
+            : undefined,
+    ].filter((problem) => problem !== undefined);
+    throw createBackendEmissionFailure('rust', module, `runtime external symbol binding plan is incomplete (${problems.join('; ')})`, 'rust-runtime-external-symbol-binding-incomplete', { classification: 'target-runtime' });
+}
+function assertRuntimeExternalConstructorAbiRust(module) {
+    const completeness = analyzeCompilerRuntimeExternalConstructorAbiCompleteness(collectIrModulesRuntimeExternalConstructorInvocations([module]), createCompilerRuntimeExternalConstructorAbiPlanRust());
+    if (completeness.kind === 'complete')
+        return;
+    const problems = [
+        completeness.missingExternalConstructors.length > 0
+            ? `missing: ${completeness.missingExternalConstructors.map(formatRuntimeExternalConstructorInvocation).join(', ')}`
+            : undefined,
+        completeness.duplicateExternalConstructors.length > 0
+            ? `duplicate: ${completeness.duplicateExternalConstructors.map(formatRuntimeExternalSymbolIdentity).join(', ')}`
+            : undefined,
+        completeness.invalidExternalConstructors.length > 0
+            ? `invalid: ${completeness.invalidExternalConstructors.map(formatRuntimeExternalSymbolIdentity).join(', ')}`
+            : undefined,
+    ].filter((problem) => problem !== undefined);
+    throw createBackendEmissionFailure('rust', module, `runtime external constructor ABI plan is incomplete (${problems.join('; ')})`, 'rust-runtime-external-constructor-abi-incomplete', { classification: 'target-runtime' });
+}
+function formatRuntimeExternalConstructorInvocation(invocation) {
+    return `${formatRuntimeExternalSymbolIdentity(invocation.externalSymbol)}(${invocation.providedArgumentCount === 'dynamic' ? '...' : String(invocation.providedArgumentCount)})`;
+}
+function formatRuntimeExternalSymbolIdentity(identity) {
+    return `${identity.sourceName}[${identity.space}]`;
+}
+function isAmbientIdentifier(expression) {
+    return expression.kind === 'identifier' && expression.reference.kind === 'ambient';
+}
+function emissionError(context, message) {
+    throw createBackendEmissionFailure('rust', context.module, message);
+}
+function collectStringConcatenationOperands(expression) {
+    if (expression.kind === 'binary' &&
+        expression.operator === '+' &&
+        expression.semantics.left.flow === 'string' &&
+        expression.semantics.right.flow === 'string') {
+        return [
+            ...collectStringConcatenationOperands(expression.left),
+            ...collectStringConcatenationOperands(expression.right),
+        ];
+    }
+    return [expression];
+}
+function emitStringConcatenationRust(expression, context) {
+    const operands = collectStringConcatenationOperands(expression);
+    const format = operands
+        .map((operand) => operand.kind === 'literal' && typeof operand.value === 'string'
+        ? operand.value.replaceAll('{', '{{').replaceAll('}', '}}')
+        : '{}')
+        .join('');
+    const values = operands.flatMap((operand) => operand.kind === 'literal' && typeof operand.value === 'string' ? [] : [emitExpression(operand, context)]);
+    return `format!(${JSON.stringify(format)}${values.length > 0 ? `, ${values.join(', ')}` : ''})`;
+}
+function emitAssignmentOperatorRust(operator, semantics, context) {
+    const emitted = rustAssignmentOperatorEmission[operator];
+    if (!emitted)
+        emissionError(context, `operator ${operator} requires Rust semantic lowering`);
+    if (!isAssignmentOperatorDirectRust(operator, semantics)) {
+        emissionError(context, `operator ${operator} on ${semantics.left.flow} and ${semantics.right.flow} requires Rust type-directed lowering`);
+    }
+    return emitted;
+}
+function emitBinaryOperatorRust(operator, semantics, context) {
+    const emitted = rustBinaryOperatorEmission[operator];
+    if (!emitted)
+        emissionError(context, `operator ${operator} requires Rust semantic lowering`);
+    if (!isBinaryOperatorDirectRust(operator, semantics)) {
+        emissionError(context, `operator ${operator} on ${semantics.left.flow} and ${semantics.right.flow} requires Rust type-directed lowering`);
+    }
+    return emitted;
+}
+function getStaticTypeofNameRust(domain) {
+    switch (domain) {
+        case 'bigint':
+        case 'boolean':
+        case 'number':
+        case 'string':
+        case 'symbol':
+        case 'undefined':
+            return domain;
+        case 'null':
+        case 'object':
+        case 'unknown':
+            return undefined;
+    }
+    return undefined;
+}
+function emitNumericUpdateUnaryRust(expression, context) {
+    const bindingType = expression.operand.kind === 'identifier' && expression.operand.reference.kind === 'binding'
+        ? context.bindingTypes.get(expression.operand.reference.binding.id)
+        : undefined;
+    if (expression.semantics.operand.flow !== 'number' ||
+        expression.semantics.result !== 'number' ||
+        expression.operand.kind !== 'identifier' ||
+        expression.operand.reference.kind !== 'binding' ||
+        bindingType?.kind !== 'primitive' ||
+        bindingType.name !== 'number') {
+        emissionError(context, `operator ${expression.operator} requires a numeric Rust binding target`);
+    }
+    const name = emitIdentifierReferenceRust(expression.operand.reference, context);
+    const arithmetic = expression.operator === '++' ? '+' : '-';
+    if (context.cellWrappedBindingIds.has(expression.operand.reference.binding.id)) {
+        const previous = getGeneratedTargetNameRust('update_previous', context);
+        const updated = `${previous} ${arithmetic} 1.0`;
+        return expression.postfix
+            ? `{ let ${previous} = ${name}.get(); ${name}.set(${updated}); ${previous} }`
+            : `{ let ${previous} = ${name}.get(); ${name}.set(${updated}); ${name}.get() }`;
+    }
+    if (context.refCellWrappedBindingIds.has(expression.operand.reference.binding.id)) {
+        emissionError(context, `operator ${expression.operator} cannot update a non-Copy Rust binding`);
+    }
+    if (!expression.postfix)
+        return `{ ${name} ${arithmetic}= 1.0; ${name} }`;
+    const previous = getGeneratedTargetNameRust('update_previous', context);
+    return `{ let ${previous} = ${name}; ${name} ${arithmetic}= 1.0; ${previous} }`;
+}
+function emitPrefixUnaryOperatorRust(operator, semantics, context) {
+    const decision = rustPrefixUnaryOperatorDecision[operator];
+    if ('refusal' in decision)
+        emissionError(context, decision.refusal);
+    if (!isPrefixUnaryOperatorDirectRust(operator, semantics)) {
+        emissionError(context, `operator ${operator} on ${semantics.operand.flow} requires Rust type-directed lowering`);
+    }
+    return decision.emitted;
+}
+function isAssignmentOperatorDirectRust(operator, semantics) {
+    if (operator === '=')
+        return true;
+    if (operator === '%=' || operator === '*=' || operator === '+=' || operator === '-=' || operator === '/=') {
+        return hasMatchingOperatorDomains(semantics, ['number']);
+    }
+    return false;
+}
+// Which expressions the Rust emitter renders as an `Option`. An optional chain projects into one; an
+// ordinary value does not, and wrapping it would claim a nullability the emitted type does not have.
+function isIrExpressionOptionShapedRust(expression, context) {
+    // An optional member is an `Option` field in the emitted record, so reading it is already the shape
+    // the operator needs — the chain is about the object being absent, this is about the member.
+    //
+    // A chain the source wrote over a receiver its own types say cannot be absent produces a plain
+    // value, not an `Option`. The `?.` is redundant there, and treating it as an `Option` asks a value
+    // for a method it does not have.
+    if (expression.kind === 'property') {
+        if (expression.optionalChain?.receiverNullish === 'excluded')
+            return false;
+        return expression.optional || expression.absent === 'optionalMember';
+    }
+    if (expression.kind === 'call')
+        return expression.optional;
+    // An array index is absent-admitting in the source language whatever the index is, which is why
+    // `values[index] ?? fallback` is ordinary code. Rust's `[]` panics instead, so the coalesce reads
+    // through `get`, which is both the Option the operator needs and the faithful behaviour.
+    if (expression.kind === 'element') {
+        return expression.optional || (expression.semantics.receivers.includes('array') && !expression.optional);
+    }
+    if (expression.kind === 'identifier' &&
+        expression.reference.kind === 'binding' &&
+        (context.nullableBindingIds.has(expression.reference.binding.id) ||
+            context.arrayElementBindingIds.has(expression.reference.binding.id)))
+        return true;
+    return expression.kind === 'undefinedDefault';
+}
+function emitOptionShapedOperandRust(expression, context) {
+    if (expression.kind === 'element' && !expression.optional && expression.semantics.receivers.includes('array')) {
+        return `${emitExpression(expression.object, context)}.get(${emitIndexOperandRust(expression.index, context)}).cloned()`;
+    }
+    return emitExpression(expression, context);
+}
+function isBinaryOperatorDirectRust(operator, semantics) {
+    if (operator === '%' || operator === '*' || operator === '+' || operator === '-' || operator === '/') {
+        return hasMatchingOperatorDomains(semantics, ['number']);
+    }
+    if (operator === '<' || operator === '<=' || operator === '>' || operator === '>=') {
+        return semantics.left.flow === 'number' && semantics.right.flow === 'number' && semantics.result === 'boolean';
+    }
+    if (operator === '&&' || operator === '||') {
+        return hasMatchingOperatorDomains(semantics, ['boolean']);
+    }
+    if (operator === '===' || operator === '!==') {
+        return (semantics.left.flow === semantics.right.flow &&
+            semantics.result === 'boolean' &&
+            (semantics.left.flow === 'boolean' || semantics.left.flow === 'number' || semantics.left.flow === 'string'));
+    }
+    if (operator === '&' || operator === '|' || operator === '^' || operator === '<<' || operator === '>>') {
+        return hasMatchingOperatorDomains(semantics, ['number']);
+    }
+    return false;
+}
+function isPrefixUnaryOperatorDirectRust(operator, semantics) {
+    if (operator === '!')
+        return semantics.operand.flow === 'boolean' && semantics.result === 'boolean';
+    if (operator === '+' || operator === '-')
+        return semantics.operand.flow === 'number' && semantics.result === 'number';
+    if (operator === '~')
+        return semantics.operand.flow === 'number' && semantics.result === 'number';
+    return false;
+}
+function hasMatchingOperatorDomains(semantics, supported) {
+    return (semantics.left.flow === semantics.right.flow &&
+        semantics.left.flow === semantics.result &&
+        supported.includes(semantics.left.flow));
+}
+function isNullableType(type) {
+    return (type.kind === 'null' ||
+        type.kind === 'undefined' ||
+        (type.kind === 'union' && type.types.some((member) => member.kind === 'null' || member.kind === 'undefined')));
+}
+function hasIrTypeNullMemberRust(type) {
+    return type.kind === 'null' || (type.kind === 'union' && type.types.some((member) => member.kind === 'null'));
+}
+function hasIrTypeUndefinedMemberRust(type) {
+    return (type.kind === 'undefined' || (type.kind === 'union' && type.types.some((member) => member.kind === 'undefined')));
+}
+function isIrTypeCloneSafeRust(type) {
+    switch (type.kind) {
+        case 'array':
+            return isIrTypeCloneSafeRust(type.element);
+        case 'literal':
+        case 'never':
+        case 'null':
+        case 'primitive':
+        case 'undefined':
+            return true;
+        case 'tuple':
+            return type.elements.every((element) => isIrTypeCloneSafeRust(element.type));
+        case 'union':
+            return type.types.every(isIrTypeCloneSafeRust);
+        case 'function':
+        case 'conditionalFacet':
+        case 'indexedAccess':
+        case 'intersection':
+        case 'keyof':
+        case 'named':
+        case 'object':
+        case 'typeOf':
+        case 'unknown':
+            return false;
+    }
+}
+// `Rc<dyn Fn>` is cloneable but the callable trait object does not implement `Debug`. Deriving
+// `Debug` for a record that contains one directly, through a container, or through a resolved source
+// type therefore makes otherwise valid generated Rust fail to compile. Retain the useful derive for
+// every record where no callable is proven, and omit only the unsupported bound.
+function emitRustRecordDerive(types, context) {
+    return types.some((type) => containsIrFunctionTypeRust(type, context))
+        ? '#[derive(Clone)]'
+        : '#[derive(Clone, Debug)]';
+}
+function containsIrFunctionTypeRust(type, context, module = context.module, resolving = new Set()) {
+    switch (type.kind) {
+        case 'function':
+            return true;
+        case 'array':
+            return containsIrFunctionTypeRust(type.element, context, module, resolving);
+        case 'tuple':
+            return type.elements.some((element) => containsIrFunctionTypeRust(element.type, context, module, resolving));
+        case 'intersection':
+        case 'union':
+            return type.types.some((member) => containsIrFunctionTypeRust(member, context, module, resolving));
+        case 'object':
+            return type.properties.some((property) => containsIrFunctionTypeRust(property.type, context, module, resolving));
+        case 'named': {
+            if (type.typeArguments.some((argument) => containsIrFunctionTypeRust(argument, context, module, resolving))) {
+                return true;
+            }
+            if (type.reference.kind !== 'binding' ||
+                type.reference.path.length > 0 ||
+                type.reference.binding.space !== 'type' ||
+                type.reference.binding.kind === 'typeParameter') {
+                return false;
+            }
+            const binding = type.reference.binding;
+            const location = getIrNamedTypeDeclarationLocationRust(binding, context, module);
+            if (location) {
+                const key = `${location.module.packageName}\0${location.module.source}\0${location.declaration.binding.id}`;
+                if (resolving.has(key))
+                    return false;
+                const active = new Set(resolving).add(key);
+                if (location.declaration.kind === 'typeAlias') {
+                    try {
+                        const plan = createIrTypeParameterSubstitutionPlan(location.declaration.typeParameters, type.typeArguments);
+                        return containsIrFunctionTypeRust(resolveIrTypeStructuralSubstitution(location.declaration.type, plan), context, location.module, active);
+                    }
+                    catch (error) {
+                        if (isCompilerStructuralTypeSubstitutionFailure(error))
+                            return false;
+                        throw error;
+                    }
+                }
+                const properties = getIrObjectTypePropertiesRust(type, context, module, resolving);
+                return (properties?.some((property) => containsIrFunctionTypeRust(property.type, context, location.module, active)) ??
+                    false);
+            }
+            const classDeclaration = [module, ...context.sourceModules]
+                .flatMap((candidate) => candidate.declarations)
+                .find((candidate) => candidate.kind === 'class' && candidate.binding.id === binding.id);
+            if (classDeclaration?.kind !== 'class')
+                return false;
+            const key = `${module.packageName}\0${module.source}\0${classDeclaration.binding.id}`;
+            if (resolving.has(key))
+                return false;
+            const active = new Set(resolving).add(key);
+            return (classDeclaration.fields.some((field) => containsIrFunctionTypeRust(field.type, context, module, active)) ||
+                (classDeclaration.extends
+                    ? containsIrFunctionTypeRust(classDeclaration.extends, context, module, active)
+                    : false));
+        }
+        case 'conditionalFacet':
+        case 'indexedAccess':
+        case 'keyof':
+        case 'literal':
+        case 'never':
+        case 'null':
+        case 'primitive':
+        case 'typeOf':
+        case 'undefined':
+        case 'unknown':
+            return false;
+    }
+}
+function opaqueHostType(context) {
+    return context.options.opaqueHostType ?? recordRuntimeTypeRust('OpaqueHostValue', context);
+}
+function rustImportModule(specifier, context) {
+    if (specifier.startsWith('.')) {
+        const resolvedModule = resolveImportModuleRust(specifier, undefined, context);
+        if (resolvedModule)
+            return `crate::${getRustModuleName(resolvedModule)}`;
+        const target = path.posix.normalize(path.posix.join(path.posix.dirname(context.module.source), specifier.replace(/\.[cm]?js$/u, '.ts')));
+        const resolved = /\.tsx?$/u.test(target) ? target : `${target}.ts`;
+        return `crate::${convertSourcePathToRustModuleName(resolved) ?? `_internal_${snakeCase(path.posix.basename(target))}`}`;
+    }
+    if (specifier.startsWith('@')) {
+        const packageName = /^(@[^/]+\/[^/]+)/u.exec(specifier)?.[1];
+        if (!packageName)
+            emissionError(context, `cannot identify package import ${specifier}`);
+        return convertPackageNameToRustCrateName(packageName).replaceAll('-', '_');
+    }
+    emissionError(context, `external import ${specifier} requires a runtime or standard-library mapping`);
+}
+function resolveImportModuleRust(specifier, importedName, context, importer = context.module) {
+    const matching = context.moduleResolution?.edges.filter((edge) => edge.specifier === specifier) ?? [];
+    const exact = matching.filter((edge) => edge.importer && isRustCompilerModuleIdentityEqual(edge.importer, importer));
+    const scoped = exact.length > 0 ? exact : matching.filter((edge) => !edge.importer);
+    const targets = scoped.filter((edge) => edge.importedNames === undefined || (importedName !== undefined && edge.importedNames.includes(importedName)));
+    const resolved = targets.flatMap((edge) => context.sourceModules.filter((module) => module.packageName === edge.target.packageName &&
+        path.posix.normalize(module.source) === path.posix.normalize(edge.target.source)));
+    const unique = [
+        ...new Map(resolved.map((module) => [`${module.packageName}\0${module.source}\0${module.name}`, module])).values(),
+    ];
+    if (unique.length === 1)
+        return unique[0];
+    return specifier.startsWith('.') ? resolveRelativeImportModuleRust(specifier, context, importer) : undefined;
+}
+function resolveRelativeImportModuleRust(specifier, context, importer) {
+    const source = path.posix.normalize(path.posix.join(path.posix.dirname(importer.source), specifier.replace(/\.[cm]?js$/u, '.ts')));
+    const candidates = new Set([source, `${source}.ts`, `${source}/index.ts`]);
+    return context.sourceModules.find((module) => module.packageName === importer.packageName && candidates.has(path.posix.normalize(module.source)));
+}
+function isRustCompilerModuleIdentityEqual(left, right) {
+    return (left.packageName === right.packageName &&
+        path.posix.normalize(left.source) === path.posix.normalize(right.source) &&
+        left.name === right.name);
+}
+function getRustModuleName(module) {
+    return convertSourcePathToRustModuleName(module.source) ?? `_internal_${snakeCase(module.name)}`;
+}
+function getRustModuleFilePath(module, sourceModules) {
+    const fileName = `${getRustModuleName(module)}.rs`;
+    const packageNames = new Set(sourceModules.map((candidate) => candidate.packageName));
+    return packageNames.size > 1 ? `${convertPackageNameToRustCrateName(module.packageName)}/src/${fileName}` : fileName;
+}
+function safeRustTypeName(name) {
+    const stripped = name.startsWith('#') ? name.slice(1) : name;
+    const value = stripped
+        .split('.')
+        .map((segment) => pascalCase(segment))
+        .join('::');
+    return isRustCompilerKeyword(value) ? `${value}_` : value;
+}
+// A union alias becomes a Rust enum only when every alternative is a named record available through
+// this module's own declarations or imports. Anonymous shapes still have no stable variant identity.
+function getIrUnionTypeMemberRecordsRust(type, context) {
+    const members = [];
+    for (const member of type.types) {
+        if (member.kind !== 'named' ||
+            member.reference.kind !== 'binding' ||
+            member.reference.binding.space !== 'type' ||
+            member.reference.path.length > 0 ||
+            member.typeArguments.length > 0) {
+            return undefined;
+        }
+        const name = member.reference.binding.name;
+        const declaration = getIrNamedTypeDeclarationLocationRust(member.reference.binding, context, context.module)?.declaration;
+        const properties = declaration?.kind === 'interface' && declaration.typeParameters.length === 0
+            ? declaration.properties
+            : declaration?.kind === 'typeAlias' &&
+                declaration.typeParameters.length === 0 &&
+                declaration.type.kind === 'object'
+                ? declaration.type.properties
+                : undefined;
+        if (!properties)
+            return undefined;
+        members.push({ name, properties, targetName: getTypeBindingTargetNameRust(member.reference.binding, context) });
+    }
+    return members.length > 1 ? members : undefined;
+}
+function getIrNamedTypeDeclarationLocationRust(binding, context, module) {
+    const declarationModule = [module, ...context.sourceModules].find((candidateModule) => candidateModule.declarations.some((candidate) => (candidate.kind === 'interface' || candidate.kind === 'typeAlias') && candidate.binding.id === binding.id));
+    const local = declarationModule?.declarations.find((candidate) => (candidate.kind === 'interface' || candidate.kind === 'typeAlias') && candidate.binding.id === binding.id);
+    if (local && declarationModule)
+        return { declaration: local, module: declarationModule };
+    // A flattened imported declaration can retain a type reference introduced by its own module.
+    // Follow the binding back to that importer rather than assuming every inherited property was
+    // rebound into the subject module.
+    const importer = [module, ...context.sourceModules].find((candidateModule) => candidateModule.imports.some((item) => item.bindings.some((candidate) => candidate.binding.id === binding.id)));
+    const imported = importer?.imports
+        .flatMap((item) => item.bindings.map((candidate) => ({ candidate, specifier: item.specifier })))
+        .find(({ candidate }) => candidate.binding.id === binding.id);
+    if (!imported || imported.candidate.imported === '*' || imported.candidate.imported === 'default')
+        return undefined;
+    const targetModule = resolveImportModuleRust(imported.specifier, imported.candidate.imported, context, importer);
+    const declaration = targetModule?.declarations.find((candidate) => (candidate.kind === 'interface' || candidate.kind === 'typeAlias') &&
+        candidate.binding.name === imported.candidate.imported);
+    return declaration && targetModule ? { declaration, module: targetModule } : undefined;
+}
+function getIrCallBorrowedPositionsRust(expression, context) {
+    return expression.callee.kind === 'identifier' && expression.callee.reference.kind === 'binding'
+        ? (context.borrowedParameterPositions.get(expression.callee.reference.binding.id) ?? new Set())
+        : new Set();
+}
+function getIrClassConcreteBaseRust(declaration, context) {
+    const reference = declaration.extends;
+    if (!reference || reference.kind !== 'named' || reference.reference.kind !== 'binding')
+        return undefined;
+    const binding = reference.reference.binding;
+    const target = context.module.declarations.find((candidate) => candidate.kind === 'class' && candidate.binding.id === binding.id);
+    return target?.kind === 'class' && !target.abstract ? target : undefined;
+}
+function getIrClassStatelessAbstractBaseRust(declaration, context) {
+    const reference = declaration.extends;
+    if (!reference || reference.kind !== 'named' || reference.reference.kind !== 'binding')
+        return undefined;
+    const binding = reference.reference.binding;
+    const target = context.module.declarations.find((candidate) => candidate.kind === 'class' && candidate.binding.id === binding.id);
+    return target?.kind === 'class' &&
+        target.abstract &&
+        target.fields.every((field) => field.abstract) &&
+        !target.extends
+        ? target
+        : undefined;
+}
+function emitAbstractClassTraitRust(declaration, context) {
+    if (declaration.fields.some((field) => !field.abstract)) {
+        emissionError(context, `abstract class ${declaration.binding.name} carries state a Rust trait cannot hold`);
+    }
+    if (declaration.classConstructor && declaration.classConstructor.body.length > 0) {
+        emissionError(context, `abstract class ${declaration.binding.name} constructor has no Rust trait equivalent`);
+    }
+    const abstractFields = declaration.fields.filter((field) => field.abstract);
+    const fieldNames = new Set(abstractFields.map((field) => field.name));
+    const mutating = getIrClassMutatingMethodNamesRust(declaration);
+    const visibility = declaration.exported || context.apiReferencedBindingIds.has(declaration.binding.id) ? 'pub ' : '';
+    const lines = [
+        `${visibility}trait ${getBindingTargetNameRust(declaration.binding, context)}${emitTypeParameters(declaration.typeParameters, context)} {`,
+    ];
+    abstractFields.forEach((field, index) => {
+        if (index > 0)
+            lines.push('');
+        lines.push(`  fn ${safeRustValueName(field.name)}(&self) -> ${emitType(field.type, context)};`);
+    });
+    const previousAbstractFieldNames = context.abstractFieldNames;
+    context.abstractFieldNames = fieldNames;
+    declaration.methods.forEach((method, index) => {
+        if (index > 0 || abstractFields.length > 0)
+            lines.push('');
+        const target = getIrClassMethodTargetNameRust(method);
+        const parameters = [
+            ...(method.static ? [] : [method.accessor === 'set' || mutating.has(target) ? '&mut self' : '&self']),
+            ...method.parameters.map((parameter) => emitParameter(parameter, context)),
+        ].join(', ');
+        const returns = method.accessor === 'set' ? '()' : emitType(method.returns, context);
+        const signature = `  fn ${target}${emitTypeParameters(method.typeParameters, context)}(${parameters}) -> ${returns}`;
+        if (method.abstract) {
+            lines.push(`${signature};`);
+            return;
+        }
+        lines.push(`${signature} {`, ...indentSourceLines(emitStatements(method.body, context), 2), '  }');
+    });
+    context.abstractFieldNames = previousAbstractFieldNames;
+    lines.push('}');
+    return lines;
+}
+function getIrExpressionClassDeclarationRust(object, context) {
+    if (object.kind !== 'identifier' || object.reference.kind !== 'binding')
+        return undefined;
+    const binding = object.reference.binding;
+    const declaration = context.module.declarations.find((candidate) => candidate.kind === 'class' && candidate.binding.id === binding.id);
+    return declaration?.kind === 'class' ? declaration : undefined;
+}
+function getIrExpressionEnumDeclarationRust(object, context) {
+    if (object.kind !== 'identifier' || object.reference.kind !== 'binding')
+        return undefined;
+    const binding = object.reference.binding;
+    const declaration = context.module.declarations.find((candidate) => candidate.kind === 'enum' && candidate.binding.id === binding.id);
+    return declaration?.kind === 'enum' ? declaration : undefined;
+}
+function getIrTypeNumericEnumNamespaceNameRust(type, context) {
+    return type.kind === 'named' && type.reference.kind === 'binding'
+        ? context.numericEnumNamespaceNames.get(type.reference.binding.id)
+        : undefined;
+}
+function getIrExpressionNumericEnumNamespaceNameRust(expression, context) {
+    if (expression.kind === 'identifier' && expression.reference.kind === 'binding') {
+        const type = context.bindingTypes.get(expression.reference.binding.id);
+        return type ? getIrTypeNumericEnumNamespaceNameRust(type, context) : undefined;
+    }
+    if (expression.kind !== 'property')
+        return undefined;
+    if (expression.namespaceMember?.kind === 'binding') {
+        return context.numericEnumNamespaceNames.get(expression.namespaceMember.binding.id);
+    }
+    const declaration = getIrExpressionEnumDeclarationRust(expression.object, context);
+    return declaration ? context.numericEnumNamespaceNames.get(declaration.binding.id) : undefined;
+}
+function emitNumericEnumOperandRust(expression, context) {
+    const emitted = emitExpression(expression, context);
+    return getIrExpressionNumericEnumNamespaceNameRust(expression, context) ? `((${emitted}).0 as f64)` : emitted;
+}
+function getIrExpressionClassAccessorRust(object, name, accessor, context) {
+    if (object.kind !== 'identifier' || object.reference.kind !== 'binding')
+        return false;
+    const className = context.accessorClassNames.get(object.reference.binding.id);
+    if (!className)
+        return false;
+    const declaration = context.module.declarations.find((candidate) => candidate.kind === 'class' && candidate.binding.name === className);
+    return (declaration?.kind === 'class' &&
+        declaration.methods.some((method) => method.accessor === accessor && method.name === name));
+}
+function getIrExpressionTaggedUnionRust(expression, context) {
+    if (expression.kind !== 'identifier' || expression.reference.kind !== 'binding')
+        return undefined;
+    return context.taggedUnionBindingNames.get(expression.reference.binding.id);
+}
+function collectPrimitiveUnionBindingsRust(module, context) {
+    for (const declaration of module.declarations) {
+        if (declaration.kind !== 'function')
+            continue;
+        for (const parameter of declaration.parameters) {
+            if (parameter.type.kind !== 'union')
+                continue;
+            const concrete = parameter.type.types.filter((t) => t.kind !== 'null' && t.kind !== 'undefined');
+            if (concrete.length < 2)
+                continue;
+            const enumRecord = getOrCreatePrimitiveUnionEnumRust(concrete, context);
+            if (enumRecord) {
+                context.primitiveUnionBindingIds.set(parameter.binding.id, enumRecord.name);
+            }
+        }
+        if (declaration.returns.kind === 'union') {
+            const concrete = declaration.returns.types.filter((t) => t.kind !== 'null' && t.kind !== 'undefined');
+            if (concrete.length >= 2)
+                getOrCreatePrimitiveUnionEnumRust(concrete, context);
+        }
+    }
+    analyzeIrModuleTraversal(module, {
+        variable(variable) {
+            if (!('binding' in variable) || !variable.type || variable.type.kind !== 'union')
+                return;
+            const concrete = variable.type.types.filter((t) => t.kind !== 'null' && t.kind !== 'undefined');
+            if (concrete.length < 2)
+                return;
+            const enumRecord = getOrCreatePrimitiveUnionEnumRust(concrete, context);
+            if (enumRecord) {
+                context.primitiveUnionBindingIds.set(variable.binding.id, enumRecord.name);
+            }
+        },
+    });
+}
+function emitPrimitiveUnionEnumRust(union) {
+    const lines = [
+        '#[derive(Clone, Debug)]',
+        // Primitive unions are structural products of a public signature rather than source-named
+        // declarations. Keeping the generated enum private makes every exported function that carries
+        // one unusable outside its module, so the representation itself is part of the public ABI.
+        `pub enum ${union.name} {`,
+        ...union.variants.map((v) => `  ${v.variantName}(${v.rustType}),`),
+        '}',
+        '',
+        `impl ${union.name} {`,
+        ...union.variants.flatMap((v) => [
+            `  fn as_${snakeCase(v.variantName)}(&self) -> &${v.rustType} {`,
+            '    match self {',
+            `      ${union.name}::${v.variantName}(value) => value,`,
+            ...(union.variants.length > 1 ? [`      _ => panic!("${union.name} is not ${v.variantName}"),`] : []),
+            '    }',
+            '  }',
+        ]),
+        '}',
+        '',
+        `impl std::fmt::Display for ${union.name} {`,
+        "  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {",
+        '    match self {',
+        ...union.variants.map((v) => `      ${union.name}::${v.variantName}(value) => write!(f, "{}", value),`),
+        '    }',
+        '  }',
+        '}',
+    ];
+    return lines;
+}
+function isIrCastTargetNumericRust(type) {
+    if (type.kind === 'primitive')
+        return type.name === 'number' || type.name === 'boolean';
+    return false;
+}
+function isIrTypeCopyRust(type) {
+    if (type.kind === 'primitive')
+        return type.name === 'number' || type.name === 'boolean';
+    if (type.kind === 'union') {
+        const nonNull = type.types.filter((member) => member.kind !== 'null' && member.kind !== 'undefined');
+        const sole = nonNull[0];
+        return nonNull.length === 1 && sole !== undefined && isIrTypeCopyRust(sole);
+    }
+    return false;
+}
+function emitPrimitiveUnionCastRust(expression, context) {
+    if (expression.type.kind !== 'primitive')
+        return undefined;
+    const targetName = expression.type.name;
+    const primitiveUnion = getIrExpressionPrimitiveUnionRust(expression.expression, context);
+    if (!primitiveUnion)
+        return undefined;
+    const variant = primitiveUnion.variants.find((v) => v.primitiveKind === targetName);
+    if (!variant)
+        return undefined;
+    const emitted = emitExpression(expression.expression, context);
+    if (variant.primitiveKind === 'string')
+        return `${emitted}.as_${snakeCase(variant.variantName)}().clone()`;
+    return `*${emitted}.as_${snakeCase(variant.variantName)}()`;
+}
+function emitPrimitiveUnionNarrowedReceiverRust(expression, context) {
+    if (expression.kind !== 'identifier' || !expression.narrowedMember)
+        return undefined;
+    const primitiveUnion = getIrExpressionPrimitiveUnionRust(expression, context);
+    if (!primitiveUnion)
+        return undefined;
+    const variant = primitiveUnion.variants.find((v) => v.primitiveKind === expression.narrowedMember);
+    if (!variant)
+        return undefined;
+    return `${emitIdentifierReferenceRust(expression.reference, context)}.as_${snakeCase(variant.variantName)}()`;
+}
+function getIrExpressionPrimitiveUnionRust(expression, context) {
+    if (expression.kind !== 'identifier' || expression.reference.kind !== 'binding')
+        return undefined;
+    const enumName = context.primitiveUnionBindingIds.get(expression.reference.binding.id);
+    if (!enumName)
+        return undefined;
+    for (const union of context.primitiveUnionEnums.values()) {
+        if (union.name === enumName)
+            return union;
+    }
+    return undefined;
+}
+function getOrCreatePrimitiveUnionEnumRust(types, context) {
+    if (!types.every((t) => t.kind === 'primitive'))
+        return undefined;
+    const primitives = types.filter((t) => t.kind === 'primitive');
+    const rustPrimitiveInfo = {
+        boolean: { rustType: 'bool', variantName: 'Bool' },
+        number: { rustType: 'f64', variantName: 'F64' },
+        string: { rustType: 'String', variantName: 'Str' },
+    };
+    const variants = primitives.flatMap((p) => {
+        const info = rustPrimitiveInfo[p.name];
+        return info ? [{ primitiveKind: p.name, ...info }] : [];
+    });
+    if (variants.length !== primitives.length)
+        return undefined;
+    const key = variants
+        .map((v) => v.primitiveKind)
+        .sort()
+        .join('|');
+    const existing = context.primitiveUnionEnums.get(key);
+    if (existing)
+        return existing;
+    const name = variants.map((v) => v.variantName).join('Or');
+    const record = { name, variants };
+    context.primitiveUnionEnums.set(key, record);
+    return record;
+}
+function getTypeofTypeTestRust(expression, context) {
+    if (expression.operator !== '===' &&
+        expression.operator !== '==' &&
+        expression.operator !== '!==' &&
+        expression.operator !== '!=') {
+        return undefined;
+    }
+    const typeofSide = expression.left.kind === 'unary' && !expression.left.postfix && expression.left.operator === 'typeof'
+        ? expression.left
+        : expression.right.kind === 'unary' && !expression.right.postfix && expression.right.operator === 'typeof'
+            ? expression.right
+            : undefined;
+    const literalSide = typeofSide === expression.left ? expression.right : expression.left;
+    if (!typeofSide || literalSide.kind !== 'literal' || typeof literalSide.value !== 'string')
+        return undefined;
+    const primitiveUnion = getIrExpressionPrimitiveUnionRust(typeofSide.operand, context);
+    if (!primitiveUnion)
+        return undefined;
+    const variant = primitiveUnion.variants.find((v) => v.primitiveKind === literalSide.value);
+    if (!variant)
+        return undefined;
+    return {
+        enumName: primitiveUnion.name,
+        negated: expression.operator === '!==' || expression.operator === '!=',
+        operand: typeofSide.operand,
+        variantName: variant.variantName,
+    };
+}
+// A Rust enum plus the accessors that make the alternatives reachable: one per alternative for a
+// reference control flow narrowed, and one per field every alternative shares for a reference it did
+// not. An accessor rather than a `match` at each site keeps the emitted shape of the source's own
+// control flow, which is what makes the two targets comparable.
+function emitTaggedUnionRust(targetName, type, exported, context) {
+    const members = getIrUnionTypeMemberRecordsRust(type, context);
+    if (!members)
+        emissionError(context, 'non-nullable unions require Rust tagged-union lowering');
+    const visibility = exported ? 'pub ' : '';
+    const lines = [emitRustRecordDerive(type.types, context), `${visibility}enum ${targetName} {`];
+    for (const member of members) {
+        lines.push(`  ${pascalCase(member.name)}(${member.targetName}),`);
+    }
+    lines.push('}', '', `impl ${targetName} {`);
+    for (const member of members) {
+        lines.push(`  ${visibility}fn as_${safeRustValueName(member.name)}(&self) -> &${member.targetName} {`, '    match self {', `      ${targetName}::${pascalCase(member.name)}(value) => value,`, ...(members.length > 1 ? [`      _ => panic!("${targetName} is not ${pascalCase(member.name)}"),`] : []), '    }', '  }');
+    }
+    const shared = members[0].properties.filter((property) => members.every((member) => member.properties.some((candidate) => candidate.name === property.name)));
+    for (const property of shared) {
+        lines.push(`  ${visibility}fn ${safeRustValueName(property.name)}(&self) -> ${emitType(property.type, context)} {`, '    match self {', ...members.map((member) => `      ${targetName}::${pascalCase(member.name)}(value) => value.${safeRustValueName(property.name)}.clone(),`), '    }', '  }');
+    }
+    lines.push('}');
+    return lines;
+}
+function getOrCreateAnonymousUnionEnumRust(types, context) {
+    const key = JSON.stringify({
+        parameters: context.activeTypeParameters.map((parameter) => parameter.binding.id),
+        types,
+    });
+    const existing = context.anonymousUnionEnums.get(key);
+    if (existing)
+        return existing;
+    const record = {
+        name: getGeneratedTargetNameRust('AnonymousUnion', context),
+        typeParameters: context.activeTypeParameters,
+        variants: [],
+    };
+    // Register the identity before rendering payload types so a recursive named alias can lead back
+    // to this generated enum without allocating a second definition.
+    context.anonymousUnionEnums.set(key, record);
+    record.variants.push(...createGeneralUnionVariantsRust(types, context));
+    return record;
+}
+function createGeneralUnionVariantsRust(types, context) {
+    const names = new Map();
+    return types.flatMap((type) => {
+        if (type.kind === 'never')
+            return [];
+        const preferred = getGeneralUnionVariantNameRust(type, context);
+        const occurrence = (names.get(preferred) ?? 0) + 1;
+        names.set(preferred, occurrence);
+        const name = occurrence === 1 ? preferred : `${preferred}${String(occurrence)}`;
+        if (type.kind === 'literal' || type.kind === 'null' || type.kind === 'undefined') {
+            return [{ kind: 'unit', name }];
+        }
+        const properties = type.kind === 'object' || type.kind === 'intersection' ? getIrObjectTypePropertiesRust(type, context) : undefined;
+        if (properties) {
+            return [
+                {
+                    fields: properties.map((property) => ({
+                        name: safeRustValueName(property.name),
+                        optional: property.optional,
+                        rustType: emitType(property.type, context),
+                    })),
+                    kind: 'struct',
+                    name,
+                },
+            ];
+        }
+        return [{ kind: 'tuple', name, rustType: emitType(type, context) }];
+    });
+}
+function getGeneralUnionVariantNameRust(type, context) {
+    if (type.kind === 'literal') {
+        if (typeof type.value === 'boolean')
+            return type.value ? 'True' : 'False';
+        if (typeof type.value === 'number') {
+            return safeRustTypeName(`Number ${String(type.value).replace('-', 'Negative ')}`) || 'Number';
+        }
+        return safeRustTypeName(type.value) || 'String';
+    }
+    if (type.kind === 'named') {
+        return safeRustTypeName(type.reference.kind === 'ambient'
+            ? type.reference.name
+            : (type.reference.path.at(-1) ?? type.reference.binding.name));
+    }
+    if (type.kind === 'object' || type.kind === 'intersection') {
+        const properties = getIrObjectTypePropertiesRust(type, context);
+        const discriminant = properties?.find((property) => property.type.kind === 'literal' && typeof property.type.value === 'string');
+        if (discriminant?.type.kind === 'literal' && typeof discriminant.type.value === 'string') {
+            return safeRustTypeName(discriminant.type.value) || 'Object';
+        }
+    }
+    return {
+        array: 'Array',
+        conditionalFacet: 'ConditionalFacet',
+        function: 'Function',
+        indexedAccess: 'IndexedAccess',
+        intersection: 'Intersection',
+        keyof: 'Key',
+        never: 'Never',
+        null: 'Null',
+        object: 'Object',
+        primitive: type.kind === 'primitive'
+            ? { bigint: 'I64', boolean: 'Bool', number: 'F64', string: 'String', symbol: 'Symbol', void: 'Void' }[type.name]
+            : 'Value',
+        tuple: 'Tuple',
+        typeOf: 'TypeOf',
+        undefined: 'Undefined',
+        union: 'Union',
+        unknown: 'Unknown',
+    }[type.kind];
+}
+function emitGeneralUnionRust(targetName, variants, typeParameters, exported, context) {
+    const visibility = exported ? 'pub ' : '';
+    const lines = ['#[derive(Clone)]', `${visibility}enum ${targetName}${emitTypeParameters(typeParameters, context)} {`];
+    for (const variant of variants) {
+        if (variant.kind === 'unit') {
+            lines.push(`  ${variant.name},`);
+        }
+        else if (variant.kind === 'tuple') {
+            lines.push(`  ${variant.name}(${variant.rustType}),`);
+        }
+        else {
+            lines.push(`  ${variant.name} {`, ...variant.fields.map((field) => `    ${field.name}: ${field.optional ? `Option<${field.rustType}>` : field.rustType},`), '  },');
+        }
+    }
+    lines.push('}');
+    return lines;
+}
+// Rust spells a constant in upper snake case, and the name is otherwise the source's own.
+// A getter keeps the source's name, because a call reads the same way; a setter takes a `set_` name,
+// because the two accessors share one name in the source and Rust has one namespace for both.
+function getIrClassMethodTargetNameRust(method) {
+    return method.accessor === 'set' ? `set_${safeRustValueName(method.name)}` : safeRustValueName(method.name);
+}
+// A runtime type is named bare where it is used and imported once at the top, which is how Rust
+// spells a dependency. Recording the name at the point of use is what makes the import exact.
+// Rust braces a use list only when there is more than one name in it, which is what `rustfmt` leaves
+// behind and therefore what canonical output looks like.
+function emitUseTreeRust(names) {
+    return names.length === 1 ? names[0] : `{${names.join(', ')}}`;
+}
+function recordRuntimeTypeRust(name, context) {
+    context.runtimeTypeNames.add(name);
+    return name;
+}
+function constantRustName(name) {
+    return safeRustValueName(name).toUpperCase();
+}
+function safeRustValueName(name) {
+    if (name === 'this')
+        return 'self';
+    const stripped = name.startsWith('#') ? name.slice(1) : name;
+    const value = snakeCase(stripped);
+    return isRustCompilerKeyword(value) ? `${value}_` : value;
+}
+function pascalCase(value) {
+    return value
+        .split(/[-_]/u)
+        .filter(Boolean)
+        .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+        .join('');
+}
+function screamingSnakeCase(value) {
+    return snakeCase(value).toUpperCase();
+}
+function snakeCase(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/gu, '$1_$2')
+        .replace(/([A-Z]+)([A-Z][a-z])/gu, '$1_$2')
+        .replace(/[-\s]+/gu, '_')
+        .toLowerCase();
+}
+const rustTypedArrayConstructorNames = new Set([
+    'Float32Array',
+    'Float64Array',
+    'Int8Array',
+    'Int16Array',
+    'Int32Array',
+    'Uint8Array',
+    'Uint8ClampedArray',
+    'Uint16Array',
+    'Uint32Array',
+]);
+const rustTypedArrayReceiverNames = new Set([
+    'float32Array',
+    'float64Array',
+    'int8Array',
+    'int16Array',
+    'int32Array',
+    'uint8Array',
+    'uint8ClampedArray',
+    'uint16Array',
+    'uint32Array',
+]);
+const rustAssignmentOperatorEmission = {
+    '%=': '%=',
+    '&&=': undefined,
+    '&=': '&=',
+    '**=': undefined,
+    '*=': '*=',
+    '+=': '+=',
+    '-=': '-=',
+    '/=': '/=',
+    '<<=': '<<=',
+    '=': '=',
+    '>>=': '>>=',
+    '>>>=': undefined,
+    '??=': undefined,
+    '^=': '^=',
+    '|=': '|=',
+    '||=': undefined,
+};
+const rustBinaryOperatorEmission = {
+    '%': '%',
+    '&': '&',
+    '&&': '&&',
+    '*': '*',
+    '**': undefined,
+    '+': '+',
+    ',': undefined,
+    '-': '-',
+    '/': '/',
+    '<': '<',
+    '<<': '<<',
+    '<=': '<=',
+    '!=': '!=',
+    '!==': '!=',
+    '==': '==',
+    '===': '==',
+    '>': '>',
+    '>=': '>=',
+    '>>': '>>',
+    '>>>': undefined,
+    '??': undefined,
+    '^': '^',
+    in: undefined,
+    instanceof: undefined,
+    '|': '|',
+    '||': '||',
+};
+const rustPrefixUnaryOperatorDecision = {
+    '!': { emitted: '!' },
+    '+': { emitted: '+' },
+    '++': { refusal: 'prefix ++ requires value-preserving Rust lowering' },
+    '-': { emitted: '-' },
+    '--': { refusal: 'prefix -- requires value-preserving Rust lowering' },
+    delete: { refusal: 'delete requires Rust semantic lowering' },
+    typeof: { refusal: 'typeof requires Rust semantic lowering' },
+    void: { refusal: 'void requires Rust semantic lowering' },
+    '~': { emitted: '!' },
+};
+const rustMathSpreadFoldTargets = {
+    max: { folder: 'f64::max', identity: 'f64::NEG_INFINITY' },
+    min: { folder: 'f64::min', identity: 'f64::INFINITY' },
+};
+//# sourceMappingURL=rustCompilerBackend.js.map