alchemy 2.0.0-beta.4 → 2.0.0-beta.41

package/bin/exec.js

@@ -0,0 +1,3360 @@
+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 Redacted from "effect/Redacted";
+import path from "pathe";
+import * as Config from "effect/Config";
+import os from "node:os";
+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 { SingleShotGen } from "effect/Utils";
+import { pipeArguments } from "effect/Pipeable";
+import "effect/Scope";
+import * as Duration from "effect/Duration";
+import * as Exit from "effect/Exit";
+import * as Metric from "effect/Metric";
+import { createHash } from "node:crypto";
+import * as Argument from "effect/unstable/cli/Argument";
+import * as CliError from "effect/unstable/cli/CliError";
+import { jsx, jsxs } from "react/jsx-runtime";
+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/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: {}
+});
+var Profile = class extends EffectContext.Service()("Alchemy::Profile") {};
+/**
+* Layer that builds the {@link Profile} service. Captures the
+* {@link FileSystem.FileSystem} dependency at layer-build time, so any
+* Effect that yields {@link Profile} ends up with `R = Profile` (no
+* `FileSystem` leak). Provide this once at the top of your runtime
+* (alongside `PlatformServices` / `NodeContext`).
+*/
+const ProfileLive = Layer.effect(Profile, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const readConfig = fs.readFileString(configFilePath).pipe(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));
+	const writeConfig = (config) => fs.makeDirectory(path.dirname(configFilePath), { recursive: true }).pipe(Effect.flatMap(() => fs.writeFileString(configFilePath, JSON.stringify(config, null, 2))));
+	const getProfile = (name) => readConfig.pipe(Effect.map((config) => config.profiles[name]));
+	const setProfile = (name, profile$1) => readConfig.pipe(Effect.tap((config) => Effect.sync(() => config.profiles[name] = profile$1)), Effect.flatMap(writeConfig));
+	const deleteProfile = (name) => readConfig.pipe(Effect.flatMap((config) => {
+		if (!(name in config.profiles)) return Effect.succeed(false);
+		delete config.profiles[name];
+		return writeConfig(config).pipe(Effect.as(true));
+	}));
+	const loadOrConfigure = (auth, profileName, ctx) => Effect.flatMap(getProfile(profileName), (existing) => existing?.[auth.name] ? Effect.succeed(existing[auth.name]) : Effect.tap(auth.configure(profileName, ctx), (config) => setProfile(profileName, {
+		...existing,
+		[auth.name]: config
+	})));
+	return {
+		readConfig,
+		writeConfig,
+		getProfile,
+		setProfile,
+		deleteProfile,
+		loadOrConfigure
+	};
+}));
+/**
+* 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/Credentials.js
+const credentialsDirPath = path.join(rootDir, "credentials");
+const profileCredentialsDirPath = (profile$1) => path.join(credentialsDirPath, profile$1);
+const credentialsFilePath = (profile$1, provider) => path.join(profileCredentialsDirPath(profile$1), `${provider}.json`);
+var CredentialsStore = class extends EffectContext.Service()("Alchemy::CredentialsStore") {};
+const CredentialsStoreLive = Layer.effect(CredentialsStore, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const read = (profile$1, provider) => fs.readFileString(credentialsFilePath(profile$1, provider)).pipe(Effect.catch(() => Effect.succeed(void 0)), Effect.map((data) => {
+		if (data === void 0) return void 0;
+		try {
+			return JSON.parse(data);
+		} catch {
+			return;
+		}
+	}));
+	const write = (profile$1, provider, credentials) => {
+		const filePath = credentialsFilePath(profile$1, provider);
+		return fs.makeDirectory(path.dirname(filePath), { recursive: true }).pipe(Effect.flatMap(() => fs.writeFileString(filePath, JSON.stringify(credentials, null, 2))));
+	};
+	const remove_ = (profile$1, provider) => fs.remove(credentialsFilePath(profile$1, provider)).pipe(Effect.catch(() => Effect.void));
+	const deleteProfile = (profile$1) => fs.remove(profileCredentialsDirPath(profile$1), { recursive: true }).pipe(Effect.catch(() => Effect.void));
+	return {
+		read,
+		write,
+		delete: remove_,
+		deleteProfile
+	};
+}));
+
+//#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) => ref[RefMetadata];
+
+//#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/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 effectClass = ((impl) => impl === void 0 ? (innerImpl) => effectClass(innerImpl) : Object.assign(class {
+	static asEffect() {
+		return impl;
+	}
+	static [Symbol.iterator]() {
+		return new SingleShotGen(this.asEffect());
+	}
+	static pipe(...fns) {
+		return pipeArguments(this, fns);
+	}
+}, impl));
+const taggedFunction = (tag$1, fn) => {
+	const overrides = {
+		asEffect: () => tag$1,
+		[Symbol.iterator]: () => tag$1[Symbol.iterator](),
+		pipe: (...fns) => pipeArguments(tag$1, fns),
+		toString: () => `${tag$1.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$1, prop, tag$1),
+		has: (target, prop) => Reflect.has(overrides, prop) || Reflect.has(target, prop) || Reflect.has(tag$1, 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) => {
+	if (!stackName) return (stackName$1) => Object.assign(stackRef(stackName$1).pipe(effectClass), {
+		stage: createStageProxy(stackName$1),
+		make: (options$1, eff$1) => Stack(stackName$1, options$1, eff$1)
+	});
+	return eff.pipe(make$1({
+		name: stackName,
+		...options
+	}), (eff$1) => Object.assign(eff$1, { stage: createStageProxy(stackName) }));
+}));
+const createStageProxy = (stackName) => new Proxy({}, { get: (_, stage$1) => stackRef(stackName, { stage: stage$1 }) });
+const StackName = Stack.use((stack) => Effect.succeed(stack.name));
+const make$1 = (options) => (effect) => Effect.scope.pipe(Effect.flatMap((scope) => {
+	if (options.state == null) return Effect.die(/* @__PURE__ */ new Error(`Stack "${options.name}" is missing a state store. Add a \`state\` layer to the stack options, e.g.:\n  Alchemy.Stack("${options.name}", {\n    providers: Cloudflare.providers(),\n    state: Cloudflare.state(), // <-- required\n  }, ...)\nSee https://v2.alchemy.run/concepts/state-store for available state stores.`));
+	if (options.providers == null) return Effect.die(/* @__PURE__ */ new Error(`Stack "${options.name}" is missing a providers layer. Add a \`providers\` layer to the stack options, e.g.:\n  Alchemy.Stack("${options.name}", {\n    providers: Cloudflare.providers(), // <-- required\n    state: Cloudflare.state(),\n  }, ...)`));
+	return options.providers.pipe(Layer.provideMerge(options.state), Layer.provideMerge(Layer.effect(Stack, Stage.pipe(Effect.map((stage$1) => options.stack ?? {
+		name: options.name,
+		stage: stage$1,
+		resources: {},
+		bindings: {},
+		actions: {}
+	})))), Layer.buildWithScope(scope));
+}), Effect.flatMap((context) => Effect.all([
+	effect,
+	Stack,
+	Effect.context()
+]).pipe(Effect.map(([output, stack, services$1]) => ({
+	...stack,
+	output,
+	services: EffectContext.merge(services$1, context)
+})), Effect.provideContext(context))));
+const CurrentStack = Effect.serviceOption(Stack).pipe(Effect.map(Option.getOrUndefined));
+const platform = Layer.mergeAll(PlatformServices, FetchHttpClient.layer, Logger.layer([fileLogger("out")], { mergeWithExisting: true }), Layer.provide(ProfileLive, PlatformServices), Layer.provide(CredentialsStoreLive, PlatformServices));
+
+//#endregion
+//#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
+const isActionState = (s) => !!s && s.kind === "action";
+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());
+	}
+	asEffect() {
+		return this.bind(this.toString());
+	}
+	bind(id) {
+		return RuntimeContext.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 isNamedExpr = (node) => node?.kind === "NamedExpr";
+/**
+* Wraps another `Expr` and overrides its `toString()` / inspect output.
+*
+* `BaseExpr` derives the binding id from `this.toString()`, so
+* wrapping an expression in `NamedExpr` makes that derived id stable and
+* caller-controlled (e.g. an env var name like `"API_KEY"`).
+*/
+var NamedExpr = class extends BaseExpr {
+	expr;
+	bindingName;
+	kind = "NamedExpr";
+	constructor(expr, bindingName) {
+		super();
+		this.expr = expr;
+		this.bindingName = bindingName;
+		return proxy(this);
+	}
+	[inspect]() {
+		return this.bindingName;
+	}
+};
+const isAllExpr = (node) => node?.kind === "AllExpr";
+var AllExpr = class extends BaseExpr {
+	outs;
+	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} })`;
+	}
+};
+const isStackRefExpr = (node) => node?.kind === "StackRefExpr";
+/**
+* A reference to the persisted output of a Stack at `(stack, stage)`.
+*
+* Resolved at evaluation time by reading `state.getOutput({ stack,
+* stage })`. Distinct from {@link RefExpr}, which references a
+* single resource's attributes within a stack/stage. `stage` may be
+* `undefined`, in which case it falls back to the current stage.
+*/
+var StackRefExpr = class extends BaseExpr {
+	stack;
+	stage;
+	kind = "StackRefExpr";
+	constructor(stack, stage$1) {
+		super();
+		this.stack = stack;
+		this.stage = stage$1;
+		return proxy(this);
+	}
+	[inspect]() {
+		return `stackRef(${this.stack}${this.stage ? `, { stage: ${this.stage} }` : ""})`;
+	}
+};
+/**
+* Build an `Output<A>` referencing the persisted output of another
+* Stack. The returned Effect resolves to a lazy `Output<A>` whose
+* value is read from the state store at plan/apply time.
+*
+* Returns `Effect<Output<A>>` (not `Output<A>` directly) so that
+* `yield* Output.stackRef(...)` reads ergonomically inside an Effect
+* generator and lines up with `Resource.ref` and `Stack.stage.<name>`.
+*/
+const stackRef = (stack, options = {}) => Effect.succeed(new StackRefExpr(stack, options.stage));
+function proxy(self) {
+	const target = Object.assign(() => {}, self);
+	if (inspect in self) Object.defineProperty(target, inspect, {
+		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) => {
+			throw new Error(`Cannot coerce Output<${self[inspect]()}> to a ${hint === "number" ? "number" : "string"} via JS coercion. Use Output.interpolate\`...\` or Output.map(output, fn) to compose Outputs — the value isn't known until deploy time.`);
+		} : prop === ExprSymbol ? self : prop === inspect ? target$1[inspect] : isResourceExpr(self) && self.stables && prop in self.stables ? self.stables[prop] : prop === "apply" ? self[prop] : prop in self ? typeof self[prop] === "function" && !("kind" in self) ? new PropExpr(proxy$1, prop) : self[prop] : new PropExpr(proxy$1, prop),
+		apply: (_, thisArg, args) => {
+			if (isPropExpr(self)) {
+				if (self.identifier === "apply") return new ApplyExpr(self.expr, args[0]);
+				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 (isNamedExpr(expr)) return yield* evaluate(expr.expr, upstream$1);
+		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 ?? resource.output;
+		} else if (isStackRefExpr(expr)) {
+			const state = yield* State;
+			const stack = expr.stack;
+			const stage$1 = expr.stage ?? (yield* Stage);
+			const output = yield* state.getOutput({
+				stack,
+				stage: stage$1
+			});
+			if (output == null) return yield* Effect.fail(new InvalidReferenceError({
+				message: `Reference to stack '${stack}' at stage '${stage$1}' not found. Have you deployed stage '${stage$1}' of '${stack}'?`,
+				stack,
+				stage: stage$1,
+				resourceId: stack
+			}));
+			return output;
+		}
+	}
+	if (Array.isArray(expr)) return yield* Effect.all(expr.map((item) => evaluate(item, upstream$1)));
+	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) || isNamedExpr(expr)) return upstream(expr.expr);
+	else if (Array.isArray(expr)) return expr.map(upstream).reduce(toObject, {});
+	else if (typeof expr === "object" && expr !== null) return Object.values(expr).map((v) => upstream(v)).reduce(toObject, {});
+	return {};
+};
+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 ?? {}, false)) !== JSON.stringify(canonicalize(newProps ?? {}, false));
+const canonicalize = (value, stripNullish) => {
+	if (stripNullish && value == null) return void 0;
+	if (Array.isArray(value)) return value.map((v) => canonicalize(v, stripNullish));
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).filter(([, nested]) => !stripNullish || nested != null).sort(([a], [b]) => a.localeCompare(b)).map(([key, nested]) => [key, canonicalize(nested, stripNullish)]));
+	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/Action.js
+const isAction = (value) => typeof value === "object" && value !== null && value?.Kind === "action";
+
+//#endregion
+//#region lib/Util/hash.js
+/**
+* Stable hash of a resolved Task input. Wrapped in `Effect.sync` so the
+* call participates in the Effect runtime (tracing/interruption) per the
+* Effect-platform conventions.
+*/
+const hashInput = (input) => Effect.sync(() => createHash("sha256").update(JSON.stringify(input ?? null)).digest("hex"));
+
+//#endregion
+//#region lib/Util/scc.js
+/**
+* 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 actions = Object.values(stack.actions ?? {});
+	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$1) => c$1.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* () {
+		if (isAction(resourceExpr.src)) return resourceExpr;
+		return yield* resolvedResources[resourceExpr.src.FQN] ??= yield* Effect.cached(Effect.gen(function* () {
+			const resource = resourceExpr.src;
+			const provider = yield* findProviderByType(resource.Type);
+			const props = yield* resolveInput(resource.Props);
+			const persisted = yield* state.get({
+				stack: stackName,
+				stage: stage$1,
+				fqn: resource.FQN
+			});
+			const oldState = isActionState(persisted) ? void 0 : persisted;
+			if (!oldState || oldState.status === "creating") return resourceExpr;
+			const oldProps = oldState.status === "updating" ? oldState.old.props : oldState.props;
+			const oldBindings = oldState.bindings ?? [];
+			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;
+		else if (isRefExpr(expr)) {
+			const refStack = expr.stack ?? stackName;
+			const refStage = expr.stage ?? stage$1;
+			const refState = yield* state.get({
+				stack: refStack,
+				stage: refStage,
+				fqn: expr.resourceId
+			}).pipe(Effect.orDie);
+			if (!refState) return yield* Effect.die(new InvalidReferenceError({
+				message: `Reference to '${expr.resourceId}' in stack '${refStack}' and stage '${refStage}' not found. Have you deployed '${refStage}' of '${refStack}'?`,
+				stack: refStack,
+				stage: refStage,
+				resourceId: expr.resourceId
+			}));
+			return refState.attr ?? refState.output;
+		} else if (isStackRefExpr(expr)) {
+			const refStack = expr.stack;
+			const refStage = expr.stage ?? stage$1;
+			const output = yield* state.getOutput({
+				stack: refStack,
+				stage: refStage
+			}).pipe(Effect.orDie);
+			if (output == null) return yield* Effect.die(new InvalidReferenceError({
+				message: `Reference to stack '${refStack}' at stage '${refStage}' not found. Have you deployed stage '${refStage}' of '${refStack}'?`,
+				stack: refStack,
+				stage: refStage,
+				resourceId: refStack
+			}));
+			return output;
+		} else if (isNamedExpr(expr)) return yield* resolveOutput(expr.expr);
+		return yield* Effect.die(/* @__PURE__ */ new Error("Not implemented yet" + expr.kind));
+	});
+	const oldDownstreamDependencies = Object.fromEntries(oldResources.filter((resource) => !!resource).map((resource) => [resource.fqn, resource.downstream]));
+	const newResourceFqns = new Set(resources.map((r) => r.FQN));
+	const newActionFqns = new Set(actions.map((t) => t.FQN));
+	const newNodeFqns = new Set([...newResourceFqns, ...newActionFqns]);
+	const newUpstreamDependencies = Object.fromEntries([...resources.map((resource) => [resource.FQN, Object.values(upstreamAny(resource.Props)).map((r) => r.FQN)]), ...actions.map((action) => [action.FQN, Object.values(upstreamAny(action.Input)).map((r) => r.FQN)])]);
+	const bindingUpstreamDependencies = Object.fromEntries(resources.map((resource) => [resource.FQN, Object.values(upstreamAny(stack.bindings[resource.FQN] ?? [])).map((r) => r.FQN)]));
+	const rawUpstreamDependencies = Object.fromEntries([...resources.map((resource) => {
+		const fqn = resource.FQN;
+		const propDeps = newUpstreamDependencies[fqn] ?? [];
+		const bindDeps = bindingUpstreamDependencies[fqn] ?? [];
+		return [fqn, [...new Set([...propDeps, ...bindDeps])]];
+	}), ...actions.map((action) => {
+		const fqn = action.FQN;
+		return [fqn, newUpstreamDependencies[fqn] ?? []];
+	})]);
+	const allUpstreamDependencies = Object.fromEntries([...resources.map((resource) => {
+		const fqn = resource.FQN;
+		return [fqn, (rawUpstreamDependencies[fqn] ?? []).filter((dep) => newNodeFqns.has(dep))];
+	}), ...actions.map((action) => {
+		const fqn = action.FQN;
+		return [fqn, (newUpstreamDependencies[fqn] ?? []).filter((dep) => newNodeFqns.has(dep))];
+	})]);
+	const combinedCycleMembers = findCycleMembers(allUpstreamDependencies);
+	const computeDownstream = (upFqn) => {
+		const downstream = [];
+		for (const [downFqn, upstreams] of Object.entries(rawUpstreamDependencies)) {
+			if (downFqn === upFqn) continue;
+			if (!upstreams.includes(upFqn)) continue;
+			if ((newUpstreamDependencies[downFqn] ?? []).includes(upFqn)) {
+				downstream.push(downFqn);
+				continue;
+			}
+			if (combinedCycleMembers.has(upFqn) && combinedCycleMembers.has(downFqn)) continue;
+			downstream.push(downFqn);
+		}
+		return downstream;
+	};
+	const newDownstreamDependencies = Object.fromEntries([...resources.map((resource) => [resource.FQN, computeDownstream(resource.FQN)]), ...actions.map((action) => [action.FQN, computeDownstream(action.FQN)])]);
+	const resourceGraph = Object.fromEntries((yield* Effect.all(resources.map(Effect.fn("plan.diff.resource")(function* (resource) {
+		const provider = yield* findProviderByType(resource.Type);
+		const id = resource.LogicalId;
+		const fqn = resource.FQN;
+		const news = yield* resolveInput(resource.Props);
+		const downstream = newDownstreamDependencies[fqn] ?? [];
+		const newBindings = yield* resolveInput(stack.bindings[fqn] ?? []);
+		const persisted = yield* state.get({
+			stack: stackName,
+			stage: stage$1,
+			fqn
+		});
+		let oldState = isActionState(persisted) ? void 0 : persisted;
+		let forceUpdateAfterAdoption = false;
+		if (oldState === void 0 && provider.read && isResolved(news)) {
+			const adoptInstanceId = yield* generateInstanceId();
+			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 actionGraph = Object.fromEntries(yield* Effect.all(actions.map(Effect.fn("plan.diff.action")(function* (action) {
+		const fqn = action.FQN;
+		const downstream = newDownstreamDependencies[fqn] ?? [];
+		const inputHash = yield* hashInput(yield* resolveInput(action.Input));
+		const oldState = yield* state.get({
+			stack: stackName,
+			stage: stage$1,
+			fqn
+		});
+		if (oldState && !isActionState(oldState)) return [fqn, {
+			kind: "action",
+			action: "run",
+			def: action,
+			input: action.Input,
+			state: void 0,
+			downstream,
+			forced: false
+		}];
+		const prior = oldState;
+		if (prior?.status === "ran" && prior.inputHash === inputHash && !options.force) return [fqn, {
+			kind: "action",
+			action: "noop",
+			def: action,
+			state: prior,
+			downstream
+		}];
+		return [fqn, {
+			kind: "action",
+			action: "run",
+			def: action,
+			input: action.Input,
+			state: prior,
+			downstream,
+			forced: !!options.force
+		}];
+	})), { concurrency: "unbounded" }));
+	const cycleMembers = combinedCycleMembers;
+	{
+		const createReplaceNodes = new Set(Object.entries(resourceGraph).filter(([_, node]) => node.action === "create" || node.action === "replace").map(([fqn]) => fqn));
+		if (createReplaceNodes.size > 0) {
+			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 actionDeletions = Object.fromEntries((yield* Effect.all((yield* state.list({
+		stack: stackName,
+		stage: stage$1
+	})).map(Effect.fn("plan.diff.actionDeletion")(function* (fqn) {
+		if (newActionFqns.has(fqn) || newResourceFqns.has(fqn)) return;
+		const persisted = yield* state.get({
+			stack: stackName,
+			stage: stage$1,
+			fqn
+		});
+		if (!isActionState(persisted)) return;
+		const { logicalId } = parseFqn(fqn);
+		return [fqn, {
+			kind: "action",
+			action: "delete",
+			state: persisted,
+			downstream: persisted.downstream ?? [],
+			def: {
+				Kind: "action",
+				Namespace: persisted.namespace,
+				FQN: fqn,
+				LogicalId: logicalId,
+				Type: persisted.actionType,
+				Input: persisted.input,
+				Run: () => void 0,
+				Output: void 0
+			}
+		}];
+	})), { concurrency: "unbounded" })).filter((v) => !!v));
+	const deletions = Object.fromEntries((yield* Effect.all((yield* state.list({
+		stack: stackName,
+		stage: stage$1
+	})).map(Effect.fn("plan.diff.deletion")(function* (fqn) {
+		if (newResourceFqns.has(fqn) || newActionFqns.has(fqn)) return;
+		const persisted = yield* state.get({
+			stack: stackName,
+			stage: stage$1,
+			fqn
+		});
+		if (isActionState(persisted)) return;
+		const oldState = persisted;
+		let attr = oldState?.attr;
+		if (oldState) {
+			const { logicalId } = parseFqn(fqn);
+			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,
+		actions: actionGraph,
+		deletions,
+		actionDeletions,
+		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]));
+	const resolved = yield* evaluate(plan.output, outputs);
+	yield* state.setOutput({
+		stack: stackName,
+		stage: stage$1,
+		value: resolved
+	});
+	return resolved;
+}).pipe(ensureArtifactStore, Effect.withSpan("apply", { attributes: {
+	"alchemy.resources.count": Object.keys(plan.resources).length,
+	"alchemy.deletions.count": Object.keys(plan.deletions).length
+} }));
+const executePlan = Effect.fnUntraced(function* (plan, tracker, terminalStatuses, session, state, stackName, stage$1) {
+	const allNodes = {
+		...plan.resources,
+		...plan.actions
+	};
+	const ready = Object.fromEntries(yield* Effect.all(Object.keys(allNodes).map((fqn) => Effect.map(Deferred.make(), (d) => [fqn, d]))));
+	const readyStable = Object.fromEntries(yield* Effect.all(Object.keys(allNodes).map((fqn) => Effect.map(Deferred.make(), (d) => [fqn, d]))));
+	const getOutputs = () => Object.fromEntries(Object.entries(tracker).map(([fqn, t]) => [fqn, t.output]));
+	const waitForDeps = (fqns) => Effect.all(fqns.filter((fqn) => fqn in ready).map((fqn) => Deferred.await(ready[fqn])), { concurrency: "unbounded" });
+	const waitForStableDeps = (fqns) => Effect.all(fqns.filter((fqn) => fqn in readyStable).map((fqn) => Deferred.await(readyStable[fqn])), { concurrency: "unbounded" });
+	const failures = [];
+	yield* Effect.all(Object.entries(allNodes).map(([fqn, node]) => node.kind === "action" ? executeActionNode(fqn, node, tracker, ready, readyStable, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForStableDeps, failures) : executeNode(fqn, node, tracker, ready, readyStable, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForDeps, failures, plan.cycleMembers.has(fqn))), { concurrency: "unbounded" });
+	if (failures.length > 0) yield* Effect.failCause(failures.map((f) => f.cause).reduce(Cause.combine));
+});
+const executeNode = (fqn, node, tracker, ready, readyStable, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForDeps, failures, inCycle) => Effect.gen(function* () {
+	const logicalId = node.resource.LogicalId;
+	const namespace = node.resource.Namespace;
+	const commit = (value) => state.set({
+		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.gen(function* () {
+		terminalStatuses.set(fqn, {
+			id: logicalId,
+			type: node.resource.Type,
+			status
+		});
+		if (inCycle) return;
+		yield* session.emit({
+			kind: "status-change",
+			id: logicalId,
+			type: node.resource.Type,
+			status
+		});
+	});
+	const signalReady = Deferred.succeed(ready[fqn], void 0);
+	const signalReadyStable = Deferred.succeed(readyStable[fqn], void 0);
+	const storeAndSignal = (t) => Effect.gen(function* () {
+		tracker[fqn] = t;
+		yield* signalReady;
+	});
+	if (node.action === "noop") {
+		yield* signalReadyStable;
+		yield* storeAndSignal({
+			output: node.state.attr,
+			props: node.state.props,
+			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("pending");
+			yield* waitForDeps(allUpstreamFqns());
+			yield* report("creating");
+			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* signalReadyStable;
+			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* report("pending");
+			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* signalReadyStable;
+			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* signalReadyStable;
+				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("pending");
+			yield* waitForDeps(allUpstreamFqns());
+			yield* report("creating replacement");
+			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* signalReadyStable;
+			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* Deferred.failCause(readyStable[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 executeActionNode = (fqn, node, tracker, ready, readyStable, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForDeps, failures) => Effect.gen(function* () {
+	const task = node.def;
+	const logicalId = task.LogicalId;
+	const namespace = task.Namespace;
+	const commit = (value) => state.set({
+		stack: stackName,
+		stage: stage$1,
+		fqn,
+		value: {
+			...value,
+			namespace
+		}
+	});
+	const report = (status) => session.emit({
+		kind: "status-change",
+		id: logicalId,
+		type: task.Type,
+		status
+	});
+	const signalReady = Deferred.succeed(ready[fqn], void 0);
+	const signalReadyStable = Deferred.succeed(readyStable[fqn], void 0);
+	if (node.action === "noop") {
+		tracker[fqn] = {
+			output: node.state.output,
+			props: { __input: node.state.input },
+			bindings: [],
+			instanceId: fqn
+		};
+		yield* signalReady;
+		yield* signalReadyStable;
+		terminalStatuses.set(fqn, {
+			id: logicalId,
+			type: task.Type,
+			status: "skipped"
+		});
+		yield* report("skipped");
+		return;
+	}
+	yield* report("pending");
+	yield* waitForDeps(Object.keys(resolveUpstream(node.input)).filter((f) => f in readyStable));
+	const outputs = getOutputs();
+	const resolvedInput = yield* evaluate(node.input, outputs);
+	const inputHashValue = yield* hashInput(resolvedInput);
+	yield* commit({
+		kind: "action",
+		status: "running",
+		fqn,
+		logicalId,
+		actionType: task.Type,
+		inputHash: inputHashValue,
+		input: resolvedInput,
+		downstream: node.downstream
+	});
+	yield* report("running");
+	const result = yield* task.Run(resolvedInput);
+	yield* commit({
+		kind: "action",
+		status: "ran",
+		fqn,
+		logicalId,
+		actionType: task.Type,
+		inputHash: inputHashValue,
+		input: resolvedInput,
+		output: result,
+		downstream: node.downstream
+	});
+	tracker[fqn] = {
+		output: result,
+		props: { __input: resolvedInput },
+		bindings: [],
+		instanceId: fqn
+	};
+	yield* signalReady;
+	yield* signalReadyStable;
+	terminalStatuses.set(fqn, {
+		id: logicalId,
+		type: task.Type,
+		status: "ran"
+	});
+	yield* report("ran");
+}).pipe(Effect.catchCause((cause) => Effect.gen(function* () {
+	failures.push({
+		fqn,
+		logicalId: node.def.LogicalId,
+		type: node.def.Type,
+		cause
+	});
+	yield* Deferred.failCause(ready[fqn], cause);
+	yield* Deferred.failCause(readyStable[fqn], cause);
+	yield* session.emit({
+		kind: "status-change",
+		id: node.def.LogicalId,
+		type: node.def.Type,
+		status: "fail"
+	});
+})), Effect.withSpan("apply.action", { attributes: {
+	"alchemy.action.fqn": fqn,
+	"alchemy.action.type": node.def.Type,
+	"alchemy.action.logical_id": node.def.LogicalId,
+	"alchemy.action.verb": node.action
+} }));
+const converge = Effect.fnUntraced(function* (plan, tracker, terminalStatuses, session, state, stackName, stage$1) {
+	for (;;) {
+		let anyUpdated = false;
+		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"
+			});
+		}
+		for (const [fqn, node] of Object.entries(plan.actions)) {
+			if (node.action !== "run") continue;
+			if (!tracker[fqn]) continue;
+			const outputs = Object.fromEntries(Object.entries(tracker).map(([k, t]) => [k, t.output]));
+			const newInput = yield* evaluate(node.input, outputs);
+			const newHash = yield* hashInput(newInput);
+			const oldInput = tracker[fqn].props?.__input;
+			if (newHash === (yield* hashInput(oldInput))) continue;
+			anyUpdated = true;
+			yield* state.set({
+				stack: stackName,
+				stage: stage$1,
+				fqn,
+				value: {
+					kind: "action",
+					status: "running",
+					fqn,
+					logicalId: node.def.LogicalId,
+					namespace: node.def.Namespace,
+					actionType: node.def.Type,
+					inputHash: newHash,
+					input: newInput,
+					downstream: node.downstream
+				}
+			});
+			const result = yield* node.def.Run(newInput);
+			yield* state.set({
+				stack: stackName,
+				stage: stage$1,
+				fqn,
+				value: {
+					kind: "action",
+					status: "ran",
+					fqn,
+					logicalId: node.def.LogicalId,
+					namespace: node.def.Namespace,
+					actionType: node.def.Type,
+					inputHash: newHash,
+					input: newInput,
+					output: result,
+					downstream: node.downstream
+				}
+			});
+			tracker[fqn] = {
+				output: result,
+				props: { __input: newInput },
+				bindings: [],
+				instanceId: fqn
+			};
+			terminalStatuses.set(fqn, {
+				id: node.def.LogicalId,
+				type: node.def.Type,
+				status: "ran"
+			});
+		}
+		if (!anyUpdated) break;
+	}
+});
+const collectGarbage = Effect.fnUntraced(function* (plan, session) {
+	const state = yield* State;
+	const stackName = (yield* Stack).name;
+	const stage$1 = yield* Stage;
+	yield* Effect.all(Object.entries(plan.actionDeletions ?? {}).map(([fqn, node]) => node === void 0 ? Effect.void : Effect.gen(function* () {
+		yield* session.emit({
+			kind: "status-change",
+			id: node.def.LogicalId,
+			type: node.def.Type,
+			status: "deleting"
+		});
+		yield* state.delete({
+			stack: stackName,
+			stage: stage$1,
+			fqn
+		});
+		yield* session.emit({
+			kind: "status-change",
+			id: node.def.LogicalId,
+			type: node.def.Type,
+			status: "deleted"
+		});
+	})), { concurrency: "unbounded" });
+	const deleteGraph = Effect.fnUntraced(function* (deletionGraph) {
+		const deletions = {};
+		const deleteResource = (node, ancestors = /* @__PURE__ */ new Set()) => Effect.gen(function* () {
+			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, 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.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.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/LoggingCli.js
+const ESC = "\x1B[";
+const RESET = `${ESC}0m`;
+const useColor = process.stdout.hasColors?.() ?? !!process.stdout.isTTY;
+const c = (code, s) => useColor ? `${ESC}${code}m${s}${RESET}` : s;
+const dim = (s) => c("2", s);
+const bold = (s) => c("1", s);
+const red = (s) => c("31", s);
+const green = (s) => c("32", s);
+const yellow = (s) => c("33", s);
+const blue = (s) => c("34", s);
+const magenta = (s) => c("35", s);
+const cyan = (s) => c("36", s);
+const actionColor$1 = {
+	create: green,
+	update: yellow,
+	replace: magenta,
+	delete: red,
+	noop: dim
+};
+const statusColor$1 = (status) => {
+	switch (status) {
+		case "created":
+		case "updated":
+		case "replaced": return green;
+		case "deleted": return dim;
+		case "fail": return red;
+		case "attaching":
+		case "post-attach": return cyan;
+		default: return yellow;
+	}
+};
+const tag = (id) => bold(`[${id}]`);
+const isTerminal = (status) => status === "created" || status === "updated" || status === "deleted" || status === "replaced" || status === "fail";
+const formatPlanLines = (plan) => {
+	const items = [...Object.values(plan.resources), ...Object.values(plan.deletions)];
+	if (items.length === 0) return [bold("Plan:") + " no changes"];
+	const counts = items.reduce((acc, item) => (acc[item.action] = (acc[item.action] ?? 0) + 1, acc), {});
+	const summary = [
+		"create",
+		"update",
+		"replace",
+		"delete",
+		"noop"
+	].filter((a) => counts[a]).map((a) => actionColor$1[a](`${counts[a]} to ${a}`)).join(dim(", "));
+	const sorted = [...items].sort((a, b) => a.resource.LogicalId.localeCompare(b.resource.LogicalId));
+	const lines = [`${bold("Plan:")} ${summary}`];
+	for (const item of sorted) {
+		const action = actionColor$1[item.action](item.action);
+		lines.push(`${tag(item.resource.LogicalId)} ${action}`);
+		for (const binding of item.bindings) {
+			if (binding.action === "noop") continue;
+			const bindingAction = actionColor$1[binding.action](binding.action);
+			lines.push(`${tag(`${item.resource.LogicalId}/${binding.sid}`)} ${bindingAction}`);
+		}
+	}
+	return lines;
+};
+const LoggingCli = Layer.succeed(Cli, Cli.of({
+	approvePlan: (plan) => Effect.gen(function* () {
+		for (const line of formatPlanLines(plan)) yield* Console.log(line);
+		yield* Console.log(`\n${yellow("Non-interactive terminal detected.")} Pass ${bold("--yes")} to approve, or set ${bold("ALCHEMY_TUI=1")} for the interactive UI.`);
+		return false;
+	}),
+	displayPlan: (plan) => Effect.gen(function* () {
+		for (const line of formatPlanLines(plan)) yield* Console.log(line);
+	}),
+	startApplySession: (plan) => Effect.gen(function* () {
+		for (const line of formatPlanLines(plan)) yield* Console.log(line);
+		yield* Console.log("");
+		const counts = {
+			ok: 0,
+			fail: 0
+		};
+		return {
+			emit: (event) => Effect.sync(() => {
+				if (event.kind === "annotate") {
+					console.log(`${tag(event.id)} ${blue(event.message)}`);
+					return;
+				}
+				const id = event.bindingId ? `${event.id}/${event.bindingId}` : event.id;
+				const status = statusColor$1(event.status)(event.status);
+				const msg = event.message ? ` ${dim("—")} ${event.message}` : "";
+				console.log(`${tag(id)} ${status}${msg}`);
+				if (isTerminal(event.status)) if (event.status === "fail") counts.fail++;
+				else counts.ok++;
+			}),
+			done: () => Console.log(`\n${bold("Done:")} ${green(`${counts.ok} succeeded`)}${counts.fail ? dim(", ") + red(`${counts.fail} failed`) : ""}`)
+		};
+	})
+}));
+
+//#endregion
+//#region lib/Cli/NamespaceTree.js
+function buildNamespaceTree(items, actions = []) {
+	const root = {
+		id: "",
+		path: [],
+		children: /* @__PURE__ */ new Map(),
+		resources: [],
+		actions: []
+	};
+	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: [],
+					actions: []
+				};
+				current.children.set(segment, child);
+			}
+			current = child;
+		}
+		return current;
+	};
+	for (const item of items) getNode(toPath(item.resource.Namespace)).resources.push(item);
+	for (const action of actions) getNode(toPath(action.def.Namespace)).actions.push(action);
+	return root;
+}
+function deriveNamespaceAction(node) {
+	const actions = /* @__PURE__ */ new Set();
+	for (const resource of node.resources) actions.add(deriveResourceChildrenAction(resource, node));
+	for (const action of node.actions) actions.add(action.action === "run" ? "create" : action.action === "delete" ? "delete" : "noop");
+	for (const child of node.children.values()) {
+		const childAction = deriveNamespaceAction(child);
+		if (childAction === "mixed") return "mixed";
+		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 sortedActions = [...node.actions].sort((a, b) => a.def.LogicalId.localeCompare(b.def.LogicalId));
+	for (const action of sortedActions) result.push({
+		type: "action",
+		depth,
+		id: action.def.LogicalId,
+		path: [...node.path, action.def.LogicalId],
+		action: action.action,
+		actionType: action.def.Type
+	});
+};
+const isEmpty = (node) => node.resources.length === 0 && node.actions.length === 0 && Array.from(node.children.values()).every(isEmpty);
+const deriveResourceChildrenAction = (resource, node) => {
+	const actions = new Set([resource.action]);
+	for (const binding of resource.bindings) actions.add(binding.action);
+	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 taskItems = useMemo(() => [...Object.values(plan.actions ?? {}), ...Object.values(plan.actionDeletions ?? {})].filter((t) => t !== void 0), [plan]);
+	const flatItems = useMemo(() => {
+		return flattenTree(buildNamespaceTree(items, taskItems));
+	}, [items, taskItems]);
+	if (items.length === 0 && taskItems.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 taskCounts = taskItems.reduce((acc, item) => (acc[item.action]++, acc), {
+		run: 0,
+		noop: 0,
+		delete: 0
+	});
+	const actions = [
+		"create",
+		"update",
+		"delete",
+		"replace"
+	].filter((action) => counts[action] > 0);
+	const taskHeaderEntries = [taskCounts.run > 0 ? `${taskCounts.run} to run` : void 0, taskCounts.delete > 0 ? `${taskCounts.delete} to drop` : void 0].filter((s) => !!s);
+	return jsxs(Box, {
+		flexDirection: "column",
+		children: [jsxs(Box, {
+			marginTop: 1,
+			children: [
+				jsx(Text, {
+					underline: true,
+					children: "Plan"
+				}),
+				jsx(Text, { children: ": " }),
+				[...actions.map((action) => {
+					const count = counts[action];
+					return jsx(Box, { children: jsxs(Text, {
+						color: actionColor(action),
+						children: [
+							count,
+							" to ",
+							action
+						]
+					}) }, action);
+				}), ...taskHeaderEntries.map((label, i) => jsx(Box, { children: jsx(Text, {
+					color: "cyan",
+					children: label
+				}) }, `task-${i}`))].flatMap((box, i, arr) => i === arr.length - 1 ? [box] : [box, jsx(Text, { children: " | " }, `sep-${i}`)])
+			]
+		}), jsx(Box, {
+			flexDirection: "column",
+			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);
+				if (item.type === "action") return jsxs(Box, {
+					flexDirection: "row",
+					children: [
+						jsx(Text, { children: indent }),
+						jsx(Box, {
+							width: 2,
+							children: jsxs(Text, {
+								color,
+								children: [icon, " "]
+							})
+						}),
+						jsx(Box, { children: jsx(Text, {
+							bold: true,
+							children: item.id
+						}) }),
+						jsx(Box, {
+							marginLeft: 1,
+							children: jsxs(Text, {
+								color: "blackBright",
+								children: [
+									"(",
+									item.actionType,
+									")"
+								]
+							})
+						}),
+						jsx(Box, {
+							marginLeft: 1,
+							children: jsx(Text, {
+								color: "cyan",
+								children: "[action]"
+							})
+						})
+					]
+				}, key);
+				return jsxs(Box, {
+					flexDirection: "row",
+					children: [
+						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",
+	run: "cyan"
+})[action] ?? "gray";
+const getActionIcon = (action) => ({
+	create: "+",
+	update: "~",
+	delete: "-",
+	noop: "•",
+	replace: "!",
+	mixed: "*",
+	run: "λ"
+})[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)], [...Object.values(plan.actions ?? {}), ...Object.values(plan.actionDeletions ?? {})].filter((t) => t !== void 0))).filter((item) => item.type !== "binding").map((item) => {
+		if (item.type === "namespace") return {
+			key: getTaskKey(item),
+			type: "namespace",
+			id: item.id,
+			depth: item.depth,
+			action: item.action
+		};
+		if (item.type === "action") return {
+			key: getTaskKey(item),
+			type: "task",
+			id: item.id,
+			depth: item.depth,
+			actionType: item.actionType ?? "unknown",
+			action: item.action
+		};
+		return {
+			key: getTaskKey(item),
+			type: "resource",
+			id: item.id,
+			depth: item.depth,
+			resourceType: item.resourceType ?? "unknown",
+			action: item.action,
+			persistedApplyStatus: item.action === "noop" ? (() => {
+				const crud = findCrudByLogicalId(plan, item.id);
+				return crud?.action === "noop" ? crud.state.status : void 0;
+			})() : void 0
+		};
+	});
+};
+const buildLogicalIdIndex = (rows) => {
+	const index = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (row.type !== "resource" && row.type !== "task") 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)]] : row.type === "task" ? [[row.key, {
+	key: row.key,
+	id: row.id,
+	type: row.actionType,
+	status: row.action === "noop" ? "skipped" : "pending",
+	updatedAt: Date.now()
+}]] : []));
+function PlanProgress(props) {
+	const { source, plan } = props;
+	const spinner = useGlobalSpinner();
+	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);
+			if (row.type === "task") {
+				const t = tasks.get(row.key);
+				const status = t?.status ?? (row.action === "noop" ? "ran" : "pending");
+				const color$1 = statusColor(status);
+				const icon$1 = taskIcon(row.action, status, spinner);
+				const label = row.action === "delete" ? status === "deleted" ? "deleted" : "drop" : status === "ran" ? row.action === "noop" ? "skip" : "ran" : status === "running" ? "running" : status === "fail" ? "fail" : row.action === "noop" ? "skip" : "run";
+				return jsxs(Box, {
+					flexDirection: "column",
+					children: [jsxs(Box, {
+						flexDirection: "row",
+						children: [
+							jsx(Text, { children: indent }),
+							jsx(Box, {
+								width: 2,
+								children: jsxs(Text, {
+									color: color$1,
+									children: [icon$1, " "]
+								})
+							}),
+							jsx(Text, {
+								bold: true,
+								children: row.id
+							}),
+							jsxs(Text, {
+								dimColor: true,
+								children: [
+									" (",
+									row.actionType,
+									")"
+								]
+							}),
+							jsxs(Text, {
+								color: color$1,
+								children: [" ", label]
+							}),
+							jsxs(Text, {
+								color: "cyan",
+								dimColor: true,
+								children: [" ", "[action]"]
+							})
+						]
+					}), t?.message ? jsx(Box, {
+						paddingLeft: row.depth * 2 + 2,
+						children: jsxs(Text, {
+							dimColor: true,
+							children: ["• ", t.message]
+						})
+					}) : null]
+				}, row.key);
+			}
+			const task = tasks.get(row.key) ?? toPlanTask(row);
+			const displayStatus = getDisplayStatus(row, task.status);
+			const color = statusColor(displayStatus);
+			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 "running":
+		case "ran": return "cyan";
+		case "skipped": return "gray";
+		case "fail": return "redBright";
+		default: return;
+	}
+}
+function taskIcon(action, status, spinnerChar) {
+	if (status === "running") return spinnerChar;
+	if (status === "fail") return "✗";
+	if (status === "skipped") return "•";
+	if (status === "ran") return action === "noop" ? "•" : "✓";
+	if (status === "deleted") return "✓";
+	if (action === "delete") return "-";
+	if (action === "noop") return "•";
+	return "λ";
+}
+function statusIcon(status, spinnerChar) {
+	if (isInProgress(status)) return spinnerChar;
+	if (status === "fail") return "✗";
+	return "✓";
+}
+function isInProgress(status) {
+	return status === "pending" || status === "creating" || status === "updating" || status === "deleting" || status === "running";
+}
+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/selectCli.js
+/**
+* Returns true when the current process looks like it's being driven by a
+* coding agent, CI runner, or anything else that won't render an interactive
+* TUI well. The Ink renderer repaints the screen on every event, which floods
+* agent transcripts with redundant frames; LoggingCli emits one line per
+* status change instead.
+*/
+const isNonInteractive = () => {
+	const env = process.env;
+	if (env.ALCHEMY_PLAIN === "1" || env.ALCHEMY_NO_TUI === "1") return true;
+	if (env.ALCHEMY_TUI === "1") return false;
+	if (!process.stdout.isTTY) return true;
+	if (env.CI) return true;
+	if (env.CLAUDECODE || env.CLAUDE_CODE_ENTRYPOINT || env.CURSOR_AGENT || env.AIDER_MODEL || env.CODEX_CLI) return true;
+	return false;
+};
+const selectCli = () => isNonInteractive() ? LoggingCli : inkCLI();
+
+//#endregion
+//#region lib/Cli/exec.js
+const services = Layer.mergeAll(Layer.provideMerge(AlchemyContextLive, PlatformServices), Layer.provide(ProfileLive, PlatformServices), Layer.provide(CredentialsStoreLive, PlatformServices), FetchHttpClient.layer, ConfigProvider.layer(ConfigProvider.fromEnv()), selectCli());
+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