@rebasepro/cli 0.25.0-canary.ge06257e → 0.25.1

package/dist/{db-Dkn9XhT-.js → db-9P6MnmdC.js}

@@ -1,8 +1,7 @@
-import { i as recordEvent } from "./telemetry-EMFRVRQi.js";
-import { _ as resolveTsxLoader, f as requireBackendDir, g as resolveTsx, h as resolvePluginCliScript, l as getActiveBackendPlugin, n as dependenciesNotInstalled, o as findEnvFile, p as requireProjectRoot } from "./project-Wp2zoyeN.js";
-import { a as unknownCommand, i as suggestCommand, n as parseCommandArgs, t as UsageError } from "./args-CcBphFdj.js";
+import { i as recordEvent } from "./telemetry-HfU5uAh1.js";
+import { D as redactConnectionPasswords, S as switchOn, T as unknownCommand, _ as resolveTsxLoader, b as parseCommandArgs, f as requireBackendDir, g as resolveTsx, h as resolvePluginCliScript, l as getActiveBackendPlugin, n as dependenciesNotInstalled, o as findEnvFile, p as requireProjectRoot, w as suggestCommand, x as resolveSwitchValues, y as UsageError } from "./project-g4K6kV1t.js";
 import { r as refuseMissingCollectionsPath, t as COLLECTIONS_FLAG_HELP } from "./path-flags-BFgG9V6y.js";
-import { DEV_DATABASE_KIND_ENV, devDatabaseKind } from "./prepare-C1iaiTC4.js";
+import { DEV_DATABASE_KIND_ENV, devDatabaseKind } from "./prepare-1rVNd2PF.js";
 import chalk from "chalk";
 import fs from "fs";
 import os from "os";
@@ -116,9 +115,6 @@ function reportSpawnFailure(error) {
 //#endregion
 //#region src/commands/db.ts
 /**
-* CLI command: rebase db <action>
-*/
-/**
 * The connection string a prepared database actually answers on.
 *
 * One function, because `db url` and `db pull` disagreed about it and the
@@ -244,6 +240,84 @@ function readFlagValue(rawArgs, flag) {
 	}
 	return null;
 }
+/** `rebase db pull`'s flags. */
+var PULL_FLAGS = {
+	"--from": String,
+	"--schema": [String],
+	"--anonymize": Boolean,
+	"--yes": Boolean,
+	"-y": "--yes",
+	"--docker": Boolean,
+	"--database-url": String
+};
+/** `rebase db url`'s flags. */
+var URL_FLAGS = {
+	"--database-url": String,
+	"--docker": Boolean
+};
+/** `rebase db reset`'s flags. */
+var RESET_FLAGS = {
+	"--yes": Boolean,
+	"-y": "--yes"
+};
+/** `rebase db stop` takes none. */
+var STOP_FLAGS = {};
+/** `rebase db pull`'s line, parsed strictly. */
+function parsePullFlags(rawArgs) {
+	return parseCommandArgs({
+		spec: PULL_FLAGS,
+		rawArgs: [...rawArgs],
+		commandWords: 2,
+		command: "db pull",
+		maxPositionals: 0
+	}).flags;
+}
+/** `rebase db url`'s line, parsed strictly. */
+function parseUrlFlags(rawArgs) {
+	return parseCommandArgs({
+		spec: URL_FLAGS,
+		rawArgs: [...rawArgs],
+		commandWords: 2,
+		command: "db url",
+		maxPositionals: 0
+	}).flags;
+}
+/** `rebase db reset`'s line, parsed strictly. */
+function parseResetFlags(rawArgs) {
+	return parseCommandArgs({
+		spec: RESET_FLAGS,
+		rawArgs: [...rawArgs],
+		commandWords: 2,
+		command: "db reset",
+		maxPositionals: 0
+	}).flags;
+}
+/** `rebase db stop`'s line, parsed strictly. */
+function parseStopFlags(rawArgs) {
+	return parseCommandArgs({
+		spec: STOP_FLAGS,
+		rawArgs: [...rawArgs],
+		commandWords: 2,
+		command: "db stop",
+		maxPositionals: 0
+	}).flags;
+}
+/**
+* The `db` subcommands this CLI answers itself, each with its strict parse.
+*
+* The driver's `db` commands refuse a flag they do not take; these four never
+* reach the driver, and read their flags out of argv by hand, so they accepted
+* anything. On `pull` that cost personal data: `--anonymise` (or `--anonymiz`,
+* or `--anon`) was dropped and the copy arrived as it was. An undeclared flag,
+* or a word where none is taken, is now a `UsageError` naming the flag it was
+* probably meant to be, raised before anything has run.
+*/
+var OWN_SUBCOMMAND_PARSERS = {
+	pull: parsePullFlags,
+	url: parseUrlFlags,
+	reset: parseResetFlags,
+	stop: parseStopFlags
+};
 /**
 * Run a database subcommand through the active driver's CLI, throwing on
 * failure instead of exiting.
@@ -313,7 +387,7 @@ var ATLAS_DEV_URL_ENV = "REBASE_ATLAS_DEV_URL";
 */
 var INVOCATION_CWD_ENV = "REBASE_INVOCATION_CWD";
 /** Loaded only when a command needs one: PGlite is 25 MB of WASM. */
-var startAtlasDevDatabase = async () => (await import("./atlas-dev-database-DeK3Sa4h.js")).startAtlasDevDatabase();
+var startAtlasDevDatabase = async () => (await import("./atlas-dev-database-BusbHP6n.js")).startAtlasDevDatabase();
 /**
 * The empty database an Atlas-backed subcommand plans against, on the managed
 * development database.
@@ -553,17 +627,17 @@ async function runDriverDbCommand(rawArgs, options = {}) {
 	const env = { ...process.env };
 	if (envFile) env.DOTENV_CONFIG_PATH = envFile;
 	env[DEV_DATABASE_KIND_ENV] = devDatabaseKind(projectRoot) ?? "";
-	const { resolveProjectDatabase } = await import("./prepare-C1iaiTC4.js");
+	const { resolveProjectDatabase } = await import("./prepare-1rVNd2PF.js");
 	const resolvedKind = resolveProjectDatabase(projectRoot, {
 		flagUrl: readFlagValue(rawArgs, "--database-url"),
-		flagDocker: rawArgs.includes("--docker")
+		flagDocker: switchOn(rawArgs, "--docker")
 	}).kind;
 	refuseBranchOnManagedDatabase(rawArgs, resolvedKind);
 	refuseRestoreOnManagedDatabase(rawArgs, resolvedKind);
-	const { prepareDatabaseEnv, managedNotices } = await import("./prepare-C1iaiTC4.js");
+	const { prepareDatabaseEnv, managedNotices } = await import("./prepare-1rVNd2PF.js");
 	const prepared = await prepareDatabaseEnv(projectRoot, {
 		flagUrl: readFlagValue(rawArgs, "--database-url"),
-		flagDocker: rawArgs.includes("--docker"),
+		flagDocker: switchOn(rawArgs, "--docker"),
 		onProgress: (message) => {
 			if (!options.quiet) console.log(chalk.gray(`  ${message}`));
 		}
@@ -597,13 +671,13 @@ async function dbCommand(subcommand, rawArgs) {
 		const action = argsFromCommand(rawArgs, "backups")[1];
 		if (action !== void 0 && action !== "list") unknownCommand(action, ["list"], "db backups");
 	}
+	OWN_SUBCOMMAND_PARSERS[subcommand]?.(rawArgs);
 	const projectRoot = requireProjectRoot();
 	recordEvent("cli.db", { subcommand: subcommand ?? "none" }, { projectRoot });
 	if (subcommand === "stop" || subcommand === "reset") {
 		await manageLocalDatabase(subcommand, projectRoot, rawArgs);
 		return;
 	}
-	await ensureDockerDatabase(projectRoot, rawArgs);
 	if (subcommand === "pull") {
 		await pullIntoLocal(projectRoot, rawArgs);
 		return;
@@ -612,6 +686,12 @@ async function dbCommand(subcommand, rawArgs) {
 		await printDatabaseUrl(projectRoot, rawArgs);
 		return;
 	}
+	if (subcommand === "branch" && commandWords(rawArgs, "db")[2] === "switch") assertSwitchFlags(rawArgs);
+	else {
+		await refuseDriverLineBeforeStarting(projectRoot, rawArgs);
+		refuseMissingCollectionsPath(rawArgs, process.cwd(), requireBackendDir(projectRoot));
+	}
+	await ensureDockerDatabase(projectRoot, rawArgs);
 	if (subcommand === "branch" && commandWords(rawArgs, "db")[2] === "switch") {
 		await switchBranch(projectRoot, rawArgs);
 		return;
@@ -620,9 +700,9 @@ async function dbCommand(subcommand, rawArgs) {
 	if (subcommand === "branch") {
 		const action = commandWords(rawArgs, "db")[2];
 		if (action === "delete") await refuseDeletingActiveBranch(projectRoot, rawArgs);
+		if (action === "prune" || action === "list") await tellDriverTheActiveBranch(projectRoot);
 		if (action && REGISTRY_ACTIONS.has(action)) driverArgs = await onParentDatabase(projectRoot, rawArgs, action);
 	}
-	refuseMissingCollectionsPath(driverArgs, process.cwd(), requireBackendDir(projectRoot));
 	try {
 		await runDriverDbCommand(driverArgs);
 	} catch (error) {
@@ -635,6 +715,33 @@ async function dbCommand(subcommand, rawArgs) {
 	}
 }
 /**
+* Refuse a driver `db` line the driver would refuse on its flags, before
+* anything is started for it.
+*
+* The driver is spawned with a database already running, because getting one
+* means starting one: the remembered compose container, or the managed PGlite
+* daemon. So `rebase db push --dry-rn` started the database and only then
+* heard that `--dry-rn` does not exist. The check is the driver's own
+* (`assertDbCommandLine`, the same parse each of its commands runs), so this
+* answer and the one the driver gives cannot drift apart.
+*
+* It is this CLI's copy of `@rebasepro/server-postgres`, which ships at the
+* CLI's version, as the project's does. For any other driver the line goes
+* through as it is, and that driver judges it.
+*
+* @throws UsageError with the driver's sentence: nothing ran.
+*/
+async function refuseDriverLineBeforeStarting(projectRoot, rawArgs) {
+	if (getActiveBackendPlugin(requireBackendDir(projectRoot)) !== "@rebasepro/server-postgres") return;
+	const { assertDbCommandLine } = await import("@rebasepro/server-postgres");
+	try {
+		assertDbCommandLine(argsFromCommand(rawArgs, "db"));
+	} catch (error) {
+		if (error instanceof Error) throw new UsageError(error.message);
+		throw error;
+	}
+}
+/**
 * `rebase db url` — the connection string this project is using, on stdout.
 *
 * The managed database is the one case where nothing on disk names it: `.env`
@@ -654,21 +761,13 @@ async function dbCommand(subcommand, rawArgs) {
 * string for a database nobody is serving is not an answer.
 */
 async function printDatabaseUrl(projectRoot, rawArgs) {
-	parseCommandArgs({
-		spec: {
-			"--database-url": String,
-			"--docker": Boolean
-		},
-		rawArgs: [...rawArgs],
-		commandWords: 2,
-		command: "db url",
-		maxPositionals: 0
-	});
-	const { prepareDatabaseEnv } = await import("./prepare-C1iaiTC4.js");
-	const { readEnvFile } = await import("./project-Wp2zoyeN.js").then((n) => n.u);
+	const flags = parseUrlFlags(rawArgs);
+	await ensureDockerDatabase(projectRoot, rawArgs);
+	const { prepareDatabaseEnv } = await import("./prepare-1rVNd2PF.js");
+	const { readEnvFile } = await import("./project-g4K6kV1t.js").then((n) => n.u);
 	const url = databaseUrlOf(await prepareDatabaseEnv(projectRoot, {
-		flagUrl: readFlagValue(rawArgs, "--database-url"),
-		flagDocker: rawArgs.includes("--docker"),
+		flagUrl: flags["--database-url"] ?? null,
+		flagDocker: flags["--docker"] === true,
 		quiet: true,
 		onProgress: (message) => console.error(chalk.gray(`  ${message}`))
 	}), readEnvFile(projectRoot));
@@ -687,8 +786,8 @@ async function printDatabaseUrl(projectRoot, rawArgs) {
 * removing the directory cannot leave a half-dropped schema behind.
 */
 async function manageLocalDatabase(subcommand, projectRoot, rawArgs) {
-	const { resetManagedDatabase, stopManagedDatabase, stoppedManagedDatabaseLines, findRunningDaemon } = await import("./daemon-CknkDjd6.js").then((n) => n.t);
-	const { dataDir } = await import("./state-CCB-FAQ9.js").then((n) => n.p);
+	const { resetManagedDatabase, stopManagedDatabase, stoppedManagedDatabaseLines, findRunningDaemon } = await import("./daemon-DDMRbz4T.js").then((n) => n.t);
+	const { dataDir } = await import("./state-CYdBvnwA.js").then((n) => n.p);
 	const nothingHere = () => {
 		const kind = devDatabaseKind(projectRoot);
 		const verb = subcommand === "stop" ? "was not running" : "does not exist";
@@ -712,7 +811,7 @@ async function manageLocalDatabase(subcommand, projectRoot, rawArgs) {
 		console.log(chalk.gray(nothingHere()));
 		return;
 	}
-	if (!rawArgs.includes("--yes") && !rawArgs.includes("-y")) {
+	if (parseResetFlags(rawArgs)["--yes"] !== true) {
 		if (!process.stdin.isTTY) {
 			console.error(chalk.red("✗ `rebase db reset` deletes the local database and cannot prompt here."));
 			console.error(chalk.yellow("  Re-run with --yes if that is what you intend."));
@@ -741,36 +840,47 @@ async function manageLocalDatabase(subcommand, projectRoot, rawArgs) {
 * and the wrong one here means overwriting production with a laptop.
 */
 async function pullIntoLocal(projectRoot, rawArgs) {
-	const { describeRestoreFailure, describeTarget, dumpSource, findPgTool, restoreCopy } = await import("./pull-COpNJFzY.js");
-	const { prepareDatabaseEnv } = await import("./prepare-C1iaiTC4.js");
-	const { readEnvFile } = await import("./project-Wp2zoyeN.js").then((n) => n.u);
-	const source = readFlagValue(rawArgs, "--from");
+	const { describeRestoreFailure, describeTarget, dumpSource, findPgTool, restoreCopy, sourceProblem } = await import("./pull-DDMpsZ5r.js");
+	const { prepareDatabaseEnv } = await import("./prepare-1rVNd2PF.js");
+	const { readEnvFile } = await import("./project-g4K6kV1t.js").then((n) => n.u);
+	const flags = parsePullFlags(rawArgs);
+	const schemas = flags["--schema"] ?? [];
+	const anonymize = flags["--anonymize"] === true;
+	const targetFlag = flags["--database-url"];
+	if (targetFlag !== void 0) {
+		console.error(chalk.red("✗ `rebase db pull` does not take --database-url."));
+		console.error("");
+		console.error(chalk.gray("  The target is always this project's local development database. There is"));
+		console.error(chalk.gray("  no flag that makes this write somewhere else, deliberately: a command that"));
+		console.error(chalk.gray("  can copy in both directions eventually copies in the wrong one."));
+		console.error("");
+		const shown = redactConnectionPasswords(targetFlag);
+		console.error(chalk.gray(`  To read from another database, that is ${chalk.cyan("--from")}:`));
+		console.error(chalk.gray(`  rebase db pull --from "${shown}"`));
+		if (shown !== targetFlag) console.error(chalk.gray("  with the password in place of ***."));
+		process.exit(1);
+	}
+	const source = flags["--from"];
 	if (!source) {
 		console.error(chalk.red("✗ `rebase db pull` needs a source: --from <connection-string>"));
 		console.error(chalk.gray("  Example: rebase db pull --from \"$PRODUCTION_DATABASE_URL\""));
 		process.exit(1);
 	}
-	const schemas = rawArgs.flatMap((arg, index) => arg === "--schema" && rawArgs[index + 1] ? [rawArgs[index + 1]] : []);
-	const anonymize = rawArgs.includes("--anonymize");
+	const notASource = sourceProblem(source);
+	if (notASource !== null) {
+		console.error(chalk.red(`✗ The --from value is not a connection string: ${notASource}. Nothing was read or changed.`));
+		console.error(chalk.gray("  Pass a URL, postgresql://user:password@host:5432/database, or libpq's"));
+		console.error(chalk.gray("  host=… port=… dbname=… user=… pairs, quoted as one argument."));
+		process.exit(1);
+	}
 	for (const tool of ["pg_dump", "pg_restore"]) if (!await findPgTool(tool)) {
 		console.error(chalk.red(`✗ \`${tool}\` is not on PATH, and this command cannot run without it.`));
 		console.error(chalk.gray("  Install the PostgreSQL client tools, e.g. `brew install libpq`."));
 		process.exit(1);
 	}
-	const targetFlag = readFlagValue(rawArgs, "--database-url");
-	if (targetFlag !== null) {
-		console.error(chalk.red("✗ `rebase db pull` does not take --database-url."));
-		console.error("");
-		console.error(chalk.gray("  The target is always this project's local development database. There is"));
-		console.error(chalk.gray("  no flag that makes this write somewhere else, deliberately: a command that"));
-		console.error(chalk.gray("  can copy in both directions eventually copies in the wrong one."));
-		console.error("");
-		console.error(chalk.gray(`  To read from another database, that is ${chalk.cyan("--from")}:`));
-		console.error(chalk.gray(`  rebase db pull --from ${targetFlag}`));
-		process.exit(1);
-	}
+	await ensureDockerDatabase(projectRoot, rawArgs);
 	const prepared = await prepareDatabaseEnv(projectRoot, {
-		flagDocker: rawArgs.includes("--docker"),
+		flagDocker: flags["--docker"] === true,
 		onProgress: (message) => console.log(chalk.gray(`  ${message}`))
 	});
 	const target = databaseUrlOf(prepared, readEnvFile(projectRoot)) ?? "";
@@ -792,7 +902,7 @@ async function pullIntoLocal(projectRoot, rawArgs) {
 	console.log(`    ${chalk.gray("Data")}  ${anonymize ? "personal-looking columns will be overwritten after the copy" : chalk.yellow("copied as-is, including any personal data")}`);
 	if (schemas.length > 0) console.log(`    ${chalk.gray("Schemas")}  ${schemas.join(", ")}`);
 	console.log("");
-	if (!rawArgs.includes("--yes") && !rawArgs.includes("-y")) {
+	if (flags["--yes"] !== true) {
 		if (!process.stdin.isTTY) {
 			console.error(chalk.red("✗ This replaces the local database and cannot prompt here."));
 			console.error(chalk.yellow("  Re-run with --yes if that is what you intend."));
@@ -863,7 +973,7 @@ async function pullIntoLocal(projectRoot, rawArgs) {
 */
 async function restoreAppRole(target) {
 	const { Client } = await import("pg");
-	const { provisionableSchemas } = await import("./pull-COpNJFzY.js");
+	const { provisionableSchemas } = await import("./pull-DDMpsZ5r.js");
 	const client = new Client({ connectionString: target });
 	client.on("error", () => void 0);
 	try {
@@ -898,7 +1008,7 @@ async function restoreAppRole(target) {
 */
 async function anonymizeTarget(target, source, kind) {
 	const { Client } = await import("pg");
-	const { anonymizeCopy } = await import("./pull-COpNJFzY.js");
+	const { anonymizeCopy } = await import("./pull-DDMpsZ5r.js");
 	const deleteIt = kind === "managed" ? `Delete it now: ${chalk.cyan("rebase db reset --yes")}` : kind === "docker" ? `Delete it now: ${chalk.cyan("docker compose down -v")}` : "Delete it now: drop the restored tables, or the database, before anything else reads it.";
 	const holdsRealData = (reason) => [
 		chalk.red(`✗ The copy could not be anonymized: ${reason}`),
@@ -945,11 +1055,11 @@ async function anonymizeTarget(target, source, kind) {
 * own connection error follows, which is the same contract `dev` keeps.
 */
 async function ensureDockerDatabase(projectRoot, rawArgs) {
-	const { ensureDevDatabase } = await import("./dev-preflight-CorMg7Ub.js").then((n) => n.n);
-	const { resolveProjectDatabase } = await import("./prepare-C1iaiTC4.js");
+	const { ensureDevDatabase } = await import("./dev-preflight-FT9GbJVj.js").then((n) => n.n);
+	const { resolveProjectDatabase } = await import("./prepare-1rVNd2PF.js");
 	const resolved = resolveProjectDatabase(projectRoot, {
 		flagUrl: readFlagValue(rawArgs, "--database-url"),
-		flagDocker: rawArgs.includes("--docker")
+		flagDocker: switchOn(rawArgs, "--docker")
 	});
 	if (resolved.kind !== "docker") return;
 	const composeUrl = resolved.url;
@@ -960,7 +1070,7 @@ async function ensureDockerDatabase(projectRoot, rawArgs) {
 		disabled: false,
 		hasCollections: false,
 		pushSchema: async () => void 0,
-		log: (message) => console.log(message)
+		log: (message) => console.error(message)
 	});
 }
 /**
@@ -979,7 +1089,7 @@ async function ensureDockerDatabase(projectRoot, rawArgs) {
 async function refuseDeletingActiveBranch(projectRoot, rawArgs) {
 	const [, , , name] = commandWords(rawArgs, "db");
 	if (!name) return;
-	const { readActiveBranch } = await import("./branch-pointer-DTQNLFtb.js");
+	const { readActiveBranch } = await import("./branch-pointer-Bn_FjNld.js");
 	const active = readActiveBranch(projectRoot);
 	if (active?.name !== name) return;
 	const off = "rebase db branch switch --off";
@@ -997,6 +1107,29 @@ async function refuseDeletingActiveBranch(projectRoot, rawArgs) {
 	console.error("");
 	process.exit(1);
 }
+/**
+* The variable that tells the driver which database this checkout is switched
+* to. Spelled the same in `packages/server-postgres/src/branch-prune.ts`.
+*/
+var ACTIVE_BRANCH_DATABASE_ENV = "REBASE_ACTIVE_BRANCH_DATABASE";
+/**
+* Tell the driver which branch this checkout is on, for the two actions that
+* answer differently for it.
+*
+* - `prune` keeps it, as `delete` refuses it. `prune --older-than 0d --yes`
+*   dropped it, and the checkout then pointed every command at a database
+*   that no longer existed, with no word of `switch --off`.
+* - `list` marks it, where every branch had the same bullet.
+*
+* The pointer is the CLI's and the driver is a child process, so it is told
+* the database in its environment.
+*/
+async function tellDriverTheActiveBranch(projectRoot) {
+	const { readActiveBranch } = await import("./branch-pointer-Bn_FjNld.js");
+	const active = readActiveBranch(projectRoot);
+	if (active) process.env[ACTIVE_BRANCH_DATABASE_ENV] = active.database;
+	else delete process.env[ACTIVE_BRANCH_DATABASE_ENV];
+}
 /** The `branch` actions that read or write the registry — every one but `switch`. */
 var REGISTRY_ACTIONS = /* @__PURE__ */ new Set([
 	"list",
@@ -1033,16 +1166,16 @@ var REGISTRY_ACTIONS = /* @__PURE__ */ new Set([
 */
 async function onParentDatabase(projectRoot, rawArgs, action) {
 	if (readFlagValue(rawArgs, "--database-url") !== null) return rawArgs;
-	const { readActiveBranch } = await import("./branch-pointer-DTQNLFtb.js");
+	const { readActiveBranch } = await import("./branch-pointer-Bn_FjNld.js");
 	const active = readActiveBranch(projectRoot);
 	if (!active) return rawArgs;
-	const { readEnvFile } = await import("./project-Wp2zoyeN.js").then((n) => n.u);
-	const { resolveDevDatabase } = await import("./resolve-b_p9bmdH.js");
-	const { resolveComposeUrl } = await import("./prepare-C1iaiTC4.js");
-	const { readLastDevDocker } = await import("./last-dev-database-BEBPfAMY.js");
+	const { readEnvFile } = await import("./project-g4K6kV1t.js").then((n) => n.u);
+	const { resolveDevDatabase } = await import("./resolve-BQUAC3Wi.js");
+	const { resolveComposeUrl } = await import("./prepare-1rVNd2PF.js");
+	const { readLastDevDocker } = await import("./last-dev-database-B_75fxZC.js");
 	const envFile = readEnvFile(projectRoot);
 	const parent = resolveDevDatabase({
-		flagDocker: rawArgs.includes("--docker"),
+		flagDocker: switchOn(rawArgs, "--docker"),
 		lastDevDocker: readLastDevDocker(projectRoot),
 		env: process.env,
 		envFile,
@@ -1051,7 +1184,7 @@ async function onParentDatabase(projectRoot, rawArgs, action) {
 	});
 	const url = (parent.kind === "managed" ? null : parent.url)?.trim();
 	if (!url) return rawArgs;
-	console.log(chalk.gray(`  ● On branch ${active.name} — using the main database, where the branch registry lives.`));
+	console.error(chalk.gray(`  ● On branch ${active.name} — using the main database, where the branch registry lives.`));
 	const from = action === "create" && readFlagValue(rawArgs, "--from") === null ? ["--from", active.database] : [];
 	return [
 		...rawArgs,
@@ -1064,13 +1197,15 @@ async function onParentDatabase(projectRoot, rawArgs, action) {
 * The flags `rebase db branch switch` takes, the relayed database flags and
 * `--debug` included.
 */
-var SWITCH_FLAGS = [
-	"--off",
-	"--main",
-	"--database-url",
-	"--docker",
-	"--debug"
-];
+var SWITCH_FLAGS = {
+	"--off": Boolean,
+	"--main": Boolean,
+	"--database-url": String,
+	"--docker": Boolean,
+	"--debug": Boolean
+};
+/** The long flags in {@link SWITCH_FLAGS}, for the did-you-mean. */
+var SWITCH_FLAG_NAMES = Object.keys(SWITCH_FLAGS);
 /**
 * Refuse a flag `switch` does not take, naming the one it was probably meant to be.
 *
@@ -1081,13 +1216,19 @@ var SWITCH_FLAGS = [
 function assertSwitchFlags(rawArgs) {
 	for (const word of rawArgs.slice(2)) {
 		if (!word.startsWith("-")) continue;
-		const flag = word.split("=")[0];
-		if (SWITCH_FLAGS.includes(flag)) continue;
-		const near = suggestCommand(flag.replace(/^-+/, ""), SWITCH_FLAGS.map((known) => known.slice(2)));
-		throw new UsageError(`\`rebase db branch switch\` has no option ${flag}` + (near ? ` — did you mean --${near}?` : " — it takes --off (or --main) and a branch name.") + " Nothing was changed.");
+		const flag = word.split(/[=\s]/)[0];
+		if (SWITCH_FLAG_NAMES.includes(flag)) continue;
+		const near = suggestCommand(flag.replace(/^-+/, ""), SWITCH_FLAG_NAMES.map((known) => known.slice(2)));
+		throw new UsageError(`\`rebase db branch switch\` has no option ${flag}` + (near ? ` — did you mean --${near}?` : " — it takes --off (or --main) and a branch name.") + " Nothing was run. See `rebase db branch --help`.");
 	}
+	resolveSwitchValues(SWITCH_FLAGS, rawArgs.slice(2), "db branch switch");
 }
 /**
+* What `switch` cannot change: a `rebase dev` started before it connected to
+* the database it was given then, and serves it until it is restarted.
+*/
+var RUNNING_DEV_KEEPS_ITS_DATABASE = "A `rebase dev` that is already running keeps the database it started on until you restart it.";
+/**
 * `rebase db branch switch <name>` — point this checkout at a branch.
 *
 * The step branching was missing. `create` copied the database in about a
@@ -1113,17 +1254,17 @@ function assertSwitchFlags(rawArgs) {
 */
 async function switchBranch(projectRoot, rawArgs) {
 	assertSwitchFlags(rawArgs);
-	const { branchDatabaseName, clearActiveBranch, databaseNameOf, readActiveBranch, writeActiveBranch } = await import("./branch-pointer-DTQNLFtb.js");
-	const { readEnvFile } = await import("./project-Wp2zoyeN.js").then((n) => n.u);
-	const { resolveDevDatabase } = await import("./resolve-b_p9bmdH.js");
-	const { resolveComposeUrl } = await import("./prepare-C1iaiTC4.js");
-	const { readLastDevDocker } = await import("./last-dev-database-BEBPfAMY.js");
-	const goingOff = rawArgs.includes("--off") || rawArgs.includes("--main");
+	const { branchDatabaseName, clearActiveBranch, databaseNameOf, readActiveBranch, writeActiveBranch } = await import("./branch-pointer-Bn_FjNld.js");
+	const { readEnvFile } = await import("./project-g4K6kV1t.js").then((n) => n.u);
+	const { resolveDevDatabase } = await import("./resolve-BQUAC3Wi.js");
+	const { resolveComposeUrl } = await import("./prepare-1rVNd2PF.js");
+	const { readLastDevDocker } = await import("./last-dev-database-B_75fxZC.js");
+	const goingOff = switchOn(rawArgs, "--off") || switchOn(rawArgs, "--main");
 	const name = commandWords(rawArgs, "db")[3];
 	const envFile = readEnvFile(projectRoot);
 	const resolved = resolveDevDatabase({
 		flagUrl: readFlagValue(rawArgs, "--database-url"),
-		flagDocker: rawArgs.includes("--docker"),
+		flagDocker: switchOn(rawArgs, "--docker"),
 		lastDevDocker: readLastDevDocker(projectRoot),
 		env: process.env,
 		envFile,
@@ -1150,6 +1291,7 @@ async function switchBranch(projectRoot, rawArgs) {
 		clearActiveBranch(projectRoot);
 		console.log("");
 		console.log(active ? chalk.green(`  ✓ Back on the main database${base ? ` (${databaseNameOf(base)})` : ""}.`) : chalk.gray("  Already on the main database."));
+		if (active) console.log(chalk.gray(`    ${RUNNING_DEV_KEEPS_ITS_DATABASE}`));
 		console.log("");
 		return;
 	}
@@ -1161,6 +1303,9 @@ async function switchBranch(projectRoot, rawArgs) {
 		process.exit(1);
 	}
 	const database = branchDatabaseName(name);
+	const { reopenClosedDatabases, reopenedDatabasesNotice } = await import("@rebasepro/server-postgres");
+	const healed = await reopenClosedDatabases(base, [readActiveBranch(projectRoot)?.database]);
+	for (const line of reopenedDatabasesNotice(healed)) console.error(chalk.yellow(`  ${line}`));
 	const { Client } = await import("pg");
 	const client = new Client({ connectionString: base });
 	try {
@@ -1196,6 +1341,7 @@ async function switchBranch(projectRoot, rawArgs) {
 	console.log(chalk.green(`  ✓ Switched to branch "${name}".`));
 	console.log(chalk.gray(`    Database: ${database}`));
 	console.log(chalk.gray("    Every rebase command in this checkout now uses it — dev, db push, migrate."));
+	console.log(chalk.gray(`    ${RUNNING_DEV_KEEPS_ITS_DATABASE}`));
 	console.log(chalk.gray(`    Back to the main database: ${chalk.cyan("rebase db branch switch --off")}`));
 	console.log("");
 }
@@ -1283,7 +1429,12 @@ var DB_ACTION_HELP = {
 	pull: {
 		usage: "rebase db pull --from <url> [--schema <name>] [--anonymize] [--yes]",
 		summary: "Copy another database into local development. One-directional by design — it can never push.",
-		notes: ["The target is not selectable: --database-url is refused, so this can never write to a remote database."]
+		notes: [
+			"--anonymize overwrites personal-looking columns after the copy. A misspelt flag is refused, never ignored.",
+			"--schema <name> copies only that schema; repeat it for more.",
+			"--docker pulls into Postgres in Docker rather than the database `rebase dev` would pick.",
+			"The target is not selectable: --database-url is refused, so this can never write to a remote database."
+		]
 	},
 	stop: {
 		usage: "rebase db stop",
@@ -1379,6 +1530,6 @@ function dbExamples(kind) {
 `;
 }
 //#endregion
-export { DB_SUBCOMMANDS, absolutizeLocalPathArgs, dbCommand, ensureDockerDatabase, argsFromCommand as n, resolveDriverCli, runDriverDbCommand, runDriverSchemaCommand, spawnDriverCli, reportSpawnFailure as t };
+export { DATABASE_SOURCE_ENV, DB_SUBCOMMANDS, absolutizeLocalPathArgs, databaseUrlOf, dbCommand, ensureDockerDatabase, argsFromCommand as n, resolveDriverCli, runDriverDbCommand, runDriverSchemaCommand, spawnDriverCli, reportSpawnFailure as t };
 
-//# sourceMappingURL=db-Dkn9XhT-.js.map
+//# sourceMappingURL=db-9P6MnmdC.js.map