@rebasepro/cli 0.24.0 → 0.24.1-canary.g19596ef

package/dist/branch-pointer-kk9F5FBO.js

@@ -1,111 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import path from "path";
-import fs from "fs";
-//#region src/dev-db/branch-pointer.ts
-/**
-* Which database branch this checkout is working on.
-*
-* `rebase db branch create` made a full copy of the database in about a second
-* and then stopped one step short of being a feature: there was no `switch`, no
-* `--branch` on `rebase dev`, and nothing wrote the branch anywhere a command
-* would read it. The only way to *use* a branch was to hand-edit
-* `DATABASE_URL`, and the documentation claimed otherwise — "the CLI updates
-* your local development configuration" — which it did not; the `.env` was
-* byte-identical afterwards.
-*
-* This is that missing step, and the shape of it is chosen to avoid three
-* things:
-*
-* 1. **It does not touch `.env`.** That file holds secrets, comments and the
-*    developer's own ordering, and a command that rewrites it in place will
-*    eventually lose something that was not its business. The branch is
-*    recorded beside the other per-checkout state in `.rebase/`, which is
-*    already gitignored — a branch is a fact about one machine, never about
-*    the project.
-*
-* 2. **It stores a name, not a connection string.** The credentials stay in
-*    exactly one place; the URL is derived by swapping the database name on
-*    the base one at resolution time. A stored URL would be a second copy of
-*    the password, and would go stale the moment `.env` changed.
-*
-* 3. **It does not outrank an explicit instruction.** `--database-url` and a
-*    `DATABASE_URL` in the shell are more immediate and more specific than a
-*    switch made yesterday, so they still win. The pointer sits directly above
-*    the project's `.env`: it is a deliberate, persistent choice, and `.env` is
-*    the project default it is meant to override. Anything less and `switch`
-*    would silently do nothing on every project that sets `DATABASE_URL` —
-*    which is every project not using the managed database.
-*/
-var branch_pointer_exports = /* @__PURE__ */ __exportAll({
-	BRANCH_DB_PREFIX: () => "rb_",
-	branchDatabaseName: () => branchDatabaseName,
-	branchPointerPath: () => branchPointerPath,
-	branchUrl: () => branchUrl,
-	clearActiveBranch: () => clearActiveBranch,
-	databaseNameOf: () => databaseNameOf,
-	readActiveBranch: () => readActiveBranch,
-	writeActiveBranch: () => writeActiveBranch
-});
-/** Where the pointer lives, next to the rest of the per-checkout state. */
-function branchPointerPath(projectRoot) {
-	return path.join(projectRoot, ".rebase", "branch.json");
-}
-function branchDatabaseName(name) {
-	return `rb_${name}`;
-}
-/** Read the active branch, or null when the checkout is on the main database. */
-function readActiveBranch(projectRoot) {
-	try {
-		const raw = fs.readFileSync(branchPointerPath(projectRoot), "utf-8");
-		const parsed = JSON.parse(raw);
-		if (typeof parsed.name !== "string" || typeof parsed.database !== "string") return null;
-		if (!parsed.name || !parsed.database) return null;
-		return {
-			name: parsed.name,
-			database: parsed.database
-		};
-	} catch {
-		return null;
-	}
-}
-function writeActiveBranch(projectRoot, branch) {
-	const file = branchPointerPath(projectRoot);
-	fs.mkdirSync(path.dirname(file), { recursive: true });
-	fs.writeFileSync(file, `${JSON.stringify(branch, null, 2)}\n`, "utf-8");
-}
-/** Return to the main database. Absent is success — this is idempotent. */
-function clearActiveBranch(projectRoot) {
-	fs.rmSync(branchPointerPath(projectRoot), { force: true });
-}
-/**
-* The base connection string with its database swapped for the branch's.
-*
-* Everything else is carried across untouched — credentials, host, port, and
-* the query string, which is load-bearing here: `?sslmode=disable` is what a
-* local Docker Postgres needs, and dropping it turns a switch into a TLS error
-* that says nothing about branches.
-*
-* Returns null for a connection string that cannot be parsed, so the caller can
-* say so plainly rather than emitting a mangled URL that fails later.
-*/
-function branchUrl(baseUrl, database) {
-	try {
-		const url = new URL(baseUrl);
-		url.pathname = `/${database}`;
-		return url.toString();
-	} catch {
-		return null;
-	}
-}
-/** The database name in a connection string, for reporting what you are on. */
-function databaseNameOf(connectionString) {
-	try {
-		return new URL(connectionString).pathname.replace(/^\//, "") || null;
-	} catch {
-		return null;
-	}
-}
-//#endregion
-export { readActiveBranch as i, branch_pointer_exports as n, databaseNameOf as r, branchUrl as t };
-
-//# sourceMappingURL=branch-pointer-kk9F5FBO.js.map

package/dist/branch-pointer-kk9F5FBO.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"branch-pointer-kk9F5FBO.js","names":[],"sources":["../src/dev-db/branch-pointer.ts"],"sourcesContent":["/**\n * Which database branch this checkout is working on.\n *\n * `rebase db branch create` made a full copy of the database in about a second\n * and then stopped one step short of being a feature: there was no `switch`, no\n * `--branch` on `rebase dev`, and nothing wrote the branch anywhere a command\n * would read it. The only way to *use* a branch was to hand-edit\n * `DATABASE_URL`, and the documentation claimed otherwise — \"the CLI updates\n * your local development configuration\" — which it did not; the `.env` was\n * byte-identical afterwards.\n *\n * This is that missing step, and the shape of it is chosen to avoid three\n * things:\n *\n * 1. **It does not touch `.env`.** That file holds secrets, comments and the\n *    developer's own ordering, and a command that rewrites it in place will\n *    eventually lose something that was not its business. The branch is\n *    recorded beside the other per-checkout state in `.rebase/`, which is\n *    already gitignored — a branch is a fact about one machine, never about\n *    the project.\n *\n * 2. **It stores a name, not a connection string.** The credentials stay in\n *    exactly one place; the URL is derived by swapping the database name on\n *    the base one at resolution time. A stored URL would be a second copy of\n *    the password, and would go stale the moment `.env` changed.\n *\n * 3. **It does not outrank an explicit instruction.** `--database-url` and a\n *    `DATABASE_URL` in the shell are more immediate and more specific than a\n *    switch made yesterday, so they still win. The pointer sits directly above\n *    the project's `.env`: it is a deliberate, persistent choice, and `.env` is\n *    the project default it is meant to override. Anything less and `switch`\n *    would silently do nothing on every project that sets `DATABASE_URL` —\n *    which is every project not using the managed database.\n */\n\nimport fs from \"fs\";\nimport path from \"path\";\n\n/** Where the pointer lives, next to the rest of the per-checkout state. */\nexport function branchPointerPath(projectRoot: string): string {\n    return path.join(projectRoot, \".rebase\", \"branch.json\");\n}\n\nexport interface ActiveBranch {\n    /** The name the developer typed. */\n    name: string;\n    /** The PostgreSQL database that name refers to. */\n    database: string;\n}\n\n/**\n * The prefix `BranchService` puts on every branch database.\n *\n * Duplicated from the driver rather than imported because the CLI must answer\n * \"which database\" without loading a database driver — `rebase dev` reads this\n * before it knows which plugin the project uses. It is covered by a test that\n * fails if the driver's prefix moves.\n */\nexport const BRANCH_DB_PREFIX = \"rb_\";\n\nexport function branchDatabaseName(name: string): string {\n    return `${BRANCH_DB_PREFIX}${name}`;\n}\n\n/** Read the active branch, or null when the checkout is on the main database. */\nexport function readActiveBranch(projectRoot: string): ActiveBranch | null {\n    try {\n        const raw = fs.readFileSync(branchPointerPath(projectRoot), \"utf-8\");\n        const parsed = JSON.parse(raw) as Partial<ActiveBranch>;\n        if (typeof parsed.name !== \"string\" || typeof parsed.database !== \"string\") return null;\n        if (!parsed.name || !parsed.database) return null;\n\n        return { name: parsed.name, database: parsed.database };\n    } catch {\n        // Absent is the common case and is not an error. A corrupt file is\n        // treated the same way: the answer is \"no branch\", which is the state\n        // the developer can always get back to with `branch switch --off`.\n        return null;\n    }\n}\n\nexport function writeActiveBranch(projectRoot: string, branch: ActiveBranch): void {\n    const file = branchPointerPath(projectRoot);\n    fs.mkdirSync(path.dirname(file), { recursive: true });\n    fs.writeFileSync(file, `${JSON.stringify(branch, null, 2)}\\n`, \"utf-8\");\n}\n\n/** Return to the main database. Absent is success — this is idempotent. */\nexport function clearActiveBranch(projectRoot: string): void {\n    fs.rmSync(branchPointerPath(projectRoot), { force: true });\n}\n\n/**\n * The base connection string with its database swapped for the branch's.\n *\n * Everything else is carried across untouched — credentials, host, port, and\n * the query string, which is load-bearing here: `?sslmode=disable` is what a\n * local Docker Postgres needs, and dropping it turns a switch into a TLS error\n * that says nothing about branches.\n *\n * Returns null for a connection string that cannot be parsed, so the caller can\n * say so plainly rather than emitting a mangled URL that fails later.\n */\nexport function branchUrl(baseUrl: string, database: string): string | null {\n    try {\n        const url = new URL(baseUrl);\n        // `pathname` keeps its leading slash; a URL with no database at all\n        // still gets one, which is what connecting to a named branch means.\n        url.pathname = `/${database}`;\n\n        return url.toString();\n    } catch {\n        return null;\n    }\n}\n\n/** The database name in a connection string, for reporting what you are on. */\nexport function databaseNameOf(connectionString: string): string | null {\n    try {\n        const name = new URL(connectionString).pathname.replace(/^\\//, \"\");\n\n        return name || null;\n    } catch {\n        return null;\n    }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,kBAAkB,aAA6B;CAC3D,OAAO,KAAK,KAAK,aAAa,WAAW,aAAa;AAC1D;AAmBA,SAAgB,mBAAmB,MAAsB;CACrD,OAAO,MAAsB;AACjC;;AAGA,SAAgB,iBAAiB,aAA0C;CACvE,IAAI;EACA,MAAM,MAAM,GAAG,aAAa,kBAAkB,WAAW,GAAG,OAAO;EACnE,MAAM,SAAS,KAAK,MAAM,GAAG;EAC7B,IAAI,OAAO,OAAO,SAAS,YAAY,OAAO,OAAO,aAAa,UAAU,OAAO;EACnF,IAAI,CAAC,OAAO,QAAQ,CAAC,OAAO,UAAU,OAAO;EAE7C,OAAO;GAAE,MAAM,OAAO;GAAM,UAAU,OAAO;EAAS;CAC1D,QAAQ;EAIJ,OAAO;CACX;AACJ;AAEA,SAAgB,kBAAkB,aAAqB,QAA4B;CAC/E,MAAM,OAAO,kBAAkB,WAAW;CAC1C,GAAG,UAAU,KAAK,QAAQ,IAAI,GAAG,EAAE,WAAW,KAAK,CAAC;CACpD,GAAG,cAAc,MAAM,GAAG,KAAK,UAAU,QAAQ,MAAM,CAAC,EAAE,KAAK,OAAO;AAC1E;;AAGA,SAAgB,kBAAkB,aAA2B;CACzD,GAAG,OAAO,kBAAkB,WAAW,GAAG,EAAE,OAAO,KAAK,CAAC;AAC7D;;;;;;;;;;;;AAaA,SAAgB,UAAU,SAAiB,UAAiC;CACxE,IAAI;EACA,MAAM,MAAM,IAAI,IAAI,OAAO;EAG3B,IAAI,WAAW,IAAI;EAEnB,OAAO,IAAI,SAAS;CACxB,QAAQ;EACJ,OAAO;CACX;AACJ;;AAGA,SAAgB,eAAe,kBAAyC;CACpE,IAAI;EAGA,OAFa,IAAI,IAAI,gBAAgB,CAAC,CAAC,SAAS,QAAQ,OAAO,EAExD,KAAQ;CACnB,QAAQ;EACJ,OAAO;CACX;AACJ"}

package/dist/constraints-DKGbNfUW.js

@@ -1,48 +0,0 @@
-//#region src/dev-db/constraints.ts
-/**
-* Extensions to hand PGlite's constructor.
-*
-* `CREATE EXTENSION` alone cannot install these — PGlite resolves them from
-* bundles supplied at construction time, so anything missing here is missing
-* from the database no matter what the migration says.
-*
-* The module is spelled out per extension rather than derived from the name,
-* because they do not all live in the same place: the two contrib ones are
-* subpaths of PGlite itself, and pgvector is a package of its own. Deriving the
-* path is what left `vector` off this list — `@electric-sql/pglite/contrib/vector`
-* does not exist, so a project declaring a `{ type: "vector" }` property could
-* not use the managed dev database at all.
-*/
-var PGLITE_EXTENSIONS = [
-	{
-		name: "pg_trgm",
-		module: "@electric-sql/pglite/contrib/pg_trgm",
-		export: "pg_trgm"
-	},
-	{
-		name: "unaccent",
-		module: "@electric-sql/pglite/contrib/unaccent",
-		export: "unaccent"
-	},
-	{
-		name: "vector",
-		module: "@electric-sql/pglite-pgvector",
-		export: "vector"
-	}
-];
-/**
-* Announced at startup, every time, rather than discovered.
-*
-* A developer who does not know realtime is off will read the silence as a bug
-* in their own code, which is a worse outcome than not offering the managed
-* database at all.
-*/
-var MANAGED_LIMITATIONS = [{
-	id: "concurrency",
-	summary: "Requests are served one at a time. Behaviour is correct but serialized, so lock contention and job-queue concurrency cannot be reproduced here.",
-	remedy: "Reproduce concurrency against a real Postgres: rebase dev --docker"
-}];
-//#endregion
-export { PGLITE_EXTENSIONS as n, MANAGED_LIMITATIONS as t };
-
-//# sourceMappingURL=constraints-DKGbNfUW.js.map

package/dist/constraints-DKGbNfUW.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constraints-DKGbNfUW.js","names":[],"sources":["../src/dev-db/constraints.ts"],"sourcesContent":["/**\n * What PGlite can and cannot do as a development database, measured rather\n * than assumed.\n *\n * Everything in this directory is shaped by four facts, each established by\n * running it against `@electric-sql/pglite` 0.5.6 and\n * `@electric-sql/pglite-socket` 0.2.9 rather than by reading their docs. They\n * are recorded here because two of them are silent failures — the kind that\n * make a developer lose an evening to a feature that reports success and does\n * nothing.\n *\n * 1. **It is really PostgreSQL 18.3.** `select version()` over the socket\n *    returns `PostgreSQL 18.3 (PGlite 0.5.6) on wasm32`, which is the same\n *    major as the `postgres:18-alpine` the eject template ships. So a dev\n *    database here and a compose database there are the same Postgres, and\n *    schema behaviour does not diverge between them.\n *\n * 2. **`pg_trgm` and `unaccent` are available**, which is what search\n *    collections need. They are not installed by a bare `CREATE EXTENSION`,\n *    though — PGlite ships them as separate bundles that must be passed to the\n *    constructor, and without that `CREATE EXTENSION pg_trgm` fails with\n *    `extension \"pg_trgm\" is not available`. {@link PGLITE_EXTENSIONS} is that\n *    list, and it has to stay in step with what the schema generator emits.\n *\n * 3. **RLS is enforced exactly as it is on a real server.** With\n *    `SET LOCAL ROLE \"rebase_user\"` inside a transaction — which is how\n *    `PostgresBackendDriver` isolates every request — `current_user` becomes\n *    the restricted role, `session_user` stays the owner, and a policy using\n *    `current_setting('app.tenant')` filters rows correctly, including under\n *    `FORCE ROW LEVEL SECURITY`. Measured: an owner saw 3 rows and the\n *    role-switched transaction saw 2, with the cross-tenant probe returning 0.\n *    This is the one that mattered most: a dev database that quietly failed to\n *    apply RLS would give false confidence about the product's central claim.\n *\n * 4. **Concurrency is the real limit, and it fails badly.** PGlite is a single\n *    session, and `PGLiteSocketServer` multiplexes connections onto it. Two\n *    pooled clients that hold *overlapping transactions* deadlock — not error,\n *    hang — which is precisely what a request-per-transaction server does under\n *    any concurrent load. {@link MANAGED_POOL_MAX} is the answer: one client\n *    connection, so requests queue in the pool instead of deadlocking in the\n *    multiplexer. Measured: with a pool of 1, four concurrent queries and a\n *    role-switched RLS transaction all pass; with a pool of 5 the same script\n *    hangs indefinitely.\n *\n * 5. **LISTEN/NOTIFY needed repairing, and now works.** A notification is an\n *    asynchronous message with no request to answer, and the multiplexer hands\n *    it to whichever socket is reading rather than to the one that issued\n *    `LISTEN` — so a dedicated listener connection, which is exactly how the\n *    realtime engine works, received nothing while the *writer* received\n *    notifications it never asked for. `notification-proxy.ts` corrects that by\n *    copying every `NotificationResponse` frame to every client, which for a\n *    single-session database is simply the truth. Realtime therefore works\n *    against the managed database, with no change to the server: it does\n *    ordinary `LISTEN` over ordinary libpq.\n */\n\n/** One extension bundle, and where to import it from. */\nexport interface PgliteExtension {\n    /** The name `CREATE EXTENSION` uses, and the key PGlite is handed. */\n    name: string;\n    /** Module the bundle is imported from. */\n    module: string;\n    /** The named export carrying the bundle. */\n    export: string;\n}\n\n/**\n * Extensions to hand PGlite's constructor.\n *\n * `CREATE EXTENSION` alone cannot install these — PGlite resolves them from\n * bundles supplied at construction time, so anything missing here is missing\n * from the database no matter what the migration says.\n *\n * The module is spelled out per extension rather than derived from the name,\n * because they do not all live in the same place: the two contrib ones are\n * subpaths of PGlite itself, and pgvector is a package of its own. Deriving the\n * path is what left `vector` off this list — `@electric-sql/pglite/contrib/vector`\n * does not exist, so a project declaring a `{ type: \"vector\" }` property could\n * not use the managed dev database at all.\n */\nexport const PGLITE_EXTENSIONS: readonly PgliteExtension[] = [\n    { name: \"pg_trgm\", module: \"@electric-sql/pglite/contrib/pg_trgm\", export: \"pg_trgm\" },\n    { name: \"unaccent\", module: \"@electric-sql/pglite/contrib/unaccent\", export: \"unaccent\" },\n    { name: \"vector\", module: \"@electric-sql/pglite-pgvector\", export: \"vector\" }\n];\n\n/**\n * Client connections the managed database tolerates: exactly one.\n *\n * Not a tuning choice. Two concurrent transactions over the socket\n * multiplexer deadlock, and a request-per-transaction server produces those\n * the moment two requests overlap. One connection converts that deadlock into\n * ordinary queueing, which is slower and correct.\n */\nexport const MANAGED_POOL_MAX = 1;\n\n/**\n * Connections the socket server will accept.\n *\n * Above {@link MANAGED_POOL_MAX} so that a second *non-transactional* client —\n * `rebase db push` in another terminal while `rebase dev` runs — is refused\n * with a connection error rather than corrupting the multiplexer. The pool\n * limit is what prevents overlapping transactions; this only stops a stampede.\n */\nexport const MANAGED_SERVER_MAX_CONNECTIONS = 4;\n\n/** What a managed PGlite database cannot do, in the words the user needs. */\nexport interface ManagedLimitation {\n    /** Stable id, so a warning can be suppressed or tested for. */\n    id: string;\n    /** One line, naming the feature rather than the mechanism. */\n    summary: string;\n    /** What to do instead. Always a concrete command. */\n    remedy: string;\n}\n\n/**\n * Announced at startup, every time, rather than discovered.\n *\n * A developer who does not know realtime is off will read the silence as a bug\n * in their own code, which is a worse outcome than not offering the managed\n * database at all.\n */\nexport const MANAGED_LIMITATIONS: readonly ManagedLimitation[] = [\n    {\n        id: \"concurrency\",\n        summary:\n            \"Requests are served one at a time. Behaviour is correct but serialized, so \" +\n            \"lock contention and job-queue concurrency cannot be reproduced here.\",\n        remedy: \"Reproduce concurrency against a real Postgres: rebase dev --docker\"\n    }\n] as const;\n"],"mappings":";;;;;;;;;;;;;;;AAgFA,IAAa,oBAAgD;CACzD;EAAE,MAAM;EAAW,QAAQ;EAAwC,QAAQ;CAAU;CACrF;EAAE,MAAM;EAAY,QAAQ;EAAyC,QAAQ;CAAW;CACxF;EAAE,MAAM;EAAU,QAAQ;EAAiC,QAAQ;CAAS;AAChF;;;;;;;;AAuCA,IAAa,sBAAoD,CAC7D;CACI,IAAI;CACJ,SACI;CAEJ,QAAQ;AACZ,CACJ"}

package/dist/daemon-C8p32i-n.js

@@ -1,357 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as devDbDir, c as readState, i as dataDir, l as releaseStartLock, o as findFreePort, r as clearState, s as pidRunning, t as acquireStartLock, u as stateFile } from "./state-C59Elrnt.js";
-import path from "path";
-import fs from "fs";
-import net from "net";
-import { fileURLToPath } from "url";
-import { randomBytes } from "crypto";
-import { spawn } from "child_process";
-//#region src/dev-db/daemon.ts
-/**
-* Starting, finding and stopping the managed database, from the caller's side.
-*
-* Every command that needs Postgres calls {@link ensureManagedDatabase} and
-* gets a connection string back. Whether that started a process or found one
-* already running is not the caller's business, which is the point: `rebase
-* db push`, `rebase dev` and `rebase studio` in three terminals must all reach
-* the same database without coordinating, because two processes opening one
-* PGlite data directory would corrupt it.
-*
-* The hard part is not starting the daemon; it is deciding whether the one the
-* state file describes is still there. A pid can be recycled after a reboot and
-* a port can be taken by a stranger, so believing either on its own would let
-* Rebase send a migration somewhere unintended. {@link isDaemonAlive} asks the
-* daemon to identify itself instead.
-*/
-var daemon_exports = /* @__PURE__ */ __exportAll({
-	ensureManagedDatabase: () => ensureManagedDatabase,
-	findRunningDaemon: () => findRunningDaemon,
-	isDaemonAlive: () => isDaemonAlive,
-	managedUrl: () => managedUrl,
-	pgliteLogTail: () => pgliteLogTail,
-	resetManagedDatabase: () => resetManagedDatabase,
-	resolveCliEntry: () => resolveCliEntry,
-	resolveSpawn: () => resolveSpawn,
-	stopManagedDatabase: () => stopManagedDatabase
-});
-/** How long to wait for a first boot. PGlite runs initdb on an empty data dir. */
-var START_TIMEOUT_MS = 6e4;
-/** Poll interval while waiting for the daemon to publish its state file. */
-var POLL_INTERVAL_MS = 150;
-/** How long the identity handshake may take before we call it dead. */
-var IDENTITY_TIMEOUT_MS = 1500;
-/**
-* PGlite's built-in superuser and database.
-*
-* Fixed by PGlite rather than chosen here, and asserted by the socket spike:
-* `session_user` comes back as `postgres`.
-*/
-var MANAGED_USER = "postgres";
-var MANAGED_DATABASE = "postgres";
-/**
-* The DSN for the managed development database.
-*
-* **`sslmode=disable` is not decoration.** PGlite's socket server speaks no TLS,
-* and libpq-family clients try SSL first — so Atlas, which `rebase db push`
-* shells out to, failed the whole push with
-* `pq: SSL is not enabled on the server`. Its remedy box then told the reader to
-* append `sslmode=disable` to `DATABASE_URL`, which on this path is not set at
-* all: `rebase init` leaves it commented out precisely so the managed database
-* is used. The advice was correct and unfollowable.
-*
-* Putting it in the URL fixes every consumer at once — Atlas, `pg`, and anything
-* a driver shells out to later — rather than teaching each one about PGlite.
-*/
-/**
-* The end of `pglite.log`, for an error message that has to carry its own reason.
-*
-* The daemon writes its output to a file because it is detached — it has to
-* outlive the command that started it. That is right, and it means every
-* startup failure used to be reported as a path: "see pglite.log for the
-* reason". On a laptop that is a fair trade. In CI it is not a trade at all,
-* because the runner discards the workspace: the log named in the message no
-* longer exists by the time anybody reads the message, so a failed run says
-* only that something failed.
-*
-* So the tail comes with the error. Bounded, because a log that has been
-* appended to across many runs is not something to paste in full.
-*/
-function pgliteLogTail(projectRoot, lines = 12) {
-	try {
-		const contents = fs.readFileSync(path.join(devDbDir(projectRoot), "pglite.log"), "utf8").trimEnd();
-		if (!contents) return "  (pglite.log is empty — the daemon wrote nothing before exiting)";
-		return contents.split("\n").slice(-lines).map((line) => `      ${line}`).join("\n");
-	} catch {
-		return "  (pglite.log could not be read)";
-	}
-}
-function managedUrl(port) {
-	return `postgresql://${MANAGED_USER}@127.0.0.1:${port}/${MANAGED_DATABASE}?sslmode=disable`;
-}
-/**
-* Ask the process behind a state record to prove it is the one we wrote down.
-*
-* A pid check alone answers "is *a* process running", and a port check alone
-* answers "is *something* listening" — after a reboot both say yes about
-* strangers. The daemon answers with the token from its own state file, so a
-* match is the only evidence accepted.
-*/
-function isDaemonAlive(state) {
-	if (!pidRunning(state.pid)) return Promise.resolve(false);
-	return new Promise((resolve) => {
-		const socket = new net.Socket();
-		let answer = "";
-		const settle = (alive) => {
-			socket.removeAllListeners();
-			socket.destroy();
-			resolve(alive);
-		};
-		socket.setTimeout(IDENTITY_TIMEOUT_MS);
-		socket.once("timeout", () => settle(false));
-		socket.once("error", () => settle(false));
-		socket.on("data", (chunk) => {
-			answer += chunk.toString("utf8");
-			if (answer.includes("\n")) settle(answer.trim() === `rebase-dev-db ${state.token}`);
-		});
-		socket.once("close", () => settle(answer.trim() === `rebase-dev-db ${state.token}`));
-		socket.connect(state.identityPort, "127.0.0.1");
-	});
-}
-/** The running daemon for this project, or `null`. Never starts anything. */
-async function findRunningDaemon(projectRoot) {
-	const state = readState(projectRoot);
-	if (!state) return null;
-	if (await isDaemonAlive(state)) return state;
-	clearState(projectRoot);
-	return null;
-}
-/**
-* Resolve the CLI entry point, so the daemon can be spawned as ourselves.
-*
-* A hidden subcommand rather than a second build entry: under `tsx` this file
-* is `src/dev-db/daemon.ts` and in a published CLI it is bundled into
-* `dist/index.js`, and in both cases the executable to re-invoke is the one
-* already running. `rebase dev` re-runs itself the same way to regenerate the
-* SDK types.
-*/
-function resolveCliEntry() {
-	const argvEntry = process.argv[1];
-	if (argvEntry && fs.existsSync(argvEntry)) return argvEntry;
-	return fileURLToPath(new URL("data:video/mp2t;base64,LyoqCiAqIFRoZSBDTEkncyBwdWJsaWMgZW50cnkg4oCUIGRlbGliZXJhdGVseSBzbWFsbC4KICoKICogVGhpcyBmaWxlIHVzZWQgdG8gYGV4cG9ydCAqYCBmcm9tIHNpeHRlZW4gbW9kdWxlczogZXZlcnkgY29tbWFuZCBmdW5jdGlvbiwKICogYGRldGVjdFBhY2thZ2VNYW5hZ2VyYCwgYGZpbmRQcm9qZWN0Um9vdGAsIHRoZSB3aG9sZSBvZiBgY29tbWFuZHMvY2xvdWRgLiBOb25lCiAqIG9mIGl0IHdhcyBpbXBvcnRlZCBieSBhbnl0aGluZywgaW4gdGhpcyByZXBvc2l0b3J5IG9yIHRoZSBjb250cm9sIHBsYW5lLCBhbmQKICogbm9uZSBvZiBpdCB3YXMgbWVhbnQgdG8gYmU6IGBAcmViYXNlcHJvL2NsaWAgaXMgYSBwcm9ncmFtLCBhbmQgYSBwcm9ncmFtJ3MKICogaW50ZXJuYWxzIGJlY29tZSBhbiBBUEkgdGhlIG1vbWVudCB0aGV5IGFyZSBleHBvcnRlZCBhbmQgcHVibGlzaGVkLiBUaGUKICogYmFycmVsIHdhcyB3cml0dGVuIHRoZSB3YXkgYmFycmVscyBnZXQgd3JpdHRlbiDigJQgb25lIGxpbmUgcGVyIGZpbGUg4oCUIGFuZCB0aGUKICogc3VyZmFjZSBpdCBjcmVhdGVkIHdhcyBhbiBhY2NpZGVudCBvZiB0aGF0IGNvbnZlbnRpb24gcmF0aGVyIHRoYW4gYSBkZWNpc2lvbi4KICoKICogVGhyZWUgdGhpbmdzIGFyZSBleHBvcnRlZCwgZWFjaCBmb3IgYSBzdGF0ZWQgcmVhc29uLgogKi8KCi8qKgogKiBXaGF0IGBiaW4vcmViYXNlLmpzYCBjYWxscy4gVGhlIGJpbmFyeSBpbXBvcnRzIGBkaXN0L2luZGV4LmVzLmpzYCBhbmQgaW52b2tlcwogKiBgZW50cnkoKWAsIHNvIHRoaXMgaXMgdGhlIG9uZSBleHBvcnQgdGhlIENMSSBjYW5ub3QgcnVuIHdpdGhvdXQuCiAqLwpleHBvcnQgeyBlbnRyeSB9IGZyb20gIi4vY2xpIjsKCi8qKgogKiBUaGUgbWFuaWZlc3QgYW5kIGJ1bmRsZSBjb250cmFjdHMuCiAqCiAqIEV4cG9ydGVkIGJlY2F1c2UgdmFsaWRhdGluZyB0aGVtIGlzIG5vdCBvbmx5IHRoZSBDTEkncyBqb2I6IGEgY29udHJvbCBwbGFuZQogKiBoYXMgdG8gZGVjaWRlIHdoZXRoZXIgYSBzdWJtaXR0ZWQgYnVuZGxlIGNhbiBydW4gYmVmb3JlIGl0IGRlcGxveXMgaXQsIGFuZCBpdAogKiBtdXN0IHJlYWNoIHRoYXQgdmVyZGljdCB3aXRoIHRoZSBzYW1lIGNvZGUgdGhhdCBwcm9kdWNlZCB0aGUgYXJ0aWZhY3QuCiAqLwpleHBvcnQgKiBmcm9tICIuL21hbmlmZXN0IjsKZXhwb3J0ICogZnJvbSAiLi9idW5kbGUiOwo=", "" + import.meta.url));
-}
-/**
-* How to re-invoke ourselves, which differs between a published CLI and this
-* repository.
-*
-* A published `rebase` is `node bin/rebase.js`, and re-running that is trivial.
-* Inside the monorepo the entry is TypeScript, which plain `node` cannot load —
-* so the daemon has to be started through the same loader that is running now.
-* Getting this wrong fails as a spawn that exits instantly with a syntax error,
-* which is why the caller reads `pglite.log` on failure.
-*/
-function resolveSpawn(entry) {
-	if (!/\.[cm]?ts$/.test(entry)) return {
-		execPath: process.execPath,
-		prefixArgs: []
-	};
-	return {
-		execPath: process.execPath,
-		prefixArgs: ["--import", "tsx"]
-	};
-}
-/**
-* Ask the running daemon for one additional database, and get its port.
-*
-* The identity socket doubles as the command channel: the daemon answers
-* with its token first, which is how the caller knows it is talking to the
-* daemon the state file describes and not to a stranger on a recycled port.
-*/
-function ensureAdditionalDatabase(state, key) {
-	return new Promise((resolve, reject) => {
-		const socket = new net.Socket();
-		let answer = "";
-		let identified = false;
-		const fail = (message) => {
-			socket.removeAllListeners();
-			socket.destroy();
-			reject(new Error(message));
-		};
-		socket.setTimeout(START_TIMEOUT_MS);
-		socket.once("timeout", () => fail(`The development database did not answer for "${key}" within ${Math.round(START_TIMEOUT_MS / 1e3)}s.`));
-		socket.once("error", (err) => fail(`Could not reach the development database for "${key}": ${err.message}`));
-		socket.on("data", (chunk) => {
-			answer += chunk.toString("utf8");
-			let newline = answer.indexOf("\n");
-			while (newline !== -1) {
-				const line = answer.slice(0, newline).trim();
-				answer = answer.slice(newline + 1);
-				if (!identified) {
-					if (line !== `rebase-dev-db ${state.token}`) return fail("The process on the development database's port is not the daemon.");
-					identified = true;
-					socket.write(`ensure ${key}\n`);
-				} else if (line.startsWith("ok ")) {
-					const port = Number(line.slice(3));
-					socket.removeAllListeners();
-					socket.destroy();
-					if (!Number.isInteger(port) || port <= 0) return reject(/* @__PURE__ */ new Error(`The development database answered with an invalid port for "${key}": ${line}`));
-					return resolve(port);
-				} else return fail(`The development database could not serve "${key}": ${line.replace(/^error\s*/, "")}`);
-				newline = answer.indexOf("\n");
-			}
-		});
-		socket.connect(state.identityPort, "127.0.0.1");
-	});
-}
-/** Every additional database the caller asked for, as connection strings. */
-async function adoptWithAdditional(state, started, keys) {
-	const additional = {};
-	for (const key of keys) {
-		const known = state.databases?.[key];
-		additional[key] = managedUrl(known ? known.port : await ensureAdditionalDatabase(state, key));
-	}
-	return {
-		...adopt(state, started),
-		additional
-	};
-}
-/**
-* The project's managed database, started if it is not already running.
-*
-* Safe to call concurrently from several commands: the loser of the race finds
-* the winner's state file during its poll and adopts it rather than starting a
-* second daemon.
-*/
-async function ensureManagedDatabase(projectRoot, options = {}) {
-	const keys = options.additionalKeys ?? [];
-	const existing = await findRunningDaemon(projectRoot);
-	if (existing) return adoptWithAdditional(existing, false, keys);
-	fs.mkdirSync(devDbDir(projectRoot), { recursive: true });
-	ensureGitignore(projectRoot);
-	if (!acquireStartLock(projectRoot, START_TIMEOUT_MS)) {
-		const adopted = await waitForDaemon(projectRoot, START_TIMEOUT_MS);
-		if (adopted) return adoptWithAdditional(adopted, false, keys);
-		if (!acquireStartLock(projectRoot, 0)) throw new Error(`Another process is starting the development database and did not finish.
-  Remove ${path.join(devDbDir(projectRoot), "starting.lock")} if nothing is running.`);
-	}
-	const port = await findFreePort();
-	const token = randomBytes(16).toString("hex");
-	const entry = options.entry ?? resolveCliEntry();
-	const spawnPlan = options.spawn ?? resolveSpawn(entry);
-	const args = [
-		...spawnPlan.prefixArgs,
-		entry,
-		"__dev-db-daemon",
-		"--project",
-		projectRoot,
-		"--port",
-		String(port),
-		"--token",
-		token
-	];
-	if (options.idleTimeoutMs !== void 0) args.push("--idle-timeout", String(options.idleTimeoutMs));
-	const log = fs.openSync(path.join(devDbDir(projectRoot), "pglite.log"), "a");
-	const child = spawn(spawnPlan.execPath, args, {
-		detached: true,
-		stdio: [
-			"ignore",
-			log,
-			log
-		]
-	});
-	child.unref();
-	try {
-		const deadline = Date.now() + START_TIMEOUT_MS;
-		let announced = false;
-		while (Date.now() < deadline) {
-			const state = readState(projectRoot);
-			if (state && await isDaemonAlive(state)) return adoptWithAdditional(state, true, keys);
-			if (!announced && !options.quiet) {
-				announced = true;
-				options.onProgress?.("Starting the development database…");
-			}
-			if (child.exitCode !== null && child.exitCode !== 0) throw new Error(`The development database failed to start (exit ${child.exitCode}).\n  ${path.join(devDbDir(projectRoot), "pglite.log")} ends:\n` + pgliteLogTail(projectRoot));
-			await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
-		}
-		throw new Error(`The development database did not start within ${Math.round(START_TIMEOUT_MS / 1e3)}s.\n  ${path.join(devDbDir(projectRoot), "pglite.log")} ends:\n` + pgliteLogTail(projectRoot) + "\n  To use your own Postgres instead, set DATABASE_URL or pass --database-url.");
-	} finally {
-		releaseStartLock(projectRoot);
-	}
-}
-/** Shape a live state record as the caller's result. */
-function adopt(state, started) {
-	return {
-		url: managedUrl(state.port),
-		dataDir: state.dataDir,
-		port: state.port,
-		pid: state.pid,
-		started,
-		additional: {}
-	};
-}
-/** Poll until another process publishes a live daemon, or give up. */
-async function waitForDaemon(projectRoot, timeoutMs) {
-	const deadline = Date.now() + timeoutMs;
-	while (Date.now() < deadline) {
-		const state = readState(projectRoot);
-		if (state && await isDaemonAlive(state)) return state;
-		await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
-	}
-	return null;
-}
-/** Stop the daemon. Returns false when there was nothing running. */
-async function stopManagedDatabase(projectRoot) {
-	const state = await findRunningDaemon(projectRoot);
-	if (!state) return false;
-	try {
-		process.kill(state.pid, "SIGTERM");
-	} catch {
-		clearState(projectRoot);
-		return false;
-	}
-	const deadline = Date.now() + 1e4;
-	while (Date.now() < deadline) {
-		if (!fs.existsSync(stateFile(projectRoot))) return true;
-		await new Promise((resolve) => setTimeout(resolve, 100));
-	}
-	clearState(projectRoot);
-	return true;
-}
-/**
-* Stop the daemon and delete the data directory.
-*
-* Destructive and deliberately not clever: it removes the whole directory
-* rather than dropping schemas, because "give me an empty database" is the only
-* thing anyone means by it.
-*/
-async function resetManagedDatabase(projectRoot) {
-	await stopManagedDatabase(projectRoot);
-	fs.rmSync(dataDir(projectRoot), {
-		recursive: true,
-		force: true
-	});
-	const dir = devDbDir(projectRoot);
-	if (fs.existsSync(dir)) {
-		for (const entry of fs.readdirSync(dir)) if (entry.startsWith("pgdata__")) fs.rmSync(path.join(dir, entry), {
-			recursive: true,
-			force: true
-		});
-	}
-	clearState(projectRoot);
-}
-/**
-* Keep the generated directory out of git.
-*
-* `.rebase/` holds a Postgres data directory and a log. A project that commits
-* it will push hundreds of megabytes and a database that only makes sense on
-* one machine, so the ignore file is written next to the data rather than
-* relying on the project's root `.gitignore` having been updated.
-*/
-function ensureGitignore(projectRoot) {
-	const target = path.join(devDbDir(projectRoot), ".gitignore");
-	if (fs.existsSync(target)) return;
-	fs.writeFileSync(target, "# Generated by `rebase dev` — a local Postgres data directory and its log.\n# Machine-specific and large; never commit it.\n*\n", "utf8");
-}
-//#endregion
-export { resolveCliEntry as a, managedUrl as i, ensureManagedDatabase as n, resolveSpawn as o, findRunningDaemon as r, daemon_exports as t };
-
-//# sourceMappingURL=daemon-C8p32i-n.js.map

package/dist/daemon-C8p32i-n.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"daemon-C8p32i-n.js","names":[],"sources":["../src/dev-db/daemon.ts"],"sourcesContent":["/**\n * Starting, finding and stopping the managed database, from the caller's side.\n *\n * Every command that needs Postgres calls {@link ensureManagedDatabase} and\n * gets a connection string back. Whether that started a process or found one\n * already running is not the caller's business, which is the point: `rebase\n * db push`, `rebase dev` and `rebase studio` in three terminals must all reach\n * the same database without coordinating, because two processes opening one\n * PGlite data directory would corrupt it.\n *\n * The hard part is not starting the daemon; it is deciding whether the one the\n * state file describes is still there. A pid can be recycled after a reboot and\n * a port can be taken by a stranger, so believing either on its own would let\n * Rebase send a migration somewhere unintended. {@link isDaemonAlive} asks the\n * daemon to identify itself instead.\n */\n\nimport { randomBytes } from \"crypto\";\nimport { type ChildProcess, spawn } from \"child_process\";\nimport fs from \"fs\";\nimport net from \"net\";\nimport path from \"path\";\nimport { fileURLToPath } from \"url\";\n\nimport {\n    acquireStartLock,\n    clearState,\n    type DaemonState,\n    dataDir,\n    devDbDir,\n    findFreePort,\n    pidRunning,\n    readState,\n    releaseStartLock,\n    stateFile\n} from \"./state\";\n\n/** How long to wait for a first boot. PGlite runs initdb on an empty data dir. */\nconst START_TIMEOUT_MS = 60_000;\n/** Poll interval while waiting for the daemon to publish its state file. */\nconst POLL_INTERVAL_MS = 150;\n/** How long the identity handshake may take before we call it dead. */\nconst IDENTITY_TIMEOUT_MS = 1_500;\n\nexport interface ManagedDatabase {\n    /** Connection string for this project's managed database. */\n    url: string;\n    /** Where the data lives, for diagnostics and `--reset`. */\n    dataDir: string;\n    port: number;\n    pid: number;\n    /** True when this call started the daemon rather than finding it. */\n    started: boolean;\n    /**\n     * Connection strings for the additional databases the caller asked for,\n     * by declared key — `database(\"analytics\")` → `analytics`. Each is its\n     * own PGlite instance behind the same daemon.\n     */\n    additional: Record<string, string>;\n}\n\n/**\n * PGlite's built-in superuser and database.\n *\n * Fixed by PGlite rather than chosen here, and asserted by the socket spike:\n * `session_user` comes back as `postgres`.\n */\nconst MANAGED_USER = \"postgres\";\nconst MANAGED_DATABASE = \"postgres\";\n\n/**\n * The DSN for the managed development database.\n *\n * **`sslmode=disable` is not decoration.** PGlite's socket server speaks no TLS,\n * and libpq-family clients try SSL first — so Atlas, which `rebase db push`\n * shells out to, failed the whole push with\n * `pq: SSL is not enabled on the server`. Its remedy box then told the reader to\n * append `sslmode=disable` to `DATABASE_URL`, which on this path is not set at\n * all: `rebase init` leaves it commented out precisely so the managed database\n * is used. The advice was correct and unfollowable.\n *\n * Putting it in the URL fixes every consumer at once — Atlas, `pg`, and anything\n * a driver shells out to later — rather than teaching each one about PGlite.\n */\n\n/**\n * The end of `pglite.log`, for an error message that has to carry its own reason.\n *\n * The daemon writes its output to a file because it is detached — it has to\n * outlive the command that started it. That is right, and it means every\n * startup failure used to be reported as a path: \"see pglite.log for the\n * reason\". On a laptop that is a fair trade. In CI it is not a trade at all,\n * because the runner discards the workspace: the log named in the message no\n * longer exists by the time anybody reads the message, so a failed run says\n * only that something failed.\n *\n * So the tail comes with the error. Bounded, because a log that has been\n * appended to across many runs is not something to paste in full.\n */\nexport function pgliteLogTail(projectRoot: string, lines = 12): string {\n    try {\n        const contents = fs.readFileSync(path.join(devDbDir(projectRoot), \"pglite.log\"), \"utf8\").trimEnd();\n        if (!contents) return \"  (pglite.log is empty — the daemon wrote nothing before exiting)\";\n        return contents.split(\"\\n\").slice(-lines).map(line => `      ${line}`).join(\"\\n\");\n    } catch {\n        return \"  (pglite.log could not be read)\";\n    }\n}\n\nexport function managedUrl(port: number): string {\n    return `postgresql://${MANAGED_USER}@127.0.0.1:${port}/${MANAGED_DATABASE}?sslmode=disable`;\n}\n\n/**\n * Ask the process behind a state record to prove it is the one we wrote down.\n *\n * A pid check alone answers \"is *a* process running\", and a port check alone\n * answers \"is *something* listening\" — after a reboot both say yes about\n * strangers. The daemon answers with the token from its own state file, so a\n * match is the only evidence accepted.\n */\nexport function isDaemonAlive(state: DaemonState): Promise<boolean> {\n    if (!pidRunning(state.pid)) return Promise.resolve(false);\n\n    return new Promise((resolve) => {\n        const socket = new net.Socket();\n        let answer = \"\";\n        const settle = (alive: boolean) => {\n            socket.removeAllListeners();\n            socket.destroy();\n            resolve(alive);\n        };\n        socket.setTimeout(IDENTITY_TIMEOUT_MS);\n        socket.once(\"timeout\", () => settle(false));\n        socket.once(\"error\", () => settle(false));\n        socket.on(\"data\", (chunk) => {\n            answer += chunk.toString(\"utf8\");\n            if (answer.includes(\"\\n\")) settle(answer.trim() === `rebase-dev-db ${state.token}`);\n        });\n        socket.once(\"close\", () => settle(answer.trim() === `rebase-dev-db ${state.token}`));\n        socket.connect(state.identityPort, \"127.0.0.1\");\n    });\n}\n\n/** The running daemon for this project, or `null`. Never starts anything. */\nexport async function findRunningDaemon(projectRoot: string): Promise<DaemonState | null> {\n    const state = readState(projectRoot);\n    if (!state) return null;\n    if (await isDaemonAlive(state)) return state;\n\n    // The record describes something that is not there. Clearing it is the\n    // whole recovery: the next ensure call starts a fresh daemon, and leaving\n    // it would make every subsequent check pay the identity timeout.\n    clearState(projectRoot);\n\n    return null;\n}\n\n/**\n * Resolve the CLI entry point, so the daemon can be spawned as ourselves.\n *\n * A hidden subcommand rather than a second build entry: under `tsx` this file\n * is `src/dev-db/daemon.ts` and in a published CLI it is bundled into\n * `dist/index.js`, and in both cases the executable to re-invoke is the one\n * already running. `rebase dev` re-runs itself the same way to regenerate the\n * SDK types.\n */\nexport function resolveCliEntry(): string {\n    // `process.argv[1]` is `bin/rebase.js` for a real invocation, which is\n    // exactly what should be re-run. Under a test runner it is the runner, so\n    // fall back to this module's own directory.\n    const argvEntry = process.argv[1];\n    if (argvEntry && fs.existsSync(argvEntry)) return argvEntry;\n\n    return fileURLToPath(new URL(\"../index.js\", import.meta.url));\n}\n\n/**\n * How to re-invoke ourselves, which differs between a published CLI and this\n * repository.\n *\n * A published `rebase` is `node bin/rebase.js`, and re-running that is trivial.\n * Inside the monorepo the entry is TypeScript, which plain `node` cannot load —\n * so the daemon has to be started through the same loader that is running now.\n * Getting this wrong fails as a spawn that exits instantly with a syntax error,\n * which is why the caller reads `pglite.log` on failure.\n */\nexport function resolveSpawn(entry: string): { execPath: string; prefixArgs: string[] } {\n    if (!/\\.[cm]?ts$/.test(entry)) return { execPath: process.execPath, prefixArgs: [] };\n\n    // Node can load TypeScript when tsx is registered as an import hook. tsx is\n    // already a dependency of this package, because `rebase dev` runs the\n    // backend through it.\n    return { execPath: process.execPath, prefixArgs: [\"--import\", \"tsx\"] };\n}\n\nexport interface EnsureOptions {\n    /** Silence the \"starting…\" progress line. */\n    quiet?: boolean;\n    /** Milliseconds of inactivity before the daemon exits. 0 disables. */\n    idleTimeoutMs?: number;\n    /** Where progress goes. Injected for tests. */\n    onProgress?: (message: string) => void;\n    /** Override how the daemon process is launched. For tests. */\n    spawn?: { execPath: string; prefixArgs: string[] };\n    /**\n     * Override the CLI entry to re-invoke. For tests.\n     *\n     * Necessary because under a test runner `process.argv[1]` is the runner\n     * itself, which exists and is therefore accepted by {@link resolveCliEntry}\n     * — spawning vitest with `__dev-db-daemon` rather than the CLI.\n     */\n    entry?: string;\n    /**\n     * Keys of the additional databases the project declares, beyond the\n     * default. Each is served by the daemon on request, so a project that\n     * adds `database(\"analytics\")` while the daemon is running gets it\n     * without a restart.\n     */\n    additionalKeys?: readonly string[];\n}\n\n/**\n * Ask the running daemon for one additional database, and get its port.\n *\n * The identity socket doubles as the command channel: the daemon answers\n * with its token first, which is how the caller knows it is talking to the\n * daemon the state file describes and not to a stranger on a recycled port.\n */\nfunction ensureAdditionalDatabase(state: DaemonState, key: string): Promise<number> {\n    return new Promise((resolve, reject) => {\n        const socket = new net.Socket();\n        let answer = \"\";\n        let identified = false;\n        const fail = (message: string) => {\n            socket.removeAllListeners();\n            socket.destroy();\n            reject(new Error(message));\n        };\n        socket.setTimeout(START_TIMEOUT_MS);\n        socket.once(\"timeout\", () => fail(`The development database did not answer for \"${key}\" within ${Math.round(START_TIMEOUT_MS / 1000)}s.`));\n        socket.once(\"error\", (err) => fail(`Could not reach the development database for \"${key}\": ${err.message}`));\n        socket.on(\"data\", (chunk) => {\n            answer += chunk.toString(\"utf8\");\n            let newline = answer.indexOf(\"\\n\");\n            while (newline !== -1) {\n                const line = answer.slice(0, newline).trim();\n                answer = answer.slice(newline + 1);\n                if (!identified) {\n                    if (line !== `rebase-dev-db ${state.token}`) return fail(\"The process on the development database's port is not the daemon.\");\n                    identified = true;\n                    socket.write(`ensure ${key}\\n`);\n                } else if (line.startsWith(\"ok \")) {\n                    const port = Number(line.slice(3));\n                    socket.removeAllListeners();\n                    socket.destroy();\n                    if (!Number.isInteger(port) || port <= 0) return reject(new Error(`The development database answered with an invalid port for \"${key}\": ${line}`));\n                    return resolve(port);\n                } else {\n                    return fail(`The development database could not serve \"${key}\": ${line.replace(/^error\\s*/, \"\")}`);\n                }\n                newline = answer.indexOf(\"\\n\");\n            }\n        });\n        socket.connect(state.identityPort, \"127.0.0.1\");\n    });\n}\n\n/** Every additional database the caller asked for, as connection strings. */\nasync function adoptWithAdditional(state: DaemonState, started: boolean, keys: readonly string[]): Promise<ManagedDatabase> {\n    const additional: Record<string, string> = {};\n    for (const key of keys) {\n        const known = state.databases?.[key];\n        const port = known ? known.port : await ensureAdditionalDatabase(state, key);\n        additional[key] = managedUrl(port);\n    }\n    return { ...adopt(state, started), additional };\n}\n\n/**\n * The project's managed database, started if it is not already running.\n *\n * Safe to call concurrently from several commands: the loser of the race finds\n * the winner's state file during its poll and adopts it rather than starting a\n * second daemon.\n */\nexport async function ensureManagedDatabase(\n    projectRoot: string,\n    options: EnsureOptions = {}\n): Promise<ManagedDatabase> {\n    const keys = options.additionalKeys ?? [];\n    const existing = await findRunningDaemon(projectRoot);\n    if (existing) return adoptWithAdditional(existing, false, keys);\n\n    fs.mkdirSync(devDbDir(projectRoot), { recursive: true });\n    ensureGitignore(projectRoot);\n\n    // Exactly one process may spawn a daemon. Without this, `rebase dev` and\n    // `rebase db push` started in the same second both see no state file, both\n    // spawn, and two processes open one PGlite data directory — the corruption\n    // the single-daemon design exists to prevent.\n    if (!acquireStartLock(projectRoot, START_TIMEOUT_MS)) {\n        const adopted = await waitForDaemon(projectRoot, START_TIMEOUT_MS);\n        if (adopted) return adoptWithAdditional(adopted, false, keys);\n\n        // The holder gave up or died without publishing. Falling through to\n        // start one ourselves is better than failing: the lock is stale by now,\n        // so the next acquire will break it.\n        if (!acquireStartLock(projectRoot, 0)) {\n            throw new Error(\n                \"Another process is starting the development database and did not finish.\\n\" +\n                `  Remove ${path.join(devDbDir(projectRoot), \"starting.lock\")} if nothing is running.`\n            );\n        }\n    }\n\n    const port = await findFreePort();\n    const token = randomBytes(16).toString(\"hex\");\n    const entry = options.entry ?? resolveCliEntry();\n\n    const spawnPlan = options.spawn ?? resolveSpawn(entry);\n    const args = [\n        ...spawnPlan.prefixArgs,\n        entry,\n        \"__dev-db-daemon\",\n        \"--project\", projectRoot,\n        \"--port\", String(port),\n        \"--token\", token\n    ];\n    if (options.idleTimeoutMs !== undefined) {\n        args.push(\"--idle-timeout\", String(options.idleTimeoutMs));\n    }\n\n    const log = fs.openSync(path.join(devDbDir(projectRoot), \"pglite.log\"), \"a\");\n    const child: ChildProcess = spawn(spawnPlan.execPath, args, {\n        // Detached with no stdin and its output on a file: the daemon must\n        // survive the command that started it, and must not hold the terminal\n        // open when that command exits.\n        detached: true,\n        stdio: [\"ignore\", log, log]\n    });\n    child.unref();\n\n    try {\n        const deadline = Date.now() + START_TIMEOUT_MS;\n        let announced = false;\n        while (Date.now() < deadline) {\n            const state = readState(projectRoot);\n            if (state && (await isDaemonAlive(state))) return adoptWithAdditional(state, true, keys);\n\n            if (!announced && !options.quiet) {\n                announced = true;\n                options.onProgress?.(\"Starting the development database…\");\n            }\n\n            // A daemon that died on startup will never publish a state file, and\n            // waiting the full minute for that is a bad way to learn it. The log\n            // is the only place the reason exists.\n            if (child.exitCode !== null && child.exitCode !== 0) {\n                throw new Error(\n                    `The development database failed to start (exit ${child.exitCode}).\\n` +\n                    `  ${path.join(devDbDir(projectRoot), \"pglite.log\")} ends:\\n` +\n                    pgliteLogTail(projectRoot)\n                );\n            }\n\n            await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));\n        }\n\n        throw new Error(\n            `The development database did not start within ${Math.round(START_TIMEOUT_MS / 1000)}s.\\n` +\n            `  ${path.join(devDbDir(projectRoot), \"pglite.log\")} ends:\\n` +\n            pgliteLogTail(projectRoot) + \"\\n\" +\n            \"  To use your own Postgres instead, set DATABASE_URL or pass --database-url.\"\n        );\n    } finally {\n        // Released whether we succeeded, timed out or threw. A lock left behind\n        // by a crash is broken by age, but only after a full timeout — which a\n        // developer should never have to wait out.\n        releaseStartLock(projectRoot);\n    }\n}\n\n/** Shape a live state record as the caller's result. */\nfunction adopt(state: DaemonState, started: boolean): ManagedDatabase {\n    return {\n        url: managedUrl(state.port),\n        dataDir: state.dataDir,\n        port: state.port,\n        pid: state.pid,\n        started,\n        additional: {}\n    };\n}\n\n/** Poll until another process publishes a live daemon, or give up. */\nasync function waitForDaemon(projectRoot: string, timeoutMs: number): Promise<DaemonState | null> {\n    const deadline = Date.now() + timeoutMs;\n    while (Date.now() < deadline) {\n        const state = readState(projectRoot);\n        if (state && (await isDaemonAlive(state))) return state;\n        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));\n    }\n\n    return null;\n}\n\n/** Stop the daemon. Returns false when there was nothing running. */\nexport async function stopManagedDatabase(projectRoot: string): Promise<boolean> {\n    const state = await findRunningDaemon(projectRoot);\n    if (!state) return false;\n\n    try {\n        process.kill(state.pid, \"SIGTERM\");\n    } catch {\n        clearState(projectRoot);\n\n        return false;\n    }\n\n    // Wait for it to clear its own state file, which is how it says it closed\n    // the data directory cleanly. A hard kill here would risk the WAL.\n    const deadline = Date.now() + 10_000;\n    while (Date.now() < deadline) {\n        if (!fs.existsSync(stateFile(projectRoot))) return true;\n        await new Promise((resolve) => setTimeout(resolve, 100));\n    }\n\n    clearState(projectRoot);\n\n    return true;\n}\n\n/**\n * Stop the daemon and delete the data directory.\n *\n * Destructive and deliberately not clever: it removes the whole directory\n * rather than dropping schemas, because \"give me an empty database\" is the only\n * thing anyone means by it.\n */\nexport async function resetManagedDatabase(projectRoot: string): Promise<void> {\n    await stopManagedDatabase(projectRoot);\n    fs.rmSync(dataDir(projectRoot), { recursive: true, force: true });\n    // Every additional database too: `pgdata__<key>` beside `pgdata`. \"Give\n    // me an empty database\" means all of them — a reset that emptied the\n    // default and kept the analytics rows would be a surprise on first read.\n    const dir = devDbDir(projectRoot);\n    if (fs.existsSync(dir)) {\n        for (const entry of fs.readdirSync(dir)) {\n            if (entry.startsWith(\"pgdata__\")) fs.rmSync(path.join(dir, entry), { recursive: true, force: true });\n        }\n    }\n    clearState(projectRoot);\n}\n\n/**\n * Keep the generated directory out of git.\n *\n * `.rebase/` holds a Postgres data directory and a log. A project that commits\n * it will push hundreds of megabytes and a database that only makes sense on\n * one machine, so the ignore file is written next to the data rather than\n * relying on the project's root `.gitignore` having been updated.\n */\nfunction ensureGitignore(projectRoot: string): void {\n    const target = path.join(devDbDir(projectRoot), \".gitignore\");\n    if (fs.existsSync(target)) return;\n    fs.writeFileSync(\n        target,\n        \"# Generated by `rebase dev` — a local Postgres data directory and its log.\\n\" +\n        \"# Machine-specific and large; never commit it.\\n*\\n\",\n        \"utf8\"\n    );\n}\n"],"mappings":"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"}