@rebasepro/cli 0.23.0 → 0.24.1-canary.g19596ef

package/dist/db-B7RuNuaQ.js

@@ -0,0 +1,1312 @@
+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 { n as parseCommandArgs } from "./args-BnmsEXvu.js";
+import { t as unknownCommand } from "./unknown-command-DNwDcX3w.js";
+import { r as refuseMissingCollectionsPath, t as COLLECTIONS_FLAG_HELP } from "./path-flags-BFgG9V6y.js";
+import { DEV_DATABASE_KIND_ENV, devDatabaseKind } from "./prepare-CDN6lSpz.js";
+import chalk from "chalk";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import inquirer from "inquirer";
+import { execa } from "execa";
+//#region src/utils/command-words.ts
+/**
+* The words that name a command, with the flags taken back out.
+*
+* `rawArgs` is the whole of `process.argv`, and reading the command's words at
+* fixed indices off it assumes nothing precedes them. Something routinely does:
+* `--debug` is what `bin/rebase.js` prints after every failure as the thing to
+* re-run with, so it is the single most likely token to appear before a command
+* word, and it shifted every index by one.
+*
+* What that cost is not a bad error message. `rebase db branch switch feature`
+* writes a per-checkout pointer that the CLI owns; the driver, running as a
+* child process, cannot persist it and does not try. The dispatch found
+* `switch` by position, so `rebase --debug db branch switch feature` missed the
+* CLI's branch and handed the line to the driver — which reported success and
+* left the checkout on the main database. Every subsequent `dev`, `push` and
+* `backup` then ran against the wrong database, believing it was the branch,
+* which is the exact failure branching exists to prevent.
+*
+* The words are anchored on the command name rather than taken from position
+* zero, because a flag written in the space form (`--database-url <url>`) leaves
+* its value behind as a bare token and no parser at this level knows which
+* flags take values. Anchoring survives that: the value would have to be the
+* literal command name to fool it.
+*
+* Returns `[]` when the command name is not on the line at all.
+*/
+function commandWords(rawArgs, command) {
+	const words = rawArgs.slice(2).filter((token) => !token.startsWith("-"));
+	const start = words.indexOf(command);
+	return start === -1 ? [] : words.slice(start);
+}
+/**
+* The line to hand a spawned driver, starting at the command word.
+*
+* The same defect one layer down, and it does not degrade gracefully: the
+* driver reads its domain from `args[0]`, so `rebase --debug db push` spawned
+* it with `["--debug", "db", "push"]` and it answered "Unknown domain command:
+* --debug" — for a flag the CLI itself tells you to add after any failure.
+*
+* Tokens written *before* the command word are moved after it rather than
+* dropped. Dropping them would be the same class of bug in the other direction:
+* `rebase --database-url postgres://… db push` would silently lose the flag that
+* says which database to touch. Appending keeps each flag next to its value, and
+* `arg` reads flags wherever they appear.
+*
+* Falls back to `rawArgs.slice(2)` when the command word is not on the line,
+* which is what an internally synthesised argv looks like.
+*/
+function argsFromCommand(rawArgs, command) {
+	const tail = rawArgs.slice(2);
+	const start = tail.findIndex((token) => token === command);
+	if (start <= 0) return [...tail];
+	return [...tail.slice(start), ...tail.slice(0, start)];
+}
+//#endregion
+//#region src/utils/spawn-error.ts
+/**
+* What to say when a spawned child process fails.
+*
+* Two failures arrive through the same `catch` and need opposite treatment:
+*
+*  - **The child ran and exited non-zero.** It had inherited stdio, so it has
+*    already printed its own diagnostics. execa's "Command failed with exit
+*    code 1: …" is a second, worse copy of the same news with the whole argv
+*    appended.
+*  - **The child never started.** ENOENT on the tsx binary, EACCES on a script
+*    that lost its permissions, ENOMEM on a full machine. Nobody printed
+*    anything, because nothing ran. `schema.ts` and `doctor.ts` both swallowed
+*    these — `catch { process.exit(1); }`, the error not even bound — so
+*    `rebase schema generate` against a broken tsx exited 1 in silence, and so
+*    did `rebase doctor`, the command whose entire job is to say what is wrong.
+*
+* The tsx symlink surviving a cleaned pnpm store is the ordinary way to get
+* here: `resolveLocalBin` finds the symlink, so "dependencies are not
+* installed" never fires, and the spawn is where it breaks.
+*
+* ## Why the message is not what decides it
+*
+* `db.ts` did make this distinction, by testing the message against
+* `/Command failed|exited with code/i` — and that test is wrong for every case
+* it was written to catch. execa prefixes **all** of them the same way:
+*
+*     Command failed with exit code 3: /bin/sh -c 'exit 3'
+*     Command failed with ENOENT: /…/tsx x⏎spawn /…/tsx ENOENT
+*     Command failed with EACCES: /…/tsx x⏎spawn /…/tsx EACCES
+*
+* So the filter matched the spawn failures too and `db push` was as silent as
+* the other two. The structured fields do distinguish them: a child that ran
+* has a numeric `exitCode` (or a `signal`, if something killed it), and a child
+* that never started has neither — only an errno in `code`.
+*/
+/** Did the process start? Only then has anything else already been printed. */
+function childRan(error) {
+	if (!(error instanceof Error)) return false;
+	const failure = error;
+	return typeof failure.exitCode === "number" || typeof failure.signal === "string";
+}
+function reportSpawnFailure(error) {
+	if (childRan(error) || !(error instanceof Error)) return;
+	const failure = error;
+	const message = typeof failure.originalMessage === "string" ? failure.originalMessage : error.message;
+	if (message) console.error(chalk.red(`✗ ${message}`));
+}
+//#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
+* disagreement was a dead command: `prepareDatabaseEnv` returns `env: {}` for a
+* plain external database — the connection string is already somewhere the
+* child looks — so `db pull`'s `prepared.env.DATABASE_URL ?? process.env
+* .DATABASE_URL` was empty for the standard `.env` configuration and answered
+* `✗ No local database to pull into.` on a project whose `rebase db url` had
+* just printed one. Exporting the same URL in the shell made it work, which is
+* the shape of a bug nobody reports as one.
+*
+* `readEnvFile` is passed in rather than imported: this module loads
+* `../utils/project` dynamically everywhere else, and the callers already have
+* it open.
+*/
+function databaseUrlOf(prepared, envFile) {
+	const named = (value) => value && value.trim() ? value : void 0;
+	return named(prepared.env.DATABASE_URL) ?? named(prepared.database.kind === "managed" ? void 0 : prepared.database.url) ?? named(envFile.DATABASE_URL) ?? named(process.env.DATABASE_URL);
+}
+/**
+* A destination that names a remote store rather than a local path.
+*
+* Matched as "scheme://" generally, not as a list of the schemes we support:
+* an unknown scheme is still not something to join onto a filesystem path, and
+* a Windows drive letter ("C:\backups") has no "//" so it stays a path.
+*/
+var REMOTE_DESTINATION_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
+/**
+* The flags whose value is a local path, on every line the CLI relays.
+*
+* All three spellings of the destination, because the driver accepts all
+* three: `backup-cli.ts` maps `--output` and `-o` onto `--out`, and `rebase db
+* backup --help` advertises `--output` as an alias. Only `--out` and `-o` were
+* absolutised once, so the one spelling the help page names was the one that
+* landed in `backend/` — and the success line still echoed the path as typed.
+*
+* And `--collections`, which was not absolutised at all: from the project root,
+* `rebase schema generate --collections ./config/collections` was "not found",
+* while the same spelling worked for `generate-sdk`. See `utils/path-flags.ts`.
+*/
+var LOCAL_PATH_FLAGS = [
+	"--out",
+	"--output",
+	"-o",
+	"--collections",
+	"-c"
+];
+/**
+* Rewrite local path arguments so they mean what the user typed.
+*
+* The plugin CLI is spawned with `cwd: backendDir` — it has to be, because that
+* is where the plugin and its dependencies resolve from. But the developer runs
+* `rebase db` from the project root, so a relative `--out ./backups` was being
+* resolved against `backend/` and landed in `backend/backups`, while the
+* success line echoed the path as typed. The file was real and the reported
+* location was wrong, which is the worst way for a backup command to behave.
+* `rebase db --help` documents exactly this invocation.
+*
+* Absolutising here rather than inside the plugin keeps the fix where the cwd
+* is actually changed, and leaves the plugin usable on its own terms.
+*/
+function absolutizeLocalPathArgs(args, cwd, pathFlags = LOCAL_PATH_FLAGS) {
+	const takesPath = (flag) => pathFlags.includes(flag);
+	/**
+	* Flags whose next token is a value, not a positional.
+	*
+	* Mirrors the `arg` specs in `@rebasepro/server-postgres`'s backup CLI.
+	* Needed only to find the `db restore` dump argument: without it,
+	* `restore --target-db app_restored ./x.dump` treats `app_restored` as the
+	* positional — it is the first token not starting with `-` — and turns a
+	* database name into a path while leaving the real dump path unresolved.
+	*/
+	const VALUE_FLAGS = /* @__PURE__ */ new Set([
+		"--out",
+		"--output",
+		"-o",
+		"--target-db",
+		"--exclude-schema",
+		"--row-security-role"
+	]);
+	const out = [...args];
+	for (let i = 0; i < out.length; i++) {
+		const arg = out[i];
+		const eq = arg.indexOf("=");
+		if (eq > 0 && takesPath(arg.slice(0, eq))) {
+			const value = arg.slice(eq + 1);
+			if (value && !REMOTE_DESTINATION_RE.test(value)) out[i] = `${arg.slice(0, eq)}=${path.resolve(cwd, value)}`;
+			continue;
+		}
+		if (takesPath(arg)) {
+			const value = out[i + 1];
+			if (value && !value.startsWith("-") && !REMOTE_DESTINATION_RE.test(value)) {
+				out[i + 1] = path.resolve(cwd, value);
+				i++;
+			}
+		}
+	}
+	const restoreAt = out.indexOf("restore");
+	if (restoreAt !== -1) for (let i = restoreAt + 1; i < out.length; i++) {
+		const arg = out[i];
+		if (arg.startsWith("-")) {
+			if (!arg.includes("=") && VALUE_FLAGS.has(arg)) i++;
+			continue;
+		}
+		if (!REMOTE_DESTINATION_RE.test(arg)) out[i] = path.resolve(cwd, arg);
+		break;
+	}
+	return out;
+}
+/**
+/**
+* Read `--flag value` or `--flag=value` out of the raw argv.
+*
+* This command forwards its arguments to the driver plugin rather than parsing
+* them, so the two flags the CLI itself acts on are picked out by hand instead
+* of adding a spec that would then have to strip them back out again.
+*/
+function readFlagValue(rawArgs, flag) {
+	for (let index = 0; index < rawArgs.length; index += 1) {
+		const arg = rawArgs[index];
+		if (arg === flag) return rawArgs[index + 1] ?? null;
+		if (arg.startsWith(`${flag}=`)) return arg.slice(flag.length + 1);
+	}
+	return null;
+}
+/**
+* Run a database subcommand through the active driver's CLI, throwing on
+* failure instead of exiting.
+*
+* `dbCommand` below turns every failure into `process.exit(1)`, which is right
+* for a command the user invoked directly and wrong for a caller that has more
+* to do afterwards — `rebase dev` runs a schema push during start-up and must
+* survive it failing. Exiting is therefore the wrapper's job, not this
+* function's.
+*
+* The database is resolved *here* rather than in the wrapper, so the schema
+* push `rebase dev` performs during start-up reaches the managed database too.
+*/
+/**
+* The `db` subcommands that plan their work with Atlas.
+*
+* Atlas computes a diff by replaying the desired schema into a **second, empty
+* database** and comparing. That is why these three are listed and `backup` and
+* `restore` are not — those shell out to `pg_dump`, which fails loudly on its
+* own. `branch` is refused too, but for its own reason and with its own
+* message: see {@link refuseBranchOnManagedDatabase}.
+*/
+var ATLAS_BACKED_SUBCOMMANDS = /* @__PURE__ */ new Set([
+	"push",
+	"generate",
+	"migrate"
+]);
+/**
+* A managed-database refusal, raised so the caller decides what it costs.
+*
+* These two guards used to `process.exit(1)` where they stood. That is right
+* for `rebase db push`, typed by a person, and catastrophic for the same code
+* reached from inside `rebase dev`: the dev server's first-boot schema push
+* runs in-process, so an exit there took the whole dev server down — with a
+* `try/catch` around it written expressly to prevent that, which could never
+* run. The first `rebase dev --docker` of every scaffold died this way.
+*
+* So the refusal is a value now. It carries the block it wants printed rather
+* than printing it, because who prints (and whether printing is even right) is
+* the caller's question: `dbCommand` prints it and exits 1, and `rebase dev`
+* keeps serving.
+*/
+var ManagedDatabaseRefusal = class extends Error {
+	/** The lines to print, in order, already coloured. */
+	lines;
+	constructor(summary, lines) {
+		super(summary);
+		this.name = "ManagedDatabaseRefusal";
+		this.lines = lines;
+	}
+};
+/** Print a refusal exactly as the guards used to print it themselves. */
+function printManagedDatabaseRefusal(refusal) {
+	for (const line of refusal.lines) console.error(line);
+}
+/**
+* The variable the driver reads for Atlas's dev database
+* (`ATLAS_DEV_URL_ENV` in `@rebasepro/server-postgres`, which this CLI does not
+* depend on).
+*/
+var ATLAS_DEV_URL_ENV = "REBASE_ATLAS_DEV_URL";
+/**
+* The variable that tells the driver where `rebase` was run
+* (`INVOCATION_CWD_ENV` in `@rebasepro/server-postgres`). The driver runs in
+* `backend/`, so a path it resolves itself, such as `db backup`'s default
+* `./backups`, needs to know the directory the developer meant.
+*/
+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-D_LP_Woq.js")).startAtlasDevDatabase();
+/**
+* The empty database an Atlas-backed subcommand plans against, on the managed
+* development database.
+*
+* **PGlite serves exactly one database.** Atlas computes a change by replaying
+* the desired schema into a second, empty one; on a real server the driver
+* makes it as `<db>_dev_diff`, but `CREATE DATABASE` against PGlite reports
+* success and creates nothing, so Atlas connected straight back to the
+* database it was comparing and stopped with `connected database is not
+* clean`. These commands were refused outright on the managed database — and
+* with them every way to drop, rename or narrow a column there, since boot
+* only adds.
+*
+* So a throwaway second PGlite is started for the command instead — in
+* memory, in this process, gone when the command ends — and handed to the
+* driver as `REBASE_ATLAS_DEV_URL`. Nothing else about the push changes: the
+* destructive gate is the driver's, and holds as it does everywhere.
+*
+* `undefined` when none is needed: another database kind (the driver makes its
+* own), a subcommand that is not Atlas's, or a `REBASE_ATLAS_DEV_URL` the
+* developer set. When one cannot be started — PGlite is an optional
+* dependency — the old refusal stands, with the reason.
+*/
+async function atlasDevDatabaseFor(rawArgs, kind, env, start = startAtlasDevDatabase) {
+	if (kind !== "managed") return void 0;
+	const [domain, subcommand] = commandWords(rawArgs, "db");
+	if (domain !== "db" || !ATLAS_BACKED_SUBCOMMANDS.has(subcommand ?? "")) return void 0;
+	if (env["REBASE_ATLAS_DEV_URL"]?.trim()) return void 0;
+	try {
+		return await start();
+	} catch (err) {
+		const summary = `rebase db ${subcommand} could not start the database Atlas plans against.`;
+		throw new ManagedDatabaseRefusal(summary, [
+			"",
+			chalk.red(`  ✗ ${summary}`),
+			chalk.gray(`    ${err instanceof Error ? err.message : String(err)}`),
+			"",
+			chalk.gray("  Atlas plans every change against a second, empty database. On the managed"),
+			chalk.gray("  database that is a throwaway PGlite, started for the command."),
+			"",
+			chalk.gray(`  ${chalk.cyan("rebase dev")} still applies your collections at boot, additively. Otherwise,`),
+			chalk.gray(`  set ${ATLAS_DEV_URL_ENV} to an empty Postgres database Atlas may fill and clear,`),
+			chalk.gray("  or point the project at a real Postgres (uncomment DATABASE_URL in .env)."),
+			""
+		]);
+	}
+}
+/**
+* Stop `rebase db branch` before it reports a branch that is not one.
+*
+* **PGlite serves exactly one database**, and this is the second thing that
+* follows from it. `CREATE DATABASE "rb_feature_x" TEMPLATE "postgres"` there
+* writes a `pg_database` catalog row and nothing else. Nothing errors, so the
+* whole feature reports success end to end:
+*
+*     $ rebase db branch create feature_x
+*       ✓ Branch "feature_x" created successfully.
+*     $ rebase db branch list
+*       ● feature_x (7.1 MB) — created just now
+*
+* `listBranches` joins `pg_database`, the catalog row is there, and
+* `pg_database_size` answers with the one database's size — so the listing
+* corroborates the lie. Then connecting to `rb_feature_x` reports
+* `current_database()` = `postgres`, and a table created "in the branch" is
+* visible in the parent immediately. Measured on a fresh `rebase init` scaffold.
+*
+* **The branch is the parent.** Every write made in the belief that it is
+* sandboxed lands in the developer's real development database — which is the
+* exact failure branching exists to prevent, announced as a success.
+*
+* So this refuses the whole `branch` domain rather than `create` alone: `list`
+* on the managed database ends with "Create one with: rebase db branch create",
+* an invitation to do the broken thing, and `info` would confirm a size for a
+* database that was never made.
+*
+* Push, generate and migrate had the same problem — Atlas's scratch database
+* is a second database too — and get a throwaway PGlite of their own instead
+* (`atlasDevDatabaseFor` above). A branch cannot: it is meant to keep the
+* project's data, and a throwaway instance has none.
+*/
+function refuseBranchOnManagedDatabase(rawArgs, kind) {
+	if (kind !== "managed") return;
+	const [domain, subcommand] = commandWords(rawArgs, "db");
+	if (domain !== "db" || subcommand !== "branch") return;
+	const summary = "rebase db branch does not work on the managed development database.";
+	throw new ManagedDatabaseRefusal(summary, [
+		"",
+		chalk.red(`  ✗ ${summary}`),
+		"",
+		chalk.gray("  Branching copies a database with CREATE DATABASE ... TEMPLATE. The managed"),
+		chalk.gray("  database is PGlite, which serves exactly one — the copy would be the"),
+		chalk.gray("  original, and every write you meant to sandbox would land in it."),
+		"",
+		chalk.gray("  Branching needs a real Postgres. Either:"),
+		chalk.gray(`  ${chalk.cyan("rebase dev --docker")}    starts one, and branches work against it`),
+		chalk.gray("  or uncomment DATABASE_URL in .env to point at your own."),
+		""
+	]);
+}
+/**
+* Resolve the active driver's CLI and the environment it should run in.
+*
+* Shared by the two runners below. Deliberately does NOT resolve a database:
+* `schema generate` reads collection files and writes one file, and starting a
+* database to run it would be a side effect nobody asked for.
+*/
+async function resolveDriverCli() {
+	const projectRoot = requireProjectRoot();
+	const backendDir = requireBackendDir(projectRoot);
+	const activePlugin = getActiveBackendPlugin(backendDir);
+	if (!activePlugin) throw new Error("Could not detect an active database plugin. Make sure a package like @rebasepro/server-postgres is installed in backend/package.json.");
+	const pluginCli = resolvePluginCliScript(backendDir, activePlugin);
+	if (!pluginCli) throw new Error(dependenciesNotInstalled(projectRoot));
+	const envFile = findEnvFile(projectRoot);
+	const env = { ...process.env };
+	if (envFile) env.DOTENV_CONFIG_PATH = envFile;
+	env[DEV_DATABASE_KIND_ENV] = devDatabaseKind(projectRoot) ?? "";
+	return {
+		projectRoot,
+		backendDir,
+		pluginCli,
+		env
+	};
+}
+/**
+* The one place this CLI spawns the driver's own CLI.
+*
+* There were three, each with its own copy of "tsx for a `.ts` entry, `node`
+* otherwise". That rule was right only while the driver shipped `src/`; once it
+* shipped `dist/cli.js` all three quietly switched to plain `node`, and the
+* driver loads the PROJECT's TypeScript in process:
+*
+*   - `schema stale` reads the collections, could not resolve `./authors` onto
+*     `authors.ts`, and answered "⏭ Not checked" while exiting 0;
+*   - `db push` does the same in `ensureAuthTables`, so `rebase.users` was never
+*     created and the push died at "Applying RLS policies" with
+*     `relation "rebase.users" does not exist` — on a virgin database, which is
+*     the documented bring-your-own-Postgres first run.
+*
+* Two were fixed and the third was missed, because three copies of a decision
+* are three chances to miss one. There is one now, and a gate holds it at one.
+*
+* tsx whenever it is installed — a devDependency of every scaffold, for exactly
+* this reason. Without it a `.ts` entry cannot run at all; a built entry still
+* runs, and the subcommands that never touch the project's TypeScript still work.
+*
+* tsx's loader in one Node (`node --import`) rather than the `tsx` binary,
+* which is a shell shim and a relay Node in front of the same loader: one Node
+* start instead of two, ~50–100 ms on each of the driver runs every `rebase
+* dev` start and every collection save makes. The binary stays the fallback for
+* a tsx whose loader does not resolve as a package — a global install.
+*/
+async function spawnDriverCli(resolved, childArgs, options = {}) {
+	const { projectRoot, backendDir, pluginCli, env } = resolved;
+	const stdio = options.quiet ? "pipe" : "inherit";
+	const tsxBin = resolveTsx(projectRoot);
+	const tsxLoader = resolveTsxLoader(projectRoot);
+	if (!tsxBin && !tsxLoader && pluginCli.endsWith(".ts")) throw new Error(dependenciesNotInstalled(projectRoot));
+	const [command, ...prefix] = tsxLoader ? [
+		process.execPath,
+		"--import",
+		tsxLoader
+	] : [tsxBin ?? "node"];
+	await execa(command, [
+		...prefix,
+		pluginCli,
+		...childArgs
+	], {
+		cwd: backendDir,
+		stdio,
+		env
+	});
+}
+/** @deprecated Use {@link spawnDriverCli}. Kept as the internal name callers use. */
+var execDriverCli = spawnDriverCli;
+/**
+* Run a `schema` subcommand through the active driver's CLI.
+*
+* Separate from {@link runDriverDbCommand} because it must NOT resolve a
+* database. `rebase dev` calls this before the database exists, which is the
+* whole point: the generated schema has to be right before anything reads it.
+* Throws rather than exiting — the caller has more to do.
+*/
+async function runDriverSchemaCommand(rawArgs, options = {}) {
+	await execDriverCli(await resolveDriverCli(), rawArgs.slice(2), options);
+}
+async function runDriverDbCommand(rawArgs, options = {}) {
+	const projectRoot = requireProjectRoot();
+	const backendDir = requireBackendDir(projectRoot);
+	const activePlugin = getActiveBackendPlugin(backendDir);
+	if (!activePlugin) throw new Error("Could not detect an active database plugin. Make sure a package like @rebasepro/server-postgres is installed in backend/package.json.");
+	const pluginCli = resolvePluginCliScript(backendDir, activePlugin);
+	if (!pluginCli) throw new Error(dependenciesNotInstalled(projectRoot));
+	const envFile = findEnvFile(projectRoot);
+	const env = { ...process.env };
+	if (envFile) env.DOTENV_CONFIG_PATH = envFile;
+	env[DEV_DATABASE_KIND_ENV] = devDatabaseKind(projectRoot) ?? "";
+	const { resolveProjectDatabase } = await import("./prepare-CDN6lSpz.js");
+	refuseBranchOnManagedDatabase(rawArgs, resolveProjectDatabase(projectRoot, {
+		flagUrl: readFlagValue(rawArgs, "--database-url"),
+		flagDocker: rawArgs.includes("--docker")
+	}).kind);
+	const { prepareDatabaseEnv, managedNotices } = await import("./prepare-CDN6lSpz.js");
+	const prepared = await prepareDatabaseEnv(projectRoot, {
+		flagUrl: readFlagValue(rawArgs, "--database-url"),
+		flagDocker: rawArgs.includes("--docker"),
+		onProgress: (message) => {
+			if (!options.quiet) console.log(chalk.gray(`  ${message}`));
+		}
+	});
+	Object.assign(env, prepared.env);
+	if (!options.quiet) for (const line of managedNotices(prepared)) console.log(chalk.gray(`  ${line}`));
+	const atlasDev = await atlasDevDatabaseFor(rawArgs, prepared.database.kind, env);
+	if (atlasDev) env[ATLAS_DEV_URL_ENV] = atlasDev.url;
+	env[INVOCATION_CWD_ENV] = process.cwd();
+	const childArgs = absolutizeLocalPathArgs(argsFromCommand(rawArgs, "db"), process.cwd());
+	try {
+		await spawnDriverCli({
+			projectRoot,
+			backendDir,
+			pluginCli,
+			env
+		}, childArgs, options);
+	} finally {
+		await atlasDev?.stop();
+	}
+}
+async function dbCommand(subcommand, rawArgs) {
+	if (!subcommand || subcommand === "--help" || rawArgs.includes("--help") || rawArgs.includes("-h")) {
+		printDbHelp(subcommand === "--help" ? void 0 : subcommand);
+		return;
+	}
+	if (!DB_ACTION_HELP[subcommand]) unknownCommand(subcommand, Object.keys(DB_ACTION_HELP), "db");
+	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;
+	}
+	if (subcommand === "url") {
+		await printDatabaseUrl(projectRoot, rawArgs);
+		return;
+	}
+	if (subcommand === "branch" && commandWords(rawArgs, "db")[2] === "switch") {
+		await switchBranch(projectRoot, rawArgs);
+		return;
+	}
+	let driverArgs = rawArgs;
+	if (subcommand === "branch") {
+		const action = commandWords(rawArgs, "db")[2];
+		if (action === "delete") await refuseDeletingActiveBranch(projectRoot, rawArgs);
+		if (action && REGISTRY_ACTIONS.has(action)) driverArgs = await onParentDatabase(projectRoot, rawArgs, action);
+	}
+	refuseMissingCollectionsPath(driverArgs, process.cwd(), requireBackendDir(projectRoot));
+	try {
+		await runDriverDbCommand(driverArgs);
+	} catch (error) {
+		if (error instanceof ManagedDatabaseRefusal) {
+			printManagedDatabaseRefusal(error);
+			process.exit(1);
+		}
+		reportSpawnFailure(error);
+		process.exit(1);
+	}
+}
+/**
+* `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`
+* ships `DATABASE_URL` commented out on purpose, the port is derived from the
+* project path, and the data lives under `.rebase/`. A headless project has no
+* admin panel to open either, so before this there was no way to point `psql`,
+* a GUI client or a seeding script at the database `rebase dev` had just
+* created — short of reading the CLI's source.
+*
+* Resolution is the same ordered rule every other command uses, so this prints
+* your own `DATABASE_URL` when you have set one rather than inventing a second
+* answer. Nothing but the URL goes to stdout, so it pipes:
+*
+*     psql "$(rebase db url)"
+*
+* It starts the managed database if it is not running, because a connection
+* 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-CDN6lSpz.js");
+	const { readEnvFile } = await import("./project-Wp2zoyeN.js").then((n) => n.u);
+	const url = databaseUrlOf(await prepareDatabaseEnv(projectRoot, {
+		flagUrl: readFlagValue(rawArgs, "--database-url"),
+		flagDocker: rawArgs.includes("--docker"),
+		quiet: true,
+		onProgress: (message) => console.error(chalk.gray(`  ${message}`))
+	}), readEnvFile(projectRoot));
+	if (!url) {
+		console.error(chalk.red("  ✗ This project has no database URL to print."));
+		console.error(chalk.gray("    Set DATABASE_URL in .env, or run `rebase dev` to start the managed one."));
+		process.exit(1);
+	}
+	console.log(url);
+}
+/**
+* `rebase db stop` and `rebase db reset`, for the managed database only.
+*
+* `reset` deletes the data directory rather than dropping schemas: "give me an
+* empty database" is the only thing anyone means by it, and doing it by
+* removing the directory cannot leave a half-dropped schema behind.
+*/
+async function manageLocalDatabase(subcommand, projectRoot, rawArgs) {
+	const { resetManagedDatabase, stopManagedDatabase, findRunningDaemon } = await import("./daemon-pzsQwDHa.js");
+	const { dataDir } = await import("./state-Do7ZJYkF.js").then((n) => n.d);
+	const nothingHere = () => {
+		const kind = devDatabaseKind(projectRoot);
+		const verb = subcommand === "stop" ? "was not running" : "does not exist";
+		if (kind && kind !== "managed") return `  The managed development database (PGlite) ${verb}; this project uses its own DATABASE_URL, which is untouched.`;
+		return subcommand === "stop" ? "  The managed development database (PGlite) was not running." : "  There is no managed development database (PGlite) to reset.";
+	};
+	if (subcommand === "stop") {
+		const stopped = await stopManagedDatabase(projectRoot);
+		console.log(stopped ? chalk.green("✓ Development database stopped. Data is kept — `rebase dev` will start it again.") : chalk.gray(nothingHere()));
+		return;
+	}
+	const running = await findRunningDaemon(projectRoot);
+	const hasData = fs.existsSync(dataDir(projectRoot));
+	if (!running && !hasData) {
+		console.log(chalk.gray(nothingHere()));
+		return;
+	}
+	if (!rawArgs.includes("--yes") && !rawArgs.includes("-y")) {
+		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."));
+			process.exit(1);
+		}
+		const { confirmed } = await inquirer.prompt([{
+			type: "confirm",
+			name: "confirmed",
+			message: `Delete the development database at ${dataDir(projectRoot)}? This cannot be undone.`,
+			default: false
+		}]);
+		if (!confirmed) {
+			console.log(chalk.gray("  Left alone."));
+			return;
+		}
+	}
+	await resetManagedDatabase(projectRoot);
+	console.log(chalk.green("✓ Development database deleted. `rebase dev` will create a fresh one."));
+}
+/**
+* `rebase db pull --from <url>` — copy another database's contents into local
+* development.
+*
+* Deliberately one-directional. There is no flag that makes this push, because
+* a tool that can copy in both directions eventually copies in the wrong one,
+* and the wrong one here means overwriting production with a laptop.
+*/
+async function pullIntoLocal(projectRoot, rawArgs) {
+	const { describeTarget, dumpArgs, dumpEnv, findPgTool, restoreArgs, restoreEnv, restoreOutcome } = await import("./pull-CrGYMEsy.js");
+	const { prepareDatabaseEnv } = await import("./prepare-CDN6lSpz.js");
+	const { readEnvFile } = await import("./project-Wp2zoyeN.js").then((n) => n.u);
+	const source = readFlagValue(rawArgs, "--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");
+	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);
+	}
+	const prepared = await prepareDatabaseEnv(projectRoot, {
+		flagDocker: rawArgs.includes("--docker"),
+		onProgress: (message) => console.log(chalk.gray(`  ${message}`))
+	});
+	const target = databaseUrlOf(prepared, readEnvFile(projectRoot)) ?? "";
+	if (!target) {
+		console.error(chalk.red("✗ No local database to pull into."));
+		console.error(chalk.gray("  Set DATABASE_URL in .env, or run `rebase dev` to start the managed one."));
+		process.exit(1);
+	}
+	const plan = {
+		source,
+		target,
+		anonymize,
+		schemas
+	};
+	console.log("");
+	console.log(chalk.bold("  This will replace your local database."));
+	console.log(`    ${chalk.gray("From")}  ${describeTarget(source)}`);
+	console.log(`    ${chalk.gray("Into")}  ${describeTarget(target)}${prepared.dataDir ? chalk.gray(`  (${prepared.dataDir})`) : ""}`);
+	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 (!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."));
+			process.exit(1);
+		}
+		const { confirmed } = await inquirer.prompt([{
+			type: "confirm",
+			name: "confirmed",
+			message: "Continue?",
+			default: false
+		}]);
+		if (!confirmed) {
+			console.log(chalk.gray("  Nothing was changed."));
+			return;
+		}
+	}
+	const dumpFile = path.join(os.tmpdir(), `rebase-pull-${process.pid}.dump`);
+	let failure = null;
+	let anonymizeFailure = null;
+	try {
+		console.log(chalk.gray("  Dumping…"));
+		await execa("pg_dump", [
+			...dumpArgs(plan),
+			"--file",
+			dumpFile
+		], {
+			stdio: [
+				"ignore",
+				"inherit",
+				"inherit"
+			],
+			env: dumpEnv(plan)
+		});
+		console.log(chalk.gray("  Restoring…"));
+		const restored = restoreOutcome(await execa("pg_restore", restoreArgs(plan, dumpFile), {
+			env: restoreEnv(plan),
+			stdin: "ignore",
+			stdout: "inherit",
+			stderr: ["pipe", "inherit"],
+			reject: false
+		}));
+		failure = restored.failure;
+		if (anonymize && restored.started) anonymizeFailure = await anonymizeTarget(target, describeTarget(source), prepared.database.kind);
+		if (restored.started) await restoreAppRole(target);
+	} finally {
+		fs.rmSync(dumpFile, { force: true });
+	}
+	if (anonymizeFailure) {
+		for (const line of anonymizeFailure) console.error(line);
+		if (failure) console.error(chalk.red(`✗ ${failure}`));
+		process.exit(1);
+	}
+	if (failure) {
+		console.error(chalk.red(`✗ ${failure}`));
+		console.error(chalk.yellow(`  The local database holds an incomplete copy of ${describeTarget(source)}.`));
+		console.error(chalk.gray("  Fix what the errors above name — often an extension or a role the source has — and pull again."));
+		process.exit(1);
+	}
+	console.log(chalk.green("✓ Local database now holds a copy of " + describeTarget(source)));
+}
+/**
+* Give the restored copy back the privileges `pg_dump` stripped.
+*
+* A pull without this ends on a green tick and hands over a database the
+* application cannot read: `--no-privileges` removes every GRANT, so the copy
+* has the source's RLS policies and none of the grants behind them, and the
+* first query as `rebase_user` fails with `permission denied`. Measured — 68
+* policies and 60 grants in, 68 policies and 0 grants out.
+*
+* `ensureAppRole` is the routine boot runs and `rebase db push` runs, so the
+* pulled database ends up in the state a booted one is in, and there is no
+* second description of these grants to drift. `detectConnectionPosture` gates
+* it the same way `db push` does: a connection that cannot create roles reports
+* that rather than failing the pull, which has already succeeded by this point.
+*
+* Failure here is a warning, not an error. The data is restored and correct; a
+* missing grant is repaired by the next `rebase dev` or `rebase db push`, and
+* saying so beats unwinding a copy that is fine.
+*/
+async function restoreAppRole(target) {
+	const { Client } = await import("pg");
+	const { provisionableSchemas } = await import("./pull-CrGYMEsy.js");
+	const client = new Client({ connectionString: target });
+	client.on("error", () => void 0);
+	try {
+		await client.connect();
+		const { detectConnectionPosture, ensureAppRole, REBASE_USER_ROLE } = await import("@rebasepro/server-postgres");
+		const runSql = async (text) => (await client.query(text)).rows;
+		if (!(await detectConnectionPosture(runSql)).privileged) {
+			console.log(chalk.yellow(`  ⚠ Could not re-grant the "${REBASE_USER_ROLE}" role — this connection may not create roles.`));
+			console.log(chalk.gray("    The copy has its RLS policies but no privileges behind them;"));
+			console.log(chalk.gray("    `rebase dev` or `rebase db push` will provision them."));
+			return;
+		}
+		const { rows } = await client.query("SELECT nspname AS \"schema\" FROM pg_namespace");
+		const schemas = provisionableSchemas(rows);
+		await ensureAppRole(runSql, schemas);
+		console.log(chalk.gray(`  ✓ Re-granted "${REBASE_USER_ROLE}" on ${schemas.length} schema(s) — pg_dump strips privileges.`));
+	} catch (error) {
+		console.log(chalk.yellow(`  ⚠ Restored, but could not re-grant "rebase_user": ${error instanceof Error ? error.message : String(error)}`));
+		console.log(chalk.gray("    Run `rebase db push` (or start `rebase dev`) to provision it."));
+	} finally {
+		await client.end().catch(() => void 0);
+	}
+}
+/**
+* Anonymize the restored copy, and say what happened if that did not work.
+*
+* Returns null when the copy is anonymized, and otherwise the lines that say —
+* in red, because `--anonymize` was the developer saying this data must not
+* arrive as it is — what state the local database is in now: emptied of what
+* could not be anonymized, or, when even that failed, holding real data that
+* has to be deleted before anything else.
+*/
+async function anonymizeTarget(target, source, kind) {
+	const { Client } = await import("pg");
+	const { anonymizeCopy } = await import("./pull-CrGYMEsy.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}`),
+		chalk.red.bold(`  The local database holds an UN-ANONYMIZED copy of ${source}, personal data included.`),
+		chalk.yellow(`  ${deleteIt}`)
+	];
+	const client = new Client({ connectionString: target });
+	client.on("error", () => void 0);
+	try {
+		await client.connect();
+	} catch (error) {
+		return holdsRealData(error instanceof Error ? error.message : String(error));
+	}
+	try {
+		const outcome = await anonymizeCopy(client);
+		if (outcome.ok) {
+			console.log(chalk.green(`  ✓ Anonymized ${outcome.tables.length} table(s).`));
+			console.log(chalk.gray("    Name-based and best-effort: a free-text column may still hold personal data."));
+			return null;
+		}
+		if (outcome.emptyError !== null) return [...holdsRealData(outcome.error), chalk.red(`  Emptying the affected tables failed too: ${outcome.emptyError}`)];
+		return [
+			chalk.red(`✗ The copy could not be anonymized: ${outcome.error}`),
+			chalk.yellow("  Nothing was anonymized — the pass is one transaction — so the tables it would have"),
+			chalk.yellow("  rewritten were emptied instead, with every row that references them:"),
+			...outcome.emptied.length > 0 ? [chalk.gray(`    ${outcome.emptied.join(", ")}`)] : [],
+			chalk.gray(`  The rest of the copy of ${source} is in place. Fix that error and pull again.`)
+		];
+	} finally {
+		await client.end().catch(() => void 0);
+	}
+}
+/**
+* Start the compose database a `db … --docker` was asked to talk to.
+*
+* `--docker` resolved the compose URL and stopped there, so every `db`
+* subcommand carrying it reached a container nobody had started —
+* `ECONNREFUSED 127.0.0.1:5436`, two lines, no diagnosis — including the
+* commands the managed-database refusals send readers to `--docker` for.
+*
+* `rebase dev --docker`'s preflight, called with the compose URL and nothing
+* to push: this is not a schema step, and `rebase db push --docker` is the
+* push. A failure here is reported and not fatal — the command runs and its
+* own connection error follows, which is the same contract `dev` keeps.
+*/
+async function ensureDockerDatabase(projectRoot, rawArgs) {
+	const { ensureDevDatabase } = await import("./dev-preflight-B-LYyBf1.js");
+	const { resolveProjectDatabase } = await import("./prepare-CDN6lSpz.js");
+	const resolved = resolveProjectDatabase(projectRoot, {
+		flagUrl: readFlagValue(rawArgs, "--database-url"),
+		flagDocker: rawArgs.includes("--docker")
+	});
+	if (resolved.kind !== "docker") return;
+	const composeUrl = resolved.url;
+	if (!composeUrl) return;
+	await ensureDevDatabase({
+		projectRoot,
+		databaseUrl: composeUrl,
+		disabled: false,
+		hasCollections: false,
+		pushSchema: async () => void 0,
+		log: (message) => console.log(message)
+	});
+}
+/**
+* You cannot delete the branch you are standing on.
+*
+* Not a new rule — it was always refused, by a message about a database the
+* developer had never named. After `switch feature_x` the resolved DSN *is*
+* `rb_feature_x`, so `BranchService.deleteBranch` compared it against the
+* connected database, found them equal, and answered `✗ Cannot delete the main
+* database.` The main database is precisely what the developer was not on.
+*
+* Answered here because the pointer is the CLI's: the driver runs as a child
+* process that has never heard of it, and cannot tell "the branch you are on"
+* from "the main database" — those are the same connection string to it.
+*/
+async function refuseDeletingActiveBranch(projectRoot, rawArgs) {
+	const [, , , name] = commandWords(rawArgs, "db");
+	if (!name) return;
+	const { readActiveBranch } = await import("./branch-pointer-DvSHBjjz.js");
+	const active = readActiveBranch(projectRoot);
+	if (active?.name !== name) return;
+	const off = "rebase db branch switch --off";
+	const del = `rebase db branch delete ${name}`;
+	const column = Math.max(29, del.length) + 4;
+	console.error("");
+	console.error(chalk.red(`✗ You are on branch "${name}" — leave it before deleting it.`));
+	console.error("");
+	console.error(chalk.gray(`  Every database command in this checkout is pointed at ${active.database},`));
+	console.error(chalk.gray("  including this one, so the delete would be asking that database to drop"));
+	console.error(chalk.gray("  itself."));
+	console.error("");
+	console.error(`  ${chalk.cyan(off)}${" ".repeat(column - 29)}back to the main database`);
+	console.error(`  ${chalk.cyan(del)}${" ".repeat(column - del.length)}then this works`);
+	console.error("");
+	process.exit(1);
+}
+/** The `branch` actions that read or write the registry — every one but `switch`. */
+var REGISTRY_ACTIONS = /* @__PURE__ */ new Set([
+	"list",
+	"create",
+	"delete",
+	"info",
+	"prune"
+]);
+/**
+* Every `branch` action runs against the parent, where the registry lives.
+*
+* `rebase.branches` is written in the database branches are made *from*, and a
+* branch is a `CREATE DATABASE … TEMPLATE` copy — so the copy carries a
+* snapshot of that table taken at branch time, and every branch made since is
+* missing from it. After `switch feature_x`, `branch list` connected to
+* `rb_feature_x` and answered `No branches found. Create one with: rebase db
+* branch create <name>` while `branch switch` with no argument, one command
+* earlier, had said `● On branch feature_x`.
+*
+* The same snapshot answered `create`, `delete`, `info` and `prune`: a branch
+* created from a switched checkout was recorded only in the copy, so `list`
+* never showed it and `delete` from the main checkout said "not found" while
+* its database stayed; `info` and `delete` could not find a branch made after
+* the one this checkout is on. The Branches pane in Studio was fixed the same
+* way (`REBASE_BRANCH_PARENT_DATABASE`).
+*
+* `create` still copies what this checkout is on — a branch of the branch, a
+* thing the developer asked for by switching first — so it is given
+* `--from <the branch's database>` unless it names a source itself.
+*
+* Resolved with `branch: null` — the same rule `switch` uses to find what to
+* branch *from* — and relayed as `--database-url`, which the driver honours
+* over anything it would resolve for itself.
+*/
+async function onParentDatabase(projectRoot, rawArgs, action) {
+	if (readFlagValue(rawArgs, "--database-url") !== null) return rawArgs;
+	const { readActiveBranch } = await import("./branch-pointer-DvSHBjjz.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-B2O-wKKk.js");
+	const { resolveComposeUrl } = await import("./prepare-CDN6lSpz.js");
+	const { readLastDevDocker } = await import("./last-dev-database-B58g89uA.js");
+	const envFile = readEnvFile(projectRoot);
+	const parent = resolveDevDatabase({
+		flagDocker: rawArgs.includes("--docker"),
+		lastDevDocker: readLastDevDocker(projectRoot),
+		env: process.env,
+		envFile,
+		branch: null,
+		composeUrl: resolveComposeUrl(projectRoot, envFile)
+	});
+	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.`));
+	const from = action === "create" && readFlagValue(rawArgs, "--from") === null ? ["--from", active.database] : [];
+	return [
+		...rawArgs,
+		...from,
+		"--database-url",
+		url
+	];
+}
+/**
+* `rebase db branch switch <name>` — point this checkout at a branch.
+*
+* The step branching was missing. `create` copied the database in about a
+* second and then printed `Database: rb_feature_auth` and stopped: there was no
+* `switch`, no `--branch` on `rebase dev`, and no `REBASE_BRANCH`. The only way
+* to use a branch was to hand-edit `DATABASE_URL`, while the documentation said
+* "the CLI updates your local development configuration" — it did not, and the
+* `.env` was byte-identical afterwards.
+*
+* Three things it insists on:
+*
+* - **The branch has to exist.** Writing a pointer to a database that was never
+*   created turns a typo into a connection error on the *next* command, which
+*   is the one place it cannot be explained. Checked against
+*   `rebase.branches` and `pg_database` both, because a branch dropped outside
+*   Rebase leaves the metadata row behind.
+*
+* - **It says what changed, and how to undo it.** A command that silently
+*   redirects every subsequent database operation owes the reader the database
+*   name it moved to and the words that move it back.
+*
+* - **It never edits `.env`.** See `branch-pointer.ts`.
+*/
+async function switchBranch(projectRoot, rawArgs) {
+	const { branchDatabaseName, clearActiveBranch, databaseNameOf, readActiveBranch, writeActiveBranch } = await import("./branch-pointer-DvSHBjjz.js");
+	const { readEnvFile } = await import("./project-Wp2zoyeN.js").then((n) => n.u);
+	const { resolveDevDatabase } = await import("./resolve-B2O-wKKk.js");
+	const { resolveComposeUrl } = await import("./prepare-CDN6lSpz.js");
+	const { readLastDevDocker } = await import("./last-dev-database-B58g89uA.js");
+	const goingOff = rawArgs.includes("--off") || rawArgs.includes("--main");
+	const name = commandWords(rawArgs, "db")[3];
+	const envFile = readEnvFile(projectRoot);
+	const resolved = resolveDevDatabase({
+		flagUrl: readFlagValue(rawArgs, "--database-url"),
+		flagDocker: rawArgs.includes("--docker"),
+		lastDevDocker: readLastDevDocker(projectRoot),
+		env: process.env,
+		envFile,
+		branch: null,
+		composeUrl: resolveComposeUrl(projectRoot, envFile)
+	});
+	const base = (resolved.kind === "managed" ? null : resolved.url)?.trim() || void 0;
+	if (!name && !goingOff) {
+		const active = readActiveBranch(projectRoot);
+		console.log("");
+		if (active) {
+			console.log(`  ${chalk.green("●")} On branch ${chalk.bold(active.name)} ${chalk.gray(`(${active.database})`)}`);
+			console.log(chalk.gray(`    Back to the main database: ${chalk.cyan("rebase db branch switch --off")}`));
+		} else {
+			const main = base ? databaseNameOf(base) : null;
+			console.log(`  ${chalk.gray("●")} On the main database${main ? chalk.gray(` (${main})`) : ""}`);
+			console.log(chalk.gray(`    Switch to a branch: ${chalk.cyan("rebase db branch switch <name>")}`));
+		}
+		console.log("");
+		return;
+	}
+	if (goingOff) {
+		const active = readActiveBranch(projectRoot);
+		clearActiveBranch(projectRoot);
+		console.log("");
+		console.log(active ? chalk.green(`  ✓ Back on the main database${base ? ` (${databaseNameOf(base)})` : ""}.`) : chalk.gray("  Already on the main database."));
+		console.log("");
+		return;
+	}
+	if (!base) {
+		console.error(chalk.red("✗ There is no database to branch from."));
+		console.error(chalk.gray(resolved.kind === "managed" ? "  This project is on the managed development database, which serves exactly one —" : "  --docker needs a docker-compose.yml with a db service, and this project has none —"));
+		console.error(chalk.gray("  and branching copies a database. Set DATABASE_URL in .env or in your"));
+		console.error(chalk.gray("  shell, or run `rebase dev --docker`."));
+		process.exit(1);
+	}
+	const database = branchDatabaseName(name);
+	const { Client } = await import("pg");
+	const client = new Client({ connectionString: base });
+	try {
+		await client.connect();
+	} catch (error) {
+		console.error(chalk.red(`✗ Could not reach the database to check that branch "${name}" exists.`));
+		console.error(chalk.gray(`  ${error instanceof Error ? error.message : String(error)}`));
+		process.exit(1);
+	}
+	try {
+		const { rows } = await client.query(`SELECT EXISTS (SELECT 1 FROM rebase.branches WHERE name = $1)      AS registered,
+                    EXISTS (SELECT 1 FROM pg_database    WHERE datname = $2)    AS present`, [name, database]).catch(() => ({ rows: [{
+			registered: false,
+			present: false
+		}] }));
+		const { registered, present } = rows[0] ?? {
+			registered: false,
+			present: false
+		};
+		if (!present) {
+			console.error(chalk.red(`✗ Branch "${name}" does not exist.`));
+			console.error(registered ? chalk.gray(`  It is registered but its database (${database}) is gone — someone dropped it outside Rebase.`) : chalk.gray(`  ${chalk.cyan("rebase db branch list")} shows the ones that do.`));
+			process.exit(1);
+		}
+	} finally {
+		await client.end();
+	}
+	writeActiveBranch(projectRoot, {
+		name,
+		database
+	});
+	console.log("");
+	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(`    Back to the main database: ${chalk.cyan("rebase db branch switch --off")}`));
+	console.log("");
+}
+/**
+* What each `rebase db <action>` does and takes.
+*
+* Kept here rather than delegated to the driver because the driver is reached
+* by *running* it — which is exactly what `--help` must not do. The page is
+* deliberately short: the authority on a flag is the command's own spec, and
+* `check-doc-commands.mjs` holds every command written in this repository's
+* markdown to it. What a reader needs from here is which subcommands exist and
+* what the destructive ones want before they will run.
+*/
+/** The database flags every driver command takes; `db url --help` has its own wording. */
+var DATABASE_FLAGS_HELP = "--database-url <url> names the database; --docker uses the compose one, starting it if needed.";
+var DB_ACTION_HELP = {
+	push: {
+		usage: "rebase db push [--collections <dir>] [--dry-run] [--allow-destructive] [--yes]",
+		summary: "Apply the schema straight to the database. Development only — it does not write a migration.",
+		notes: [
+			"--dry-run prints the SQL and applies nothing. Read it before you approve it.",
+			"A change that drops data, or re-keys a table (every row gets a new id), needs --allow-destructive.",
+			`--collections <dir>: ${COLLECTIONS_FLAG_HELP}.`,
+			DATABASE_FLAGS_HELP
+		]
+	},
+	generate: {
+		usage: "rebase db generate [--collections <dir>]",
+		summary: "Generate the Drizzle schema, the Postgres DDL and a SQL migration file from the collections.",
+		notes: [
+			"A migration that drops or narrows data is named when it is written. It is still written.",
+			`--collections <dir>: ${COLLECTIONS_FLAG_HELP}.`,
+			DATABASE_FLAGS_HELP
+		]
+	},
+	migrate: {
+		usage: "rebase db migrate [--baseline <version>] [--refuse-destructive] [amount]",
+		summary: "Run the pending migration files against the database.",
+		notes: [
+			"--refuse-destructive dry-runs the pending files and applies nothing when one drops or narrows data.",
+			"--baseline <version> records that version as already applied and starts from the next one.",
+			"It is what a database Rebase has already booted against needs: boot ensures the schema, so the first migration would try to create tables that are already there.",
+			"The version is the numeric prefix of a file in drizzle/migrations.",
+			DATABASE_FLAGS_HELP
+		]
+	},
+	branch: {
+		usage: "rebase db branch <create|list|switch|delete|info|prune> [name]",
+		summary: "Database branching.",
+		notes: [
+			"create <name> [--from <source>] copies an existing database, files and all.",
+			"switch <name> points this checkout at a branch; every later command uses it.",
+			"switch with no name reports where you are; switch --off returns to the main database.",
+			"prune [--older-than <14|14d|2w>] removes branches nothing is using, and the entries that drifted.",
+			"prune --include-dev-diff also removes the Atlas scratch databases `db push` leaves behind.",
+			"prune asks before it drops anything; --yes, -y answers for you, which is the form a CI job wants.",
+			"--force disconnects other sessions first — Postgres refuses to copy or drop a database anything is connected to, usually your own `rebase dev`."
+		]
+	},
+	backup: {
+		usage: "rebase db backup [--out <path|s3://…>]",
+		summary: "Create a pg_dump backup. --out is resolved against the directory you are standing in.",
+		notes: ["--output is accepted as an alias, as it is on `rebase build`.", "`rebase db backup list` lists them, the way `rebase cloud db backup list` does."]
+	},
+	backups: {
+		usage: "rebase db backups list [--out <path|s3://…>]",
+		summary: "List stored backups.",
+		notes: ["`rebase db backup list` is the same command, spelled the cloud family's way."]
+	},
+	url: {
+		usage: "rebase db url [--database-url <url>] [--docker]",
+		summary: "Print the connection string this project uses. Nothing else goes to stdout, so it pipes.",
+		notes: [
+			"psql \"$(rebase db url)\"",
+			"Starts the managed database if it is not already running.",
+			"--database-url and --docker answer for the database `rebase dev` would pick with the same flag.",
+			"After `rebase dev --docker` it prints the Docker database without the flag, as every db command does."
+		]
+	},
+	restore: {
+		usage: "rebase db restore <dump> [--target-db <name>] [--create-db] --yes",
+		summary: "Restore a backup with pg_restore.",
+		notes: ["Destructive, and refuses to run without --yes."]
+	},
+	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."]
+	},
+	stop: {
+		usage: "rebase db stop",
+		summary: "Stop the managed development database. Data is kept."
+	},
+	reset: {
+		usage: "rebase db reset [--yes]",
+		summary: "Delete the managed development database and start over.",
+		notes: ["Destructive, and the data exists only on this machine."]
+	}
+};
+/** Every subcommand the family dispatches — the help table's keys. */
+var DB_SUBCOMMANDS = Object.keys(DB_ACTION_HELP);
+function printDbHelp(action) {
+	const entry = action ? DB_ACTION_HELP[action] : void 0;
+	if (entry) {
+		console.log(`
+${chalk.bold(`rebase db ${action}`)}
+
+  ${entry.summary}
+
+${chalk.green.bold("Usage")}
+  ${chalk.blue(entry.usage)}
+${entry.notes?.length ? `\n${chalk.green.bold("Notes")}\n${entry.notes.map((n) => `  ${chalk.gray(`• ${n}`)}`).join("\n")}\n` : ""}
+${chalk.gray("Run `rebase db --help` for every subcommand.")}
+`);
+		return;
+	}
+	console.log(`
+${chalk.bold("rebase db")} — Database management commands
+
+${chalk.green.bold("Usage")}
+  rebase db ${chalk.blue("<command>")} [options]
+
+${chalk.green.bold("Commands")}
+  ${chalk.gray("(Commands are provided by your active database driver plugin)")}
+  ${chalk.blue.bold("url")}        Print the connection string this project uses (pipes into psql)
+  ${chalk.blue.bold("pull")}       Copy another database into local dev (--from <url>, --anonymize)
+  ${chalk.blue.bold("stop")}       Stop the managed development database (data is kept)
+  ${chalk.blue.bold("reset")}      Delete the managed development database and start over
+  ${chalk.blue.bold("push")}       Apply schema directly to database (development)
+  ${chalk.blue.bold("generate")}   Generate migration files
+  ${chalk.blue.bold("migrate")}    Run pending migrations
+  ${chalk.blue.bold("branch")}     Database branching (create, list, switch, delete, info, prune)
+  ${chalk.blue.bold("backup")}     Create a backup with pg_dump (--out <path|s3://…>)
+  ${chalk.blue.bold("restore")}    Restore a backup with pg_restore (destructive; needs --yes)
+  ${chalk.blue.bold("backups")}    List stored backups (db backup list is the same)
+
+${chalk.green.bold("Examples")}
+${dbExamples(devDatabaseKind())}
+  ${chalk.gray("# Back up to a local directory, then to object storage")}
+  rebase db backup --out ./backups
+  rebase db backup --out s3://my-private-bucket/backups
+
+  ${chalk.gray("# Restore into a fresh database (safe: does not touch the live one)")}
+  rebase db restore ./backups/rebase-app-20260714T030000Z.dump --create-db --target-db app_restored
+`);
+}
+/**
+* The examples, which are not the same on the managed development database.
+*
+* Every one of the four the help used to lead with — `db push`, `db generate`,
+* `db migrate`, `db branch` — is refused there, by guards in this same file
+* that explain exactly why. So on the project the CLI had just scaffolded, the
+* first thing `rebase db --help` offered was a command that answers with a
+* refusal, and the reader's most likely conclusion is that their install is
+* broken.
+*
+* Exported for its test.
+*/
+function dbExamples(kind) {
+	if (kind === "managed") return `  ${chalk.gray("# Quick development workflow (this project is on the managed database)")}
+  rebase schema generate
+  rebase dev                        ${chalk.gray("# boot applies your collections to it, additively")}
+  rebase db push                    ${chalk.gray("# also drops, renames and narrows columns")}
+
+  ${chalk.gray("# branch needs a Postgres of your own")}
+  rebase dev --docker               ${chalk.gray("# starts one; or uncomment DATABASE_URL in .env")}
+
+`;
+	return `  ${chalk.gray("# Quick development workflow")}
+  rebase schema generate && rebase db push
+
+  ${chalk.gray("# Production migration workflow")}
+  rebase db generate
+  rebase db migrate
+
+  ${chalk.gray("# Create a database branch and work on it")}
+  rebase db branch create feature_auth
+  rebase db branch switch feature_auth
+  rebase db branch switch --off
+
+`;
+}
+//#endregion
+export { DB_SUBCOMMANDS, absolutizeLocalPathArgs, dbCommand, ensureDockerDatabase, argsFromCommand as n, resolveDriverCli, runDriverDbCommand, runDriverSchemaCommand, spawnDriverCli, reportSpawnFailure as t };
+
+//# sourceMappingURL=db-B7RuNuaQ.js.map