alchemy 2.0.0-beta.36 → 2.0.0-beta.38

package/bin/exec.js

@@ -1,4 +1,3 @@
-import { createRequire } from "node:module";
 import * as ConfigProvider from "effect/ConfigProvider";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -12,6 +11,8 @@ import * as Redacted from "effect/Redacted";
 import path from "pathe";
 import * as Config from "effect/Config";
 import os from "node:os";
+import * as dns from "node:dns";
+import * as undici from "undici";
 import * as Console from "effect/Console";
 import * as Logger from "effect/Logger";
 import * as Option from "effect/Option";
@@ -23,9 +24,11 @@ import * as Deferred from "effect/Deferred";
 import { pipe } from "effect/Function";
 import { SingleShotGen } from "effect/Utils";
 import { pipeArguments } from "effect/Pipeable";
+import "effect/Scope";
 import * as Duration from "effect/Duration";
 import * as Exit from "effect/Exit";
 import * as Metric from "effect/Metric";
+import { createHash } from "node:crypto";
 import * as Argument from "effect/unstable/cli/Argument";
 import * as CliError from "effect/unstable/cli/CliError";
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -152,22 +155,16 @@ const isLocalhost = (hostname) => hostname === "localhost" || hostname === "[::1
 const installLocalhostDns = () => {
 	if (installed) return;
 	installed = true;
-	if (typeof globalThis.Bun !== "undefined") return;
-	try {
-		const require = createRequire(import.meta.url);
-		const undici = require("undici");
-		const dns = require("node:dns");
-		undici.setGlobalDispatcher(new undici.Agent({ connect: { lookup: (hostname, options, cb) => {
-			if (isLocalhost(hostname)) {
-				if (options && options.all) return cb(null, [{
-					address: "127.0.0.1",
-					family: 4
-				}]);
-				return cb(null, "127.0.0.1", 4);
-			}
-			return dns.lookup(hostname, options, cb);
-		} } }));
-	} catch {}
+	undici.setGlobalDispatcher(new undici.Agent({ connect: { lookup: (hostname, options, cb) => {
+		if (isLocalhost(hostname)) {
+			if (options && options.all) return cb(null, [{
+				address: "127.0.0.1",
+				family: 4
+			}]);
+			return cb(null, "127.0.0.1", 4);
+		}
+		return dns.lookup(hostname, options, cb);
+	} } }));
 };
 
 //#endregion
@@ -358,18 +355,7 @@ var Cli = class extends EffectContext.Service()("CLI") {};
 //#region lib/Ref.js
 const RefMetadata = Symbol.for("alchemy/RefMetadata");
 const isRef = (s) => s && s[RefMetadata] !== void 0;
-const getRefMetadata = (ref$1) => ref$1[RefMetadata];
-const ref = ({ stack, id, stage: stage$1 }) => {
-	const ref$1 = new Proxy({}, { get: (_, prop) => {
-		if (prop === RefMetadata) return {
-			stack,
-			stage: stage$1,
-			id
-		};
-		return of(ref$1)[prop];
-	} });
-	return ref$1;
-};
+const getRefMetadata = (ref) => ref[RefMetadata];
 
 //#endregion
 //#region lib/FQN.js
@@ -479,11 +465,22 @@ const loadConfigProvider = (envFile$1) => {
 
 //#endregion
 //#region lib/Util/effect.js
+const effectClass = ((impl) => impl === void 0 ? (innerImpl) => effectClass(innerImpl) : Object.assign(class {
+	static asEffect() {
+		return impl;
+	}
+	static [Symbol.iterator]() {
+		return new SingleShotGen(this.asEffect());
+	}
+	static pipe(...fns) {
+		return pipeArguments(this, fns);
+	}
+}, impl));
 const taggedFunction = (tag$1, fn) => {
 	const overrides = {
-		asEffect: () => tag$1.asEffect(),
+		asEffect: () => tag$1,
 		[Symbol.iterator]: () => tag$1[Symbol.iterator](),
-		pipe: (...fns) => pipeArguments(tag$1.asEffect(), fns),
+		pipe: (...fns) => pipeArguments(tag$1, fns),
 		toString: () => `${tag$1.toString()}.${fn.name}`
 	};
 	return new Proxy(fn, {
@@ -505,34 +502,38 @@ const fileLogger = Effect.fnUntraced(function* (...segments) {
 
 //#endregion
 //#region lib/Stack.js
-const Stack = Object.assign(taggedFunction(EffectContext.Service()("Stack"), (stackName, options, eff) => eff.pipe(make$1({
-	name: stackName,
-	...options
-}), (eff$1) => Object.assign(eff$1, { stage: new Proxy({}, { get: (_, stage$1) => ref({
-	stack: stackName,
-	stage: stage$1,
-	id: stackName
-}) }) }))));
+const Stack = Object.assign(taggedFunction(EffectContext.Service()("Stack"), (stackName, options, eff) => {
+	if (!stackName) return (stackName$1) => Object.assign(stackRef(stackName$1).pipe(effectClass), {
+		stage: createStageProxy(stackName$1),
+		make: (options$1, eff$1) => Stack(stackName$1, options$1, eff$1)
+	});
+	return eff.pipe(make$1({
+		name: stackName,
+		...options
+	}), (eff$1) => Object.assign(eff$1, { stage: createStageProxy(stackName) }));
+}));
+const createStageProxy = (stackName) => new Proxy({}, { get: (_, stage$1) => stackRef(stackName, { stage: stage$1 }) });
 const StackName = Stack.use((stack) => Effect.succeed(stack.name));
 const make$1 = (options) => (effect) => Effect.scope.pipe(Effect.flatMap((scope) => {
 	if (options.state == null) return Effect.die(/* @__PURE__ */ new Error(`Stack "${options.name}" is missing a state store. Add a \`state\` layer to the stack options, e.g.:\n  Alchemy.Stack("${options.name}", {\n    providers: Cloudflare.providers(),\n    state: Cloudflare.state(), // <-- required\n  }, ...)\nSee https://v2.alchemy.run/concepts/state-store for available state stores.`));
 	if (options.providers == null) return Effect.die(/* @__PURE__ */ new Error(`Stack "${options.name}" is missing a providers layer. Add a \`providers\` layer to the stack options, e.g.:\n  Alchemy.Stack("${options.name}", {\n    providers: Cloudflare.providers(), // <-- required\n    state: Cloudflare.state(),\n  }, ...)`));
-	return options.providers.pipe(Layer.provideMerge(options.state), Layer.provideMerge(Layer.effect(Stack, Stage.asEffect().pipe(Effect.map((stage$1) => options.stack ?? {
+	return options.providers.pipe(Layer.provideMerge(options.state), Layer.provideMerge(Layer.effect(Stack, Stage.pipe(Effect.map((stage$1) => options.stack ?? {
 		name: options.name,
 		stage: stage$1,
 		resources: {},
-		bindings: {}
+		bindings: {},
+		actions: {}
 	})))), Layer.buildWithScope(scope));
 }), Effect.flatMap((context) => Effect.all([
 	effect,
-	Stack.asEffect(),
+	Stack,
 	Effect.context()
 ]).pipe(Effect.map(([output, stack, services$1]) => ({
 	...stack,
 	output,
 	services: EffectContext.merge(services$1, context)
 })), Effect.provideContext(context))));
-const CurrentStack = Effect.serviceOption(Stack).asEffect().pipe(Effect.map(Option.getOrUndefined));
+const CurrentStack = Effect.serviceOption(Stack).pipe(Effect.map(Option.getOrUndefined));
 const platform = Layer.mergeAll(PlatformServices, FetchHttpClient.layer, Logger.layer([fileLogger("out")], { mergeWithExisting: true }), Layer.provide(ProfileLive, PlatformServices), Layer.provide(CredentialsStoreLive, PlatformServices));
 
 //#endregion
@@ -553,6 +554,7 @@ const CurrentRuntimeContext = Effect.serviceOption(RuntimeContext).pipe(Effect.m
 
 //#endregion
 //#region lib/State/State.js
+const isActionState = (s) => !!s && s.kind === "action";
 var State = class extends EffectContext.Service()("alchemy/State") {};
 
 //#endregion
@@ -578,13 +580,13 @@ var BaseExpr = class {
 		return this;
 	}
 	[Symbol.iterator]() {
-		return new SingleShotGen(this);
+		return new SingleShotGen(this.asEffect());
 	}
 	asEffect() {
 		return this.bind(this.toString());
 	}
 	bind(id) {
-		return RuntimeContext.asEffect().pipe(Effect.flatMap((ctx) => Effect.map(ctx.set(id, this), (key) => ctx.get(key))));
+		return RuntimeContext.pipe(Effect.flatMap((ctx) => Effect.map(ctx.set(id, this), (key) => ctx.get(key))));
 	}
 	pipe(...fns) {
 		return pipe(this, ...fns);
@@ -667,6 +669,28 @@ var EffectExpr = class extends BaseExpr {
 		return `${this.expr[inspect]()}.mapEffect(${this.f.toString()})`;
 	}
 };
+const isNamedExpr = (node) => node?.kind === "NamedExpr";
+/**
+* Wraps another `Expr` and overrides its `toString()` / inspect output.
+*
+* `BaseExpr` derives the binding id from `this.toString()`, so
+* wrapping an expression in `NamedExpr` makes that derived id stable and
+* caller-controlled (e.g. an env var name like `"API_KEY"`).
+*/
+var NamedExpr = class extends BaseExpr {
+	expr;
+	bindingName;
+	kind = "NamedExpr";
+	constructor(expr, bindingName) {
+		super();
+		this.expr = expr;
+		this.bindingName = bindingName;
+		return proxy(this);
+	}
+	[inspect]() {
+		return this.bindingName;
+	}
+};
 const isAllExpr = (node) => node?.kind === "AllExpr";
 var AllExpr = class extends BaseExpr {
 	outs;
@@ -697,6 +721,39 @@ var RefExpr = class extends BaseExpr {
 		return `ref(${this.resourceId}, { stack: ${this.stack}, stage: ${this.stage} })`;
 	}
 };
+const isStackRefExpr = (node) => node?.kind === "StackRefExpr";
+/**
+* A reference to the persisted output of a Stack at `(stack, stage)`.
+*
+* Resolved at evaluation time by reading `state.getOutput({ stack,
+* stage })`. Distinct from {@link RefExpr}, which references a
+* single resource's attributes within a stack/stage. `stage` may be
+* `undefined`, in which case it falls back to the current stage.
+*/
+var StackRefExpr = class extends BaseExpr {
+	stack;
+	stage;
+	kind = "StackRefExpr";
+	constructor(stack, stage$1) {
+		super();
+		this.stack = stack;
+		this.stage = stage$1;
+		return proxy(this);
+	}
+	[inspect]() {
+		return `stackRef(${this.stack}${this.stage ? `, { stage: ${this.stage} }` : ""})`;
+	}
+};
+/**
+* Build an `Output<A>` referencing the persisted output of another
+* Stack. The returned Effect resolves to a lazy `Output<A>` whose
+* value is read from the state store at plan/apply time.
+*
+* Returns `Effect<Output<A>>` (not `Output<A>` directly) so that
+* `yield* Output.stackRef(...)` reads ergonomically inside an Effect
+* generator and lines up with `Resource.ref` and `Stack.stage.<name>`.
+*/
+const stackRef = (stack, options = {}) => Effect.succeed(new StackRefExpr(stack, options.stage));
 function proxy(self) {
 	const target = Object.assign(() => {}, self);
 	if (inspect in self) Object.defineProperty(target, inspect, {
@@ -705,7 +762,9 @@ function proxy(self) {
 	});
 	const proxy$1 = new Proxy(target, {
 		has: (_, prop) => prop === ExprSymbol || prop === inspect ? true : prop in self,
-		get: (target$1, prop) => prop === Symbol.toPrimitive ? (hint) => hint === "number" ? NaN : self.toString() : prop === ExprSymbol ? self : prop === inspect ? target$1[inspect] : isResourceExpr(self) && self.stables && prop in self.stables ? self.stables[prop] : prop === "apply" ? self[prop] : prop in self ? typeof self[prop] === "function" && !("kind" in self) ? new PropExpr(proxy$1, prop) : self[prop] : new PropExpr(proxy$1, prop),
+		get: (target$1, prop) => prop === Symbol.toPrimitive ? (hint) => {
+			throw new Error(`Cannot coerce Output<${self[inspect]()}> to a ${hint === "number" ? "number" : "string"} via JS coercion. Use Output.interpolate\`...\` or Output.map(output, fn) to compose Outputs — the value isn't known until deploy time.`);
+		} : prop === ExprSymbol ? self : prop === inspect ? target$1[inspect] : isResourceExpr(self) && self.stables && prop in self.stables ? self.stables[prop] : prop === "apply" ? self[prop] : prop in self ? typeof self[prop] === "function" && !("kind" in self) ? new PropExpr(proxy$1, prop) : self[prop] : new PropExpr(proxy$1, prop),
 		apply: (_, thisArg, args) => {
 			if (isPropExpr(self)) {
 				if (self.identifier === "apply") return new ApplyExpr(self.expr, args[0]);
@@ -740,6 +799,7 @@ const evaluate = (expr, upstream$1) => Effect.gen(function* () {
 		else if (isEffectExpr(expr)) return yield* expr.f(yield* evaluate(expr.expr, upstream$1));
 		else if (isAllExpr(expr)) return yield* Effect.all(expr.outs.map((out) => evaluate(out, upstream$1)));
 		else if (isPropExpr(expr)) return (yield* evaluate(expr.expr, upstream$1))?.[expr.identifier];
+		else if (isNamedExpr(expr)) return yield* evaluate(expr.expr, upstream$1);
 		else if (isRefExpr(expr)) {
 			const state = yield* State;
 			const stack = expr.stack ?? (yield* Stack).name;
@@ -755,7 +815,22 @@ const evaluate = (expr, upstream$1) => Effect.gen(function* () {
 				stage: stage$1,
 				resourceId: expr.resourceId
 			}));
-			return resource.attr;
+			return resource.attr ?? resource.output;
+		} else if (isStackRefExpr(expr)) {
+			const state = yield* State;
+			const stack = expr.stack;
+			const stage$1 = expr.stage ?? (yield* Stage);
+			const output = yield* state.getOutput({
+				stack,
+				stage: stage$1
+			});
+			if (output == null) return yield* Effect.fail(new InvalidReferenceError({
+				message: `Reference to stack '${stack}' at stage '${stage$1}' not found. Have you deployed stage '${stage$1}' of '${stack}'?`,
+				stack,
+				stage: stage$1,
+				resourceId: stack
+			}));
+			return output;
 		}
 	}
 	if (Array.isArray(expr)) return yield* Effect.all(expr.map((item) => evaluate(item, upstream$1)));
@@ -776,7 +851,7 @@ const upstream = (expr) => {
 	else if (isResourceExpr(expr)) return { [expr.src.FQN]: expr.src };
 	else if (isPropExpr(expr)) return upstream(expr.expr);
 	else if (isAllExpr(expr)) return Object.assign({}, ...expr.outs.map((out) => upstream(out)));
-	else if (isEffectExpr(expr) || isApplyExpr(expr)) return upstream(expr.expr);
+	else if (isEffectExpr(expr) || isApplyExpr(expr) || isNamedExpr(expr)) return upstream(expr.expr);
 	else if (Array.isArray(expr)) return expr.map(upstream).reduce(toObject, {});
 	else if (typeof expr === "object" && expr !== null) return Object.values(expr).map((v) => upstream(v)).reduce(toObject, {});
 	return {};
@@ -922,6 +997,19 @@ const recordOutcome = (baseAttrs, status, duration) => {
 	return Effect.all([Metric.update(Metric.withAttributes(resourceCounter, attrs), 1), Metric.update(Metric.withAttributes(resourceDuration, attrs), duration)], { discard: true });
 };
 
+//#endregion
+//#region lib/Action.js
+const isAction = (value) => typeof value === "object" && value !== null && value?.Kind === "action";
+
+//#endregion
+//#region lib/Util/hash.js
+/**
+* Stable hash of a resolved Task input. Wrapped in `Effect.sync` so the
+* call participates in the Effect runtime (tracing/interruption) per the
+* Effect-platform conventions.
+*/
+const hashInput = (input) => Effect.sync(() => createHash("sha256").update(JSON.stringify(input ?? null)).digest("hex"));
+
 //#endregion
 //#region lib/Util/scc.js
 /**
@@ -1000,6 +1088,7 @@ const findCycleMembers = (edges) => {
 const make = (stack, options = {}) => Effect.gen(function* () {
 	const state = yield* State;
 	const resources = Object.values(stack.resources);
+	const actions = Object.values(stack.actions ?? {});
 	const stackName = stack.name;
 	const stage$1 = stack.stage;
 	const shouldAdopt = Effect.gen(function* () {
@@ -1022,15 +1111,17 @@ const make = (stack, options = {}) => Effect.gen(function* () {
 	})), { concurrency: "unbounded" });
 	const resolvedResources = {};
 	const resolveResource = (resourceExpr) => Effect.gen(function* () {
+		if (isAction(resourceExpr.src)) return resourceExpr;
 		return yield* resolvedResources[resourceExpr.src.FQN] ??= yield* Effect.cached(Effect.gen(function* () {
 			const resource = resourceExpr.src;
 			const provider = yield* findProviderByType(resource.Type);
 			const props = yield* resolveInput(resource.Props);
-			const oldState = yield* state.get({
+			const persisted = yield* state.get({
 				stack: stackName,
 				stage: stage$1,
 				fqn: resource.FQN
 			});
+			const oldState = isActionState(persisted) ? void 0 : persisted;
 			if (!oldState || oldState.status === "creating") return resourceExpr;
 			const oldProps = oldState.status === "updating" ? oldState.old.props : oldState.props;
 			const oldBindings = oldState.bindings ?? [];
@@ -1074,23 +1165,76 @@ const make = (stack, options = {}) => Effect.gen(function* () {
 			return hasOutputs(upstream$1) ? expr : yield* expr.f(upstream$1);
 		} else if (isAllExpr(expr)) return yield* Effect.all(expr.outs.map(resolveOutput), { concurrency: "unbounded" });
 		else if (isLiteralExpr(expr)) return expr.value;
-		return yield* Effect.die(/* @__PURE__ */ new Error("Not implemented yet"));
+		else if (isRefExpr(expr)) {
+			const refStack = expr.stack ?? stackName;
+			const refStage = expr.stage ?? stage$1;
+			const refState = yield* state.get({
+				stack: refStack,
+				stage: refStage,
+				fqn: expr.resourceId
+			}).pipe(Effect.orDie);
+			if (!refState) return yield* Effect.die(new InvalidReferenceError({
+				message: `Reference to '${expr.resourceId}' in stack '${refStack}' and stage '${refStage}' not found. Have you deployed '${refStage}' of '${refStack}'?`,
+				stack: refStack,
+				stage: refStage,
+				resourceId: expr.resourceId
+			}));
+			return refState.attr ?? refState.output;
+		} else if (isStackRefExpr(expr)) {
+			const refStack = expr.stack;
+			const refStage = expr.stage ?? stage$1;
+			const output = yield* state.getOutput({
+				stack: refStack,
+				stage: refStage
+			}).pipe(Effect.orDie);
+			if (output == null) return yield* Effect.die(new InvalidReferenceError({
+				message: `Reference to stack '${refStack}' at stage '${refStage}' not found. Have you deployed stage '${refStage}' of '${refStack}'?`,
+				stack: refStack,
+				stage: refStage,
+				resourceId: refStack
+			}));
+			return output;
+		} else if (isNamedExpr(expr)) return yield* resolveOutput(expr.expr);
+		return yield* Effect.die(/* @__PURE__ */ new Error("Not implemented yet" + expr.kind));
 	});
 	const oldDownstreamDependencies = Object.fromEntries(oldResources.filter((resource) => !!resource).map((resource) => [resource.fqn, resource.downstream]));
 	const newResourceFqns = new Set(resources.map((r) => r.FQN));
-	const newUpstreamDependencies = Object.fromEntries(resources.map((resource) => [resource.FQN, Object.values(upstreamAny(resource.Props)).map((r) => r.FQN)]));
+	const newActionFqns = new Set(actions.map((t) => t.FQN));
+	const newNodeFqns = new Set([...newResourceFqns, ...newActionFqns]);
+	const newUpstreamDependencies = Object.fromEntries([...resources.map((resource) => [resource.FQN, Object.values(upstreamAny(resource.Props)).map((r) => r.FQN)]), ...actions.map((action) => [action.FQN, Object.values(upstreamAny(action.Input)).map((r) => r.FQN)])]);
 	const bindingUpstreamDependencies = Object.fromEntries(resources.map((resource) => [resource.FQN, Object.values(upstreamAny(stack.bindings[resource.FQN] ?? [])).map((r) => r.FQN)]));
-	const rawUpstreamDependencies = Object.fromEntries(resources.map((resource) => {
+	const rawUpstreamDependencies = Object.fromEntries([...resources.map((resource) => {
 		const fqn = resource.FQN;
 		const propDeps = newUpstreamDependencies[fqn] ?? [];
 		const bindDeps = bindingUpstreamDependencies[fqn] ?? [];
 		return [fqn, [...new Set([...propDeps, ...bindDeps])]];
-	}));
-	const allUpstreamDependencies = Object.fromEntries(resources.map((resource) => {
+	}), ...actions.map((action) => {
+		const fqn = action.FQN;
+		return [fqn, newUpstreamDependencies[fqn] ?? []];
+	})]);
+	const allUpstreamDependencies = Object.fromEntries([...resources.map((resource) => {
 		const fqn = resource.FQN;
-		return [fqn, (rawUpstreamDependencies[fqn] ?? []).filter((dep) => newResourceFqns.has(dep))];
-	}));
-	const newDownstreamDependencies = Object.fromEntries(resources.map((resource) => [resource.FQN, Object.entries(newUpstreamDependencies).filter(([_, upstream$1]) => upstream$1.includes(resource.FQN)).map(([depFqn]) => depFqn)]));
+		return [fqn, (rawUpstreamDependencies[fqn] ?? []).filter((dep) => newNodeFqns.has(dep))];
+	}), ...actions.map((action) => {
+		const fqn = action.FQN;
+		return [fqn, (newUpstreamDependencies[fqn] ?? []).filter((dep) => newNodeFqns.has(dep))];
+	})]);
+	const combinedCycleMembers = findCycleMembers(allUpstreamDependencies);
+	const computeDownstream = (upFqn) => {
+		const downstream = [];
+		for (const [downFqn, upstreams] of Object.entries(rawUpstreamDependencies)) {
+			if (downFqn === upFqn) continue;
+			if (!upstreams.includes(upFqn)) continue;
+			if ((newUpstreamDependencies[downFqn] ?? []).includes(upFqn)) {
+				downstream.push(downFqn);
+				continue;
+			}
+			if (combinedCycleMembers.has(upFqn) && combinedCycleMembers.has(downFqn)) continue;
+			downstream.push(downFqn);
+		}
+		return downstream;
+	};
+	const newDownstreamDependencies = Object.fromEntries([...resources.map((resource) => [resource.FQN, computeDownstream(resource.FQN)]), ...actions.map((action) => [action.FQN, computeDownstream(action.FQN)])]);
 	const resourceGraph = Object.fromEntries((yield* Effect.all(resources.map(Effect.fn("plan.diff.resource")(function* (resource) {
 		const provider = yield* findProviderByType(resource.Type);
 		const id = resource.LogicalId;
@@ -1098,11 +1242,12 @@ const make = (stack, options = {}) => Effect.gen(function* () {
 		const news = yield* resolveInput(resource.Props);
 		const downstream = newDownstreamDependencies[fqn] ?? [];
 		const newBindings = yield* resolveInput(stack.bindings[fqn] ?? []);
-		let oldState = yield* state.get({
+		const persisted = yield* state.get({
 			stack: stackName,
 			stage: stage$1,
 			fqn
 		});
+		let oldState = isActionState(persisted) ? void 0 : persisted;
 		let forceUpdateAfterAdoption = false;
 		if (oldState === void 0 && provider.read && isResolved(news)) {
 			const adoptInstanceId = yield* generateInstanceId();
@@ -1273,7 +1418,43 @@ const make = (stack, options = {}) => Effect.gen(function* () {
 			state: oldState
 		});
 	})), { concurrency: "unbounded" })).map((update) => [update.resource.FQN, update]));
-	const cycleMembers = findCycleMembers(allUpstreamDependencies);
+	const actionGraph = Object.fromEntries(yield* Effect.all(actions.map(Effect.fn("plan.diff.action")(function* (action) {
+		const fqn = action.FQN;
+		const downstream = newDownstreamDependencies[fqn] ?? [];
+		const inputHash = yield* hashInput(yield* resolveInput(action.Input));
+		const oldState = yield* state.get({
+			stack: stackName,
+			stage: stage$1,
+			fqn
+		});
+		if (oldState && !isActionState(oldState)) return [fqn, {
+			kind: "action",
+			action: "run",
+			def: action,
+			input: action.Input,
+			state: void 0,
+			downstream,
+			forced: false
+		}];
+		const prior = oldState;
+		if (prior?.status === "ran" && prior.inputHash === inputHash && !options.force) return [fqn, {
+			kind: "action",
+			action: "noop",
+			def: action,
+			state: prior,
+			downstream
+		}];
+		return [fqn, {
+			kind: "action",
+			action: "run",
+			def: action,
+			input: action.Input,
+			state: prior,
+			downstream,
+			forced: !!options.force
+		}];
+	})), { concurrency: "unbounded" }));
+	const cycleMembers = combinedCycleMembers;
 	{
 		const createReplaceNodes = new Set(Object.entries(resourceGraph).filter(([_, node]) => node.action === "create" || node.action === "replace").map(([fqn]) => fqn));
 		if (createReplaceNodes.size > 0) {
@@ -1301,16 +1482,47 @@ const make = (stack, options = {}) => Effect.gen(function* () {
 			}
 		}
 	}
+	const actionDeletions = Object.fromEntries((yield* Effect.all((yield* state.list({
+		stack: stackName,
+		stage: stage$1
+	})).map(Effect.fn("plan.diff.actionDeletion")(function* (fqn) {
+		if (newActionFqns.has(fqn) || newResourceFqns.has(fqn)) return;
+		const persisted = yield* state.get({
+			stack: stackName,
+			stage: stage$1,
+			fqn
+		});
+		if (!isActionState(persisted)) return;
+		const { logicalId } = parseFqn(fqn);
+		return [fqn, {
+			kind: "action",
+			action: "delete",
+			state: persisted,
+			downstream: persisted.downstream ?? [],
+			def: {
+				Kind: "action",
+				Namespace: persisted.namespace,
+				FQN: fqn,
+				LogicalId: logicalId,
+				Type: persisted.actionType,
+				Input: persisted.input,
+				Run: () => void 0,
+				Output: void 0
+			}
+		}];
+	})), { concurrency: "unbounded" })).filter((v) => !!v));
 	const deletions = Object.fromEntries((yield* Effect.all((yield* state.list({
 		stack: stackName,
 		stage: stage$1
 	})).map(Effect.fn("plan.diff.deletion")(function* (fqn) {
-		if (newResourceFqns.has(fqn)) return;
-		const oldState = yield* state.get({
+		if (newResourceFqns.has(fqn) || newActionFqns.has(fqn)) return;
+		const persisted = yield* state.get({
 			stack: stackName,
 			stage: stage$1,
 			fqn
 		});
+		if (isActionState(persisted)) return;
+		const oldState = persisted;
 		let attr = oldState?.attr;
 		if (oldState) {
 			const { logicalId } = parseFqn(fqn);
@@ -1363,7 +1575,9 @@ const make = (stack, options = {}) => Effect.gen(function* () {
 	}
 	return {
 		resources: resourceGraph,
+		actions: actionGraph,
 		deletions,
+		actionDeletions,
 		output: stack.output,
 		cycleMembers
 	};
@@ -1417,20 +1631,32 @@ const apply = (plan) => Effect.gen(function* () {
 	yield* session.done();
 	if (!plan.output) return;
 	const outputs = Object.fromEntries(Object.entries(tracker).map(([fqn, t]) => [fqn, t.output]));
-	return yield* evaluate(plan.output, outputs);
+	const resolved = yield* evaluate(plan.output, outputs);
+	yield* state.setOutput({
+		stack: stackName,
+		stage: stage$1,
+		value: resolved
+	});
+	return resolved;
 }).pipe(ensureArtifactStore, Effect.withSpan("apply", { attributes: {
 	"alchemy.resources.count": Object.keys(plan.resources).length,
 	"alchemy.deletions.count": Object.keys(plan.deletions).length
 } }));
 const executePlan = Effect.fnUntraced(function* (plan, tracker, terminalStatuses, session, state, stackName, stage$1) {
-	const ready = Object.fromEntries(yield* Effect.all(Object.keys(plan.resources).map((fqn) => Effect.map(Deferred.make(), (d) => [fqn, d]))));
+	const allNodes = {
+		...plan.resources,
+		...plan.actions
+	};
+	const ready = Object.fromEntries(yield* Effect.all(Object.keys(allNodes).map((fqn) => Effect.map(Deferred.make(), (d) => [fqn, d]))));
+	const readyStable = Object.fromEntries(yield* Effect.all(Object.keys(allNodes).map((fqn) => Effect.map(Deferred.make(), (d) => [fqn, d]))));
 	const getOutputs = () => Object.fromEntries(Object.entries(tracker).map(([fqn, t]) => [fqn, t.output]));
 	const waitForDeps = (fqns) => Effect.all(fqns.filter((fqn) => fqn in ready).map((fqn) => Deferred.await(ready[fqn])), { concurrency: "unbounded" });
+	const waitForStableDeps = (fqns) => Effect.all(fqns.filter((fqn) => fqn in readyStable).map((fqn) => Deferred.await(readyStable[fqn])), { concurrency: "unbounded" });
 	const failures = [];
-	yield* Effect.all(Object.entries(plan.resources).map(([fqn, node]) => executeNode(fqn, node, tracker, ready, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForDeps, failures, plan.cycleMembers.has(fqn))), { concurrency: "unbounded" });
+	yield* Effect.all(Object.entries(allNodes).map(([fqn, node]) => node.kind === "action" ? executeActionNode(fqn, node, tracker, ready, readyStable, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForStableDeps, failures) : executeNode(fqn, node, tracker, ready, readyStable, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForDeps, failures, plan.cycleMembers.has(fqn))), { concurrency: "unbounded" });
 	if (failures.length > 0) yield* Effect.failCause(failures.map((f) => f.cause).reduce(Cause.combine));
 });
-const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForDeps, failures, inCycle) => Effect.gen(function* () {
+const executeNode = (fqn, node, tracker, ready, readyStable, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForDeps, failures, inCycle) => Effect.gen(function* () {
 	const logicalId = node.resource.LogicalId;
 	const namespace = node.resource.Namespace;
 	const commit = (value) => state.set({
@@ -1464,11 +1690,13 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 		});
 	});
 	const signalReady = Deferred.succeed(ready[fqn], void 0);
+	const signalReadyStable = Deferred.succeed(readyStable[fqn], void 0);
 	const storeAndSignal = (t) => Effect.gen(function* () {
 		tracker[fqn] = t;
 		yield* signalReady;
 	});
 	if (node.action === "noop") {
+		yield* signalReadyStable;
 		yield* storeAndSignal({
 			output: node.state.attr,
 			props: node.state.props,
@@ -1604,6 +1832,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 				instanceId
 			};
 			yield* signalReady;
+			yield* signalReadyStable;
 			yield* markTerminal("created");
 			return;
 		}
@@ -1672,6 +1901,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 				instanceId
 			};
 			yield* signalReady;
+			yield* signalReadyStable;
 			yield* markTerminal("updated");
 			return;
 		}
@@ -1684,6 +1914,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 					instanceId
 				};
 				yield* signalReady;
+				yield* signalReadyStable;
 				yield* markTerminal("created");
 				return;
 			}
@@ -1778,6 +2009,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 				instanceId
 			};
 			yield* signalReady;
+			yield* signalReadyStable;
 			yield* markTerminal("created");
 			return;
 		}
@@ -1791,6 +2023,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 		cause
 	});
 	yield* Deferred.failCause(ready[fqn], cause);
+	yield* Deferred.failCause(readyStable[fqn], cause);
 	yield* session.emit({
 		kind: "status-change",
 		id: node.resource.LogicalId,
@@ -1803,6 +2036,104 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 	"alchemy.resource.logical_id": node.resource.LogicalId,
 	"alchemy.resource.action": node.action
 } }));
+const executeActionNode = (fqn, node, tracker, ready, readyStable, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForDeps, failures) => Effect.gen(function* () {
+	const task = node.def;
+	const logicalId = task.LogicalId;
+	const namespace = task.Namespace;
+	const commit = (value) => state.set({
+		stack: stackName,
+		stage: stage$1,
+		fqn,
+		value: {
+			...value,
+			namespace
+		}
+	});
+	const report = (status) => session.emit({
+		kind: "status-change",
+		id: logicalId,
+		type: task.Type,
+		status
+	});
+	const signalReady = Deferred.succeed(ready[fqn], void 0);
+	const signalReadyStable = Deferred.succeed(readyStable[fqn], void 0);
+	if (node.action === "noop") {
+		tracker[fqn] = {
+			output: node.state.output,
+			props: { __input: node.state.input },
+			bindings: [],
+			instanceId: fqn
+		};
+		yield* signalReady;
+		yield* signalReadyStable;
+		terminalStatuses.set(fqn, {
+			id: logicalId,
+			type: task.Type,
+			status: "skipped"
+		});
+		return;
+	}
+	yield* waitForDeps(Object.keys(resolveUpstream(node.input)).filter((f) => f in readyStable));
+	const outputs = getOutputs();
+	const resolvedInput = yield* evaluate(node.input, outputs);
+	const inputHashValue = yield* hashInput(resolvedInput);
+	yield* commit({
+		kind: "action",
+		status: "running",
+		fqn,
+		logicalId,
+		actionType: task.Type,
+		inputHash: inputHashValue,
+		input: resolvedInput,
+		downstream: node.downstream
+	});
+	yield* report("running");
+	const result = yield* task.Run(resolvedInput);
+	yield* commit({
+		kind: "action",
+		status: "ran",
+		fqn,
+		logicalId,
+		actionType: task.Type,
+		inputHash: inputHashValue,
+		input: resolvedInput,
+		output: result,
+		downstream: node.downstream
+	});
+	tracker[fqn] = {
+		output: result,
+		props: { __input: resolvedInput },
+		bindings: [],
+		instanceId: fqn
+	};
+	yield* signalReady;
+	yield* signalReadyStable;
+	terminalStatuses.set(fqn, {
+		id: logicalId,
+		type: task.Type,
+		status: "ran"
+	});
+}).pipe(Effect.catchCause((cause) => Effect.gen(function* () {
+	failures.push({
+		fqn,
+		logicalId: node.def.LogicalId,
+		type: node.def.Type,
+		cause
+	});
+	yield* Deferred.failCause(ready[fqn], cause);
+	yield* Deferred.failCause(readyStable[fqn], cause);
+	yield* session.emit({
+		kind: "status-change",
+		id: node.def.LogicalId,
+		type: node.def.Type,
+		status: "fail"
+	});
+})), Effect.withSpan("apply.action", { attributes: {
+	"alchemy.action.fqn": fqn,
+	"alchemy.action.type": node.def.Type,
+	"alchemy.action.logical_id": node.def.LogicalId,
+	"alchemy.action.verb": node.action
+} }));
 const converge = Effect.fnUntraced(function* (plan, tracker, terminalStatuses, session, state, stackName, stage$1) {
 	for (;;) {
 		let anyUpdated = false;
@@ -1869,6 +2200,61 @@ const converge = Effect.fnUntraced(function* (plan, tracker, terminalStatuses, s
 				status: "updated"
 			});
 		}
+		for (const [fqn, node] of Object.entries(plan.actions)) {
+			if (node.action !== "run") continue;
+			if (!tracker[fqn]) continue;
+			const outputs = Object.fromEntries(Object.entries(tracker).map(([k, t]) => [k, t.output]));
+			const newInput = yield* evaluate(node.input, outputs);
+			const newHash = yield* hashInput(newInput);
+			const oldInput = tracker[fqn].props?.__input;
+			if (newHash === (yield* hashInput(oldInput))) continue;
+			anyUpdated = true;
+			yield* state.set({
+				stack: stackName,
+				stage: stage$1,
+				fqn,
+				value: {
+					kind: "action",
+					status: "running",
+					fqn,
+					logicalId: node.def.LogicalId,
+					namespace: node.def.Namespace,
+					actionType: node.def.Type,
+					inputHash: newHash,
+					input: newInput,
+					downstream: node.downstream
+				}
+			});
+			const result = yield* node.def.Run(newInput);
+			yield* state.set({
+				stack: stackName,
+				stage: stage$1,
+				fqn,
+				value: {
+					kind: "action",
+					status: "ran",
+					fqn,
+					logicalId: node.def.LogicalId,
+					namespace: node.def.Namespace,
+					actionType: node.def.Type,
+					inputHash: newHash,
+					input: newInput,
+					output: result,
+					downstream: node.downstream
+				}
+			});
+			tracker[fqn] = {
+				output: result,
+				props: { __input: newInput },
+				bindings: [],
+				instanceId: fqn
+			};
+			terminalStatuses.set(fqn, {
+				id: node.def.LogicalId,
+				type: node.def.Type,
+				status: "ran"
+			});
+		}
 		if (!anyUpdated) break;
 	}
 });
@@ -1876,6 +2262,25 @@ const collectGarbage = Effect.fnUntraced(function* (plan, session) {
 	const state = yield* State;
 	const stackName = (yield* Stack).name;
 	const stage$1 = yield* Stage;
+	yield* Effect.all(Object.entries(plan.actionDeletions ?? {}).map(([fqn, node]) => node === void 0 ? Effect.void : Effect.gen(function* () {
+		yield* session.emit({
+			kind: "status-change",
+			id: node.def.LogicalId,
+			type: node.def.Type,
+			status: "deleting"
+		});
+		yield* state.delete({
+			stack: stackName,
+			stage: stage$1,
+			fqn
+		});
+		yield* session.emit({
+			kind: "status-change",
+			id: node.def.LogicalId,
+			type: node.def.Type,
+			status: "deleted"
+		});
+	})), { concurrency: "unbounded" });
 	const deleteGraph = Effect.fnUntraced(function* (deletionGraph) {
 		const deletions = {};
 		const deleteResource = (node, ancestors = /* @__PURE__ */ new Set()) => Effect.gen(function* () {
@@ -2030,10 +2435,10 @@ var __rewriteRelativeImportExtension = void 0 && (void 0).__rewriteRelativeImpor
 	return path$1;
 };
 const USER = Config.string("USER").pipe(Config.orElse(() => Config.string("USERNAME")), Config.withDefault("unknown"));
-const STAGE = Config.string("stage").pipe(Config.option, (a) => a.asEffect(), Effect.map(Option.getOrUndefined));
+const STAGE = Config.string("stage").pipe(Config.option, (a) => a, Effect.map(Option.getOrUndefined));
 const stage = Flag.string("stage").pipe(Flag.withSchema(S.String.check(S.isPattern(/^[a-z0-9]+([-_a-z0-9]+)*$/gi))), Flag.withDescription("Stage to deploy to, defaults to dev_${USER}"), Flag.optional, Flag.map(Option.getOrUndefined), Flag.mapEffect(Effect.fn(function* (stage$1) {
 	if (stage$1) return stage$1;
-	return yield* STAGE.pipe(Effect.catch(() => Effect.fail(new CliError.MissingOption({ option: "stage" }))), Effect.flatMap((s) => s === void 0 ? USER.asEffect().pipe(Effect.map((user) => `dev_${user}`), Effect.catch(() => Effect.succeed("unknown"))) : Effect.succeed(s)));
+	return yield* STAGE.pipe(Effect.catch(() => Effect.fail(new CliError.MissingOption({ option: "stage" }))), Effect.flatMap((s) => s === void 0 ? USER.pipe(Effect.map((user) => `dev_${user}`), Effect.catch(() => Effect.succeed("unknown"))) : Effect.succeed(s)));
 })));
 const envFile = Flag.file("env-file").pipe(Flag.optional, Flag.withDescription("File to load environment variables from, defaults to .env"));
 const dryRun = Flag.boolean("dry-run").pipe(Flag.withDescription("Dry run the deployment, do not actually deploy"), Flag.withDefault(false));
@@ -2096,7 +2501,7 @@ const stackSpanAttrs = (args) => ({
 const adopt = Flag.boolean("adopt").pipe(Flag.withDescription("Adopt pre-existing cloud resources that conflict with this stack instead of failing. Useful for re-importing infrastructure into a fresh state store."), Flag.withDefault(false));
 const execStack = Effect.fn(function* ({ main, stage: stage$1, envFile: envFile$1, profile: profile$1, dryRun: dryRun$1 = false, force: force$1 = false, yes: yes$1 = false, destroy = false, dev = false, adopt: adopt$1 = false }) {
 	const stackEffect = yield* importStack(main);
-	const services$1 = Layer.mergeAll(Layer.effect(AlchemyContext, AlchemyContext.asEffect().pipe(Effect.map((ctx) => ({
+	const services$1 = Layer.mergeAll(Layer.effect(AlchemyContext, AlchemyContext.pipe(Effect.map((ctx) => ({
 		...ctx,
 		dev,
 		adopt: adopt$1
@@ -2250,12 +2655,13 @@ const LoggingCli = Layer.succeed(Cli, Cli.of({
 
 //#endregion
 //#region lib/Cli/NamespaceTree.js
-function buildNamespaceTree(items) {
+function buildNamespaceTree(items, actions = []) {
 	const root = {
 		id: "",
 		path: [],
 		children: /* @__PURE__ */ new Map(),
-		resources: []
+		resources: [],
+		actions: []
 	};
 	const getNode = (path$1) => {
 		let current = root;
@@ -2267,7 +2673,8 @@ function buildNamespaceTree(items) {
 					id: segment,
 					path: path$1.slice(0, i + 1),
 					children: /* @__PURE__ */ new Map(),
-					resources: []
+					resources: [],
+					actions: []
 				};
 				current.children.set(segment, child);
 			}
@@ -2276,11 +2683,13 @@ function buildNamespaceTree(items) {
 		return current;
 	};
 	for (const item of items) getNode(toPath(item.resource.Namespace)).resources.push(item);
+	for (const action of actions) getNode(toPath(action.def.Namespace)).actions.push(action);
 	return root;
 }
 function deriveNamespaceAction(node) {
 	const actions = /* @__PURE__ */ new Set();
 	for (const resource of node.resources) actions.add(deriveResourceChildrenAction(resource, node));
+	for (const action of node.actions) actions.add(action.action === "run" ? "create" : action.action === "delete" ? "delete" : "noop");
 	for (const child of node.children.values()) {
 		const childAction = deriveNamespaceAction(child);
 		if (childAction === "mixed") return "mixed";
@@ -2333,8 +2742,17 @@ const flattenNamespace = (node, depth, result) => {
 		});
 		if (childNamespace) flattenNamespace(childNamespace, depth + 1, result);
 	}
+	const sortedActions = [...node.actions].sort((a, b) => a.def.LogicalId.localeCompare(b.def.LogicalId));
+	for (const action of sortedActions) result.push({
+		type: "action",
+		depth,
+		id: action.def.LogicalId,
+		path: [...node.path, action.def.LogicalId],
+		action: action.action,
+		actionType: action.def.Type
+	});
 };
-const isEmpty = (node) => node.resources.length === 0 && Array.from(node.children.values()).every(isEmpty);
+const isEmpty = (node) => node.resources.length === 0 && node.actions.length === 0 && Array.from(node.children.values()).every(isEmpty);
 const deriveResourceChildrenAction = (resource, node) => {
 	const actions = new Set([resource.action]);
 	for (const binding of resource.bindings) actions.add(binding.action);
@@ -2355,10 +2773,11 @@ const deriveAction = (actions) => {
 //#region lib/Cli/tui/components/Plan.js
 function Plan({ plan }) {
 	const items = useMemo(() => [...Object.values(plan.resources), ...Object.values(plan.deletions)], [plan]);
+	const taskItems = useMemo(() => [...Object.values(plan.actions ?? {}), ...Object.values(plan.actionDeletions ?? {})].filter((t) => t !== void 0), [plan]);
 	const flatItems = useMemo(() => {
-		return flattenTree(buildNamespaceTree(items));
-	}, [items]);
-	if (items.length === 0) return jsx(Text, {
+		return flattenTree(buildNamespaceTree(items, taskItems));
+	}, [items, taskItems]);
+	if (items.length === 0 && taskItems.length === 0) return jsx(Text, {
 		color: "gray",
 		children: "No changes planned"
 	});
@@ -2369,12 +2788,18 @@ function Plan({ plan }) {
 		noop: 0,
 		replace: 0
 	});
+	const taskCounts = taskItems.reduce((acc, item) => (acc[item.action]++, acc), {
+		run: 0,
+		noop: 0,
+		delete: 0
+	});
 	const actions = [
 		"create",
 		"update",
 		"delete",
 		"replace"
 	].filter((action) => counts[action] > 0);
+	const taskHeaderEntries = [taskCounts.run > 0 ? `${taskCounts.run} to run` : void 0, taskCounts.delete > 0 ? `${taskCounts.delete} to drop` : void 0].filter((s) => !!s);
 	return jsxs(Box, {
 		flexDirection: "column",
 		children: [jsxs(Box, {
@@ -2385,20 +2810,20 @@ function Plan({ plan }) {
 					children: "Plan"
 				}),
 				jsx(Text, { children: ": " }),
-				actions.flatMap((action, i) => {
+				[...actions.map((action) => {
 					const count = counts[action];
-					const color = actionColor(action);
-					if (count === 0) return [];
-					const box = jsx(Box, { children: jsxs(Text, {
-						color,
+					return jsx(Box, { children: jsxs(Text, {
+						color: actionColor(action),
 						children: [
 							count,
 							" to ",
 							action
 						]
 					}) }, action);
-					return i === actions.length - 1 ? [box] : [box, jsx(Text, { children: " | " }, `${action}-separator`)];
-				})
+				}), ...taskHeaderEntries.map((label, i) => jsx(Box, { children: jsx(Text, {
+					color: "cyan",
+					children: label
+				}) }, `task-${i}`))].flatMap((box, i, arr) => i === arr.length - 1 ? [box] : [box, jsx(Text, { children: " | " }, `sep-${i}`)])
 			]
 		}), jsx(Box, {
 			flexDirection: "column",
@@ -2442,6 +2867,41 @@ function Plan({ plan }) {
 						})
 					]
 				}, key);
+				if (item.type === "action") return jsxs(Box, {
+					flexDirection: "row",
+					children: [
+						jsx(Text, { children: indent }),
+						jsx(Box, {
+							width: 2,
+							children: jsxs(Text, {
+								color,
+								children: [icon, " "]
+							})
+						}),
+						jsx(Box, { children: jsx(Text, {
+							bold: true,
+							children: item.id
+						}) }),
+						jsx(Box, {
+							marginLeft: 1,
+							children: jsxs(Text, {
+								color: "blackBright",
+								children: [
+									"(",
+									item.actionType,
+									")"
+								]
+							})
+						}),
+						jsx(Box, {
+							marginLeft: 1,
+							children: jsx(Text, {
+								color: "cyan",
+								children: "[action]"
+							})
+						})
+					]
+				}, key);
 				return jsxs(Box, {
 					flexDirection: "row",
 					children: [
@@ -2491,7 +2951,8 @@ const getActionColor = (action) => ({
 	update: "yellow",
 	delete: "red",
 	replace: "magenta",
-	mixed: "cyan"
+	mixed: "cyan",
+	run: "cyan"
 })[action] ?? "gray";
 const getActionIcon = (action) => ({
 	create: "+",
@@ -2499,7 +2960,8 @@ const getActionIcon = (action) => ({
 	delete: "-",
 	noop: "•",
 	replace: "!",
-	mixed: "*"
+	mixed: "*",
+	run: "λ"
 })[action] ?? "?";
 const actionColor = (action) => getActionColor(action);
 
@@ -2542,29 +3004,40 @@ function ApprovePlan(props) {
 //#region lib/Cli/tui/components/PlanProgress.js
 const getTaskKey = (item) => item.path.join("/");
 const buildProgressRows = (plan) => {
-	return flattenTree(buildNamespaceTree([...Object.values(plan.resources), ...Object.values(plan.deletions).filter((item) => item !== void 0)])).filter((item) => item.type !== "binding").map((item) => item.type === "namespace" ? {
-		key: getTaskKey(item),
-		type: "namespace",
-		id: item.id,
-		depth: item.depth,
-		action: item.action
-	} : {
-		key: getTaskKey(item),
-		type: "resource",
-		id: item.id,
-		depth: item.depth,
-		resourceType: item.resourceType ?? "unknown",
-		action: item.action,
-		persistedApplyStatus: item.action === "noop" ? (() => {
-			const crud = findCrudByLogicalId(plan, item.id);
-			return crud?.action === "noop" ? crud.state.status : void 0;
-		})() : void 0
+	return flattenTree(buildNamespaceTree([...Object.values(plan.resources), ...Object.values(plan.deletions).filter((item) => item !== void 0)], [...Object.values(plan.actions ?? {}), ...Object.values(plan.actionDeletions ?? {})].filter((t) => t !== void 0))).filter((item) => item.type !== "binding").map((item) => {
+		if (item.type === "namespace") return {
+			key: getTaskKey(item),
+			type: "namespace",
+			id: item.id,
+			depth: item.depth,
+			action: item.action
+		};
+		if (item.type === "action") return {
+			key: getTaskKey(item),
+			type: "task",
+			id: item.id,
+			depth: item.depth,
+			actionType: item.actionType ?? "unknown",
+			action: item.action
+		};
+		return {
+			key: getTaskKey(item),
+			type: "resource",
+			id: item.id,
+			depth: item.depth,
+			resourceType: item.resourceType ?? "unknown",
+			action: item.action,
+			persistedApplyStatus: item.action === "noop" ? (() => {
+				const crud = findCrudByLogicalId(plan, item.id);
+				return crud?.action === "noop" ? crud.state.status : void 0;
+			})() : void 0
+		};
 	});
 };
 const buildLogicalIdIndex = (rows) => {
 	const index = /* @__PURE__ */ new Map();
 	for (const row of rows) {
-		if (row.type !== "resource") continue;
+		if (row.type !== "resource" && row.type !== "task") continue;
 		const keys = index.get(row.id);
 		if (keys) keys.push(row.key);
 		else index.set(row.id, [row.key]);
@@ -2587,7 +3060,13 @@ function toPlanTask(rowOrId, planItem) {
 		updatedAt: Date.now()
 	};
 }
-const buildInitialTasks = (rows) => new Map(rows.flatMap((row) => row.type === "resource" ? [[row.key, toPlanTask(row)]] : []));
+const buildInitialTasks = (rows) => new Map(rows.flatMap((row) => row.type === "resource" ? [[row.key, toPlanTask(row)]] : row.type === "task" ? [[row.key, {
+	key: row.key,
+	id: row.id,
+	type: row.actionType,
+	status: row.action === "noop" ? "skipped" : "pending",
+	updatedAt: Date.now()
+}]] : []));
 function PlanProgress(props) {
 	const { source, plan } = props;
 	const spinner = useGlobalSpinner();
@@ -2654,6 +3133,56 @@ function PlanProgress(props) {
 					})
 				]
 			}, row.key);
+			if (row.type === "task") {
+				const t = tasks.get(row.key);
+				const status = t?.status ?? (row.action === "noop" ? "ran" : "pending");
+				const color$1 = statusColor(status);
+				const icon$1 = taskIcon(row.action, status, spinner);
+				const label = row.action === "delete" ? status === "deleted" ? "deleted" : "drop" : status === "ran" ? row.action === "noop" ? "skip" : "ran" : status === "running" ? "running" : status === "fail" ? "fail" : row.action === "noop" ? "skip" : "run";
+				return jsxs(Box, {
+					flexDirection: "column",
+					children: [jsxs(Box, {
+						flexDirection: "row",
+						children: [
+							jsx(Text, { children: indent }),
+							jsx(Box, {
+								width: 2,
+								children: jsxs(Text, {
+									color: color$1,
+									children: [icon$1, " "]
+								})
+							}),
+							jsx(Text, {
+								bold: true,
+								children: row.id
+							}),
+							jsxs(Text, {
+								dimColor: true,
+								children: [
+									" (",
+									row.actionType,
+									")"
+								]
+							}),
+							jsxs(Text, {
+								color: color$1,
+								children: [" ", label]
+							}),
+							jsxs(Text, {
+								color: "cyan",
+								dimColor: true,
+								children: [" ", "[action]"]
+							})
+						]
+					}), t?.message ? jsx(Box, {
+						paddingLeft: row.depth * 2 + 2,
+						children: jsxs(Text, {
+							dimColor: true,
+							children: ["• ", t.message]
+						})
+					}) : null]
+				}, row.key);
+			}
 			const task = tasks.get(row.key) ?? toPlanTask(row);
 			const displayStatus = getDisplayStatus(row, task.status);
 			const color = statusColor(displayStatus);
@@ -2713,17 +3242,30 @@ function statusColor(status) {
 		case "updated": return "yellow";
 		case "deleting":
 		case "deleted": return "red";
+		case "running":
+		case "ran": return "cyan";
+		case "skipped": return "gray";
 		case "fail": return "redBright";
 		default: return;
 	}
 }
+function taskIcon(action, status, spinnerChar) {
+	if (status === "running") return spinnerChar;
+	if (status === "fail") return "✗";
+	if (status === "skipped") return "•";
+	if (status === "ran") return action === "noop" ? "•" : "✓";
+	if (status === "deleted") return "✓";
+	if (action === "delete") return "-";
+	if (action === "noop") return "•";
+	return "λ";
+}
 function statusIcon(status, spinnerChar) {
 	if (isInProgress(status)) return spinnerChar;
 	if (status === "fail") return "✗";
 	return "✓";
 }
 function isInProgress(status) {
-	return status === "pending" || status === "creating" || status === "updating" || status === "deleting";
+	return status === "pending" || status === "creating" || status === "updating" || status === "deleting" || status === "running";
 }
 const spinnerFrames = [
 	"⠋",