@devdogsuga/devtools 0.1.49 → 0.1.51-next.526

package/dist/{failure-log-DOt6E3hS.js → root-CsocfxnK.js}

@@ -1,7 +1,7 @@
-import { a as ownVersion } from "./root-CjPWNkBu.js";
-import { mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { homedir, platform, release } from "node:os";
+import { fileURLToPath } from "node:url";
 //#region ../cli-core/src/args.ts
 /**
 * Positional arguments, with flag values excluded.
@@ -42,7 +42,11 @@ const VALUE_FLAGS = /* @__PURE__ */ new Set([
 	"--db-url",
 	"--user",
 	"--filter",
-	"--shell"
+	"--shell",
+	"--to",
+	"--secret",
+	"--content-type",
+	"--content-ref"
 ]);
 function positionals(argv) {
 	const found = [];
@@ -246,6 +250,27 @@ function cliName() {
 	return current;
 }
 //#endregion
+//#region ../cli-core/src/version.ts
+let cachedOwnDir;
+/** The published package's own root: the nearest directory above this
+* module's file that holds a `package.json`. A bundled CLI runs from a flat
+* `dist/`, so that is the CLI's root (`dist/launch.js` -> up one); the core
+* is inlined into it, so its own source location never matters at run time.
+* Memoized since it never changes within a process. */
+function ownPackageDir() {
+	if (cachedOwnDir !== void 0) return cachedOwnDir;
+	let dir = dirname(fileURLToPath(import.meta.url));
+	while (!existsSync(join(dir, "package.json")) && dirname(dir) !== dir) dir = dirname(dir);
+	cachedOwnDir = dir;
+	return dir;
+}
+/** Reads this build's own `package.json` version — used by `telemetry.ts`
+* (release tagging) and the CLI's `version` command. */
+function ownVersion() {
+	const pkg = JSON.parse(readFileSync(join(ownPackageDir(), "package.json"), "utf8"));
+	return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+}
+//#endregion
 //#region ../cli-core/src/failure-log.ts
 /**
 * A local log for a failed run, so a contributor has something to attach to
@@ -400,4 +425,78 @@ function installFailureLog(options) {
 	});
 }
 //#endregion
-export { cliName as a, YES as c, positionals as d, suppressFailureLog as i, createCatalog as l, noteError as n, JSON_FLAG as o, noteRan as r, SCOPES as s, installFailureLog as t, flagValue as u };
+//#region ../cli-core/src/repo/root.ts
+/**
+* Where devtools finds the DevDogsUGA checkout it is running against.
+*
+* devtools used to live inside `packages/devtools` of that repo, so its own
+* `import.meta.url` WAS a path into the repo (`PROJECT_ROOT` /
+* `REPO_ROOT` walked up a fixed number of `..` segments from this file).
+* Published as its own package and run through `pnpm dlx`, that assumption
+* breaks: this file's `import.meta.url` points into a dlx cache directory
+* or an isolated `node_modules` tree that has nothing to do with the repo
+* the contributor is standing in.
+*
+* So repo discovery walks up from `process.cwd()` instead, looking for the
+* marker validated in the `devtools-dlx` prototype
+* (`/home/sloan/scratchpad/devdogs/prototypes/devtools-dlx/FINDINGS.md`,
+* experiment 1): a directory containing `pnpm-workspace.yaml` AND whose
+* `package.json` has `"name": "devdogs-monorepo"` (DevDogsUGA) or
+* `"backstage"` (Backstage, which the CLIs also run from; `layout.ts` says
+* what differs). The name check is not redundant — a bare
+* `pnpm-workspace.yaml` matches any pnpm workspace, which devtools should
+* refuse rather than silently "find".
+*/
+/**
+* The `package.json` names a repo root may carry: DevDogsUGA's, and Backstage's
+* (the CLIs run from both; see `layout.ts`).
+*/
+const REPO_MARKER_NAMES = ["devdogs-monorepo", "backstage"];
+var RepoNotFoundError = class extends Error {
+	constructor() {
+		super("run this from inside a DevDogsUGA clone");
+		this.name = "RepoNotFoundError";
+	}
+};
+function looksLikeRepoRoot(dir) {
+	if (!existsSync(join(dir, "pnpm-workspace.yaml"))) return false;
+	try {
+		const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+		return REPO_MARKER_NAMES.includes(pkg.name);
+	} catch {
+		return false;
+	}
+}
+/**
+* Walks up from `startDir` (default `process.cwd()`) looking for the repo
+* marker. Returns `null` rather than throwing — `findRepoRoot()` below is
+* the throwing convenience most callers want; this is exported for callers
+* (like `setup`) that need to know without failing.
+*/
+function discoverRepoRoot(startDir = process.cwd()) {
+	let dir = startDir;
+	for (;;) {
+		if (looksLikeRepoRoot(dir)) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+let cachedRoot;
+/**
+* The memoized, throwing repo-root lookup. Lazy on purpose: importing this
+* module must never fail just because nothing has called it yet (`setup`
+* and `completions` in `launch.ts` never need a repo at all, and must stay
+* that way — see that file's header comment on why).
+*
+* Resolved once per process: `process.cwd()` does not change mid-invocation
+* for this CLI, and re-walking the filesystem on every call would be pure
+* waste.
+*/
+function findRepoRoot() {
+	if (cachedRoot === void 0) cachedRoot = process.env.DEVTOOLS_TEST_REPO_ROOT ?? discoverRepoRoot();
+	if (cachedRoot === null) throw new RepoNotFoundError();
+	return cachedRoot;
+}
+//#endregion
+export { noteError as a, ownPackageDir as c, JSON_FLAG as d, SCOPES as f, positionals as g, flagValue as h, installFailureLog as i, ownVersion as l, createCatalog as m, discoverRepoRoot as n, noteRan as o, YES as p, findRepoRoot as r, suppressFailureLog as s, RepoNotFoundError as t, cliName as u };

package/dist/session-CmDxHEMn.js

@@ -0,0 +1,2 @@
+import { a as parseSessionSelector, c as rememberDevDatabase, i as enterEnvironment, l as rememberedDevDatabase, n as availableTiers, o as resolveSessionTier, r as developmentRemoteCandidate, s as askSession, t as SESSION_SELECTORS } from "./session-rbONwFvY.js";
+export { SESSION_SELECTORS, askSession, availableTiers, developmentRemoteCandidate, enterEnvironment, parseSessionSelector, rememberDevDatabase, rememberedDevDatabase, resolveSessionTier };

package/dist/session-rbONwFvY.js

@@ -0,0 +1,431 @@
+import { _ as fileFor, d as loadEnvironment, f as parseRawAssignments, h as DEPLOY_ENVIRONMENTS, p as probeLocalStack, t as DEV_DB_ENV, u as isDevDatabase, v as isDeployEnvironment } from "./load-Cp8AMERM.js";
+//#region ../cli-core/src/env-runtime/ask.ts
+/**
+* The interactive half of session resolution, shared by `with-env` and the
+* devtools launcher so both ask the same questions the same way.
+*
+* `resolveSessionTier` (in `session.ts`) is the policy; this wires it to a
+* terminal. It adds the one thing the policy deliberately leaves out: which
+* development database a contributor picked can be REMEMBERED, as a
+* `DEV_DB=local|remote` line in the development env file (`.env`). The first
+* time development is ambiguous (`.env` names a `DB_URL` and the local stack
+* is the other option), the picker asks local or remote, then "Remember my
+* decision" or "Just this once". Remembering writes the line; just this once
+* writes nothing, so the next run asks again. Deleting the line forgets.
+*
+* A remembered value counts exactly like an exported `DEV_DB`, which still
+* wins over it: a shell export or a parent session's answer is the more
+* specific choice.
+*
+* Off a terminal the callers differ, which is what `unanswered` says.
+* `with-env` fronts `pnpm -r` and CI, so with nothing remembered it lets the
+* local-stack probe decide, as it always has. The devtools launcher refuses
+* and asks for `--tier development:local|remote`.
+*
+* ⚠️ Node-only, like the rest of `session.ts`, and kept out of `index.ts` for
+* the same reason. `@clack/prompts` is imported only when a question is
+* actually shown: `with-env` runs this on every script, and the remembered
+* value is read with `parseRawAssignments` rather than dotenvx for the same
+* reason (see the import-cost note at the top of `cli.ts`).
+*/
+/**
+* Resolves the session, asking on a terminal and offering to remember the
+* development database. Returns the same result `resolveSessionTier` does.
+*/
+async function askSession(opts) {
+	const devDb = nonEmpty(opts.devDb) ?? await rememberedDevDatabase(opts.root);
+	const deployEnv = nonEmpty(opts.deployEnv);
+	const remoteCandidate = devDb === void 0 && (opts.explicit === "development" || opts.explicit === void 0 && (deployEnv === void 0 || deployEnv === "development")) && (opts.canAsk || opts.unanswered === "refuse") ? await developmentRemoteCandidate(opts.root) : void 0;
+	const localStackOnline = typeof remoteCandidate === "string" ? await probeLocalStack() : void 0;
+	let asked = false;
+	const resolution = await resolveSessionTier({
+		explicit: opts.explicit,
+		deployEnv: opts.deployEnv,
+		devDb,
+		available: opts.available,
+		isTTY: opts.canAsk,
+		remoteCandidate,
+		localStackOnline,
+		promptMessage: "Which environment should this session use?",
+		...opts.canAsk && { prompt: async (message, choices) => {
+			asked = true;
+			return choose(message, choices, opts.onCancel);
+		} }
+	});
+	if (resolution.ok && asked && resolution.devDatabase !== void 0) {
+		if (await choose(`Use the ${resolution.devDatabase} database from now on?`, [{
+			value: true,
+			label: "Remember my decision",
+			hint: `saves DEV_DB=${resolution.devDatabase} to ${fileFor("development")}`
+		}, {
+			value: false,
+			label: "Just this once"
+		}], opts.onCancel)) {
+			await rememberDevDatabase(opts.root, resolution.devDatabase);
+			process.stderr.write(`${opts.name}: saved ${DEV_DB_ENV}=${resolution.devDatabase} to ${fileFor("development")}; delete that line to be asked again.\n`);
+		}
+	}
+	return resolution;
+}
+/**
+* The `DEV_DB` the development env file remembers, raw (an invalid value is
+* passed on so `resolveSessionTier` refuses it by name), or `undefined`.
+*/
+async function rememberedDevDatabase(root) {
+	const text = await readDevelopmentFile(root);
+	if (text === void 0) return void 0;
+	return nonEmpty(parseRawAssignments(text).get(DEV_DB_ENV)?.raw);
+}
+/** Writes `DEV_DB=<db>` to the development env file, replacing a line that
+* is already there. The file keeps its mode. */
+async function rememberDevDatabase(root, db) {
+	const { writeFile } = await import("node:fs/promises");
+	const { join } = await import("node:path");
+	const text = await readDevelopmentFile(root) ?? "";
+	const line = `${DEV_DB_ENV}=${db}`;
+	const existing = new RegExp(`^[ \\t]*(?:export[ \\t]+)?${DEV_DB_ENV}[ \\t]*=.*$`, "m");
+	const next = existing.test(text) ? text.replace(existing, line) : `${text}${text === "" || text.endsWith("\n") ? "" : "\n"}\n# Which development database to use (local or remote). Delete to be asked again.\n${line}\n`;
+	await writeFile(join(root, fileFor("development")), next, { mode: 384 });
+}
+async function readDevelopmentFile(root) {
+	const { readFile } = await import("node:fs/promises");
+	const { join } = await import("node:path");
+	try {
+		return await readFile(join(root, fileFor("development")), "utf8");
+	} catch {
+		return;
+	}
+}
+async function choose(message, options, onCancel) {
+	const { cancel, isCancel, select } = await import("@clack/prompts");
+	const choice = await select({
+		message,
+		options
+	});
+	if (isCancel(choice)) {
+		if (onCancel) onCancel();
+		cancel("Cancelled.");
+		process.exit(1);
+	}
+	return choice;
+}
+function nonEmpty(value) {
+	return value === void 0 || value === "" ? void 0 : value;
+}
+//#endregion
+//#region ../cli-core/src/env-runtime/session.ts
+/**
+* The shared tier-SESSION core: which deploy tier a process runs under, and
+* entering it.
+*
+* `with-env` and the devtools launcher both used to ask "which tier?" with
+* their own copy of the answer (see `packages/devtools/src/tier.ts`, whose
+* `availableTiers`/`resolveTier` this module supersedes as the one place the
+* policy lives). Two copies drift: a typo in `DEPLOY_ENV` fell through to the
+* picker in one implementation and would have run as development in a
+* hand-rolled second one, and neither mistake shows up until someone actually
+* has the typo. `resolveSessionTier` below is the ONE policy; every caller
+* gets a discriminated result it can print and act on identically.
+*
+* `availableTiers`/`resolveSessionTier` are pure: file existence, the
+* ambient `DEPLOY_ENV`, TTY-ness and the prompt function are all injected, so
+* the policy table is exercised in `session.test.ts` without touching a real
+* filesystem or terminal. `enterEnvironment` is deliberately NOT pure — its
+* entire job is mutating `process.env` for the CURRENT process, which is
+* what "entering" a tier means — and is left untested here for that reason;
+* it is a thin, one-branch-free wrapper around `loadEnvironment`, which
+* already carries the coverage for selection and loading.
+*
+* ⚠️ This module lives in cli-core, outside `@devdogsuga/sdk/env`, ON
+* PURPOSE, like `load.ts`, and MUST stay out of
+* the sdk env entry. The `@devdogsuga/sdk/env` export is imported by `apps/platform`, which
+* deploys to Cloudflare Workers; `enterEnvironment` calls `loadEnvironment`,
+* which dynamically imports `node:fs`/`node:path`/`node:url` and
+* `@dotenvx/dotenvx`, none of which exist at the edge. Re-exporting any of
+* this from `index.ts` would make an edge import fail at runtime instead of
+* at build.
+*/
+/**
+* The words `--tier` accepts, and the one place they are spelled out. The
+* development qualifiers exist because `staging` and `production` are ALSO
+* remote databases: a bare `local`/`remote` pair would steal the words that
+* describe them. See `DevDatabase` in `load.ts` for what the qualifier means.
+*/
+const SESSION_SELECTORS = [
+	"development:local",
+	"development:remote",
+	"staging",
+	"production"
+];
+/**
+* Parses one `--tier` word: a plain deploy tier, or a qualified
+* `development:<local|remote>`. Returns `null` for anything else — the
+* CALLER phrases the refusal, because "unknown tier" reads differently on a
+* flag than on a picker answer.
+*/
+function parseSessionSelector(value) {
+	const colon = value.indexOf(":");
+	if (colon === -1) return isDeployEnvironment(value) ? { tier: value } : null;
+	const tier = value.slice(0, colon);
+	const qualifier = value.slice(colon + 1);
+	if (tier !== "development" || !isDevDatabase(qualifier)) return null;
+	return {
+		tier: "development",
+		devDatabase: qualifier
+	};
+}
+/**
+* Deploy tiers whose canonical `.env.<tier>` file exists, in danger order
+* (the same order `DEPLOY_ENVIRONMENTS` is declared in, least- to
+* most-dangerous — see `targets.ts`).
+*
+* ⚠️ Consults `fileFor(tier)` over `DEPLOY_ENVIRONMENTS`, NEVER a glob of
+* `.env*`. `.env.generated` is development's local-stack overlay — written
+* whenever `devtools db start` brings the local Supabase stack up — not a
+* second tier's credentials. Globbing would make a running local stack count
+* as a second tier and trip `resolveSessionTier`'s prompt for everyone who
+* has ever started it; filtering the fixed table by existence is what keeps
+* development counted exactly once.
+*/
+async function availableTiers(root, exists) {
+	let check = exists;
+	if (!check) {
+		const { existsSync } = await import("node:fs");
+		const { join } = await import("node:path");
+		check = (f) => existsSync(join(root, f));
+	}
+	return DEPLOY_ENVIRONMENTS.filter((tier) => check(fileFor(tier)));
+}
+/**
+* The ONE tier-selection policy, shared by `with-env` and the devtools
+* launcher.
+*
+*   a. An explicit `--tier` wins outright. Invalid means refusal — it never
+*      falls through to `DEPLOY_ENV` or the prompt, because that would make
+*      `--tier bogus` silently resolve to whatever those said instead of
+*      reporting the typo.
+*   b. Otherwise a non-empty `DEPLOY_ENV` wins. Invalid ALSO means refusal —
+*      mirroring `UnknownEnvironmentError`'s stance in `targets.ts`: a typo
+*      must not run as development, the way falling through to a "default"
+*      tier would let it.
+*   c. Otherwise, with at most one tier file present, there is nothing to
+*      choose between: return it, or `"development"` on a machine that has
+*      never run `env pull` at all. No prompt, ever — the common case for
+*      an ordinary contributor, who has only `.env`.
+*   d. Otherwise (2+ session choices present) this is the signature of
+*      someone working on the deploy workflow itself. Prompt for it, but
+*      ONLY when a `prompt` function was given and the terminal is
+*      interactive; picking a tier whose file is absent is still a refusal,
+*      naming `env pull`. With no prompt, or outside a TTY, refuse instead
+*      of guessing — the message lists the choices present and the ways to
+*      answer.
+*
+* Wherever a resolution lands on `development`, one more question can
+* remain — WHICH development database (see `DevDatabase`). A qualified
+* selector (`development:local|remote`) answers it outright; then a valid
+* `DEV_DB`; then, when the caller looked and found a remote candidate
+* (`remoteCandidate` a string), the same ask-or-refuse discipline as the
+* tier itself; with no candidate (or a caller that did not look), the
+* qualifier stays absent and the load probe decides, as it always has.
+*/
+async function resolveSessionTier(opts) {
+	if (opts.explicit !== void 0) {
+		const parsed = parseSessionSelector(opts.explicit);
+		if (parsed === null) return {
+			ok: false,
+			reason: `unknown tier "${opts.explicit}". Expected: development, ${SESSION_SELECTORS.join(", ")}.`
+		};
+		if (parsed.tier !== "development" || parsed.devDatabase !== void 0) return {
+			ok: true,
+			...parsed,
+			resolvedBy: "explicit"
+		};
+		return qualifyDevelopment(opts, "explicit");
+	}
+	if (opts.deployEnv !== void 0 && opts.deployEnv !== "") {
+		if (!isDeployEnvironment(opts.deployEnv)) return {
+			ok: false,
+			reason: `DEPLOY_ENV="${opts.deployEnv}" is not one of ${DEPLOY_ENVIRONMENTS.join(", ")}.`
+		};
+		if (opts.deployEnv !== "development") return {
+			ok: true,
+			tier: opts.deployEnv,
+			resolvedBy: "deployEnv"
+		};
+		return qualifyDevelopment(opts, "deployEnv");
+	}
+	if (opts.available.length <= 1) {
+		const tier = opts.available[0] ?? "development";
+		if (tier !== "development") return {
+			ok: true,
+			tier,
+			resolvedBy: "sole"
+		};
+		return qualifyDevelopment(opts, "sole");
+	}
+	if (opts.prompt !== void 0 && opts.isTTY) {
+		const choices = DEPLOY_ENVIRONMENTS.flatMap((tier) => {
+			if (!opts.available.includes(tier)) return [{
+				value: tier,
+				label: tier,
+				hint: `needs env pull --target ${tier}`
+			}];
+			if (tier === "development") {
+				if (typeof opts.remoteCandidate !== "string") return [{
+					value: tier,
+					label: tier,
+					hint: "the default"
+				}];
+				return [{
+					value: "development:local",
+					label: "development:local",
+					hint: `Docker stack${localStackHint(opts.localStackOnline)}`
+				}, {
+					value: "development:remote",
+					label: "development:remote",
+					hint: opts.remoteCandidate
+				}];
+			}
+			return [{
+				value: tier,
+				label: tier,
+				hint: tier === "production" ? "⚠️  live data" : void 0
+			}];
+		});
+		const choice = await opts.prompt(opts.promptMessage ?? "Which environment should this session use?", choices);
+		const parsed = parseSessionSelector(choice);
+		if (parsed === null) return {
+			ok: false,
+			reason: `unknown tier "${choice}".`
+		};
+		if (!opts.available.includes(parsed.tier)) return {
+			ok: false,
+			reason: `${fileFor(parsed.tier)} is not present — run \`pnpm devtools env pull --target ${parsed.tier}\` first.`
+		};
+		return {
+			ok: true,
+			...parsed,
+			resolvedBy: "prompt"
+		};
+	}
+	return {
+		ok: false,
+		reason: `multiple deploy tiers are present (${opts.available.map(fileFor).join(", ")}) and none was selected. Pass --tier <tier> (${SESSION_SELECTORS.join(", ")}), set DEPLOY_ENV=<tier>, or run through \`pnpm devtools\` to pick one interactively.`
+	};
+}
+function localStackHint(online) {
+	if (online === void 0) return "";
+	return online ? " · online" : " · offline";
+}
+/**
+* The development-database half of the policy, for a resolution that landed
+* on bare `development`: `DEV_DB` answers it; otherwise a remote candidate
+* makes it a real question (asked on a TTY, refused off one); otherwise the
+* qualifier stays absent and the load probe decides. See
+* `ResolveSessionTierOptions.remoteCandidate` for why "the caller did not
+* look" and "the caller looked and found nothing" both resolve unqualified.
+*/
+async function qualifyDevelopment(opts, resolvedBy) {
+	if (opts.devDb !== void 0 && opts.devDb !== "") {
+		if (!isDevDatabase(opts.devDb)) return {
+			ok: false,
+			reason: `${DEV_DB_ENV}="${opts.devDb}" is not one of: local, remote.`
+		};
+		return {
+			ok: true,
+			tier: "development",
+			devDatabase: opts.devDb,
+			resolvedBy
+		};
+	}
+	if (typeof opts.remoteCandidate !== "string") return {
+		ok: true,
+		tier: "development",
+		resolvedBy
+	};
+	if (opts.prompt !== void 0 && opts.isTTY) {
+		const choice = await opts.prompt("Which development database?", [{
+			value: "development:local",
+			label: "development:local",
+			hint: `Docker stack${localStackHint(opts.localStackOnline)}`
+		}, {
+			value: "development:remote",
+			label: "development:remote",
+			hint: opts.remoteCandidate
+		}]);
+		const parsed = parseSessionSelector(choice);
+		if (parsed?.tier !== "development") return {
+			ok: false,
+			reason: `unknown development database "${choice}".`
+		};
+		return {
+			ok: true,
+			...parsed,
+			resolvedBy: "prompt"
+		};
+	}
+	return {
+		ok: false,
+		reason: `\`development\` is ambiguous here: .env names a remote database (${opts.remoteCandidate}) and the Docker stack is a second one. Pass --tier development:local or --tier development:remote (or set ${DEV_DB_ENV}=local|remote).`
+	};
+}
+/**
+* Whether `.env` names a remote development database, and where it points:
+* the `DB_URL` hostname for the picker's `development:remote` hint, or
+* `null` when there is no `.env`, no `DB_URL`, or an empty one. A `DB_URL`
+* whose value does not parse as a URL still counts — it would still be used
+* — and reports a placeholder host rather than vanishing from the choices.
+*
+* Reads the file directly (through dotenvx's parser, never a hand-rolled
+* one) rather than `loadEnvironment`: the whole point is to see what `.env`
+* ITSELF says before any overlay or ambient value has had a say.
+*/
+async function developmentRemoteCandidate(root) {
+	const { existsSync, readFileSync } = await import("node:fs");
+	const { join } = await import("node:path");
+	const path = join(root, fileFor("development"));
+	if (!existsSync(path)) return null;
+	let dbUrl;
+	try {
+		const { default: dx } = await import("@dotenvx/dotenvx");
+		dbUrl = dx.parse(readFileSync(path, "utf8")).DB_URL;
+	} catch {
+		return null;
+	}
+	if (dbUrl === void 0 || dbUrl === "") return null;
+	try {
+		return new URL(dbUrl).hostname || "a remote database";
+	} catch {
+		return "a remote database";
+	}
+}
+/**
+* Enters a deploy tier for the CURRENT process: loads its env files via
+* `loadEnvironment`, applies the resulting map onto `process.env` (plus
+* `DEPLOY_ENV=tier`, so anything reading it afterwards — including a nested
+* `resolveSessionTier` call — sees the tier just entered), and hands back
+* what changed.
+*
+* Deliberately does not print anything: the "loaded … (<tier>)" line is
+* mandatory (see `load.ts`'s `Selection.warnings` and this module's own
+* header) but belongs to the caller, exactly as `loadEnvironment` leaves the
+* stderr line to `with-env`. `MissingEnvFileError` is not caught here either,
+* for the same reason `loadEnvironment` does not catch it: only the caller
+* knows whether a missing file for THIS tier is fatal or survivable.
+*/
+async function enterEnvironment(tier, opts) {
+	const loaded = await loadEnvironment(tier, {
+		override: opts?.override ?? false,
+		devDatabase: opts?.devDatabase
+	});
+	for (const [key, value] of Object.entries(loaded.env)) process.env[key] = value;
+	process.env.DEPLOY_ENV = tier;
+	if (opts?.devDatabase !== void 0) process.env[DEV_DB_ENV] = opts.devDatabase;
+	return {
+		files: loaded.files,
+		warnings: loaded.warnings,
+		environment: loaded.env
+	};
+}
+//#endregion
+export { parseSessionSelector as a, rememberDevDatabase as c, enterEnvironment as i, rememberedDevDatabase as l, availableTiers as n, resolveSessionTier as o, developmentRemoteCandidate as r, askSession as s, SESSION_SELECTORS as t };

package/dist/{stack-C_50FafG.js → stack-7Lbym6Wq.js}

@@ -1,7 +1,6 @@
-import { a as listContainerNames, d as seedBuckets, f as supabase, i as foreignStackProjectId, o as readProjectId, p as supabaseCapture, r as foreignStackMessage, t as STACK_API_PORT, y as isDryRun } from "./supabase-project-C93xRFkN.js";
-import { i as loadEnvSession, p as resolveLayout, r as loadEnvLoad } from "./peers-DvUH5VxX.js";
-import { writeFile } from "node:fs/promises";
+import { E as resolveLayout, _ as loadEnvLoad, a as listContainerNames, d as seedBuckets, f as supabase, i as foreignStackProjectId, j as isDryRun, o as readProjectId, p as supabaseCapture, r as foreignStackMessage, t as STACK_API_PORT, v as loadEnvSession } from "./supabase-project-BoJKMCxL.js";
 import { join } from "node:path";
+import { writeFile } from "node:fs/promises";
 //#region src/db/session-refresh.ts
 /**
 * Re-enters development — refreshing `process.env` from `.env.generated`'s

package/dist/stack-7qA2UP9g.js

@@ -0,0 +1,2 @@
+import { t as runStackCommand } from "./stack-7Lbym6Wq.js";
+export { runStackCommand };