@rebasepro/server-postgres 0.25.0-canary.ge06257e → 0.25.0

package/dist/cli-errors.d.ts

@@ -1,3 +1,4 @@
+import { type ProjectPackageManager } from "./cli-helpers.js";
 /**
  * Detect whether an error (or AggregateError wrapping multiple attempts)
  * represents an ECONNREFUSED — i.e. the database is simply not running.
@@ -19,6 +20,16 @@ export declare function isAuthFailure(err: unknown): boolean;
  * with a plain local dev database). The fix is `?sslmode=disable` on the URL.
  */
 export declare function isSslNotEnabled(err: unknown): boolean;
+/**
+ * The database a connection was refused by because it is closed to new
+ * connections (`ALLOW_CONNECTIONS false`), or null.
+ *
+ * Postgres says it as `database "x" is not currently accepting connections`,
+ * SQLSTATE 55000. That code also covers failures that have nothing to do with
+ * connecting (`lastval is not yet defined in this session`), so the sentence is
+ * what is matched, through Drizzle's `cause` and a dual-stack `AggregateError`.
+ */
+export declare function closedDatabaseName(err: unknown): string | null;
 /**
  * Detect PostgreSQL "cannot drop ... because other objects depend on it"
  * (error code 2BP01, dependent_objects_still_exist). This is the failure that
@@ -175,7 +186,7 @@ export declare function notNullColumnIsNew(stderr: string, column: string): bool
 export declare function formatNotNullViolationBanner(violation: {
     table: string;
     column: string;
-}, rowCount: number | null, isNew?: boolean | null): string;
+}, rowCount: number | null, isNew?: boolean | null, manager?: ProjectPackageManager): string;
 /** Atlas refusing to remove a label from an enum — a renamed `enum` option id. */
 export declare function parseEnumLabelDrop(text: string): {
     label: string;

package/dist/{cli-flags-DUozBFyK.js → cli-flags-D-b0qL9T.js}

@@ -140,7 +140,8 @@ function assertKnownFlags(domain, subcommand, args) {
 				...RELAYED_FLAGS,
 				...spec
 			});
-			throw new Error(`${err.message}${suggestion ? ` (did you mean ${suggestion}?)` : ""} — run \`rebase ${domain} --help\` for the options \`${domain} ${subcommand}\` takes.`);
+			const own = Object.keys(spec).filter((flag) => flag.startsWith("--"));
+			throw new Error(`\`rebase ${domain} ${subcommand}\` has no option ${unknown.split("=")[0]}` + (suggestion ? ` — did you mean ${suggestion}?` : ` — it takes ${own.join(", ")}.`) + ` Nothing was run. See \`rebase ${domain} --help\`.`);
 		}
 		throw err;
 	}
@@ -202,4 +203,4 @@ function parseCommandFlags(spec, argv, command) {
 //#endregion
 export { parseCommandFlags as a, collectionsPathIn as i, assertKnownFlags as n, parseDriverLine as o, closestWord as r, RELAYED_FLAGS as t };
 
-//# sourceMappingURL=cli-flags-DUozBFyK.js.map
+//# sourceMappingURL=cli-flags-D-b0qL9T.js.map

package/dist/{cli-flags-DUozBFyK.js.map → cli-flags-D-b0qL9T.js.map}

@@ -1 +1 @@
-{"version":3,"file":"cli-flags-DUozBFyK.js","names":[],"sources":["../src/cli-flags.ts"],"sourcesContent":["/**\n * The flags each driver command takes, in one place, and the check that\n * enforces them.\n *\n * Every parser in `cli.ts` runs `arg(..., { permissive: true })`, which does not\n * mean \"be lenient\" — it means **an undeclared flag becomes a positional**. So\n * `rebase db push --alow-destructive` did not fail: the typo landed in `_`, the\n * push ran with the destructive gate still closed, and the developer read the\n * refusal as Rebase ignoring the flag they had just typed. `rebase schema\n * generate --ouput src/schema.ts` was worse — it wrote the default path and\n * said nothing, so the next build compiled a file nobody had regenerated.\n *\n * The check has to live at the entry point rather than in those parsers, and\n * that is not a detail: `db push` and `db generate` re-enter `schemaCommand`\n * and `generatePostgresDdlCommand` with the *db* line, so a strict parser\n * inside either of them would reject `--allow-destructive` on a line where it\n * is correct. One validation, once, against the spec for the command the user\n * actually named; the inner parsers keep reading an already-validated line.\n *\n * Commands with their own argument handling — `db branch` (`unexpectedBranchArgs`),\n * `db backup`, `db restore`, `db backups` — are deliberately absent: they own\n * their spec, and a second list here would be one more thing to keep in step.\n * An absent entry is \"not checked here\", never \"takes nothing\".\n */\nimport arg from \"arg\";\nimport { suggestNearMiss } from \"@rebasepro/utils\";\n\n/**\n * Flags that reach this process on a line it did not compose.\n *\n * `rebase db …` hands the driver the user's whole line: the CLI *reads*\n * `--database-url` and `--docker` to resolve the database and then relays them\n * verbatim, and `--debug` is what `bin/rebase.js` prints after every failure as\n * the thing to re-run with. Rejecting any of the three would make the driver\n * refuse commands the CLI documents.\n */\nexport const RELAYED_FLAGS = {\n    \"--database-url\": String,\n    \"--docker\": Boolean,\n    \"--debug\": Boolean,\n    \"--help\": Boolean,\n    \"-h\": \"--help\"\n} satisfies arg.Spec;\n\n/**\n * Parse a driver command's line — `[\"db\", \"<subcommand>\", …]` — with the\n * relayed flags declared alongside the command's own.\n *\n * Every driver parser is permissive, and an undeclared flag in a permissive\n * parse is a positional. The positionals are what `db migrate` hands\n * `atlas migrate apply`, what `db generate` names its migration after and\n * which backup `db restore` restores, so a relayed flag left undeclared was\n * read as one of those: `rebase db migrate --docker` died on Atlas's\n * `unknown flag: --docker` after it had already written the auth schema.\n */\nexport function parseDriverLine<S extends arg.Spec>(\n    spec: S,\n    args: string[]\n): arg.Result<typeof RELAYED_FLAGS & S> {\n    return arg({ ...RELAYED_FLAGS, ...spec }, { argv: args.slice(2), permissive: true });\n}\n\n/** Keyed by `\"<domain> <subcommand>\"`, the way the user types it. */\nexport const DRIVER_FLAG_SPECS: Record<string, arg.Spec> = {\n    \"db push\": {\n        \"--collections\": String,\n        \"-c\": \"--collections\",\n        \"--dry-run\": Boolean,\n        \"--allow-destructive\": Boolean,\n        \"--yes\": Boolean,\n        \"-y\": \"--yes\"\n    },\n    \"db generate\": {\n        \"--collections\": String,\n        \"-c\": \"--collections\"\n    },\n    // Bare positionals still pass through to `atlas migrate apply`, which takes\n    // an optional amount; flags do not, apart from `--baseline`.\n    //\n    // `--baseline <version>` is the escape hatch for the normal case, not an\n    // exotic one: every Rebase boot ensures the schema, so a production\n    // database has the tables before its first migration ever runs, and\n    // `migrate apply` then dies on `type \"…\" already exists (42710)`. It maps\n    // onto Atlas's own `migrate apply --baseline`, which writes the revision\n    // row Atlas reads — no ledger of ours.\n    //\n    // `--refuse-destructive` is opt-in: it dry-runs the pending files and exits\n    // 1, applying nothing, when one drops or narrows data — the gate `db push`\n    // has always had, for the path that had none.\n    \"db migrate\": {\n        \"--baseline\": String,\n        \"--refuse-destructive\": Boolean\n    },\n    \"schema generate\": {\n        \"--collections\": String,\n        \"-c\": \"--collections\",\n        \"--output\": String,\n        \"-o\": \"--output\",\n        \"--out\": \"--output\",\n        \"--watch\": Boolean,\n        \"-w\": \"--watch\"\n    },\n    \"schema introspect\": {\n        \"--output\": String,\n        \"-o\": \"--output\",\n        \"--out\": \"--output\",\n        \"--collections\": String,\n        \"-c\": \"--collections\",\n        \"--force\": Boolean,\n        \"-f\": \"--force\",\n        \"--schema\": String,\n        // Whether rows are sampled at all: without a terminal the prompt is\n        // skipped, and the skip line names `--data-inference`.\n        \"--data-inference\": Boolean,\n        \"--no-data-inference\": Boolean\n    },\n    \"schema stale\": {\n        \"--collections\": String,\n        \"-c\": \"--collections\",\n        \"--output\": String,\n        \"-o\": \"--output\",\n        \"--out\": \"--output\",\n        \"--fix\": Boolean\n    }\n};\n\n/**\n * One destination flag, two spellings, everywhere.\n *\n * `--out` is the primary on `rebase build`, an alias on `generate-sdk`, `db\n * backup` and `cloud env pull`, and was refused outright by the three `schema`\n * commands — so the spelling a user learned on one command was an\n * \"unknown or unexpected option\" on the next. Neither name can be retired (both\n * are shipped), so both are accepted, and {@link assertOutputAliasesPaired}\n * makes that the rule rather than a habit.\n */\nexport const OUTPUT_FLAG_ALIASES = [\"--out\", \"--output\"] as const;\n\n/**\n * Every spec that names one of the pair names both.\n *\n * Exported so the CLI's own specs can be held to it too: the drift this fixes\n * ran across two packages, and a check that only reads this file would let the\n * next `--out`-only command through.\n */\nexport function assertOutputAliasesPaired(specs: Record<string, arg.Spec>): string[] {\n    const problems: string[] = [];\n    for (const [command, spec] of Object.entries(specs)) {\n        const present = OUTPUT_FLAG_ALIASES.filter(flag => flag in spec);\n        if (present.length === 0 || present.length === OUTPUT_FLAG_ALIASES.length) continue;\n        const missing = OUTPUT_FLAG_ALIASES.filter(flag => !(flag in spec));\n        problems.push(`\\`${command}\\` takes ${present.join(\", \")} but not ${missing.join(\", \")}`);\n    }\n    return problems;\n}\n\n/**\n * The `--collections` path the user typed, or `null` if they typed none.\n *\n * Read once, at the entry point, because every command that takes it re-enters\n * the generators with the same line and each of them resolved it again — which\n * is how \"Collections path not found\" came to be printed four times before the\n * real output, and how a path that does not exist got as far as *writing* an\n * empty schema.\n *\n * Permissive, and it has to be: {@link assertKnownFlags} has already judged the\n * line, and `db push` carries flags the `--collections` spec does not name.\n */\nexport function collectionsPathIn(args: string[]): string | null {\n    try {\n        const parsed = arg(\n            { \"--collections\": String, \"-c\": \"--collections\" },\n            { argv: args.slice(2), permissive: true }\n        );\n\n        return parsed[\"--collections\"] ?? null;\n    } catch {\n        return null;\n    }\n}\n\n/**\n * The long flags a `--help` usage line documents.\n *\n * `\"rebase db push [--collections <dir>] [--dry-run] …\"` → `[\"--collections\",\n * \"--dry-run\"]`. Placeholders (`<dir>`) and the alternation inside a positional\n * (`<create|list|switch>`) are not flags and are not returned.\n */\nexport function flagsInUsage(usage: string): string[] {\n    return [...new Set(usage.match(/--[a-z][a-z0-9-]*/g) ?? [])];\n}\n\n/**\n * Every flag the help documents is accepted, and every flag accepted is documented.\n *\n * The drift this catches shipped: `rebase db push --help` has printed\n * `[--dry-run]` since the flag was written, `DRIVER_FLAG_SPECS[\"db push\"]` never\n * listed it, and {@link assertKnownFlags} — added later to stop typos being\n * swallowed — turned the documented flag into `unknown or unexpected option`.\n * The only way to see a push's SQL was to trip the destructive gate, which is\n * the exact problem `--dry-run` was written to solve. Worse in a project on an\n * older driver, whose permissive parser *applied* the schema on that line.\n *\n * Two hand-maintained lists in two packages cannot be kept in step by care, so\n * they are held to each other instead: `usages` is keyed the way\n * {@link DRIVER_FLAG_SPECS} is (`\"db push\"`), and comes from the CLI's own help\n * pages. A key in only one of the two is not this function's business — the\n * help covers commands that parse their own lines (`db branch`, `db backup`),\n * and an absent spec entry means \"not checked here\".\n *\n * Aliases (`\"-c\": \"--collections\"`, `\"--out\": \"--output\"`) need no line of their\n * own: they are spellings of a documented flag. Neither do {@link RELAYED_FLAGS},\n * which every driver command accepts because the CLI relays them.\n */\nexport function assertSpecMatchesUsage(\n    specs: Record<string, arg.Spec>,\n    usages: Record<string, string>\n): string[] {\n    const problems: string[] = [];\n    for (const [command, spec] of Object.entries(specs)) {\n        const usage = usages[command];\n        if (usage === undefined) continue;\n\n        const documented = flagsInUsage(usage);\n        const accepted = Object.entries(spec);\n        // An alias resolves to the flag it spells; only the target needs a line.\n        const canonical = new Set(\n            accepted\n                .map(([flag, kind]) => (typeof kind === \"string\" ? kind : flag))\n                .filter(flag => flag.startsWith(\"--\"))\n        );\n\n        for (const flag of documented) {\n            if (flag in spec || flag in RELAYED_FLAGS) continue;\n            problems.push(`\\`${command}\\` documents ${flag} in its usage line but the spec rejects it`);\n        }\n        for (const flag of canonical) {\n            if (documented.includes(flag) || flag in RELAYED_FLAGS) continue;\n            problems.push(`\\`${command}\\` accepts ${flag} but no usage line documents it`);\n        }\n    }\n    return problems;\n}\n\n/**\n * Reject a flag the named command does not take.\n *\n * `args` is the driver's whole line — `[\"db\", \"push\", …]` — so the flags are\n * read from `args.slice(2)`, past the two command words.\n *\n * Throws rather than exiting: `runPluginCommand`'s caller already turns a\n * thrown error into one red line and exit 1, and a thrown error is what the\n * tests can see.\n */\nexport function assertKnownFlags(domain: string, subcommand: string | undefined, args: string[]): void {\n    if (!subcommand) return;\n    const spec = DRIVER_FLAG_SPECS[`${domain} ${subcommand}`];\n    if (!spec) return;\n\n    try {\n        arg({ ...RELAYED_FLAGS, ...spec }, { argv: args.slice(2) });\n    } catch (err) {\n        const unknown = unknownFlagIn(err);\n        if (unknown !== null && err instanceof Error) {\n            const suggestion = closestFlag(unknown, { ...RELAYED_FLAGS, ...spec });\n            throw new Error(\n                `${err.message}${suggestion ? ` (did you mean ${suggestion}?)` : \"\"} — run ` +\n                `\\`rebase ${domain} --help\\` for the options \\`${domain} ${subcommand}\\` takes.`\n            );\n        }\n        throw err;\n    }\n}\n\n/** The flag `arg` refused as undeclared, or `null` for any other failure. */\nfunction unknownFlagIn(err: unknown): string | null {\n    if (!(err instanceof Error) || !(\"code\" in err) || err.code !== \"ARG_UNKNOWN_OPTION\") return null;\n    // arg's wording: `unknown or unexpected option: --targt-db`.\n    return /option: (\\S+)$/.exec(err.message)?.[1] ?? null;\n}\n\n/** The declared long flag `typed` is one edit or one swap away from, if there is one. */\nfunction closestFlag(typed: string, spec: arg.Spec): string | undefined {\n    const name = typed.split(\"=\")[0];\n    return closestWord(name, Object.keys(spec).filter(flag => flag.startsWith(\"--\")));\n}\n\n/**\n * The word in `known` that `typed` was probably meant to be: one edit away\n * (`--targt-db`), or two neighbouring letters swapped (`--clena`, `--froce`),\n * which `suggestNearMiss` counts as two edits and so never offers.\n */\nexport function closestWord(typed: string, known: readonly string[]): string | undefined {\n    return suggestNearMiss(known, typed) ?? transposedFrom(known, typed);\n}\n\nfunction transposedFrom(known: readonly string[], typed: string): string | undefined {\n    return known.find((candidate) => {\n        if (candidate.length !== typed.length || candidate === typed) return false;\n        const differ = [...candidate].flatMap((letter, index) => (letter === typed[index] ? [] : [index]));\n        return differ.length === 2 && differ[1] === differ[0] + 1\n            && candidate[differ[0]] === typed[differ[1]] && candidate[differ[1]] === typed[differ[0]];\n    });\n}\n\n/**\n * Parse a command that owns its argument handling, refusing what it does not\n * declare.\n *\n * `db backup`, `db restore` and `db backups list` parsed permissively, so an\n * undeclared flag became a positional and was ignored: `db restore <dump>\n * --targt-db x --create-db --yes` dropped the misspelled target and restored\n * into the live database. A typo is refused here before anything runs, naming\n * the declared flag it is one edit from, or every flag the command takes when\n * none is that close.\n *\n * @param argv the words after the command, e.g. `rawArgs.slice(2)`.\n * @param command the command as typed, for the message: `\"db restore\"`.\n */\nexport function parseCommandFlags<S extends arg.Spec>(\n    spec: S,\n    argv: string[],\n    command: string\n): arg.Result<typeof RELAYED_FLAGS & S> {\n    const full = { ...RELAYED_FLAGS, ...spec };\n    try {\n        return arg(full, { argv });\n    } catch (err) {\n        const unknown = unknownFlagIn(err);\n        if (unknown === null) throw err;\n        const suggestion = closestFlag(unknown, full);\n        const flags = Object.keys(spec).filter(flag => flag.startsWith(\"--\"));\n        throw new Error(\n            `\\`rebase ${command}\\` has no option ${unknown}` +\n            (suggestion ? ` — did you mean ${suggestion}?` : ` — it takes ${flags.join(\", \")}.`) +\n            ` Nothing was run. See \\`rebase ${command} --help\\`.`\n        );\n    }\n}\n"],"mappings":"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"}
+{"version":3,"file":"cli-flags-D-b0qL9T.js","names":[],"sources":["../src/cli-flags.ts"],"sourcesContent":["/**\n * The flags each driver command takes, in one place, and the check that\n * enforces them.\n *\n * Every parser in `cli.ts` runs `arg(..., { permissive: true })`, which does not\n * mean \"be lenient\" — it means **an undeclared flag becomes a positional**. So\n * `rebase db push --alow-destructive` did not fail: the typo landed in `_`, the\n * push ran with the destructive gate still closed, and the developer read the\n * refusal as Rebase ignoring the flag they had just typed. `rebase schema\n * generate --ouput src/schema.ts` was worse — it wrote the default path and\n * said nothing, so the next build compiled a file nobody had regenerated.\n *\n * The check has to live at the entry point rather than in those parsers, and\n * that is not a detail: `db push` and `db generate` re-enter `schemaCommand`\n * and `generatePostgresDdlCommand` with the *db* line, so a strict parser\n * inside either of them would reject `--allow-destructive` on a line where it\n * is correct. One validation, once, against the spec for the command the user\n * actually named; the inner parsers keep reading an already-validated line.\n *\n * Commands with their own argument handling — `db branch` (`unexpectedBranchArgs`),\n * `db backup`, `db restore`, `db backups` — are deliberately absent: they own\n * their spec, and a second list here would be one more thing to keep in step.\n * An absent entry is \"not checked here\", never \"takes nothing\".\n */\nimport arg from \"arg\";\nimport { suggestNearMiss } from \"@rebasepro/utils\";\n\n/**\n * Flags that reach this process on a line it did not compose.\n *\n * `rebase db …` hands the driver the user's whole line: the CLI *reads*\n * `--database-url` and `--docker` to resolve the database and then relays them\n * verbatim, and `--debug` is what `bin/rebase.js` prints after every failure as\n * the thing to re-run with. Rejecting any of the three would make the driver\n * refuse commands the CLI documents.\n */\nexport const RELAYED_FLAGS = {\n    \"--database-url\": String,\n    \"--docker\": Boolean,\n    \"--debug\": Boolean,\n    \"--help\": Boolean,\n    \"-h\": \"--help\"\n} satisfies arg.Spec;\n\n/**\n * Parse a driver command's line — `[\"db\", \"<subcommand>\", …]` — with the\n * relayed flags declared alongside the command's own.\n *\n * Every driver parser is permissive, and an undeclared flag in a permissive\n * parse is a positional. The positionals are what `db migrate` hands\n * `atlas migrate apply`, what `db generate` names its migration after and\n * which backup `db restore` restores, so a relayed flag left undeclared was\n * read as one of those: `rebase db migrate --docker` died on Atlas's\n * `unknown flag: --docker` after it had already written the auth schema.\n */\nexport function parseDriverLine<S extends arg.Spec>(\n    spec: S,\n    args: string[]\n): arg.Result<typeof RELAYED_FLAGS & S> {\n    return arg({ ...RELAYED_FLAGS, ...spec }, { argv: args.slice(2), permissive: true });\n}\n\n/** Keyed by `\"<domain> <subcommand>\"`, the way the user types it. */\nexport const DRIVER_FLAG_SPECS: Record<string, arg.Spec> = {\n    \"db push\": {\n        \"--collections\": String,\n        \"-c\": \"--collections\",\n        \"--dry-run\": Boolean,\n        \"--allow-destructive\": Boolean,\n        \"--yes\": Boolean,\n        \"-y\": \"--yes\"\n    },\n    \"db generate\": {\n        \"--collections\": String,\n        \"-c\": \"--collections\"\n    },\n    // Bare positionals still pass through to `atlas migrate apply`, which takes\n    // an optional amount; flags do not, apart from `--baseline`.\n    //\n    // `--baseline <version>` is the escape hatch for the normal case, not an\n    // exotic one: every Rebase boot ensures the schema, so a production\n    // database has the tables before its first migration ever runs, and\n    // `migrate apply` then dies on `type \"…\" already exists (42710)`. It maps\n    // onto Atlas's own `migrate apply --baseline`, which writes the revision\n    // row Atlas reads — no ledger of ours.\n    //\n    // `--refuse-destructive` is opt-in: it dry-runs the pending files and exits\n    // 1, applying nothing, when one drops or narrows data — the gate `db push`\n    // has always had, for the path that had none.\n    \"db migrate\": {\n        \"--baseline\": String,\n        \"--refuse-destructive\": Boolean\n    },\n    \"schema generate\": {\n        \"--collections\": String,\n        \"-c\": \"--collections\",\n        \"--output\": String,\n        \"-o\": \"--output\",\n        \"--out\": \"--output\",\n        \"--watch\": Boolean,\n        \"-w\": \"--watch\"\n    },\n    \"schema introspect\": {\n        \"--output\": String,\n        \"-o\": \"--output\",\n        \"--out\": \"--output\",\n        \"--collections\": String,\n        \"-c\": \"--collections\",\n        \"--force\": Boolean,\n        \"-f\": \"--force\",\n        \"--schema\": String,\n        // Whether rows are sampled at all: without a terminal the prompt is\n        // skipped, and the skip line names `--data-inference`.\n        \"--data-inference\": Boolean,\n        \"--no-data-inference\": Boolean\n    },\n    \"schema stale\": {\n        \"--collections\": String,\n        \"-c\": \"--collections\",\n        \"--output\": String,\n        \"-o\": \"--output\",\n        \"--out\": \"--output\",\n        \"--fix\": Boolean\n    }\n};\n\n/**\n * One destination flag, two spellings, everywhere.\n *\n * `--out` is the primary on `rebase build`, an alias on `generate-sdk`, `db\n * backup` and `cloud env pull`, and was refused outright by the three `schema`\n * commands — so the spelling a user learned on one command was an\n * \"unknown or unexpected option\" on the next. Neither name can be retired (both\n * are shipped), so both are accepted, and {@link assertOutputAliasesPaired}\n * makes that the rule rather than a habit.\n */\nexport const OUTPUT_FLAG_ALIASES = [\"--out\", \"--output\"] as const;\n\n/**\n * Every spec that names one of the pair names both.\n *\n * Exported so the CLI's own specs can be held to it too: the drift this fixes\n * ran across two packages, and a check that only reads this file would let the\n * next `--out`-only command through.\n */\nexport function assertOutputAliasesPaired(specs: Record<string, arg.Spec>): string[] {\n    const problems: string[] = [];\n    for (const [command, spec] of Object.entries(specs)) {\n        const present = OUTPUT_FLAG_ALIASES.filter(flag => flag in spec);\n        if (present.length === 0 || present.length === OUTPUT_FLAG_ALIASES.length) continue;\n        const missing = OUTPUT_FLAG_ALIASES.filter(flag => !(flag in spec));\n        problems.push(`\\`${command}\\` takes ${present.join(\", \")} but not ${missing.join(\", \")}`);\n    }\n    return problems;\n}\n\n/**\n * The `--collections` path the user typed, or `null` if they typed none.\n *\n * Read once, at the entry point, because every command that takes it re-enters\n * the generators with the same line and each of them resolved it again — which\n * is how \"Collections path not found\" came to be printed four times before the\n * real output, and how a path that does not exist got as far as *writing* an\n * empty schema.\n *\n * Permissive, and it has to be: {@link assertKnownFlags} has already judged the\n * line, and `db push` carries flags the `--collections` spec does not name.\n */\nexport function collectionsPathIn(args: string[]): string | null {\n    try {\n        const parsed = arg(\n            { \"--collections\": String, \"-c\": \"--collections\" },\n            { argv: args.slice(2), permissive: true }\n        );\n\n        return parsed[\"--collections\"] ?? null;\n    } catch {\n        return null;\n    }\n}\n\n/**\n * The long flags a `--help` usage line documents.\n *\n * `\"rebase db push [--collections <dir>] [--dry-run] …\"` → `[\"--collections\",\n * \"--dry-run\"]`. Placeholders (`<dir>`) and the alternation inside a positional\n * (`<create|list|switch>`) are not flags and are not returned.\n */\nexport function flagsInUsage(usage: string): string[] {\n    return [...new Set(usage.match(/--[a-z][a-z0-9-]*/g) ?? [])];\n}\n\n/**\n * Every flag the help documents is accepted, and every flag accepted is documented.\n *\n * The drift this catches shipped: `rebase db push --help` has printed\n * `[--dry-run]` since the flag was written, `DRIVER_FLAG_SPECS[\"db push\"]` never\n * listed it, and {@link assertKnownFlags} — added later to stop typos being\n * swallowed — turned the documented flag into `unknown or unexpected option`.\n * The only way to see a push's SQL was to trip the destructive gate, which is\n * the exact problem `--dry-run` was written to solve. Worse in a project on an\n * older driver, whose permissive parser *applied* the schema on that line.\n *\n * Two hand-maintained lists in two packages cannot be kept in step by care, so\n * they are held to each other instead: `usages` is keyed the way\n * {@link DRIVER_FLAG_SPECS} is (`\"db push\"`), and comes from the CLI's own help\n * pages. A key in only one of the two is not this function's business — the\n * help covers commands that parse their own lines (`db branch`, `db backup`),\n * and an absent spec entry means \"not checked here\".\n *\n * Aliases (`\"-c\": \"--collections\"`, `\"--out\": \"--output\"`) need no line of their\n * own: they are spellings of a documented flag. Neither do {@link RELAYED_FLAGS},\n * which every driver command accepts because the CLI relays them.\n */\nexport function assertSpecMatchesUsage(\n    specs: Record<string, arg.Spec>,\n    usages: Record<string, string>\n): string[] {\n    const problems: string[] = [];\n    for (const [command, spec] of Object.entries(specs)) {\n        const usage = usages[command];\n        if (usage === undefined) continue;\n\n        const documented = flagsInUsage(usage);\n        const accepted = Object.entries(spec);\n        // An alias resolves to the flag it spells; only the target needs a line.\n        const canonical = new Set(\n            accepted\n                .map(([flag, kind]) => (typeof kind === \"string\" ? kind : flag))\n                .filter(flag => flag.startsWith(\"--\"))\n        );\n\n        for (const flag of documented) {\n            if (flag in spec || flag in RELAYED_FLAGS) continue;\n            problems.push(`\\`${command}\\` documents ${flag} in its usage line but the spec rejects it`);\n        }\n        for (const flag of canonical) {\n            if (documented.includes(flag) || flag in RELAYED_FLAGS) continue;\n            problems.push(`\\`${command}\\` accepts ${flag} but no usage line documents it`);\n        }\n    }\n    return problems;\n}\n\n/**\n * Reject a flag the named command does not take.\n *\n * `args` is the driver's whole line — `[\"db\", \"push\", …]` — so the flags are\n * read from `args.slice(2)`, past the two command words.\n *\n * Throws rather than exiting: `runPluginCommand`'s caller already turns a\n * thrown error into one red line and exit 1, and a thrown error is what the\n * tests can see.\n */\nexport function assertKnownFlags(domain: string, subcommand: string | undefined, args: string[]): void {\n    if (!subcommand) return;\n    const spec = DRIVER_FLAG_SPECS[`${domain} ${subcommand}`];\n    if (!spec) return;\n\n    try {\n        arg({ ...RELAYED_FLAGS, ...spec }, { argv: args.slice(2) });\n    } catch (err) {\n        const unknown = unknownFlagIn(err);\n        if (unknown !== null && err instanceof Error) {\n            // In the words `parseCommandFlags` and the CLI's own parser use.\n            const suggestion = closestFlag(unknown, { ...RELAYED_FLAGS, ...spec });\n            const own = Object.keys(spec).filter(flag => flag.startsWith(\"--\"));\n            throw new Error(\n                `\\`rebase ${domain} ${subcommand}\\` has no option ${unknown.split(\"=\")[0]}` +\n                (suggestion ? ` — did you mean ${suggestion}?` : ` — it takes ${own.join(\", \")}.`) +\n                ` Nothing was run. See \\`rebase ${domain} --help\\`.`\n            );\n        }\n        throw err;\n    }\n}\n\n/** The flag `arg` refused as undeclared, or `null` for any other failure. */\nfunction unknownFlagIn(err: unknown): string | null {\n    if (!(err instanceof Error) || !(\"code\" in err) || err.code !== \"ARG_UNKNOWN_OPTION\") return null;\n    // arg's wording: `unknown or unexpected option: --targt-db`.\n    return /option: (\\S+)$/.exec(err.message)?.[1] ?? null;\n}\n\n/** The declared long flag `typed` is one edit or one swap away from, if there is one. */\nfunction closestFlag(typed: string, spec: arg.Spec): string | undefined {\n    const name = typed.split(\"=\")[0];\n    return closestWord(name, Object.keys(spec).filter(flag => flag.startsWith(\"--\")));\n}\n\n/**\n * The word in `known` that `typed` was probably meant to be: one edit away\n * (`--targt-db`), or two neighbouring letters swapped (`--clena`, `--froce`),\n * which `suggestNearMiss` counts as two edits and so never offers.\n */\nexport function closestWord(typed: string, known: readonly string[]): string | undefined {\n    return suggestNearMiss(known, typed) ?? transposedFrom(known, typed);\n}\n\nfunction transposedFrom(known: readonly string[], typed: string): string | undefined {\n    return known.find((candidate) => {\n        if (candidate.length !== typed.length || candidate === typed) return false;\n        const differ = [...candidate].flatMap((letter, index) => (letter === typed[index] ? [] : [index]));\n        return differ.length === 2 && differ[1] === differ[0] + 1\n            && candidate[differ[0]] === typed[differ[1]] && candidate[differ[1]] === typed[differ[0]];\n    });\n}\n\n/**\n * Parse a command that owns its argument handling, refusing what it does not\n * declare.\n *\n * `db backup`, `db restore` and `db backups list` parsed permissively, so an\n * undeclared flag became a positional and was ignored: `db restore <dump>\n * --targt-db x --create-db --yes` dropped the misspelled target and restored\n * into the live database. A typo is refused here before anything runs, naming\n * the declared flag it is one edit from, or every flag the command takes when\n * none is that close.\n *\n * @param argv the words after the command, e.g. `rawArgs.slice(2)`.\n * @param command the command as typed, for the message: `\"db restore\"`.\n */\nexport function parseCommandFlags<S extends arg.Spec>(\n    spec: S,\n    argv: string[],\n    command: string\n): arg.Result<typeof RELAYED_FLAGS & S> {\n    const full = { ...RELAYED_FLAGS, ...spec };\n    try {\n        return arg(full, { argv });\n    } catch (err) {\n        const unknown = unknownFlagIn(err);\n        if (unknown === null) throw err;\n        const suggestion = closestFlag(unknown, full);\n        const flags = Object.keys(spec).filter(flag => flag.startsWith(\"--\"));\n        throw new Error(\n            `\\`rebase ${command}\\` has no option ${unknown}` +\n            (suggestion ? ` — did you mean ${suggestion}?` : ` — it takes ${flags.join(\", \")}.`) +\n            ` Nothing was run. See \\`rebase ${command} --help\\`.`\n        );\n    }\n}\n"],"mappings":"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"}

package/dist/cli.js

@@ -1,12 +1,12 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
 import { i as __toESM } from "./rolldown-runtime-V7rFbMRe.js";
-import { $ as redactConnectionPasswords, A as getVectorExcludes, B as workspaceMemberDir, C as dropGeneratedColumns, D as getTableExcludes, E as getSearchExcludes, F as readSearchDdl, G as decidePushSafety, H as GENERATED_SQL_DIR, I as readTriggersDdl, J as extractPlanStatements, K as destructiveOptInFlag, L as readVectorDdl, M as queryColumnTypes, N as queryGeneratedColumnDependencies, O as getTriggerExcludes, P as queryUndeclarableConstraints, R as resolveLocalBin, S as dropDevDatabase, T as getForeignIndexExcludes, U as generatedSqlDir, V as DESIRED_STATE_URL, W as prepareGeneratedSqlDir, X as isSyncedPlan, Y as fromAlterTable, Z as forAtlas, _ as describeBuildScriptRemedy, a as formatForeignGeneratedColumnBanner, b as detectProjectPackageManager, c as isSslNotEnabled, d as ExcludeIntrospectionError, f as applySearchDdl, g as closeAppClients, h as atlasDevDatabaseUrl, i as diagnoseDbError, j as loadCollectionsForCli, k as getUndeclaredConstraintExcludes, m as applyVectorDdl, o as isAuthFailure, p as applyTriggersDdl, q as detectDestructiveStatements, r as diagnoseAtlasFailure, s as isEconnrefused, t as checkDatabaseConnectivity, u as reportCommandFailure, v as describeDevAddCommand, w as ensureDevDatabaseExists, x as diagnoseMissingBin, y as describeReinstallCommand, z as withAppClient } from "./cli-errors-mx4sSjB8.js";
-import { a as outWarn, i as outError, o as atlasExcludePattern, r as out, s as excludePatternParts, t as chalk } from "./source-DB6xJv3p.js";
-import { t as nextStepAfterDbGenerate } from "./generate-next-step-DCd7yiJ2.js";
+import { A as getUndeclaredConstraintExcludes, B as withAppClient, C as dropDevDatabase, D as getSearchExcludes, E as getForeignIndexExcludes, F as queryUndeclarableConstraints, G as prepareGeneratedSqlDir, H as DESIRED_STATE_URL, I as readSearchDdl, J as detectDestructiveStatements, K as decidePushSafety, L as readTriggersDdl, M as loadCollectionsForCli, N as queryColumnTypes, O as getTableExcludes, P as queryGeneratedColumnDependencies, Q as forAtlas, R as readVectorDdl, S as diagnoseMissingBin, T as ensureDevDatabaseExists, U as GENERATED_SQL_DIR, V as workspaceMemberDir, W as generatedSqlDir, X as fromAlterTable, Y as extractPlanStatements, Z as isSyncedPlan, _ as closeAppClients, a as diagnoseDbError, b as describeReinstallCommand, c as isEconnrefused, d as reportCommandFailure, et as redactConnectionPasswords, f as ExcludeIntrospectionError, g as atlasDevDatabaseUrl, h as applyVectorDdl, i as diagnoseAtlasFailure, j as getVectorExcludes, k as getTriggerExcludes, l as isSslNotEnabled, m as applyTriggersDdl, o as formatForeignGeneratedColumnBanner, p as applySearchDdl, q as destructiveOptInFlag, s as isAuthFailure, t as checkDatabaseConnectivity, v as describeBuildScriptRemedy, w as dropGeneratedColumns, x as detectProjectPackageManager, y as describeDevAddCommand, z as resolveLocalBin } from "./cli-errors-DwQnNATs.js";
+import { a as outWarn, i as outError, o as atlasExcludePattern, r as out, s as excludePatternParts, t as chalk } from "./source-Bv5KPeIx.js";
+import { t as nextStepAfterDbGenerate } from "./generate-next-step-DCeS4LrJ.js";
 import { o as execa, r as dropLegacyAuthSchema, t as RLS_BOOTSTRAP_SQL } from "./rls-bootstrap-sql-Bd-hJk08.js";
 import { n as require_arg, t as promptConfirm } from "./cli-prompt-egtNKkZl.js";
-import { i as collectionsPathIn, n as assertKnownFlags, o as parseDriverLine, r as closestWord, t as RELAYED_FLAGS } from "./cli-flags-DUozBFyK.js";
+import { i as collectionsPathIn, n as assertKnownFlags, o as parseDriverLine, r as closestWord, t as RELAYED_FLAGS } from "./cli-flags-D-b0qL9T.js";
 import { formatRelativeTime } from "@rebasepro/utils";
 import path from "path";
 import fs from "fs";
@@ -656,7 +656,9 @@ function readsRevisions(domain, args) {
 * all of them, so it excludes no one; what it does cost there is a connection.
 * The managed database accepts four and a running `rebase dev` holds two, so
 * `migrate apply`'s third — its own, the lock's, the revisions table's — was
-* closed unanswered and Atlas said only `Error: EOF`.
+* closed unanswered and Atlas said only `Error: EOF`. `migrate set`, which has
+* no `--skip-lock`, is bound to the revisions schema instead, which spares it
+* the revisions table's connection.
 */
 function buildAtlasArgs(invocation) {
 	const { domain, args, url, devUrl, excludes = [], singleSession = false } = invocation;
@@ -666,6 +668,7 @@ function buildAtlasArgs(invocation) {
 		else if (args.includes("clean") || args.includes("inspect")) argv.push("--url", url);
 	} else if (domain === "migrate") {
 		if (args.includes("diff")) argv.push("--dev-url", devUrl);
+		else if (args.includes("set") && singleSession) argv.push("--url", withSearchPath(url, "rebase"));
 		else if (readsRevisions(domain, args)) {
 			argv.push("--url", url, "--revisions-schema", "rebase");
 			if (args.includes("apply") && !args.includes("--baseline")) argv.push("--allow-dirty");
@@ -676,6 +679,23 @@ function buildAtlasArgs(invocation) {
 	return argv;
 }
 /**
+* The URL with its `search_path` set to `schema`: an Atlas URL bound to that
+* schema. Every other parameter is kept as written. A URL that does not
+* parse is returned unchanged.
+*/
+function withSearchPath(url, schema) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return url;
+	}
+	const params = Array.from(parsed.searchParams.entries()).filter(([key]) => key !== "search_path");
+	params.push(["search_path", schema]);
+	parsed.search = params.map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+	return parsed.toString();
+}
+/**
 * `atlas migrate apply`'s own arguments for `rebase db migrate`.
 *
 * `positionals` are what is left of the user's line once every flag the
@@ -1252,6 +1272,13 @@ function backupActionOf(rawArgs) {
 }
 //#endregion
 //#region src/branch-prune.ts
+/**
+* The variable the CLI hands the driver the database its checkout is switched
+* to in. The pointer is the CLI's (`dev-db/branch-pointer.ts`); the driver is
+* a child process that cannot read it. Spelled the same in
+* `packages/cli/src/commands/db.ts`.
+*/
+var ACTIVE_BRANCH_DATABASE_ENV = "REBASE_ACTIVE_BRANCH_DATABASE";
 /** True when nothing at all needs doing. */
 function planIsEmpty(plan, includeDevDiff) {
 	return plan.staleRows.length === 0 && plan.orphanDatabases.length === 0 && plan.expired.length === 0 && (!includeDevDiff || plan.devDiff.length === 0);
@@ -1284,14 +1311,31 @@ function planPrune(input, options = {}) {
 	const now = options.now ?? /* @__PURE__ */ new Date();
 	const present = new Set(input.databases);
 	const registered = new Set(input.rows.map((row) => row.dbName));
+	const isActive = (database) => options.activeDatabase != null && database === options.activeDatabase;
+	let active = null;
 	return {
 		staleRows: input.rows.filter((row) => !present.has(row.dbName)),
-		orphanDatabases: input.databases.filter((name) => name.startsWith(input.branchPrefix) && !registered.has(name)).sort(),
+		orphanDatabases: input.databases.filter((name) => name.startsWith(input.branchPrefix) && !registered.has(name)).filter((name) => {
+			if (!isActive(name)) return true;
+			active = {
+				name,
+				database: name
+			};
+			return false;
+		}).sort(),
 		expired: options.olderThanDays == null ? [] : input.rows.filter((row) => present.has(row.dbName)).map((branch) => ({
 			branch,
 			ageDays: ageInDays(branch.createdAt, now)
-		})).filter((entry) => entry.ageDays >= options.olderThanDays).sort((a, b) => b.ageDays - a.ageDays),
-		devDiff: input.databases.filter((name) => name.endsWith("_dev_diff")).sort()
+		})).filter((entry) => entry.ageDays >= options.olderThanDays).filter((entry) => {
+			if (!isActive(entry.branch.dbName)) return true;
+			active = {
+				name: entry.branch.name,
+				database: entry.branch.dbName
+			};
+			return false;
+		}).sort((a, b) => b.ageDays - a.ageDays),
+		devDiff: input.databases.filter((name) => name.endsWith("_dev_diff")).sort(),
+		active
 	};
 }
 //#endregion
@@ -1382,7 +1426,7 @@ function generatesInProcess() {
 async function generateInProcess(what, label, run) {
 	let generators;
 	try {
-		generators = await import("./generate-files-D50Pxw1G.js").then((n) => n.t);
+		generators = await import("./generate-files-ClmOUHXj.js").then((n) => n.t);
 	} catch (err) {
 		outError(chalk.red(`✗ Failed to run ${what}: ${err instanceof Error ? err.message : String(err)}`));
 		process.exit(1);
@@ -1428,7 +1472,7 @@ async function runPluginCommand(args) {
 		else if (domain === "schema") await schemaCommand(subcommand, args);
 		else if (domain === "doctor") await doctorPluginCommand(args);
 		else if (domain === "console") {
-			const { consoleCommand } = await import("./cli-console-C_ISGwJo.js");
+			const { consoleCommand } = await import("./cli-console-DQ_K-sdM.js");
 			process.exitCode = await consoleCommand(args);
 		} else {
 			outError(chalk.red(`Unknown domain command: ${domain}`));
@@ -1604,7 +1648,7 @@ async function dbCommand(subcommand, rawArgs) {
 		return;
 	}
 	if (subcommand === "backup" || subcommand === "restore" || subcommand === "backups") {
-		const { backupCommand, restoreCommand, backupsCommand } = await import("./backup-cli-HCEkPcQj.js");
+		const { backupCommand, restoreCommand, backupsCommand } = await import("./backup-cli-B2CAn9fR.js");
 		if (subcommand === "backup" && backupActionOf(rawArgs) === "list") await backupsCommand(rawArgs);
 		else if (subcommand === "backup") await backupCommand(rawArgs);
 		else if (subcommand === "restore") await restoreCommand(rawArgs);
@@ -1651,7 +1695,7 @@ async function dbCommand(subcommand, rawArgs) {
 				}
 				const searchContent = readSearchDdl();
 				if (searchContent) {
-					const { searchColumnDependencies } = await import("./generate-postgres-ddl-logic-B4k9djAV.js").then((n) => n.o);
+					const { searchColumnDependencies } = await import("./generate-postgres-ddl-logic-4eUP4t8w.js").then((n) => n.o);
 					const migrationConflicts = findGeneratedColumnConflicts(parseColumnMutations(migrationContent), searchColumnDependencies(await loadCollectionsForCli(collectionsPath)));
 					const preamble = migrationDropPreamble(migrationConflicts);
 					if (preamble) {
@@ -1699,9 +1743,14 @@ async function dbCommand(subcommand, rawArgs) {
     Search, vector, trigger and RLS DDL are applied by \`rebase db push\`, and at
     boot by the schema ensure. For a migration-only deployment, add
     ${GENERATED_SQL_DIR}/search.sql, vector.sql, triggers.sql and\n    policies.sql to a migration by hand.`));
+		const nextStep = nextStepAfterDbGenerate({
+			newestVersion: latestMigrationVersion(),
+			wrote: wroteNewMigration,
+			first: migrationsBefore.length === 0
+		});
 		out("");
-		for (const line of nextStepAfterDbGenerate(latestMigrationVersion())) out(line);
-		out("");
+		for (const line of nextStep) out(line);
+		if (nextStep.length > 0) out("");
 	} else {
 		out("");
 		out(chalk.bold(`  🗄️  Rebase DB ${subcommand.charAt(0).toUpperCase() + subcommand.slice(1)}`));
@@ -1930,8 +1979,8 @@ async function dbCommand(subcommand, rawArgs) {
 async function renameLegacyForeignKeys(databaseUrl, collectionsPath, dryRun) {
 	let renames;
 	try {
-		const { loadCollections } = await import("./doctor-CJyuhV1n.js").then((n) => n.t);
-		const { legacyForeignKeyRenames } = await import("./push-legacy-renames-D4bvMWAb.js");
+		const { loadCollections } = await import("./doctor-DvJH-IQG.js").then((n) => n.t);
+		const { legacyForeignKeyRenames } = await import("./push-legacy-renames-BqJut4F3.js");
 		const collections = await loadCollections(path.resolve(process.cwd(), collectionsPath));
 		renames = await withAppClient(databaseUrl, (client) => legacyForeignKeyRenames({ query: async (text) => ({ rows: (await client.query(text)).rows }) }, collections));
 	} catch {
@@ -1950,8 +1999,8 @@ async function renameLegacyForeignKeys(databaseUrl, collectionsPath, dryRun) {
 /** Names the enum labels the database keeps after the collections dropped them. See `schema/enum-labels-kept.ts`. */
 async function reportKeptEnumLabels(databaseUrl, collectionsPath) {
 	try {
-		const { loadCollections } = await import("./doctor-CJyuhV1n.js").then((n) => n.t);
-		const { keptEnumLabels, formatKeptEnumLabelsNotice } = await import("./enum-labels-kept-D9eTIWCz.js");
+		const { loadCollections } = await import("./doctor-DvJH-IQG.js").then((n) => n.t);
+		const { keptEnumLabels, formatKeptEnumLabelsNotice } = await import("./enum-labels-kept-CUlUlRkO.js");
 		const collections = await loadCollections(path.resolve(process.cwd(), collectionsPath));
 		const kept = await withAppClient(databaseUrl, (client) => keptEnumLabels({ query: async (text) => ({ rows: (await client.query(text)).rows }) }, collections));
 		if (kept.length > 0) outWarn(chalk.yellow(formatKeptEnumLabelsNotice(kept)));
@@ -1960,8 +2009,8 @@ async function reportKeptEnumLabels(databaseUrl, collectionsPath) {
 async function prebuildForeignKeyIndexes(databaseUrl, collectionsPath, dryRun) {
 	let missing;
 	try {
-		const { loadCollections } = await import("./doctor-CJyuhV1n.js").then((n) => n.t);
-		const { missingForeignKeyIndexes } = await import("./push-index-prebuild-BDFcfRPo.js");
+		const { loadCollections } = await import("./doctor-DvJH-IQG.js").then((n) => n.t);
+		const { missingForeignKeyIndexes } = await import("./push-index-prebuild-DIequ4bV.js");
 		const collections = await loadCollections(path.resolve(process.cwd(), collectionsPath));
 		missing = await withAppClient(databaseUrl, (client) => missingForeignKeyIndexes({ query: async (text) => ({ rows: (await client.query(text)).rows }) }, collections));
 	} catch {
@@ -1971,7 +2020,7 @@ async function prebuildForeignKeyIndexes(databaseUrl, collectionsPath, dryRun) {
 	if (missing.length === 0 || dryRun) return names;
 	out(chalk.gray(`  Building ${missing.length} foreign-key index(es) on existing tables first — CONCURRENTLY, so writes go on:`));
 	try {
-		const { buildDeferredIndexes } = await import("./deferred-index-build-Ca6OqKyR.js").then((n) => n.r);
+		const { buildDeferredIndexes } = await import("./deferred-index-build-Cis_HoGn.js").then((n) => n.r);
 		const outcome = await withAppClient(databaseUrl, (client) => buildDeferredIndexes(async () => ({
 			dedicated: true,
 			query: async (text) => ({ rows: (await client.query(text)).rows }),
@@ -2019,8 +2068,8 @@ async function lockManagedTables(databaseUrl, collectionsPath) {
 	let unsecured;
 	let userRole;
 	try {
-		const { lockCollectionTables } = await import("./ensure-collection-policies-C1ux3V_z.js");
-		const { loadCollections } = await import("./doctor-CJyuhV1n.js").then((n) => n.t);
+		const { lockCollectionTables } = await import("./ensure-collection-policies-CCqayoUz.js");
+		const { loadCollections } = await import("./doctor-DvJH-IQG.js").then((n) => n.t);
 		userRole = (await import("./rls-enforcement-D7P4-ZYX.js").then((n) => n.c)).REBASE_USER_ROLE;
 		const collections = await loadCollections(path.resolve(process.cwd(), collectionsPath));
 		({unsecured} = await withAppClient(databaseUrl, (client) => lockCollectionTables({ query: async (text) => ({ rows: (await client.query(text)).rows }) }, collections)));
@@ -2056,8 +2105,8 @@ async function lockManagedTables(databaseUrl, collectionsPath) {
 async function ensureAuthTables(databaseUrl, collectionsPath) {
 	try {
 		const { drizzle } = await import("drizzle-orm/node-postgres");
-		const { ensureAuthTablesExist } = await import("./ensure-tables-Dl_Eh9ow.js").then((n) => n.n);
-		const { loadCollections } = await import("./doctor-CJyuhV1n.js").then((n) => n.t);
+		const { ensureAuthTablesExist } = await import("./ensure-tables-Dpgwx5sy.js").then((n) => n.n);
+		const { loadCollections } = await import("./doctor-DvJH-IQG.js").then((n) => n.t);
 		const authCollection = (await loadCollections(path.resolve(process.cwd(), collectionsPath))).find((c) => {
 			const a = c.auth;
 			return a === true || typeof a === "object" && a !== null && a.enabled === true;
@@ -2137,9 +2186,9 @@ async function applyPolicies(databaseUrl, collectionsPath) {
 */
 async function policyStamping(databaseUrl, collectionsPath, policiesSql) {
 	try {
-		const { loadCollections } = await import("./doctor-CJyuhV1n.js").then((n) => n.t);
-		const { planCollectionPolicies } = await import("./generate-postgres-ddl-logic-B4k9djAV.js").then((n) => n.o);
-		const { policyStampSql } = await import("./ensure-collection-policies-C1ux3V_z.js");
+		const { loadCollections } = await import("./doctor-DvJH-IQG.js").then((n) => n.t);
+		const { planCollectionPolicies } = await import("./generate-postgres-ddl-logic-4eUP4t8w.js").then((n) => n.o);
+		const { policyStampSql } = await import("./ensure-collection-policies-CCqayoUz.js");
 		const { pinSearchPath } = await import("./connection-C938nR3E.js").then((n) => n.n);
 		return {
 			statements: stampableTables(planCollectionPolicies(await loadCollections(path.resolve(process.cwd(), collectionsPath))), policiesSql).map((plan) => policyStampSql(plan)).filter((statement) => statement !== void 0),
@@ -2157,8 +2206,8 @@ async function policyStamping(databaseUrl, collectionsPath, policiesSql) {
 */
 async function readPolicyPushPlan(databaseUrl, collectionsPath) {
 	try {
-		const { formatPolicyPushPlan, planPolicyPush, summarizePolicyPushPlan } = await import("./push-policy-plan-DTXE6aVa.js");
-		const { loadCollections } = await import("./doctor-CJyuhV1n.js").then((n) => n.t);
+		const { formatPolicyPushPlan, planPolicyPush, summarizePolicyPushPlan } = await import("./push-policy-plan-CvX8hiPb.js");
+		const { loadCollections } = await import("./doctor-DvJH-IQG.js").then((n) => n.t);
 		const { pinSearchPath } = await import("./connection-C938nR3E.js").then((n) => n.n);
 		const collections = await loadCollections(path.resolve(process.cwd(), collectionsPath));
 		const plan = await withAppClient(databaseUrl, (client) => planPolicyPush({ query: async (text, values) => ({ rows: (await client.query(text, values)).rows }) }, collections, { searchPath: pinSearchPath(databaseUrl) === databaseUrl ? void 0 : "public" }));
@@ -2186,8 +2235,8 @@ async function readPolicyPushPlan(databaseUrl, collectionsPath) {
 */
 async function reconcilePolicies(databaseUrl, collectionsPath) {
 	try {
-		const { checkPolicyDrift, dropOrphanedPolicies, formatPolicyDrift, hasDrift } = await import("./policy-drift-CY5P1ZRu.js").then((n) => n.s);
-		const { loadCollections } = await import("./doctor-CJyuhV1n.js").then((n) => n.t);
+		const { checkPolicyDrift, dropOrphanedPolicies, formatPolicyDrift, hasDrift } = await import("./policy-drift-vm0BcvcE.js").then((n) => n.s);
+		const { loadCollections } = await import("./doctor-DvJH-IQG.js").then((n) => n.t);
 		const collections = await loadCollections(path.resolve(process.cwd(), collectionsPath));
 		await withAppClient(databaseUrl, async (client) => {
 			const drift = await checkPolicyDrift(client, collections);
@@ -2233,6 +2282,11 @@ var BRANCH_FLAGS = {
 	"--yes": Boolean,
 	"-y": "--yes"
 };
+/** The source `branch create --from <source>` names, if it names one. */
+function createSource(rawArgs) {
+	const at = rawArgs.indexOf("--from");
+	return at !== -1 && rawArgs[at + 1] ? rawArgs[at + 1] : void 0;
+}
 async function branchCommand(rawArgs) {
 	const branchAction = rawArgs[2];
 	if (!branchAction || branchAction === "--help") {
@@ -2265,9 +2319,11 @@ async function branchCommand(rawArgs) {
 		process.exit(1);
 	}
 	const { DatabasePoolManager } = await import("./databasePoolManager-Yqdw14wY.js").then((n) => n.n);
-	const { BranchService } = await import("./BranchService-DNg4txyf.js").then((n) => n.n);
+	const { BranchService, reopenClosedDatabases, reopenedDatabasesNotice } = await import("./BranchService-iXXZeVYD.js").then((n) => n.n);
 	const { drizzle } = await import("drizzle-orm/node-postgres");
 	const { Pool } = await import("pg");
+	const healed = await reopenClosedDatabases(databaseUrl, [branchAction === "create" ? createSource(rawArgs) : void 0, process.env[ACTIVE_BRANCH_DATABASE_ENV]]);
+	for (const line of reopenedDatabasesNotice(healed)) outWarn(chalk.yellow(`  ${line}`));
 	await checkDatabaseConnectivity(databaseUrl);
 	await closeAppClients();
 	const pool = new Pool({
@@ -2287,9 +2343,7 @@ async function branchCommand(rawArgs) {
 					out(chalk.gray("  Usage: rebase db branch create <name> [--from <source>]"));
 					process.exit(1);
 				}
-				let source;
-				const fromIdx = rawArgs.indexOf("--from");
-				if (fromIdx !== -1 && rawArgs[fromIdx + 1]) source = rawArgs[fromIdx + 1];
+				const source = createSource(rawArgs);
 				const force = rawArgs.includes("--force");
 				out("");
 				out(chalk.bold("  🌿 Creating database branch..."));
@@ -2314,10 +2368,12 @@ async function branchCommand(rawArgs) {
 				else {
 					out(chalk.bold(`  🌿 ${branches.length} branch(es):`));
 					out("");
+					const current = process.env[ACTIVE_BRANCH_DATABASE_ENV]?.trim();
 					for (const b of branches) {
 						const size = b.sizeBytes != null ? chalk.gray(` (${formatBytes(b.sizeBytes)})`) : "";
 						const age = chalk.gray(` — created ${timeAgo(b.createdAt)}`);
-						out(`  ${chalk.green("●")} ${chalk.bold(b.name)}${size}${age}`);
+						const here = current && b.database === current ? chalk.cyan(" (current — this checkout is on it)") : "";
+						out(`  ${chalk.green("●")} ${chalk.bold(b.name)}${here}${size}${age}`);
 						out(chalk.gray(`    from ${b.parentDatabase}`));
 					}
 				}
@@ -2379,9 +2435,18 @@ async function branchCommand(rawArgs) {
 					rows,
 					databases,
 					branchPrefix: "rb_"
-				}, { olderThanDays });
+				}, {
+					olderThanDays,
+					activeDatabase: process.env["REBASE_ACTIVE_BRANCH_DATABASE"]?.trim() || null
+				});
+				const keptActive = () => {
+					if (!plan.active) return;
+					out(`  ${chalk.gray("○")} ${chalk.bold(plan.active.name)} ${chalk.gray("— this checkout is switched to it, so it is kept")}`);
+					out(chalk.gray(`    To prune it, leave it first: ${chalk.cyan("rebase db branch switch --off")}`));
+				};
 				out("");
 				if (planIsEmpty(plan, includeDevDiff)) {
+					keptActive();
 					out(chalk.gray("  Nothing to prune."));
 					if (!olderThanDays && rows.length > 0) out(chalk.gray(`  ${rows.length} branch(es) are healthy — --older-than 14 also removes old ones.`));
 					if (!includeDevDiff && plan.devDiff.length > 0) {
@@ -2396,6 +2461,7 @@ async function branchCommand(rawArgs) {
 				for (const row of plan.staleRows) out(`  ${chalk.yellow("○")} ${chalk.bold(row.name)} ${chalk.gray("— registered, but its database is gone; the entry will be removed")}`);
 				for (const dbName of plan.orphanDatabases) out(`  ${chalk.yellow("○")} ${chalk.bold(dbName)} ${chalk.gray("— a branch database with no entry; the database will be dropped")}`);
 				for (const { branch, ageDays } of plan.expired) out(`  ${chalk.red("●")} ${chalk.bold(branch.name)} ${chalk.gray(`— ${ageDays} days old; branch and database will be dropped`)}`);
+				keptActive();
 				if (includeDevDiff) for (const dbName of plan.devDiff) out(`  ${chalk.red("●")} ${chalk.bold(dbName)} ${chalk.gray("— Atlas scratch database; will be dropped")}`);
 				else if (plan.devDiff.length > 0) out(chalk.gray(`  (${plan.devDiff.length} Atlas scratch database(s) not listed — --include-dev-diff)`));
 				out("");
@@ -2762,9 +2828,9 @@ async function schemaStaleCommand(rawArgs) {
 	const schemaFile = path.resolve(process.cwd(), outputPath);
 	const fix = Boolean(argsList["--fix"]);
 	const generatedExists = fs.existsSync(schemaFile);
-	const { loadCollections } = await import("./doctor-CJyuhV1n.js").then((n) => n.t);
+	const { loadCollections } = await import("./doctor-DvJH-IQG.js").then((n) => n.t);
 	const { findLegacyForeignKeyNames, compareGeneratedDeclarations, staleVerdict } = await import("./generated-schema-staleness-FlxM2i4i.js").then((n) => n.r);
-	const { generateSchema } = await import("./generate-drizzle-schema-logic-BaT0H7Gq.js").then((n) => n.n);
+	const { generateSchema } = await import("./generate-drizzle-schema-logic-DA3zM8zc.js").then((n) => n.n);
 	const { relationalCollections } = await import("@rebasepro/common");
 	let stale = [];
 	let differences = [];