@devdogsuga/devtools 0.1.41 → 0.1.43

package/dist/{local-env-hH4encfD.js → local-env-BuHU5Ckd.js}

@@ -1,7 +1,7 @@
-import { i as ownPackageDir, r as findRepoRoot } from "./root-C2OmZDwD.js";
-import { a as repoPeerUrl, n as loadEnv, t as getEnvSync } from "./peers-RBplwovA.js";
+import { i as ownPackageDir } from "./root-CjPWNkBu.js";
+import { a as repoPeerUrl, n as loadEnv, o as resolveRepoPeerUrl, p as resolveLayout, t as getEnvSync } from "./peers-DvUH5VxX.js";
 import { register } from "node:module";
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, readdirSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 //#region ../cli-core/src/repo/peer-redirect.ts
@@ -23,10 +23,10 @@ import { pathToFileURL } from "node:url";
 * manifest also imports `zod`, which has to keep resolving from devtools'
 * own location, and a copy written anywhere else would lose that.
 */
-/** Registers `redirect`. Hooks cannot be unregistered, so each call adds a
-*  loader for the rest of the process; call it once per redirect. */
-function redirectPeer(redirect) {
-	register("./peer-redirect-hooks.js", import.meta.url, { data: [redirect] });
+/** `redirectPeer` for several at once: the hooks keep one table per
+*  registration, so everything that needs redirecting goes in one call. */
+function redirectPeers(redirects) {
+	register("./peer-redirect-hooks.js", import.meta.url, { data: redirects });
 }
 //#endregion
 //#region ../cli-core/src/repo/tsx-loader.ts
@@ -85,7 +85,11 @@ async function importRepoTs(absolutePath) {
 * filename (`tsconfig.json`, `wrangler.jsonc`, `supadart.yaml`), and a pointer
 * would be the only one of its kind.
 *
-* One special case: `supabase/env.ts` sits at the repo root, OUTSIDE the
+* From a Backstage checkout the scan covers BOTH repos (`repo/layout.ts`):
+* Backstage's `apps/*` and `packages/*`, then DevDogsUGA's through
+* `devdogsuga/`, de-duplicated by directory name with Backstage first.
+*
+* One special case: `supabase/env.ts` sits at DevDogsUGA's root, OUTSIDE the
 * workspace globs. Its variables belong to `config.toml` and the Supabase
 * CLI, not to any package, so it lives next to the config that reads them.
 *
@@ -157,12 +161,17 @@ function assertRegistryLoaded() {
 }
 async function importManifests() {
 	await loadEnv();
+	const redirects = [];
 	const envUrl = repoPeerUrl("@devdogsuga/env");
-	if (envUrl) redirectPeer({
-		parentURL: pathToFileURL(ownManifestPath()).href,
-		specifier: "@devdogsuga/env",
-		url: envUrl
-	});
+	if (envUrl) {
+		redirects.push({
+			parentURL: pathToFileURL(ownManifestPath()).href,
+			specifier: "@devdogsuga/env",
+			url: envUrl
+		});
+		redirects.push(...siblingRedirects(envUrl));
+	}
+	if (redirects.length > 0) redirectPeers(redirects);
 	const previous = process.env.SKIP_ENV_VALIDATION;
 	process.env.SKIP_ENV_VALIDATION = "1";
 	try {
@@ -177,6 +186,36 @@ async function importManifests() {
 	}
 }
 /**
+* From a Backstage checkout, the manifests under `devdogsuga/` import
+* `@devdogsuga/env` through THAT checkout's `node_modules` (or not at all, when
+* it has none): a second copy of the package, and so a second registry that
+* every `declare()` there would populate instead of the one this process
+* reads. Point their imports at the copy `loadEnv()` resolved. Resolved
+* through `realpath`, because the loader sees the module's real location, not
+* the `devdogsuga` symlink.
+*/
+function siblingRedirects(envUrl) {
+	const layout = resolveLayout();
+	if (layout.kind !== "backstage" || !layout.hasDevdogsuga) return [];
+	const nextjs = resolveRepoPeerUrl("@devdogsuga/env/nextjs");
+	const redirects = [];
+	for (const path of manifestPaths()) {
+		if (!path.startsWith(layout.devdogsugaRoot)) continue;
+		const parentURL = pathToFileURL(realpathSync(path)).href;
+		redirects.push({
+			parentURL,
+			specifier: "@devdogsuga/env",
+			url: envUrl
+		});
+		if (nextjs) redirects.push({
+			parentURL,
+			specifier: "@devdogsuga/env/nextjs",
+			url: nextjs
+		});
+	}
+	return redirects;
+}
+/**
 * Every manifest file, in a stable order.
 *
 * The workspace members are enumerated by scanning `apps/*` and `packages/*`
@@ -192,7 +231,8 @@ function manifestPaths() {
 		const manifest = manifestIn(dir);
 		if (manifest) paths.push(manifest);
 	}
-	const supabase = manifestIn(join(findRepoRoot(), "supabase"));
+	const layout = resolveLayout();
+	const supabase = layout.hasDevdogsuga ? manifestIn(join(layout.devdogsugaRoot, "supabase")) : null;
 	if (supabase) paths.push(supabase);
 	paths.push(ownManifestPath());
 	return paths;
@@ -213,20 +253,41 @@ function manifestPaths() {
 function ownManifestPath() {
 	return join(ownPackageDir(), "env.ts");
 }
+/**
+* The CLIs' own packages: each loads its own operator manifest through
+* `ownManifestPath()`, so scanning them from a Backstage checkout would
+* declare the same keys twice.
+*/
+const CLI_PACKAGES = /* @__PURE__ */ new Set(["devtools", "backstage"]);
+/**
+* `apps/*` and `packages/*` of every repo in the layout (the repo you are in
+* first, so it wins a name clash: before the cutover both repos carry
+* `apps/platform` and `packages/email`), then DevDogsUGA's `docs`.
+*/
 function workspaceDirs() {
+	const layout = resolveLayout();
+	const roots = [layout.root];
+	if (layout.kind === "backstage" && layout.hasDevdogsuga) roots.push(layout.devdogsugaRoot);
 	const dirs = [];
-	const repoRoot = findRepoRoot();
 	for (const parent of ["apps", "packages"]) {
-		const names = [];
-		for (const entry of readdirSync(join(repoRoot, parent), { withFileTypes: true })) {
-			if (!entry.isDirectory()) continue;
-			if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-			names.push(entry.name);
+		const found = /* @__PURE__ */ new Map();
+		for (const root of roots) {
+			let entries;
+			try {
+				entries = readdirSync(join(root, parent), { withFileTypes: true });
+			} catch {
+				continue;
+			}
+			for (const entry of entries) {
+				if (!entry.isDirectory()) continue;
+				if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+				if (layout.kind === "backstage" && parent === "packages" && CLI_PACKAGES.has(entry.name)) continue;
+				if (!found.has(entry.name)) found.set(entry.name, join(root, parent, entry.name));
+			}
 		}
-		names.sort();
-		for (const name of names) dirs.push(join(repoRoot, parent, name));
+		for (const name of [...found.keys()].sort()) dirs.push(found.get(name));
 	}
-	dirs.push(join(repoRoot, "docs"));
+	if (layout.hasDevdogsuga) dirs.push(join(layout.devdogsugaRoot, "docs"));
 	return dirs;
 }
 /** `src/env.ts`, then `env.ts`; both present in one package is a hard error. */

package/dist/local-env-MqH18s-N.js

@@ -0,0 +1,2 @@
+import { t as scopedProcessEnv } from "./local-env-BuHU5Ckd.js";
+export { scopedProcessEnv };

package/dist/{menu-Craj11Sn.js → menu-DYQ-Dd-O.js}

@@ -1,8 +1,8 @@
-import { c as YES, d as positionals, i as suppressFailureLog, l as createCatalog, o as JSON_FLAG, s as SCOPES } from "./failure-log-B5GG_8T1.js";
-import { a as listContainerNames, i as foreignStackProjectId, n as containerPrefix, o as readProjectId, p as supabaseCapture, r as foreignStackMessage, t as STACK_API_PORT } from "./supabase-project-Bw8sBFcE.js";
-import { r as findRepoRoot } from "./root-C2OmZDwD.js";
-import { n as loadEnv, r as loadEnvLoad } from "./peers-RBplwovA.js";
-import { c as reportDevtoolsError, f as isNonInteractive } from "./telemetry-Do13RFhc.js";
+import { c as YES, d as positionals, i as suppressFailureLog, l as createCatalog, o as JSON_FLAG, s as SCOPES } from "./failure-log-DOt6E3hS.js";
+import { a as listContainerNames, i as foreignStackProjectId, n as containerPrefix, o as readProjectId, p as supabaseCapture, r as foreignStackMessage, t as STACK_API_PORT } from "./supabase-project-C93xRFkN.js";
+import { r as findRepoRoot } from "./root-CjPWNkBu.js";
+import { c as devdogsugaRootOrNull, n as loadEnv, p as resolveLayout, r as loadEnvLoad } from "./peers-DvUH5VxX.js";
+import { c as reportDevtoolsError, f as isNonInteractive } from "./telemetry-C07-ioHm.js";
 import { cancel, confirm, isCancel, log, note, select, text } from "@clack/prompts";
 import { existsSync } from "node:fs";
 import { writeFile } from "node:fs/promises";
@@ -826,7 +826,7 @@ async function ensureGeneratedEnvFile(tier, devDatabase, deps) {
 	if (!await deps.probeLocalStack()) return { outcome: "skipped" };
 	try {
 		const env = await deps.captureStatus();
-		await deps.write(join(deps.repoRoot, GENERATED_FILE), env);
+		for (const dir of [deps.repoRoot, ...deps.mirrorRoots ?? []]) await deps.write(join(dir, GENERATED_FILE), env);
 		return {
 			outcome: "wrote",
 			line: "devtools: wrote .env.generated from the running local stack"
@@ -851,15 +851,18 @@ async function ensureGeneratedEnvFile(tier, devDatabase, deps) {
 * different copies of the same optional peer in play.
 */
 function realEnsureGeneratedEnvDeps(probeLocalStack) {
-	const repoRoot = findRepoRoot();
+	const layout = resolveLayout();
+	const repoRoot = layout.root;
+	const supabaseRoot = devdogsugaRootOrNull(layout);
 	return {
 		probeLocalStack,
-		exists: (file) => existsSync(join(repoRoot, file)),
+		exists: (file) => [repoRoot, ...layout.envMirrors].every((dir) => existsSync(join(dir, file))),
 		captureStatus: () => supabaseCapture("status", "-o", "env"),
 		write: (path, contents) => writeFile(path, contents),
 		listContainerNames: () => listContainerNames(STACK_API_PORT),
-		projectId: () => readProjectId(repoRoot),
-		repoRoot
+		projectId: () => supabaseRoot === null ? null : readProjectId(supabaseRoot),
+		repoRoot,
+		mirrorRoots: layout.envMirrors
 	};
 }
 //#endregion
@@ -1276,7 +1279,8 @@ function probeEnvironment(execute = run) {
 		stack: "unknown",
 		envFile
 	};
-	const prefix = containerPrefix(readProjectId(findRepoRoot()));
+	const supabaseRoot = devdogsugaRootOrNull(resolveLayout());
+	const prefix = containerPrefix(supabaseRoot === null ? null : readProjectId(supabaseRoot));
 	return {
 		docker,
 		stack: names.split("\n").some((name) => name.trim().startsWith(prefix)) ? "yes" : "no",

package/dist/{peers-RBplwovA.js → peers-DvUH5VxX.js}

@@ -1,8 +1,114 @@
-import { r as findRepoRoot, t as RepoNotFoundError } from "./root-C2OmZDwD.js";
+import { r as findRepoRoot, t as RepoNotFoundError } from "./root-CjPWNkBu.js";
 import { createRequire } from "node:module";
-import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
+/** The directory (relative to a Backstage root) holding the DevDogsUGA checkout. */
+const DEVDOGSUGA_LINK = "devdogsuga";
+var DevdogsugaMissingError = class extends Error {
+	constructor(path) {
+		super(`The DevDogsUGA checkout is missing at ${path}. Run \`pnpm devdogsuga\` (links the sibling clone, or \$DEVDOGSUGA_DIR) or \`pnpm install\` in the Backstage root first.`);
+		this.name = "DevdogsugaMissingError";
+	}
+};
+/** The kind of repo `dir` is the root of, by its `package.json` name; null if neither. */
+function repoKindOf(dir) {
+	try {
+		const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+		if (pkg.name === "devdogs-monorepo") return "devdogsuga";
+		if (pkg.name === "backstage") return "backstage";
+	} catch {}
+	return null;
+}
+function isDir(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+/**
+* The layout of the repo rooted at `root`. Pure: nothing is memoized, so tests
+* can build fixtures freely. An unrecognised package name is treated as
+* DevDogsUGA (the contract fixtures and every pre-Backstage caller).
+*/
+function layoutAt(root) {
+	const kind = repoKindOf(root) === "backstage" ? "backstage" : "devdogsuga";
+	const sibling = join(root, DEVDOGSUGA_LINK);
+	const hasDevdogsuga = kind === "devdogsuga" || isDir(sibling);
+	const devdogsugaRoot = kind === "devdogsuga" ? root : sibling;
+	const appsDirs = [join(root, "apps")];
+	if (kind === "backstage" && hasDevdogsuga) appsDirs.push(join(devdogsugaRoot, "apps"));
+	return {
+		kind,
+		root,
+		get devdogsugaRoot() {
+			if (!hasDevdogsuga) throw new DevdogsugaMissingError(sibling);
+			return devdogsugaRoot;
+		},
+		...kind === "backstage" ? { backstageRoot: root } : {},
+		hasDevdogsuga,
+		appsDirs: appsDirs.filter(isDir),
+		envMirrors: kind === "backstage" && hasDevdogsuga ? [devdogsugaRoot] : []
+	};
+}
+/** `layout.devdogsugaRoot`, or null instead of a throw when the checkout is missing. */
+function devdogsugaRootOrNull(layout) {
+	return layout.hasDevdogsuga ? layout.devdogsugaRoot : null;
+}
+let cached;
+let cachedFor;
+/** The layout of the repo the process is in (`findRepoRoot()`), memoized per root. */
+function resolveLayout() {
+	const root = findRepoRoot();
+	if (cached === void 0 || cachedFor !== root) {
+		cached = layoutAt(root);
+		cachedFor = root;
+	}
+	return cached;
+}
+/** Every directory under `appsDirs` (one app each), de-duplicated by name, sorted by name. */
+function listApps(layout = resolveLayout()) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const parent of layout.appsDirs) for (const entry of readdirSync(parent, { withFileTypes: true })) {
+		if (!entry.isDirectory()) continue;
+		if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+		if (!seen.has(entry.name)) seen.set(entry.name, {
+			name: entry.name,
+			dir: join(parent, entry.name)
+		});
+	}
+	return [...seen.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+/** The directory of the app called `name`, or undefined when no repo has it. */
+function findApp(name, layout = resolveLayout()) {
+	return listApps(layout).find((app) => app.name === name)?.dir;
+}
+/**
+* Resolves a workspace-relative path such as `workers.json`'s
+* `apps/schedule-builder` to a directory: the repo you are in first, then
+* DevDogsUGA's. When neither has it the first candidate is returned, so
+* callers get an ordinary ENOENT naming the path rather than a second error.
+*/
+function resolveAppPath(relative, layout = resolveLayout()) {
+	const first = join(layout.root, relative);
+	if (existsSync(first)) return first;
+	if (layout.kind === "backstage" && layout.hasDevdogsuga) {
+		const second = join(layout.devdogsugaRoot, relative);
+		if (existsSync(second)) return second;
+	}
+	return first;
+}
+/**
+* The pnpm workspace root holding the app called `name`: where
+* `pnpm --filter <name>` has to run. DevDogsUGA's root for its apps seen from a
+* Backstage checkout, `layout.root` otherwise.
+*/
+function appWorkspaceRoot(name, layout = resolveLayout()) {
+	const dir = findApp(name, layout);
+	return dir === void 0 ? layout.root : dirname(dirname(dir));
+}
+//#endregion
 //#region ../cli-core/src/repo/resolve.ts
 /**
 * Resolves an `@devdogsuga/*` package FROM the target repo, not from
@@ -199,6 +305,25 @@ function loadPeer(specifier) {
 function repoPeerUrl(specifier) {
 	return resolvedUrls.get(specifier);
 }
+/**
+* Like `repoPeerUrl`, but for any specifier a package of the repo you are in
+* can resolve, subpaths included (`@devdogsuga/env/nextjs`), without having
+* loaded it. Undefined outside a real repo or when nothing depends on it.
+*/
+function resolveRepoPeerUrl(specifier) {
+	const known = resolvedUrls.get(specifier);
+	if (known) return known;
+	if (process.env.DEVTOOLS_TEST_REPO_ROOT) return void 0;
+	try {
+		const repoRoot = findRepoRoot();
+		const base = findDependent(repoRoot, specifier);
+		if (!base) return void 0;
+		const { resolvedPath } = resolveFromRepo(repoRoot, base, specifier);
+		return pathToFileURL(resolvedPath).href;
+	} catch {
+		return;
+	}
+}
 let resolvedEnvModule;
 function loadEnv() {
 	return loadPeer("@devdogsuga/env").then((mod) => {
@@ -226,4 +351,4 @@ function loadEnvSession() {
 	return loadPeer("@devdogsuga/env/session");
 }
 //#endregion
-export { repoPeerUrl as a, loadEnvSession as i, loadEnv as n, loadEnvLoad as r, getEnvSync as t };
+export { repoPeerUrl as a, devdogsugaRootOrNull as c, listApps as d, resolveAppPath as f, loadEnvSession as i, findApp as l, loadEnv as n, resolveRepoPeerUrl as o, resolveLayout as p, loadEnvLoad as r, appWorkspaceRoot as s, getEnvSync as t, layoutAt as u };

package/dist/{root-C2OmZDwD.js → root-CjPWNkBu.js}

@@ -38,13 +38,17 @@ function ownVersion() {
 * 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"`. The name check is not
-* redundant — a bare `pnpm-workspace.yaml` also matches a Backstage
-* checkout (a separate pnpm workspace), which devtools should refuse
-* rather than silently "find".
+* `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` name every real DevDogsUGA checkout carries at its root. */
-const REPO_MARKER_NAME = "devdogs-monorepo";
+/**
+* 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");
@@ -54,7 +58,8 @@ var RepoNotFoundError = class extends Error {
 function looksLikeRepoRoot(dir) {
 	if (!existsSync(join(dir, "pnpm-workspace.yaml"))) return false;
 	try {
-		return JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).name === REPO_MARKER_NAME;
+		const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+		return REPO_MARKER_NAMES.includes(pkg.name);
 	} catch {
 		return false;
 	}

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

@@ -1,6 +1,5 @@
-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, v as isDryRun } from "./supabase-project-Bw8sBFcE.js";
-import { r as findRepoRoot } from "./root-C2OmZDwD.js";
-import { i as loadEnvSession, r as loadEnvLoad } from "./peers-RBplwovA.js";
+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 { join } from "node:path";
 //#region src/db/session-refresh.ts
@@ -52,7 +51,7 @@ async function refreshSessionEnv(opts = {}) {
 function foreignStackHint() {
 	const names = listContainerNames(STACK_API_PORT);
 	if (names === null) return void 0;
-	const foreign = foreignStackProjectId(names, readProjectId(findRepoRoot()));
+	const foreign = foreignStackProjectId(names, readProjectId(resolveLayout().devdogsugaRoot));
 	return foreign === null ? void 0 : foreignStackMessage(foreign);
 }
 /**
@@ -101,7 +100,8 @@ async function startLocalStack() {
 			wroteEnvFile: false
 		};
 	}
-	await writeFile(join(findRepoRoot(), ".env.generated"), env);
+	const layout = resolveLayout();
+	for (const dir of [layout.root, ...layout.envMirrors]) await writeFile(join(dir, ".env.generated"), env);
 	return {
 		code: await seedBuckets({ kind: "local" }),
 		wroteEnvFile: true

package/dist/stack-o1Kml3V0.js

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

package/dist/{supabase-project-Bw8sBFcE.js → supabase-project-C93xRFkN.js}

@@ -1,5 +1,6 @@
-import { a as cliName, r as noteRan } from "./failure-log-B5GG_8T1.js";
-import { r as findRepoRoot } from "./root-C2OmZDwD.js";
+import { a as cliName, r as noteRan } from "./failure-log-DOt6E3hS.js";
+import { r as findRepoRoot } from "./root-CjPWNkBu.js";
+import { p as resolveLayout } from "./peers-DvUH5VxX.js";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { execFile, execFileSync, spawn } from "node:child_process";
@@ -190,20 +191,27 @@ function reportRan(command, args, result) {
 //#endregion
 //#region ../cli-core/src/db/run.ts
 /**
-* Shared helpers for running supabase CLI and pnpm commands from the repo root.
+* Shared helpers for running supabase CLI and pnpm commands.
 *
 * The supabase CLI is a workspace devDependency (not a global install), so
-* every invocation goes through `pnpm exec supabase`. The cwd is always
-* findRepoRoot(), where `supabase/config.toml` lives.
+* every invocation goes through `pnpm exec supabase`. Plain pnpm commands run
+* in `findRepoRoot()`; the supabase ones run in DevDogsUGA's root
+* (`supabaseRoot()`), where `supabase/config.toml` lives and where the CLI is
+* installed. From a Backstage checkout that is `<root>/devdogsuga`, so it needs
+* its own `pnpm install` there before any of these work.
 */
 const runFile = promisify(execFile);
+/** Where `supabase/` lives, and so the cwd of every supabase CLI call. */
+function supabaseRoot() {
+	return resolveLayout().devdogsugaRoot;
+}
 /** Spawn a pnpm command with inherited stdio; resolves to the exit code. Pass
 * `env` to run the child against a loaded tier rather than process.env. The
 * child runs in its own process group, so stopping this process stops
 * whatever it started (see `process-group.ts`). */
-async function run(args, env) {
+async function run(args, env, cwd = findRepoRoot()) {
 	const result = await runInGroup("pnpm", args, {
-		cwd: findRepoRoot(),
+		cwd,
 		...env ? { env } : {}
 	});
 	if (reporting) reportRan("pnpm", args, result);
@@ -221,7 +229,7 @@ function reportRuns(enabled) {
 }
 /** Spawn a pnpm command while echoing and retaining stderr for diagnostics.
 * Pass `env` to run the child against a loaded tier rather than process.env. */
-function runWithStderr(args, env) {
+function runWithStderr(args, env, cwd = findRepoRoot()) {
 	return new Promise((resolve) => {
 		const child = spawn("pnpm", args, {
 			stdio: [
@@ -229,7 +237,7 @@ function runWithStderr(args, env) {
 				"inherit",
 				"pipe"
 			],
-			cwd: findRepoRoot(),
+			cwd,
 			...env ? { env } : {}
 		});
 		let stderr = "";
@@ -254,9 +262,9 @@ function runWithStderr(args, env) {
 	});
 }
 /** Spawn a pnpm command, capture stdout, throw on non-zero exit. */
-async function capture(args) {
+async function capture(args, cwd = findRepoRoot()) {
 	const { stdout } = await runFile("pnpm", args, {
-		cwd: findRepoRoot(),
+		cwd,
 		encoding: "utf8"
 	});
 	return stdout;
@@ -266,13 +274,13 @@ const supabase = (...args) => run([
 	"exec",
 	"supabase",
 	...args
-]);
+], void 0, supabaseRoot());
 /** `pnpm exec supabase …` with captured stdout. */
 const supabaseCapture = (...args) => capture([
 	"exec",
 	"supabase",
 	...args
-]);
+], supabaseRoot());
 /**
 * `supabase db push` over `dbUrl`, inherited stdio, resolving to the exit code.
 *
@@ -425,4 +433,4 @@ function foreignStackMessage(foreignProjectId) {
 	return `The stack on port ${STACK_API_PORT} belongs to project "${foreignProjectId}", not this checkout's. Stop it with \`supabase stop --project-id ${foreignProjectId}\` then \`pnpm devtools supabase start\`.`;
 }
 //#endregion
-export { dryRunKind as _, listContainerNames as a, setDryRun as b, reportRuns as c, seedBuckets as d, supabase as f, runInGroup as g, reportRan as h, foreignStackProjectId as i, run as l, formatCommand as m, containerPrefix as n, readProjectId as o, supabaseCapture as p, foreignStackMessage as r, dbPush as s, STACK_API_PORT as t, runWithStderr as u, isDryRun as v, wouldRunLine as x, resolveDryRun as y };
+export { wouldRunLine as S, runInGroup as _, listContainerNames as a, resolveDryRun as b, reportRuns as c, seedBuckets as d, supabase as f, reportRan as g, formatCommand as h, foreignStackProjectId as i, run as l, supabaseRoot as m, containerPrefix as n, readProjectId as o, supabaseCapture as p, foreignStackMessage as r, dbPush as s, STACK_API_PORT as t, runWithStderr as u, dryRunKind as v, setDryRun as x, isDryRun as y };