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

package/dist/packages/compiler-task/src/compilerAsyncStateMachine.js

@@ -0,0 +1,785 @@
+import { analyzeIrModuleClosureEvidence } from '../../compiler-closure/src/index.js';
+import { createCompilerValueCompletionPathSet, getIrStatementListCompletionSet, } from '../../compiler-completion/src/index.js';
+import { analyzeIrModuleTraversal } from '../../compiler-ir-traversal/src/index.js';
+import { analyzeIrModuleAsyncTaskInventory } from './compilerAsyncTaskInventory.js';
+export function analyzeIrModuleAsyncStateMachines(module) {
+    const inventory = analyzeIrModuleAsyncTaskInventory(module);
+    const closureEvidence = analyzeIrModuleClosureEvidence(module);
+    const bodies = getIrModuleAsyncStateMachineBodies(module);
+    const bindingAnalysis = analyzeIrModuleAsyncStateMachineBindings(module, closureEvidence.closures.map((closure) => closure.path), inventory.suspensions);
+    const results = inventory.scopes.map((scope) => createCompilerAsyncStateMachine(scope, bodies.get(getCompilerAsyncStateMachinePathIdentity(scope.path)), inventory.suspensions.filter((suspension) => suspension.scopePath !== undefined && isCompilerAsyncStateMachinePathEqual(suspension.scopePath, scope.path)), closureEvidence.closures
+        .find((closure) => isCompilerAsyncStateMachinePathEqual(closure.path, scope.path))
+        .captures.filter((capture) => capture.lifetimeBoundaries.includes('suspension')), bindingAnalysis.retainedByScope.get(getCompilerAsyncStateMachinePathIdentity(scope.path)) ?? [], getIrModuleAsyncStateMachineOrigin(module)));
+    return cloneCompilerAsyncStateMachineValue({
+        machines: results.flatMap((result) => (result.machine ? [result.machine] : [])),
+        module: inventory.module,
+        refusals: results.flatMap((result) => (result.refusal ? [result.refusal] : [])),
+        schema: 'flight-compiler-async-state-machine-analysis/1',
+    });
+}
+function addCompilerAsyncStateMachineAbruptCompletion(path, draft) {
+    const value = createCompilerAsyncStateMachineExpressionValue(path, 'abrupt');
+    draft.completionPaths.push({ kind: 'throw', path, value });
+    return value;
+}
+function addCompilerAsyncStateMachineExecuteStep(statement, path, draft) {
+    const abruptValues = getIrStatementAsyncStateMachineAbruptPaths(statement, path).map((abruptPath) => addCompilerAsyncStateMachineAbruptCompletion(abruptPath, draft));
+    draft.currentSteps.push({ abruptValues, kind: 'execute', path });
+}
+function addCompilerAsyncStateMachineState(draft) {
+    const guard = draft.guards.at(-1);
+    draft.states.push({ ...(guard ? { guard } : {}), identity: draft.currentIdentity, steps: draft.currentSteps });
+}
+function addCompilerAsyncStateMachineSuspension(awaitPath, fulfillment, terminal, draft) {
+    const rejection = addCompilerAsyncStateMachineAbruptCompletion(awaitPath, draft);
+    addCompilerAsyncStateMachineAbruptCompletion([...awaitPath, 'expression'], draft);
+    const resumeState = { kind: 'resume', suspensionPath: awaitPath };
+    const guard = draft.guards.at(-1);
+    draft.currentSteps.push({
+        fulfillment,
+        kind: 'suspend',
+        operandPath: [...awaitPath, 'expression'],
+        path: awaitPath,
+        rejection,
+        ...(guard ? { rejectState: guard.catchState } : {}),
+        ...(terminal ? {} : { resumeState }),
+    });
+    if (terminal) {
+        draft.terminal = true;
+    }
+    else {
+        addCompilerAsyncStateMachineState(draft);
+        draft.currentIdentity = resumeState;
+        draft.currentSteps = [];
+    }
+}
+function cloneCompilerAsyncStateMachineValue(value) {
+    const clone = structuredClone(value);
+    freezeCompilerAsyncStateMachineValue(clone, new WeakSet());
+    return clone;
+}
+function analyzeIrModuleAsyncStateMachineBindings(module, closurePaths, suspensionSites) {
+    const definitions = new Map();
+    const suspensionOrdinals = new Map();
+    const uses = [];
+    let ordinal = 0;
+    analyzeIrModuleTraversal(module, {
+        bindingPattern(pattern, path) {
+            ordinal += 1;
+            if (pattern.kind === 'binding' && !definitions.has(pattern.binding.id)) {
+                definitions.set(pattern.binding.id, {
+                    binding: pattern.binding,
+                    ordinal,
+                    ownerPath: getCompilerAsyncStateMachineBoundaryPath(path, closurePaths),
+                    path,
+                });
+            }
+        },
+        expression(expression, path) {
+            ordinal += 1;
+            if (expression.kind === 'await') {
+                suspensionOrdinals.set(getCompilerAsyncStateMachinePathIdentity(path), ordinal);
+            }
+            if (expression.kind === 'identifier' && expression.reference.kind === 'binding') {
+                uses.push({
+                    bindingId: expression.reference.binding.id,
+                    ordinal,
+                    ownerPath: getCompilerAsyncStateMachineBoundaryPath(path, closurePaths),
+                    path,
+                });
+            }
+        },
+        parameter(parameter, path) {
+            ordinal += 1;
+            if (!definitions.has(parameter.binding.id)) {
+                definitions.set(parameter.binding.id, {
+                    binding: parameter.binding,
+                    ordinal,
+                    ownerPath: getCompilerAsyncStateMachineBoundaryPath(path, closurePaths),
+                    path,
+                });
+            }
+        },
+        statement(statement, path) {
+            ordinal += 1;
+            if (statement.kind === 'forOf' && statement.await) {
+                suspensionOrdinals.set(getCompilerAsyncStateMachinePathIdentity(path), ordinal);
+            }
+        },
+        variable(variable, path) {
+            ordinal += 1;
+            if ('binding' in variable && !definitions.has(variable.binding.id)) {
+                definitions.set(variable.binding.id, {
+                    binding: variable.binding,
+                    ordinal,
+                    ownerPath: getCompilerAsyncStateMachineBoundaryPath(path, closurePaths),
+                    path,
+                });
+            }
+        },
+    });
+    const retainedByScope = new Map();
+    for (const definition of definitions.values()) {
+        const ownerPath = definition.ownerPath;
+        if (!ownerPath || definition.binding.kind === 'function')
+            continue;
+        const crossings = suspensionSites.filter((suspension) => {
+            if (!suspension.scopePath ||
+                !isCompilerAsyncStateMachinePathEqual(suspension.scopePath, ownerPath) ||
+                isCompilerAsyncStateMachinePathWithin(suspension.path, [...definition.path, 'initializer'])) {
+                return false;
+            }
+            const suspensionOrdinal = suspensionOrdinals.get(getCompilerAsyncStateMachinePathIdentity(suspension.path));
+            return (suspensionOrdinal !== undefined &&
+                definition.ordinal < suspensionOrdinal &&
+                uses.some((use) => use.bindingId === definition.binding.id &&
+                    use.ordinal > suspensionOrdinal &&
+                    use.ownerPath !== undefined &&
+                    isCompilerAsyncStateMachinePathEqual(use.ownerPath, ownerPath) &&
+                    !isCompilerAsyncStateMachinePathWithin(use.path, suspension.path)));
+        });
+        if (crossings.length > 0) {
+            const key = getCompilerAsyncStateMachinePathIdentity(ownerPath);
+            const retained = retainedByScope.get(key) ?? [];
+            retained.push({
+                binding: definition.binding,
+                declarationPath: definition.path,
+                suspensionPaths: crossings.map((suspension) => suspension.path),
+            });
+            retainedByScope.set(key, retained);
+        }
+    }
+    return { retainedByScope };
+}
+// A stable origin for bindings the machine introduces. The module's first declaration carries real
+// source coordinates; a module with none introduces no bindings either.
+function getIrModuleAsyncStateMachineOrigin(module) {
+    const declaration = module.declarations[0];
+    return (declaration?.origin ?? {
+        column: 1,
+        fingerprint: `sha256:${'0'.repeat(64)}`,
+        line: 1,
+        packageName: module.packageName,
+        source: module.source,
+    });
+}
+function createCompilerAsyncStateMachine(scope, body, suspensions, retainedCaptures, retainedBindings, moduleOrigin) {
+    // `for await` is not a control-flow gap. Its loop shape is the one already compiled here; what it
+    // lacks is an async-iterator protocol in the runtime contract — how a target obtains an iterator
+    // and what a settled iteration result looks like. Until the runtime surface names that, there is
+    // nothing correct to lower it into, so it refuses ahead of the state machine rather than inside it.
+    const asyncIteration = suspensions.find((suspension) => suspension.kind === 'asyncIteration');
+    if (asyncIteration) {
+        return {
+            refusal: createCompilerAsyncStateMachineRefusal('unsupported-async-iteration', asyncIteration.path, scope.path),
+        };
+    }
+    const draft = {
+        completionPaths: [],
+        cleanups: [],
+        currentIdentity: { kind: 'entry' },
+        moduleOrigin,
+        guards: [],
+        loops: [],
+        currentSteps: [],
+        states: [],
+        terminal: false,
+    };
+    const refusal = body.expression
+        ? createIrExpressionBodyAsyncStateMachine(scope, body.expression, suspensions, draft)
+        : createIrStatementBodyAsyncStateMachine(scope, body.statements, suspensions, draft);
+    if (refusal)
+        return { refusal };
+    addCompilerAsyncStateMachineState(draft);
+    return {
+        machine: {
+            completionPaths: createCompilerValueCompletionPathSet(draft.completionPaths),
+            origin: scope.origin,
+            path: scope.path,
+            retainedBindings: getCompilerAsyncStateMachineLiveBindings(retainedBindings, draft.states),
+            retainedCaptures,
+            states: draft.states,
+        },
+    };
+}
+function getCompilerAsyncStateMachineLiveBindings(retainedBindings, states) {
+    const overwrites = states
+        .flatMap((state) => state.steps)
+        .flatMap((step) => step.kind === 'suspend' && (step.fulfillment.kind === 'initializeBinding' || step.fulfillment.kind === 'rebind')
+        ? [{ bindingId: step.fulfillment.binding.id, path: step.path }]
+        : []);
+    return retainedBindings.flatMap((retained) => {
+        const suspensionPaths = retained.suspensionPaths.filter((path) => !overwrites.some((overwrite) => overwrite.bindingId === retained.binding.id && isCompilerAsyncStateMachinePathEqual(overwrite.path, path)));
+        return suspensionPaths.length > 0 ? [{ ...retained, suspensionPaths }] : [];
+    });
+}
+function createCompilerAsyncStateMachineExpressionValue(path, phase) {
+    return { kind: 'expression', path, phase };
+}
+function createCompilerAsyncStateMachineRefusal(code, path, scopePath) {
+    return { code, path, scopePath };
+}
+function createIrExpressionBodyAsyncStateMachine(scope, expression, suspensions, draft) {
+    const path = [...scope.path, 'expression'];
+    if (suspensions.length === 0) {
+        const value = createCompilerAsyncStateMachineExpressionValue(path, 'result');
+        draft.currentSteps.push({
+            evaluationRejection: addCompilerAsyncStateMachineAbruptCompletion(path, draft),
+            kind: 'resolve',
+            path,
+            value,
+        });
+        draft.completionPaths.push({ kind: 'return', path, value });
+        draft.terminal = true;
+        return undefined;
+    }
+    if (suspensions.length !== 1 || expression.kind !== 'await') {
+        return createCompilerAsyncStateMachineRefusal('unsupported-suspension-expression', path, scope.path);
+    }
+    const value = createCompilerAsyncStateMachineExpressionValue(path, 'result');
+    addCompilerAsyncStateMachineSuspension(path, { kind: 'resolve', value }, true, draft);
+    draft.completionPaths.push({ kind: 'return', path, value });
+    return undefined;
+}
+function createIrStatementBodyAsyncStateMachine(scope, statements, suspensions, draft) {
+    const refusal = createIrStatementListAsyncStateMachine(scope, statements, [...scope.path, 'body'], suspensions, draft);
+    if (refusal)
+        return refusal;
+    completeIrStatementBodyAsyncStateMachine(scope, draft);
+    return undefined;
+}
+function createIrStatementListAsyncStateMachine(scope, statements, basePath, suspensions, draft) {
+    for (let index = 0; index < statements.length; index += 1) {
+        const statement = statements[index];
+        const path = [...basePath, index];
+        if (draft.terminal) {
+            return createCompilerAsyncStateMachineRefusal('unreachable-statement', path, scope.path);
+        }
+        const statementSuspensions = suspensions.filter((suspension) => isCompilerAsyncStateMachinePathWithin(suspension.path, path));
+        if (statementSuspensions.length > 0) {
+            const refusal = createIrStatementSuspensionAsyncStateMachine(scope, statement, path, statementSuspensions, draft);
+            if (refusal)
+                return refusal;
+            continue;
+        }
+        switch (statement.kind) {
+            case 'expression':
+            case 'variable':
+                addCompilerAsyncStateMachineExecuteStep(statement, path, draft);
+                break;
+            case 'return': {
+                const value = statement.expression
+                    ? createCompilerAsyncStateMachineExpressionValue([...path, 'expression'], 'result')
+                    : { kind: 'implicitUndefined' };
+                const cleanup = draft.cleanups.at(-1);
+                if (cleanup) {
+                    // The cleanup owes this route too, so the value waits in the carrier while the cleanup runs
+                    // and the cleanup performs the settlement.
+                    draft.currentSteps.push({ binding: cleanup.carrier, kind: 'carry', path, value });
+                    draft.currentSteps.push({ kind: 'goto', path, target: cleanup.target });
+                    draft.terminal = true;
+                    break;
+                }
+                draft.currentSteps.push({
+                    ...(statement.expression
+                        ? { evaluationRejection: addCompilerAsyncStateMachineAbruptCompletion([...path, 'expression'], draft) }
+                        : {}),
+                    kind: 'resolve',
+                    path,
+                    value,
+                });
+                draft.completionPaths.push({ kind: 'return', path, value });
+                draft.terminal = true;
+                break;
+            }
+            case 'throw': {
+                const value = createCompilerAsyncStateMachineExpressionValue([...path, 'expression'], 'result');
+                draft.currentSteps.push({
+                    evaluationRejection: addCompilerAsyncStateMachineAbruptCompletion([...path, 'expression'], draft),
+                    kind: 'reject',
+                    path,
+                    value,
+                });
+                draft.completionPaths.push({ kind: 'throw', path, value });
+                draft.terminal = true;
+                break;
+            }
+            case 'break':
+            case 'continue': {
+                // An unlabelled jump means the innermost loop; a labelled one means the loop that carries
+                // that label, which may be several levels out.
+                const target = statement.target;
+                const loop = target
+                    ? [...draft.loops].reverse().find((candidate) => candidate.label === target.id)
+                    : draft.loops.at(-1);
+                if (!loop) {
+                    return createCompilerAsyncStateMachineRefusal('escaping-control-flow', path, scope.path);
+                }
+                draft.currentSteps.push({
+                    kind: 'goto',
+                    path,
+                    target: statement.kind === 'break' ? loop.breakTarget : loop.continueTarget,
+                });
+                draft.terminal = true;
+                break;
+            }
+            case 'block':
+            case 'do':
+            case 'for':
+            case 'forIn':
+            case 'forOf':
+            case 'if':
+            case 'switch':
+            case 'try':
+            case 'while': {
+                if (isIrStatementAsyncStateMachineOpaque(statement)) {
+                    addCompilerAsyncStateMachineExecuteStep(statement, path, draft);
+                    break;
+                }
+                // Control leaves this statement, so it cannot run inside one state even though nothing in it
+                // suspends. The structured handlers own those routes; anything they do not model refuses
+                // there rather than here.
+                const refusal = createIrStatementSuspensionAsyncStateMachine(scope, statement, path, [], draft);
+                if (refusal)
+                    return refusal;
+                break;
+            }
+        }
+    }
+    return undefined;
+}
+function completeIrStatementBodyAsyncStateMachine(scope, draft) {
+    if (!draft.terminal) {
+        const path = [...scope.path, 'body', 'end'];
+        const value = { kind: 'implicitUndefined' };
+        draft.currentSteps.push({ kind: 'resolve', path, value });
+        draft.completionPaths.push({ kind: 'normal', path, value });
+        draft.terminal = true;
+    }
+}
+function createIrIfStatementAsyncStateMachine(scope, statement, path, suspensions, draft) {
+    const conditionPath = [...path, 'condition'];
+    if (suspensions.some((suspension) => isCompilerAsyncStateMachinePathWithin(suspension.path, conditionPath))) {
+        // A suspension in the condition has to settle before the branch is even decided, which is a
+        // different state shape from a suspension in an arm. Refused until it has one.
+        return createCompilerAsyncStateMachineRefusal('unsupported-suspension-expression', conditionPath, scope.path);
+    }
+    const whenTrue = { arm: 'whenTrue', kind: 'branchArm', path };
+    const whenFalse = { arm: 'whenFalse', kind: 'branchArm', path };
+    const join = { kind: 'join', path };
+    draft.currentSteps.push({
+        conditionPath,
+        evaluationRejection: addCompilerAsyncStateMachineAbruptCompletion(conditionPath, draft),
+        kind: 'branch',
+        path,
+        whenFalse: statement.otherwise ? whenFalse : join,
+        whenTrue,
+    });
+    addCompilerAsyncStateMachineState(draft);
+    draft.currentIdentity = whenTrue;
+    draft.currentSteps = [];
+    draft.terminal = false;
+    const consequent = createIrStatementArmAsyncStateMachine(scope, statement.consequent, [...path, 'consequent'], suspensions, draft);
+    if (consequent)
+        return consequent;
+    const trueTerminal = draft.terminal;
+    if (!trueTerminal)
+        draft.currentSteps.push({ kind: 'goto', path: [...path, 'consequent'], target: join });
+    addCompilerAsyncStateMachineState(draft);
+    let falseTerminal = false;
+    if (statement.otherwise) {
+        draft.currentIdentity = whenFalse;
+        draft.currentSteps = [];
+        draft.terminal = false;
+        const otherwise = createIrStatementArmAsyncStateMachine(scope, statement.otherwise, [...path, 'otherwise'], suspensions, draft);
+        if (otherwise)
+            return otherwise;
+        falseTerminal = draft.terminal;
+        if (!falseTerminal)
+            draft.currentSteps.push({ kind: 'goto', path: [...path, 'otherwise'], target: join });
+        addCompilerAsyncStateMachineState(draft);
+    }
+    draft.currentIdentity = join;
+    draft.currentSteps = [];
+    // The statement after the branch is reachable unless every arm left, and an `if` with no `else`
+    // always has a route that skips the consequent entirely.
+    draft.terminal = Boolean(statement.otherwise) && trueTerminal && falseTerminal;
+    return undefined;
+}
+function createIrLoopStatementAsyncStateMachine(scope, statement, path, suspensions, draft) {
+    const conditionPath = [...path, 'condition'];
+    if (suspensions.some((suspension) => isCompilerAsyncStateMachinePathWithin(suspension.path, conditionPath))) {
+        return createCompilerAsyncStateMachineRefusal('unsupported-suspension-expression', conditionPath, scope.path);
+    }
+    const header = { kind: 'loopHeader', path };
+    const body = { arm: 'whenTrue', kind: 'branchArm', path };
+    const join = { kind: 'join', path };
+    // `while` tests before its body, so a true test enters the body arm. `do` tests after its body,
+    // where the header *is* the body, so a true test re-enters the header instead.
+    const branch = () => ({
+        conditionPath,
+        evaluationRejection: addCompilerAsyncStateMachineAbruptCompletion(conditionPath, draft),
+        kind: 'branch',
+        path,
+        whenFalse: join,
+        whenTrue: statement.kind === 'do' ? header : body,
+    });
+    draft.currentSteps.push({ header, kind: 'loop', path });
+    addCompilerAsyncStateMachineState(draft);
+    // The two forms differ only in where the condition sits. `while` tests before the body, so the
+    // header is the test and the body is its own arm; `do` runs the body first, so the header is the
+    // body and the test is its tail.
+    draft.currentIdentity = header;
+    draft.currentSteps = [];
+    draft.terminal = false;
+    if (statement.kind === 'while') {
+        draft.currentSteps.push(branch());
+        addCompilerAsyncStateMachineState(draft);
+        draft.currentIdentity = body;
+        draft.currentSteps = [];
+    }
+    draft.loops.push({
+        breakTarget: join,
+        continueTarget: header,
+        ...(statement.label ? { label: statement.label.id } : {}),
+    });
+    const refusal = createIrStatementArmAsyncStateMachine(scope, statement.body, [...path, 'body'], suspensions, draft);
+    draft.loops.pop();
+    if (refusal)
+        return refusal;
+    if (!draft.terminal) {
+        if (statement.kind === 'do')
+            draft.currentSteps.push(branch());
+        else
+            draft.currentSteps.push({ kind: 'goto', path: [...path, 'body'], target: header });
+    }
+    addCompilerAsyncStateMachineState(draft);
+    draft.currentIdentity = join;
+    draft.currentSteps = [];
+    // Either form may reach its exit, so the statement after the loop is always reachable.
+    draft.terminal = false;
+    return undefined;
+}
+function createIrTryStatementAsyncStateMachine(scope, statement, path, suspensions, draft, 
+// Where the guarded body lives in the source. It is the try body's own path except when two regions
+// share one statement, where the inner region's body is the same node the outer region guards.
+bodyPath = [...path, 'tryBody'], 
+// Likewise for the handler: the inner region's `catch` is the same source node the outer statement
+// declares, not a nested one.
+sourceHandlerPath) {
+    const catchClause = statement.catchClause;
+    const finallyBody = statement.finallyBody;
+    if (catchClause && finallyBody) {
+        // The cleanup owes every route out of the handled region, including the handler's own. That is
+        // exactly `try { try A catch H } finally F`, so it is built as two regions rather than as a third
+        // route through one. The inner region is keyed on the try body's path, so their state identities
+        // cannot collide.
+        return createIrTryStatementAsyncStateMachine(scope, { finallyBody, kind: 'try', tryBody: { kind: 'try', catchClause, tryBody: statement.tryBody } }, path, suspensions, draft, [...path, 'tryBody'], [...path, 'finallyBody']);
+    }
+    if (!catchClause && !finallyBody) {
+        return createCompilerAsyncStateMachineRefusal('unsupported-control-flow', path, scope.path);
+    }
+    const handlerPath = sourceHandlerPath ?? (catchClause ? [...path, 'catchClause', 'body'] : [...path, 'finallyBody']);
+    const body = { arm: 'whenTrue', kind: 'branchArm', path };
+    const handler = { kind: 'catch', path };
+    const cleanup = { arm: 'whenFalse', kind: 'branchArm', path };
+    const join = { kind: 'join', path };
+    // The carrier is addressed by the try statement's own path, which is unique within the module and
+    // stable across runs, so two cleanups in one function never share one.
+    const carrier = finallyBody
+        ? {
+            ...draft.moduleOrigin,
+            id: `binding:${JSON.stringify([draft.moduleOrigin.packageName, draft.moduleOrigin.source, path, 'cleanup-value'])}`,
+            kind: 'variable',
+            name: 'cleanupValue',
+            scope: 'block',
+            space: 'value',
+        }
+        : undefined;
+    // The guard step belongs to the state that opens the region, and that state is not itself guarded:
+    // its own throws happen before the handler is in scope.
+    draft.currentSteps.push({
+        body,
+        ...(carrier ? { carrier } : {}),
+        catchState: handler,
+        join,
+        kind: 'guard',
+        path,
+    });
+    addCompilerAsyncStateMachineState(draft);
+    draft.guards.push({
+        ...(catchClause?.binding ? { catchBinding: catchClause.binding } : {}),
+        catchState: handler,
+        ...(finallyBody ? { rethrow: true } : {}),
+    });
+    if (carrier)
+        draft.cleanups.push({ carrier, target: cleanup });
+    draft.currentIdentity = body;
+    draft.currentSteps = [];
+    draft.terminal = false;
+    const tryRefusal = statement.tryBody.kind === 'try'
+        ? createIrTryStatementAsyncStateMachine(scope, statement.tryBody, bodyPath, suspensions, draft, bodyPath, [
+            ...path,
+            'catchClause',
+            'body',
+        ])
+        : createIrStatementArmAsyncStateMachine(scope, statement.tryBody, bodyPath, suspensions, draft);
+    if (tryRefusal)
+        return tryRefusal;
+    const bodyTerminal = draft.terminal;
+    if (!bodyTerminal) {
+        draft.currentSteps.push({ kind: 'goto', path: bodyPath, target: finallyBody ? cleanup : join });
+    }
+    addCompilerAsyncStateMachineState(draft);
+    draft.guards.pop();
+    if (carrier)
+        draft.cleanups.pop();
+    if (finallyBody) {
+        // A route that leaves the body normally still owes the cleanup, so the cleanup is reached twice:
+        // once here, and once from the rejection route that ends by re-raising.
+        draft.currentIdentity = cleanup;
+        draft.currentSteps = [];
+        draft.terminal = false;
+        const normalRefusal = createIrStatementArmAsyncStateMachine(scope, finallyBody, handlerPath, [], draft);
+        if (normalRefusal)
+            return normalRefusal;
+        if (draft.terminal) {
+            return createCompilerAsyncStateMachineRefusal('unsupported-control-flow', handlerPath, scope.path);
+        }
+        if (bodyTerminal && carrier) {
+            // The body left through a route that owed the cleanup, so the cleanup performs its settlement
+            // from the value the route carried here.
+            const value = { binding: carrier, kind: 'carried' };
+            draft.currentSteps.push({ kind: 'resolve', path: handlerPath, value });
+            draft.completionPaths.push({ kind: 'return', path: handlerPath, value });
+            draft.terminal = true;
+        }
+        else {
+            draft.currentSteps.push({ kind: 'goto', path: handlerPath, target: join });
+        }
+        addCompilerAsyncStateMachineState(draft);
+    }
+    draft.currentIdentity = handler;
+    draft.currentSteps = [];
+    draft.terminal = false;
+    const handlerRefusal = createIrStatementArmAsyncStateMachine(scope, catchClause ? catchClause.body : finallyBody, handlerPath, catchClause ? suspensions : [], draft);
+    if (handlerRefusal)
+        return handlerRefusal;
+    if (!draft.terminal && catchClause)
+        draft.currentSteps.push({ kind: 'goto', path: handlerPath, target: join });
+    addCompilerAsyncStateMachineState(draft);
+    draft.currentIdentity = join;
+    draft.currentSteps = [];
+    draft.terminal = false;
+    return undefined;
+}
+function createIrStatementArmAsyncStateMachine(scope, statement, path, suspensions, draft) {
+    const armSuspensions = suspensions.filter((suspension) => isCompilerAsyncStateMachinePathWithin(suspension.path, path));
+    if (statement.kind === 'block' && !statement.label) {
+        return createIrStatementListAsyncStateMachine(scope, statement.statements, [...path, 'statements'], armSuspensions, draft);
+    }
+    if (armSuspensions.length === 0 && statement.kind === 'return') {
+        const value = statement.expression
+            ? createCompilerAsyncStateMachineExpressionValue([...path, 'expression'], 'result')
+            : { kind: 'implicitUndefined' };
+        const cleanup = draft.cleanups.at(-1);
+        if (cleanup) {
+            draft.currentSteps.push({ binding: cleanup.carrier, kind: 'carry', path, value });
+            draft.currentSteps.push({ kind: 'goto', path, target: cleanup.target });
+        }
+        else {
+            draft.currentSteps.push({
+                ...(statement.expression
+                    ? { evaluationRejection: addCompilerAsyncStateMachineAbruptCompletion([...path, 'expression'], draft) }
+                    : {}),
+                kind: 'resolve',
+                path,
+                value,
+            });
+            draft.completionPaths.push({ kind: 'return', path, value });
+        }
+        draft.terminal = true;
+        return undefined;
+    }
+    if (armSuspensions.length === 0 && statement.kind === 'throw') {
+        const value = createCompilerAsyncStateMachineExpressionValue([...path, 'expression'], 'result');
+        draft.currentSteps.push({
+            evaluationRejection: addCompilerAsyncStateMachineAbruptCompletion([...path, 'expression'], draft),
+            kind: 'reject',
+            path,
+            value,
+        });
+        draft.completionPaths.push({ kind: 'throw', path, value });
+        draft.terminal = true;
+        return undefined;
+    }
+    if (armSuspensions.length === 0 && (statement.kind === 'break' || statement.kind === 'continue')) {
+        const target = statement.target;
+        const loop = target
+            ? [...draft.loops].reverse().find((candidate) => candidate.label === target.id)
+            : draft.loops.at(-1);
+        if (!loop)
+            return createCompilerAsyncStateMachineRefusal('escaping-control-flow', path, scope.path);
+        draft.currentSteps.push({
+            kind: 'goto',
+            path,
+            target: statement.kind === 'break' ? loop.breakTarget : loop.continueTarget,
+        });
+        draft.terminal = true;
+        return undefined;
+    }
+    if (armSuspensions.length > 0) {
+        return createIrStatementSuspensionAsyncStateMachine(scope, statement, path, armSuspensions, draft);
+    }
+    // An else-if remains a structured branch even when every suspension happened before it. It still
+    // owns return/throw completion routes, so walk it with the branch state builder instead of asking
+    // the opaque-step path to pretend those exits are local to one execute step.
+    if (statement.kind === 'if') {
+        return createIrStatementSuspensionAsyncStateMachine(scope, statement, path, [], draft);
+    }
+    if (!isIrStatementAsyncStateMachineOpaque(statement)) {
+        return createCompilerAsyncStateMachineRefusal('unsupported-control-flow', path, scope.path);
+    }
+    addCompilerAsyncStateMachineExecuteStep(statement, path, draft);
+    return undefined;
+}
+function createIrStatementSuspensionAsyncStateMachine(scope, statement, path, suspensions, draft) {
+    if (statement.kind === 'block') {
+        // A block introduces no control flow of its own, so a suspension inside one needs no new state
+        // shape — only the statement list walked at the block's own path. A labelled block is refused,
+        // because its label is a `break` target and the machine does not model one yet.
+        if (statement.label) {
+            return createCompilerAsyncStateMachineRefusal('unsupported-control-flow', path, scope.path);
+        }
+        return createIrStatementListAsyncStateMachine(scope, statement.statements, [...path, 'statements'], suspensions, draft);
+    }
+    if (statement.kind === 'if') {
+        return createIrIfStatementAsyncStateMachine(scope, statement, path, suspensions, draft);
+    }
+    if (statement.kind === 'try') {
+        return createIrTryStatementAsyncStateMachine(scope, statement, path, suspensions, draft);
+    }
+    if (statement.kind === 'do' || statement.kind === 'while') {
+        return createIrLoopStatementAsyncStateMachine(scope, statement, path, suspensions, draft);
+    }
+    if (suspensions.length !== 1) {
+        return createCompilerAsyncStateMachineRefusal('unsupported-suspension-expression', path, scope.path);
+    }
+    const suspension = suspensions[0];
+    if (statement.kind === 'return' && statement.expression?.kind === 'await') {
+        const awaitPath = [...path, 'expression'];
+        const value = createCompilerAsyncStateMachineExpressionValue(awaitPath, 'result');
+        const cleanup = draft.cleanups.at(-1);
+        if (cleanup) {
+            // The cleanup owes this route too, so the settled value is carried through it rather than
+            // resolving the task the moment the suspension fulfills.
+            addCompilerAsyncStateMachineSuspension(awaitPath, { binding: cleanup.carrier, kind: 'rebind' }, false, draft);
+            draft.currentSteps.push({ kind: 'goto', path, target: cleanup.target });
+            draft.terminal = true;
+            return undefined;
+        }
+        addCompilerAsyncStateMachineSuspension(awaitPath, { kind: 'resolve', value }, true, draft);
+        draft.completionPaths.push({ kind: 'return', path, value });
+        return undefined;
+    }
+    if (statement.kind === 'expression') {
+        if (statement.expression.kind === 'await') {
+            const awaitPath = [...path, 'expression'];
+            addCompilerAsyncStateMachineSuspension(awaitPath, { kind: 'discard' }, false, draft);
+            return undefined;
+        }
+        if (statement.expression.kind === 'assignment' &&
+            statement.expression.operator === '=' &&
+            statement.expression.left.kind === 'identifier' &&
+            statement.expression.left.reference.kind === 'binding' &&
+            statement.expression.right.kind === 'await') {
+            const awaitPath = [...path, 'expression', 'right'];
+            addCompilerAsyncStateMachineSuspension(awaitPath, { binding: statement.expression.left.reference.binding, kind: 'rebind' }, false, draft);
+            return undefined;
+        }
+    }
+    if (statement.kind === 'variable' && statement.declarations.length === 1) {
+        const variable = statement.declarations[0];
+        if (!('binding' in variable) || variable.initializer?.kind !== 'await') {
+            return createCompilerAsyncStateMachineRefusal('unsupported-suspension-expression', suspension.path, scope.path);
+        }
+        const awaitPath = [...path, 'declarations', 0, 'initializer'];
+        addCompilerAsyncStateMachineSuspension(awaitPath, { binding: variable.binding, kind: 'initializeBinding' }, false, draft);
+        return undefined;
+    }
+    return createCompilerAsyncStateMachineRefusal('unsupported-suspension-expression', suspension.path, scope.path);
+}
+function freezeCompilerAsyncStateMachineValue(value, seen) {
+    if (!value || typeof value !== 'object' || seen.has(value))
+        return;
+    seen.add(value);
+    for (const child of Object.values(value))
+        freezeCompilerAsyncStateMachineValue(child, seen);
+    Object.freeze(value);
+}
+function getCompilerAsyncStateMachinePathIdentity(path) {
+    return JSON.stringify(path);
+}
+function getCompilerAsyncStateMachineBoundaryPath(path, boundaries) {
+    let nearest;
+    for (const boundary of boundaries) {
+        if (isCompilerAsyncStateMachinePathWithin(path, boundary) && (!nearest || boundary.length > nearest.length)) {
+            nearest = boundary;
+        }
+    }
+    return nearest;
+}
+function getIrModuleAsyncStateMachineBodies(module) {
+    const bodies = new Map();
+    analyzeIrModuleTraversal(module, {
+        declaration(declaration, path) {
+            if (declaration.kind === 'function' && declaration.async) {
+                bodies.set(getCompilerAsyncStateMachinePathIdentity(path), { statements: declaration.body });
+            }
+            if (declaration.kind === 'class') {
+                declaration.methods.forEach((method, index) => {
+                    if (method.async) {
+                        bodies.set(getCompilerAsyncStateMachinePathIdentity([...path, 'methods', index]), {
+                            statements: method.body,
+                        });
+                    }
+                });
+            }
+        },
+        expression(expression, path) {
+            if (expression.kind === 'function' && expression.async) {
+                bodies.set(getCompilerAsyncStateMachinePathIdentity(path), {
+                    ...(expression.expression ? { expression: expression.expression } : {}),
+                    statements: expression.body,
+                });
+            }
+        },
+    });
+    return bodies;
+}
+function getIrStatementAsyncStateMachineAbruptPaths(statement, path) {
+    if (statement.kind === 'expression')
+        return [[...path, 'expression']];
+    if (statement.kind === 'variable') {
+        return statement.declarations.flatMap((variable, index) => variable.initializer ? [[...path, 'declarations', index, 'initializer']] : []);
+    }
+    // A compound statement executed as one step can reject from anywhere inside it. The statement is
+    // the finest address available without re-walking it, and re-walking would claim a precision the
+    // step does not have: the whole statement either runs to completion or rejects.
+    return [path];
+}
+// A statement that never suspends can run inside one state, but only if control cannot leave it by a
+// route the machine has to represent. `return` must become a resolve, and `break` or `continue` name
+// a loop target outside the statement, so any of the three refuses. `throw` does not: the execute
+// step already registers the statement as an abrupt completion path, so a rejection from anywhere
+// inside it settles the task the same way an inline throwing expression does.
+function isIrStatementAsyncStateMachineOpaque(statement) {
+    return getIrStatementListCompletionSet([statement]).completions.every((completion) => completion.kind === 'normal' || completion.kind === 'throw');
+}
+function isCompilerAsyncStateMachinePathEqual(left, right) {
+    return left.length === right.length && left.every((segment, index) => segment === right[index]);
+}
+function isCompilerAsyncStateMachinePathWithin(path, ancestor) {
+    return ancestor.length <= path.length && ancestor.every((segment, index) => segment === path[index]);
+}
+//# sourceMappingURL=compilerAsyncStateMachine.js.map