alchemy 2.0.0-beta.3 → 2.0.0-beta.31

package/bin/exec.js

@@ -0,0 +1,2625 @@
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as S from "effect/Schema";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as EffectContext from "effect/Context";
+import * as FileSystem from "effect/FileSystem";
+import * as Path$1 from "effect/Path";
+import { Path } from "effect/Path";
+import * as Console from "effect/Console";
+import * as Logger from "effect/Logger";
+import * as Option from "effect/Option";
+import * as Command from "effect/unstable/cli/Command";
+import * as Flag from "effect/unstable/cli/Flag";
+import * as Data from "effect/Data";
+import * as Cause from "effect/Cause";
+import * as Deferred from "effect/Deferred";
+import { pipe } from "effect/Function";
+import * as Redacted from "effect/Redacted";
+import { SingleShotGen } from "effect/Utils";
+import { pipeArguments } from "effect/Pipeable";
+import path from "pathe";
+import * as Config from "effect/Config";
+import os from "node:os";
+import * as Duration from "effect/Duration";
+import * as Exit from "effect/Exit";
+import * as Metric from "effect/Metric";
+import * as Argument from "effect/unstable/cli/Argument";
+import * as CliError from "effect/unstable/cli/CliError";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Box, Text, render, useApp, useInput } from "ink";
+import { useEffect, useMemo, useRef, useState } from "react";
+
+//#region lib/AlchemyContext.js
+var AlchemyContext = class extends EffectContext.Service()("alchemy/Context") {};
+const AlchemyContextLive = Layer.effect(AlchemyContext, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const dir = (yield* Path$1.Path).join(process.cwd(), ".alchemy");
+	yield* fs.makeDirectory(dir, { recursive: true });
+	return {
+		dotAlchemy: dir,
+		updateStateStore: false,
+		dev: false,
+		adopt: false
+	};
+}));
+
+//#endregion
+//#region lib/Util/PlatformServices.js
+const isBun = typeof Bun !== "undefined";
+const PlatformServices = Effect.promise(async () => {
+	if (isBun) {
+		const [BunServices, BunSocket] = await Promise.all([import("@effect/platform-bun/BunServices"), import("@effect/platform-bun/BunSocket")]);
+		return Layer.merge(BunServices.layer, BunSocket.layerWebSocketConstructor);
+	} else {
+		const [NodeServices, NodeSocket] = await Promise.all([import("@effect/platform-node/NodeServices"), import("@effect/platform-node/NodeSocket")]);
+		return Layer.merge(NodeServices.layer, NodeSocket.layerWebSocketConstructor);
+	}
+}).pipe(Layer.unwrap);
+const runMain = (effect, options) => {
+	if (isBun) import("@effect/platform-bun/BunRuntime").then((BunRuntime) => BunRuntime.runMain(effect, options));
+	else import("@effect/platform-node/NodeRuntime").then((NodeRuntime) => NodeRuntime.runMain(effect, options));
+};
+
+//#endregion
+//#region lib/AdoptPolicy.js
+/**
+* AdoptPolicy controls whether the engine should "adopt" pre-existing cloud
+* resources that conflict with this stack instead of failing.
+*
+* The engine always calls a provider's `read` lifecycle operation when there
+* is no prior state and `read` is implemented. The provider's job is to
+* report two things:
+*
+*   1. Whether the resource exists (returns attributes vs. `undefined`).
+*   2. Whether *we* own it (plain attributes vs. {@link Unowned}-branded).
+*
+* The engine then routes:
+*
+*   | `read` outcome      | `adopt: false` | `adopt: true`     |
+*   | ------------------- | -------------- | ----------------- |
+*   | undefined           | create         | create            |
+*   | owned (plain attrs) | silent adopt   | silent adopt      |
+*   | {@link Unowned}     | fail           | takeover (adopt)  |
+*
+* "Owned" means a provider has affirmatively determined the resource was
+* created by this stack/stage/logical-id (typically by inspecting tags or
+* naming conventions). Resources without ownership semantics simply always
+* return plain attrs — they are treated as owned by default, so silent
+* adoption is the norm and `--adopt` is unnecessary.
+*
+* The policy can be overridden per-effect via {@link adopt} — most commonly
+* applied at the resource or stack scope.
+*/
+var AdoptPolicy = class extends EffectContext.Service()("AdoptPolicy") {};
+/**
+* Engine-raised failure produced when `read` reports an existing resource
+* marked as {@link Unowned} and `adopt` is `false`. Surface this to the user
+* to indicate they should either re-tag the cloud resource, pick a different
+* physical name, or re-run with `--adopt` (or `adopt(true)`) to force a
+* takeover.
+*/
+var OwnedBySomeoneElse = class extends Data.TaggedError("OwnedBySomeoneElse") {};
+/**
+* Private symbol used to brand attribute objects returned by `read` as
+* "exists in cloud, but not owned by this stack/stage/logical-id".
+*
+* Deliberately *not* registered via `Symbol.for` — the brand is an
+* engine-internal routing hint and must not be observable or
+* forgeable from outside this module. The engine strips it before any
+* state persistence (see {@link stripUnowned}) so it never leaks into
+* the state store, JSON serialization, or downstream `Output`s.
+*/
+const UnownedTag = Symbol("alchemy/Unowned");
+/**
+* Brand a `read` return value as belonging to a different owner.
+*
+* Use this in a provider's `read` implementation when the resource exists in
+* the cloud but a positive ownership check (e.g. tag inspection) shows it
+* was *not* created by this stack/stage/logical-id:
+*
+* ```ts
+* read: Effect.fnUntraced(function* ({ id, output, olds }) {
+*   const settings = yield* getScriptSettings({ ... }).pipe(
+*     Effect.catchTag("WorkerNotFound", () => Effect.succeed(undefined)),
+*   );
+*   if (!settings) return undefined;
+*
+*   const attrs = { workerName, ...buildAttrs(settings) };
+*   return hasAlchemyWorkerTags(id, settings.tags) ? attrs : Unowned(attrs);
+* }),
+* ```
+*
+* The returned value is structurally still `T` — there is no wrapper to
+* unwrap. The brand is a non-enumerable symbol that the engine inspects
+* during planning to decide whether to take over (`adopt: true`) or fail
+* loudly (`adopt: false`).
+*
+* Resources without ownership semantics should simply return plain attrs —
+* the engine treats them as owned and silent adoption is the default.
+*/
+const Unowned = Object.assign((attrs) => {
+	const cloned = { ...attrs };
+	Object.defineProperty(cloned, UnownedTag, {
+		value: true,
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	return cloned;
+}, { is: (value) => typeof value === "object" && value !== null && value[UnownedTag] === true });
+/**
+* Strip the {@link Unowned} brand from an attributes object before persisting
+* it — state should not carry per-deploy ownership-routing metadata.
+*
+* The brand is intentionally non-enumerable, so a plain spread already
+* drops it; the additional `delete` is defense-in-depth in case a future
+* change makes the descriptor enumerable. Always returns a fresh object
+* (never mutates the input).
+*/
+const stripUnowned = (attrs) => {
+	const out = { ...attrs };
+	if (UnownedTag in out) delete out[UnownedTag];
+	return out;
+};
+
+//#endregion
+//#region lib/Artifacts.js
+/**
+* Per-resource in-memory artifacts shared across a single `Plan.make -> apply`
+* execution.
+*
+* The engine scopes this service by resource `FQN` before invoking lifecycle
+* handlers, so providers should treat it as a resource-local bag for expensive,
+* deterministic intermediate results that can be reused across phases.
+*
+* Expected usage:
+*
+* - `diff` computes an expensive artifact once and stores it
+* - `create` / `update` reads the same artifact and skips recomputing it
+* - artifacts are ephemeral and must never be required for correctness on a
+*   later deploy because the bag is reset between runs
+*
+* Example:
+*
+* ```ts
+* const artifacts = yield* Artifacts;
+* const cached = yield* artifacts.get<PreparedBundle>("bundle");
+* if (cached) return cached;
+*
+* const bundle = yield* prepareBundle();
+* yield* artifacts.set("bundle", bundle);
+* return bundle;
+* ```
+*/
+var Artifacts = class extends EffectContext.Service()("Artifacts") {};
+var ArtifactStore = class extends EffectContext.Service()("Artifacts/Store") {};
+/**
+* Create a fresh root store for one deploy/test run.
+*/
+const createArtifactStore = () => /* @__PURE__ */ new Map();
+const getOrCreateBag = (store, fqn) => {
+	const existing = store.get(fqn);
+	if (existing) return existing;
+	const bag = /* @__PURE__ */ new Map();
+	store.set(fqn, bag);
+	return bag;
+};
+const makeScopedArtifacts = (store, fqn) => {
+	const bag = getOrCreateBag(store, fqn);
+	return {
+		get: (key) => Effect.sync(() => bag.get(key)),
+		set: (key, value) => Effect.sync(() => {
+			bag.set(key, value);
+		}),
+		delete: (key) => Effect.sync(() => {
+			bag.delete(key);
+		})
+	};
+};
+/**
+* Ensure an artifact root exists, reusing the ambient store when one is already
+* present. This lets nested helpers participate in the same run-scoped cache.
+*/
+const ensureArtifactStore = (effect) => Effect.serviceOption(ArtifactStore).pipe(Effect.map(Option.getOrUndefined), Effect.flatMap((existing) => effect.pipe(Effect.provideService(ArtifactStore, existing ?? createArtifactStore()))));
+
+//#endregion
+//#region lib/Cli/Cli.js
+var Cli = class extends EffectContext.Service()("CLI") {};
+
+//#endregion
+//#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;
+};
+
+//#endregion
+//#region lib/FQN.js
+/**
+* Separator used in FQN strings.
+*/
+const FQN_SEPARATOR = "/";
+/**
+* Convert a NamespaceNode chain to an array of namespace IDs, from root to leaf.
+*
+* @example
+* ```ts
+* const ns = { Id: "Child", Parent: { Id: "Parent", Parent: { Id: "Root" } } };
+* toPath(ns); // ["Root", "Parent", "Child"]
+* ```
+*/
+const toPath = (ns) => {
+	if (!ns) return [];
+	const path$1 = [];
+	let current = ns;
+	while (current) {
+		path$1.unshift(current.Id);
+		current = current.Parent;
+	}
+	return path$1;
+};
+/**
+* Create a fully-qualified name (FQN) from a namespace and logical ID.
+* The FQN is a flat key suitable for state storage.
+*
+* @example
+* ```ts
+* const ns = { Id: "Child", Parent: { Id: "Parent" } };
+* toFqn(ns, "MyResource"); // "Parent/Child/MyResource"
+* toFqn(undefined, "MyResource"); // "MyResource"
+* ```
+*/
+const toFqn = (ns, logicalId) => {
+	const path$1 = toPath(ns);
+	path$1.push(logicalId);
+	return path$1.join(FQN_SEPARATOR);
+};
+/**
+* Parse an FQN back into namespace path segments and the logical ID.
+*
+* @example
+* ```ts
+* parseFqn("Parent/Child/MyResource"); // { path: ["Parent", "Child"], logicalId: "MyResource" }
+* parseFqn("MyResource"); // { path: [], logicalId: "MyResource" }
+* ```
+*/
+const parseFqn = (fqn) => {
+	const parts = fqn.split(FQN_SEPARATOR);
+	return {
+		path: parts,
+		logicalId: parts.pop()
+	};
+};
+
+//#endregion
+//#region lib/Provider.js
+const Provider = (type) => EffectContext.Service()(type);
+const isProviderCollectionService = (value) => {
+	return typeof value === "object" && value !== null && "kind" in value && value.kind === "ProviderCollection";
+};
+const findProviderByType = (type) => tryFindProviderByType(type).pipe(Effect.flatMap(Option.match({
+	onNone: () => Effect.die(`Provider not found for ${type}`),
+	onSome: (provider) => Effect.succeed(provider)
+})));
+const tryFindProviderByType = Effect.fnUntraced(function* (resourceType) {
+	const Tag = Provider(resourceType);
+	const direct = yield* Effect.serviceOption(Tag);
+	if (Option.isSome(direct)) return direct;
+	const context = yield* Effect.context();
+	for (const value of context.mapUnsafe.values()) if (isProviderCollectionService(value)) {
+		const provider = value.get(resourceType);
+		if (provider) return Option.some(provider);
+	}
+	return Option.none();
+});
+
+//#endregion
+//#region lib/Util/service.js
+const GenericService = () => (Kind) => {
+	const service = EffectContext.Service(Kind);
+	const make$2 = (Type) => EffectContext.Service(`${Kind}<${Type}>`);
+	return Object.assign(Object.setPrototypeOf(make$2, service), service);
+};
+
+//#endregion
+//#region lib/Auth/Profile.js
+const rootDir = path.join(os.homedir(), ".alchemy");
+const configFilePath = path.join(rootDir, "profiles.json");
+/**
+* Config key consulted by the various `fromAuthProvider` /
+* `fromEnvironment` layers to pick which named profile in
+* `~/.alchemy/profiles.json` to use. Defaults to `"default"`.
+*/
+const ALCHEMY_PROFILE = Config.string("ALCHEMY_PROFILE").pipe(Config.withDefault("default"));
+const CONFIG_VERSION = 0;
+const emptyConfig = () => ({
+	version: CONFIG_VERSION,
+	profiles: {}
+});
+const readConfig = FileSystem.FileSystem.asEffect().pipe(Effect.flatMap((fs) => fs.readFileString(configFilePath)), Effect.flatMap((data) => Effect.try({
+	try: () => {
+		const parsed = JSON.parse(data);
+		if (parsed?.version !== CONFIG_VERSION) return emptyConfig();
+		return parsed;
+	},
+	catch: emptyConfig
+})), Effect.orElseSucceed(emptyConfig));
+/**
+* Returns a `ConfigProvider` that overrides `ALCHEMY_PROFILE` with the
+* given `profile` (when explicitly passed via the CLI `--profile` flag),
+* falling through to `base` for everything else.
+*
+* Use this to let the CLI's `--profile <name>` win over `$ALCHEMY_PROFILE`
+* without disturbing other config lookups.
+*/
+const withProfileOverride = (base, profile$1) => {
+	if (profile$1 === void 0) return base;
+	const overrides = { ALCHEMY_PROFILE: profile$1 };
+	const overrideProvider = ConfigProvider.make((path$1) => Effect.succeed(path$1.length === 1 && typeof path$1[0] === "string" && path$1[0] in overrides ? ConfigProvider.makeValue(overrides[path$1[0]]) : void 0));
+	return ConfigProvider.orElse(base)(overrideProvider);
+};
+
+//#endregion
+//#region lib/Auth/AuthProvider.js
+var AuthProviders = class extends EffectContext.Service()("AuthProviders") {};
+
+//#endregion
+//#region lib/Stage.js
+var Stage = class extends EffectContext.Service()("Stage") {};
+
+//#endregion
+//#region lib/Util/ConfigProvider.js
+const loadConfigProvider = (envFile$1) => {
+	if (Option.isSome(envFile$1)) return ConfigProvider.fromDotEnv({ path: envFile$1.value }).pipe(Effect.map((dotEnv) => ConfigProvider.orElse(dotEnv, ConfigProvider.fromEnv())));
+	return Effect.gen(function* () {
+		if (!(yield* (yield* FileSystem.FileSystem).exists(".env"))) return ConfigProvider.fromEnv();
+		return ConfigProvider.orElse(yield* ConfigProvider.fromDotEnv({ path: ".env" }), ConfigProvider.fromEnv());
+	});
+};
+
+//#endregion
+//#region lib/Util/effect.js
+const taggedFunction = (tag, fn) => {
+	const overrides = {
+		asEffect: () => tag.asEffect(),
+		[Symbol.iterator]: () => tag[Symbol.iterator](),
+		pipe: (...fns) => pipeArguments(tag.asEffect(), fns),
+		toString: () => `${tag.toString()}.${fn.name}`
+	};
+	return new Proxy(fn, {
+		get: (target, prop, receiver) => Reflect.has(overrides, prop) ? Reflect.get(overrides, prop, receiver) : Reflect.has(target, prop) ? Reflect.get(target, prop, receiver) : Reflect.get(tag, prop, tag),
+		has: (target, prop) => Reflect.has(overrides, prop) || Reflect.has(target, prop) || Reflect.has(tag, prop)
+	});
+};
+
+//#endregion
+//#region lib/Util/FileLogger.js
+const fileLogger = Effect.fnUntraced(function* (...segments) {
+	const { dotAlchemy } = yield* AlchemyContext;
+	const fs = yield* FileSystem.FileSystem;
+	const path$1 = yield* Path;
+	const logFile = path$1.join(dotAlchemy, "log", ...segments);
+	yield* fs.makeDirectory(path$1.dirname(logFile), { recursive: true });
+	return yield* Logger.formatLogFmt.pipe(Logger.toFile(logFile, { flag: "a" }));
+});
+
+//#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 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 ?? {
+		name: options.name,
+		stage: stage$1,
+		resources: {},
+		bindings: {}
+	})))), Layer.buildWithScope(scope));
+}), Effect.flatMap((context) => Effect.all([
+	effect,
+	Stack.asEffect(),
+	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 platform = Layer.mergeAll(PlatformServices, FetchHttpClient.layer, Logger.layer([fileLogger("out")], { mergeWithExisting: true }));
+
+//#endregion
+//#region lib/Resource.js
+const isResource = (value) => {
+	return typeof value === "object" && value !== null && "Type" in value;
+};
+
+//#endregion
+//#region lib/RuntimeContext.js
+/**
+* Context of the runtime environment.
+*
+* E.g. the context of a running Worker, Task, Process, Function
+*/
+const RuntimeContext = GenericService()("Alchemy::RuntimeContext");
+const CurrentRuntimeContext = Effect.serviceOption(RuntimeContext).pipe(Effect.map(Option.getOrUndefined));
+
+//#endregion
+//#region lib/State/State.js
+var State = class extends EffectContext.Service()("alchemy/State") {};
+
+//#endregion
+//#region lib/Util/data.js
+const isPrimitive = (value) => value === void 0 || value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string" || typeof value === "symbol" || typeof value === "bigint";
+
+//#endregion
+//#region lib/Output.js
+const inspect = Symbol.for("nodejs.util.inspect.custom");
+const of = (resource) => {
+	if (isRef(resource)) {
+		const metadata = getRefMetadata(resource);
+		return new RefExpr(metadata.stack, metadata.stage, metadata.id);
+	}
+	return new ResourceExpr(resource);
+};
+const isOutput = (value) => value && (typeof value === "object" || typeof value === "function") && ExprSymbol in value;
+const ExprSymbol = Symbol.for("alchemy/Expr");
+const isExpr = (value) => value && (typeof value === "object" || typeof value === "function") && ExprSymbol in value;
+var BaseExpr = class {
+	constructor() {}
+	as() {
+		return this;
+	}
+	[Symbol.iterator]() {
+		return new SingleShotGen(this);
+	}
+	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))));
+	}
+	pipe(...fns) {
+		return pipe(this, ...fns);
+	}
+	toString() {
+		return this[inspect]();
+	}
+};
+const isResourceExpr = (node) => node?.kind === "ResourceExpr";
+var ResourceExpr = class extends BaseExpr {
+	src;
+	stables;
+	kind = "ResourceExpr";
+	constructor(src, stables) {
+		super();
+		this.src = src;
+		this.stables = stables;
+		return proxy(this);
+	}
+	[inspect]() {
+		return this.src.LogicalId;
+	}
+};
+const isPropExpr = (node) => node?.kind === "PropExpr";
+var PropExpr = class extends BaseExpr {
+	expr;
+	identifier;
+	kind = "PropExpr";
+	constructor(expr, identifier) {
+		super();
+		this.expr = expr;
+		this.identifier = identifier;
+		return proxy(this);
+	}
+	[inspect]() {
+		return `${this.expr[inspect]()}.${this.identifier.toString()}`;
+	}
+};
+const isLiteralExpr = (node) => node?.kind === "LiteralExpr";
+var LiteralExpr = class extends BaseExpr {
+	value;
+	kind = "LiteralExpr";
+	constructor(value) {
+		super();
+		this.value = value;
+		return proxy(this);
+	}
+	[inspect]() {
+		return String(this.value);
+	}
+};
+const VoidExpr = new LiteralExpr(void 0);
+const isApplyExpr = (node) => node?.kind === "ApplyExpr";
+var ApplyExpr = class extends BaseExpr {
+	expr;
+	f;
+	kind = "ApplyExpr";
+	constructor(expr, f) {
+		super();
+		this.expr = expr;
+		this.f = f;
+		return proxy(this);
+	}
+	[inspect]() {
+		return `${this.expr[inspect]()}.map(${this.f.toString()})`;
+	}
+};
+const isEffectExpr = (node) => node?.kind === "EffectExpr";
+var EffectExpr = class extends BaseExpr {
+	expr;
+	f;
+	kind = "EffectExpr";
+	constructor(expr, f) {
+		super();
+		this.expr = expr;
+		this.f = f;
+		return proxy(this);
+	}
+	[inspect]() {
+		return `${this.expr[inspect]()}.mapEffect(${this.f.toString()})`;
+	}
+};
+const isAllExpr = (node) => node?.kind === "AllExpr";
+var AllExpr = class extends BaseExpr {
+	outs;
+	kind = "AllExpr";
+	constructor(outs) {
+		super();
+		this.outs = outs;
+		return proxy(this);
+	}
+	[inspect]() {
+		return `all(${this.outs.map((out) => out[inspect]()).join(", ")})`;
+	}
+};
+const isRefExpr = (node) => node?.kind === "RefExpr";
+var RefExpr = class extends BaseExpr {
+	stack;
+	stage;
+	resourceId;
+	kind = "RefExpr";
+	constructor(stack, stage$1, resourceId) {
+		super();
+		this.stack = stack;
+		this.stage = stage$1;
+		this.resourceId = resourceId;
+		return proxy(this);
+	}
+	[inspect]() {
+		return `ref(${this.resourceId}, { stack: ${this.stack}, stage: ${this.stage} })`;
+	}
+};
+function proxy(self) {
+	const target = Object.assign(() => {}, self);
+	if (inspect in self) Object.defineProperty(target, inspect, {
+		value: self[inspect].bind(self),
+		configurable: true
+	});
+	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),
+		apply: (_, thisArg, args) => {
+			if (isPropExpr(self)) {
+				if (self.identifier === "apply") return new ApplyExpr(self.expr, args[0]);
+				else if (self.identifier === "effect") return new EffectExpr(self.expr, args[0]);
+			}
+		}
+	});
+	return proxy$1;
+}
+var MissingSourceError = class extends Data.TaggedError("MissingSourceError") {};
+var InvalidReferenceError = class extends Data.TaggedError("InvalidReferenceError") {};
+const evaluate = (expr, upstream$1) => Effect.gen(function* () {
+	if (isResource(expr)) {
+		const srcId = expr.FQN;
+		const src = upstream$1[srcId];
+		if (!src) return yield* new MissingSourceError({
+			message: `Source ${srcId} not found`,
+			srcId
+		});
+		return src;
+	} else if (isOutput(expr)) {
+		if (isResourceExpr(expr)) {
+			const srcId = expr.src.FQN;
+			const src = upstream$1[srcId];
+			if (!src) return yield* new MissingSourceError({
+				message: `Source ${srcId} not found`,
+				srcId
+			});
+			return src;
+		} else if (isLiteralExpr(expr)) return expr.value;
+		else if (isApplyExpr(expr)) return expr.f(yield* evaluate(expr.expr, upstream$1));
+		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 (isRefExpr(expr)) {
+			const state = yield* State;
+			const stack = expr.stack ?? (yield* Stack).name;
+			const stage$1 = expr.stage ?? (yield* Stage);
+			const resource = yield* state.get({
+				stack,
+				stage: stage$1,
+				fqn: expr.resourceId
+			});
+			if (!resource) return yield* Effect.fail(new InvalidReferenceError({
+				message: `Reference to '${expr.resourceId}' in stack '${stack}' and stage '${stage$1}' not found. Have you deployed '${stage$1}' or '${stack}'?`,
+				stack,
+				stage: stage$1,
+				resourceId: expr.resourceId
+			}));
+			return resource.attr;
+		}
+	}
+	if (Array.isArray(expr)) return yield* Effect.all(expr.map((item) => evaluate(item, upstream$1)));
+	else if (Redacted.isRedacted(expr)) return expr;
+	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 (isResource(value)) return { [value.FQN]: value };
+	else 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) => {
+	if (isResource(expr)) return { [expr.FQN]: 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 (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 {};
+};
+const resolveUpstream = (value) => {
+	if (isPrimitive(value)) return {};
+	else if (isResource(value)) return { [value.FQN]: value };
+	else if (isOutput(value)) return upstream(value);
+	else if (Array.isArray(value)) return Object.fromEntries(value.map((v) => resolveUpstream(v)).flatMap(Object.entries));
+	else if (typeof value === "object" || typeof value === "function") return Object.fromEntries(Object.values(value).map(resolveUpstream).flatMap(Object.entries));
+	return {};
+};
+const toObject = (acc, v) => ({
+	...acc,
+	...v
+});
+
+//#endregion
+//#region lib/Diff.js
+const isResolved = (value) => !_hasUnresolved(value);
+const _hasUnresolved = (value) => {
+	if (value == null || isPrimitive(value)) return false;
+	if (isExpr(value) || Effect.isEffect(value)) return true;
+	if (Array.isArray(value)) return value.some(_hasUnresolved);
+	if (typeof value === "object") return Object.values(value).some(_hasUnresolved);
+	return false;
+};
+const havePropsChanged = (oldProps, newProps) => hasOutputs(newProps) || JSON.stringify(canonicalize(oldProps ?? {})) !== JSON.stringify(canonicalize(newProps ?? {}));
+const canonicalize = (value) => {
+	if (Array.isArray(value)) return value.map(canonicalize);
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, nested]) => [key, canonicalize(nested)]));
+	return value;
+};
+const diffBindings = (oldBindings, newBindings) => {
+	const oldMap = new Map(oldBindings.map((b) => [b.sid, b]));
+	const newMap = new Map(newBindings.map((b) => [b.sid, b]));
+	return [...Array.from(oldMap).filter(([sid]) => !newMap.has(sid)).map(([sid, old]) => ({
+		sid,
+		action: "delete",
+		data: old.data
+	})), ...Array.from(newMap).map(([sid, binding]) => {
+		const old = oldMap.get(sid);
+		return {
+			sid,
+			action: !old ? "create" : havePropsChanged(old.data, binding.data) ? "update" : "noop",
+			data: binding.data
+		};
+	})];
+};
+
+//#endregion
+//#region lib/InstanceId.js
+/** A 16-byte (128-bit) random hex-encoded string representing an physical instance of a logical resource */
+var InstanceId = class extends EffectContext.Service()("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 lib/Util/types.js
+const asEffect = (effect) => Effect.isEffect(effect) ? effect : Effect.succeed(effect);
+
+//#endregion
+//#region lib/Telemetry/Metrics.js
+/**
+* Counter for resource lifecycle operations. Tagged per call with
+* `resource_type`, `op` (`precreate`/`create`/`update`/`delete`/`read`),
+* and `status` (`success`/`error`).
+*/
+const resourceCounter = Metric.counter("alchemy.resource.operations", {
+	description: "Number of resource lifecycle operations dispatched by alchemy apply.",
+	incremental: true
+});
+/**
+* Histogram of how long each lifecycle operation takes.
+*/
+const resourceDuration = Metric.timer("alchemy.resource.duration", { description: "Wall-clock duration of resource lifecycle operations dispatched by alchemy apply." });
+/**
+* Counter for CLI command invocations.
+*/
+const cliCounter = Metric.counter("alchemy.cli.invocations", {
+	description: "Number of alchemy CLI command invocations.",
+	incremental: true
+});
+/**
+* Counter for Cloudflare State Store bootstrap/deploy operations.
+* Tagged per call with `op` (e.g. `deploy`) and `status`
+* (`success`/`error`) so that the deploy success rate of the
+* state store itself can be tracked separately from regular
+* resource lifecycle ops.
+*/
+const stateStoreCounter = Metric.counter("alchemy.state_store.operations", {
+	description: "Number of Cloudflare State Store deploy/bootstrap operations dispatched by alchemy.",
+	incremental: true
+});
+/**
+* Counter for State store layer construction. Tagged with `id` (the
+* `StateService.id` slug) so we can answer "how many distinct projects
+* are using each backend" from the corresponding `state_store.init`
+* spans. Open-ended on purpose: third-party state stores get counted
+* automatically by setting their `StateService.id`.
+*/
+const stateStoreInitCounter = Metric.counter("alchemy.state_store.inits", {
+	description: "Number of times a State store layer is constructed.",
+	incremental: true
+});
+/**
+* Wraps a resource lifecycle Effect to record a counter + timer entry,
+* tagged with `resource_type`, `op`, and `status` (`success`/`error`).
+*
+* Usage:
+* ```ts
+* provider.reconcile(input).pipe(recordResourceOp(node.resource.Type, "create"))
+* ```
+*/
+const recordResourceOp = (resourceType, op) => (self) => Effect.suspend(() => {
+	const startNs = process.hrtime.bigint();
+	const baseAttrs = {
+		resource_type: resourceType,
+		op
+	};
+	return self.pipe(Effect.onExit((exit) => recordOutcome(baseAttrs, Exit.isSuccess(exit) ? "success" : "error", elapsed(startNs))));
+});
+/**
+* Wraps a CLI command Effect to bump {@link cliCounter} with the
+* outcome (`success`/`error`).
+*/
+const recordCli = (command) => (self) => self.pipe(Effect.onExit((exit) => Metric.update(Metric.withAttributes(cliCounter, {
+	command,
+	status: Exit.isSuccess(exit) ? "success" : "error"
+}), 1)));
+const elapsed = (startNs) => Duration.nanos(process.hrtime.bigint() - startNs);
+const recordOutcome = (baseAttrs, status, duration) => {
+	const attrs = {
+		...baseAttrs,
+		status
+	};
+	return Effect.all([Metric.update(Metric.withAttributes(resourceCounter, attrs), 1), Metric.update(Metric.withAttributes(resourceDuration, attrs), duration)], { discard: true });
+};
+
+//#endregion
+//#region lib/Util/scc.js
+/**
+* Compute the set of graph nodes that participate in a dependency cycle.
+*
+* A node is considered "in a cycle" iff it sits in a strongly-connected
+* component (SCC) of size > 1, or has a self-edge (size-1 SCC that loops
+* back to itself).
+*
+* Implementation is iterative Tarjan's algorithm to avoid blowing the JS
+* call stack on very wide graphs.
+*/
+const findCycleMembers = (edges) => {
+	const cycleMembers = /* @__PURE__ */ new Set();
+	let index = 0;
+	const indexOf = /* @__PURE__ */ new Map();
+	const lowlink = /* @__PURE__ */ new Map();
+	const onStack = /* @__PURE__ */ new Set();
+	const stack = [];
+	const callStack = [];
+	const startNode = (node) => {
+		indexOf.set(node, index);
+		lowlink.set(node, index);
+		index += 1;
+		stack.push(node);
+		onStack.add(node);
+		callStack.push({
+			node,
+			childIdx: 0
+		});
+	};
+	for (const root of Object.keys(edges)) {
+		if (indexOf.has(root)) continue;
+		startNode(root);
+		while (callStack.length > 0) {
+			const frame = callStack[callStack.length - 1];
+			const children = edges[frame.node] ?? [];
+			if (frame.childIdx < children.length) {
+				const child = children[frame.childIdx];
+				frame.childIdx += 1;
+				if (!indexOf.has(child)) {
+					startNode(child);
+					continue;
+				}
+				if (onStack.has(child)) lowlink.set(frame.node, Math.min(lowlink.get(frame.node), indexOf.get(child)));
+				continue;
+			}
+			if (lowlink.get(frame.node) === indexOf.get(frame.node)) {
+				const scc = [];
+				for (;;) {
+					const w = stack.pop();
+					onStack.delete(w);
+					scc.push(w);
+					if (w === frame.node) break;
+				}
+				if (scc.length > 1) for (const fqn of scc) cycleMembers.add(fqn);
+				else {
+					const only = scc[0];
+					if ((edges[only] ?? []).includes(only)) cycleMembers.add(only);
+				}
+			}
+			callStack.pop();
+			const parent = callStack[callStack.length - 1];
+			if (parent) {
+				const cur = lowlink.get(parent.node);
+				const childLow = lowlink.get(frame.node);
+				if (childLow < cur) lowlink.set(parent.node, childLow);
+			}
+		}
+	}
+	return cycleMembers;
+};
+
+//#endregion
+//#region lib/Plan.js
+const make = (stack, options = {}) => Effect.gen(function* () {
+	const state = yield* State;
+	const resources = Object.values(stack.resources);
+	const stackName = stack.name;
+	const stage$1 = stack.stage;
+	const shouldAdopt = Effect.gen(function* () {
+		const fromService = yield* Effect.serviceOption(AdoptPolicy);
+		if (Option.isSome(fromService)) return fromService.value;
+		const ctx = yield* Effect.serviceOption(AlchemyContext);
+		return Option.match(ctx, {
+			onNone: () => false,
+			onSome: (c) => c.adopt
+		});
+	});
+	const resourceFqns = yield* state.list({
+		stack: stackName,
+		stage: stage$1
+	});
+	const oldResources = yield* Effect.all(resourceFqns.map((fqn) => state.get({
+		stack: stackName,
+		stage: stage$1,
+		fqn
+	})), { concurrency: "unbounded" });
+	const resolvedResources = {};
+	const resolveResource = (resourceExpr) => Effect.gen(function* () {
+		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({
+				stack: stackName,
+				stage: stage$1,
+				fqn: resource.FQN
+			});
+			if (!oldState || oldState.status === "creating") return resourceExpr;
+			const oldProps = oldState.status === "updating" ? oldState.old.props : oldState.props;
+			const oldBindings = oldState.bindings ?? [];
+			const newBindings = stack.bindings[resource.FQN] ?? [];
+			const diff = yield* provider.diff ? provider.diff({
+				id: resource.LogicalId,
+				olds: oldProps,
+				instanceId: oldState.instanceId,
+				news: props,
+				output: oldState.attr,
+				oldBindings,
+				newBindings
+			}).pipe(providePlanScope(resource.FQN, oldState.instanceId)) : Effect.succeed(void 0);
+			const stables = [...provider.stables ?? [], ...diff?.stables ?? []];
+			const withStables = (output) => stables.length > 0 ? new ResourceExpr(resourceExpr.src, Object.fromEntries(stables.map((stable) => [stable, output?.[stable]]))) : resourceExpr;
+			if (diff == null) {
+				if (havePropsChanged(oldProps, props)) return withStables(oldState?.attr);
+			} else if (diff.action === "update") return withStables(oldState?.attr);
+			else if (diff.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* () {
+		if (!input) return input;
+		else if (isExpr(input)) return yield* resolveOutput(input);
+		else if (Redacted.isRedacted(input)) return input;
+		else if (Array.isArray(input)) return yield* Effect.all(input.map(resolveInput), { concurrency: "unbounded" });
+		else if (isResource(input)) return yield* resolveInput(yield* resolveOutput(of(input)));
+		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* () {
+		if (isResourceExpr(expr)) return yield* resolveResource(expr);
+		else if (isPropExpr(expr)) return (yield* resolveOutput(expr.expr))?.[expr.identifier];
+		else if (isApplyExpr(expr)) {
+			const upstream$1 = yield* resolveOutput(expr.expr);
+			return hasOutputs(upstream$1) ? expr : expr.f(upstream$1);
+		} 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), { concurrency: "unbounded" });
+		else if (isLiteralExpr(expr)) return expr.value;
+		return yield* Effect.die(/* @__PURE__ */ new Error("Not implemented yet"));
+	});
+	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 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 fqn = resource.FQN;
+		const propDeps = newUpstreamDependencies[fqn] ?? [];
+		const bindDeps = bindingUpstreamDependencies[fqn] ?? [];
+		return [fqn, [...new Set([...propDeps, ...bindDeps])]];
+	}));
+	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)]));
+	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;
+		const fqn = resource.FQN;
+		const news = yield* resolveInput(resource.Props);
+		const downstream = newDownstreamDependencies[fqn] ?? [];
+		const newBindings = yield* resolveInput(stack.bindings[fqn] ?? []);
+		let oldState = yield* state.get({
+			stack: stackName,
+			stage: stage$1,
+			fqn
+		});
+		let forceUpdateAfterAdoption = false;
+		if (oldState === void 0 && provider.read && isResolved(news)) {
+			const adoptInstanceId = yield* generateInstanceId();
+			const readResult = yield* provider.read({
+				id,
+				instanceId: adoptInstanceId,
+				olds: news,
+				output: void 0
+			}).pipe(providePlanScope(fqn, adoptInstanceId));
+			if (readResult !== void 0) {
+				if (Unowned.is(readResult) && !(yield* shouldAdopt)) return yield* new OwnedBySomeoneElse({
+					message: `Cannot adopt resource '${fqn}' (${resource.Type}): it exists in the cloud but is not owned by this stack/stage/logical-id. Re-run with \`--adopt\` (or wrap the effect in \`adopt(true)\`) to take it over.`,
+					resourceType: resource.Type,
+					logicalId: id
+				});
+				const adoptedState = {
+					status: "created",
+					fqn,
+					logicalId: id,
+					instanceId: adoptInstanceId,
+					namespace: resource.Namespace,
+					resourceType: resource.Type,
+					props: news,
+					attr: stripUnowned(readResult),
+					providerVersion: provider.version ?? 0,
+					bindings: [],
+					downstream,
+					removalPolicy: resource.RemovalPolicy
+				};
+				yield* state.set({
+					stack: stackName,
+					stage: stage$1,
+					fqn,
+					value: adoptedState
+				});
+				oldState = adoptedState;
+				forceUpdateAfterAdoption = true;
+			}
+		}
+		const oldBindings = oldState?.bindings ?? [];
+		const bindingDiffs = diffBindings(oldBindings, newBindings);
+		const Node = (node) => ({
+			...node,
+			provider,
+			resource,
+			bindings: bindingDiffs,
+			downstream
+		});
+		if (oldState === void 0) return Node({
+			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
+				}).pipe(providePlanScope(fqn, oldState.instanceId));
+				if (attr) return Node({
+					action: "create",
+					props: news,
+					state: {
+						...oldState,
+						attr
+					}
+				});
+			}
+		}
+		const oldProps = oldState.props;
+		const diff = yield* asEffect(provider?.diff?.({
+			id,
+			olds: oldProps,
+			instanceId: oldState.instanceId,
+			output: oldState.attr,
+			news,
+			oldBindings,
+			newBindings
+		}).pipe(providePlanScope(fqn, oldState.instanceId))).pipe(Effect.map((diff$1) => diff$1 ?? { action: havePropsChanged(oldProps, news) || bindingDiffs.some((b) => b.action !== "noop") ? "update" : "noop" }), Effect.map((diff$1) => options.force && diff$1.action === "noop" ? { action: "update" } : diff$1), Effect.map((diff$1) => forceUpdateAfterAdoption && diff$1.action === "noop" ? { action: "update" } : diff$1));
+		if (oldState.status === "creating") if (diff.action === "noop") return Node({
+			action: "create",
+			props: news,
+			state: oldState
+		});
+		else if (diff.action === "update") return Node({
+			action: "create",
+			props: news,
+			state: oldState
+		});
+		else return Node({
+			action: "replace",
+			props: news,
+			deleteFirst: diff.deleteFirst ?? false,
+			state: oldState
+		});
+		else if (oldState.status === "updating") if (diff.action === "update" || diff.action === "noop") return Node({
+			action: "update",
+			props: news,
+			state: oldState
+		});
+		else return Node({
+			action: "replace",
+			deleteFirst: diff.deleteFirst ?? false,
+			props: news,
+			state: oldState
+		});
+		else if (oldState.status === "replacing") if (diff.action === "noop") return Node({
+			action: "replace",
+			deleteFirst: oldState.deleteFirst,
+			props: news,
+			state: oldState
+		});
+		else if (diff.action === "update") return Node({
+			action: "replace",
+			deleteFirst: oldState.deleteFirst,
+			props: news,
+			state: oldState
+		});
+		else return Node({
+			restart: true,
+			action: "replace",
+			deleteFirst: diff.deleteFirst ?? oldState.deleteFirst,
+			props: news,
+			state: oldState
+		});
+		else if (oldState.status === "replaced") if (diff.action === "noop") return Node({
+			action: "replace",
+			deleteFirst: oldState.deleteFirst,
+			props: news,
+			state: oldState
+		});
+		else if (diff.action === "update") return Node({
+			action: "update",
+			props: news,
+			state: oldState
+		});
+		else return Node({
+			restart: true,
+			action: "replace",
+			deleteFirst: diff.deleteFirst ?? oldState.deleteFirst,
+			props: news,
+			state: oldState
+		});
+		else if (oldState.status === "deleting") return Node({
+			action: "create",
+			props: news,
+			state: {
+				...oldState,
+				status: "creating",
+				props: news
+			}
+		});
+		else if (diff.action === "update") return Node({
+			action: "update",
+			props: news,
+			state: oldState
+		});
+		else if (diff.action === "replace") return Node({
+			action: "replace",
+			props: news,
+			state: oldState,
+			deleteFirst: diff?.deleteFirst ?? false
+		});
+		else return Node({
+			action: "noop",
+			state: oldState
+		});
+	})), { concurrency: "unbounded" })).map((update) => [update.resource.FQN, update]));
+	const cycleMembers = findCycleMembers(allUpstreamDependencies);
+	{
+		const createReplaceNodes = new Set(Object.entries(resourceGraph).filter(([_, node]) => node.action === "create" || node.action === "replace").map(([fqn]) => fqn));
+		if (createReplaceNodes.size > 0) {
+			const hasPrecreate = new Set([...createReplaceNodes].filter((fqn) => !!resourceGraph[fqn]?.provider?.precreate));
+			const resolved = new Set(hasPrecreate);
+			let changed = true;
+			while (changed) {
+				changed = false;
+				for (const fqn of createReplaceNodes) {
+					if (resolved.has(fqn)) continue;
+					if ((allUpstreamDependencies[fqn] ?? []).filter((dep) => createReplaceNodes.has(dep)).every((dep) => resolved.has(dep))) {
+						resolved.add(fqn);
+						changed = true;
+					}
+				}
+			}
+			const deadlocked = [...createReplaceNodes].filter((fqn) => !resolved.has(fqn));
+			if (deadlocked.length > 0) {
+				const missingPrecreate = deadlocked.filter((fqn) => !hasPrecreate.has(fqn));
+				return yield* Effect.die(new UnsatisfiedResourceCycle({
+					message: `Circular dependency detected that cannot be resolved: [${deadlocked.join(", ")}]. Resources lacking a precreate handler: [${missingPrecreate.join(", ")}]. All resources in a dependency cycle must implement precreate to allow early signaling.`,
+					cycle: deadlocked,
+					missingPrecreate
+				}));
+			}
+		}
+	}
+	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({
+			stack: stackName,
+			stage: stage$1,
+			fqn
+		});
+		let attr = oldState?.attr;
+		if (oldState) {
+			const { logicalId } = parseFqn(fqn);
+			const resourceType = oldState.resourceType;
+			const provider = yield* findProviderByType(resourceType);
+			if (oldState.attr === void 0) {
+				if (provider.read) attr = yield* provider.read({
+					id: logicalId,
+					instanceId: oldState.instanceId,
+					olds: oldState.props,
+					output: oldState.attr
+				}).pipe(providePlanScope(fqn, oldState.instanceId));
+			}
+			return [fqn, {
+				action: "delete",
+				state: {
+					...oldState,
+					attr
+				},
+				provider,
+				resource: {
+					Namespace: oldState.namespace,
+					FQN: fqn,
+					LogicalId: logicalId,
+					Type: oldState.resourceType,
+					Attributes: attr,
+					Props: oldState.props,
+					Binding: void 0,
+					Provider: Provider(resourceType),
+					RemovalPolicy: oldState.removalPolicy,
+					RuntimeContext: void 0,
+					Providers: void 0
+				},
+				downstream: oldDownstreamDependencies[fqn] ?? [],
+				bindings: oldState.bindings.map((binding) => ({
+					sid: binding.sid,
+					action: "delete",
+					data: binding.data
+				}))
+			}];
+		}
+	})), { concurrency: "unbounded" })).filter((v) => !!v));
+	for (const resourceFqn of Object.keys(deletions)) {
+		const dependencies = Object.entries(rawUpstreamDependencies).filter(([survivorFqn, upstream$1]) => survivorFqn in resourceGraph && upstream$1.includes(resourceFqn)).map(([survivorFqn]) => survivorFqn);
+		if (dependencies.length > 0) return yield* new DeleteResourceHasDownstreamDependencies({
+			message: `Resource ${resourceFqn} has downstream dependencies`,
+			resourceId: resourceFqn,
+			dependencies
+		});
+	}
+	return {
+		resources: resourceGraph,
+		deletions,
+		output: stack.output,
+		cycleMembers
+	};
+}).pipe(ensureArtifactStore, Effect.withSpan("plan.make", { attributes: {
+	"alchemy.stack": stack.name,
+	"alchemy.stage": stack.stage,
+	"alchemy.resources.count": Object.keys(stack.resources).length,
+	"alchemy.force": !!options.force
+} }));
+const providePlanScope = (fqn, instanceId) => (effect) => Effect.serviceOption(ArtifactStore).pipe(Effect.map(Option.getOrElse(createArtifactStore)), Effect.flatMap((store) => effect.pipe(Effect.provideService(Artifacts, makeScopedArtifacts(store, fqn)), Effect.provideService(InstanceId, instanceId))));
+var DeleteResourceHasDownstreamDependencies = class extends Data.TaggedError("DeleteResourceHasDownstreamDependencies") {};
+var UnsatisfiedResourceCycle = class extends Data.TaggedError("UnsatisfiedResourceCycle") {};
+
+//#endregion
+//#region lib/Apply.js
+const provideLifecycleScope = (fqn, instanceId) => (effect) => Effect.serviceOption(ArtifactStore).pipe(Effect.map(Option.getOrElse(createArtifactStore)), Effect.flatMap((store) => effect.pipe(Effect.provideService(Artifacts, makeScopedArtifacts(store, fqn)), Effect.provideService(InstanceId, instanceId))));
+/**
+* Instruments a single provider lifecycle call with an OTel span
+* (`provider.<op>`), the resource counter / duration histogram, and the
+* scoped artifacts/instance services normally supplied by
+* {@link provideLifecycleScope}.
+*
+* This is the only call site through which provider lifecycle methods
+* are dispatched, so wrapping it here gives us a fully-instrumented
+* toolchain without touching any individual provider implementation.
+*/
+const instrumentLifecycle = (op, fqn, resourceType, logicalId, instanceId) => (effect) => effect.pipe(provideLifecycleScope(fqn, instanceId), recordResourceOp(resourceType, op), Effect.withSpan(`provider.${op}`, { attributes: {
+	"alchemy.resource.fqn": fqn,
+	"alchemy.resource.type": resourceType,
+	"alchemy.resource.logical_id": logicalId,
+	"alchemy.resource.instance_id": instanceId,
+	"alchemy.resource.op": op
+} }));
+const apply = (plan) => Effect.gen(function* () {
+	const session = yield* (yield* Cli).startApplySession(plan);
+	const state = yield* State;
+	const stack = yield* Stack;
+	const stage$1 = yield* Stage;
+	const stackName = stack.name;
+	const tracker = {};
+	const terminalStatuses = /* @__PURE__ */ new Map();
+	yield* executePlan(plan, tracker, terminalStatuses, session, state, stackName, stage$1);
+	yield* collectGarbage(plan, session);
+	yield* converge(plan, tracker, terminalStatuses, session, state, stackName, stage$1);
+	yield* Effect.forEach(Array.from(terminalStatuses.values()), ({ id, type, status }) => session.emit({
+		kind: "status-change",
+		id,
+		type,
+		status
+	}), { concurrency: "unbounded" });
+	yield* session.done();
+	if (!plan.output) return;
+	const outputs = Object.fromEntries(Object.entries(tracker).map(([fqn, t]) => [fqn, t.output]));
+	return yield* evaluate(plan.output, outputs);
+}).pipe(ensureArtifactStore, Effect.withSpan("apply", { attributes: {
+	"alchemy.resources.count": Object.keys(plan.resources).length,
+	"alchemy.deletions.count": Object.keys(plan.deletions).length
+} }));
+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 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 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" });
+	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 logicalId = node.resource.LogicalId;
+	const namespace = node.resource.Namespace;
+	const commit = (value) => state.set({
+		stack: stackName,
+		stage: stage$1,
+		fqn,
+		value: {
+			...value,
+			namespace
+		}
+	});
+	const scopedSession = {
+		...session,
+		note: (note) => session.emit({
+			id: logicalId,
+			kind: "annotate",
+			message: note
+		})
+	};
+	const report = (status) => session.emit({
+		kind: "status-change",
+		id: logicalId,
+		type: node.resource.Type,
+		status
+	});
+	const markTerminal = (status) => Effect.sync(() => {
+		terminalStatuses.set(fqn, {
+			id: logicalId,
+			type: node.resource.Type,
+			status
+		});
+	});
+	const signalReady = Deferred.succeed(ready[fqn], void 0);
+	const storeAndSignal = (t) => Effect.gen(function* () {
+		tracker[fqn] = t;
+		yield* signalReady;
+	});
+	if (node.action === "noop") {
+		yield* storeAndSignal({
+			output: node.state.attr,
+			props: node.state.props,
+			bindings: node.state.bindings ?? [],
+			instanceId: node.state.instanceId
+		});
+		return;
+	}
+	const allUpstreamFqns = () => {
+		const propDeps = Object.keys(resolveUpstream(node.props));
+		const bindingDeps = Object.keys(resolveUpstream(node.bindings));
+		return [...new Set([...propDeps, ...bindingDeps])];
+	};
+	const instanceId = yield* Effect.gen(function* () {
+		if (node.action === "create" && !node.state?.instanceId) {
+			const id = yield* generateInstanceId();
+			yield* commit({
+				status: "creating",
+				fqn,
+				logicalId,
+				instanceId: id,
+				downstream: node.downstream,
+				props: node.props,
+				providerVersion: node.provider.version ?? 0,
+				resourceType: node.resource.Type,
+				bindings: excludeDeletedBindings(node.bindings),
+				removalPolicy: node.resource.RemovalPolicy
+			});
+			return id;
+		} else if (node.action === "replace") {
+			if ((node.state.status === "replaced" || node.state.status === "replacing") && !node.restart) return node.state.instanceId;
+			const id = yield* generateInstanceId();
+			yield* commit({
+				status: "replacing",
+				fqn,
+				logicalId,
+				instanceId: id,
+				downstream: node.downstream,
+				props: node.props,
+				providerVersion: node.provider.version ?? 0,
+				resourceType: node.resource.Type,
+				bindings: excludeDeletedBindings(node.bindings),
+				old: node.state,
+				deleteFirst: node.deleteFirst,
+				removalPolicy: node.resource.RemovalPolicy
+			});
+			return id;
+		} else if (node.state?.instanceId) return node.state.instanceId;
+		return yield* Effect.die(`Instance ID not found for resource '${logicalId}' and action is '${node.action}'`);
+	});
+	yield* Effect.gen(function* () {
+		if (node.action === "create") {
+			if (!node.state) yield* commit({
+				status: "creating",
+				fqn,
+				logicalId,
+				instanceId,
+				resourceType: node.resource.Type,
+				props: node.props,
+				attr: void 0,
+				providerVersion: node.provider.version ?? 0,
+				bindings: excludeDeletedBindings(node.bindings),
+				downstream: node.downstream,
+				removalPolicy: node.resource.RemovalPolicy
+			});
+			let attr = node.state?.attr;
+			if (attr !== void 0) yield* storeAndSignal({
+				output: attr,
+				props: {},
+				bindings: [],
+				instanceId
+			});
+			if (node.provider.precreate && attr === void 0) {
+				yield* report("pre-creating");
+				attr = yield* node.provider.precreate({
+					id: logicalId,
+					news: node.props,
+					session: scopedSession,
+					instanceId,
+					bindings: excludeDeletedBindings(node.bindings)
+				}).pipe(instrumentLifecycle("precreate", fqn, node.resource.Type, logicalId, instanceId));
+				yield* commit({
+					status: "creating",
+					fqn,
+					logicalId,
+					instanceId,
+					resourceType: node.resource.Type,
+					props: node.props,
+					attr,
+					providerVersion: node.provider.version ?? 0,
+					bindings: excludeDeletedBindings(node.bindings),
+					downstream: node.downstream,
+					removalPolicy: node.resource.RemovalPolicy
+				});
+				yield* storeAndSignal({
+					output: attr,
+					props: {},
+					bindings: [],
+					instanceId
+				});
+			}
+			yield* report("creating");
+			yield* waitForDeps(allUpstreamFqns());
+			const outputs = getOutputs();
+			const news = yield* evaluate(node.props, outputs);
+			const bindingOutputs = excludeDeletedBindings(yield* evaluate(node.bindings, outputs));
+			attr = yield* node.provider.reconcile({
+				id: logicalId,
+				news,
+				instanceId,
+				bindings: bindingOutputs,
+				session: scopedSession,
+				olds: void 0,
+				output: attr
+			}).pipe(instrumentLifecycle("create", fqn, node.resource.Type, logicalId, instanceId));
+			yield* commit({
+				status: "created",
+				fqn,
+				logicalId,
+				instanceId,
+				resourceType: node.resource.Type,
+				props: news,
+				attr,
+				bindings: excludeDeletedBindings(node.bindings),
+				providerVersion: node.provider.version ?? 0,
+				downstream: node.downstream,
+				removalPolicy: node.resource.RemovalPolicy
+			});
+			tracker[fqn] = {
+				output: attr,
+				props: news,
+				bindings: bindingOutputs,
+				instanceId
+			};
+			yield* signalReady;
+			yield* markTerminal("created");
+			return;
+		}
+		if (node.action === "update") {
+			if (inCycle) yield* storeAndSignal({
+				output: node.state.attr,
+				props: node.state.props,
+				bindings: node.state.bindings ?? [],
+				instanceId
+			});
+			yield* waitForDeps(allUpstreamFqns());
+			const outputs = getOutputs();
+			const news = yield* evaluate(node.props, outputs);
+			yield* node.state.status === "replaced" ? commit({
+				...node.state,
+				attr: node.state.attr,
+				props: news
+			}) : commit({
+				status: "updating",
+				fqn,
+				logicalId,
+				instanceId,
+				resourceType: node.resource.Type,
+				props: news,
+				attr: node.state.attr,
+				providerVersion: node.provider.version ?? 0,
+				bindings: excludeDeletedBindings(node.bindings),
+				downstream: node.downstream,
+				old: node.state.status === "updating" ? node.state.old : node.state,
+				removalPolicy: node.resource.RemovalPolicy
+			});
+			yield* report("updating");
+			const previousProps = node.state.status === "created" || node.state.status === "updated" || node.state.status === "replaced" ? node.state.props : node.state.old.props;
+			const bindingOutputs = excludeDeletedBindings(yield* evaluate(node.bindings, outputs));
+			const attr = yield* node.provider.reconcile({
+				id: logicalId,
+				news,
+				instanceId,
+				bindings: bindingOutputs,
+				session: scopedSession,
+				olds: previousProps,
+				output: node.state.attr
+			}).pipe(instrumentLifecycle("update", fqn, node.resource.Type, logicalId, instanceId));
+			if (node.state.status === "replaced") yield* commit({
+				...node.state,
+				attr,
+				props: news
+			});
+			else yield* commit({
+				status: "updated",
+				fqn,
+				logicalId,
+				instanceId,
+				resourceType: node.resource.Type,
+				props: news,
+				attr,
+				bindings: excludeDeletedBindings(node.bindings),
+				providerVersion: node.provider.version ?? 0,
+				downstream: node.downstream,
+				removalPolicy: node.resource.RemovalPolicy
+			});
+			tracker[fqn] = {
+				output: attr,
+				props: news,
+				bindings: bindingOutputs,
+				instanceId
+			};
+			yield* signalReady;
+			yield* markTerminal("updated");
+			return;
+		}
+		if (node.action === "replace") {
+			if (node.state.status === "replaced" && !node.restart) {
+				tracker[fqn] = {
+					output: node.state.attr,
+					props: node.state.props,
+					bindings: node.state.bindings ?? [],
+					instanceId
+				};
+				yield* signalReady;
+				yield* markTerminal("created");
+				return;
+			}
+			let replState;
+			if (node.state.status !== "replacing" || node.restart) replState = yield* commit({
+				status: "replacing",
+				fqn,
+				logicalId,
+				instanceId,
+				resourceType: node.resource.Type,
+				props: node.props,
+				bindings: excludeDeletedBindings(node.bindings),
+				attr: void 0,
+				providerVersion: node.provider.version ?? 0,
+				deleteFirst: node.deleteFirst,
+				old: node.state,
+				downstream: node.downstream,
+				removalPolicy: node.resource.RemovalPolicy
+			});
+			else replState = node.state;
+			let attr = replState.attr;
+			if (attr !== void 0) yield* storeAndSignal({
+				output: attr,
+				props: {},
+				bindings: [],
+				instanceId
+			});
+			if (node.provider.precreate && attr === void 0) {
+				yield* report("pre-creating");
+				attr = yield* node.provider.precreate({
+					id: logicalId,
+					news: node.props,
+					session: scopedSession,
+					instanceId,
+					bindings: excludeDeletedBindings(node.bindings)
+				}).pipe(instrumentLifecycle("precreate", fqn, node.resource.Type, logicalId, instanceId));
+				yield* commit({
+					status: "replacing",
+					fqn,
+					logicalId,
+					instanceId,
+					resourceType: node.resource.Type,
+					props: node.props,
+					attr,
+					providerVersion: node.provider.version ?? 0,
+					bindings: excludeDeletedBindings(node.bindings),
+					downstream: node.downstream,
+					old: replState.old,
+					deleteFirst: node.deleteFirst,
+					removalPolicy: node.resource.RemovalPolicy
+				});
+				yield* storeAndSignal({
+					output: attr,
+					props: {},
+					bindings: [],
+					instanceId
+				});
+			}
+			yield* report("creating replacement");
+			yield* waitForDeps(allUpstreamFqns());
+			const outputs = getOutputs();
+			const news = yield* evaluate(node.props, outputs);
+			const bindingOutputs = excludeDeletedBindings(yield* evaluate(node.bindings, outputs));
+			attr = yield* node.provider.reconcile({
+				id: logicalId,
+				news,
+				instanceId,
+				bindings: bindingOutputs,
+				session: scopedSession,
+				olds: void 0,
+				output: attr
+			}).pipe(instrumentLifecycle("create", fqn, node.resource.Type, logicalId, instanceId));
+			yield* commit({
+				status: "replaced",
+				fqn,
+				logicalId,
+				instanceId,
+				resourceType: node.resource.Type,
+				props: news,
+				attr,
+				providerVersion: node.provider.version ?? 0,
+				bindings: excludeDeletedBindings(node.bindings),
+				downstream: node.downstream,
+				old: replState.old,
+				deleteFirst: node.deleteFirst,
+				removalPolicy: node.resource.RemovalPolicy
+			});
+			tracker[fqn] = {
+				output: attr,
+				props: news,
+				bindings: bindingOutputs,
+				instanceId
+			};
+			yield* signalReady;
+			yield* markTerminal("created");
+			return;
+		}
+		return yield* Effect.die(`Unknown action: ${node.action}`);
+	});
+}).pipe(Effect.catchCause((cause) => Effect.gen(function* () {
+	failures.push({
+		fqn,
+		logicalId: node.resource.LogicalId,
+		type: node.resource.Type,
+		cause
+	});
+	yield* Deferred.failCause(ready[fqn], cause);
+	yield* session.emit({
+		kind: "status-change",
+		id: node.resource.LogicalId,
+		type: node.resource.Type,
+		status: "fail"
+	});
+})), Effect.withSpan("apply.resource", { attributes: {
+	"alchemy.resource.fqn": fqn,
+	"alchemy.resource.type": node.resource.Type,
+	"alchemy.resource.logical_id": node.resource.LogicalId,
+	"alchemy.resource.action": node.action
+} }));
+const converge = Effect.fnUntraced(function* (plan, tracker, terminalStatuses, session, state, stackName, stage$1) {
+	for (;;) {
+		let anyUpdated = false;
+		for (const [fqn, node] of Object.entries(plan.resources)) {
+			if (node.action === "noop") continue;
+			if (!tracker[fqn]) continue;
+			const outputs = Object.fromEntries(Object.entries(tracker).map(([k, t]) => [k, t.output]));
+			const newProps = yield* evaluate(node.props, outputs);
+			const newBindings = excludeDeletedBindings(yield* evaluate(node.bindings, outputs));
+			const oldProps = tracker[fqn].props;
+			const oldBindings = tracker[fqn].bindings;
+			const propsChanged = havePropsChanged(oldProps, newProps);
+			const bindingsChanged = JSON.stringify(oldBindings) !== JSON.stringify(newBindings);
+			if (!propsChanged && !bindingsChanged) continue;
+			anyUpdated = true;
+			const logicalId = node.resource.LogicalId;
+			const namespace = node.resource.Namespace;
+			const instanceId = tracker[fqn].instanceId;
+			const scopedSession = {
+				...session,
+				note: (note) => session.emit({
+					id: logicalId,
+					kind: "annotate",
+					message: note
+				})
+			};
+			const attr = yield* node.provider.reconcile({
+				id: logicalId,
+				news: newProps,
+				instanceId,
+				bindings: newBindings,
+				session: scopedSession,
+				olds: oldProps,
+				output: tracker[fqn].output
+			}).pipe(instrumentLifecycle("update", fqn, node.resource.Type, logicalId, instanceId));
+			tracker[fqn] = {
+				output: attr,
+				props: newProps,
+				bindings: newBindings,
+				instanceId
+			};
+			yield* state.set({
+				stack: stackName,
+				stage: stage$1,
+				fqn,
+				value: {
+					status: "updated",
+					fqn,
+					logicalId,
+					instanceId,
+					resourceType: node.resource.Type,
+					props: newProps,
+					attr,
+					providerVersion: node.provider.version ?? 0,
+					bindings: excludeDeletedBindings(node.bindings),
+					downstream: node.downstream,
+					namespace,
+					removalPolicy: node.resource.RemovalPolicy
+				}
+			});
+			terminalStatuses.set(fqn, {
+				id: logicalId,
+				type: node.resource.Type,
+				status: "updated"
+			});
+		}
+		if (!anyUpdated) break;
+	}
+});
+const collectGarbage = Effect.fnUntraced(function* (plan, session) {
+	const state = yield* State;
+	const stackName = (yield* Stack).name;
+	const stage$1 = yield* Stage;
+	const deleteGraph = Effect.fnUntraced(function* (deletionGraph) {
+		const deletions = {};
+		const deleteResource = (node, ancestors = /* @__PURE__ */ new Set()) => Effect.gen(function* () {
+			const isDeleteNode = (node$1) => "action" in node$1;
+			const { logicalId, namespace, resourceType, instanceId, downstream, props, attr, provider } = isDeleteNode(node) ? {
+				logicalId: node.resource.LogicalId,
+				namespace: node.resource.Namespace,
+				resourceType: node.resource.Type,
+				instanceId: node.state.instanceId,
+				downstream: node.downstream,
+				props: node.state.props,
+				attr: node.state.attr,
+				provider: node.provider
+			} : {
+				logicalId: node.logicalId,
+				namespace: node.namespace,
+				resourceType: node.old.resourceType,
+				instanceId: node.old.instanceId,
+				downstream: node.old.downstream,
+				props: node.old.props,
+				attr: node.old.attr,
+				provider: yield* findProviderByType(node.old.resourceType)
+			};
+			const fqn = toFqn(namespace, logicalId);
+			const nextAncestors = new Set(ancestors).add(fqn);
+			const commit = (value) => state.set({
+				stack: stackName,
+				stage: stage$1,
+				fqn,
+				value: {
+					...value,
+					namespace
+				}
+			});
+			const report = (status) => session.emit({
+				kind: "status-change",
+				id: logicalId,
+				type: resourceType,
+				status
+			});
+			const scopedSession = {
+				...session,
+				note: (note) => session.emit({
+					id: logicalId,
+					kind: "annotate",
+					message: note
+				})
+			};
+			return yield* deletions[fqn] ??= yield* Effect.cached(Effect.gen(function* () {
+				yield* Effect.all(downstream.map((dep) => dep !== fqn && dep in deletionGraph && !ancestors.has(dep) ? deleteResource(deletionGraph[dep], nextAncestors) : Effect.void), { concurrency: "unbounded" });
+				if (isDeleteNode(node)) {
+					yield* report("deleting");
+					if (node.resource.RemovalPolicy === "retain") {
+						yield* state.delete({
+							stack: stackName,
+							stage: stage$1,
+							fqn
+						});
+						yield* report("deleted");
+						return;
+					}
+					yield* commit({
+						status: "deleting",
+						fqn,
+						logicalId,
+						instanceId,
+						resourceType,
+						props,
+						attr,
+						downstream,
+						providerVersion: provider.version ?? 0,
+						bindings: excludeDeletedBindings(node.bindings),
+						removalPolicy: node.resource.RemovalPolicy
+					});
+				}
+				if (attr !== void 0) yield* provider.delete({
+					id: logicalId,
+					instanceId,
+					olds: props,
+					output: attr,
+					session: scopedSession,
+					bindings: []
+				}).pipe(instrumentLifecycle("delete", fqn, resourceType, logicalId, instanceId));
+				if (isDeleteNode(node)) {
+					yield* state.delete({
+						stack: stackName,
+						stage: stage$1,
+						fqn
+					});
+					yield* report("deleted");
+				} else {
+					yield* scopedSession.note("Cleaning up replaced resource...");
+					if (node.old.status === "replacing" || node.old.status === "replaced") yield* commit({
+						status: "replaced",
+						fqn,
+						logicalId: node.logicalId,
+						instanceId: node.instanceId,
+						resourceType: node.resourceType,
+						props: node.props,
+						attr: node.attr,
+						providerVersion: node.providerVersion,
+						downstream: node.downstream,
+						bindings: excludeDeletedBindings(node.bindings),
+						old: node.old.old,
+						deleteFirst: node.deleteFirst,
+						removalPolicy: node.removalPolicy
+					});
+					else yield* commit({
+						status: "created",
+						fqn,
+						logicalId: node.logicalId,
+						instanceId: node.instanceId,
+						resourceType: node.resourceType,
+						props: node.props,
+						attr: node.attr,
+						providerVersion: node.providerVersion,
+						downstream: node.downstream,
+						bindings: excludeDeletedBindings(node.bindings),
+						removalPolicy: node.removalPolicy
+					});
+					yield* scopedSession.note("Replaced resource cleanup complete.");
+				}
+			}));
+		});
+		yield* Effect.all(Object.values(deletionGraph).filter((node) => node !== void 0).map((node) => deleteResource(node)), { concurrency: "unbounded" });
+	});
+	let first = true;
+	while (true) {
+		const remainingReplacedResources = yield* state.getReplacedResources({
+			stack: stackName,
+			stage: stage$1
+		});
+		if (!first && remainingReplacedResources.length === 0) break;
+		yield* deleteGraph({
+			...first ? plan.deletions : {},
+			...Object.fromEntries(remainingReplacedResources.map((replaced) => [toFqn(replaced.namespace, replaced.logicalId), replaced]))
+		});
+		first = false;
+	}
+});
+const excludeDeletedBindings = (bindings) => bindings.flatMap(({ action, sid, data }) => action === "delete" ? [] : [{
+	sid,
+	data
+}]);
+
+//#endregion
+//#region lib/Cli/commands/_shared.js
+var __rewriteRelativeImportExtension = void 0 && (void 0).__rewriteRelativeImportExtension || function(path$1, preserveJsx) {
+	if (typeof path$1 === "string" && /^\.\.?\//.test(path$1)) return path$1.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+		return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
+	});
+	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 = 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)));
+})));
+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));
+const yes = Flag.boolean("yes").pipe(Flag.withDescription("Yes to all prompts"), Flag.withDefault(false));
+const force = Flag.boolean("force").pipe(Flag.withDescription("Force updates for resources that would otherwise no-op"), Flag.withDefault(false));
+const script = Argument.file("main", { mustExist: true }).pipe(Argument.withDescription("Main file to deploy, defaults to alchemy.run.ts"), Argument.withDefault("alchemy.run.ts"));
+const profile = Flag.string("profile").pipe(Flag.withDescription("Auth profile to use (~/.alchemy/profiles.json). Defaults to 'default' or $ALCHEMY_PROFILE."), Flag.optional, Flag.map(Option.getOrElse(() => "default")));
+const resourceFilter = Flag.string("filter").pipe(Flag.withDescription("Comma-separated logical resource IDs (e.g. Api,Sandbox). Only those resources are included."), Flag.optional, Flag.map(Option.getOrUndefined));
+/**
+* Wraps a CLI command handler with a top-level OpenTelemetry span
+* (`cli.<command>`) and bumps the `alchemy.cli.invocations` counter.
+*
+* `attrs` runs against the parsed command args and contributes
+* additional attributes to the span (e.g. stage, profile, dry-run flag).
+*
+* Usage:
+* ```ts
+* Command.make(
+*   "deploy",
+*   { ...flags },
+*   instrumentCommand("deploy", (a) => ({
+*     "alchemy.stage": a.stage,
+*     "alchemy.profile": a.profile,
+*   }))(execStack),
+* );
+* ```
+*/
+const instrumentCommand = (command, attrs) => (handler) => (args) => handler(args).pipe(Effect.withSpan(`cli.${command}`, { attributes: attrs ? attrs(args) : {} }), recordCli(command));
+const importStack = Effect.fn(function* (main) {
+	const path$1 = yield* Path$1.Path;
+	const stackEffect = (yield* Effect.promise(() => import(__rewriteRelativeImportExtension(path$1.resolve(process.cwd(), main))))).default;
+	if (!Effect.isEffect(stackEffect)) return yield* Effect.die(/* @__PURE__ */ new Error(`Main file '${main}' must export a default stack definition (export default Alchemy.Stack({...}))`));
+	return stackEffect;
+});
+
+//#endregion
+//#region lib/Cli/commands/deploy.js
+const ExecStackOptions = S.Struct({
+	main: S.String,
+	stage: S.String,
+	envFile: S.OptionFromOptional(S.String),
+	profile: S.optional(S.String),
+	dryRun: S.optional(S.Boolean),
+	force: S.optional(S.Boolean),
+	yes: S.optional(S.Boolean),
+	destroy: S.optional(S.Boolean),
+	dev: S.optional(S.Boolean),
+	adopt: S.optional(S.Boolean)
+});
+const stackSpanAttrs = (args) => ({
+	"alchemy.stage": args.stage,
+	"alchemy.profile": args.profile,
+	"alchemy.main": args.main,
+	"alchemy.dry_run": !!args.dryRun,
+	"alchemy.force": !!args.force,
+	"alchemy.destroy": !!args.destroy,
+	"alchemy.dev": !!args.dev,
+	"alchemy.adopt": !!args.adopt
+});
+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) => ({
+		...ctx,
+		dev,
+		adopt: adopt$1
+	})))), Layer.succeed(AdoptPolicy, adopt$1), Layer.succeed(ArtifactStore, createArtifactStore()), Layer.succeed(AuthProviders, yield* Effect.serviceOption(AuthProviders).pipe(Effect.map(Option.getOrElse(() => ({}))))), ConfigProvider.layer(withProfileOverride(yield* loadConfigProvider(envFile$1), profile$1)), Logger.layer([fileLogger("out")], { mergeWithExisting: true }), Layer.succeed(Stage, stage$1));
+	yield* Effect.gen(function* () {
+		const cli = yield* Cli;
+		const stack = yield* stackEffect;
+		yield* Effect.gen(function* () {
+			const updatePlan = yield* make(destroy ? {
+				...stack,
+				resources: {},
+				bindings: {},
+				output: {}
+			} : stack, { force: force$1 });
+			if (dryRun$1) yield* cli.displayPlan(updatePlan);
+			else {
+				const hasChanges = Object.keys(updatePlan.deletions).length > 0 || Object.values(updatePlan.resources).some((node) => node.action !== "noop" || node.bindings.some((b) => b.action !== "noop"));
+				if (!yes$1 && hasChanges) {
+					if (!(yield* cli.approvePlan(updatePlan))) return;
+				}
+				const outputs = yield* apply(updatePlan);
+				if (outputs !== void 0) yield* Console.log(outputs);
+				if (dev) yield* Effect.never;
+			}
+		}).pipe(Effect.provide(stack.services));
+	}).pipe(Effect.provide(services$1));
+});
+const deployCommand = Command.make("deploy", {
+	dryRun,
+	force,
+	main: script,
+	envFile,
+	stage,
+	yes,
+	profile,
+	adopt
+}, instrumentCommand("deploy", stackSpanAttrs)(execStack));
+const destroyCommand = Command.make("destroy", {
+	dryRun,
+	main: script,
+	envFile,
+	stage,
+	yes,
+	profile
+}, instrumentCommand("destroy", stackSpanAttrs)((args) => execStack({
+	...args,
+	destroy: true
+})));
+const planCommand = Command.make("plan", {
+	main: script,
+	envFile,
+	stage,
+	profile
+}, instrumentCommand("plan", stackSpanAttrs)((args) => execStack({
+	...args,
+	dryRun: true
+})));
+
+//#endregion
+//#region lib/Cli/NamespaceTree.js
+function buildNamespaceTree(items) {
+	const root = {
+		id: "",
+		path: [],
+		children: /* @__PURE__ */ new Map(),
+		resources: []
+	};
+	const getNode = (path$1) => {
+		let current = root;
+		for (let i = 0; i < path$1.length; i++) {
+			const segment = path$1[i];
+			let child = current.children.get(segment);
+			if (!child) {
+				child = {
+					id: segment,
+					path: path$1.slice(0, i + 1),
+					children: /* @__PURE__ */ new Map(),
+					resources: []
+				};
+				current.children.set(segment, child);
+			}
+			current = child;
+		}
+		return current;
+	};
+	for (const item of items) getNode(toPath(item.resource.Namespace)).resources.push(item);
+	return root;
+}
+function deriveNamespaceAction(node) {
+	const actions = /* @__PURE__ */ new Set();
+	for (const resource of node.resources) actions.add(deriveResourceChildrenAction(resource, node));
+	for (const child of node.children.values()) {
+		const childAction = deriveNamespaceAction(child);
+		if (childAction === "mixed") return "mixed";
+		actions.add(childAction);
+	}
+	return deriveAction(actions);
+}
+function flattenTree(node, depth = 0, result = []) {
+	flattenNamespace(node, depth, result);
+	return result;
+}
+const flattenNamespace = (node, depth, result) => {
+	const sortedResources = [...node.resources].sort((a, b) => a.resource.LogicalId.localeCompare(b.resource.LogicalId));
+	const sortedChildren = Array.from(node.children.entries()).sort(([a], [b]) => a.localeCompare(b));
+	const resourceIds = new Set(sortedResources.map((resource) => resource.resource.LogicalId));
+	for (const [id, child] of sortedChildren) {
+		if (resourceIds.has(id) || isEmpty(child)) continue;
+		result.push({
+			type: "namespace",
+			depth,
+			id,
+			path: child.path,
+			action: deriveNamespaceAction(child),
+			hasChildren: true
+		});
+		flattenNamespace(child, depth + 1, result);
+	}
+	for (const resource of sortedResources) {
+		const childNamespace = node.children.get(resource.resource.LogicalId);
+		result.push({
+			type: "resource",
+			depth,
+			id: resource.resource.LogicalId,
+			path: [...node.path, resource.resource.LogicalId],
+			action: resource.action,
+			resourceType: resource.resource.Type,
+			bindingCount: resource.bindings.length
+		});
+		for (const binding of [...resource.bindings].sort((a, b) => a.sid.localeCompare(b.sid))) result.push({
+			type: "binding",
+			depth: depth + 1,
+			id: binding.sid,
+			path: [
+				...node.path,
+				resource.resource.LogicalId,
+				binding.sid
+			],
+			action: binding.action,
+			bindingSid: binding.sid
+		});
+		if (childNamespace) flattenNamespace(childNamespace, depth + 1, result);
+	}
+};
+const isEmpty = (node) => node.resources.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);
+	const childNamespace = node.children.get(resource.resource.LogicalId);
+	if (childNamespace) actions.add(deriveNamespaceAction(childNamespace));
+	return deriveAction(actions);
+};
+const deriveAction = (actions) => {
+	if (actions.size === 0) return "noop";
+	if (actions.has("replace")) return actions.size === 1 ? "replace" : "mixed";
+	if (actions.has("delete")) return actions.size === 1 ? "delete" : "mixed";
+	if (actions.has("create")) return actions.size === 1 ? "create" : "mixed";
+	if (actions.has("update")) return actions.size === 1 ? "update" : "mixed";
+	return "noop";
+};
+
+//#endregion
+//#region lib/Cli/tui/components/Plan.js
+function Plan({ plan }) {
+	const items = useMemo(() => [...Object.values(plan.resources), ...Object.values(plan.deletions)], [plan]);
+	const flatItems = useMemo(() => {
+		return flattenTree(buildNamespaceTree(items));
+	}, [items]);
+	if (items.length === 0) return jsx(Text, {
+		color: "gray",
+		children: "No changes planned"
+	});
+	const counts = items.reduce((acc, item) => (acc[item.action]++, acc), {
+		create: 0,
+		update: 0,
+		delete: 0,
+		noop: 0,
+		replace: 0
+	});
+	const actions = [
+		"create",
+		"update",
+		"delete",
+		"replace"
+	].filter((action) => counts[action] > 0);
+	return jsxs(Box, {
+		flexDirection: "column",
+		children: [jsxs(Box, {
+			marginTop: 1,
+			children: [
+				jsx(Text, {
+					underline: true,
+					children: "Plan"
+				}),
+				jsx(Text, { children: ": " }),
+				actions.flatMap((action, i) => {
+					const count = counts[action];
+					const color = actionColor(action);
+					if (count === 0) return [];
+					const box = jsx(Box, { children: jsxs(Text, {
+						color,
+						children: [
+							count,
+							" to ",
+							action
+						]
+					}) }, action);
+					return i === actions.length - 1 ? [box] : [box, jsx(Text, { children: " | " }, `${action}-separator`)];
+				})
+			]
+		}), jsx(Box, {
+			flexDirection: "column",
+			marginTop: 1,
+			children: flatItems.map((item) => {
+				const indent = "  ".repeat(item.depth);
+				const color = getActionColor(item.action);
+				const icon = getActionIcon(item.action);
+				const key = item.path.join("/");
+				if (item.type === "namespace") return jsxs(Box, {
+					flexDirection: "row",
+					children: [
+						jsx(Text, { children: indent }),
+						jsx(Box, {
+							width: 2,
+							children: jsxs(Text, {
+								color,
+								children: [icon, " "]
+							})
+						}),
+						jsx(Text, {
+							color: "blueBright",
+							children: item.id
+						})
+					]
+				}, key);
+				if (item.type === "binding") return jsxs(Box, {
+					flexDirection: "row",
+					children: [
+						jsx(Text, { children: indent }),
+						jsx(Box, {
+							width: 2,
+							children: jsxs(Text, {
+								color,
+								children: [icon, " "]
+							})
+						}),
+						jsx(Text, {
+							color: "cyan",
+							children: item.bindingSid
+						})
+					]
+				}, key);
+				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.resourceType,
+									")"
+								]
+							})
+						}),
+						item.bindingCount !== void 0 && item.bindingCount > 0 && jsx(Box, {
+							marginLeft: 1,
+							children: jsxs(Text, {
+								color: "cyan",
+								children: [
+									"(",
+									item.bindingCount,
+									" bindings)"
+								]
+							})
+						})
+					]
+				}, key);
+			})
+		})]
+	});
+}
+const getActionColor = (action) => ({
+	noop: "gray",
+	create: "green",
+	update: "yellow",
+	delete: "red",
+	replace: "magenta",
+	mixed: "cyan"
+})[action] ?? "gray";
+const getActionIcon = (action) => ({
+	create: "+",
+	update: "~",
+	delete: "-",
+	noop: "•",
+	replace: "!",
+	mixed: "*"
+})[action] ?? "?";
+const actionColor = (action) => getActionColor(action);
+
+//#endregion
+//#region lib/Cli/tui/components/ApprovePlan.js
+function ApprovePlan(props) {
+	const { plan, approve } = props;
+	const [selected, setSelected] = useState(0);
+	const { exit } = useApp();
+	useInput((_input, key) => {
+		if (key.leftArrow || key.rightArrow) setSelected((prev) => prev === 0 ? 1 : 0);
+		else if (key.return) {
+			approve(selected === 0);
+			exit();
+		}
+	});
+	return jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			jsx(Plan, { plan }),
+			jsx(Box, {
+				marginTop: 1,
+				children: jsx(Text, { children: "Proceed?" })
+			}),
+			jsxs(Box, {
+				gap: 1,
+				children: [jsxs(Text, {
+					color: selected === 0 ? "green" : "gray",
+					children: [selected === 0 ? "◉" : "○", " Yes"]
+				}), jsxs(Text, {
+					color: selected === 1 ? "red" : "gray",
+					children: [selected === 1 ? "◉" : "○", " No"]
+				})]
+			})
+		]
+	});
+}
+
+//#endregion
+//#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
+	});
+};
+const buildLogicalIdIndex = (rows) => {
+	const index = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (row.type !== "resource") continue;
+		const keys = index.get(row.id);
+		if (keys) keys.push(row.key);
+		else index.set(row.id, [row.key]);
+	}
+	return index;
+};
+function toPlanTask(rowOrId, planItem) {
+	if (typeof rowOrId === "string") return {
+		key: rowOrId,
+		id: rowOrId,
+		type: planItem.resource.Type,
+		status: planItem.action === "noop" ? planItem.state.status : "pending",
+		updatedAt: Date.now()
+	};
+	return {
+		key: rowOrId.key,
+		id: rowOrId.id,
+		type: rowOrId.resourceType,
+		status: rowOrId.action === "noop" ? rowOrId.persistedApplyStatus ?? "created" : "pending",
+		updatedAt: Date.now()
+	};
+}
+const buildInitialTasks = (rows) => new Map(rows.flatMap((row) => row.type === "resource" ? [[row.key, toPlanTask(row)]] : []));
+function PlanProgress(props) {
+	const { source, plan } = props;
+	const spinner = useGlobalSpinner();
+	const rows = useMemo(() => buildProgressRows(plan), [plan]);
+	const logicalIdIndex = useMemo(() => buildLogicalIdIndex(rows), [rows]);
+	const [tasks, setTasks] = useState(() => buildInitialTasks(rows));
+	const unsubscribeRef = useRef(null);
+	useEffect(() => {
+		unsubscribeRef.current?.();
+		unsubscribeRef.current = source.subscribe((event) => {
+			setTasks((prev) => {
+				const next = new Map(prev);
+				const keys = logicalIdIndex.get(event.id) ?? [];
+				if (event.kind === "status-change") {
+					if (!event.bindingId) for (const key of keys) {
+						const current = next.get(key);
+						next.set(key, {
+							key,
+							id: event.id,
+							type: event.type,
+							status: event.status,
+							message: event.message ?? current?.message,
+							updatedAt: Date.now()
+						});
+					}
+				} else for (const key of keys) {
+					const current = next.get(key);
+					if (!current) continue;
+					next.set(key, {
+						...current,
+						message: event.message,
+						updatedAt: Date.now()
+					});
+				}
+				return next;
+			});
+		});
+		return () => {
+			unsubscribeRef.current?.();
+			unsubscribeRef.current = null;
+		};
+	}, [logicalIdIndex, source]);
+	useEffect(() => {
+		setTasks(buildInitialTasks(rows));
+	}, [rows]);
+	return jsx(Box, {
+		flexDirection: "column",
+		children: rows.map((row) => {
+			const indent = "  ".repeat(row.depth);
+			if (row.type === "namespace") return jsxs(Box, {
+				flexDirection: "row",
+				children: [
+					jsx(Text, { children: indent }),
+					jsx(Box, {
+						width: 2,
+						children: jsx(Text, {
+							color: "blueBright",
+							children: "↳ "
+						})
+					}),
+					jsx(Text, {
+						color: "blueBright",
+						children: row.id
+					})
+				]
+			}, row.key);
+			const task = tasks.get(row.key) ?? toPlanTask(row);
+			const displayStatus = getDisplayStatus(row, task.status);
+			const color = statusColor(displayStatus);
+			const icon = statusIcon(task.status, spinner);
+			return jsxs(Box, {
+				flexDirection: "column",
+				children: [jsxs(Box, {
+					flexDirection: "row",
+					children: [
+						jsx(Text, { children: indent }),
+						jsx(Box, {
+							width: 2,
+							children: jsxs(Text, {
+								color,
+								children: [icon, " "]
+							})
+						}),
+						jsx(Text, {
+							bold: true,
+							children: task.id
+						}),
+						jsxs(Text, {
+							dimColor: true,
+							children: [
+								" (",
+								task.type,
+								")"
+							]
+						}),
+						jsxs(Text, {
+							color,
+							children: [" ", displayStatus]
+						})
+					]
+				}), task.message ? jsx(Box, {
+					paddingLeft: row.depth * 2 + 2,
+					children: jsxs(Text, {
+						dimColor: true,
+						children: ["• ", task.message]
+					})
+				}) : null]
+			}, row.key);
+		})
+	});
+}
+function getDisplayStatus(row, status) {
+	if (row.action === "noop" && (status === "created" || status === "updated")) return "no change";
+	return status;
+}
+function statusColor(status) {
+	switch (status) {
+		case "no change": return "gray";
+		case "pending": return "gray";
+		case "creating":
+		case "created": return "green";
+		case "updating":
+		case "updated": return "yellow";
+		case "deleting":
+		case "deleted": return "red";
+		case "fail": return "redBright";
+		default: 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";
+}
+const spinnerFrames = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+function useGlobalSpinner(intervalMs = 80) {
+	const [index, setIndex] = useState(0);
+	useEffect(() => {
+		const timer = setInterval(() => {
+			setIndex((i) => (i + 1) % spinnerFrames.length);
+		}, intervalMs);
+		return () => clearInterval(timer);
+	}, [intervalMs]);
+	return spinnerFrames[index];
+}
+const findCrudByLogicalId = (plan, logicalId) => {
+	for (const node of Object.values(plan.resources)) if (node.resource.LogicalId === logicalId) return node;
+	for (const node of Object.values(plan.deletions)) if (node?.resource.LogicalId === logicalId) return node;
+};
+
+//#endregion
+//#region lib/Cli/tui/InkCLI.js
+const inkCLI = () => Layer.succeed(Cli, Cli.of({
+	approvePlan,
+	displayPlan,
+	startApplySession
+}));
+const approvePlan = Effect.fn(function* (plan) {
+	let approved = false;
+	const { waitUntilExit } = render(jsx(ApprovePlan, {
+		plan,
+		approve: (a) => approved = a
+	}));
+	yield* Effect.promise(waitUntilExit);
+	return approved;
+});
+const displayPlan = (plan) => Effect.sync(() => {
+	const { unmount } = render(jsx(Plan, { plan }));
+	unmount();
+});
+const startApplySession = Effect.fn(function* (plan) {
+	const listeners = /* @__PURE__ */ new Set();
+	const { unmount } = render(jsx(PlanProgress, {
+		plan,
+		source: { subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		} }
+	}));
+	return {
+		done: Effect.fn(function* () {
+			yield* Effect.sleep(10);
+			yield* Effect.sync(() => unmount());
+		}),
+		emit: (event) => Effect.sync(() => {
+			for (const listener of listeners) listener(event);
+		})
+	};
+});
+
+//#endregion
+//#region lib/Cli/exec.js
+const services = Layer.mergeAll(Layer.provideMerge(AlchemyContextLive, PlatformServices), FetchHttpClient.layer, ConfigProvider.layer(ConfigProvider.fromEnv()), inkCLI());
+const exec = () => execStack(S.decodeSync(ExecStackOptions)(JSON.parse(process.env.ALCHEMY_EXEC_OPTIONS))).pipe(Effect.provide(services), Effect.scoped);
+
+//#endregion
+//#region bin/exec.ts
+exec().pipe(runMain);
+
+//#endregion
+export {  };
+//# sourceMappingURL=exec.js.map