alchemy-effect 0.4.0 → 0.6.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.4.0";
+var version = "0.6.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");
@@ -14093,7 +14093,7 @@ const localFs = Layer.effect(State, Effect.gen(function* () {
 //#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
@@ -14102,6 +14102,8 @@ 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)
 */
@@ -14295,7 +14297,7 @@ const plan = (..._resources) => Effect.gen(function* () {
 		stack: app$1.name,
 		stage: app$1.stage,
 		resourceId: id
-	})));
+	})), { concurrency: "unbounded" });
 	const resolvedResources = {};
 	const resolveResource = (resourceExpr) => Effect.gen(function* () {
 		return yield* resolvedResources[resourceExpr.src.id] ??= yield* Effect.cached(Effect.gen(function* () {
@@ -14315,7 +14317,7 @@ const plan = (..._resources) => Effect.gen(function* () {
 				instanceId: oldState.instanceId,
 				news: props,
 				output: oldState.attr
-			}) : Effect.succeed(void 0);
+			}).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) {
@@ -14329,8 +14331,8 @@ const plan = (..._resources) => Effect.gen(function* () {
 	const resolveInput = (input) => Effect.gen(function* () {
 		if (!input) return input;
 		else if (isExpr(input)) return yield* resolveOutput(input);
-		else if (Array.isArray(input)) return yield* Effect.all(input.map(resolveInput));
-		else if (typeof input === "object") return Object.fromEntries(yield* Effect.all(Object.entries(input).map(([key, value]) => resolveInput(value).pipe(Effect.map((value$1) => [key, value$1])))));
+		else if (Array.isArray(input)) return yield* Effect.all(input.map(resolveInput), { concurrency: "unbounded" });
+		else if (typeof input === "object") return Object.fromEntries(yield* Effect.all(Object.entries(input).map(([key, value]) => resolveInput(value).pipe(Effect.map((value$1) => [key, value$1]))), { concurrency: "unbounded" }));
 		return input;
 	});
 	const resolveOutput = (expr) => Effect.gen(function* () {
@@ -14342,7 +14344,7 @@ const plan = (..._resources) => Effect.gen(function* () {
 		} else if (isEffectExpr(expr)) {
 			const upstream$1 = yield* resolveOutput(expr.expr);
 			return hasOutputs(upstream$1) ? expr : yield* expr.f(upstream$1);
-		} else if (isAllExpr(expr)) return yield* Effect.all(expr.outs.map(resolveOutput));
+		} else if (isAllExpr(expr)) return yield* Effect.all(expr.outs.map(resolveOutput), { concurrency: "unbounded" });
 		return yield* Effect.die(/* @__PURE__ */ new Error("Not implemented yet"));
 	});
 	const oldDownstreamDependencies = Object.fromEntries(oldResources.filter((resource) => !!resource).map((resource) => [resource.logicalId, resource.downstream]));
@@ -14385,6 +14387,25 @@ const plan = (..._resources) => Effect.gen(function* () {
 			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,
@@ -14392,7 +14413,7 @@ const plan = (..._resources) => Effect.gen(function* () {
 			instanceId: oldState.instanceId,
 			output: oldState.attr,
 			news
-		}) : void 0).pipe(Effect.map((diff$2) => diff$2 ?? { action: arePropsChanged(oldProps, news) ? "update" : "noop" }));
+		}).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,
@@ -14470,7 +14491,7 @@ const plan = (..._resources) => Effect.gen(function* () {
 			action: "noop",
 			state: oldState
 		});
-	})))).map((update) => [update.resource.id, update]));
+	})), { concurrency: "unbounded" })).map((update) => [update.resource.id, update]));
 	const deletions = Object.fromEntries((yield* Effect.all((yield* state.list({
 		stack: app$1.name,
 		stage: app$1.stage
@@ -14481,20 +14502,36 @@ const plan = (..._resources) => Effect.gen(function* () {
 			stage: app$1.stage,
 			resourceId: 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));
+		let attr = oldState?.attr;
+		if (oldState) {
+			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)));
+			}
+			return [id, {
+				action: "delete",
+				state: {
+					...oldState,
+					attr
+				},
+				bindings: [],
+				provider,
+				resource: {
+					id,
+					type: oldState.resourceType,
+					attr,
+					props: oldState.props
+				},
+				downstream: oldDownstreamDependencies[id] ?? []
+			}];
+		}
+	})), { concurrency: "unbounded" })).filter((v) => !!v));
 	for (const [resourceId, deletion] of Object.entries(deletions)) {
 		const dependencies = deletion.state.downstream.filter((d) => d in resourceGraph);
 		if (dependencies.length > 0) return yield* Effect.fail(new DeleteResourceHasDownstreamDependencies({
@@ -14550,7 +14587,7 @@ const diffBindings = Effect.fn(function* ({ oldState, bindings, target }) {
 			attr: oldBinding.attr
 		};
 	});
-	return (yield* Effect.all(bindings.map(diffBinding))).filter((action) => action !== null);
+	return (yield* Effect.all(bindings.map(diffBinding), { concurrency: "unbounded" })).filter((action) => action !== null);
 });
 const isBindingDiff = Effect.fn(function* ({ target, oldBinding: { binding: oldBinding }, newBinding }) {
 	const oldCap = oldBinding.capability;
@@ -14559,18 +14596,20 @@ 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?.attr
-			},
-			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" };
 });
@@ -14654,7 +14693,7 @@ const expandAndPivot = Effect.fnUntraced(function* (plan$1, session) {
 			};
 		}
 		return oldBindingOutput;
-	})));
+	})), { concurrency: "unbounded" });
 	const apply = (node) => Effect.gen(function* () {
 		const commit = (value) => state.set({
 			stack: app$1.name,
@@ -14680,7 +14719,7 @@ const expandAndPivot = Effect.fnUntraced(function* (plan$1, session) {
 				status
 			});
 			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 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]))), { concurrency: "unbounded" }));
 			const instanceId = yield* Effect.gen(function* () {
 				if (node.action === "create" && !node.state?.instanceId) {
 					const instanceId$1 = yield* generateInstanceId();
@@ -14714,248 +14753,250 @@ const expandAndPivot = Effect.fnUntraced(function* (plan$1, session) {
 				} 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({
+			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$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.bindings,
+						target: {
+							id,
+							props: news,
+							attr
+						}
+					});
+					yield* report("creating");
+					attr = yield* node.provider.create({
 						id,
-						news: node.props,
-						session: scopedSession,
-						instanceId
+						news,
+						instanceId,
+						bindings: bindingOutputs,
+						session: scopedSession
 					});
 					yield* checkpoint(attr);
-				}
-				yield* report("attaching");
-				let bindingOutputs = yield* attachBindings({
-					resource,
-					bindings: node.bindings,
-					target: {
-						id,
+					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
-					}
-				});
-				yield* report("creating");
-				attr = yield* node.provider.create({
-					id,
-					news,
-					instanceId,
-					bindings: bindingOutputs,
-					session: scopedSession
-				});
-				yield* checkpoint(attr);
-				yield* report("post-attach");
-				bindingOutputs = yield* postAttachBindings({
-					resource,
-					bindings: node.bindings,
-					bindingOutputs,
-					target: {
+						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]))), { concurrency: "unbounded" }));
+					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,
-						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({
+						news,
+						instanceId,
+						bindings: bindingOutputs,
+						session: scopedSession,
+						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: attr$1,
+						attr,
 						props: news
 					});
-					else return commit({
-						status: "updating",
+					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]))), { concurrency: "unbounded" }));
+					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: node.bindings,
+						bindings: bindings ?? node.bindings,
 						downstream: node.downstream,
-						old: node.state.status === "updating" ? node.state.old : node.state
+						old: state$1.old,
+						deleteFirst: node.deleteFirst
 					});
-				};
-				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,
-					news,
-					instanceId,
-					bindings: bindingOutputs,
-					session: scopedSession,
-					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
+					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
+						});
 					}
-				});
-				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({
+					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.props,
-						session: scopedSession,
-						instanceId
+						news,
+						instanceId,
+						bindings: bindingOutputs,
+						session: scopedSession
 					});
 					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;
 				}
-				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
-				});
-				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}`);
+				return yield* Effect.dieMessage(`Unknown action: ${node.action}`);
+			}).pipe(Effect.provide(Layer.succeed(InstanceId, instanceId)));
 		}));
 	});
 	return Object.fromEntries(yield* Effect.all(Object.entries(plan$1.resources).map(Effect.fn(function* ([id, node]) {
 		return [id, yield* apply(node)];
-	}))));
+	})), { concurrency: "unbounded" }));
 });
 const collectGarbage = Effect.fnUntraced(function* (plan$1, session) {
 	const state = yield* State;
@@ -15009,7 +15050,7 @@ const collectGarbage = Effect.fnUntraced(function* (plan$1, session) {
 			})
 		};
 		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* Effect.all(downstream.map((dep) => dep in deletionGraph ? deleteResource(deletionGraph[dep]) : Effect.void), { concurrency: "unbounded" });
 			yield* report("deleting");
 			if (isDeleteNode(node)) yield* commit({
 				status: "deleting",
@@ -15022,7 +15063,7 @@ const collectGarbage = Effect.fnUntraced(function* (plan$1, session) {
 				providerVersion: provider.version ?? 0,
 				bindings: node.bindings
 			});
-			yield* provider.delete({
+			if (attr !== void 0) yield* provider.delete({
 				id: logicalId,
 				instanceId,
 				olds: props,
@@ -15051,15 +15092,15 @@ const collectGarbage = Effect.fnUntraced(function* (plan$1, session) {
 				});
 				yield* report("replaced");
 			}
-		}));
+		}).pipe(Effect.provide(Layer.succeed(InstanceId, instanceId))));
 	});
-	yield* Effect.all(Object.values(deletionGraph).filter((node) => node !== void 0).map(deleteResource));
+	yield* Effect.all(Object.values(deletionGraph).filter((node) => node !== void 0).map(deleteResource), { concurrency: "unbounded" });
 });
 
 //#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 });
@@ -55235,7 +55276,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
@@ -55325,10 +55366,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
@@ -55342,7 +55383,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));
 });