alchemy 2.0.0-beta.2 → 2.0.0-beta.21

package/lib/Apply.js

@@ -0,0 +1,764 @@
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Artifacts, ArtifactStore, createArtifactStore, ensureArtifactStore, makeScopedArtifacts, } from "./Artifacts.js";
+import { Cli, } from "./Cli/Cli.js";
+import { havePropsChanged } from "./Diff.js";
+import { toFqn } from "./FQN.js";
+import { generateInstanceId, InstanceId } from "./InstanceId.js";
+import * as Output from "./Output.js";
+import {} from "./Plan.js";
+import { findProviderByType } from "./Provider.js";
+import { Stack } from "./Stack.js";
+import { Stage } from "./Stage.js";
+import { recordResourceOp } from "./Telemetry/Metrics.js";
+import { State, StateStoreError, } from "./State/index.js";
+const provideLifecycleScope = (fqn, instanceId) => (effect) => Effect.serviceOption(ArtifactStore).pipe(Effect.map(Option.getOrElse(createArtifactStore)), Effect.flatMap((store) => effect.pipe(Effect.provideService(Artifacts, makeScopedArtifacts(store, fqn)), Effect.provideService(InstanceId, instanceId))));
+/**
+ * Instruments a single provider lifecycle call with an OTel span
+ * (`provider.<op>`), the resource counter / duration histogram, and the
+ * scoped artifacts/instance services normally supplied by
+ * {@link provideLifecycleScope}.
+ *
+ * This is the only call site through which provider lifecycle methods
+ * are dispatched, so wrapping it here gives us a fully-instrumented
+ * toolchain without touching any individual provider implementation.
+ */
+const instrumentLifecycle = (op, fqn, resourceType, logicalId, instanceId) => (effect) => effect.pipe(provideLifecycleScope(fqn, instanceId), recordResourceOp(resourceType, op), Effect.withSpan(`provider.${op}`, {
+    attributes: {
+        "alchemy.resource.fqn": fqn,
+        "alchemy.resource.type": resourceType,
+        "alchemy.resource.logical_id": logicalId,
+        "alchemy.resource.instance_id": instanceId,
+        "alchemy.resource.op": op,
+    },
+}));
+export const apply = (plan) => Effect.gen(function* () {
+    const cli = yield* Cli;
+    const session = yield* cli.startApplySession(plan);
+    const state = yield* State;
+    const stack = yield* Stack;
+    const stage = yield* Stage;
+    const stackName = stack.name;
+    const tracker = {};
+    const terminalStatuses = new Map();
+    yield* executePlan(plan, tracker, terminalStatuses, session, state, stackName, stage);
+    // TODO(sam): support roll back to previous state if errors occur during expansion
+    // -> RISK: some UPDATEs may not be reversible (i.e. trigger replacements)
+    // TODO(sam): should pivot be done separately? E.g shift traffic?
+    yield* collectGarbage(plan, session);
+    yield* converge(plan, tracker, terminalStatuses, session, state, stackName, stage);
+    yield* Effect.forEach(Array.from(terminalStatuses.values()), ({ id, type, status }) => session.emit({ kind: "status-change", id, type, status }), { concurrency: "unbounded" });
+    yield* session.done();
+    if (!plan.output) {
+        return undefined;
+    }
+    const outputs = Object.fromEntries(Object.entries(tracker).map(([fqn, t]) => [fqn, t.output]));
+    return yield* Output.evaluate(plan.output, outputs);
+}).pipe(ensureArtifactStore, Effect.withSpan("apply", {
+    attributes: {
+        "alchemy.resources.count": Object.keys(plan.resources).length,
+        "alchemy.deletions.count": Object.keys(plan.deletions).length,
+    },
+}));
+// ── Phase 1: concurrent initial execution ──────────────────────────────────
+//
+// Each resource gets a Deferred<void> that signals "I have some output
+// available in `tracker`." Resources with `precreate` signal early so that
+// downstream resources can resolve stable identifiers without deadlocking.
+// The actual output lives in the mutable `tracker` map, not in the Deferred.
+const executePlan = Effect.fnUntraced(function* (plan, tracker, terminalStatuses, session, state, stackName, stage) {
+    const ready = Object.fromEntries(yield* Effect.all(Object.keys(plan.resources).map((fqn) => Effect.map(Deferred.make(), (d) => [fqn, d]))));
+    const getOutputs = () => Object.fromEntries(Object.entries(tracker).map(([fqn, t]) => [fqn, t.output]));
+    const waitForDeps = (fqns) => Effect.all(fqns
+        .filter((fqn) => fqn in ready)
+        .map((fqn) => Deferred.await(ready[fqn])), { concurrency: "unbounded" });
+    yield* Effect.all(Object.entries(plan.resources).map(([fqn, node]) => executeNode(fqn, node, tracker, ready, terminalStatuses, session, state, stackName, stage, getOutputs, waitForDeps)), { concurrency: "unbounded" });
+});
+const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state, stackName, stage, getOutputs, waitForDeps) => Effect.gen(function* () {
+    const logicalId = node.resource.LogicalId;
+    const namespace = node.resource.Namespace;
+    const commit = (value) => state.set({
+        stack: stackName,
+        stage,
+        fqn,
+        value: { ...value, namespace },
+    });
+    const scopedSession = {
+        ...session,
+        note: (note) => session.emit({ id: logicalId, kind: "annotate", message: note }),
+    };
+    const report = (status) => session.emit({
+        kind: "status-change",
+        id: logicalId,
+        type: node.resource.Type,
+        status,
+    });
+    const markTerminal = (status) => Effect.sync(() => {
+        terminalStatuses.set(fqn, {
+            id: logicalId,
+            type: node.resource.Type,
+            status,
+        });
+    });
+    const signalReady = Deferred.succeed(ready[fqn], void 0);
+    const storeAndSignal = (t) => Effect.gen(function* () {
+        tracker[fqn] = t;
+        yield* signalReady;
+    });
+    // ── noop ──
+    if (node.action === "noop") {
+        yield* storeAndSignal({
+            output: node.state.attr,
+            props: node.state.props,
+            bindings: node.state.bindings ?? [],
+            instanceId: node.state.instanceId,
+        });
+        return;
+    }
+    const allUpstreamFqns = () => {
+        const propDeps = Object.keys(Output.resolveUpstream(node.props));
+        const bindingDeps = Object.keys(Output.resolveUpstream(node.bindings));
+        return [...new Set([...propDeps, ...bindingDeps])];
+    };
+    // ── instance ID ──
+    const instanceId = yield* Effect.gen(function* () {
+        if (node.action === "create" && !node.state?.instanceId) {
+            const id = yield* generateInstanceId();
+            yield* commit({
+                status: "creating",
+                fqn,
+                logicalId,
+                instanceId: id,
+                downstream: node.downstream,
+                props: node.props,
+                providerVersion: node.provider.version ?? 0,
+                resourceType: node.resource.Type,
+                bindings: excludeDeletedBindings(node.bindings),
+                removalPolicy: node.resource.RemovalPolicy,
+            });
+            return id;
+        }
+        else if (node.action === "replace") {
+            if ((node.state.status === "replaced" ||
+                node.state.status === "replacing") &&
+                !node.restart) {
+                // Ordinary replacement recovery keeps using the same replacement
+                // generation. Only `restart` is allowed to mint a new instance id.
+                return node.state.instanceId;
+            }
+            const id = yield* generateInstanceId();
+            yield* commit({
+                status: "replacing",
+                fqn,
+                logicalId,
+                instanceId: id,
+                downstream: node.downstream,
+                props: node.props,
+                providerVersion: node.provider.version ?? 0,
+                resourceType: node.resource.Type,
+                bindings: excludeDeletedBindings(node.bindings),
+                old: node.state,
+                deleteFirst: node.deleteFirst,
+                removalPolicy: node.resource.RemovalPolicy,
+            });
+            return id;
+        }
+        else if (node.state?.instanceId) {
+            return node.state.instanceId;
+        }
+        return yield* Effect.die(`Instance ID not found for resource '${logicalId}' and action is '${node.action}'`);
+    });
+    // ── lifecycle ──
+    yield* Effect.gen(function* () {
+        // ── create ──
+        if (node.action === "create") {
+            if (!node.state) {
+                // First persistence point for a brand new logical resource. Once this is
+                // written, retries know they should resume creation instead of planning
+                // another fresh create from scratch.
+                yield* commit({
+                    status: "creating",
+                    fqn,
+                    logicalId,
+                    instanceId,
+                    resourceType: node.resource.Type,
+                    props: node.props,
+                    attr: undefined,
+                    providerVersion: node.provider.version ?? 0,
+                    bindings: excludeDeletedBindings(node.bindings),
+                    downstream: node.downstream,
+                    removalPolicy: node.resource.RemovalPolicy,
+                });
+            }
+            let attr = node.state?.attr;
+            if (attr !== undefined) {
+                // Precreate/read may already have produced a usable output snapshot. Publish
+                // it early so downstream resources can start resolving against it.
+                yield* storeAndSignal({
+                    output: attr,
+                    props: {},
+                    bindings: [],
+                    instanceId,
+                });
+            }
+            if (node.provider.precreate && attr === undefined) {
+                // Some resources need a placeholder physical resource before their real
+                // create can finish. Persist that stub so downstream evaluation can proceed.
+                yield* report("pre-creating");
+                attr = yield* node.provider
+                    .precreate({
+                    id: logicalId,
+                    news: node.props,
+                    session: scopedSession,
+                    instanceId,
+                    bindings: excludeDeletedBindings(node.bindings),
+                })
+                    .pipe(instrumentLifecycle("precreate", fqn, node.resource.Type, logicalId, instanceId));
+                yield* commit({
+                    status: "creating",
+                    fqn,
+                    logicalId,
+                    instanceId,
+                    resourceType: node.resource.Type,
+                    props: node.props,
+                    attr,
+                    providerVersion: node.provider.version ?? 0,
+                    bindings: excludeDeletedBindings(node.bindings),
+                    downstream: node.downstream,
+                    removalPolicy: node.resource.RemovalPolicy,
+                });
+                yield* storeAndSignal({
+                    output: attr,
+                    props: {},
+                    bindings: [],
+                    instanceId,
+                });
+            }
+            yield* report("creating");
+            // Create runs against fully resolved upstream outputs and bindings, not the
+            // raw Output expressions stored in the plan.
+            yield* waitForDeps(allUpstreamFqns());
+            const outputs = getOutputs();
+            const news = (yield* Output.evaluate(node.props, outputs));
+            const bindingOutputs = excludeDeletedBindings(yield* Output.evaluate(node.bindings, outputs));
+            attr = yield* node.provider
+                .create({
+                id: logicalId,
+                news,
+                instanceId,
+                bindings: bindingOutputs,
+                session: scopedSession,
+                output: attr,
+            })
+                .pipe(instrumentLifecycle("create", fqn, node.resource.Type, logicalId, instanceId));
+            yield* commit({
+                status: "created",
+                fqn,
+                logicalId,
+                instanceId,
+                resourceType: node.resource.Type,
+                props: news,
+                attr,
+                bindings: excludeDeletedBindings(node.bindings),
+                providerVersion: node.provider.version ?? 0,
+                downstream: node.downstream,
+                removalPolicy: node.resource.RemovalPolicy,
+            });
+            tracker[fqn] = {
+                output: attr,
+                props: news,
+                bindings: bindingOutputs,
+                instanceId,
+            };
+            yield* signalReady;
+            yield* markTerminal("created");
+            return;
+        }
+        // ── update ──
+        if (node.action === "update") {
+            // Updates always begin by exposing the currently live output so downstream
+            // resources can continue to resolve references during the update pass.
+            yield* storeAndSignal({
+                output: node.state.attr,
+                props: node.state.props,
+                bindings: node.state.bindings ?? [],
+                instanceId,
+            });
+            yield* waitForDeps(allUpstreamFqns());
+            const outputs = getOutputs();
+            const news = (yield* Output.evaluate(node.props, outputs));
+            yield* node.state.status === "replaced"
+                ? commit({
+                    // Keep the replacement wrapper intact while changing the live
+                    // replacement props; GC still has older generations to delete.
+                    ...node.state,
+                    attr: node.state.attr,
+                    props: news,
+                })
+                : commit({
+                    // For ordinary updates we snapshot the previously stable props/attrs
+                    // once, so retries can continue from the same baseline.
+                    status: "updating",
+                    fqn,
+                    logicalId,
+                    instanceId,
+                    resourceType: node.resource.Type,
+                    props: news,
+                    attr: node.state.attr,
+                    providerVersion: node.provider.version ?? 0,
+                    bindings: excludeDeletedBindings(node.bindings),
+                    downstream: node.downstream,
+                    old: node.state.status === "updating" ? node.state.old : node.state,
+                    removalPolicy: node.resource.RemovalPolicy,
+                });
+            yield* report("updating");
+            const previousProps = node.state.status === "created" ||
+                node.state.status === "updated" ||
+                node.state.status === "replaced"
+                ? node.state.props
+                : node.state.old.props;
+            // Providers receive the resolved binding payload for this exact pass, while
+            // `previousProps` tells them what state the live resource is being updated from.
+            const bindingOutputs = excludeDeletedBindings(yield* Output.evaluate(node.bindings, outputs));
+            const attr = yield* node.provider
+                .update({
+                id: logicalId,
+                news,
+                instanceId,
+                bindings: bindingOutputs,
+                session: scopedSession,
+                olds: previousProps,
+                // @ts-expect-error - type system says this can be undefined, can it be?
+                output: node.state.attr,
+            })
+                .pipe(instrumentLifecycle("update", fqn, node.resource.Type, logicalId, instanceId));
+            if (node.state.status === "replaced") {
+                yield* commit({
+                    // The live replacement changed, but cleanup of older generations still
+                    // has to continue afterwards.
+                    ...node.state,
+                    attr,
+                    props: news,
+                });
+            }
+            else {
+                yield* commit({
+                    status: "updated",
+                    fqn,
+                    logicalId,
+                    instanceId,
+                    resourceType: node.resource.Type,
+                    props: news,
+                    attr,
+                    bindings: excludeDeletedBindings(node.bindings),
+                    providerVersion: node.provider.version ?? 0,
+                    downstream: node.downstream,
+                    removalPolicy: node.resource.RemovalPolicy,
+                });
+            }
+            tracker[fqn] = {
+                output: attr,
+                props: news,
+                bindings: bindingOutputs,
+                instanceId,
+            };
+            yield* markTerminal("updated");
+            return;
+        }
+        // ── replace ──
+        if (node.action === "replace") {
+            if (node.state.status === "replaced" && !node.restart) {
+                // The replacement already exists; this pass only needs GC to clean up
+                // older generations, so expose the current replacement and stop here.
+                tracker[fqn] = {
+                    output: node.state.attr,
+                    props: node.state.props,
+                    bindings: node.state.bindings ?? [],
+                    instanceId,
+                };
+                yield* signalReady;
+                yield* markTerminal("created");
+                return;
+            }
+            let replState;
+            if (node.state.status !== "replacing" || node.restart) {
+                // `restart` deliberately nests the previous top-level replacement state
+                // into `old`, creating a new outer generation to replace it.
+                replState = yield* commit({
+                    status: "replacing",
+                    fqn,
+                    logicalId,
+                    instanceId,
+                    resourceType: node.resource.Type,
+                    props: node.props,
+                    bindings: excludeDeletedBindings(node.bindings),
+                    attr: undefined,
+                    providerVersion: node.provider.version ?? 0,
+                    deleteFirst: node.deleteFirst,
+                    old: node.state,
+                    downstream: node.downstream,
+                    removalPolicy: node.resource.RemovalPolicy,
+                });
+            }
+            else {
+                // Resume the same replacement generation after an interrupted apply.
+                replState = node.state;
+            }
+            let attr = replState.attr;
+            if (attr !== undefined) {
+                // If precreate already ran, expose that intermediate output immediately so
+                // downstream resources can resolve against the same in-flight replacement.
+                yield* storeAndSignal({
+                    output: attr,
+                    props: {},
+                    bindings: [],
+                    instanceId,
+                });
+            }
+            if (node.provider.precreate && attr === undefined) {
+                yield* report("pre-creating");
+                attr = yield* node.provider
+                    .precreate({
+                    id: logicalId,
+                    news: node.props,
+                    session: scopedSession,
+                    instanceId,
+                    bindings: excludeDeletedBindings(node.bindings),
+                })
+                    .pipe(instrumentLifecycle("precreate", fqn, node.resource.Type, logicalId, instanceId));
+                yield* commit({
+                    status: "replacing",
+                    fqn,
+                    logicalId,
+                    instanceId,
+                    resourceType: node.resource.Type,
+                    props: node.props,
+                    attr,
+                    providerVersion: node.provider.version ?? 0,
+                    bindings: excludeDeletedBindings(node.bindings),
+                    downstream: node.downstream,
+                    old: replState.old,
+                    deleteFirst: node.deleteFirst,
+                    removalPolicy: node.resource.RemovalPolicy,
+                });
+                yield* storeAndSignal({
+                    output: attr,
+                    props: {},
+                    bindings: [],
+                    instanceId,
+                });
+            }
+            yield* report("creating replacement");
+            // Replacement create is evaluated exactly like create, but against the new
+            // generation's instance id and with the previous generations preserved in `old`.
+            yield* waitForDeps(allUpstreamFqns());
+            const outputs = getOutputs();
+            const news = (yield* Output.evaluate(node.props, outputs));
+            const bindingOutputs = excludeDeletedBindings(yield* Output.evaluate(node.bindings, outputs));
+            attr = yield* node.provider
+                .create({
+                id: logicalId,
+                news,
+                instanceId,
+                bindings: bindingOutputs,
+                session: scopedSession,
+                output: attr,
+            })
+                .pipe(instrumentLifecycle("create", fqn, node.resource.Type, logicalId, instanceId));
+            yield* commit({
+                // Creation of the new generation succeeded; from here on the only remaining
+                // work is draining the old chain via garbage collection.
+                status: "replaced",
+                fqn,
+                logicalId,
+                instanceId,
+                resourceType: node.resource.Type,
+                props: news,
+                attr,
+                providerVersion: node.provider.version ?? 0,
+                bindings: excludeDeletedBindings(node.bindings),
+                downstream: node.downstream,
+                // Preserve the remaining backlog exactly as-is. GC is responsible for
+                // popping one generation at a time until the chain is exhausted.
+                old: replState.old,
+                deleteFirst: node.deleteFirst,
+                removalPolicy: node.resource.RemovalPolicy,
+            });
+            tracker[fqn] = {
+                output: attr,
+                props: news,
+                bindings: bindingOutputs,
+                instanceId,
+            };
+            yield* signalReady;
+            // Keep progress anchored to the live replacement while GC drains the
+            // previous generation(s) in the background.
+            yield* markTerminal("created");
+            return;
+        }
+        // @ts-expect-error - node is never, this should be unreachable
+        return yield* Effect.die(`Unknown action: ${node.action}`);
+    });
+}).pipe(Effect.withSpan("apply.resource", {
+    attributes: {
+        "alchemy.resource.fqn": fqn,
+        "alchemy.resource.type": node.resource.Type,
+        "alchemy.resource.logical_id": node.resource.LogicalId,
+        "alchemy.resource.action": node.action,
+    },
+}));
+// ── Phase 3: imperative convergence loop ───────────────────────────────────
+//
+// After the initial concurrent pass, some resources may have been created
+// with stale upstream values (e.g. a precreate stub instead of the final
+// output). Walk the plan and re-evaluate each resource's props/bindings
+// against the current tracker outputs. Call provider.update for any
+// resource whose resolved inputs differ from what it was last applied with.
+// Repeat until no resource needs updating.
+const converge = Effect.fnUntraced(function* (plan, tracker, terminalStatuses, session, state, stackName, stage) {
+    for (;;) {
+        let anyUpdated = false;
+        for (const [fqn, node] of Object.entries(plan.resources)) {
+            if (node.action === "noop")
+                continue;
+            if (!tracker[fqn])
+                continue;
+            const outputs = Object.fromEntries(Object.entries(tracker).map(([k, t]) => [k, t.output]));
+            const newProps = (yield* Output.evaluate(node.props, outputs));
+            const newBindings = excludeDeletedBindings(yield* Output.evaluate(node.bindings, outputs));
+            const oldProps = tracker[fqn].props;
+            const oldBindings = tracker[fqn].bindings;
+            const propsChanged = havePropsChanged(oldProps, newProps);
+            const bindingsChanged = JSON.stringify(oldBindings) !== JSON.stringify(newBindings);
+            if (!propsChanged && !bindingsChanged)
+                continue;
+            anyUpdated = true;
+            const logicalId = node.resource.LogicalId;
+            const namespace = node.resource.Namespace;
+            const instanceId = tracker[fqn].instanceId;
+            const scopedSession = {
+                ...session,
+                note: (note) => session.emit({ id: logicalId, kind: "annotate", message: note }),
+            };
+            const attr = yield* node.provider
+                .update({
+                id: logicalId,
+                news: newProps,
+                instanceId,
+                bindings: newBindings,
+                session: scopedSession,
+                olds: oldProps,
+                output: tracker[fqn].output,
+            })
+                .pipe(instrumentLifecycle("update", fqn, node.resource.Type, logicalId, instanceId));
+            tracker[fqn] = {
+                output: attr,
+                props: newProps,
+                bindings: newBindings,
+                instanceId,
+            };
+            yield* state.set({
+                stack: stackName,
+                stage,
+                fqn,
+                value: {
+                    status: "updated",
+                    fqn,
+                    logicalId,
+                    instanceId,
+                    resourceType: node.resource.Type,
+                    props: newProps,
+                    attr,
+                    providerVersion: node.provider.version ?? 0,
+                    bindings: excludeDeletedBindings(node.bindings),
+                    downstream: node.downstream,
+                    namespace,
+                    removalPolicy: node.resource.RemovalPolicy,
+                },
+            });
+            terminalStatuses.set(fqn, {
+                id: logicalId,
+                type: node.resource.Type,
+                status: "updated",
+            });
+        }
+        if (!anyUpdated)
+            break;
+    }
+});
+// ── Phase 2: delete orphans and old replaced resources ─────────────────────
+const collectGarbage = Effect.fnUntraced(function* (plan, session) {
+    const state = yield* State;
+    const stack = yield* Stack;
+    const stackName = stack.name;
+    const stage = yield* Stage;
+    const deleteGraph = Effect.fnUntraced(function* (deletionGraph) {
+        const deletions = {};
+        const deleteResource = (node, ancestors = new Set()) => Effect.gen(function* () {
+            const isDeleteNode = (node) => "action" in node;
+            const { logicalId, namespace, resourceType, instanceId, downstream, props, attr, provider, } = isDeleteNode(node)
+                ? {
+                    logicalId: node.resource.LogicalId,
+                    namespace: node.resource.Namespace,
+                    resourceType: node.resource.Type,
+                    instanceId: node.state.instanceId,
+                    downstream: node.downstream,
+                    props: node.state.props,
+                    attr: node.state.attr,
+                    provider: node.provider,
+                }
+                : {
+                    logicalId: node.logicalId,
+                    namespace: node.namespace,
+                    resourceType: node.old.resourceType,
+                    instanceId: node.old.instanceId,
+                    downstream: node.old.downstream,
+                    props: node.old.props,
+                    attr: node.old.attr,
+                    provider: yield* findProviderByType(node.old.resourceType),
+                };
+            const fqn = toFqn(namespace, logicalId);
+            const nextAncestors = new Set(ancestors).add(fqn);
+            const commit = (value) => state.set({
+                stack: stackName,
+                stage,
+                fqn,
+                value: { ...value, namespace },
+            });
+            const report = (status) => session.emit({
+                kind: "status-change",
+                id: logicalId,
+                type: resourceType,
+                status,
+            });
+            const scopedSession = {
+                ...session,
+                note: (note) => session.emit({
+                    id: logicalId,
+                    kind: "annotate",
+                    message: note,
+                }),
+            };
+            return yield* (deletions[fqn] ??= yield* Effect.cached(Effect.gen(function* () {
+                yield* Effect.all(downstream.map((dep) => dep !== fqn && dep in deletionGraph && !ancestors.has(dep)
+                    ? deleteResource(deletionGraph[dep], nextAncestors)
+                    : Effect.void), { concurrency: "unbounded" });
+                if (isDeleteNode(node)) {
+                    yield* report("deleting");
+                    if (node.resource.RemovalPolicy === "retain") {
+                        yield* state.delete({
+                            stack: stackName,
+                            stage,
+                            fqn,
+                        });
+                        yield* report("deleted");
+                        return;
+                    }
+                    yield* commit({
+                        status: "deleting",
+                        fqn,
+                        logicalId,
+                        instanceId,
+                        resourceType,
+                        props,
+                        attr,
+                        downstream,
+                        providerVersion: provider.version ?? 0,
+                        bindings: excludeDeletedBindings(node.bindings),
+                        removalPolicy: node.resource.RemovalPolicy,
+                    });
+                }
+                if (attr !== undefined) {
+                    yield* provider
+                        .delete({
+                        id: logicalId,
+                        instanceId,
+                        olds: props,
+                        output: attr,
+                        session: scopedSession,
+                        bindings: [],
+                    })
+                        .pipe(instrumentLifecycle("delete", fqn, resourceType, logicalId, instanceId));
+                }
+                if (isDeleteNode(node)) {
+                    yield* state.delete({
+                        stack: stackName,
+                        stage,
+                        fqn,
+                    });
+                    yield* report("deleted");
+                }
+                else {
+                    yield* scopedSession.note("Cleaning up replaced resource...");
+                    if (node.old.status === "replacing" ||
+                        node.old.status === "replaced") {
+                        // We only deleted the outermost old generation. A nested replacement
+                        // chain still exists, so stay in `replaced` and pop the chain forward
+                        // one level. The outer loop will pick this resource up again.
+                        yield* commit({
+                            status: "replaced",
+                            fqn,
+                            logicalId: node.logicalId,
+                            instanceId: node.instanceId,
+                            resourceType: node.resourceType,
+                            props: node.props,
+                            attr: node.attr,
+                            providerVersion: node.providerVersion,
+                            downstream: node.downstream,
+                            bindings: excludeDeletedBindings(node.bindings),
+                            old: node.old.old,
+                            deleteFirst: node.deleteFirst,
+                            removalPolicy: node.removalPolicy,
+                        });
+                    }
+                    else {
+                        // The old chain is fully drained, so the current replacement is now
+                        // the stable resource and we can collapse back to a terminal state.
+                        yield* commit({
+                            status: "created",
+                            fqn,
+                            logicalId: node.logicalId,
+                            instanceId: node.instanceId,
+                            resourceType: node.resourceType,
+                            props: node.props,
+                            attr: node.attr,
+                            providerVersion: node.providerVersion,
+                            downstream: node.downstream,
+                            bindings: excludeDeletedBindings(node.bindings),
+                            removalPolicy: node.removalPolicy,
+                        });
+                    }
+                    yield* scopedSession.note("Replaced resource cleanup complete.");
+                }
+            })));
+        });
+        yield* Effect.all(Object.values(deletionGraph)
+            .filter((node) => node !== undefined)
+            .map((node) => deleteResource(node)), { concurrency: "unbounded" });
+    });
+    // The first pass handles both planned deletions and any top-level replaced
+    // resources already present in state. Later passes only drain replacement
+    // chains that were re-committed as `replaced` while deleting older generations.
+    let first = true;
+    while (true) {
+        const remainingReplacedResources = yield* state.getReplacedResources({
+            stack: stackName,
+            stage,
+        });
+        if (!first && remainingReplacedResources.length === 0) {
+            break;
+        }
+        yield* deleteGraph({
+            // Orphan/resource deletions from the current plan should only run once.
+            ...(first ? plan.deletions : {}),
+            ...Object.fromEntries(remainingReplacedResources.map((replaced) => [
+                toFqn(replaced.namespace, replaced.logicalId),
+                replaced,
+            ])),
+        });
+        first = false;
+    }
+});
+const excludeDeletedBindings = (bindings) => bindings.flatMap(({ action, sid, data }) => action === "delete" ? [] : [{ sid, data }]);
+//# sourceMappingURL=Apply.js.map