@devdogsuga/devtools 0.1.51-next.545 → 0.1.51-next.548

package/dist/{cli-DNZ-6WEI.js → cli-DV6tvG1E.js}

@@ -1,10 +1,10 @@
 import { n as execSync, r as spawnProcess } from "./spawn-BvLQzc_K.js";
-import { n as discoverRepoRoot, r as findRepoRoot } from "./root-PA8K5G2d.js";
-import { A as findApp, M as listApps, N as resolveAppPath, O as appWorkspaceRoot, P as resolveLayout, _ as dryRunKind, c as supabaseRoot, d as loadEnvLoad, f as loadEnvSession, g as runInGroup, h as reportRan, i as runWithStderr, j as layoutAt, k as devdogsugaRootOrNull, l as getEnvSync, n as reportRuns, o as supabase, p as repoPeerUrl, r as run$1, t as dbPush, u as loadEnv, v as isDryRun, x as wouldRunLine } from "./run-CRBte7p0.js";
-import { A as renderHelp, C as loadProductConfig, D as catalog, M as probeEnvironment, O as helpPath, T as isProductMode, _ as explain, a as recordEnteredTier, b as ProductConfigError, c as nonEmpty, d as sessionLabel, g as errorMessage, h as bail, i as beginInvocation, j as describeEnvironment, k as renderCommandList, l as resolveDbConnection, n as bareGroupStartPath, o as recordResolved, r as runMenu, s as reproducibleCommand, t as bareGroupStartFlags, u as sessionIsLocal, v as explainError, w as activeCatalog, x as currentProduct, y as unwrap } from "./menu-oQE5IqAI.js";
+import { n as discoverRepoRoot, r as findRepoRoot } from "./root-RaJ8ECCO.js";
+import { A as findApp, M as listApps, N as resolveAppPath, O as appWorkspaceRoot, P as resolveLayout, _ as dryRunKind, c as supabaseRoot, d as loadEnvLoad, f as loadEnvSession, g as runInGroup, h as reportRan, i as runWithStderr, j as layoutAt, k as devdogsugaRootOrNull, l as getEnvSync, n as reportRuns, o as supabase, p as repoPeerUrl, r as run$1, t as dbPush, u as loadEnv, v as isDryRun, x as wouldRunLine } from "./run-D5iI9zve.js";
+import { A as renderHelp, C as loadProductConfig, D as catalog, M as probeEnvironment, O as helpPath, T as isProductMode, _ as explain, a as recordEnteredTier, b as ProductConfigError, c as nonEmpty, d as sessionLabel, g as errorMessage, h as bail, i as beginInvocation, j as describeEnvironment, k as renderCommandList, l as resolveDbConnection, n as bareGroupStartPath, o as recordResolved, r as runMenu, s as reproducibleCommand, t as bareGroupStartFlags, u as sessionIsLocal, v as explainError, w as activeCatalog, x as currentProduct, y as unwrap } from "./menu-CZK0L1Vf.js";
 import { a as isVersionRequest, c as cliName, m as positionals, o as ownPackageDir, p as flagValue, s as ownVersion } from "./failure-log-MSdCgvLc.js";
-import { f as hasYes, n as captureDevtoolsError, o as initDevtoolsTelemetry, p as isNonInteractive } from "./telemetry-BDTAGquh.js";
-import { t as runStackCommand } from "./stack-BRevXgI3.js";
+import { f as hasYes, n as captureDevtoolsError, o as initDevtoolsTelemetry, p as isNonInteractive } from "./telemetry-BDOwjuoC.js";
+import { t as runStackCommand } from "./stack-CzNe6rxl.js";
 import { register } from "node:module";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
@@ -7058,7 +7058,7 @@ function commandLine(command, args) {
 function cliLine(cli, args) {
 	return commandLine(cli.command, [...cli.prefix, ...args]);
 }
-function versionOf(output) {
+function versionOf$1(output) {
 	return /\b(\d+\.\d+\.\d+)\b/.exec(output)?.[1] ?? null;
 }
 async function resolveSupabaseCli(root, pin, run, fileExists = existsSync) {
@@ -7076,7 +7076,7 @@ async function resolveSupabaseCli(root, pin, run, fileExists = existsSync) {
 	});
 	for (const candidate of candidates) try {
 		const result = await run(candidate.command, ["--version"], { cwd: root });
-		if (result.code === 0 && versionOf(result.stdout) === pin) return candidate;
+		if (result.code === 0 && versionOf$1(result.stdout) === pin) return candidate;
 	} catch {}
 	try {
 		if ((await run("pnpm", ["--version"], { cwd: root })).code === 0) return {
@@ -7229,19 +7229,36 @@ async function resolveTarget(product, cli, run, preference) {
 * project, and the SQL runs in one transaction.
 */
 var DevDataError = class extends Error {
+	/** A failure the contributor or the product's SQL caused, not a devtools bug: never sent to Sentry. */
+	expected = true;
 	constructor(message) {
 		super(message);
 		this.name = "DevDataError";
 	}
 };
 /**
-* Whether `err` is Postgres saying a table or schema does not exist
-* (SQLSTATE 42P01 undefined_table, 3F000 invalid_schema_name): the database
-* has not had the product's schema applied yet.
+* Whether `err` is the product's own SQL being wrong: a Postgres error whose
+* SQLSTATE class is a cardinality violation (21), data exception (22),
+* integrity constraint violation (23) or syntax error or access rule
+* violation (42). Everything else is not the file's fault and reports as a
+* normal failure: a refused or dropped connection (class 08 and
+* `ECONNREFUSED`), an operator shutdown (57, `admin_shutdown`), a server out
+* of resources (53), a transaction that was rolled back (40), and so on.
 */
-function isMissingSchemaError(err) {
+function isSqlFileError(err) {
 	const code = err?.code;
-	return code === "42P01" || code === "3F000";
+	return typeof code === "string" && /^(21|22|23|42)[0-9A-Z]{3}$/.test(code);
+}
+/**
+* The line of `text` a Postgres error points at, from the error's 1-based
+* character `position`, or null when it carries none.
+*/
+function errorLine(err, text) {
+	const raw = err?.position;
+	const position = typeof raw === "string" ? Number(raw) : raw;
+	if (typeof position !== "number" || !Number.isInteger(position)) return null;
+	if (position < 1 || position > text.length + 1) return null;
+	return text.slice(0, position - 1).split("\n").length;
 }
 function postgresSession(dbUrl) {
 	const sql = postgres(dbUrl, {
@@ -7273,6 +7290,24 @@ function postgresSession(dbUrl) {
 				lastSignInAt: row.last_sign_in_at?.toISOString() ?? null
 			} : null;
 		},
+		async appliedMigrations() {
+			const [table] = await sql`
+        select to_regclass('supabase_migrations.schema_migrations')::text as present`;
+			if (!table?.present) return null;
+			return (await sql`
+        select version from supabase_migrations.schema_migrations`).map((r) => r.version);
+		},
+		async missingSchemas(schemas) {
+			const rows = await sql`
+        select nspname from pg_namespace where nspname = any(${[...schemas]})`;
+			const present = new Set(rows.map((r) => r.nspname));
+			return schemas.filter((name) => !present.has(name));
+		},
+		async exec(text) {
+			await sql.begin(async (tx) => {
+				await tx.unsafe(text);
+			});
+		},
 		async runAs(memberId, text) {
 			await sql.begin(async (tx) => {
 				await tx`select set_config('devtools.member_id', ${memberId}, true)`;
@@ -7296,10 +7331,9 @@ async function runDevData(product, target, open, options) {
 	const text = readFileSync(file, "utf8");
 	const session = open(target.dbUrl);
 	try {
+		const missing = await session.missingSchemas(product.config.supabase.schemas);
+		if (missing.length > 0) throw new DevDataError(`This database does not have ${product.config.name}'s ${missing.length === 1 ? "schema" : "schemas"} yet (missing: ${missing.join(", ")}). Run \`devtools setup\` first, or \`devtools db sync\` if you have already set up.`);
 		return await seed(session, devData.file, text, options, log);
-	} catch (err) {
-		if (isMissingSchemaError(err)) throw new DevDataError(`This database does not have ${product.config.name}'s tables yet (${err.message}). Run \`devtools setup\` first, or \`devtools db sync\` if you have already set up.`);
-		throw err;
 	} finally {
 		await session.close();
 	}
@@ -7312,7 +7346,13 @@ async function seed(session, file, text, options, log) {
 		log(`Would run ${file} (${text.split("\n").length} lines) in one transaction.`);
 		return null;
 	}
-	await session.runAs(member.id, text);
+	try {
+		await session.runAs(member.id, text);
+	} catch (err) {
+		if (!isSqlFileError(err)) throw err;
+		const line = errorLine(err, text);
+		throw new DevDataError(`${file}${line === null ? "" : `:${line}`}: ${err.message}. This is a problem in the product's dev-data SQL, not in devtools; nothing was seeded (the file runs in one transaction).`);
+	}
 	return {
 		member,
 		file
@@ -7546,6 +7586,15 @@ function typesAssetName(product, hash) {
 * Without that, the diff would start from an empty database and write the whole
 * schema as one migration, which `db push` rejects as already applied.
 *
+* The record only says what *should* be in the database. Before the diff,
+* sync therefore compares the database itself with the record (`supabase db
+* diff --from <database> --to migrations`, restricted to the product's
+* schemas) and re-applies whatever is missing: a dropped table, a dropped
+* schema, a database reset behind the record's back. The migration ledger is
+* never trusted to decide anything; it is rewritten to list the record when it
+* is missing or short. "The database already matches" is therefore a
+* statement about the live database.
+*
 * It never resets the database. A reset wipes `auth.custom_oauth_providers`,
 * which is where "Sign in with DevDogs" is registered (Q83); `--rebuild` is
 * the explicit escape hatch for a database that has drifted from its record,
@@ -7597,6 +7646,7 @@ async function dbSync(product, cli, target, run, options) {
 			"--db-url",
 			"<DB_URL>"
 		])} (this machine has no record of what the project has had applied)`);
+		if (options.open) log(`Would run: ${cliLine(cli, liveDiffArgs(product, target).slice(cli.prefix.length))} (and restore anything the database lost)`);
 		log(`Would run: ${cliLine(cli, generateArgs.slice(cli.prefix.length))}`);
 		log(target.kind === "local" ? `Would run: ${cliLine(cli, [
 			"migration",
@@ -7620,6 +7670,7 @@ async function dbSync(product, cli, target, run, options) {
 		const restored = migrationFiles(migrationsDir).length;
 		if (fetched.code === 0 && restored > 0) log(`Restored ${restored} applied migration${restored === 1 ? "" : "s"} from the project's history.`);
 	}
+	const restored = await restoreDatabase(product, cli, target, run, options, log);
 	const before = new Set(migrationFiles(migrationsDir));
 	let generated = await run(cli.command, generateArgs, { cwd: product.root });
 	if (generated.code !== 0 && isContainerFailure(generated)) {
@@ -7629,11 +7680,11 @@ async function dbSync(product, cli, target, run, options) {
 	if (generated.code !== 0) throw new SyncError(isContainerFailure(generated) ? "Could not diff the schema: Docker is needed for the shadow database. Start Docker and try again." : "Could not diff the schema against what this database has had applied.", generated.stderr || generated.stdout);
 	const created = migrationFiles(migrationsDir).filter((f) => !before.has(f));
 	if (created.length === 0) {
-		log("The database already matches supabase/schemas.");
+		if (!restored.applied) log("The database already matches supabase/schemas.");
 		return {
 			migration: null,
-			applied: false,
-			destructive: []
+			applied: restored.applied,
+			destructive: restored.destructive
 		};
 	}
 	const migration = created[created.length - 1];
@@ -7667,8 +7718,137 @@ async function dbSync(product, cli, target, run, options) {
 	return {
 		migration,
 		applied: true,
-		destructive
+		destructive: [...restored.destructive, ...destructive]
+	};
+}
+/** `20261011120000` from `20261011120000_devtools_sync.sql`. */
+function versionOf(file) {
+	return file.split("_")[0] ?? file;
+}
+function liveDiffArgs(product, target) {
+	return [
+		"db",
+		"diff",
+		"--from",
+		target.kind === "local" ? "local" : target.dbUrl,
+		"--to",
+		"migrations",
+		"--use-pg-delta",
+		"--schema",
+		product.config.supabase.schemas.join(","),
+		"--output-format",
+		"json"
+	];
+}
+/**
+* The SQL that turns the database into what the record describes, from the
+* CLI's pg-delta diff (database to migrations baseline). Empty when they
+* agree. Only the product's own schemas are compared, so the platform's
+* (auth, storage, ...) never show up as drift.
+*/
+async function liveDiff(product, cli, target, run, log) {
+	const args = [...cli.prefix, ...liveDiffArgs(product, target)];
+	let result = await run(cli.command, args, { cwd: product.root });
+	if (result.code !== 0 && isContainerFailure(result)) {
+		log("The shadow database did not start; trying once more.");
+		result = await run(cli.command, args, { cwd: product.root });
+	}
+	if (result.code !== 0) throw new SyncError(isContainerFailure(result) ? "Could not compare the database with its record: Docker is needed for the shadow database. Start Docker and try again." : "Could not compare the database with what devtools recorded as applied.", result.stderr || result.stdout);
+	for (const line of result.stdout.split("\n").reverse()) {
+		const text = line.trim();
+		if (!text.startsWith("{")) continue;
+		try {
+			const parsed = JSON.parse(text);
+			if (typeof parsed.diff === "string") return parsed.diff;
+		} catch {}
+	}
+	throw new SyncError("Could not read the result of comparing the database with its record.", result.stdout || result.stderr);
+}
+/**
+* Makes the database agree with the local record, from the database itself.
+* The declarative diff only compares `supabase/schemas` with
+* `supabase/migrations`, so a database that lost objects behind the record's
+* back (a table dropped by hand, a hosted project reset from the dashboard, a
+* checkout switched from the local stack to a hosted project) would read as
+* "already matches". So, with a record to compare against:
+*
+*   1. the database is diffed against the record, per configured schema, and
+*      whatever it lacks is created again (data in what remains is untouched);
+*      statements that drop something need the same approval as any change;
+*   2. the migration ledger is made to list every migration in the record
+*      (marking them applied, which they now are), so the next
+*      `migration up` applies only what is new.
+*
+* A missing or unreadable ledger decides nothing by itself: it is rewritten,
+* never read as "start over". A database that cannot be reached is left to
+* the apply step to report.
+*/
+async function restoreDatabase(product, cli, target, run, options, log) {
+	const nothing = {
+		applied: false,
+		destructive: []
 	};
+	const files = migrationFiles(product.paths.migrationsDir);
+	if (!options.open || files.length === 0) return nothing;
+	let session;
+	let missing;
+	let ledger;
+	try {
+		session = options.open(target.dbUrl);
+		missing = await session.missingSchemas(product.config.supabase.schemas);
+	} catch (err) {
+		log(`Could not check what the database has (${err.message}); trusting the local record.`);
+		await session?.close().catch(() => void 0);
+		return nothing;
+	}
+	try {
+		try {
+			ledger = await session.appliedMigrations();
+		} catch (err) {
+			ledger = void 0;
+			log(`Could not read the migration history (${err.message}); deciding from the schemas alone.`);
+		}
+		const sql = (await liveDiff(product, cli, target, run, log)).trim();
+		let applied = false;
+		let destructive = [];
+		if (sql) {
+			destructive = destructiveStatements(sql);
+			if (destructive.length > 0 && !options.yes) {
+				if (!(options.confirmDestructive ? await options.confirmDestructive(sql, destructive) : false)) throw new SyncError(`The database differs from supabase/schemas and putting it right drops data in your development database (${destructive.length} statement${destructive.length === 1 ? "" : "s"}). Re-run with --yes to allow it.`, destructive.join(";\n"));
+			}
+			log(missing.length > 0 ? `The database is missing ${missing.length === 1 ? "schema" : "schemas"} ${missing.join(", ")}; creating ${missing.length === 1 ? "it" : "them"} again from supabase/schemas.` : "The database has lost part of supabase/schemas (a dropped table, view or function, perhaps); restoring it. Existing data is kept.");
+			try {
+				await session.exec(sql);
+			} catch (err) {
+				throw new SyncError("Could not restore what the database lost. `devtools db sync --rebuild` starts over (it wipes local data).", err.message);
+			}
+			applied = true;
+		}
+		if (ledger !== void 0) {
+			const known = new Set(ledger ?? []);
+			const unlisted = files.map(versionOf).filter((version) => !known.has(version));
+			if (unlisted.length > 0) {
+				if (ledger === null) log("The database has no migration history table; recreating it from the local record.");
+				const repaired = await run(cli.command, [
+					...cli.prefix,
+					"migration",
+					"repair",
+					"--status",
+					"applied",
+					"--db-url",
+					target.dbUrl,
+					...unlisted
+				], { cwd: product.root });
+				if (repaired.code !== 0) throw new SyncError("Could not record the applied migrations in the database's history.", repaired.stderr || repaired.stdout);
+			}
+		}
+		return {
+			applied,
+			destructive
+		};
+	} finally {
+		await session.close().catch(() => void 0);
+	}
 }
 function isContainerFailure(result) {
 	return /docker|container|image/i.test(result.stderr + result.stdout);
@@ -7932,7 +8112,8 @@ async function runSync(product, deps, rest) {
 		yes: hasYes(rest),
 		confirmDestructive: deps.interactive() ? confirmDestructive : void 0,
 		dryRun,
-		log: (line) => log.info(line)
+		log: (line) => log.info(line),
+		open: deps.openSql
 	});
 	if (rest.includes("--rebuild") && !dryRun) try {
 		const row = await reRegisterSavedProvider(product.paths.toolingFile, target);
@@ -7957,7 +8138,7 @@ async function regenerateAfterSync(product, cli, target, result, deps) {
 		log.info(`Would regenerate ${product.config.types.out}.`);
 		return;
 	}
-	if (!result.migration && typesAreCurrent(product)) return;
+	if (!result.applied && typesAreCurrent(product)) return;
 	try {
 		await generateTypes(product, cli, target, deps.run, (line) => log.info(line));
 		log.success(`Regenerated ${product.config.types.out}.`);
@@ -8003,7 +8184,7 @@ function createProductHandlers(deps = defaultDeps) {
 		switch (sub) {
 			case "sync": {
 				const { result, cli, target } = await runSync(product, deps, flags);
-				if (result.migration) log.success("Your database now matches supabase/schemas.");
+				if (result.applied) log.success("Your database now matches supabase/schemas.");
 				await regenerateAfterSync(product, cli, target, result, deps);
 				return DONE;
 			}
@@ -8233,9 +8414,10 @@ async function runSetup(product, deps, rest) {
 	const result = await dbSync(product, cli, target, deps.run, {
 		yes: hasYes(rest),
 		confirmDestructive: deps.interactive() ? confirmDestructive : void 0,
-		log: (line) => log.info(line)
+		log: (line) => log.info(line),
+		open: deps.openSql
 	});
-	log.success(result.migration ? "Applied supabase/schemas to your database." : "Your database already matched supabase/schemas.");
+	log.success(result.applied ? "Applied supabase/schemas to your database." : "Your database already matched supabase/schemas.");
 	if (target.kind === "local") await waitForRest(target, deps, product);
 	if (rest.includes("--download-types")) try {
 		await downloadTypes(product, {

package/dist/launch.js

@@ -1,8 +1,8 @@
-import { n as discoverRepoRoot, r as findRepoRoot, t as RepoNotFoundError } from "./root-PA8K5G2d.js";
-import { b as setDryRun, d as loadEnvLoad, f as loadEnvSession, m as formatCommand, v as isDryRun, y as resolveDryRun } from "./run-CRBte7p0.js";
-import { D as catalog, E as setProductMode, N as setEnvironmentRoot, O as helpPath, S as findProductRoot, c as nonEmpty, f as enterSessionEnvironment, g as errorMessage, h as bail, m as setMenuEnvHook, n as bareGroupStartPath, p as realEnvEntryDeps, y as unwrap } from "./menu-oQE5IqAI.js";
+import { i as markOutsideCheckout, n as discoverRepoRoot, r as findRepoRoot, t as RepoNotFoundError } from "./root-RaJ8ECCO.js";
+import { b as setDryRun, d as loadEnvLoad, f as loadEnvSession, m as formatCommand, v as isDryRun, y as resolveDryRun } from "./run-D5iI9zve.js";
+import { D as catalog, E as setProductMode, N as setEnvironmentRoot, O as helpPath, S as findProductRoot, c as nonEmpty, f as enterSessionEnvironment, g as errorMessage, h as bail, m as setMenuEnvHook, n as bareGroupStartPath, p as realEnvEntryDeps, y as unwrap } from "./menu-CZK0L1Vf.js";
 import { a as isVersionRequest, c as cliName, t as installFailureLog } from "./failure-log-MSdCgvLc.js";
-import { c as lastSentryEventId, f as hasYes, h as stripTierFlag, m as stripNoEnvFlag, n as captureDevtoolsError, o as initDevtoolsTelemetry, p as isNonInteractive } from "./telemetry-BDTAGquh.js";
+import { c as lastSentryEventId, f as hasYes, h as stripTierFlag, m as stripNoEnvFlag, n as captureDevtoolsError, o as initDevtoolsTelemetry, p as isNonInteractive } from "./telemetry-BDOwjuoC.js";
 import { confirm, select } from "@clack/prompts";
 //#region ../cli-core/src/session.ts
 /**
@@ -172,7 +172,7 @@ function outsideRepoMessage(rest) {
 /** The offer's stack start (`env-entry.ts` holds the TTY prompt, this holds
 * the lifecycle command), imported lazily like the rest of the commands. */
 async function startStack() {
-	const { runStackCommand } = await import("./stack-Cl_B_dt7.js");
+	const { runStackCommand } = await import("./stack-VZ-1SmuM.js");
 	return runStackCommand("start");
 }
 /**
@@ -183,11 +183,12 @@ async function startStack() {
 * post-tier-resolution path.
 */
 async function dispatch(argv) {
-	const { main } = await import("./cli-DNZ-6WEI.js");
+	const { main } = await import("./cli-DV6tvG1E.js");
 	try {
 		await main(argv);
 	} catch (err) {
-		process.stderr.write(`devtools: ${err instanceof RepoNotFoundError ? outsideRepoMessage(argv) : errorMessage(err)}\n`);
+		const outside = markOutsideCheckout(err);
+		process.stderr.write(`devtools: ${outside ? outsideRepoMessage(argv) : errorMessage(err)}\n`);
 		await captureDevtoolsError(err);
 		process.exit(1);
 	}

package/dist/{load-yn7JCcS2.js → load-aeN4iX1h.js}

@@ -1,2 +1,2 @@
-import { a as LocalStackOfflineError, c as applyDeployTierAliases, d as loadEnvironment, f as locateRepoRoot, h as selectEnvFiles, i as LOCAL_STACK_PORT, l as applyWranglerLocalDatabaseAlias, m as probeLocalStack, n as GENERATED_FILE, o as MissingEnvFileError, p as parseRawAssignments, r as HYPERDRIVE_LOCAL_CONNECTION_ENV, s as SHELL_KEYS_ENV, t as DEV_DB_ENV, u as isDevDatabase } from "./load-Z2CXCpyx.js";
+import { a as LocalStackOfflineError, c as applyDeployTierAliases, d as loadEnvironment, f as locateRepoRoot, h as selectEnvFiles, i as LOCAL_STACK_PORT, l as applyWranglerLocalDatabaseAlias, m as probeLocalStack, n as GENERATED_FILE, o as MissingEnvFileError, p as parseRawAssignments, r as HYPERDRIVE_LOCAL_CONNECTION_ENV, s as SHELL_KEYS_ENV, t as DEV_DB_ENV, u as isDevDatabase } from "./load-lrgJ5Kz7.js";
 export { DEV_DB_ENV, GENERATED_FILE, HYPERDRIVE_LOCAL_CONNECTION_ENV, LOCAL_STACK_PORT, LocalStackOfflineError, MissingEnvFileError, SHELL_KEYS_ENV, applyDeployTierAliases, applyWranglerLocalDatabaseAlias, isDevDatabase, loadEnvironment, locateRepoRoot, parseRawAssignments, probeLocalStack, selectEnvFiles };

package/dist/{load-Z2CXCpyx.js → load-lrgJ5Kz7.js}

@@ -521,7 +521,7 @@ async function probeLocalStack(port = LOCAL_STACK_PORT, timeoutMs = 250) {
 * worse failure than a rejected promise.
 */
 async function locateRepoRoot() {
-	const { discoverRepoRoot, RepoNotFoundError } = await import("./root-DfH38DFq.js");
+	const { discoverRepoRoot, RepoNotFoundError } = await import("./root-IVsv7i8N.js");
 	const fromCwd = discoverRepoRoot();
 	if (fromCwd !== null) return fromCwd;
 	const { existsSync } = await import("node:fs");

package/dist/{menu-oQE5IqAI.js → menu-CZK0L1Vf.js}

@@ -1,8 +1,8 @@
 import { n as execSync } from "./spawn-BvLQzc_K.js";
-import { n as discoverRepoRoot } from "./root-PA8K5G2d.js";
-import { C as containerPrefix, D as readProjectId, E as listContainerNames, P as resolveLayout, S as STACK_API_PORT, T as foreignStackProjectId, d as loadEnvLoad, k as devdogsugaRootOrNull, s as supabaseCapture, u as loadEnv, w as foreignStackMessage } from "./run-CRBte7p0.js";
+import { n as discoverRepoRoot } from "./root-RaJ8ECCO.js";
+import { C as containerPrefix, D as readProjectId, E as listContainerNames, P as resolveLayout, S as STACK_API_PORT, T as foreignStackProjectId, d as loadEnvLoad, k as devdogsugaRootOrNull, s as supabaseCapture, u as loadEnv, w as foreignStackMessage } from "./run-D5iI9zve.js";
 import { d as YES, f as createCatalog, i as suppressFailureLog, l as JSON_FLAG, m as positionals, u as SCOPES } from "./failure-log-MSdCgvLc.js";
-import { l as reportDevtoolsError, p as isNonInteractive } from "./telemetry-BDTAGquh.js";
+import { l as reportDevtoolsError, p as isNonInteractive } from "./telemetry-BDOwjuoC.js";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { z } from "zod";

package/dist/{root-DfH38DFq.js → root-IVsv7i8N.js}

@@ -1,2 +1,2 @@
-import { n as discoverRepoRoot, t as RepoNotFoundError } from "./root-PA8K5G2d.js";
+import { n as discoverRepoRoot, t as RepoNotFoundError } from "./root-RaJ8ECCO.js";
 export { RepoNotFoundError, discoverRepoRoot };

package/dist/{root-PA8K5G2d.js → root-RaJ8ECCO.js}

@@ -73,5 +73,17 @@ function findRepoRoot() {
 	if (cachedRoot === null) throw new RepoNotFoundError();
 	return cachedRoot;
 }
+/**
+* Whether `err` is the user running a checkout-requiring command with no
+* DevDogsUGA checkout above the working directory, and if so marks it
+* `expected` so telemetry drops it. A `RepoNotFoundError` raised while a
+* checkout does exist (a `findRepoRoot()` call that should not have needed
+* one, as in DEVTOOLS-D) is a bug and stays reportable.
+*/
+function markOutsideCheckout(err, startDir = process.cwd()) {
+	if (!(err instanceof RepoNotFoundError) || discoverRepoRoot(startDir) !== null) return false;
+	Object.assign(err, { expected: true });
+	return true;
+}
 //#endregion
-export { discoverRepoRoot as n, findRepoRoot as r, RepoNotFoundError as t };
+export { markOutsideCheckout as i, discoverRepoRoot as n, findRepoRoot as r, RepoNotFoundError as t };

package/dist/{run-CRBte7p0.js → run-D5iI9zve.js}

@@ -1,5 +1,5 @@
 import { n as execSync, r as spawnProcess, t as exec } from "./spawn-BvLQzc_K.js";
-import { r as findRepoRoot, t as RepoNotFoundError } from "./root-PA8K5G2d.js";
+import { r as findRepoRoot, t as RepoNotFoundError } from "./root-RaJ8ECCO.js";
 import { c as cliName, r as noteRan } from "./failure-log-MSdCgvLc.js";
 import { createRequire } from "node:module";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
@@ -631,11 +631,11 @@ function getEnvSync() {
 }
 /** The env loader (`loadEnvironment` and the tier/file selection). Bundled. */
 function loadEnvLoad() {
-	return import("./load-yn7JCcS2.js");
+	return import("./load-aeN4iX1h.js");
 }
 /** The session policy (tier resolution, `enterEnvironment`). Bundled. */
 function loadEnvSession() {
-	return import("./session-DzgtIg6K.js");
+	return import("./session-DdF8eqv3.js");
 }
 //#endregion
 //#region ../cli-core/src/db/run.ts

package/dist/{session-DzgtIg6K.js → session-DdF8eqv3.js}

@@ -1,2 +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-CuexI1f9.js";
+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-bPPOkolU.js";
 export { SESSION_SELECTORS, askSession, availableTiers, developmentRemoteCandidate, enterEnvironment, parseSessionSelector, rememberDevDatabase, rememberedDevDatabase, resolveSessionTier };

package/dist/{session-CuexI1f9.js → session-bPPOkolU.js}

@@ -1,4 +1,4 @@
-import { d as loadEnvironment, g as DEPLOY_ENVIRONMENTS, m as probeLocalStack, p as parseRawAssignments, t as DEV_DB_ENV, u as isDevDatabase, v as fileFor, y as isDeployEnvironment } from "./load-Z2CXCpyx.js";
+import { d as loadEnvironment, g as DEPLOY_ENVIRONMENTS, m as probeLocalStack, p as parseRawAssignments, t as DEV_DB_ENV, u as isDevDatabase, v as fileFor, y as isDeployEnvironment } from "./load-lrgJ5Kz7.js";
 //#region ../cli-core/src/env-runtime/ask.ts
 /**
 * The interactive half of session resolution, shared by `with-env` and the

package/dist/{stack-BRevXgI3.js → stack-CzNe6rxl.js}

@@ -1,4 +1,4 @@
-import { D as readProjectId, E as listContainerNames, P as resolveLayout, S as STACK_API_PORT, T as foreignStackProjectId, a as seedBuckets, d as loadEnvLoad, f as loadEnvSession, o as supabase, s as supabaseCapture, v as isDryRun, w as foreignStackMessage } from "./run-CRBte7p0.js";
+import { D as readProjectId, E as listContainerNames, P as resolveLayout, S as STACK_API_PORT, T as foreignStackProjectId, a as seedBuckets, d as loadEnvLoad, f as loadEnvSession, o as supabase, s as supabaseCapture, v as isDryRun, w as foreignStackMessage } from "./run-D5iI9zve.js";
 import { join } from "node:path";
 import { writeFile } from "node:fs/promises";
 //#region src/db/session-refresh.ts

package/dist/stack-VZ-1SmuM.js

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

package/dist/{telemetry-BDTAGquh.js → telemetry-BDOwjuoC.js}

@@ -1,4 +1,4 @@
-import { n as discoverRepoRoot, t as RepoNotFoundError } from "./root-PA8K5G2d.js";
+import { n as discoverRepoRoot } from "./root-RaJ8ECCO.js";
 import { c as cliName, n as noteError, s as ownVersion } from "./failure-log-MSdCgvLc.js";
 import { readFileSync } from "node:fs";
 import * as Sentry from "@sentry/node";
@@ -301,7 +301,9 @@ function hasRealCaller(inRepo, isTTY) {
 }
 /**
 * A failure the person caused and can fix without anyone's help: the wrong
-* directory, a bad flag, a database that has not been set up. These are
+* directory, a bad flag, a database that has not been set up. A `RepoNotFoundError` is
+* not on this list by class: only the dispatcher marks the genuine
+* outside-a-checkout case `expected` (`markOutsideCheckout`). These are
 * printed and exit non-zero but are not bugs, so they are never sent to Sentry
 * (the failure log still records them). Matched by name as well as class so
 * that `UsageError` (`ui.ts`, which imports this module) and the product
@@ -309,7 +311,6 @@ function hasRealCaller(inRepo, isTTY) {
 * opts in by setting `expected = true`.
 */
 function isExpectedFailure(err) {
-	if (err instanceof RepoNotFoundError) return true;
 	if (!(err instanceof Error)) return false;
 	return err.name === "UsageError" || err.expected === true;
 }

package/dist/telemetry.js

@@ -1,2 +1,2 @@
-import { a as hasRealCaller, c as lastSentryEventId, d as resolveDevtoolsDsn, i as devtoolsTelemetryEnabled, l as reportDevtoolsError, n as captureDevtoolsError, o as initDevtoolsTelemetry, r as devtoolsEnvironment, s as isExpectedFailure, t as captureDevtoolsDeprecation, u as reportDevtoolsFailure } from "./telemetry-BDTAGquh.js";
+import { a as hasRealCaller, c as lastSentryEventId, d as resolveDevtoolsDsn, i as devtoolsTelemetryEnabled, l as reportDevtoolsError, n as captureDevtoolsError, o as initDevtoolsTelemetry, r as devtoolsEnvironment, s as isExpectedFailure, t as captureDevtoolsDeprecation, u as reportDevtoolsFailure } from "./telemetry-BDOwjuoC.js";
 export { captureDevtoolsDeprecation, captureDevtoolsError, devtoolsEnvironment, devtoolsTelemetryEnabled, hasRealCaller, initDevtoolsTelemetry, isExpectedFailure, lastSentryEventId, reportDevtoolsError, reportDevtoolsFailure, resolveDevtoolsDsn };

package/dist/with-env.js

@@ -1,6 +1,6 @@
 import { r as spawnProcess, t as exec } from "./spawn-BvLQzc_K.js";
-import { _ as UnknownEnvironmentError, a as LocalStackOfflineError, c as applyDeployTierAliases, d as loadEnvironment, l as applyWranglerLocalDatabaseAlias, m as probeLocalStack, n as GENERATED_FILE, o as MissingEnvFileError } from "./load-Z2CXCpyx.js";
-import { n as availableTiers, s as askSession, t as SESSION_SELECTORS } from "./session-CuexI1f9.js";
+import { _ as UnknownEnvironmentError, a as LocalStackOfflineError, c as applyDeployTierAliases, d as loadEnvironment, l as applyWranglerLocalDatabaseAlias, m as probeLocalStack, n as GENERATED_FILE, o as MissingEnvFileError } from "./load-lrgJ5Kz7.js";
+import { n as availableTiers, s as askSession, t as SESSION_SELECTORS } from "./session-bPPOkolU.js";
 import { createRequire } from "node:module";
 import { existsSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devdogsuga/devtools",
-  "version": "0.1.51-next.545",
+  "version": "0.1.51-next.548",
   "private": false,
   "type": "module",
   "description": "Contributor CLI for DevDogs repositories (the platform monorepo, DogDays, DogPack): the real tools with the session's tier filled in, `setup`, `db sync`, `db types`, `dev-data`, a menu over them, the checks CI runs, and the `with-env` launcher. Ships built JS; run via `pnpm devtools` in a product repo, `pnpm dlx @devdogsuga/devtools` (or the `devtools` bin once installed) from inside a clone.",

package/dist/stack-Cl_B_dt7.js

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