alchemy-effect 0.3.0 → 0.5.0

package/bin/alchemy-effect.js

@@ -22,7 +22,7 @@ import * as Redacted from "effect/Redacted";
 import * as Schema from "effect/Schema";
 import * as EffectSecret from "effect/Secret";
 import * as Context from "effect/Context";
-import * as Layer from "effect/Layer";
+import * as Layer$1 from "effect/Layer";
 import * as Terminal from "@effect/platform/Terminal";
 import * as Effectable from "effect/Effectable";
 import * as Data from "effect/Data";
@@ -43,7 +43,7 @@ import * as ConfigProvider from "effect/ConfigProvider";
 import { NodeContext, NodeRuntime } from "@effect/platform-node";
 import * as PlatformConfigProvider from "@effect/platform/PlatformConfigProvider";
 import * as FetchHttpClient from "@effect/platform/FetchHttpClient";
-import { pipe as pipe$1 } from "effect";
+import { Layer, pipe as pipe$1 } from "effect";
 import { omit } from "effect/Struct";
 import { PassThrough, Stream } from "node:stream";
 import process$1, { cwd, env } from "node:process";
@@ -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.5.0";
 
 //#endregion
 //#region src/resource.ts
@@ -14054,7 +14054,7 @@ const isResource = (r) => {
 //#region src/state.ts
 var StateStoreError = class extends Data.TaggedError("StateStoreError") {};
 var State = class extends Context.Tag("AWS::Lambda::State")() {};
-const localFs = Layer.effect(State, Effect.gen(function* () {
+const localFs = Layer$1.effect(State, Effect.gen(function* () {
 	const fs$1 = yield* FileSystem.FileSystem;
 	const path$3 = yield* Path$1.Path;
 	const dotAlchemy$1 = path$3.join(process.cwd(), ".alchemy");
@@ -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,14 +14087,32 @@ 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
 //#region src/app.ts
 var App$1 = class extends Context.Tag("App")() {};
-const app = (input) => Layer.succeed(App$1, App$1.of(input));
+const app = (input) => Layer$1.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
+/** A 16-byte (128-bit) random hex-encoded string representing an physical instance of a logical resource */
+var InstanceId = class extends Context.Tag("instance-id")() {};
+/**
+* @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 +14131,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 +14225,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 +14259,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 +14275,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 +14309,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
-			}) : Effect.succeed(void 0);
+				output: oldState.attr
+			}).pipe(Effect.provide(Layer$1.succeed(InstanceId, oldState.instanceId))) : 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 +14340,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 +14364,132 @@ 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
+		});
+		else if (oldState.status === "creating" && oldState.attr === void 0) {
+			if (provider.read) {
+				const attr = yield* provider.read({
+					id,
+					instanceId: oldState.instanceId,
+					olds: oldState.props,
+					output: oldState.attr,
+					bindings
+				});
+				if (attr) return Node$1({
+					action: "create",
+					props: news,
+					state: {
+						...oldState,
+						attr
+					}
+				});
+			}
+		}
+		const oldProps = oldState.props;
+		const diff$1 = yield* asEffect(provider.diff ? provider.diff({
+			id,
+			olds: oldProps,
+			instanceId: oldState.instanceId,
+			output: oldState.attr,
+			news
+		}).pipe(Effect.provide(Layer$1.succeed(InstanceId, oldState.instanceId))) : 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 (diff$1?.action === "update") return Node$1({
+		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({
+			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 +14502,39 @@ const plan = (...resources) => Effect.gen(function* () {
 			stage: app$1.stage,
 			resourceId: id
 		});
-		const context = yield* Effect.context();
+		let attr = oldState?.attr;
 		if (oldState) {
-			const provider = context.unsafeMap.get(oldState?.type);
-			if (!provider) yield* Effect.die(/* @__PURE__ */ new Error(`Provider not found for ${oldState?.type}`));
+			const provider = yield* getProviderByType(oldState.resourceType);
+			if (oldState.attr === void 0) {
+				if (provider.read) attr = yield* provider.read({
+					id,
+					instanceId: oldState.instanceId,
+					olds: oldState.props,
+					output: oldState.attr,
+					bindings: oldState.bindings ?? []
+				}).pipe(Effect.provide(Layer$1.succeed(InstanceId, oldState.instanceId)));
+				if (attr === void 0) return;
+			}
 			return [id, {
 				action: "delete",
-				olds: oldState.props,
-				output: oldState.output,
-				provider,
-				attributes: oldState?.output,
+				state: {
+					...oldState,
+					attr
+				},
 				bindings: [],
+				provider,
 				resource: {
 					id,
-					type: oldState.type,
-					attr: oldState.output,
+					type: oldState.resourceType,
+					attr,
 					props: oldState.props
 				},
-				downstream: downstream[id] ?? []
+				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 +14546,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}`;
@@ -14479,34 +14597,38 @@ const isBindingDiff = Effect.fn(function* ({ target, oldBinding: { binding: oldB
 	const provider = yield* newBinding.Tag;
 	if (provider.diff) {
 		const oldState = yield* (yield* State).get(oldCap.resource.id);
-		const diff$1 = yield* provider.diff({
-			source: {
-				id: oldCap.resource.id,
-				props: newCap.resource.props,
-				oldProps: oldState?.props,
-				oldAttr: oldState?.output
-			},
-			props: newBinding.props,
-			attr: oldBinding.attr,
-			target
-		});
-		if (diff$1?.action === "update" || diff$1?.action === "replace") return diff$1;
+		if (oldState) {
+			const diff$1 = yield* provider.diff({
+				source: {
+					id: oldCap.resource.id,
+					props: newCap.resource.props,
+					oldProps: oldState?.props,
+					oldAttr: oldState?.attr
+				},
+				props: newBinding.props,
+				attr: oldBinding.attr,
+				target
+			}).pipe(Effect.provide(Layer$1.succeed(InstanceId, oldState.instanceId)));
+			if (diff$1?.action === "update" || diff$1?.action === "replace") return diff$1;
+		}
 	}
 	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 +14696,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,152 +14713,395 @@ 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");
-				let bindingOutputs = yield* attachBindings({
-					resource,
-					bindings: node$1.bindings,
-					target: {
-						id,
-						props: news,
-						attr
-					}
-				});
-				const output = yield* (phase === "create" ? node$1.provider.create : node$1.provider.update)({
-					id,
-					news,
-					bindings: bindingOutputs,
-					session: scopedSession,
-					...node$1.action === "update" ? {
-						output: node$1.output,
-						olds: node$1.olds
-					} : {}
-				}).pipe(Effect.tap(() => report(phase === "create" ? "created" : "updated")));
-				bindingOutputs = yield* postAttachBindings({
-					resource,
-					bindings: node$1.bindings,
-					bindingOutputs,
-					target: {
-						id,
+			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}'`);
+			});
+			return yield* Effect.gen(function* () {
+				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: 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* saveState({
-					news,
-					output,
-					bindings: node$1.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({
+					yield* report("attaching");
+					let bindingOutputs = yield* attachBindings({
+						resource,
+						bindings: node.bindings,
+						target: {
+							id,
+							props: news,
+							attr
+						}
+					});
+					yield* report("creating");
+					attr = yield* node.provider.create({
 						id,
-						news: node.news,
+						news,
+						instanceId,
+						bindings: bindingOutputs,
 						session: scopedSession
 					});
-				}
-				yield* Effect.logDebug("create", id);
-				return yield* createOrUpdate({
-					node,
-					attr,
-					phase: "create"
-				});
-			} else if (node.action === "update") {
-				yield* Effect.logDebug("update", id);
-				return yield* createOrUpdate({
-					node,
-					attr: node.attributes,
-					phase: "update"
-				});
-			} 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({
-					id,
-					olds: node.olds,
-					output: node.output,
-					session: scopedSession,
-					bindings: []
-				}).pipe(Effect.flatMap(() => state.delete({
-					stack: app$1.name,
-					stage: app$1.stage,
-					resourceId: id
-				})), Effect.tap(() => report("deleted")));
-			} else if (node.action === "replace") {
-				const destroy = Effect.gen(function* () {
-					yield* report("deleting");
-					return yield* node.provider.delete({
+					yield* checkpoint(attr);
+					yield* report("post-attach");
+					bindingOutputs = yield* postAttachBindings({
+						resource,
+						bindings: node.bindings,
+						bindingOutputs,
+						target: {
+							id,
+							props: news,
+							attr
+						}
+					});
+					yield* commit({
+						status: "created",
+						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("created");
+					return attr;
+				} else if (node.action === "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
+						}
+					});
+					yield* report("updating");
+					const attr = yield* node.provider.update({
 						id,
-						olds: node.olds,
-						output: node.output,
+						news,
+						instanceId,
+						bindings: bindingOutputs,
 						session: scopedSession,
-						bindings: []
+						olds: node.state.status === "created" || node.state.status === "updated" || node.state.status === "replaced" ? node.state.props : node.state.old.props,
+						output: node.state.attr
 					});
-				});
-				const create$1 = Effect.gen(function* () {
-					yield* report("creating");
-					return yield* node.provider.create({
+					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") {
+					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,
+							news: node.props,
+							session: scopedSession,
+							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: node.news,
-						bindings: yield* attachBindings({
-							resource,
-							bindings: node.bindings,
-							target: {
-								id,
-								props: node.news,
-								attr: node.attributes
-							}
-						}),
+						news,
+						instanceId,
+						bindings: bindingOutputs,
 						session: scopedSession
-					}).pipe(Effect.tap((output) => saveState({
-						news: node.news,
-						output
-					})));
-				});
-				if (!node.deleteFirst) {
-					yield* destroy;
-					return outputs;
-				} else {
-					yield* destroy;
-					return yield* create$1;
+					});
+					yield* checkpoint({
+						status: "replacing",
+						attr
+					});
+					yield* report("post-attach");
+					bindingOutputs = yield* postAttachBindings({
+						resource,
+						bindings: node.bindings,
+						bindingOutputs,
+						target: {
+							id,
+							props: news,
+							attr
+						}
+					});
+					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}`);
+			}).pipe(Effect.provide(Layer.succeed(InstanceId, instanceId)));
 		}));
 	});
-	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");
+			}
+		}).pipe(Effect.provide(Layer.succeed(InstanceId, instanceId))));
+	});
+	yield* Effect.all(Object.values(deletionGraph).filter((node) => node !== void 0).map(deleteResource));
 });
 
 //#endregion
 //#region src/dot-alchemy.ts
 var DotAlchemy = class extends Context.Tag(".alchemy")() {};
-const dotAlchemy = Layer.effect(DotAlchemy, Effect.gen(function* () {
+const dotAlchemy = Layer$1.effect(DotAlchemy, Effect.gen(function* () {
 	const fs$1 = yield* FileSystem.FileSystem;
 	const dir = (yield* Path$1.Path).join(process.cwd(), ".alchemy");
 	yield* fs$1.makeDirectory(dir, { recursive: true });
@@ -40518,7 +40876,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 +41089,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) {
@@ -54919,7 +55277,7 @@ function useGlobalSpinner(intervalMs = 80) {
 
 //#endregion
 //#region src/cli/ink-service.tsx
-const inkCLI = () => Layer.succeed(CLI, CLI.of({
+const inkCLI = () => Layer$1.succeed(CLI, CLI.of({
 	approvePlan,
 	displayPlan,
 	startApplySession
@@ -55009,10 +55367,10 @@ const execStack = Effect.fn(function* ({ main: main$1, stage: stage$1, envFile:
 	if (!stack) return yield* Effect.die(/* @__PURE__ */ new Error(`Main file '${main$1}' must export a default stack definition (export default defineStack({...}))`));
 	const stackName = stack.name;
 	const configProvider = Option.isSome(envFile$1) ? ConfigProvider.orElse(yield* PlatformConfigProvider.fromDotEnv(envFile$1.value), ConfigProvider.fromEnv) : ConfigProvider.fromEnv();
-	const stageConfig = yield* asEffect(stack.stages.config(stage$1)).pipe(Effect.provide(stack.layers ?? Layer.empty), Effect.withConfigProvider(configProvider));
-	const platform$1 = Layer.mergeAll(NodeContext.layer, FetchHttpClient.layer, Logger.pretty);
-	const alchemy = Layer.mergeAll(stack.state ?? localFs, stack.cli ?? inkCLI(), dotAlchemy);
-	const layers = Layer.provideMerge(Layer.provideMerge(stack.providers, alchemy), Layer.mergeAll(platform$1, make({
+	const stageConfig = yield* asEffect(stack.stages.config(stage$1)).pipe(Effect.provide(stack.layers ?? Layer$1.empty), Effect.withConfigProvider(configProvider));
+	const platform$1 = Layer$1.mergeAll(NodeContext.layer, FetchHttpClient.layer, Logger.pretty);
+	const alchemy = Layer$1.mergeAll(stack.state ?? localFs, stack.cli ?? inkCLI(), dotAlchemy);
+	const layers = Layer$1.provideMerge(Layer$1.provideMerge(stack.providers, alchemy), Layer$1.mergeAll(platform$1, make({
 		name: stackName,
 		stage: stage$1,
 		config: stageConfig
@@ -55026,7 +55384,7 @@ const execStack = Effect.fn(function* ({ main: main$1, stage: stage$1, envFile:
 				if (!(yield* cli.approvePlan(updatePlan))) return;
 			}
 			const outputs = yield* applyPlan(updatePlan);
-			if (outputs && stack.tap) yield* stack.tap(outputs).pipe(Effect.provide(stack.layers ?? Layer.empty));
+			if (outputs && stack.tap) yield* stack.tap(outputs).pipe(Effect.provide(stack.layers ?? Layer$1.empty));
 		}
 	}).pipe(Effect.provide(layers), Effect.withConfigProvider(configProvider));
 });