alchemy-effect 0.3.0 → 0.4.0

package/bin/alchemy-effect.js

@@ -14042,7 +14042,7 @@ const asEffect = (effect) => Effect.isEffect(effect) ? effect : Effect.succeed(e
 
 //#endregion
 //#region package.json
-var version = "0.3.0";
+var version = "0.4.0";
 
 //#endregion
 //#region src/resource.ts
@@ -14064,10 +14064,17 @@ const localFs = Layer.effect(State, Effect.gen(function* () {
 	const stage$1 = ({ stack, stage: stage$2 }) => path$3.join(stateDir, stack, stage$2);
 	const resource = ({ stack, stage: stage$2, resourceId }) => path$3.join(stateDir, stack, stage$2, `${resourceId}.json`);
 	const ensure = yield* Effect.cachedFunction((dir) => fs$1.makeDirectory(dir, { recursive: true }));
-	return {
-		listApps: () => fs$1.readDirectory(stateDir).pipe(recover, Effect.map((files) => files ?? [])),
+	const state = {
+		listStacks: () => fs$1.readDirectory(stateDir).pipe(recover, Effect.map((files) => files ?? [])),
 		listStages: (stack) => fs$1.readDirectory(path$3.join(stateDir, stack)).pipe(recover, Effect.map((files) => files ?? [])),
 		get: (request) => fs$1.readFile(resource(request)).pipe(Effect.map((file$5) => JSON.parse(file$5.toString())), recover),
+		getReplacedResources: Effect.fnUntraced(function* (request) {
+			return (yield* Effect.all((yield* state.list(request)).map((resourceId) => state.get({
+				stack: request.stack,
+				stage: request.stage,
+				resourceId
+			})))).filter((r) => r?.status === "replaced");
+		}),
 		set: (request) => ensure(stage$1(request)).pipe(Effect.flatMap(() => fs$1.writeFileString(resource(request), JSON.stringify(request.value, (k, v) => {
 			if (isResource(v)) return {
 				id: v.id,
@@ -14080,6 +14087,7 @@ const localFs = Layer.effect(State, Effect.gen(function* () {
 		delete: (request) => fs$1.remove(resource(request)).pipe(recover),
 		list: (request) => fs$1.readDirectory(stage$1(request)).pipe(recover, Effect.map((files) => files?.map((file$5) => file$5.replace(/\.json$/, "")) ?? []))
 	};
+	return state;
 }));
 
 //#endregion
@@ -14088,6 +14096,21 @@ var App$1 = class extends Context.Tag("App")() {};
 const app = (input) => Layer.succeed(App$1, App$1.of(input));
 const make = app;
 
+//#endregion
+//#region src/cli/service.ts
+var CLI = class extends Context.Tag("CLIService")() {};
+
+//#endregion
+//#region src/instance-id.ts
+/**
+* @returns Hex-encoded instance ID (16 random bytes)
+*/
+const generateInstanceId = () => Effect.sync(() => {
+	const bytes = new Uint8Array(16);
+	crypto.getRandomValues(bytes);
+	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+});
+
 //#endregion
 //#region src/data.ts
 const isPrimitive = (value) => value === void 0 || value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string" || typeof value === "symbol" || typeof value === "bigint";
@@ -14106,7 +14129,6 @@ const proxy = (self$1) => {
 				if (self$1.identifier === "apply") return new ApplyExpr(self$1.expr, args[0]);
 				else if (self$1.identifier === "effect") return new EffectExpr(self$1.expr, args[0]);
 			}
-			throw new Error("Not callable");
 		}
 	});
 	return proxy$1;
@@ -14201,11 +14223,18 @@ const evaluate = (expr, upstream$1) => Effect.gen(function* () {
 			stage: stage$1,
 			resourceId: expr.resourceId
 		}));
-		return resource.output;
+		return resource.attr;
 	} else if (Array.isArray(expr)) return yield* Effect.all(expr.map((item) => evaluate(item, upstream$1)));
 	else if (typeof expr === "object" && expr !== null) return Object.fromEntries(yield* Effect.all(Object.entries(expr).map(([key, value]) => evaluate(value, upstream$1).pipe(Effect.map((value$1) => [key, value$1])))));
 	return expr;
 });
+const hasOutputs = (value) => Object.keys(upstreamAny(value)).length > 0;
+const upstreamAny = (value) => {
+	if (isExpr(value)) return upstream(value);
+	else if (Array.isArray(value)) return Object.assign({}, ...value.map(resolveUpstream));
+	else if (value && (typeof value === "object" || typeof value === "function")) return Object.assign({}, ...Object.values(value).map((value$1) => resolveUpstream(value$1)));
+	return {};
+};
 const upstream = (expr) => _upstream(expr);
 const _upstream = (expr) => {
 	if (isResourceExpr(expr)) return { [expr.src.id]: expr.src };
@@ -14228,6 +14257,14 @@ const resolveUpstream = (value) => {
 	return {};
 };
 
+//#endregion
+//#region src/provider.ts
+const getProviderByType = Effect.fnUntraced(function* (resourceType) {
+	const provider = (yield* Effect.context()).unsafeMap.get(resourceType);
+	if (!provider) return yield* Effect.die(/* @__PURE__ */ new Error(`Provider not found for ${resourceType}`));
+	return provider;
+});
+
 //#endregion
 //#region src/service.ts
 const isService = (resource) => {
@@ -14236,30 +14273,29 @@ const isService = (resource) => {
 
 //#endregion
 //#region src/plan.ts
-const Node$1 = (node) => ({
-	...node,
-	toString() {
-		return `${this.action.charAt(0).toUpperCase()}${this.action.slice(1)}(${this.resource})`;
-	},
-	[Symbol.toStringTag]() {
-		return this.toString();
-	}
-});
-const plan = (...resources) => Effect.gen(function* () {
+const plan = (..._resources) => Effect.gen(function* () {
 	const state = yield* State;
+	const findResources = (resource, visited) => {
+		if (visited.has(resource.id)) return [];
+		visited.add(resource.id);
+		const upstream$1 = Object.values(upstreamAny(resource.props));
+		return [
+			resource,
+			...upstream$1,
+			...upstream$1.flatMap((r) => findResources(r, visited))
+		];
+	};
+	const resources = _resources.flatMap((r) => findResources(r, /* @__PURE__ */ new Set())).filter((r, i, arr) => arr.findIndex((r2) => r2.id === r.id) === i);
 	const app$1 = yield* App$1;
 	const resourceIds = yield* state.list({
 		stack: app$1.name,
 		stage: app$1.stage
 	});
-	const downstream = (yield* Effect.all(resourceIds.map((id) => state.get({
+	const oldResources = yield* Effect.all(resourceIds.map((id) => state.get({
 		stack: app$1.name,
 		stage: app$1.stage,
 		resourceId: id
-	})))).filter((resource) => !!resource?.bindings).flatMap((resource) => resource.bindings.flatMap(({ binding }) => [[binding.capability.resource.id, binding.capability.resource]])).reduce((acc, [id, resourceId]) => ({
-		...acc,
-		[id]: [...acc[id] ?? [], resourceId]
-	}), {});
+	})));
 	const resolvedResources = {};
 	const resolveResource = (resourceExpr) => Effect.gen(function* () {
 		return yield* resolvedResources[resourceExpr.src.id] ??= yield* Effect.cached(Effect.gen(function* () {
@@ -14271,21 +14307,23 @@ const plan = (...resources) => Effect.gen(function* () {
 				stage: app$1.stage,
 				resourceId: resource.id
 			});
-			if (!oldState) return resourceExpr;
+			if (!oldState || oldState.status === "creating") return resourceExpr;
+			const oldProps = oldState.status === "created" || oldState.status === "updated" || oldState.status === "replaced" ? oldState.props : oldState.status === "updating" || oldState.status === "replacing" ? oldState.old.props : oldState.props;
 			const diff$1 = yield* provider.diff ? provider.diff({
 				id: resource.id,
-				olds: oldState.props,
+				olds: oldProps,
+				instanceId: oldState.instanceId,
 				news: props,
-				output: oldState.output
+				output: oldState.attr
 			}) : Effect.succeed(void 0);
+			const stables = [...provider.stables ?? [], ...diff$1?.stables ?? []];
+			const withStables = (output) => stables.length > 0 ? new ResourceExpr(resourceExpr.src, Object.fromEntries(stables.map((stable) => [stable, output?.[stable]]))) : resourceExpr;
 			if (diff$1 == null) {
-				if (arePropsChanged(oldState, props)) return resourceExpr;
-			} else if (diff$1.action === "update") {
-				const output = oldState?.output;
-				if (diff$1.stables) return new ResourceExpr(resourceExpr.src, Object.fromEntries(diff$1.stables.map((stable) => [stable, output?.[stable]])));
-				else return resourceExpr;
-			} else if (diff$1.action === "replace") {}
-			return oldState?.output;
+				if (arePropsChanged(oldProps, props)) return withStables(oldState?.attr);
+			} else if (diff$1.action === "update") return withStables(oldState?.attr);
+			else if (diff$1.action === "replace") return resourceExpr;
+			if (oldState.status === "created" || oldState.status === "updated" || oldState.status === "replaced") return oldState?.attr;
+			else return resourceExpr;
 		}));
 	});
 	const resolveInput = (input) => Effect.gen(function* () {
@@ -14300,22 +14338,19 @@ const plan = (...resources) => Effect.gen(function* () {
 		else if (isPropExpr(expr)) return (yield* resolveOutput(expr.expr))?.[expr.identifier];
 		else if (isApplyExpr(expr)) {
 			const upstream$1 = yield* resolveOutput(expr.expr);
-			return isOutput(upstream$1) ? expr : expr.f(upstream$1);
+			return hasOutputs(upstream$1) ? expr : expr.f(upstream$1);
 		} else if (isEffectExpr(expr)) {
 			const upstream$1 = yield* resolveOutput(expr.expr);
-			return isOutput(upstream$1) ? expr : yield* expr.f(upstream$1);
+			return hasOutputs(upstream$1) ? expr : yield* expr.f(upstream$1);
 		} else if (isAllExpr(expr)) return yield* Effect.all(expr.outs.map(resolveOutput));
 		return yield* Effect.die(/* @__PURE__ */ new Error("Not implemented yet"));
 	});
-	const resolveUpstream$1 = (value) => {
-		if (isExpr(value)) return upstream(value);
-		else if (Array.isArray(value)) return Object.assign({}, ...value.map(resolveUpstream$1));
-		else if (value && (typeof value === "object" || typeof value === "function")) return Object.assign({}, ...Object.values(value).map((value$1) => resolveUpstream$1(value$1)));
-		return {};
-	};
+	const oldDownstreamDependencies = Object.fromEntries(oldResources.filter((resource) => !!resource).map((resource) => [resource.logicalId, resource.downstream]));
+	const newUpstreamDependencies = Object.fromEntries(resources.map((resource) => [resource.id, [...Object.values(upstreamAny(resource.props)).map((r) => r.id), ...isService(resource) ? resource.props.bindings.capabilities.map((cap) => cap.resource.id) : []]]));
+	const newDownstreamDependencies = Object.fromEntries(resources.map((resource) => [resource.id, Object.entries(newUpstreamDependencies).filter(([_, downstream]) => downstream.includes(resource.id)).map(([id]) => id)]));
 	const resourceGraph = Object.fromEntries((yield* Effect.all(resources.flatMap((resource) => [
 		...isService(resource) ? resource.props.bindings.capabilities.map((cap) => cap.resource) : [],
-		...Object.values(resolveUpstream$1(resource.props)),
+		...Object.values(upstreamAny(resource.props)),
 		resource
 	]).filter((node, i, arr) => arr.findIndex((n) => n.id === node.id) === i).map(Effect.fn(function* (node) {
 		const id = node.id;
@@ -14327,68 +14362,113 @@ const plan = (...resources) => Effect.gen(function* () {
 			resourceId: id
 		});
 		const provider = yield* resource.provider.tag;
+		const downstream = newDownstreamDependencies[id] ?? [];
 		const bindings = isService(node) ? yield* diffBindings({
 			oldState,
 			bindings: node.props.bindings.bindings,
 			target: {
 				id: node.id,
 				props: node.props,
-				oldAttr: oldState?.output,
+				oldAttr: oldState?.attr,
 				oldProps: oldState?.props
 			}
 		}) : [];
-		if (oldState === void 0 || oldState.status === "creating") return Node$1({
-			action: "create",
-			news,
+		const Node$1 = (node$1) => ({
+			...node$1,
 			provider,
 			resource,
 			bindings,
-			attributes: void 0
+			downstream
 		});
-		const diff$1 = provider.diff ? yield* (() => {
-			const diff$2 = provider.diff({
-				id,
-				olds: oldState.props,
-				news,
-				output: oldState.output
-			});
-			return Effect.isEffect(diff$2) ? diff$2 : Effect.succeed(diff$2);
-		})() : void 0;
-		if (!diff$1 && arePropsChanged(oldState, news)) return Node$1({
+		if (oldState === void 0) return Node$1({
+			action: "create",
+			props: news,
+			state: oldState
+		});
+		const oldProps = oldState.props;
+		const diff$1 = yield* asEffect(provider.diff ? provider.diff({
+			id,
+			olds: oldProps,
+			instanceId: oldState.instanceId,
+			output: oldState.attr,
+			news
+		}) : void 0).pipe(Effect.map((diff$2) => diff$2 ?? { action: arePropsChanged(oldProps, news) ? "update" : "noop" }));
+		if (oldState.status === "creating") if (diff$1.action === "noop") return Node$1({
+			action: "create",
+			props: news,
+			state: oldState
+		});
+		else if (diff$1.action === "update") return Node$1({
+			action: "create",
+			props: news,
+			state: oldState
+		});
+		else return Node$1({
+			action: "replace",
+			props: news,
+			deleteFirst: diff$1.deleteFirst ?? false,
+			state: oldState
+		});
+		else if (oldState.status === "updating") if (diff$1.action === "update" || diff$1.action === "noop") return Node$1({
 			action: "update",
-			olds: oldState.props,
-			news,
-			output: oldState.output,
-			provider,
-			resource,
-			bindings,
-			attributes: void 0
+			props: news,
+			state: oldState
 		});
-		else if (diff$1?.action === "replace") return Node$1({
+		else return Node$1({
 			action: "replace",
-			olds: oldState.props,
-			news,
-			output: oldState.output,
-			provider,
-			resource,
-			bindings,
-			attributes: void 0
+			deleteFirst: diff$1.deleteFirst ?? false,
+			props: news,
+			state: oldState
+		});
+		else if (oldState.status === "replacing") if (diff$1.action === "noop") return Node$1({
+			action: "replace",
+			deleteFirst: oldState.deleteFirst,
+			props: news,
+			state: oldState
 		});
-		else if (diff$1?.action === "update") return Node$1({
+		else if (diff$1.action === "update") return Node$1({
+			action: "replace",
+			deleteFirst: oldState.deleteFirst,
+			props: news,
+			state: oldState
+		});
+		else return yield* Effect.fail(new CannotReplacePartiallyReplacedResource(id));
+		else if (oldState.status === "replaced") if (diff$1.action === "noop") return Node$1({
+			action: "replace",
+			deleteFirst: oldState.deleteFirst,
+			props: news,
+			state: oldState
+		});
+		else if (diff$1.action === "update") return Node$1({
 			action: "update",
-			olds: oldState.props,
-			news,
-			output: oldState.output,
-			provider,
-			resource,
-			bindings,
-			attributes: void 0
+			props: news,
+			state: oldState
+		});
+		else return yield* Effect.fail(new CannotReplacePartiallyReplacedResource(id));
+		else if (oldState.status === "deleting") if (diff$1.action === "noop" || diff$1.action === "update") return Node$1({
+			action: "create",
+			props: news,
+			state: {
+				...oldState,
+				status: "creating",
+				props: news
+			}
+		});
+		else return yield* Effect.fail(new CannotReplacePartiallyReplacedResource(id));
+		else if (diff$1.action === "update") return Node$1({
+			action: "update",
+			props: news,
+			state: oldState
+		});
+		else if (diff$1.action === "replace") return Node$1({
+			action: "replace",
+			props: news,
+			state: oldState,
+			deleteFirst: diff$1?.deleteFirst ?? false
 		});
 		else return Node$1({
 			action: "noop",
-			resource,
-			bindings,
-			attributes: void 0
+			state: oldState
 		});
 	})))).map((update) => [update.resource.id, update]));
 	const deletions = Object.fromEntries((yield* Effect.all((yield* state.list({
@@ -14401,29 +14481,22 @@ const plan = (...resources) => Effect.gen(function* () {
 			stage: app$1.stage,
 			resourceId: id
 		});
-		const context = yield* Effect.context();
-		if (oldState) {
-			const provider = context.unsafeMap.get(oldState?.type);
-			if (!provider) yield* Effect.die(/* @__PURE__ */ new Error(`Provider not found for ${oldState?.type}`));
-			return [id, {
-				action: "delete",
-				olds: oldState.props,
-				output: oldState.output,
-				provider,
-				attributes: oldState?.output,
-				bindings: [],
-				resource: {
-					id,
-					type: oldState.type,
-					attr: oldState.output,
-					props: oldState.props
-				},
-				downstream: downstream[id] ?? []
-			}];
-		}
+		if (oldState) return [id, {
+			action: "delete",
+			state: oldState,
+			bindings: [],
+			provider: yield* getProviderByType(oldState.resourceType),
+			resource: {
+				id,
+				type: oldState.resourceType,
+				attr: oldState.attr,
+				props: oldState.props
+			},
+			downstream: oldDownstreamDependencies[id] ?? []
+		}];
 	})))).filter((v) => !!v));
 	for (const [resourceId, deletion] of Object.entries(deletions)) {
-		const dependencies = deletion.downstream.filter((d) => d in resourceGraph);
+		const dependencies = deletion.state.downstream.filter((d) => d in resourceGraph);
 		if (dependencies.length > 0) return yield* Effect.fail(new DeleteResourceHasDownstreamDependencies({
 			message: `Resource ${resourceId} has downstream dependencies`,
 			resourceId,
@@ -14435,13 +14508,20 @@ const plan = (...resources) => Effect.gen(function* () {
 		deletions
 	};
 });
+var CannotReplacePartiallyReplacedResource = class extends Data.TaggedError("CannotReplacePartiallyReplacedResource") {
+	constructor(logicalId) {
+		super({
+			message: `Resource '${logicalId}' did not finish being replaced in a previous deployment and is expected to be replaced again in this deployment. You should revert its properties and try again after a successful deployment.`,
+			logicalId
+		});
+	}
+};
 var DeleteResourceHasDownstreamDependencies = class extends Data.TaggedError("DeleteResourceHasDownstreamDependencies") {};
-const arePropsChanged = (oldState, newProps) => {
-	return JSON.stringify(omit(oldState?.props ?? {}, "bindings")) !== JSON.stringify(omit(newProps ?? {}, "bindings"));
+const arePropsChanged = (oldProps, newProps) => {
+	return hasOutputs(newProps) || JSON.stringify(omit(oldProps ?? {}, "bindings")) !== JSON.stringify(omit(newProps ?? {}, "bindings"));
 };
 const diffBindings = Effect.fn(function* ({ oldState, bindings, target }) {
 	const oldBindings = oldState?.bindings;
-	new Set(oldBindings?.map(({ binding }) => binding.capability.sid));
 	const diffBinding = Effect.fn(function* (binding) {
 		const cap = binding.capability;
 		const sid = cap.sid ?? `${cap.action}:${cap.resource.ID}`;
@@ -14484,7 +14564,7 @@ const isBindingDiff = Effect.fn(function* ({ target, oldBinding: { binding: oldB
 				id: oldCap.resource.id,
 				props: newCap.resource.props,
 				oldProps: oldState?.props,
-				oldAttr: oldState?.output
+				oldAttr: oldState?.attr
 			},
 			props: newBinding.props,
 			attr: oldBinding.attr,
@@ -14495,18 +14575,20 @@ const isBindingDiff = Effect.fn(function* ({ target, oldBinding: { binding: oldB
 	return { action: oldBinding.capability.action !== newBinding.capability.action || oldBinding.capability?.resource?.id !== newBinding.capability?.resource?.id ? "update" : "noop" };
 });
 
-//#endregion
-//#region src/cli/service.ts
-var CLI = class extends Context.Tag("CLIService")() {};
-
 //#endregion
 //#region src/apply.ts
 const applyPlan = (plan$1) => Effect.gen(function* () {
+	const session = yield* (yield* CLI).startApplySession(plan$1);
+	const resources = yield* expandAndPivot(plan$1, session);
+	yield* collectGarbage(plan$1, session);
+	yield* session.done();
+	if (Object.keys(plan$1.resources).length === 0) return;
+	return resources;
+});
+const expandAndPivot = Effect.fnUntraced(function* (plan$1, session) {
 	const state = yield* State;
 	const app$1 = yield* App$1;
 	const outputs = {};
-	const session = yield* (yield* CLI).startApplySession(plan$1);
-	const { emit: emit$1, done } = session;
 	const resolveUpstream$1 = Effect.fn(function* (resourceId) {
 		const upstreamNode = plan$1.resources[resourceId];
 		return {
@@ -14574,19 +14656,12 @@ const applyPlan = (plan$1) => Effect.gen(function* () {
 		return oldBindingOutput;
 	})));
 	const apply = (node) => Effect.gen(function* () {
-		const saveState = ({ output, bindings = node.bindings, news }) => state.set({
+		const commit = (value) => state.set({
 			stack: app$1.name,
 			stage: app$1.stage,
 			resourceId: node.resource.id,
-			value: {
-				id: node.resource.id,
-				type: node.resource.type,
-				status: node.action === "create" ? "created" : "updated",
-				props: news,
-				output,
-				bindings
-			}
-		}).pipe(Effect.map(() => output));
+			value
+		});
 		const id = node.resource.id;
 		const resource = node.resource;
 		const scopedSession = {
@@ -14598,38 +14673,95 @@ const applyPlan = (plan$1) => Effect.gen(function* () {
 			})
 		};
 		return yield* outputs[id] ??= yield* Effect.cached(Effect.gen(function* () {
-			const report = (status) => emit$1({
+			const report = (status) => session.emit({
 				kind: "status-change",
 				id,
 				type: node.resource.type,
 				status
 			});
-			const createOrUpdate = Effect.fn(function* ({ node: node$1, attr, phase }) {
-				const upstream$1 = Object.fromEntries(yield* Effect.all(Object.entries(resolveUpstream(node$1.news)).map(([id$1]) => resolveUpstream$1(id$1).pipe(Effect.map(({ upstreamAttr }) => [id$1, upstreamAttr])))));
-				const news = yield* evaluate(node$1.news, upstream$1);
-				yield* report(phase === "create" ? "creating" : "updating");
+			if (node.action === "noop") return node.state.attr;
+			const upstream$1 = Object.fromEntries(yield* Effect.all(Object.entries(resolveUpstream(node.props)).map(([id$1]) => resolveUpstream$1(id$1).pipe(Effect.map(({ upstreamAttr }) => [id$1, upstreamAttr])))));
+			const instanceId = yield* Effect.gen(function* () {
+				if (node.action === "create" && !node.state?.instanceId) {
+					const instanceId$1 = yield* generateInstanceId();
+					yield* commit({
+						status: "creating",
+						instanceId: instanceId$1,
+						logicalId: id,
+						downstream: node.downstream,
+						props: node.props,
+						providerVersion: node.provider.version ?? 0,
+						resourceType: node.resource.type,
+						bindings: node.bindings
+					});
+					return instanceId$1;
+				} else if (node.action === "replace") {
+					if (node.state.status === "replaced" || node.state.status === "replacing") return node.state.instanceId;
+					const instanceId$1 = yield* generateInstanceId();
+					yield* commit({
+						status: "replacing",
+						instanceId: instanceId$1,
+						logicalId: id,
+						downstream: node.downstream,
+						props: node.props,
+						providerVersion: node.provider.version ?? 0,
+						resourceType: node.resource.type,
+						bindings: node.bindings,
+						old: node.state,
+						deleteFirst: node.deleteFirst
+					});
+					return instanceId$1;
+				} else if (node.state?.instanceId) return node.state.instanceId;
+				return yield* Effect.dieMessage(`Instance ID not found for resource '${id}' and action is '${node.action}'`);
+			});
+			if (node.action === "create") {
+				const news = yield* evaluate(node.props, upstream$1);
+				const checkpoint = (attr$1) => commit({
+					status: "creating",
+					logicalId: id,
+					instanceId,
+					resourceType: node.resource.type,
+					props: news,
+					attr: attr$1,
+					providerVersion: node.provider.version ?? 0,
+					bindings: node.bindings,
+					downstream: node.downstream
+				});
+				if (!node.state) yield* checkpoint(void 0);
+				let attr;
+				if (node.action === "create" && node.provider.precreate && node.state?.attr === void 0) {
+					yield* report("pre-creating");
+					attr = yield* node.provider.precreate({
+						id,
+						news: node.props,
+						session: scopedSession,
+						instanceId
+					});
+					yield* checkpoint(attr);
+				}
+				yield* report("attaching");
 				let bindingOutputs = yield* attachBindings({
 					resource,
-					bindings: node$1.bindings,
+					bindings: node.bindings,
 					target: {
 						id,
 						props: news,
 						attr
 					}
 				});
-				const output = yield* (phase === "create" ? node$1.provider.create : node$1.provider.update)({
+				yield* report("creating");
+				attr = yield* node.provider.create({
 					id,
 					news,
+					instanceId,
 					bindings: bindingOutputs,
-					session: scopedSession,
-					...node$1.action === "update" ? {
-						output: node$1.output,
-						olds: node$1.olds
-					} : {}
-				}).pipe(Effect.tap(() => report(phase === "create" ? "created" : "updated")));
+					session: scopedSession
+				});
+				yield* checkpoint(attr);
+				yield* report("post-attach");
 				bindingOutputs = yield* postAttachBindings({
 					resource,
-					bindings: node$1.bindings,
+					bindings: node.bindings,
 					bindingOutputs,
 					target: {
 						id,
@@ -14637,107 +14769,291 @@ const applyPlan = (plan$1) => Effect.gen(function* () {
 						attr
 					}
 				});
-				yield* saveState({
-					news,
-					output,
-					bindings: node$1.bindings.map((binding, i) => ({
+				yield* commit({
+					status: "created",
+					logicalId: id,
+					instanceId,
+					resourceType: node.resource.type,
+					props: news,
+					attr,
+					bindings: node.bindings.map((binding, i) => ({
 						...binding,
 						attr: bindingOutputs[i]
-					}))
-				});
-				return output;
-			});
-			if (node.action === "noop") return (yield* state.get({
-				stack: app$1.name,
-				stage: app$1.stage,
-				resourceId: id
-			}))?.output;
-			else if (node.action === "create") {
-				let attr;
-				if (node.provider.precreate) {
-					yield* Effect.logDebug("precreate", id);
-					attr = yield* node.provider.precreate({
-						id,
-						news: node.news,
-						session: scopedSession
-					});
-				}
-				yield* Effect.logDebug("create", id);
-				return yield* createOrUpdate({
-					node,
-					attr,
-					phase: "create"
+					})),
+					providerVersion: node.provider.version ?? 0,
+					downstream: node.downstream
 				});
+				yield* report("created");
+				return attr;
 			} else if (node.action === "update") {
-				yield* Effect.logDebug("update", id);
-				return yield* createOrUpdate({
-					node,
-					attr: node.attributes,
-					phase: "update"
+				const upstream$2 = Object.fromEntries(yield* Effect.all(Object.entries(resolveUpstream(node.props)).map(([id$1]) => resolveUpstream$1(id$1).pipe(Effect.map(({ upstreamAttr }) => [id$1, upstreamAttr])))));
+				const news = yield* evaluate(node.props, upstream$2);
+				const checkpoint = (attr$1) => {
+					if (node.state.status === "replaced") return commit({
+						...node.state,
+						attr: attr$1,
+						props: news
+					});
+					else return commit({
+						status: "updating",
+						logicalId: id,
+						instanceId,
+						resourceType: node.resource.type,
+						props: news,
+						attr: attr$1,
+						providerVersion: node.provider.version ?? 0,
+						bindings: node.bindings,
+						downstream: node.downstream,
+						old: node.state.status === "updating" ? node.state.old : node.state
+					});
+				};
+				yield* checkpoint(node.state.attr);
+				yield* report("attaching");
+				let bindingOutputs = yield* attachBindings({
+					resource,
+					bindings: node.bindings,
+					target: {
+						id,
+						props: news,
+						attr: node.state.attr
+					}
 				});
-			} else if (node.action === "delete") {
-				yield* Effect.logDebug("delete", id);
-				yield* Effect.all(node.downstream.map((dep) => dep in plan$1.resources ? apply(plan$1.resources[dep]) : Effect.void));
-				yield* report("deleting");
-				return yield* node.provider.delete({
+				yield* report("updating");
+				const attr = yield* node.provider.update({
 					id,
-					olds: node.olds,
-					output: node.output,
+					news,
+					instanceId,
+					bindings: bindingOutputs,
 					session: scopedSession,
-					bindings: []
-				}).pipe(Effect.flatMap(() => state.delete({
-					stack: app$1.name,
-					stage: app$1.stage,
-					resourceId: id
-				})), Effect.tap(() => report("deleted")));
+					olds: node.state.status === "created" || node.state.status === "updated" || node.state.status === "replaced" ? node.state.props : node.state.old.props,
+					output: node.state.attr
+				});
+				yield* checkpoint(attr);
+				yield* report("post-attach");
+				bindingOutputs = yield* postAttachBindings({
+					resource,
+					bindings: node.bindings,
+					bindingOutputs,
+					target: {
+						id,
+						props: news,
+						attr
+					}
+				});
+				if (node.state.status === "replaced") yield* commit({
+					...node.state,
+					attr,
+					props: news
+				});
+				else yield* commit({
+					status: "updated",
+					logicalId: id,
+					instanceId,
+					resourceType: node.resource.type,
+					props: news,
+					attr,
+					bindings: node.bindings.map((binding, i) => ({
+						...binding,
+						attr: bindingOutputs[i]
+					})),
+					providerVersion: node.provider.version ?? 0,
+					downstream: node.downstream
+				});
+				yield* report("updated");
+				return attr;
 			} else if (node.action === "replace") {
-				const destroy = Effect.gen(function* () {
-					yield* report("deleting");
-					return yield* node.provider.delete({
+				if (node.state.status === "replaced") return node.state.attr;
+				let state$1;
+				if (node.state.status !== "replacing") yield* commit(state$1 = {
+					status: "replacing",
+					logicalId: id,
+					instanceId,
+					resourceType: node.resource.type,
+					props: node.props,
+					attr: node.state.attr,
+					providerVersion: node.provider.version ?? 0,
+					deleteFirst: node.deleteFirst,
+					old: node.state,
+					downstream: node.downstream
+				});
+				else state$1 = node.state;
+				const upstream$2 = Object.fromEntries(yield* Effect.all(Object.entries(resolveUpstream(node.props)).map(([id$1]) => resolveUpstream$1(id$1).pipe(Effect.map(({ upstreamAttr }) => [id$1, upstreamAttr])))));
+				const news = yield* evaluate(node.props, upstream$2);
+				const checkpoint = ({ status, attr: attr$1, bindings }) => commit({
+					status,
+					logicalId: id,
+					instanceId,
+					resourceType: node.resource.type,
+					props: news,
+					attr: attr$1,
+					providerVersion: node.provider.version ?? 0,
+					bindings: bindings ?? node.bindings,
+					downstream: node.downstream,
+					old: state$1.old,
+					deleteFirst: node.deleteFirst
+				});
+				let attr;
+				if (node.provider.precreate && node.state?.attr === void 0) {
+					yield* report("pre-creating");
+					attr = yield* node.provider.precreate({
 						id,
-						olds: node.olds,
-						output: node.output,
+						news: node.props,
 						session: scopedSession,
-						bindings: []
+						instanceId
 					});
+					yield* checkpoint({
+						status: "replacing",
+						attr
+					});
+				}
+				yield* report("attaching");
+				let bindingOutputs = yield* attachBindings({
+					resource,
+					bindings: node.bindings,
+					target: {
+						id,
+						props: news,
+						attr
+					}
+				});
+				yield* report("creating replacement");
+				attr = yield* node.provider.create({
+					id,
+					news,
+					instanceId,
+					bindings: bindingOutputs,
+					session: scopedSession
+				});
+				yield* checkpoint({
+					status: "replacing",
+					attr
 				});
-				const create$1 = Effect.gen(function* () {
-					yield* report("creating");
-					return yield* node.provider.create({
+				yield* report("post-attach");
+				bindingOutputs = yield* postAttachBindings({
+					resource,
+					bindings: node.bindings,
+					bindingOutputs,
+					target: {
 						id,
-						news: node.news,
-						bindings: yield* attachBindings({
-							resource,
-							bindings: node.bindings,
-							target: {
-								id,
-								props: node.news,
-								attr: node.attributes
-							}
-						}),
-						session: scopedSession
-					}).pipe(Effect.tap((output) => saveState({
-						news: node.news,
-						output
-					})));
+						props: news,
+						attr
+					}
 				});
-				if (!node.deleteFirst) {
-					yield* destroy;
-					return outputs;
-				} else {
-					yield* destroy;
-					return yield* create$1;
-				}
+				yield* checkpoint({
+					status: "replaced",
+					attr,
+					bindings: node.bindings.map((binding, i) => ({
+						...binding,
+						attr: bindingOutputs[i]
+					}))
+				});
+				yield* report("created");
+				return attr;
 			}
+			return yield* Effect.dieMessage(`Unknown action: ${node.action}`);
 		}));
 	});
-	const nodes = [...Object.entries(plan$1.resources), ...Object.entries(plan$1.deletions)];
-	const resources = Object.fromEntries(yield* Effect.all(nodes.map(Effect.fn(function* ([id, node]) {
+	return Object.fromEntries(yield* Effect.all(Object.entries(plan$1.resources).map(Effect.fn(function* ([id, node]) {
 		return [id, yield* apply(node)];
 	}))));
-	yield* done();
-	if (Object.keys(plan$1.resources).length === 0) return;
-	return resources;
+});
+const collectGarbage = Effect.fnUntraced(function* (plan$1, session) {
+	const state = yield* State;
+	const app$1 = yield* App$1;
+	const deletions = {};
+	const replacedResources = yield* state.getReplacedResources({
+		stack: app$1.name,
+		stage: app$1.stage
+	});
+	const deletionGraph = {
+		...plan$1.deletions,
+		...Object.fromEntries(replacedResources.map((replaced) => [replaced.logicalId, replaced]))
+	};
+	const deleteResource = Effect.fnUntraced(function* (node) {
+		const isDeleteNode = (node$1) => "action" in node$1;
+		const { logicalId, resourceType, instanceId, downstream, props, attr, provider } = isDeleteNode(node) ? {
+			logicalId: node.resource.id,
+			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,
+			resourceType: node.old.resourceType,
+			instanceId: node.old.instanceId,
+			downstream: node.old.downstream,
+			props: node.old.props,
+			attr: node.old.attr,
+			provider: yield* getProviderByType(node.old.resourceType)
+		};
+		const commit = (value) => state.set({
+			stack: app$1.name,
+			stage: app$1.stage,
+			resourceId: logicalId,
+			value
+		});
+		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[logicalId] ??= yield* Effect.cached(Effect.gen(function* () {
+			yield* Effect.all(downstream.map((dep) => dep in deletionGraph ? deleteResource(deletionGraph[dep]) : Effect.void));
+			yield* report("deleting");
+			if (isDeleteNode(node)) yield* commit({
+				status: "deleting",
+				logicalId,
+				instanceId,
+				resourceType,
+				props,
+				attr,
+				downstream,
+				providerVersion: provider.version ?? 0,
+				bindings: node.bindings
+			});
+			yield* provider.delete({
+				id: logicalId,
+				instanceId,
+				olds: props,
+				output: attr,
+				session: scopedSession,
+				bindings: []
+			});
+			if (isDeleteNode(node)) {
+				yield* state.delete({
+					stack: app$1.name,
+					stage: app$1.stage,
+					resourceId: logicalId
+				});
+				yield* report("deleted");
+			} else {
+				yield* commit({
+					status: "created",
+					logicalId,
+					instanceId,
+					resourceType,
+					props: node.props,
+					attr: node.attr,
+					providerVersion: provider.version ?? 0,
+					downstream: node.downstream,
+					bindings: node.bindings
+				});
+				yield* report("replaced");
+			}
+		}));
+	});
+	yield* Effect.all(Object.values(deletionGraph).filter((node) => node !== void 0).map(deleteResource));
 });
 
 //#endregion
@@ -40518,7 +40834,7 @@ var require_backend = /* @__PURE__ */ __commonJS({ "../node_modules/react-devtoo
 				}),
 				695: ((module$1, __unused_webpack_exports, __webpack_require__$1) => {
 					module$1.exports = Yallist;
-					Yallist.Node = Node$2;
+					Yallist.Node = Node$1;
 					Yallist.create = Yallist;
 					function Yallist(list$3) {
 						var self$1 = this;
@@ -40731,24 +41047,24 @@ var require_backend = /* @__PURE__ */ __commonJS({ "../node_modules/react-devtoo
 						return this;
 					};
 					function insert(self$1, node, value) {
-						var inserted = node === self$1.head ? new Node$2(value, null, node, self$1) : new Node$2(value, node, node.next, self$1);
+						var inserted = node === self$1.head ? new Node$1(value, null, node, self$1) : new Node$1(value, node, node.next, self$1);
 						if (inserted.next === null) self$1.tail = inserted;
 						if (inserted.prev === null) self$1.head = inserted;
 						self$1.length++;
 						return inserted;
 					}
 					function push$2(self$1, item) {
-						self$1.tail = new Node$2(item, self$1.tail, null, self$1);
+						self$1.tail = new Node$1(item, self$1.tail, null, self$1);
 						if (!self$1.head) self$1.head = self$1.tail;
 						self$1.length++;
 					}
 					function unshift(self$1, item) {
-						self$1.head = new Node$2(item, null, self$1.head, self$1);
+						self$1.head = new Node$1(item, null, self$1.head, self$1);
 						if (!self$1.tail) self$1.tail = self$1.head;
 						self$1.length++;
 					}
-					function Node$2(value, prev, next, list$3) {
-						if (!(this instanceof Node$2)) return new Node$2(value, prev, next, list$3);
+					function Node$1(value, prev, next, list$3) {
+						if (!(this instanceof Node$1)) return new Node$1(value, prev, next, list$3);
 						this.list = list$3;
 						this.value = value;
 						if (prev) {