alchemy 2.0.0-beta.59 → 2.0.0-beta.60

package/bin/exec.js

@@ -37,6 +37,7 @@ import * as Flag from "effect/unstable/cli/Flag";
 import * as Metric from "effect/Metric";
 import * as Argument from "effect/unstable/cli/Argument";
 import * as CliError from "effect/unstable/cli/CliError";
+import { pathToFileURL } from "node:url";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { Box, Text, render, useApp, useInput } from "ink";
 import { useEffect, useMemo, useRef, useState } from "react";
@@ -58,219 +59,172 @@ var __export = (all) => {
 
 //#endregion
 //#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
-	};
-}));
+var AlchemyContext, AlchemyContextLive;
+var init_AlchemyContext = __esm({ "lib/AlchemyContext.js": (() => {
+	AlchemyContext = class extends EffectContext.Service()("alchemy/Context") {};
+	AlchemyContextLive = Layer.effect(AlchemyContext, Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem;
+		const dir = (yield* Path$1.Path).join(process.cwd(), ".alchemy");
+		yield* fs.makeDirectory(dir, { recursive: true });
+		return {
+			dotAlchemy: dir,
+			updateStateStore: false,
+			dev: false,
+			adopt: false
+		};
+	}));
+}) });
 
 //#endregion
 //#region lib/Util/interactive.js
-/**
-* Returns true when the current process looks like it's being driven by a
-* coding agent, CI runner, test runner, or anything else that won't render an
-* interactive TUI / prompt well.
-*
-* Two callers rely on this:
-*  - `Cli/selectCli.ts` uses it to pick `LoggingCli` over the Ink TUI.
-*  - `Auth/Profile.ts` uses it to refuse to launch an interactive credential
-*    configure flow (and thus avoid acquiring an auth lockfile) when there's
-*    no TTY to drive the prompts.
-*
-* Kept in `Util` (rather than `Cli`) so `Auth` can depend on it without
-* pulling in the CLI layer.
-*/
-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;
-};
+var isNonInteractive;
+var init_interactive = __esm({ "lib/Util/interactive.js": (() => {
+	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;
+	};
+}) });
 
 //#endregion
 //#region lib/Auth/AuthProvider.js
-const interactiveMutex = Semaphore.makeUnsafe(1);
-var AuthError = class extends Schema.TaggedErrorClass()("AuthError", {
-	message: Schema.String,
-	cause: Schema.optional(Schema.Defect())
-}) {};
-var AuthProviders = class extends EffectContext.Service()("AuthProviders") {};
+var interactiveMutex, AuthError, AuthProviders;
+var init_AuthProvider = __esm({ "lib/Auth/AuthProvider.js": (() => {
+	interactiveMutex = Semaphore.makeUnsafe(1);
+	AuthError = class extends Schema.TaggedErrorClass()("AuthError", {
+		message: Schema.String,
+		cause: Schema.optional(Schema.Defect())
+	}) {};
+	AuthProviders = class extends EffectContext.Service()("AuthProviders") {};
+}) });
 
 //#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 AlchemyProfile = class extends EffectContext.Service()("Alchemy::Profile") {};
-/**
-* Layer that builds the {@link AlchemyProfile} service. Captures the
-* {@link FileSystem.FileSystem} dependency at layer-build time, so any
-* Effect that yields {@link AlchemyProfile} ends up with `R = Profile` (no
-* `FileSystem` leak). Provide this once at the top of your runtime
-* (alongside `PlatformServices` / `NodeContext`).
-*/
-const ProfileLive = Layer.effect(AlchemyProfile, 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) => {
-		const stored = existing?.[auth.name];
-		if (stored) return Effect.succeed(stored);
-		if (!ctx.ci && isNonInteractive()) return Effect.fail(new AuthError({ message: `No credentials configured for '${auth.name}' in profile '${profileName}', and this process is non-interactive so it can't be configured interactively. Run \`alchemy login --profile ${profileName}\` to configure it, or set CI=1 to use environment-variable credentials.` }));
-		return Effect.tap(auth.configure(profileName, ctx), (config) => setProfile(profileName, {
-			...existing,
-			[auth.name]: config
-		}));
+var rootDir, configFilePath, ALCHEMY_PROFILE, CONFIG_VERSION, emptyConfig, AlchemyProfile, ProfileLive, withProfileOverride;
+var init_Profile = __esm({ "lib/Auth/Profile.js": (() => {
+	init_interactive();
+	init_AuthProvider();
+	rootDir = path.join(os.homedir(), ".alchemy");
+	configFilePath = path.join(rootDir, "profiles.json");
+	ALCHEMY_PROFILE = Config.string("ALCHEMY_PROFILE").pipe(Config.withDefault("default"));
+	CONFIG_VERSION = 0;
+	emptyConfig = () => ({
+		version: CONFIG_VERSION,
+		profiles: {}
 	});
-	return {
-		readConfig,
-		writeConfig,
-		getProfile,
-		setProfile,
-		deleteProfile,
-		loadOrConfigure
+	AlchemyProfile = class extends EffectContext.Service()("Alchemy::Profile") {};
+	ProfileLive = Layer.effect(AlchemyProfile, 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) => {
+			const stored = existing?.[auth.name];
+			if (stored) return Effect.succeed(stored);
+			if (!ctx.ci && isNonInteractive()) return Effect.fail(new AuthError({ message: `No credentials configured for '${auth.name}' in profile '${profileName}', and this process is non-interactive so it can't be configured interactively. Run \`alchemy login --profile ${profileName}\` to configure it, or set CI=1 to use environment-variable credentials.` }));
+			return Effect.tap(auth.configure(profileName, ctx), (config) => setProfile(profileName, {
+				...existing,
+				[auth.name]: config
+			}));
+		});
+		return {
+			readConfig,
+			writeConfig,
+			getProfile,
+			setProfile,
+			deleteProfile,
+			loadOrConfigure
+		};
+	}));
+	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);
 	};
-}));
-/**
-* 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(() => {
-			return fs.writeFileString(filePath, JSON.stringify(credentials, null, 2));
+var credentialsDirPath, profileCredentialsDirPath, credentialsFilePath, CredentialsStore, CredentialsStoreLive;
+var init_Credentials = __esm({ "lib/Auth/Credentials.js": (() => {
+	init_Profile();
+	credentialsDirPath = path.join(rootDir, "credentials");
+	profileCredentialsDirPath = (profile$1) => path.join(credentialsDirPath, profile$1);
+	credentialsFilePath = (profile$1, provider) => path.join(profileCredentialsDirPath(profile$1), `${provider}.json`);
+	CredentialsStore = class extends EffectContext.Service()("Alchemy::CredentialsStore") {};
+	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 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
-	};
-}));
+		const write = (profile$1, provider, credentials) => {
+			const filePath = credentialsFilePath(profile$1, provider);
+			return fs.makeDirectory(path.dirname(filePath), { recursive: true }).pipe(Effect.flatMap(() => {
+				return 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/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);
-		})
+var Artifacts, ArtifactStore, createArtifactStore, getOrCreateBag, makeScopedArtifacts, ensureArtifactStore;
+var init_Artifacts = __esm({ "lib/Artifacts.js": (() => {
+	Artifacts = class extends EffectContext.Service()("Artifacts") {};
+	ArtifactStore = class extends EffectContext.Service()("Artifacts/Store") {};
+	createArtifactStore = () => /* @__PURE__ */ new Map();
+	getOrCreateBag = (store, fqn) => {
+		const existing = store.get(fqn);
+		if (existing) return existing;
+		const bag = /* @__PURE__ */ new Map();
+		store.set(fqn, bag);
+		return bag;
 	};
-};
-/**
-* 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()))));
+	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);
+			})
+		};
+	};
+	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
@@ -281,111 +235,36 @@ var init_Cli = __esm({ "lib/Cli/Cli.js": (() => {
 
 //#endregion
 //#region lib/Ref.js
-const RefMetadata = Symbol.for("alchemy/RefMetadata");
-const isRef = (s) => s && s[RefMetadata] !== void 0;
-const getRefMetadata = (ref) => ref[RefMetadata];
+var RefMetadata, isRef, getRefMetadata;
+var init_Ref = __esm({ "lib/Ref.js": (() => {
+	RefMetadata = Symbol.for("alchemy/RefMetadata");
+	isRef = (s) => s && s[RefMetadata] !== void 0;
+	getRefMetadata = (ref) => ref[RefMetadata];
+}) });
 
 //#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.fn(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;
-};
+var AdoptPolicy, OwnedBySomeoneElse, UnownedTag, Unowned, stripUnowned;
+var init_AdoptPolicy = __esm({ "lib/AdoptPolicy.js": (() => {
+	AdoptPolicy = class extends EffectContext.Service()("AdoptPolicy") {};
+	OwnedBySomeoneElse = class extends Data.TaggedError("OwnedBySomeoneElse") {};
+	UnownedTag = Symbol("alchemy/Unowned");
+	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 });
+	stripUnowned = (attrs) => {
+		const out = { ...attrs };
+		if (UnownedTag in out) delete out[UnownedTag];
+		return out;
+	};
+}) });
 
 //#endregion
 //#region lib/FQN.js
@@ -413,280 +292,73 @@ var init_FQN = __esm({ "lib/FQN.js": (() => {
 
 //#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.fn(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();
-});
+var Provider, isProviderCollectionService, findProviderByType, tryFindProviderByType;
+var init_Provider = __esm({ "lib/Provider.js": (() => {
+	Provider = (type) => EffectContext.Service()(type);
+	isProviderCollectionService = (value) => {
+		return typeof value === "object" && value !== null && "kind" in value && value.kind === "ProviderCollection";
+	};
+	findProviderByType = ((type) => tryFindProviderByType(type).pipe(Effect.flatMap(Option.match({
+		onNone: () => Effect.die(`Provider not found for ${type}`),
+		onSome: (provider) => Effect.succeed(provider)
+	}))));
+	tryFindProviderByType = Effect.fn(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/Resource.js
-const isResource = (value) => {
-	return typeof value === "object" && value !== null && "Type" in value;
-};
+var isResource;
+var init_Resource = __esm({ "lib/Resource.js": (() => {
+	isResource = (value) => {
+		return typeof value === "object" && value !== null && "Type" in value;
+	};
+}) });
 
 //#endregion
 //#region lib/RuntimeContext.js
-/**
-* Canonicalize a logical key into a key that is safe to use as the name of an
-* environment variable / binding (`[a-zA-Z][a-zA-Z0-9_]*`).
-*
-* `RuntimeContext.set`/`get` are dumb key/value stores: they read and write the
-* key **verbatim**. It is the *caller's* responsibility to hand them a
-* canonical key, since the caller is the one that knows the logical key may
-* contain `.`/`-` (e.g. a dotted config name from `Platform`, or an
-* `Output.toString()` like `"QueueSinkQueue.queueUrl"`). Callers run the key
-* through this before calling `set`/`get` so both sides agree.
-*/
-const sanitizeKey = (key) => key.replaceAll(/[^a-zA-Z0-9]/g, "_");
-/**
-* Context of the runtime environment.
-*
-* E.g. the context of a running Worker, Task, Process, Function
-*/
-var RuntimeContext = class extends EffectContext.Service()("RuntimeContext") {
-	static phantom = Layer.empty;
-};
-const CurrentRuntimeContext = Effect.serviceOption(RuntimeContext).pipe(Effect.map(Option.getOrUndefined));
+var sanitizeKey, RuntimeContext, CurrentRuntimeContext;
+var init_RuntimeContext = __esm({ "lib/RuntimeContext.js": (() => {
+	sanitizeKey = (key) => key.replaceAll(/[^a-zA-Z0-9]/g, "_");
+	RuntimeContext = class extends EffectContext.Service()("RuntimeContext") {
+		static phantom = Layer.empty;
+	};
+	CurrentRuntimeContext = Effect.serviceOption(RuntimeContext).pipe(Effect.map(Option.getOrUndefined));
+}) });
 
 //#endregion
 //#region lib/Stage.js
-var Stage = class extends EffectContext.Service()("Stage") {};
+var Stage;
+var init_Stage = __esm({ "lib/Stage.js": (() => {
+	Stage = class extends EffectContext.Service()("Stage") {};
+}) });
 
 //#endregion
 //#region lib/State/State.js
-const isActionState = (s) => !!s && s.kind === "action";
-var State = class extends EffectContext.Service()("alchemy/State") {};
+var isActionState, State;
+var init_State = __esm({ "lib/State/State.js": (() => {
+	isActionState = (s) => !!s && s.kind === "action";
+	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";
+var isPrimitive;
+var init_data = __esm({ "lib/Util/data.js": (() => {
+	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 asOutput = (t) => isOutput(t) ? t : Effect.isEffect(t) ? new EffectExpr(VoidExpr, () => t) : new LiteralExpr(t);
-const isOutput = (value) => value && (typeof value === "object" || typeof value === "function") && ExprSymbol in value;
-const ExprSymbol = Symbol.for("alchemy/Expr");
-const exprKind = (node) => node?.[ExprSymbol]?.kind ?? node?.kind;
-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) {
-		const key = sanitizeKey(id);
-		return RuntimeContext.pipe(Effect.flatMap((ctx) => Effect.map(ctx.set(key, this), (k) => ctx.get(k))));
-	}
-	pipe(...fns) {
-		return pipe(this, ...fns);
-	}
-	toString() {
-		return this[inspect]();
-	}
-};
-const isResourceExpr = (node) => exprKind(node) === "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) => exprKind(node) === "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) => exprKind(node) === "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) => exprKind(node) === "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 isFlatMapExpr = (node) => exprKind(node) === "FlatMapExpr";
-var FlatMapExpr = class extends BaseExpr {
-	expr;
-	f;
-	kind = "FlatMapExpr";
-	constructor(expr, f) {
-		super();
-		this.expr = expr;
-		this.f = f;
-		return proxy(this);
-	}
-	[inspect]() {
-		return `${this.expr[inspect]()}.flatMap(${this.f.toString()})`;
-	}
-};
-const isEffectExpr = (node) => exprKind(node) === "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) => exprKind(node) === "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) => exprKind(node) === "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) => exprKind(node) === "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) => exprKind(node) === "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, {
@@ -708,211 +380,427 @@ function proxy(self) {
 	});
 	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;
+var inspect, of, asOutput, isOutput, ExprSymbol, exprKind, isExpr, BaseExpr, isResourceExpr, ResourceExpr, isPropExpr, PropExpr, isLiteralExpr, LiteralExpr, VoidExpr, isApplyExpr, ApplyExpr, isFlatMapExpr, FlatMapExpr, isEffectExpr, EffectExpr, isNamedExpr, NamedExpr, isAllExpr, AllExpr, isRefExpr, RefExpr, isStackRefExpr, StackRefExpr, stackRef, MissingSourceError, InvalidReferenceError, evaluate, hasOutputs, upstreamAny, upstream, resolveUpstream, toObject;
+var init_Output = __esm({ "lib/Output.js": (() => {
+	init_Ref();
+	init_Resource();
+	init_RuntimeContext();
+	init_Stack();
+	init_Stage();
+	init_State();
+	init_data();
+	inspect = Symbol.for("nodejs.util.inspect.custom");
+	of = (resource) => {
+		if (isRef(resource)) {
+			const metadata = getRefMetadata(resource);
+			return new RefExpr(metadata.stack, metadata.stage, metadata.id);
+		}
+		return new ResourceExpr(resource);
+	};
+	asOutput = (t) => isOutput(t) ? t : Effect.isEffect(t) ? new EffectExpr(VoidExpr, () => t) : new LiteralExpr(t);
+	isOutput = (value) => value && (typeof value === "object" || typeof value === "function") && ExprSymbol in value;
+	ExprSymbol = Symbol.for("alchemy/Expr");
+	exprKind = (node) => node?.[ExprSymbol]?.kind ?? node?.kind;
+	isExpr = (value) => value && (typeof value === "object" || typeof value === "function") && ExprSymbol in value;
+	BaseExpr = class {
+		constructor() {}
+		as() {
+			return this;
+		}
+		[Symbol.iterator]() {
+			return new SingleShotGen(this.asEffect());
+		}
+		asEffect() {
+			return this.bind(this.toString());
+		}
+		bind(id) {
+			const key = sanitizeKey(id);
+			return RuntimeContext.pipe(Effect.flatMap((ctx) => Effect.map(ctx.set(key, this), (k) => ctx.get(k))));
+		}
+		pipe(...fns) {
+			return pipe(this, ...fns);
+		}
+		toString() {
+			return this[inspect]();
+		}
+	};
+	isResourceExpr = (node) => exprKind(node) === "ResourceExpr";
+	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;
+		}
+	};
+	isPropExpr = (node) => exprKind(node) === "PropExpr";
+	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()}`;
+		}
+	};
+	isLiteralExpr = (node) => exprKind(node) === "LiteralExpr";
+	LiteralExpr = class extends BaseExpr {
+		value;
+		kind = "LiteralExpr";
+		constructor(value) {
+			super();
+			this.value = value;
+			return proxy(this);
+		}
+		[inspect]() {
+			return String(this.value);
+		}
+	};
+	VoidExpr = new LiteralExpr(void 0);
+	isApplyExpr = (node) => exprKind(node) === "ApplyExpr";
+	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()})`;
+		}
+	};
+	isFlatMapExpr = (node) => exprKind(node) === "FlatMapExpr";
+	FlatMapExpr = class extends BaseExpr {
+		expr;
+		f;
+		kind = "FlatMapExpr";
+		constructor(expr, f) {
+			super();
+			this.expr = expr;
+			this.f = f;
+			return proxy(this);
+		}
+		[inspect]() {
+			return `${this.expr[inspect]()}.flatMap(${this.f.toString()})`;
+		}
+	};
+	isEffectExpr = (node) => exprKind(node) === "EffectExpr";
+	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()})`;
+		}
+	};
+	isNamedExpr = (node) => exprKind(node) === "NamedExpr";
+	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;
+		}
+	};
+	isAllExpr = (node) => exprKind(node) === "AllExpr";
+	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(", ")})`;
+		}
+	};
+	isRefExpr = (node) => exprKind(node) === "RefExpr";
+	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} })`;
+		}
+	};
+	isStackRefExpr = (node) => exprKind(node) === "StackRefExpr";
+	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} }` : ""})`;
+		}
+	};
+	stackRef = (stack, options = {}) => Effect.succeed(new StackRefExpr(stack, options.stage));
+	MissingSourceError = class extends Data.TaggedError("MissingSourceError") {};
+	InvalidReferenceError = class extends Data.TaggedError("InvalidReferenceError") {};
+	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 (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 (isFlatMapExpr(expr)) {
-			const value = yield* evaluate(expr.expr, upstream$1);
-			return yield* evaluate(expr.f(value), 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* 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* 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;
+		} 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 (isFlatMapExpr(expr)) {
+				const value = yield* evaluate(expr.expr, upstream$1);
+				return yield* evaluate(expr.f(value), 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* 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* 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 (Config.isConfig(expr)) return yield* evaluate(yield* expr, upstream$1);
-	else if (Duration.isDuration(expr) || 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) || isFlatMapExpr(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
-});
+		if (Array.isArray(expr)) return yield* Effect.all(expr.map((item) => evaluate(item, upstream$1)));
+		else if (Config.isConfig(expr)) return yield* evaluate(yield* expr, upstream$1);
+		else if (Duration.isDuration(expr) || 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;
+	});
+	hasOutputs = (value) => Object.keys(upstreamAny(value)).length > 0;
+	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 {};
+	};
+	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) || isFlatMapExpr(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 {};
+	};
+	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 {};
+	};
+	toObject = (acc, v) => ({
+		...acc,
+		...v
+	});
+}) });
 
 //#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());
-	});
-};
+var loadConfigProvider;
+var init_ConfigProvider = __esm({ "lib/Util/ConfigProvider.js": (() => {
+	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 {}, Effectable.Prototype({
-	label: "alchemy/EffectClass",
-	evaluate: () => impl
-})));
-const taggedFunction = (tag$1, fn) => {
-	const overrides = { 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)
-	});
-};
+var effectClass, taggedFunction;
+var init_effect = __esm({ "lib/Util/effect.js": (() => {
+	effectClass = ((impl) => impl === void 0 ? (innerImpl) => effectClass(innerImpl) : Object.assign(class {}, Effectable.Prototype({
+		label: "alchemy/EffectClass",
+		evaluate: () => impl
+	})));
+	taggedFunction = (tag$1, fn) => {
+		const overrides = { 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.fn(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" }));
-});
+var fileLogger;
+var init_FileLogger = __esm({ "lib/Util/FileLogger.js": (() => {
+	init_AlchemyContext();
+	fileLogger = Effect.fn(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/Util/PlatformServices.js
-const isBun = typeof Bun !== "undefined";
-/**
-* Constructs a layer with different implementations for Bun and Node.
-*/
-const platformLayer = (constructors) => Layer.unwrap(Effect.promise(async () => {
-	if (isBun) return await constructors.bun();
-	else return await constructors.node();
-}));
-const PlatformServices = platformLayer({
-	bun: async () => {
-		const [BunServices, BunSocket] = await Promise.all([import("@effect/platform-bun/BunServices"), import("@effect/platform-bun/BunSocket")]);
-		return Layer.merge(BunServices.layer, BunSocket.layerWebSocketConstructor);
-	},
-	node: async () => {
-		const [NodeServices, NodeSocket] = await Promise.all([import("@effect/platform-node/NodeServices"), import("@effect/platform-node/NodeSocket")]);
-		return Layer.merge(NodeServices.layer, NodeSocket.layerWebSocketConstructor);
-	}
-});
-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));
-};
+var isBun, platformLayer, PlatformServices, runMain;
+var init_PlatformServices = __esm({ "lib/Util/PlatformServices.js": (() => {
+	isBun = typeof Bun !== "undefined";
+	platformLayer = (constructors) => Layer.unwrap(Effect.promise(async () => {
+		if (isBun) return await constructors.bun();
+		else return await constructors.node();
+	}));
+	PlatformServices = platformLayer({
+		bun: async () => {
+			const [BunServices, BunSocket] = await Promise.all([import("@effect/platform-bun/BunServices"), import("@effect/platform-bun/BunSocket")]);
+			return Layer.merge(BunServices.layer, BunSocket.layerWebSocketConstructor);
+		},
+		node: async () => {
+			const [NodeServices, NodeSocket] = await Promise.all([import("@effect/platform-node/NodeServices"), import("@effect/platform-node/NodeSocket")]);
+			return Layer.merge(NodeServices.layer, NodeSocket.layerWebSocketConstructor);
+		}
+	});
+	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/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), {
-		stackName: stackName$1,
-		stage: createStageProxy(stackName$1),
-		state: options?.state,
-		providers: options?.providers,
-		make: (options$1, eff$1) => Stack(stackName$1, options$1, eff$1)
-	});
-	return eff.pipe(make$2({
-		name: stackName,
-		...options
-	}), (eff$1) => Object.assign(eff$1, {
-		stackName,
-		stage: createStageProxy(stackName),
-		state: options?.state,
-		providers: options?.providers
+var Stack, createStageProxy, StackName, make$2, CurrentStack, platform;
+var init_Stack = __esm({ "lib/Stack.js": (() => {
+	init_Credentials();
+	init_Profile();
+	init_Output();
+	init_Stage();
+	init_effect();
+	init_FileLogger();
+	init_PlatformServices();
+	Stack = Object.assign(taggedFunction(EffectContext.Service()("Stack"), (stackName, options, eff) => {
+		if (!stackName) return (stackName$1) => Object.assign(stackRef(stackName$1).pipe(effectClass), {
+			stackName: stackName$1,
+			stage: createStageProxy(stackName$1),
+			state: options?.state,
+			providers: options?.providers,
+			make: (options$1, eff$1) => Stack(stackName$1, options$1, eff$1)
+		});
+		return eff.pipe(make$2({
+			name: stackName,
+			...options
+		}), (eff$1) => Object.assign(eff$1, {
+			stackName,
+			stage: createStageProxy(stackName),
+			state: options?.state,
+			providers: options?.providers
+		}));
 	}));
-}));
-const createStageProxy = (stackName) => new Proxy({}, { get: (_, stage$1) => stackRef(stackName, { stage: stage$1 }) });
-const StackName = Stack.use((stack) => Effect.succeed(stack.name));
-const make$2 = (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));
+	createStageProxy = (stackName) => new Proxy({}, { get: (_, stage$1) => stackRef(stackName, { stage: stage$1 }) });
+	StackName = Stack.use((stack) => Effect.succeed(stack.name));
+	make$2 = (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))));
+	CurrentStack = Effect.serviceOption(Stack).pipe(Effect.map(Option.getOrUndefined));
+	platform = Layer.mergeAll(PlatformServices, FetchHttpClient.layer, Logger.layer([fileLogger("out")], { mergeWithExisting: true }), Layer.provide(ProfileLive, PlatformServices), Layer.provide(CredentialsStoreLive, PlatformServices));
+}) });
 
 //#endregion
 //#region lib/Local/RpcSerialization.js
+init_Output();
 const unwrapRpcHandlers = (handlers, streamKeys) => {
 	return Object.fromEntries(Object.entries(handlers).map(([key, value]) => [key, typeof value === "function" ? streamKeys?.includes(key) ? unwrapRpcStreamHandler(value) : unwrapRpcEffectHandler(value) : typeof value === "object" && value !== null && !Array.isArray(value) ? unwrapRpcHandlers(value) : value]));
 };
@@ -948,6 +836,8 @@ const serializeRpcArgs = (value) => {
 
 //#endregion
 //#region lib/Local/RpcProviderProxy.js
+init_AlchemyContext();
+init_Stack();
 var RpcProviderProxy = class extends EffectContext.Service()("alchemy/Local/RpcProviderProxy") {};
 const SPAWNER_URL_ENV_KEY = "ALCHEMY_RPC_SPAWNER_URL";
 const make$1 = Effect.fn(function* (spawnerUrl) {
@@ -979,6 +869,8 @@ const fromEnv = () => Layer.effect(RpcProviderProxy, Config.string(SPAWNER_URL_E
 
 //#endregion
 //#region lib/Diff.js
+init_Output();
+init_data();
 const isResolved = (value) => !_hasUnresolved(value);
 const _hasUnresolved = (value) => {
 	if (value == null || isPrimitive(value)) return false;
@@ -1041,7 +933,10 @@ const generateInstanceId = () => Effect.sync(() => {
 
 //#endregion
 //#region lib/Util/types.js
-const asEffect = (effect) => typeof effect?.asEffect === "function" ? effect.asEffect() : Effect.isEffect(effect) ? effect : Effect.succeed(effect);
+var asEffect;
+var init_types = __esm({ "lib/Util/types.js": (() => {
+	asEffect = (effect) => typeof effect?.asEffect === "function" ? effect.asEffect() : Effect.isEffect(effect) ? effect : Effect.succeed(effect);
+}) });
 
 //#endregion
 //#region lib/Action.js
@@ -1126,23 +1021,8 @@ const recordOutcome = (baseAttrs, status, duration) => {
 };
 
 //#endregion
-//#region lib/Util/sha256.js
-const sha256 = (input) => Effect.promise(async () => {
-	const digest = await crypto.subtle.digest("SHA-256", toArrayBuffer(input));
-	return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
-});
-/**
-* Stable sha256 hex digest of a resolved Task input. Unlike
-* {@link sha256Object} this does not stabilize key ordering — it hashes the
-* raw `JSON.stringify(input ?? null)` so identical inputs map to identical
-* hashes for caching/equality checks.
-*/
-const hashInput = (input) => sha256(JSON.stringify(input ?? null));
-const toArrayBuffer = (input) => {
-	if (input instanceof ArrayBuffer) return input;
-	if (typeof input === "string") return new TextEncoder().encode(input);
-	return input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
-};
+//#region lib/State/index.js
+init_State();
 
 //#endregion
 //#region lib/Util/scc.js
@@ -1217,9 +1097,33 @@ const findCycleMembers = (edges) => {
 	return cycleMembers;
 };
 
+//#endregion
+//#region lib/Util/sha256.js
+var sha256, hashInput, toArrayBuffer;
+var init_sha256 = __esm({ "lib/Util/sha256.js": (() => {
+	sha256 = (input) => Effect.promise(async () => {
+		const digest = await crypto.subtle.digest("SHA-256", toArrayBuffer(input));
+		return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+	});
+	hashInput = (input) => sha256(JSON.stringify(input ?? null));
+	toArrayBuffer = (input) => {
+		if (input instanceof ArrayBuffer) return input;
+		if (typeof input === "string") return new TextEncoder().encode(input);
+		return input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
+	};
+}) });
+
 //#endregion
 //#region lib/Plan.js
+init_types();
+init_AdoptPolicy();
+init_AlchemyContext();
+init_Artifacts();
 init_FQN();
+init_Output();
+init_Provider();
+init_Resource();
+init_sha256();
 const make = (stack, options = {}) => Effect.gen(function* () {
 	const state = yield* yield* State;
 	const resources = Object.values(stack.resources);
@@ -1738,7 +1642,13 @@ var UnsatisfiedResourceCycle = class extends Data.TaggedError("UnsatisfiedResour
 
 //#endregion
 //#region lib/Apply.js
+init_Artifacts();
 init_Cli();
+init_Output();
+init_Provider();
+init_Stack();
+init_Stage();
+init_sha256();
 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
@@ -1800,7 +1710,7 @@ const executePlan = Effect.fn(function* (plan, tracker, terminalStatuses, sessio
 	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));
+	if (failures.length > 0) return 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;
@@ -2528,7 +2438,7 @@ const collectGarbage = Effect.fn(function* (plan, session) {
 							stage: stage$1,
 							fqn
 						});
-						yield* report("deleted");
+						yield* report("retained");
 						return;
 					}
 					yield* commit({
@@ -2687,8 +2597,7 @@ const printProfile = Effect.fn(function* (profile$1, stored, registry) {
 	}
 });
 const importStack = Effect.fn(function* (main) {
-	const path$1 = yield* Path$1.Path;
-	const url = import.meta.resolve(path$1.resolve(main));
+	const url = pathToFileURL((yield* Path$1.Path).resolve(main)).href;
 	const stackEffect = (yield* Effect.promise(() => import(__rewriteRelativeImportExtension(url)))).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;
@@ -2696,7 +2605,15 @@ const importStack = Effect.fn(function* (main) {
 
 //#endregion
 //#region lib/Cli/commands/deploy.js
+init_AdoptPolicy();
+init_AlchemyContext();
+init_Artifacts();
+init_AuthProvider();
+init_Profile();
 init_Cli();
+init_Stage();
+init_ConfigProvider();
+init_FileLogger();
 const ExecStackOptions = Schema.Struct({
 	main: Schema.String,
 	stage: Schema.String,
@@ -2725,7 +2642,8 @@ const execStack = Effect.fn(function* ({ main, stage: stage$1, envFile: envFile$
 	const services$1 = Layer.mergeAll(Layer.effect(AlchemyContext, AlchemyContext.pipe(Effect.map((ctx) => ({
 		...ctx,
 		dev,
-		adopt: adopt$1
+		adopt: adopt$1,
+		updateStateStore: yes$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;
@@ -2746,7 +2664,7 @@ const execStack = Effect.fn(function* ({ main, stage: stage$1, envFile: envFile$
 				}
 				const outputs = yield* dev ? apply(updatePlan).pipe(Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.failCause(cause) : Console.error(`alchemy dev: apply failed; keeping dev alive so healthy resources keep serving.\n${Cause.pretty(cause)}`).pipe(Effect.as(void 0)))) : apply(updatePlan);
 				if (outputs !== void 0) yield* Console.log(outputs);
-				if (dev) yield* Effect.never;
+				if (dev) return yield* Effect.never;
 			}
 		}).pipe(Effect.provide(stack.services));
 	}).pipe(Effect.provide(services$1));
@@ -2810,6 +2728,7 @@ const statusColor$1 = (status) => {
 		case "updated":
 		case "replaced": return green;
 		case "deleted": return dim;
+		case "retained": return dim;
 		case "fail": return red;
 		case "attaching":
 		case "post-attach": return cyan;
@@ -2817,7 +2736,7 @@ const statusColor$1 = (status) => {
 	}
 };
 const tag = (id) => bold(`[${id}]`);
-const isTerminal = (status) => status === "created" || status === "updated" || status === "deleted" || status === "replaced" || status === "fail";
+const isTerminal = (status) => status === "created" || status === "updated" || status === "deleted" || status === "retained" || 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"];
@@ -3323,7 +3242,7 @@ function PlanProgress(props) {
 				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";
+				const label = row.action === "delete" ? status === "deleted" || status === "retained" ? status : "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, {
@@ -3427,6 +3346,7 @@ function statusColor(status) {
 		case "updated": return "yellow";
 		case "deleting":
 		case "deleted": return "red";
+		case "retained": return "gray";
 		case "running":
 		case "ran": return "cyan";
 		case "skipped": return "gray";
@@ -3439,7 +3359,7 @@ function taskIcon(action, status, spinnerChar) {
 	if (status === "fail") return "✗";
 	if (status === "skipped") return "•";
 	if (status === "ran") return action === "noop" ? "•" : "✓";
-	if (status === "deleted") return "✓";
+	if (status === "deleted" || status === "retained") return "✓";
 	if (action === "delete") return "-";
 	if (action === "noop") return "•";
 	return "λ";
@@ -3582,15 +3502,21 @@ var init_InkCLI = __esm({ "lib/Cli/tui/InkCLI.js": (() => {
 
 //#endregion
 //#region lib/Cli/selectCli.js
+init_interactive();
 const selectCli = () => isNonInteractive() ? LoggingCli : Layer.unwrap(Effect.promise(() => Promise.resolve().then(() => (init_InkCLI(), InkCLI_exports)).then((m) => m.inkCLI())));
 
 //#endregion
 //#region lib/Cli/exec.js
+init_AlchemyContext();
+init_Credentials();
+init_Profile();
+init_PlatformServices();
 const services = Layer.merge(selectCli(), fromEnv()).pipe(Layer.provideMerge(Layer.mergeAll(AlchemyContextLive, ProfileLive, CredentialsStoreLive)), Layer.provideMerge(Layer.mergeAll(PlatformServices, FetchHttpClient.layer, ConfigProvider.layer(ConfigProvider.fromEnv()))));
 const exec = () => execStack(Schema.decodeSync(ExecStackOptions)(JSON.parse(process.env.ALCHEMY_EXEC_OPTIONS))).pipe(Effect.provide(services), Effect.scoped);
 
 //#endregion
 //#region bin/exec.ts
+init_PlatformServices();
 exec().pipe(runMain);
 
 //#endregion