alchemy 2.0.0-beta.test-export-fix-4 → 2.0.0-pipeline-v2-test

package/bin/alchemy.js

@@ -1,42 +1,47 @@
 import { createRequire } from "node:module";
-import * as Auth from "@distilled.cloud/aws/Auth";
-import { NodeRuntime, NodeServices } from "@effect/platform-node";
-import * as Config from "effect/Config";
 import * as ConfigProvider from "effect/ConfigProvider";
-import * as Console from "effect/Console";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as Logger from "effect/Logger";
-import * as Option from "effect/Option";
+import * as Command$1 from "effect/unstable/cli/Command";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as Context from "effect/Context";
+import * as FileSystem from "effect/FileSystem";
 import * as Path$1 from "effect/Path";
 import { Path } from "effect/Path";
-import * as S from "effect/Schema";
-import * as Stream$1 from "effect/Stream";
-import { Argument, Command, Flag } from "effect/unstable/cli";
+import * as Cause from "effect/Cause";
+import * as Config from "effect/Config";
+import * as Console from "effect/Console";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Argument from "effect/unstable/cli/Argument";
 import * as CliError from "effect/unstable/cli/CliError";
-import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
-import * as ChildProcess from "effect/unstable/process/ChildProcess";
-import * as Deferred from "effect/Deferred";
-import * as Context from "effect/Context";
+import * as Flag$1 from "effect/unstable/cli/Flag";
+import "@clack/prompts";
 import * as Data from "effect/Data";
+import "effect/unstable/process";
+import * as Auth from "@distilled.cloud/aws/Auth";
+import * as Logger from "effect/Logger";
+import * as Region$1 from "@distilled.cloud/aws/Region";
+import { Region } from "@distilled.cloud/aws/Region";
+import * as s3 from "@distilled.cloud/aws/s3";
+import * as Schedule from "effect/Schedule";
+import { Credentials, fromAwsCredentialIdentity } from "@distilled.cloud/aws/Credentials";
+import * as Deferred from "effect/Deferred";
 import { pipe } from "effect/Function";
 import { SingleShotGen } from "effect/Utils";
 import { pipeArguments } from "effect/Pipeable";
-import * as FileSystem from "effect/FileSystem";
-import "@distilled.cloud/aws/sts";
-import { Region, Region as Region$1 } from "@distilled.cloud/aws/Region";
-import * as s3 from "@distilled.cloud/aws/s3";
-import * as Schedule from "effect/Schedule";
-import { Credentials } from "@distilled.cloud/aws/Credentials";
+import * as Redacted from "effect/Redacted";
+import os from "node:os";
 import { PassThrough, Stream } from "node:stream";
 import process$1, { cwd, env } from "node:process";
-import os from "node:os";
 import { execFileSync } from "node:child_process";
 import * as fs$1 from "node:fs";
 import fs from "node:fs";
 import tty from "node:tty";
 import { EventEmitter } from "node:events";
 import { Buffer as Buffer$1 } from "node:buffer";
+import { Command, Flag } from "effect/unstable/cli";
+import * as Stream$1 from "effect/Stream";
 
 //#region rolldown:runtime
 var __create = Object.create;
@@ -69,7 +74,410 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
 //#region package.json
-var version = "2.0.0-beta.test-export-fix-4";
+var version = "2.0.0-pipeline-v2-test";
+
+//#endregion
+//#region src/Config.ts
+var DotAlchemy = class extends Context.Service()(".alchemy") {};
+const dotAlchemy = Layer.effect(DotAlchemy, Effect.gen(function* () {
+	const fs$2 = yield* FileSystem.FileSystem;
+	const dir = (yield* Path$1.Path).join(process.cwd(), ".alchemy");
+	yield* fs$2.makeDirectory(dir, { recursive: true });
+	return dir;
+}));
+
+//#endregion
+//#region src/Util/PlatformServices.ts
+const isBun$1 = typeof Bun !== "undefined";
+const PlatformServices = Effect.promise(async () => {
+	if (isBun$1) {
+		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$1) 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 src/Auth/AuthProvider.ts
+var AuthError = class extends Schema.TaggedErrorClass()("AuthError", {
+	message: Schema.String,
+	cause: Schema.optional(Schema.Defect)
+}) {};
+var AuthProviders = class extends Context.Service()("AuthProviders") {};
+
+//#endregion
+//#region src/Util/Clank.ts
+var PromptCancelled = class extends Data.TaggedError("PromptCancelled") {};
+const retryIfCancelled = Effect.retry({ while: (e) => e instanceof PromptCancelled });
+
+//#endregion
+//#region bin/commands/_shared.ts
+const USER = Config.string("USER").pipe(Config.orElse(() => Config.string("USERNAME")), Config.withDefault("unknown"));
+const STAGE = Config.string("stage").pipe(Config.option, (a) => a.asEffect(), Effect.map(Option.getOrUndefined));
+/**
+* `true` if `e` is a {@link PromptCancelled}, or an {@link AuthError} whose
+* `cause` chain bottoms out in one. Schema-tagged errors don't always
+* survive `instanceof` across module boundaries, so we also accept any
+* object whose `_tag` matches.
+*/
+const isPromptCancellation = (e) => {
+	for (let cur = e, i = 0; cur != null && i < 16; i++) {
+		if (cur instanceof PromptCancelled) return true;
+		if (typeof cur === "object" && cur._tag === "PromptCancelled") return true;
+		if (cur instanceof AuthError || typeof cur === "object" && cur._tag === "AuthError") {
+			cur = cur.cause;
+			continue;
+		}
+		return false;
+	}
+	return false;
+};
+/**
+* Catches user cancellations (Ctrl+C inside a prompt, surfaced as
+* {@link PromptCancelled} or wrapped in an {@link AuthError}) and exits
+* the CLI cleanly with a friendly message instead of dumping a stack
+* trace.
+*/
+const handleCancellation = (self$1) => self$1.pipe(Effect.catchCause((cause) => {
+	return cause.reasons.some((r) => {
+		if (Cause.isFailReason(r)) return isPromptCancellation(r.error);
+		if (Cause.isDieReason(r)) return isPromptCancellation(r.defect);
+		return false;
+	}) ? Console.log("\nCancelled.") : Effect.failCause(cause);
+}), Effect.onInterrupt(() => Console.log("\nInterrupted.")));
+const stage = Flag$1.string("stage").pipe(Flag$1.withSchema(Schema.String.check(Schema.isPattern(/^[a-z0-9]+([-_a-z0-9]+)*$/gi))), Flag$1.withDescription("Stage to deploy to, defaults to dev_${USER}"), Flag$1.optional, Flag$1.map(Option.getOrUndefined), Flag$1.mapEffect(Effect.fn(function* (stage$1) {
+	if (stage$1) return stage$1;
+	return yield* STAGE.pipe(Effect.catch(() => Effect.fail(new CliError.MissingOption({ option: "stage" }))), Effect.flatMap((s) => s === void 0 ? USER.asEffect().pipe(Effect.map((user) => `dev_${user}`), Effect.catch(() => Effect.succeed("unknown"))) : Effect.succeed(s)));
+})));
+const envFile = Flag$1.file("env-file").pipe(Flag$1.optional, Flag$1.withDescription("File to load environment variables from, defaults to .env"));
+const dryRun = Flag$1.boolean("dry-run").pipe(Flag$1.withDescription("Dry run the deployment, do not actually deploy"), Flag$1.withDefault(false));
+const yes = Flag$1.boolean("yes").pipe(Flag$1.withDescription("Yes to all prompts"), Flag$1.withDefault(false));
+const force = Flag$1.boolean("force").pipe(Flag$1.withDescription("Force updates for resources that would otherwise no-op"), Flag$1.withDefault(false));
+const main = 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$1.string("profile").pipe(Flag$1.withDescription("Auth profile to use (~/.alchemy/profiles.json). Defaults to 'default' or $ALCHEMY_PROFILE."), Flag$1.optional, Flag$1.map(Option.getOrElse(() => "default")));
+const resourceFilter = Flag$1.string("filter").pipe(Flag$1.withDescription("Comma-separated logical resource IDs (e.g. Api,Sandbox). Only those resources are included."), Flag$1.optional, Flag$1.map(Option.getOrUndefined));
+const TAIL_COLORS = [
+	"\x1B[36m",
+	"\x1B[35m",
+	"\x1B[33m",
+	"\x1B[32m",
+	"\x1B[34m",
+	"\x1B[91m",
+	"\x1B[96m",
+	"\x1B[95m",
+	"\x1B[93m",
+	"\x1B[92m"
+];
+const TAIL_RESET = "\x1B[0m";
+const formatLocalTimestamp = (date) => {
+	return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")} ${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}:${String(date.getSeconds()).padStart(2, "0")}.${String(date.getMilliseconds()).padStart(3, "0")} ${new Intl.DateTimeFormat("en-US", { timeZoneName: "short" }).formatToParts(date).find((p) => p.type === "timeZoneName")?.value ?? ""}`;
+};
+const parseResourceFilter = (filter) => {
+	if (filter === void 0) return void 0;
+	const ids = filter.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+	if (ids.length === 0) return void 0;
+	return new Set(ids);
+};
+const parseSince = (value) => {
+	const match = value.match(/^(\d+)([smhd])$/);
+	if (match) {
+		const num = parseInt(match[1], 10);
+		const unit = match[2];
+		const ms = unit === "s" ? num * 1e3 : unit === "m" ? num * 6e4 : unit === "h" ? num * 36e5 : num * 864e5;
+		return new Date(Date.now() - ms);
+	}
+	const parsed = new Date(value);
+	if (isNaN(parsed.getTime())) throw new Error(`Invalid --since value: '${value}'. Use a duration (e.g. '1h', '30m') or ISO date.`);
+	return parsed;
+};
+const importStack = Effect.fn(function* (main$1) {
+	const path = yield* Path$1.Path;
+	const stackEffect = (yield* Effect.promise(() => import(path.resolve(process.cwd(), main$1)))).default;
+	if (!Effect.isEffect(stackEffect)) return yield* Effect.die(/* @__PURE__ */ new Error(`Main file '${main$1}' must export a default stack definition (export default Alchemy.Stack({...}))`));
+	return stackEffect;
+});
+
+//#endregion
+//#region src/AWS/Environment.ts
+const AWS_PROFILE = Config.string("AWS_PROFILE").pipe(Config.withDefault("default"));
+const AWS_REGION = Config.string("AWS_REGION");
+var AWSEnvironment = class extends Context.Service()("AWS::Environment") {};
+/**
+* Build an `AWSEnvironment` from an SSO profile (`AWS_PROFILE` env var,
+* defaults to `"default"`). Uses the profile's `sso_account_id` and `region`,
+* and resolves credentials lazily via `aws sso login`.
+*/
+const Default = Layer.effect(AWSEnvironment, Effect.suspend(() => loadDefault())).pipe(Layer.orDie);
+const loadDefault = () => Effect.gen(function* () {
+	const profileName = yield* AWS_PROFILE;
+	const auth = yield* Auth.Default;
+	const profile$1 = yield* auth.loadProfile(profileName);
+	if (!profile$1.sso_account_id) return yield* Effect.die(`AWS SSO profile '${profileName}' is missing sso_account_id`);
+	const region = profile$1.region ?? (yield* AWS_REGION.pipe(Config.option, Config.map(Option.getOrElse(() => "us-east-1"))));
+	return {
+		profile: profileName,
+		accountId: profile$1.sso_account_id,
+		region,
+		credentials: auth.loadProfileCredentials(profileName)
+	};
+});
+const isStatic = (shape) => shape.credentials != null && typeof shape.credentials.accessKeyId === "string";
+/**
+* Build an `AWSEnvironment` Layer directly from values — useful for
+* static credentials in CI or tests.
+*
+* Named `makeEnvironment` rather than `of` because `Context.Service.of`
+* already exists with different semantics (builds the service value, not
+* a Layer); putting both on `AWSEnvironment` would be confusing.
+*/
+const makeEnvironment = (shape) => Layer.succeed(AWSEnvironment, isStatic(shape) ? {
+	...shape,
+	credentials: Effect.succeed(fromAwsCredentialIdentity(shape.credentials))
+} : shape);
+
+//#endregion
+//#region src/AWS/Bootstrap.ts
+/**
+* Tag key used to identify the alchemy assets bucket.
+*/
+const ASSETS_BUCKET_TAG = "alchemy::assets-bucket";
+/**
+* Tag key used to scope the alchemy assets bucket to an AWS region.
+*/
+const ASSETS_BUCKET_REGION_TAG = "alchemy::assets-bucket-region";
+/**
+* Build an account-regional namespace bucket name.
+*
+* Account-regional buckets must follow the naming convention:
+*   `<prefix>-<accountId>-<region>-an`
+*
+* @see https://docs.aws.amazon.com/AmazonS3/latest/userguide/gpbucketnamespaces.html#account-regional-gp-buckets
+*/
+const createAssetsBucketName = (accountId, region) => `alchemy-assets-${accountId}-${region}-an`.toLowerCase();
+const createAssetsBucketTags = (region) => [{
+	Key: ASSETS_BUCKET_TAG,
+	Value: "true"
+}, {
+	Key: ASSETS_BUCKET_REGION_TAG,
+	Value: region
+}];
+const getBucketTags = (bucketName) => s3.getBucketTagging({ Bucket: bucketName }).pipe(Effect.map((response) => response.TagSet ?? []), Effect.catchTag("NoSuchTagSet", () => Effect.succeed([])));
+const hasAssetsBucketTag = (tags) => tags.some((tag) => tag.Key === ASSETS_BUCKET_TAG && tag.Value === "true");
+const normalizeBucketRegion = (location) => {
+	if (!location) return "us-east-1";
+	if (location === "EU") return "eu-west-1";
+	return location;
+};
+const bucketMatchesRegion = (tags, region) => {
+	const taggedRegion = tags.find((tag) => tag.Key === ASSETS_BUCKET_REGION_TAG)?.Value;
+	return taggedRegion === void 0 ? void 0 : taggedRegion === region;
+};
+const lookupAssetsBuckets = Effect.gen(function* () {
+	const region = yield* Region;
+	const buckets = (yield* s3.listBuckets({})).Buckets ?? [];
+	const matchingBuckets = [];
+	for (const bucket of buckets) {
+		const bucketName = bucket.Name;
+		if (!bucketName) continue;
+		const tags = yield* getBucketTags(bucketName).pipe(Effect.catch(() => Effect.succeed([])));
+		if (!hasAssetsBucketTag(tags)) continue;
+		const taggedRegionMatch = bucketMatchesRegion(tags, region);
+		if (taggedRegionMatch === true) {
+			matchingBuckets.push(bucketName);
+			continue;
+		}
+		if (taggedRegionMatch === false) continue;
+		if ((yield* s3.getBucketLocation({ Bucket: bucketName }).pipe(Effect.map((response) => normalizeBucketRegion(response.LocationConstraint)), Effect.catch(() => Effect.succeed(void 0)))) === region) matchingBuckets.push(bucketName);
+	}
+	return matchingBuckets;
+});
+const lookupAssetsBucket = Effect.gen(function* () {
+	const matchingBuckets = yield* lookupAssetsBuckets;
+	for (const bucketName of matchingBuckets) return Option.some(bucketName);
+	return Option.none();
+});
+const ensureAssetsBucketTags = Effect.fn(function* (bucketName, region) {
+	const tagSet = [...(yield* getBucketTags(bucketName)).filter((tag) => tag.Key !== ASSETS_BUCKET_TAG && tag.Key !== ASSETS_BUCKET_REGION_TAG), ...createAssetsBucketTags(region)];
+	yield* s3.putBucketTagging({
+		Bucket: bucketName,
+		Tagging: { TagSet: tagSet.map((tag) => ({
+			Key: tag.Key,
+			Value: tag.Value
+		})) }
+	});
+});
+const deleteAllObjects = Effect.fn(function* (bucketName) {
+	let continuationToken;
+	do {
+		const listResponse = yield* s3.listObjectsV2({
+			Bucket: bucketName,
+			ContinuationToken: continuationToken
+		});
+		if (listResponse.Contents && listResponse.Contents.length > 0) yield* s3.deleteObjects({
+			Bucket: bucketName,
+			Delete: {
+				Objects: listResponse.Contents.map((obj) => ({ Key: obj.Key })),
+				Quiet: true
+			}
+		});
+		continuationToken = listResponse.NextContinuationToken;
+	} while (continuationToken);
+	let keyMarker;
+	let versionIdMarker;
+	do {
+		const listVersionsResponse = yield* s3.listObjectVersions({
+			Bucket: bucketName,
+			KeyMarker: keyMarker,
+			VersionIdMarker: versionIdMarker
+		});
+		const objectsToDelete = [...(listVersionsResponse.Versions ?? []).map((v) => ({
+			Key: v.Key,
+			VersionId: v.VersionId
+		})), ...(listVersionsResponse.DeleteMarkers ?? []).map((dm) => ({
+			Key: dm.Key,
+			VersionId: dm.VersionId
+		}))];
+		if (objectsToDelete.length > 0) yield* s3.deleteObjects({
+			Bucket: bucketName,
+			Delete: {
+				Objects: objectsToDelete,
+				Quiet: true
+			}
+		});
+		keyMarker = listVersionsResponse.NextKeyMarker;
+		versionIdMarker = listVersionsResponse.NextVersionIdMarker;
+	} while (keyMarker);
+});
+/**
+* Bootstrap the AWS environment by creating the assets bucket.
+*
+* This is idempotent - running it multiple times is safe.
+* The bucket is tagged and later discovered by tag lookup instead of by name.
+*/
+const bootstrap = Effect.fn(function* () {
+	const region = yield* Region;
+	const existingBucket = yield* lookupAssetsBucket;
+	if (Option.isSome(existingBucket)) {
+		yield* ensureAssetsBucketTags(existingBucket.value, region);
+		yield* Effect.logInfo(`Assets bucket already exists: ${existingBucket.value}`);
+		return {
+			bucketName: existingBucket.value,
+			created: false
+		};
+	}
+	const { accountId } = yield* AWSEnvironment;
+	const bucketName = createAssetsBucketName(accountId, region);
+	yield* s3.createBucket({
+		Bucket: bucketName,
+		BucketNamespace: "account-regional",
+		CreateBucketConfiguration: {
+			Tags: createAssetsBucketTags(region),
+			...region === "us-east-1" ? {} : { LocationConstraint: region }
+		}
+	}).pipe(Effect.catchTag("BucketAlreadyOwnedByYou", () => Effect.void), Effect.retry({
+		while: (e) => e._tag === "OperationAborted" || e._tag === "ServiceUnavailable",
+		schedule: Schedule.exponential(100)
+	}));
+	yield* s3.headBucket({ Bucket: bucketName }).pipe(Effect.retry({ schedule: Schedule.exponential(100).pipe(Schedule.both(Schedule.recurs(10))) }));
+	yield* Effect.logInfo(`Created assets bucket: ${bucketName}`);
+	return {
+		bucketName,
+		created: true
+	};
+});
+const destroyBootstrap = Effect.fn(function* () {
+	const bucketNames = yield* lookupAssetsBuckets;
+	for (const bucketName of bucketNames) {
+		yield* Effect.logInfo(`Destroying assets bucket: ${bucketName}`);
+		yield* deleteAllObjects(bucketName);
+		yield* s3.deleteBucket({ Bucket: bucketName }).pipe(Effect.retry({
+			while: (e) => e._tag === "OperationAborted" || e._tag === "ServiceUnavailable",
+			schedule: Schedule.exponential(100).pipe(Schedule.both(Schedule.recurs(10)))
+		}));
+	}
+	return {
+		bucketNames,
+		destroyed: bucketNames.length
+	};
+});
+
+//#endregion
+//#region src/AWS/Credentials.ts
+/**
+* Lazy `Credentials` layer derived from the surrounding {@link AWSEnvironment}.
+* Credentials are resolved on first access (not during layer construction),
+* matching the existing @distilled.cloud/aws semantics.
+*/
+const fromEnvironment$1 = Layer.effect(Credentials, Effect.map(AWSEnvironment.asEffect(), (env$2) => env$2.credentials));
+
+//#endregion
+//#region src/AWS/Region.ts
+/**
+* Derive the AWS region from the surrounding {@link AWSEnvironment}.
+*/
+const fromEnvironment = Layer.effect(Region$1.Region, Effect.map(AWSEnvironment.asEffect(), (env$2) => env$2.region));
+
+//#endregion
+//#region src/Util/ConfigProvider.ts
+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 src/Util/FileLogger.ts
+const fileLogger = Effect.fnUntraced(function* (...segments) {
+	const dotAlchemy$1 = yield* DotAlchemy;
+	const fs$2 = yield* FileSystem.FileSystem;
+	const path = yield* Path;
+	const logFile = path.join(dotAlchemy$1, "log", ...segments);
+	yield* fs$2.makeDirectory(path.dirname(logFile), { recursive: true });
+	return yield* Logger.formatLogFmt.pipe(Logger.toFile(logFile, { flag: "a" }));
+});
+
+//#endregion
+//#region bin/commands/bootstrap.ts
+const awsProfile = Flag$1.string("profile").pipe(Flag$1.withDescription("AWS profile to use for credentials"), Flag$1.optional, Flag$1.map(Option.getOrElse(() => "default")));
+const awsRegion = Flag$1.string("region").pipe(Flag$1.withDescription("AWS region to bootstrap (defaults to AWS_REGION env var)"), Flag$1.optional, Flag$1.map(Option.getOrUndefined));
+const bootstrapDestroy = Flag$1.boolean("destroy").pipe(Flag$1.withDescription("Destroy all bootstrap buckets in the selected region"), Flag$1.withDefault(false));
+const bootstrapCommand = Command$1.make("bootstrap", {
+	envFile,
+	profile: awsProfile,
+	region: awsRegion,
+	destroy: bootstrapDestroy
+}, Effect.fnUntraced(function* ({ envFile: envFile$1, profile: profile$1, region, destroy }) {
+	const logger = Logger.layer([fileLogger("bootstrap.txt")]);
+	return yield* Effect.gen(function* () {
+		const ssoProfile = yield* Auth.loadProfile(profile$1);
+		if (!ssoProfile.sso_account_id) return yield* Effect.die(`AWS SSO profile '${profile$1}' is missing sso_account_id`);
+		const ambient = yield* Effect.context();
+		const environment = makeEnvironment({
+			accountId: ssoProfile.sso_account_id,
+			region: region ?? ssoProfile.region ?? "us-east-1",
+			credentials: Auth.loadProfileCredentials(profile$1).pipe(Effect.provide(ambient)),
+			profile: profile$1
+		});
+		const awsLayers = Layer.provideMerge(Layer.mergeAll(fromEnvironment, fromEnvironment$1), environment);
+		return yield* Effect.gen(function* () {
+			const provider = yield* loadConfigProvider(envFile$1);
+			const bootstrapLayer = Layer.provide(awsLayers, Layer.succeed(ConfigProvider.ConfigProvider, provider));
+			if (destroy) {
+				yield* destroyBootstrap().pipe(Effect.tap((result) => result.destroyed === 0 ? Console.log("✓ No bootstrap buckets found to destroy") : Console.log(`✓ Destroyed ${result.destroyed} bootstrap bucket(s): ${result.bucketNames.join(", ")}`)), Effect.provide(bootstrapLayer));
+				return;
+			}
+			yield* bootstrap().pipe(Effect.tap(({ bucketName, created }) => created ? Console.log(`✓ Created assets bucket: ${bucketName}`) : Console.log(`✓ Assets bucket already exists: ${bucketName}`)), Effect.provide(bootstrapLayer));
+		});
+	}).pipe(Effect.provide(logger));
+}));
 
 //#endregion
 //#region src/Artifacts.ts
@@ -126,11 +534,6 @@ const makeScopedArtifacts = (store, fqn) => {
 	};
 };
 /**
-* Run an effect with a fresh artifact root, replacing any existing store.
-* Use this at top-level entrypoints that intentionally define a new deploy run.
-*/
-const provideFreshArtifactStore = (effect) => effect.pipe(Effect.provideServiceEffect(ArtifactStore, Effect.sync(createArtifactStore)));
-/**
 * 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.
 */
@@ -287,20 +690,23 @@ const Stack = Object.assign(taggedFunction(Context.Service()("Stack"), (stackNam
 	id: stackName
 }) }) }))));
 const StackName = Stack.use((stack) => Effect.succeed(stack.name));
-const make$1 = (name, providers, stack) => (effect) => Effect.all([
+const make$1 = (name, providers, stack) => (effect) => Effect.scope.pipe(Effect.flatMap((scope) => {
+	const stackLayer = Layer.effect(Stack, Stage.asEffect().pipe(Effect.map((stage$1) => stack ?? {
+		name,
+		stage: stage$1,
+		resources: {},
+		bindings: {}
+	}), Effect.tap(Effect.logInfo)));
+	return providers.pipe(Layer.provideMerge(stackLayer), Layer.buildWithScope(scope));
+}), Effect.flatMap((context) => Effect.all([
 	effect,
 	Stack.asEffect(),
 	Effect.context()
-]).pipe(Effect.map(([output, stack$1, services]) => ({
+]).pipe(Effect.map(([output, stack$1, services$1]) => ({
 	...stack$1,
 	output,
-	services
-})), Effect.provide(providers), Effect.provideServiceEffect(Stack, Stage.asEffect().pipe(Effect.map((stage$1) => stack ?? {
-	name,
-	stage: stage$1,
-	resources: {},
-	bindings: {}
-}), Effect.tap(Effect.logInfo))));
+	services: services$1
+})), Effect.provideContext(context))));
 const CurrentStack = Effect.serviceOption(Stack).asEffect().pipe(Effect.map(Option.getOrUndefined));
 
 //#endregion
@@ -576,6 +982,28 @@ const generateInstanceId = () => Effect.sync(() => {
 
 //#endregion
 //#region src/State/LocalState.ts
+const REDACTED_MARKER = "__redacted__";
+const encodeState = (value) => {
+	if (value === null || value === void 0) return value;
+	if (Redacted.isRedacted(value)) return { [REDACTED_MARKER]: encodeState(Redacted.value(value)) };
+	if (isResource(value)) return {
+		id: value.LogicalId,
+		type: value.Type,
+		props: encodeState(value.Props),
+		attr: encodeState(value.Attributes)
+	};
+	if (Array.isArray(value)) return value.map(encodeState);
+	if (typeof value === "object") {
+		const result = {};
+		for (const [k, v] of Object.entries(value)) result[k] = encodeState(v);
+		return result;
+	}
+	return value;
+};
+const reviveState = (_key, value) => {
+	if (value !== null && typeof value === "object" && !Array.isArray(value) && REDACTED_MARKER in value) return Redacted.make(value[REDACTED_MARKER]);
+	return value;
+};
 const LocalState = Layer.effect(State, Effect.gen(function* () {
 	const fs$2 = yield* FileSystem.FileSystem;
 	const path = yield* Path$1.Path;
@@ -593,7 +1021,7 @@ const LocalState = Layer.effect(State, Effect.gen(function* () {
 	const state = {
 		listStacks: () => fs$2.readDirectory(stateDir).pipe(recover, Effect.map((files) => files ?? [])),
 		listStages: (stack) => fs$2.readDirectory(path.join(stateDir, stack)).pipe(recover, Effect.map((files) => files ?? [])),
-		get: (request) => fs$2.readFile(resource(request)).pipe(Effect.map((file) => JSON.parse(file.toString())), recover),
+		get: (request) => fs$2.readFile(resource(request)).pipe(Effect.map((file) => JSON.parse(file.toString(), reviveState)), recover),
 		getReplacedResources: Effect.fnUntraced(function* (request) {
 			return (yield* Effect.all((yield* state.list(request)).map((fqn) => state.get({
 				stack: request.stack,
@@ -601,15 +1029,7 @@ const LocalState = Layer.effect(State, Effect.gen(function* () {
 				fqn
 			})))).filter((r) => r?.status === "replaced");
 		}),
-		set: (request) => ensure(stageDir(request)).pipe(Effect.flatMap(() => fs$2.writeFileString(resource(request), JSON.stringify(request.value, (k, v) => {
-			if (isResource(v)) return {
-				id: v.LogicalId,
-				type: v.Type,
-				props: v.Props,
-				attr: v.Attributes
-			};
-			return v;
-		}, 2))), recover, Effect.map(() => request.value)),
+		set: (request) => ensure(stageDir(request)).pipe(Effect.flatMap(() => fs$2.writeFileString(resource(request), JSON.stringify(encodeState(request.value), null, 2))), recover, Effect.map(() => request.value)),
 		delete: (request) => fs$2.remove(resource(request)).pipe(recover),
 		list: (request) => fs$2.readDirectory(stageDir(request)).pipe(recover, Effect.map((files) => files?.map((file) => decodeFqn(file.replace(/\.json$/, ""))) ?? []))
 	};
@@ -619,7 +1039,7 @@ const LocalState = Layer.effect(State, Effect.gen(function* () {
 //#endregion
 //#region src/Apply.ts
 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))));
-const apply = (plan) => ensureArtifactStore(Effect.gen(function* () {
+const apply = (plan) => Effect.gen(function* () {
 	const session = yield* (yield* Cli).startApplySession(plan);
 	const state = yield* State;
 	const stack = yield* Stack;
@@ -640,7 +1060,7 @@ const apply = (plan) => ensureArtifactStore(Effect.gen(function* () {
 	if (!plan.output) return;
 	const outputs = Object.fromEntries(Object.entries(tracker).map(([fqn, t]) => [fqn, t.output]));
 	return yield* evaluate(plan.output, outputs);
-}));
+}).pipe(ensureArtifactStore);
 const executePlan = Effect.fnUntraced(function* (plan, tracker, terminalStatuses, session, state, stackName, stage$1) {
 	const ready = Object.fromEntries(yield* Effect.all(Object.keys(plan.resources).map((fqn) => Effect.map(Deferred.make(), (d) => [fqn, d]))));
 	const getOutputs = () => Object.fromEntries(Object.entries(tracker).map(([fqn, t]) => [fqn, t.output]));
@@ -1217,174 +1637,498 @@ const excludeDeletedBindings = (bindings) => bindings.flatMap(({ action, sid, da
 }]);
 
 //#endregion
-//#region src/AWS/Region.ts
-const AWS_REGION = Config.string("AWS_REGION");
+//#region ../../node_modules/.bun/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
+let _lazyMatch = () => {
+	var __lib__ = (() => {
+		var m = Object.defineProperty, V = Object.getOwnPropertyDescriptor, G = Object.getOwnPropertyNames, T = Object.prototype.hasOwnProperty, q = (r, e) => {
+			for (var n in e) m(r, n, {
+				get: e[n],
+				enumerable: true
+			});
+		}, H = (r, e, n, a) => {
+			if (e && typeof e == "object" || typeof e == "function") for (let t of G(e)) !T.call(r, t) && t !== n && m(r, t, {
+				get: () => e[t],
+				enumerable: !(a = V(e, t)) || a.enumerable
+			});
+			return r;
+		}, J = (r) => H(m({}, "__esModule", { value: true }), r), w = {};
+		q(w, { default: () => re$1 });
+		var A = (r) => Array.isArray(r), d = (r) => typeof r == "function", Q = (r) => r.length === 0, W = (r) => typeof r == "number", K = (r) => typeof r == "object" && r !== null, X = (r) => r instanceof RegExp, b = (r) => typeof r == "string", h = (r) => r === void 0, Y = (r) => {
+			const e = /* @__PURE__ */ new Map();
+			return (n) => {
+				const a = e.get(n);
+				if (a) return a;
+				const t = r(n);
+				return e.set(n, t), t;
+			};
+		}, rr = (r, e, n = {}) => {
+			const a = {
+				cache: {},
+				input: r,
+				index: 0,
+				indexMax: 0,
+				options: n,
+				output: []
+			};
+			if (v(e)(a) && a.index === r.length) return a.output;
+			throw new Error(`Failed to parse at index ${a.indexMax}`);
+		}, i = (r, e) => A(r) ? er(r, e) : b(r) ? ar(r, e) : nr(r, e), er = (r, e) => {
+			const n = {};
+			for (const a of r) {
+				if (a.length !== 1) throw new Error(`Invalid character: "${a}"`);
+				const t = a.charCodeAt(0);
+				n[t] = true;
+			}
+			return (a) => {
+				const t = a.index, o = a.input;
+				for (; a.index < o.length && o.charCodeAt(a.index) in n;) a.index += 1;
+				const u = a.index;
+				if (u > t) {
+					if (!h(e) && !a.options.silent) {
+						const s = a.input.slice(t, u), c = d(e) ? e(s, o, String(t)) : e;
+						h(c) || a.output.push(c);
+					}
+					a.indexMax = Math.max(a.indexMax, a.index);
+				}
+				return true;
+			};
+		}, nr = (r, e) => {
+			const n = r.source, a = r.flags.replace(/y|$/, "y"), t = new RegExp(n, a);
+			return g((o) => {
+				t.lastIndex = o.index;
+				const u = t.exec(o.input);
+				if (u) {
+					if (!h(e) && !o.options.silent) {
+						const s = d(e) ? e(...u, o.input, String(o.index)) : e;
+						h(s) || o.output.push(s);
+					}
+					return o.index += u[0].length, o.indexMax = Math.max(o.indexMax, o.index), true;
+				} else return false;
+			});
+		}, ar = (r, e) => (n) => {
+			if (n.input.startsWith(r, n.index)) {
+				if (!h(e) && !n.options.silent) {
+					const t = d(e) ? e(r, n.input, String(n.index)) : e;
+					h(t) || n.output.push(t);
+				}
+				return n.index += r.length, n.indexMax = Math.max(n.indexMax, n.index), true;
+			} else return false;
+		}, C = (r, e, n, a) => {
+			const t = v(r);
+			return g(_(M((o) => {
+				let u = 0;
+				for (; u < n;) {
+					const s = o.index;
+					if (!t(o) || (u += 1, o.index === s)) break;
+				}
+				return u >= e;
+			})));
+		}, tr = (r, e) => C(r, 0, 1), f = (r, e) => C(r, 0, Infinity), x = (r, e) => {
+			const n = r.map(v);
+			return g(_(M((a) => {
+				for (let t = 0, o = n.length; t < o; t++) if (!n[t](a)) return false;
+				return true;
+			})));
+		}, l = (r, e) => {
+			const n = r.map(v);
+			return g(_((a) => {
+				for (let t = 0, o = n.length; t < o; t++) if (n[t](a)) return true;
+				return false;
+			}));
+		}, M = (r, e = false) => {
+			const n = v(r);
+			return (a) => {
+				const t = a.index, o = a.output.length, u = n(a);
+				return (!u || e) && (a.index = t, a.output.length !== o && (a.output.length = o)), u;
+			};
+		}, _ = (r, e) => {
+			return v(r);
+		}, g = (() => {
+			let r = 0;
+			return (e) => {
+				const n = v(e), a = r += 1;
+				return (t) => {
+					var o;
+					if (t.options.memoization === false) return n(t);
+					const u = t.index, s = (o = t.cache)[a] || (o[a] = /* @__PURE__ */ new Map()), c = s.get(u);
+					if (c === false) return false;
+					if (W(c)) return t.index = c, true;
+					if (c) return t.index = c.index, c.output?.length && t.output.push(...c.output), true;
+					{
+						const Z = t.output.length;
+						if (n(t)) {
+							const D = t.index, U = t.output.length;
+							if (U > Z) {
+								const ee = t.output.slice(Z, U);
+								s.set(u, {
+									index: D,
+									output: ee
+								});
+							} else s.set(u, D);
+							return true;
+						} else return s.set(u, false), false;
+					}
+				};
+			};
+		})(), E = (r) => {
+			let e;
+			return (n) => (e || (e = v(r())), e(n));
+		}, v = Y((r) => {
+			if (d(r)) return Q(r) ? E(r) : r;
+			if (b(r) || X(r)) return i(r);
+			if (A(r)) return x(r);
+			if (K(r)) return l(Object.values(r));
+			throw new Error("Invalid rule");
+		}), P = "abcdefghijklmnopqrstuvwxyz", ir = (r) => {
+			let e = "";
+			for (; r > 0;) e = P[(r - 1) % 26] + e, r = Math.floor((r - 1) / 26);
+			return e;
+		}, O = (r) => {
+			let e = 0;
+			for (let n = 0, a = r.length; n < a; n++) e = e * 26 + P.indexOf(r[n]) + 1;
+			return e;
+		}, S = (r, e) => {
+			if (e < r) return S(e, r);
+			const n = [];
+			for (; r <= e;) n.push(r++);
+			return n;
+		}, or = (r, e, n) => S(r, e).map((a) => String(a).padStart(n, "0")), R = (r, e) => S(O(r), O(e)).map(ir), p = (r) => r, z = (r) => ur((e) => rr(e, r, { memoization: false }).join("")), ur = (r) => {
+			const e = {};
+			return (n) => e[n] ?? (e[n] = r(n));
+		}, sr = i(/^\*\*\/\*$/, ".*"), cr = i(/^\*\*\/(\*)?([ a-zA-Z0-9._-]+)$/, (r, e, n) => `.*${e ? "" : "(?:^|/)"}${n.replaceAll(".", "\\.")}`), lr = i(/^\*\*\/(\*)?([ a-zA-Z0-9._-]*)\{([ a-zA-Z0-9._-]+(?:,[ a-zA-Z0-9._-]+)*)\}$/, (r, e, n, a) => `.*${e ? "" : "(?:^|/)"}${n.replaceAll(".", "\\.")}(?:${a.replaceAll(",", "|").replaceAll(".", "\\.")})`), y = i(/\\./, p), pr = i(/[$.*+?^(){}[\]\|]/, (r) => `\\${r}`), vr = i(/./, p), fr = l([i(/^(?:!!)*!(.*)$/, (r, e) => `(?!^${L(e)}$).*?`), i(/^(!!)+/, "")]), j = l([
+			i(/\/(\*\*\/)+/, "(?:/.+/|/)"),
+			i(/^(\*\*\/)+/, "(?:^|.*/)"),
+			i(/\/(\*\*)$/, "(?:/.*|$)"),
+			i(/\*\*/, ".*")
+		]), N = l([i(/\*\/(?!\*\*\/)/, "[^/]*/"), i(/\*/, "[^/]*")]), k = i("?", "[^/]"), $r = i("[", p), wr = i("]", p), Ar = i(/[!^]/, "^/"), br = i(/[a-z]-[a-z]|[0-9]-[0-9]/i, p), Er = l([
+			y,
+			i(/[$.*+?^(){}[\|]/, (r) => `\\${r}`),
+			br,
+			i(/[^\]]/, p)
+		]), B = x([
+			$r,
+			tr(Ar),
+			f(Er),
+			wr
+		]), Pr = i("{", "(?:"), Or = i("}", ")"), I = x([
+			Pr,
+			l([
+				i(/(\d+)\.\.(\d+)/, (r, e, n) => or(+e, +n, Math.min(e.length, n.length)).join("|")),
+				i(/([a-z]+)\.\.([a-z]+)/, (r, e, n) => R(e, n).join("|")),
+				i(/([A-Z]+)\.\.([A-Z]+)/, (r, e, n) => R(e.toLowerCase(), n.toLowerCase()).join("|").toUpperCase())
+			]),
+			Or
+		]), kr = i("{", "(?:"), Br = i("}", ")"), Ir = i(",", "|"), Fr = i(/[$.*+?^(){[\]\|]/, (r) => `\\${r}`), Lr = i(/[^}]/, p), F = x([
+			kr,
+			f(l([
+				j,
+				N,
+				k,
+				B,
+				I,
+				E(() => F),
+				y,
+				Fr,
+				Ir,
+				Lr
+			])),
+			Br
+		]), L = z(f(l([
+			sr,
+			cr,
+			lr,
+			fr,
+			j,
+			N,
+			k,
+			B,
+			I,
+			F,
+			y,
+			pr,
+			vr
+		]))), Tr = i(/\\./, p), qr = i(/./, p), Yr = z(f(l([
+			Tr,
+			i(/\*\*\*+/, "*"),
+			i(/([^/{[(!])\*\*/, (r, e) => `${e}*`),
+			i(/(^|.)\*\*(?=[^*/)\]}])/, (r, e) => `${e}*`),
+			qr
+		]))), $ = (r, e) => {
+			const n = Array.isArray(r) ? r : [r];
+			if (!n.length) return false;
+			const a = n.map($.compile), t = n.every((s) => /(\/(?:\*\*)?|\[\/\])$/.test(s)), o = e.replace(/[\\\/]+/g, "/").replace(/\/$/, t ? "/" : "");
+			return a.some((s) => s.test(o));
+		};
+		$.compile = (r) => new RegExp(`^${L(Yr(r))}$`, "s");
+		var re$1 = $;
+		return J(w);
+	})();
+	return __lib__.default || __lib__;
+};
+let _match;
+const zeptomatch = (path, pattern) => {
+	if (!_match) {
+		_match = _lazyMatch();
+		_lazyMatch = null;
+	}
+	return _match(path, pattern);
+};
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+const _PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
+const sep = "/";
+const normalize = function(path) {
+	if (path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
+		if (isPathAbsolute) return "/";
+		return trailingSeparator ? "./" : ".";
+	}
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
+	if (isUNCPath) {
+		if (!isPathAbsolute) return `//./${path}`;
+		return `//${path}`;
+	}
+	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...segments) {
+	let path = "";
+	for (const seg of segments) {
+		if (!seg) continue;
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/";
+			const segLeading = seg[0] === "/";
+			if (pathTrailing && segLeading) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
+	}
+	return normalize(path);
+};
+function cwd$2() {
+	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
+	return "/";
+}
+const resolve = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd$2();
+		if (!path || path.length === 0) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+const toNamespacedPath = function(p) {
+	return normalizeWindowsPath(p);
+};
+const extname = function(p) {
+	if (p === "..") return "";
+	const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+	return match && match[1] || "";
+};
+const relative = function(from, to) {
+	const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) return _to.join("/");
+	const _fromCopy = [..._from];
+	for (const segment of _fromCopy) {
+		if (_to[0] !== segment) break;
+		_from.shift();
+		_to.shift();
+	}
+	return [..._from.map(() => ".."), ..._to].join("/");
+};
+const dirname = function(p) {
+	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
+	return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+const format$2 = function(p) {
+	const ext = p.ext ? p.ext.startsWith(".") ? p.ext : `.${p.ext}` : "";
+	const segments = [
+		p.root,
+		p.dir,
+		p.base ?? (p.name ?? "") + ext
+	].filter(Boolean);
+	return normalizeWindowsPath(p.root ? resolve(...segments) : segments.join("/"));
+};
+const basename = function(p, extension$2) {
+	const segments = normalizeWindowsPath(p).split("/");
+	let lastSegment = "";
+	for (let i = segments.length - 1; i >= 0; i--) {
+		const val = segments[i];
+		if (val) {
+			lastSegment = val;
+			break;
+		}
+	}
+	return extension$2 && lastSegment.endsWith(extension$2) ? lastSegment.slice(0, -extension$2.length) : lastSegment;
+};
+const parse$3 = function(p) {
+	const root$1 = _PATH_ROOT_RE.exec(p)?.[0]?.replace(/\\/g, "/") || "";
+	const base = basename(p);
+	const extension$2 = extname(base);
+	return {
+		root: root$1,
+		dir: dirname(p),
+		base,
+		ext: extension$2,
+		name: base.slice(0, base.length - extension$2.length)
+	};
+};
+const matchesGlob = (path, pattern) => {
+	return zeptomatch(pattern, normalize(path));
+};
+const _path = {
+	__proto__: null,
+	basename,
+	dirname,
+	extname,
+	format: format$2,
+	isAbsolute,
+	join,
+	matchesGlob,
+	normalize,
+	normalizeString,
+	parse: parse$3,
+	relative,
+	resolve,
+	sep,
+	toNamespacedPath
+};
 
 //#endregion
-//#region src/AWS/Account.ts
-var Account = class extends Context.Service()("AWS::AccountID") {};
+//#region ../../node_modules/.bun/pathe@2.0.3/node_modules/pathe/dist/index.mjs
+const delimiter = /* @__PURE__ */ (() => globalThis.process?.platform === "win32" ? ";" : ":")();
+const _platforms = {
+	posix: void 0,
+	win32: void 0
+};
+const mix = (del = delimiter) => {
+	return new Proxy(_path, { get(_, prop) {
+		if (prop === "delimiter") return del;
+		if (prop === "posix") return posix;
+		if (prop === "win32") return win32;
+		return _platforms[prop] || _path[prop];
+	} });
+};
+const posix = /* @__PURE__ */ mix(":");
+const win32 = /* @__PURE__ */ mix(";");
 
 //#endregion
-//#region src/AWS/Bootstrap.ts
-/**
-* Tag key used to identify the alchemy assets bucket.
-*/
-const ASSETS_BUCKET_TAG = "alchemy::assets-bucket";
+//#region src/Auth/Profile.ts
+const rootDir = posix.join(os.homedir(), ".alchemy");
+const configFilePath = posix.join(rootDir, "profiles.json");
 /**
-* Tag key used to scope the alchemy assets bucket to an AWS region.
+* Config key consulted by the various `fromAuthProvider` /
+* `fromEnvironment` layers to pick which named profile in
+* `~/.alchemy/profiles.json` to use. Defaults to `"default"`.
 */
-const ASSETS_BUCKET_REGION_TAG = "alchemy::assets-bucket-region";
-const createAssetsBucketName = (region) => `alchemy-assets-${region}-${crypto.randomUUID().replaceAll("-", "").slice(0, 16)}`.toLowerCase();
-const createAssetsBucketTags = (region) => [{
-	Key: ASSETS_BUCKET_TAG,
-	Value: "true"
-}, {
-	Key: ASSETS_BUCKET_REGION_TAG,
-	Value: region
-}];
-const getBucketTags = (bucketName) => s3.getBucketTagging({ Bucket: bucketName }).pipe(Effect.map((response) => response.TagSet ?? []), Effect.catchTag("NoSuchTagSet", () => Effect.succeed([])));
-const hasAssetsBucketTag = (tags) => tags.some((tag) => tag.Key === ASSETS_BUCKET_TAG && tag.Value === "true");
-const normalizeBucketRegion = (location) => {
-	if (!location) return "us-east-1";
-	if (location === "EU") return "eu-west-1";
-	return location;
-};
-const bucketMatchesRegion = (tags, region) => {
-	const taggedRegion = tags.find((tag) => tag.Key === ASSETS_BUCKET_REGION_TAG)?.Value;
-	return taggedRegion === void 0 ? void 0 : taggedRegion === region;
-};
-const lookupAssetsBuckets = Effect.gen(function* () {
-	const region = yield* Region;
-	const buckets = (yield* s3.listBuckets({})).Buckets ?? [];
-	const matchingBuckets = [];
-	for (const bucket of buckets) {
-		const bucketName = bucket.Name;
-		if (!bucketName) continue;
-		const tags = yield* getBucketTags(bucketName).pipe(Effect.catch(() => Effect.succeed([])));
-		if (!hasAssetsBucketTag(tags)) continue;
-		const taggedRegionMatch = bucketMatchesRegion(tags, region);
-		if (taggedRegionMatch === true) {
-			matchingBuckets.push(bucketName);
-			continue;
-		}
-		if (taggedRegionMatch === false) continue;
-		if ((yield* s3.getBucketLocation({ Bucket: bucketName }).pipe(Effect.map((response) => normalizeBucketRegion(response.LocationConstraint)), Effect.catch(() => Effect.succeed(void 0)))) === region) matchingBuckets.push(bucketName);
-	}
-	return matchingBuckets;
-});
-const lookupAssetsBucket = Effect.gen(function* () {
-	const matchingBuckets = yield* lookupAssetsBuckets;
-	for (const bucketName of matchingBuckets) return Option.some(bucketName);
-	return Option.none();
-});
-const ensureAssetsBucketTags = Effect.fn(function* (bucketName, region) {
-	const tagSet = [...(yield* getBucketTags(bucketName)).filter((tag) => tag.Key !== ASSETS_BUCKET_TAG && tag.Key !== ASSETS_BUCKET_REGION_TAG), ...createAssetsBucketTags(region)];
-	yield* s3.putBucketTagging({
-		Bucket: bucketName,
-		Tagging: { TagSet: tagSet.map((tag) => ({
-			Key: tag.Key,
-			Value: tag.Value
-		})) }
-	});
-});
-const deleteAllObjects = Effect.fn(function* (bucketName) {
-	let continuationToken;
-	do {
-		const listResponse = yield* s3.listObjectsV2({
-			Bucket: bucketName,
-			ContinuationToken: continuationToken
-		});
-		if (listResponse.Contents && listResponse.Contents.length > 0) yield* s3.deleteObjects({
-			Bucket: bucketName,
-			Delete: {
-				Objects: listResponse.Contents.map((obj) => ({ Key: obj.Key })),
-				Quiet: true
-			}
-		});
-		continuationToken = listResponse.NextContinuationToken;
-	} while (continuationToken);
-	let keyMarker;
-	let versionIdMarker;
-	do {
-		const listVersionsResponse = yield* s3.listObjectVersions({
-			Bucket: bucketName,
-			KeyMarker: keyMarker,
-			VersionIdMarker: versionIdMarker
-		});
-		const objectsToDelete = [...(listVersionsResponse.Versions ?? []).map((v) => ({
-			Key: v.Key,
-			VersionId: v.VersionId
-		})), ...(listVersionsResponse.DeleteMarkers ?? []).map((dm) => ({
-			Key: dm.Key,
-			VersionId: dm.VersionId
-		}))];
-		if (objectsToDelete.length > 0) yield* s3.deleteObjects({
-			Bucket: bucketName,
-			Delete: {
-				Objects: objectsToDelete,
-				Quiet: true
-			}
-		});
-		keyMarker = listVersionsResponse.NextKeyMarker;
-		versionIdMarker = listVersionsResponse.NextVersionIdMarker;
-	} while (keyMarker);
+const ALCHEMY_PROFILE = Config.string("ALCHEMY_PROFILE").pipe(Config.withDefault("default"));
+const CONFIG_VERSION = 0;
+const emptyConfig = () => ({
+	version: CONFIG_VERSION,
+	profiles: {}
 });
+const readConfig = FileSystem.FileSystem.asEffect().pipe(Effect.flatMap((fs$2) => fs$2.readFileString(configFilePath)), Effect.flatMap((data) => Effect.try({
+	try: () => {
+		const parsed = JSON.parse(data);
+		if (parsed?.version !== CONFIG_VERSION) return emptyConfig();
+		return parsed;
+	},
+	catch: emptyConfig
+})), Effect.orElseSucceed(emptyConfig));
+const writeConfig = (config) => FileSystem.FileSystem.asEffect().pipe(Effect.tap((fs$2) => fs$2.makeDirectory(posix.dirname(configFilePath), { recursive: true })), Effect.flatMap((fs$2) => fs$2.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));
 /**
-* Bootstrap the AWS environment by creating the assets bucket.
+* 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.
 *
-* This is idempotent - running it multiple times is safe.
-* The bucket is tagged and later discovered by tag lookup instead of by name.
+* Use this to let the CLI's `--profile <name>` win over `$ALCHEMY_PROFILE`
+* without disturbing other config lookups.
 */
-const bootstrap = Effect.fn(function* () {
-	const region = yield* Region;
-	const existingBucket = yield* lookupAssetsBucket;
-	if (Option.isSome(existingBucket)) {
-		yield* ensureAssetsBucketTags(existingBucket.value, region);
-		yield* Effect.logInfo(`Assets bucket already exists: ${existingBucket.value}`);
-		return {
-			bucketName: existingBucket.value,
-			created: false
-		};
-	}
-	const bucketName = createAssetsBucketName(region);
-	if (region === "us-east-1") yield* s3.createBucket({ Bucket: bucketName }).pipe(Effect.retry({
-		while: (e) => e._tag === "OperationAborted" || e._tag === "ServiceUnavailable",
-		schedule: Schedule.exponential(100)
-	}));
-	else yield* s3.createBucket({
-		Bucket: bucketName,
-		CreateBucketConfiguration: { LocationConstraint: region }
-	}).pipe(Effect.catchTag("BucketAlreadyOwnedByYou", () => Effect.void), Effect.retry({
-		while: (e) => e._tag === "OperationAborted" || e._tag === "ServiceUnavailable",
-		schedule: Schedule.exponential(100)
-	}));
-	yield* s3.headBucket({ Bucket: bucketName }).pipe(Effect.retry({ schedule: Schedule.exponential(100).pipe(Schedule.both(Schedule.recurs(10))) }));
-	yield* ensureAssetsBucketTags(bucketName, region);
-	yield* Effect.logInfo(`Created assets bucket: ${bucketName}`);
-	return {
-		bucketName,
-		created: true
-	};
-});
-const destroyBootstrap = Effect.fn(function* () {
-	const bucketNames = yield* lookupAssetsBuckets;
-	for (const bucketName of bucketNames) {
-		yield* Effect.logInfo(`Destroying assets bucket: ${bucketName}`);
-		yield* deleteAllObjects(bucketName);
-		yield* s3.deleteBucket({ Bucket: bucketName }).pipe(Effect.retry({
-			while: (e) => e._tag === "OperationAborted" || e._tag === "ServiceUnavailable",
-			schedule: Schedule.exponential(100).pipe(Schedule.both(Schedule.recurs(10)))
-		}));
-	}
-	return {
-		bucketNames,
-		destroyed: bucketNames.length
-	};
-});
+const withProfileOverride = (base, profile$1) => {
+	if (profile$1 === void 0) return base;
+	const overrides = { ALCHEMY_PROFILE: profile$1 };
+	const overrideProvider = ConfigProvider.make((path) => Effect.succeed(path.length === 1 && typeof path[0] === "string" && path[0] in overrides ? ConfigProvider.makeValue(overrides[path[0]]) : void 0));
+	return ConfigProvider.orElse(base)(overrideProvider);
+};
 
 //#endregion
-//#region ../../node_modules/.bun/react@19.2.4/node_modules/react/cjs/react.production.js
-var require_react_production = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react@19.2.4/node_modules/react/cjs/react.production.js": ((exports) => {
+//#region ../../node_modules/.bun/react@19.2.5/node_modules/react/cjs/react.production.js
+var require_react_production = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react@19.2.5/node_modules/react/cjs/react.production.js": ((exports) => {
 	var REACT_ELEMENT_TYPE$1 = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE$1 = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
 	function getIteratorFn(maybeIterable) {
 		if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
@@ -1731,12 +2475,12 @@ var require_react_production = /* @__PURE__ */ __commonJS({ "../../node_modules/
 	exports.useTransition = function() {
 		return ReactSharedInternals.H.useTransition();
 	};
-	exports.version = "19.2.4";
+	exports.version = "19.2.5";
 }) });
 
 //#endregion
-//#region ../../node_modules/.bun/react@19.2.4/node_modules/react/cjs/react.development.js
-var require_react_development = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react@19.2.4/node_modules/react/cjs/react.development.js": ((exports, module) => {
+//#region ../../node_modules/.bun/react@19.2.5/node_modules/react/cjs/react.development.js
+var require_react_development = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react@19.2.5/node_modules/react/cjs/react.development.js": ((exports, module) => {
 	"production" !== process.env.NODE_ENV && (function() {
 		function defineDeprecationWarning(methodName, info) {
 			Object.defineProperty(Component$1.prototype, methodName, { get: function() {
@@ -2048,19 +2792,19 @@ var require_react_development = /* @__PURE__ */ __commonJS({ "../../node_modules
 			prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
 			actScopeDepth = prevActScopeDepth;
 		}
-		function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
+		function recursivelyFlushAsyncActWork(returnValue, resolve$1, reject) {
 			var queue = ReactSharedInternals$1.actQueue;
 			if (null !== queue) if (0 !== queue.length) try {
 				flushActQueue(queue);
 				enqueueTask(function() {
-					return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+					return recursivelyFlushAsyncActWork(returnValue, resolve$1, reject);
 				});
 				return;
 			} catch (error) {
 				ReactSharedInternals$1.thrownErrors.push(error);
 			}
 			else ReactSharedInternals$1.actQueue = null;
-			0 < ReactSharedInternals$1.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals$1.thrownErrors), ReactSharedInternals$1.thrownErrors.length = 0, reject(queue)) : resolve(returnValue);
+			0 < ReactSharedInternals$1.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals$1.thrownErrors), ReactSharedInternals$1.thrownErrors.length = 0, reject(queue)) : resolve$1(returnValue);
 		}
 		function flushActQueue(queue) {
 			if (!isFlushing) {
@@ -2221,14 +2965,14 @@ var require_react_development = /* @__PURE__ */ __commonJS({ "../../node_modules
 				queueSeveralMicrotasks(function() {
 					didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = !0, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
 				});
-				return { then: function(resolve, reject) {
+				return { then: function(resolve$1, reject) {
 					didAwaitActCall = !0;
 					thenable.then(function(returnValue) {
 						popActScope(prevActQueue, prevActScopeDepth);
 						if (0 === prevActScopeDepth) {
 							try {
 								flushActQueue(queue), enqueueTask(function() {
-									return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+									return recursivelyFlushAsyncActWork(returnValue, resolve$1, reject);
 								});
 							} catch (error$0) {
 								ReactSharedInternals$1.thrownErrors.push(error$0);
@@ -2238,7 +2982,7 @@ var require_react_development = /* @__PURE__ */ __commonJS({ "../../node_modules
 								ReactSharedInternals$1.thrownErrors.length = 0;
 								reject(_thrownError);
 							}
-						} else resolve(returnValue);
+						} else resolve$1(returnValue);
 					}, function(error) {
 						popActScope(prevActQueue, prevActScopeDepth);
 						0 < ReactSharedInternals$1.thrownErrors.length ? (error = aggregateErrors(ReactSharedInternals$1.thrownErrors), ReactSharedInternals$1.thrownErrors.length = 0, reject(error)) : reject(error);
@@ -2251,11 +2995,11 @@ var require_react_development = /* @__PURE__ */ __commonJS({ "../../node_modules
 				didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = !0, console.error("A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"));
 			}), ReactSharedInternals$1.actQueue = null);
 			if (0 < ReactSharedInternals$1.thrownErrors.length) throw callback = aggregateErrors(ReactSharedInternals$1.thrownErrors), ReactSharedInternals$1.thrownErrors.length = 0, callback;
-			return { then: function(resolve, reject) {
+			return { then: function(resolve$1, reject) {
 				didAwaitActCall = !0;
 				0 === prevActScopeDepth ? (ReactSharedInternals$1.actQueue = queue, enqueueTask(function() {
-					return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve, reject);
-				})) : resolve(returnValue$jscomp$0);
+					return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve$1, reject);
+				})) : resolve$1(returnValue$jscomp$0);
 			} };
 		};
 		exports.cache = function(fn) {
@@ -2480,14 +3224,14 @@ var require_react_development = /* @__PURE__ */ __commonJS({ "../../node_modules
 		exports.useTransition = function() {
 			return resolveDispatcher().useTransition();
 		};
-		exports.version = "19.2.4";
+		exports.version = "19.2.5";
 		"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
 	})();
 }) });
 
 //#endregion
-//#region ../../node_modules/.bun/react@19.2.4/node_modules/react/index.js
-var require_react = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react@19.2.4/node_modules/react/index.js": ((exports, module) => {
+//#region ../../node_modules/.bun/react@19.2.5/node_modules/react/index.js
+var require_react = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react@19.2.5/node_modules/react/index.js": ((exports, module) => {
 	if (process.env.NODE_ENV === "production") module.exports = require_react_production();
 	else module.exports = require_react_development();
 }) });
@@ -2885,8 +3629,8 @@ const patchConsole = (callback) => {
 var dist_default = patchConsole;
 
 //#endregion
-//#region ../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/cjs/react-reconciler-constants.production.js
-var require_react_reconciler_constants_production = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/cjs/react-reconciler-constants.production.js": ((exports) => {
+//#region ../../node_modules/.bun/react-reconciler@0.33.0+3f10a4be4e334a9b/node_modules/react-reconciler/cjs/react-reconciler-constants.production.js
+var require_react_reconciler_constants_production = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react-reconciler@0.33.0+3f10a4be4e334a9b/node_modules/react-reconciler/cjs/react-reconciler-constants.production.js": ((exports) => {
 	exports.ConcurrentRoot = 1;
 	exports.DefaultEventPriority = 32;
 	exports.LegacyRoot = 0;
@@ -2894,14 +3638,14 @@ var require_react_reconciler_constants_production = /* @__PURE__ */ __commonJS({
 }) });
 
 //#endregion
-//#region ../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/cjs/react-reconciler-constants.development.js
-var require_react_reconciler_constants_development = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/cjs/react-reconciler-constants.development.js": ((exports) => {
+//#region ../../node_modules/.bun/react-reconciler@0.33.0+3f10a4be4e334a9b/node_modules/react-reconciler/cjs/react-reconciler-constants.development.js
+var require_react_reconciler_constants_development = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react-reconciler@0.33.0+3f10a4be4e334a9b/node_modules/react-reconciler/cjs/react-reconciler-constants.development.js": ((exports) => {
 	"production" !== process.env.NODE_ENV && (exports.ConcurrentRoot = 1, exports.ContinuousEventPriority = 8, exports.DefaultEventPriority = 32, exports.DiscreteEventPriority = 2, exports.IdleEventPriority = 268435456, exports.LegacyRoot = 0, exports.NoEventPriority = 0);
 }) });
 
 //#endregion
-//#region ../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/constants.js
-var require_constants$1 = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/constants.js": ((exports, module) => {
+//#region ../../node_modules/.bun/react-reconciler@0.33.0+3f10a4be4e334a9b/node_modules/react-reconciler/constants.js
+var require_constants$1 = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react-reconciler@0.33.0+3f10a4be4e334a9b/node_modules/react-reconciler/constants.js": ((exports, module) => {
 	if (process.env.NODE_ENV === "production") module.exports = require_react_reconciler_constants_production();
 	else module.exports = require_react_reconciler_constants_development();
 }) });
@@ -3092,7 +3836,7 @@ var loadYoga = (() => {
 		function Ja(a) {
 			a = Ka(a);
 			var b = N(a);
-			S$1(a);
+			S(a);
 			return b;
 		}
 		function La(a, b) {
@@ -3910,7 +4654,7 @@ var loadYoga = (() => {
 							for (k = 0; k < e; ++k) l[k] = String.fromCharCode(A[f + k]);
 							l = l.join("");
 						}
-						S$1(d);
+						S(d);
 						return l;
 					},
 					toWireType: function(d, e) {
@@ -3960,15 +4704,15 @@ var loadYoga = (() => {
 								}
 								f[g] = 0;
 							}
-						} else if (g) for (g = 0; g < f; ++g) l = e.charCodeAt(g), 255 < l && (S$1(m), L("String has UTF-16 code units that do not fit in 8 bits")), A[m + g] = l;
+						} else if (g) for (g = 0; g < f; ++g) l = e.charCodeAt(g), 255 < l && (S(m), L("String has UTF-16 code units that do not fit in 8 bits")), A[m + g] = l;
 						else for (g = 0; g < f; ++g) A[m + g] = e[g];
-						null !== d && d.push(S$1, k);
+						null !== d && d.push(S, k);
 						return k;
 					},
 					argPackAdvance: 8,
 					readValueFromPointer: Xa,
 					V: function(d) {
-						S$1(d);
+						S(d);
 					}
 				});
 			},
@@ -3988,7 +4732,7 @@ var loadYoga = (() => {
 							var t = m + 4 + u * b;
 							if (u == l || 0 == n[t >> k]) r = d(r, t - r), void 0 === p ? p = r : (p += String.fromCharCode(0), p += r), r = t + b;
 						}
-						S$1(m);
+						S(m);
 						return p;
 					},
 					toWireType: function(m, l) {
@@ -3996,13 +4740,13 @@ var loadYoga = (() => {
 						var n = f(l), p = Ib(4 + n + b);
 						E[p >> 2] = n >> k;
 						e(l, p + 4, n + b);
-						null !== m && m.push(S$1, p);
+						null !== m && m.push(S, p);
 						return p;
 					},
 					argPackAdvance: 8,
 					readValueFromPointer: Xa,
 					V: function(m) {
-						S$1(m);
+						S(m);
 					}
 				});
 			},
@@ -4176,8 +4920,8 @@ var loadYoga = (() => {
 		};
 		var Ib = h._malloc = function() {
 			return (Ib = h._malloc = h.asm.I).apply(null, arguments);
-		}, S$1 = h._free = function() {
-			return (S$1 = h._free = h.asm.K).apply(null, arguments);
+		}, S = h._free = function() {
+			return (S = h._free = h.asm.K).apply(null, arguments);
 		};
 		h.dynCall_jiji = function() {
 			return (h.dynCall_jiji = h.asm.L).apply(null, arguments);
@@ -5681,7 +6425,7 @@ const resize = () => {
 };
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/utils.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/utils.js
 const isDev = () => process$1.env["DEV"] === "true";
 
 //#endregion
@@ -6160,8 +6904,8 @@ var require_scheduler = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/sc
 }) });
 
 //#endregion
-//#region ../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/cjs/react-reconciler.production.js
-var require_react_reconciler_production = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/cjs/react-reconciler.production.js": ((exports, module) => {
+//#region ../../node_modules/.bun/react-reconciler@0.33.0+3f10a4be4e334a9b/node_modules/react-reconciler/cjs/react-reconciler.production.js
+var require_react_reconciler_production = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react-reconciler@0.33.0+3f10a4be4e334a9b/node_modules/react-reconciler/cjs/react-reconciler.production.js": ((exports, module) => {
 	module.exports = function($$$config) {
 		function createFiber(tag, pendingProps, key, mode) {
 			return new FiberNode(tag, pendingProps, key, mode);
@@ -7024,8 +7768,8 @@ var require_react_reconciler_production = /* @__PURE__ */ __commonJS({ "../../no
 				currentEntangledActionThenable = {
 					status: "pending",
 					value: void 0,
-					then: function(resolve) {
-						entangledListeners.push(resolve);
+					then: function(resolve$1) {
+						entangledListeners.push(resolve$1);
 					}
 				};
 			}
@@ -7048,8 +7792,8 @@ var require_react_reconciler_production = /* @__PURE__ */ __commonJS({ "../../no
 				status: "pending",
 				value: null,
 				reason: null,
-				then: function(resolve) {
-					listeners.push(resolve);
+				then: function(resolve$1) {
+					listeners.push(resolve$1);
 				}
 			};
 			thenable.then(function() {
@@ -12313,8 +13057,8 @@ var require_react_reconciler_production = /* @__PURE__ */ __commonJS({ "../../no
 }) });
 
 //#endregion
-//#region ../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/cjs/react-reconciler.development.js
-var require_react_reconciler_development = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/cjs/react-reconciler.development.js": ((exports, module) => {
+//#region ../../node_modules/.bun/react-reconciler@0.33.0+3f10a4be4e334a9b/node_modules/react-reconciler/cjs/react-reconciler.development.js
+var require_react_reconciler_development = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react-reconciler@0.33.0+3f10a4be4e334a9b/node_modules/react-reconciler/cjs/react-reconciler.development.js": ((exports, module) => {
 	"production" !== process.env.NODE_ENV && (module.exports = function($$$config) {
 		function findHook(fiber, id) {
 			for (fiber = fiber.memoizedState; null !== fiber && 0 < id;) fiber = fiber.next, id--;
@@ -14131,8 +14875,8 @@ var require_react_reconciler_development = /* @__PURE__ */ __commonJS({ "../../n
 				currentEntangledActionThenable = {
 					status: "pending",
 					value: void 0,
-					then: function(resolve) {
-						entangledListeners.push(resolve);
+					then: function(resolve$1) {
+						entangledListeners.push(resolve$1);
 					}
 				};
 			}
@@ -14155,8 +14899,8 @@ var require_react_reconciler_development = /* @__PURE__ */ __commonJS({ "../../n
 				status: "pending",
 				value: null,
 				reason: null,
-				then: function(resolve) {
-					listeners.push(resolve);
+				then: function(resolve$1) {
+					listeners.push(resolve$1);
 				}
 			};
 			thenable.then(function() {
@@ -21722,8 +22466,8 @@ var require_react_reconciler_development = /* @__PURE__ */ __commonJS({ "../../n
 }) });
 
 //#endregion
-//#region ../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/index.js
-var require_react_reconciler = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/index.js": ((exports, module) => {
+//#region ../../node_modules/.bun/react-reconciler@0.33.0+3f10a4be4e334a9b/node_modules/react-reconciler/index.js
+var require_react_reconciler = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react-reconciler@0.33.0+3f10a4be4e334a9b/node_modules/react-reconciler/index.js": ((exports, module) => {
 	if (process.env.NODE_ENV === "production") module.exports = require_react_reconciler_production();
 	else module.exports = require_react_reconciler_development();
 }) });
@@ -21798,7 +22542,7 @@ function widestLine(string) {
 }
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/measure-text.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/measure-text.js
 const cache$1 = /* @__PURE__ */ new Map();
 const measureText = (text) => {
 	if (text.length === 0) return {
@@ -22582,7 +23326,7 @@ function cliTruncate(text, columns, options = {}) {
 }
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/wrap-text.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/wrap-text.js
 const cache = {};
 const wrapText = (text, maxWidth, wrapType) => {
 	const cacheKey = text + String(maxWidth) + String(wrapType);
@@ -22605,7 +23349,7 @@ const wrapText = (text, maxWidth, wrapType) => {
 var wrap_text_default = wrapText;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/ansi-tokenizer.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/ansi-tokenizer.js
 const bellCharacter = "\x07";
 const escapeCharacter = "\x1B";
 const stringTerminatorCharacter = "œ";
@@ -22902,7 +23646,7 @@ const tokenizeAnsi = (text) => {
 };
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/sanitize-ansi.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/sanitize-ansi.js
 const sgrParametersRegex = /^[\d:;]*$/;
 const sanitizeAnsi = (text) => {
 	if (!hasAnsiControlCharacters(text)) return text;
@@ -22919,7 +23663,7 @@ const sanitizeAnsi = (text) => {
 var sanitize_ansi_default = sanitizeAnsi;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/squash-text-nodes.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/squash-text-nodes.js
 const squashTextNodes = (node) => {
 	let text = "";
 	for (let index = 0; index < node.childNodes.length; index++) {
@@ -22938,7 +23682,7 @@ const squashTextNodes = (node) => {
 var squash_text_nodes_default = squashTextNodes;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/dom.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/dom.js
 const createNode = (nodeName) => {
 	const node = {
 		nodeName,
@@ -23021,7 +23765,7 @@ const setTextNodeValue = (node, text) => {
 };
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/styles.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/styles.js
 const applyPositionStyles = (node, style) => {
 	if ("position" in style) node.setPositionType(style.position === "absolute" ? src_default.POSITION_TYPE_ABSOLUTE : src_default.POSITION_TYPE_RELATIVE);
 };
@@ -26666,9 +27410,9 @@ var init_wrapper = __esm({ "../../node_modules/.bun/ws@8.20.0/node_modules/ws/wr
 }) });
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/devtools-window-polyfill.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/devtools-window-polyfill.js
 var customGlobal;
-var init_devtools_window_polyfill = __esm({ "../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/devtools-window-polyfill.js": (() => {
+var init_devtools_window_polyfill = __esm({ "../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/devtools-window-polyfill.js": (() => {
 	init_wrapper();
 	customGlobal = global;
 	customGlobal.WebSocket ||= wrapper_default;
@@ -32682,11 +33426,11 @@ var require_backend = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/reac
 						var componentInfo = getCurrentComponentInfo();
 						if (componentInfo === null) return;
 						if (args.length > 3 && typeof args[0] === "string" && args[0].startsWith("%c%s%c ") && typeof args[1] === "string" && typeof args[2] === "string" && typeof args[3] === "string") {
-							var format$2 = args[0].slice(7);
+							var format$3 = args[0].slice(7);
 							var env$2 = args[2].trim();
 							args = args.slice(4);
-							if (env$2 !== componentInfo.env) args.unshift("[" + env$2 + "] " + format$2);
-							else args.unshift(format$2);
+							if (env$2 !== componentInfo.env) args.unshift("[" + env$2 + "] " + format$3);
+							else args.unshift(format$3);
 						}
 						var message = formatConsoleArgumentsToSingleString.apply(void 0, renderer_toConsumableArray(args));
 						var componentLogsEntry = componentInfoToComponentLogsMap.get(componentInfo);
@@ -40101,10 +40845,10 @@ var require_backend = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/reac
 }) });
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/devtools.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/devtools.js
 var devtools_exports = {};
 var import_backend;
-var init_devtools = __esm({ "../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/devtools.js": (() => {
+var init_devtools = __esm({ "../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/devtools.js": (() => {
 	init_devtools_window_polyfill();
 	import_backend = /* @__PURE__ */ __toESM(require_backend(), 1);
 	import_backend.default.initialize();
@@ -40112,7 +40856,7 @@ var init_devtools = __esm({ "../../node_modules/.bun/ink@6.8.0+f52afc7756478863/
 }) });
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/reconciler.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/reconciler.js
 var import_react_reconciler = /* @__PURE__ */ __toESM(require_react_reconciler(), 1);
 var import_constants$2 = /* @__PURE__ */ __toESM(require_constants$1(), 1);
 var import_scheduler = /* @__PURE__ */ __toESM(require_scheduler(), 1);
@@ -40336,7 +41080,7 @@ function indentString(string, count = 1, options = {}) {
 }
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/get-max-width.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/get-max-width.js
 const getMaxWidth = (yogaNode) => {
 	return yogaNode.getComputedWidth() - yogaNode.getComputedPadding(src_default.EDGE_LEFT) - yogaNode.getComputedPadding(src_default.EDGE_RIGHT) - yogaNode.getComputedBorder(src_default.EDGE_LEFT) - yogaNode.getComputedBorder(src_default.EDGE_RIGHT);
 };
@@ -40847,7 +41591,7 @@ const chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/colorize.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/colorize.js
 const rgbRegex = /^rgb\(\s?(\d+),\s?(\d+),\s?(\d+)\s?\)$/;
 const ansiRegex = /^ansi256\(\s?(\d+)\s?\)$/;
 const isNamedColor = (color) => {
@@ -40879,7 +41623,7 @@ const colorize = (str, color, type) => {
 var colorize_default = colorize;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/render-border.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/render-border.js
 var import_cli_boxes = /* @__PURE__ */ __toESM(require_cli_boxes(), 1);
 const renderBorder = (x, y, node, output) => {
 	if (node.style.borderStyle) {
@@ -40920,7 +41664,7 @@ const renderBorder = (x, y, node, output) => {
 var render_border_default = renderBorder;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/render-background.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/render-background.js
 const renderBackground = (x, y, node, output) => {
 	if (!node.style.backgroundColor) return;
 	const width = node.yogaNode.getComputedWidth();
@@ -40938,7 +41682,7 @@ const renderBackground = (x, y, node, output) => {
 var render_background_default = renderBackground;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/render-node-to-output.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/render-node-to-output.js
 const applyPaddingToText = (node, text) => {
 	const yogaNode = node.childNodes[0]?.yogaNode;
 	if (yogaNode) {
@@ -41247,7 +41991,7 @@ function tokenize(str, endChar = Number.POSITIVE_INFINITY) {
 }
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/output.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/output.js
 var OutputCaches = class {
 	widths = /* @__PURE__ */ new Map();
 	blockWidths = /* @__PURE__ */ new Map();
@@ -41389,7 +42133,7 @@ var Output = class {
 };
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/renderer.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/renderer.js
 const renderer = (node, isScreenReaderEnabled) => {
 	if (node.yogaNode) {
 		if (isScreenReaderEnabled) {
@@ -41506,7 +42250,7 @@ cliCursor.toggle = (force$1, writableStream) => {
 var cli_cursor_default = cliCursor;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/cursor-helpers.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/cursor-helpers.js
 const showCursorEscape = "\x1B[?25h";
 const hideCursorEscape = "\x1B[?25l";
 /**
@@ -41551,7 +42295,7 @@ const buildReturnToBottomPrefix = (cursorWasShown, previousLineCount, previousCu
 };
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/log-update.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/log-update.js
 const visibleLineCount = (lines, str) => str.endsWith("\n") ? lines.length - 1 : lines.length;
 const createStandard = (stream, { showCursor = false } = {}) => {
 	let previousLineCount = 0;
@@ -41748,7 +42492,7 @@ const logUpdate = { create };
 var log_update_default = logUpdate;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/write-synchronized.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/write-synchronized.js
 const bsu = "\x1B[?2026h";
 const esu = "\x1B[?2026l";
 function shouldSynchronize(stream) {
@@ -41756,12 +42500,12 @@ function shouldSynchronize(stream) {
 }
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/instances.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/instances.js
 const instances = /* @__PURE__ */ new WeakMap();
 var instances_default = instances;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/input-parser.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/input-parser.js
 const escape$1 = "\x1B";
 const isCsiParameterByte = (byte) => {
 	return byte >= 48 && byte <= 63;
@@ -41884,7 +42628,7 @@ const createInputParser = () => {
 };
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/components/AppContext.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/components/AppContext.js
 /**
 `AppContext` is a React context that exposes a method to manually exit the app (unmount).
 */
@@ -41893,7 +42637,7 @@ AppContext.displayName = "InternalAppContext";
 var AppContext_default = AppContext;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/components/StdinContext.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/components/StdinContext.js
 /**
 `StdinContext` is a React context that exposes the input stream.
 */
@@ -41908,7 +42652,7 @@ StdinContext.displayName = "InternalStdinContext";
 var StdinContext_default = StdinContext;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/components/StdoutContext.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/components/StdoutContext.js
 /**
 `StdoutContext` is a React context that exposes the stdout stream where Ink renders your app.
 */
@@ -41920,7 +42664,7 @@ StdoutContext.displayName = "InternalStdoutContext";
 var StdoutContext_default = StdoutContext;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/components/StderrContext.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/components/StderrContext.js
 /**
 `StderrContext` is a React context that exposes the stderr stream.
 */
@@ -41932,7 +42676,7 @@ StderrContext.displayName = "InternalStderrContext";
 var StderrContext_default = StderrContext;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/components/FocusContext.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/components/FocusContext.js
 const FocusContext = (0, import_react.createContext)({
 	activeId: void 0,
 	add() {},
@@ -41949,7 +42693,7 @@ FocusContext.displayName = "InternalFocusContext";
 var FocusContext_default = FocusContext;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/components/CursorContext.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/components/CursorContext.js
 const CursorContext = (0, import_react.createContext)({ setCursorPosition() {} });
 CursorContext.displayName = "InternalCursorContext";
 var CursorContext_default = CursorContext;
@@ -42130,10 +42874,10 @@ var require_stack_utils = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/
 			return res;
 		}
 	};
-	function setFile(result, filename, cwd$2) {
+	function setFile(result, filename, cwd$3) {
 		if (filename) {
 			filename = filename.replace(/\\/g, "/");
-			if (filename.startsWith(`${cwd$2}/`)) filename = filename.slice(cwd$2.length + 1);
+			if (filename.startsWith(`${cwd$3}/`)) filename = filename.slice(cwd$3.length + 1);
 			result.file = filename;
 		}
 	}
@@ -42177,15 +42921,15 @@ const codeExcerpt = (source, line, options = {}) => {
 var dist_default$1 = codeExcerpt;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/components/AccessibilityContext.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/components/AccessibilityContext.js
 const accessibilityContext = (0, import_react.createContext)({ isScreenReaderEnabled: false });
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/components/BackgroundContext.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/components/BackgroundContext.js
 const backgroundContext = (0, import_react.createContext)(void 0);
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/components/Box.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/components/Box.js
 /**
 `<Box>` is an essential Ink component to build your layout. It's like `<div style="display: flex">` in the browser.
 */
@@ -42217,7 +42961,7 @@ Box.displayName = "Box";
 var Box_default = Box;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/components/Text.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/components/Text.js
 /**
 This component can display text and change its style to make it bold, underlined, italic, or strikethrough.
 */
@@ -42251,7 +42995,7 @@ function Text({ color, backgroundColor, dimColor = false, bold = false, italic =
 }
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/components/ErrorOverview.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/components/ErrorOverview.js
 var import_stack_utils = /* @__PURE__ */ __toESM(require_stack_utils(), 1);
 const cleanupPath = (path) => {
 	return path?.replace(`file://${cwd()}/`, "");
@@ -42309,7 +43053,7 @@ function ErrorOverview({ error }) {
 }
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/components/ErrorBoundary.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/components/ErrorBoundary.js
 var ErrorBoundary = class extends import_react.PureComponent {
 	static displayName = "InternalErrorBoundary";
 	static getDerivedStateFromError(error) {
@@ -42326,7 +43070,7 @@ var ErrorBoundary = class extends import_react.PureComponent {
 };
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/components/App.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/components/App.js
 const tab = "	";
 const shiftTab = "\x1B[Z";
 const escape = "\x1B";
@@ -42604,7 +43348,7 @@ App.displayName = "InternalApp";
 var App_default = App;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/kitty-keyboard.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/kitty-keyboard.js
 const kittyFlags = {
 	disambiguateEscapeCodes: 1,
 	reportEventTypes: 2,
@@ -42629,7 +43373,7 @@ const kittyModifiers = {
 };
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/ink.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/ink.js
 var import_signal_exit = /* @__PURE__ */ __toESM(require_signal_exit(), 1);
 var import_constants$1 = /* @__PURE__ */ __toESM(require_constants$1(), 1);
 const noop = () => {};
@@ -42976,8 +43720,8 @@ var Ink = class {
 		else setImmediate(resolveOrReject);
 	}
 	async waitUntilExit() {
-		this.exitPromise ||= new Promise((resolve, reject) => {
-			this.resolveExitPromise = resolve;
+		this.exitPromise ||= new Promise((resolve$1, reject) => {
+			this.resolveExitPromise = resolve$1;
 			this.rejectExitPromise = reject;
 		});
 		if (!this.beforeExitHandler) {
@@ -43049,7 +43793,7 @@ var Ink = class {
 };
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/render.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/render.js
 /**
 Mount a component and render the output.
 */
@@ -43096,11 +43840,11 @@ const getInstance = (stdout, createInstance, concurrent) => {
 };
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/render-to-string.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/render-to-string.js
 var import_constants = /* @__PURE__ */ __toESM(require_constants$1(), 1);
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/parse-keypress.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/parse-keypress.js
 const metaKeyCodeRe = /^(?:\x1b)([a-zA-Z0-9])$/;
 const fnKeyRe = /^(?:\x1b+)(O|N|\[|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/;
 const keyName = {
@@ -43494,7 +44238,7 @@ const parseKeypress = (s = "") => {
 var parse_keypress_default = parseKeypress;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/hooks/use-stdin.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/hooks/use-stdin.js
 /**
 `useStdin` is a React hook that exposes the stdin stream.
 */
@@ -43502,7 +44246,7 @@ const useStdin = () => (0, import_react.useContext)(StdinContext_default);
 var use_stdin_default = useStdin;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/hooks/use-input.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/hooks/use-input.js
 /**
 This hook is used for handling user input. It's a more convenient alternative to using `StdinContext` and listening for `data` events. The callback you pass to `useInput` is called for each character when the user enters any input. However, if the user pastes text and it's more than one character, the callback will be called only once, and the whole string will be passed as `input`.
 
@@ -43587,7 +44331,7 @@ const useInput = (inputHandler, options = {}) => {
 var use_input_default = useInput;
 
 //#endregion
-//#region ../../node_modules/.bun/ink@6.8.0+f52afc7756478863/node_modules/ink/build/hooks/use-app.js
+//#region ../../node_modules/.bun/ink@6.8.0+4d40c05051311df7/node_modules/ink/build/hooks/use-app.js
 /**
 `useApp` is a React hook that exposes a method to manually exit the app (unmount).
 */
@@ -43698,8 +44442,8 @@ const deriveAction = (actions) => {
 };
 
 //#endregion
-//#region ../../node_modules/.bun/react@19.2.4/node_modules/react/cjs/react-jsx-runtime.production.js
-var require_react_jsx_runtime_production = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react@19.2.4/node_modules/react/cjs/react-jsx-runtime.production.js": ((exports) => {
+//#region ../../node_modules/.bun/react@19.2.5/node_modules/react/cjs/react-jsx-runtime.production.js
+var require_react_jsx_runtime_production = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react@19.2.5/node_modules/react/cjs/react-jsx-runtime.production.js": ((exports) => {
 	var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
 	function jsxProd(type, config, maybeKey) {
 		var key = null;
@@ -43723,8 +44467,8 @@ var require_react_jsx_runtime_production = /* @__PURE__ */ __commonJS({ "../../n
 }) });
 
 //#endregion
-//#region ../../node_modules/.bun/react@19.2.4/node_modules/react/cjs/react-jsx-runtime.development.js
-var require_react_jsx_runtime_development = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react@19.2.4/node_modules/react/cjs/react-jsx-runtime.development.js": ((exports) => {
+//#region ../../node_modules/.bun/react@19.2.5/node_modules/react/cjs/react-jsx-runtime.development.js
+var require_react_jsx_runtime_development = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react@19.2.5/node_modules/react/cjs/react-jsx-runtime.development.js": ((exports) => {
 	"production" !== process.env.NODE_ENV && (function() {
 		function getComponentNameFromType(type) {
 			if (null == type) return null;
@@ -43914,8 +44658,8 @@ var require_react_jsx_runtime_development = /* @__PURE__ */ __commonJS({ "../../
 }) });
 
 //#endregion
-//#region ../../node_modules/.bun/react@19.2.4/node_modules/react/jsx-runtime.js
-var require_jsx_runtime = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react@19.2.4/node_modules/react/jsx-runtime.js": ((exports, module) => {
+//#region ../../node_modules/.bun/react@19.2.5/node_modules/react/jsx-runtime.js
+var require_jsx_runtime = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/react@19.2.5/node_modules/react/jsx-runtime.js": ((exports, module) => {
 	if (process.env.NODE_ENV === "production") module.exports = require_react_jsx_runtime_production();
 	else module.exports = require_react_jsx_runtime_development();
 }) });
@@ -44362,16 +45106,6 @@ const startApplySession = Effect.fn(function* (plan) {
 	};
 });
 
-//#endregion
-//#region src/Config.ts
-var DotAlchemy = class extends Context.Service()(".alchemy") {};
-const dotAlchemy = Layer.effect(DotAlchemy, Effect.gen(function* () {
-	const fs$2 = yield* FileSystem.FileSystem;
-	const dir = (yield* Path$1.Path).join(process.cwd(), ".alchemy");
-	yield* fs$2.makeDirectory(dir, { recursive: true });
-	return dir;
-}));
-
 //#endregion
 //#region src/Util/types.ts
 const asEffect = (effect) => Effect.isEffect(effect) ? effect : Effect.succeed(effect);
@@ -44703,224 +45437,114 @@ var DeleteResourceHasDownstreamDependencies = class extends Data.TaggedError("De
 var UnsatisfiedResourceCycle = class extends Data.TaggedError("UnsatisfiedResourceCycle") {};
 
 //#endregion
-//#region src/Util/ConfigProvider.ts
-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 src/Util/FileLogger.ts
-const fileLogger = Effect.fnUntraced(function* (...segments) {
-	const dotAlchemy$1 = yield* DotAlchemy;
-	const fs$2 = yield* FileSystem.FileSystem;
-	const path = yield* Path;
-	const logFile = path.join(dotAlchemy$1, "log", ...segments);
-	yield* fs$2.makeDirectory(path.dirname(logFile), { recursive: true });
-	return yield* Logger.formatLogFmt.pipe(Logger.toFile(logFile, { flag: "a" }));
+//#region bin/commands/deploy.ts
+const execStack = Effect.fn(function* ({ main: main$1, stage: stage$1, envFile: envFile$1, profile: profile$1, dryRun: dryRun$1 = false, force: force$1 = false, yes: yes$1 = false, destroy = false }) {
+	const stackEffect = yield* importStack(main$1);
+	const services$1 = Layer.mergeAll(Layer.succeed(ArtifactStore, createArtifactStore()), Layer.succeed(AuthProviders, {}), ConfigProvider.layer(withProfileOverride(yield* loadConfigProvider(envFile$1), profile$1)), inkCLI(), Logger.layer([fileLogger("out")]), Layer.succeed(Stage, stage$1), LocalState);
+	yield* Effect.gen(function* () {
+		const cli$1 = 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$1.displayPlan(updatePlan);
+			else {
+				if (!yes$1) {
+					if (!(yield* cli$1.approvePlan(updatePlan))) return;
+				}
+				const outputs = yield* apply(updatePlan);
+				yield* Console.log(outputs);
+			}
+		}).pipe(Effect.provide(stack.services));
+	}).pipe(Effect.provide(services$1));
 });
-
-//#endregion
-//#region bin/alchemy.ts
-const USER = Config.string("USER").pipe(Config.orElse(() => Config.string("USERNAME")), Config.withDefault("unknown"));
-const STAGE = Config.string("stage").pipe(Config.option, (a) => a.asEffect(), Effect.map(Option.getOrUndefined));
-const stage = Flag.string("stage").pipe(Flag.withSchema(S.String.check(S.isPattern(/^[a-z0-9]+([-_a-z0-9]+)*$/gi))), Flag.withDescription("Stage to deploy to, defaults to dev_${USER}"), Flag.optional, Flag.map(Option.getOrUndefined), Flag.mapEffect(Effect.fn(function* (stage$1) {
-	if (stage$1) return stage$1;
-	return yield* STAGE.pipe(Effect.catch(() => Effect.fail(new CliError.MissingOption({ option: "stage" }))), Effect.flatMap((s) => s === void 0 ? USER.asEffect().pipe(Effect.map((user) => `dev_${user}`), Effect.catch(() => Effect.succeed("unknown"))) : Effect.succeed(s)));
-})));
-const envFile = Flag.file("env-file").pipe(Flag.optional, Flag.withDescription("File to load environment variables from, defaults to .env"));
-const dryRun = Flag.boolean("dry-run").pipe(Flag.withDescription("Dry run the deployment, do not actually deploy"), Flag.withDefault(false));
-const yes = Flag.boolean("yes").pipe(Flag.withDescription("Yes to all prompts"), Flag.withDefault(false));
-const force = Flag.boolean("force").pipe(Flag.withDescription("Force updates for resources that would otherwise no-op"), Flag.withDefault(false));
-const main = Argument.file("main", { mustExist: true }).pipe(Argument.withDescription("Main file to deploy, defaults to alchemy.run.ts"), Argument.withDefault("alchemy.run.ts"));
-const deployCommand = Command.make("deploy", {
+const deployCommand = Command$1.make("deploy", {
 	dryRun,
 	force,
 	main,
 	envFile,
 	stage,
-	yes
-}, (args) => execStack(args));
-const destroyCommand = Command.make("destroy", {
+	yes,
+	profile
+}, execStack);
+const destroyCommand = Command$1.make("destroy", {
 	dryRun,
 	main,
 	envFile,
 	stage,
-	yes
+	yes,
+	profile
 }, (args) => execStack({
 	...args,
 	destroy: true
 }));
-const planCommand = Command.make("plan", {
+const planCommand = Command$1.make("plan", {
 	main,
 	envFile,
-	stage
+	stage,
+	profile
 }, (args) => execStack({
 	...args,
 	dryRun: true
 }));
-const execStack = Effect.fn(function* ({ main: main$1, stage: stage$1, envFile: envFile$1, dryRun: dryRun$1 = false, force: force$1 = false, yes: yes$1 = false, destroy = false }) {
-	const path = yield* Path;
-	const stackEffect = (yield* Effect.promise(() => import(path.resolve(process.cwd(), main$1)))).default;
-	if (!stackEffect) return yield* Effect.die(/* @__PURE__ */ new Error(`Main file '${main$1}' must export a default stack definition (export default defineStack({...}))`));
-	const configProvider = yield* loadConfigProvider(envFile$1);
-	const platform$1 = Layer.mergeAll(NodeServices.layer, FetchHttpClient.layer);
-	const rootLogger = Logger.layer([fileLogger("out")]);
-	const alchemy = Layer.mergeAll(LocalState, inkCLI(), Layer.provideMerge(rootLogger, dotAlchemy));
-	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 {
-				if (!yes$1) {
-					if (!(yield* cli.approvePlan(updatePlan))) return;
-				}
-				const outputs = yield* apply(updatePlan);
-				yield* Console.log(outputs);
-			}
-		}).pipe(Effect.provide(stack.services), provideFreshArtifactStore);
-	}).pipe(Effect.provide(Layer.provideMerge(alchemy, Layer.mergeAll(platform$1, Layer.succeed(Stage, stage$1)))), Effect.provideService(ConfigProvider.ConfigProvider, configProvider));
-});
-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));
-const tailCommand = Command.make("tail", {
+
+//#endregion
+//#region bin/commands/login.ts
+const loginConfigure = Flag.boolean("configure").pipe(Flag.withDescription("Run the provider's interactive configure step before logging in"), Flag.withDefault(false));
+const loginCommand = Command.make("login", {
 	main,
 	envFile,
 	stage,
-	filter: resourceFilter
-}, Effect.fnUntraced(function* ({ main: main$1, stage: stage$1, envFile: envFile$1, filter }) {
-	const path = yield* Path;
-	const stackEffect = (yield* Effect.promise(() => import(path.resolve(process.cwd(), main$1)))).default;
-	if (!stackEffect) return yield* Effect.die(/* @__PURE__ */ new Error(`Main file '${main$1}' must export a default stack definition (export default defineStack({...}))`));
-	const configProvider = yield* loadConfigProvider(envFile$1);
-	const platform$1 = Layer.mergeAll(NodeServices.layer, FetchHttpClient.layer);
-	const rootLogger = Logger.layer([fileLogger("out")]);
-	const alchemy = Layer.mergeAll(LocalState, Layer.provideMerge(rootLogger, dotAlchemy));
+	profile,
+	configure: loginConfigure
+}, Effect.fnUntraced(function* ({ main: main$1, stage: stage$1, envFile: envFile$1, profile: profile$1, configure }) {
+	const stackEffect = yield* importStack(main$1);
+	const authProviders = {};
+	const services$1 = Layer.mergeAll(Layer.succeed(AuthProviders, authProviders), ConfigProvider.layer(withProfileOverride(yield* loadConfigProvider(envFile$1), profile$1)), Logger.layer([fileLogger("out")]), Layer.succeed(Stage, stage$1), LocalState);
 	yield* Effect.gen(function* () {
-		const state = yield* State;
-		const stack = yield* stackEffect;
-		yield* Effect.gen(function* () {
-			const filterSet = parseResourceFilter(filter);
-			const availableIds = [...new Set(Object.values(stack.resources).map((r) => r.LogicalId))].sort();
-			if (filterSet) {
-				for (const id of filterSet) if (!availableIds.includes(id)) return yield* Effect.die(/* @__PURE__ */ new Error(`Unknown resource '${id}' in --filter. Available: ${availableIds.join(", ") || "(none)"}`));
-			}
-			const fqns = Object.keys(stack.resources);
-			const tailable = [];
-			for (const fqn of fqns) {
-				const resource = stack.resources[fqn];
-				if (filterSet && !filterSet.has(resource.LogicalId)) continue;
-				const resourceState = yield* state.get({
-					stack: stack.name,
-					stage: stack.stage,
-					fqn
-				});
-				if (!resourceState?.attr) continue;
-				const provider = yield* findProviderByType(resource.Type);
-				if (!provider.tail) continue;
-				tailable.push({
-					logicalId: resource.LogicalId,
-					stream: provider.tail({
-						id: resource.LogicalId,
-						instanceId: resourceState.instanceId,
-						props: resourceState.props,
-						output: resourceState.attr
-					})
+		yield* stackEffect;
+		const ci = yield* Config.boolean("CI").pipe(Config.withDefault(false));
+		const providers = Object.values(authProviders);
+		if (providers.length === 0) {
+			yield* Console.log("No AuthProviders registered. Make sure the stack's providers() layer includes AuthProviderLayer entries.");
+			return;
+		}
+		yield* Effect.forEach(providers, (provider) => Effect.gen(function* () {
+			const existing = yield* getProfile(profile$1);
+			const stored = existing?.[provider.name];
+			let cfg;
+			if (configure || stored == null) {
+				cfg = yield* provider.configure(profile$1, { ci });
+				yield* setProfile(profile$1, {
+					...existing,
+					[provider.name]: cfg
 				});
-			}
-			if (tailable.length === 0) {
-				if (filterSet) yield* Console.log("No tailable resources match --filter (deploy first, or selected resources may not support tail).");
-				else yield* Console.log("No tailable resources found. Deploy first, then run tail.");
-				return;
-			}
-			yield* Console.log(`Tailing: ${tailable.map((t) => t.logicalId).join(", ")}`);
-			const taggedStreams = tailable.map(({ logicalId, stream }, i) => {
-				const color = TAIL_COLORS[i % TAIL_COLORS.length];
-				return stream.pipe(Stream$1.map(({ timestamp, message }) => {
-					return `${color}${formatLocalTimestamp(timestamp)} [${logicalId}]${TAIL_RESET} ${message}`;
-				}));
-			});
-			yield* Stream$1.mergeAll(taggedStreams, { concurrency: "unbounded" }).pipe(Stream$1.runForEach((line) => Console.log(line)));
-		}).pipe(Effect.provide(stack.services));
-	}).pipe(Effect.provide(Layer.provideMerge(alchemy, Layer.mergeAll(platform$1, Layer.succeed(Stage, stage$1)))), Effect.provideService(ConfigProvider.ConfigProvider, configProvider), Effect.scoped);
+			} else cfg = stored;
+			yield* provider.login(profile$1, cfg);
+			yield* provider.prettyPrint(profile$1, cfg);
+		}), { discard: true });
+	}).pipe(Effect.provide(services$1));
 }));
-const awsProfile = Flag.string("profile").pipe(Flag.withDescription("AWS profile to use for credentials"), Flag.optional, Flag.map(Option.getOrElse(() => "default")));
-const awsRegion = Flag.string("region").pipe(Flag.withDescription("AWS region to bootstrap (defaults to AWS_REGION env var)"), Flag.optional, Flag.map(Option.getOrUndefined));
-const bootstrapDestroy = Flag.boolean("destroy").pipe(Flag.withDescription("Destroy all bootstrap buckets in the selected region"), Flag.withDefault(false));
-const bootstrapCommand = Command.make("bootstrap", {
-	envFile,
-	profile: awsProfile,
-	region: awsRegion,
-	destroy: bootstrapDestroy
-}, Effect.fnUntraced(function* ({ envFile: envFile$1, profile, region, destroy }) {
-	const platform$1 = Layer.mergeAll(NodeServices.layer, FetchHttpClient.layer, Layer.provideMerge(Logger.layer([fileLogger("bootstrap.txt")]), dotAlchemy));
-	return yield* Effect.gen(function* () {
-		const ssoProfile = yield* Auth.loadProfile(profile);
-		const credentials = yield* Auth.loadProfileCredentials(profile);
-		const awsLayers = Layer.mergeAll(Layer.succeed(Account, profile), Layer.succeed(Region$1, region ?? ssoProfile.region ?? "us-east-1"), Layer.succeed(Credentials, Effect.succeed(credentials)));
-		return yield* Effect.gen(function* () {
-			const provider = yield* loadConfigProvider(envFile$1);
-			const bootstrapLayer = Layer.provide(awsLayers, Layer.succeed(ConfigProvider.ConfigProvider, provider));
-			if (destroy) {
-				yield* destroyBootstrap().pipe(Effect.tap((result) => result.destroyed === 0 ? Console.log("✓ No bootstrap buckets found to destroy") : Console.log(`✓ Destroyed ${result.destroyed} bootstrap bucket(s): ${result.bucketNames.join(", ")}`)), Effect.provide(bootstrapLayer));
-				return;
-			}
-			yield* bootstrap().pipe(Effect.tap(({ bucketName, created }) => created ? Console.log(`✓ Created assets bucket: ${bucketName}`) : Console.log(`✓ Assets bucket already exists: ${bucketName}`)), Effect.provide(bootstrapLayer));
-		});
-	}).pipe(Effect.provide(platform$1));
-}));
-Command.make("dev", {
-	main,
-	envFile,
-	stage
-}, ({ envFile: envFile$1, main: main$1, stage: stage$1 }) => Effect.gen(function* () {
-	const proc = yield* ChildProcess.make("bun", ["--hot", main$1], { env: { ALCHEMY_PHASE: "dev" } });
-	proc.stdout;
-	proc.stderr;
-	proc.all;
-}));
-const TAIL_COLORS = [
-	"\x1B[36m",
-	"\x1B[35m",
-	"\x1B[33m",
-	"\x1B[32m",
-	"\x1B[34m",
-	"\x1B[91m",
-	"\x1B[96m",
-	"\x1B[95m",
-	"\x1B[93m",
-	"\x1B[92m"
-];
-const TAIL_RESET = "\x1B[0m";
-const formatLocalTimestamp = (date) => {
-	return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")} ${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}:${String(date.getSeconds()).padStart(2, "0")}.${String(date.getMilliseconds()).padStart(3, "0")} ${new Intl.DateTimeFormat("en-US", { timeZoneName: "short" }).formatToParts(date).find((p) => p.type === "timeZoneName")?.value ?? ""}`;
-};
+
+//#endregion
+//#region bin/commands/logs.ts
 const logsLimit = Flag.integer("limit").pipe(Flag.withDescription("Number of log entries to fetch"), Flag.withDefault(100));
 const logsSince = Flag.string("since").pipe(Flag.withDescription("Fetch logs since this time (e.g. '1h', '30m', '2024-01-01T00:00:00Z')"), Flag.optional, Flag.map(Option.getOrUndefined));
 const logsCommand = Command.make("logs", {
 	main,
 	envFile,
 	stage,
+	profile,
 	filter: resourceFilter,
 	limit: logsLimit,
 	since: logsSince
-}, Effect.fnUntraced(function* ({ main: main$1, stage: stage$1, envFile: envFile$1, filter, limit, since }) {
-	const path = yield* Path;
-	const stackEffect = (yield* Effect.promise(() => import(path.resolve(process.cwd(), main$1)))).default;
-	if (!stackEffect) return yield* Effect.die(/* @__PURE__ */ new Error(`Main file '${main$1}' must export a default stack definition (export default defineStack({...}))`));
-	const configProvider = yield* loadConfigProvider(envFile$1);
-	const platform$1 = Layer.mergeAll(NodeServices.layer, FetchHttpClient.layer);
-	const rootLogger = Logger.layer([fileLogger("out")]);
-	const alchemy = Layer.mergeAll(LocalState, Layer.provideMerge(rootLogger, dotAlchemy));
+}, Effect.fnUntraced(function* ({ main: main$1, stage: stage$1, envFile: envFile$1, profile: profile$1, filter, limit, since }) {
+	const stackEffect = yield* importStack(main$1);
+	const services$1 = Layer.mergeAll(ConfigProvider.layer(withProfileOverride(yield* loadConfigProvider(envFile$1), profile$1)), Layer.succeed(AuthProviders, {}), Layer.succeed(Stage, stage$1), Logger.layer([fileLogger("out")]), LocalState);
 	const sinceDate = since ? parseSince(since) : void 0;
 	yield* Effect.gen(function* () {
 		const state = yield* State;
@@ -44973,35 +45597,83 @@ const logsCommand = Command.make("logs", {
 			}).sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
 			for (const entry of merged) yield* Console.log(entry.formatted);
 		}).pipe(Effect.provide(stack.services));
-	}).pipe(Effect.provide(Layer.provideMerge(alchemy, Layer.mergeAll(platform$1, Layer.succeed(Stage, stage$1)))), Effect.provideService(ConfigProvider.ConfigProvider, configProvider), Effect.scoped);
+	}).pipe(Effect.provide(services$1));
 }));
-const parseResourceFilter = (filter) => {
-	if (filter === void 0) return void 0;
-	const ids = filter.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-	if (ids.length === 0) return void 0;
-	return new Set(ids);
-};
-const parseSince = (value) => {
-	const match = value.match(/^(\d+)([smhd])$/);
-	if (match) {
-		const num = parseInt(match[1], 10);
-		const unit = match[2];
-		const ms = unit === "s" ? num * 1e3 : unit === "m" ? num * 6e4 : unit === "h" ? num * 36e5 : num * 864e5;
-		return new Date(Date.now() - ms);
-	}
-	const parsed = new Date(value);
-	if (isNaN(parsed.getTime())) throw new Error(`Invalid --since value: '${value}'. Use a duration (e.g. '1h', '30m') or ISO date.`);
-	return parsed;
-};
-const root = Command.make("alchemy", {}).pipe(Command.withSubcommands([
+
+//#endregion
+//#region bin/commands/tail.ts
+const tailCommand = Command$1.make("tail", {
+	main,
+	envFile,
+	stage,
+	profile,
+	filter: resourceFilter
+}, Effect.fnUntraced(function* ({ main: main$1, stage: stage$1, envFile: envFile$1, profile: profile$1, filter }) {
+	const stackEffect = yield* importStack(main$1);
+	const services$1 = Layer.mergeAll(ConfigProvider.layer(withProfileOverride(yield* loadConfigProvider(envFile$1), profile$1)), Layer.succeed(AuthProviders, {}), Layer.succeed(Stage, stage$1), Logger.layer([fileLogger("out")]), LocalState);
+	yield* Effect.gen(function* () {
+		const state = yield* State;
+		const stack = yield* stackEffect;
+		yield* Effect.gen(function* () {
+			const filterSet = parseResourceFilter(filter);
+			const availableIds = [...new Set(Object.values(stack.resources).map((r) => r.LogicalId))].sort();
+			if (filterSet) {
+				for (const id of filterSet) if (!availableIds.includes(id)) return yield* Effect.die(/* @__PURE__ */ new Error(`Unknown resource '${id}' in --filter. Available: ${availableIds.join(", ") || "(none)"}`));
+			}
+			const fqns = Object.keys(stack.resources);
+			const tailable = [];
+			for (const fqn of fqns) {
+				const resource = stack.resources[fqn];
+				if (filterSet && !filterSet.has(resource.LogicalId)) continue;
+				const resourceState = yield* state.get({
+					stack: stack.name,
+					stage: stack.stage,
+					fqn
+				});
+				if (!resourceState?.attr) continue;
+				const provider = yield* findProviderByType(resource.Type);
+				if (!provider.tail) continue;
+				tailable.push({
+					logicalId: resource.LogicalId,
+					stream: provider.tail({
+						id: resource.LogicalId,
+						instanceId: resourceState.instanceId,
+						props: resourceState.props,
+						output: resourceState.attr
+					})
+				});
+			}
+			if (tailable.length === 0) {
+				if (filterSet) yield* Console.log("No tailable resources match --filter (deploy first, or selected resources may not support tail).");
+				else yield* Console.log("No tailable resources found. Deploy first, then run tail.");
+				return;
+			}
+			yield* Console.log(`Tailing: ${tailable.map((t) => t.logicalId).join(", ")}`);
+			const taggedStreams = tailable.map(({ logicalId, stream }, i) => {
+				const color = TAIL_COLORS[i % TAIL_COLORS.length];
+				return stream.pipe(Stream$1.map(({ timestamp, message }) => {
+					return `${color}${formatLocalTimestamp(timestamp)} [${logicalId}]${TAIL_RESET} ${message}`;
+				}));
+			});
+			yield* Stream$1.mergeAll(taggedStreams, { concurrency: "unbounded" }).pipe(Stream$1.runForEach((line) => Console.log(line)));
+		}).pipe(Effect.provide(stack.services));
+	}).pipe(Effect.provide(services$1));
+}));
+
+//#endregion
+//#region bin/alchemy.ts
+const root = Command$1.make("alchemy", {}).pipe(Command$1.withSubcommands([
 	bootstrapCommand,
 	deployCommand,
 	destroyCommand,
 	planCommand,
 	tailCommand,
-	logsCommand
+	logsCommand,
+	loginCommand
 ]));
-Command.run(root, { version }).pipe(Effect.provideService(ConfigProvider.ConfigProvider, ConfigProvider.fromEnv()), Effect.provide(NodeServices.layer), Effect.scoped, NodeRuntime.runMain);
+const cli = Command$1.run(root, { version });
+const services = Layer.mergeAll(Layer.provideMerge(dotAlchemy, PlatformServices), FetchHttpClient.layer, ConfigProvider.layer(ConfigProvider.fromEnv()));
+cli.pipe(Effect.provide(services), Effect.scoped, handleCancellation, runMain);
 
 //#endregion
 export {  };