@cedarjs/pg 0.1.0-alpha.0

package/dist/lifecycle-D10usEjM.cjs

@@ -0,0 +1,743 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+const require_constants = require("./constants-B7sCf4fg.cjs");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let node_os = require("node:os");
+let node_crypto = require("node:crypto");
+let node_child_process = require("node:child_process");
+let pg = require("pg");
+pg = __toESM(pg, 1);
+//#region src/core/naming.ts
+const PG_MAX = 63;
+const PREFIX = "cpg_";
+/**
+* Build an observable Postgres database name:
+*   cpg_<repoSlug>_<worktreeSlug>_<mode>_<pathHash8>
+*
+* Never drops `mode` or `pathHash`. Truncates slugs to fit ≤63 chars.
+*/
+function buildDatabaseName(identity, mode) {
+	const modePart = mode;
+	const hashPart = identity.pathHash;
+	const fixed = 6 + modePart.length + 1 + hashPart.length;
+	let budget = PG_MAX - fixed;
+	if (budget < 2) return `${PREFIX}${modePart}_${hashPart}`.slice(0, PG_MAX);
+	let repo = identity.repoSlug;
+	let wt = identity.worktreeSlug;
+	while (repo.length + wt.length > budget) if (repo.length >= wt.length && repo.length > 1) repo = repo.slice(0, -1);
+	else if (wt.length > 1) wt = wt.slice(0, -1);
+	else break;
+	const name = `${PREFIX}${repo}_${wt}_${modePart}_${hashPart}`;
+	if (name.length > PG_MAX) return name.slice(0, PG_MAX);
+	return name;
+}
+function buildRoleName(databaseName) {
+	const suffix = "_role";
+	const maxBase = PG_MAX - 5;
+	return `${databaseName.slice(0, maxBase)}${suffix}`;
+}
+//#endregion
+//#region src/core/lease.ts
+function isDbMode(value) {
+	return value === "dev" || value === "test";
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.length > 0;
+}
+/** Narrow-parse a lease; reject incomplete or wrong-version records. */
+function parseLease(raw) {
+	if (!raw || typeof raw !== "object") return null;
+	const o = raw;
+	if (o.schemaVersion !== 1) return null;
+	if (!isDbMode(o.mode)) return null;
+	if (!isNonEmptyString(o.root)) return null;
+	if (!isNonEmptyString(o.repoSlug)) return null;
+	if (!isNonEmptyString(o.worktreeSlug)) return null;
+	if (!isNonEmptyString(o.pathHash)) return null;
+	if (!isNonEmptyString(o.databaseName)) return null;
+	if (!isNonEmptyString(o.roleName)) return null;
+	if (typeof o.port !== "number") return null;
+	if (typeof o.pid !== "number") return null;
+	if (!isNonEmptyString(o.createdAt)) return null;
+	return {
+		schemaVersion: 1,
+		mode: o.mode,
+		root: o.root,
+		repoSlug: o.repoSlug,
+		worktreeSlug: o.worktreeSlug,
+		pathHash: o.pathHash,
+		databaseName: o.databaseName,
+		roleName: o.roleName,
+		port: o.port,
+		pid: o.pid,
+		createdAt: o.createdAt
+	};
+}
+function leaseDir(root) {
+	return (0, node_path.join)(root, require_constants.STATE_DIRNAME);
+}
+function leasePath(root, mode) {
+	return (0, node_path.join)(leaseDir(root), `${mode}.json`);
+}
+/** Durable registry outside worktrees so GC can find orphans after a checkout is deleted. */
+function registryDir() {
+	return process.env.CEDAR_PG_REGISTRY_DIR || (0, node_path.join)((0, node_os.homedir)(), ".cedarpg", "registry");
+}
+function registryPath(databaseName) {
+	return (0, node_path.join)(registryDir(), `${databaseName}.json`);
+}
+function writeJsonAtomic(file, value) {
+	(0, node_fs.mkdirSync)((0, node_path.dirname)(file), {
+		recursive: true,
+		mode: 448
+	});
+	const tmp = `${file}.tmp.${process.pid}`;
+	(0, node_fs.writeFileSync)(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: 384 });
+	(0, node_fs.renameSync)(tmp, file);
+}
+function registerLease(lease) {
+	writeJsonAtomic(registryPath(lease.databaseName), lease);
+}
+function unregisterLease(databaseName) {
+	try {
+		(0, node_fs.unlinkSync)(registryPath(databaseName));
+	} catch {}
+}
+function readLease(root, mode) {
+	const file = leasePath(root, mode);
+	if (!(0, node_fs.existsSync)(file)) return null;
+	try {
+		return parseLease(JSON.parse((0, node_fs.readFileSync)(file, "utf8")));
+	} catch {
+		return null;
+	}
+}
+/**
+* Persist lease. Registry is written first (GC source of truth), then the worktree cache.
+*/
+function writeLease(lease) {
+	registerLease(lease);
+	(0, node_fs.mkdirSync)(leaseDir(lease.root), {
+		recursive: true,
+		mode: 448
+	});
+	writeJsonAtomic(leasePath(lease.root, lease.mode), lease);
+}
+/**
+* Remove registry entry by databaseName and best-effort delete the worktree lease file.
+* Call only after a successful DROP (or when intentionally abandoning tracking).
+*/
+function forgetLease(lease) {
+	unregisterLease(lease.databaseName);
+	try {
+		(0, node_fs.unlinkSync)(leasePath(lease.root, lease.mode));
+	} catch {}
+}
+/** All registry entries (used by gc). */
+function listRegistryLeases() {
+	const dir = registryDir();
+	if (!(0, node_fs.existsSync)(dir)) return [];
+	const out = [];
+	for (const name of (0, node_fs.readdirSync)(dir)) {
+		if (!name.endsWith(".json")) continue;
+		try {
+			const lease = parseLease(JSON.parse((0, node_fs.readFileSync)((0, node_path.join)(dir, name), "utf8")));
+			if (lease) out.push(lease);
+		} catch {}
+	}
+	return out;
+}
+function isOrphanLease(lease) {
+	return !(0, node_fs.existsSync)(lease.root);
+}
+//#endregion
+//#region src/core/policy.ts
+/**
+* True when the URL looks like a cedarpg provisioned database (`cpg_*` name/role).
+* These must never be treated as an external escape hatch — always re-ensure so
+* disposed/stale shell env cannot skip provisioning.
+*/
+function isCedarPgManagedUrl(url) {
+	if (!url || url.startsWith("file:")) return false;
+	try {
+		const parsed = new URL(url);
+		const databaseName = decodeURIComponent((parsed.pathname.replace(/^\//, "").split("?")[0] ?? "").trim());
+		const user = decodeURIComponent(parsed.username);
+		return databaseName.startsWith("cpg_") || user.startsWith("cpg_");
+	} catch {
+		return false;
+	}
+}
+/**
+* True when `url` is a real external database and ensure should be skipped.
+* Sqlite `file:` URLs and cedarpg `cpg_*` URLs are not external.
+*/
+function isExternalDatabaseEscapeHatch(url) {
+	if (!url) return false;
+	if (url.startsWith("file:")) return false;
+	if (isCedarPgManagedUrl(url)) return false;
+	return true;
+}
+/**
+* Decide whether ensure should run.
+* Adapters may call with no args (env defaults). Cedar opt-in should pass `disabled: false`
+* and the relevant `url` (`DATABASE_URL` or `TEST_DATABASE_URL`).
+*/
+function resolveEnsureSkip(input = {}) {
+	if (input.disabled ?? (process.env.CEDAR_PG === "0" || process.env.CEDAR_PG === "false")) return {
+		skip: true,
+		reason: "disabled"
+	};
+	if (input.force ?? process.env.CEDAR_PG_FORCE === "1") return { skip: false };
+	const url = input.url !== void 0 ? input.url : process.env.TEST_DATABASE_URL;
+	if (url && isExternalDatabaseEscapeHatch(url)) return {
+		skip: true,
+		reason: "external-url",
+		databaseUrl: url
+	};
+	return { skip: false };
+}
+//#endregion
+//#region src/core/worktree.ts
+function git(args, cwd) {
+	try {
+		return (0, node_child_process.execFileSync)("git", args, {
+			cwd,
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+	} catch {
+		return null;
+	}
+}
+function sanitizeSlug(input) {
+	return input.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+}
+/**
+* Resolve the project / worktree root.
+* Explicit `root` wins (app project path). Otherwise prefer git toplevel, then cwd.
+*/
+function resolveRoot(root) {
+	if (root) return (0, node_path.resolve)(root);
+	const start = (0, node_path.resolve)(process.cwd());
+	const toplevel = git(["rev-parse", "--show-toplevel"], start);
+	if (toplevel) return toplevel;
+	return start;
+}
+/**
+* Identify repo + worktree for observable DB naming.
+*/
+function resolveWorktreeIdentity(root) {
+	const absRoot = resolveRoot(root);
+	const pathHash = (0, node_crypto.createHash)("sha256").update(absRoot).digest("hex").slice(0, 8);
+	const commonDir = git(["rev-parse", "--git-common-dir"], absRoot);
+	let repoSlug = sanitizeSlug((0, node_path.basename)(absRoot));
+	if (commonDir) {
+		const commonAbs = (0, node_path.resolve)(absRoot, commonDir);
+		const mainRoot = (0, node_path.basename)(commonAbs) === ".git" ? (0, node_path.dirname)(commonAbs) : commonAbs;
+		const fromGit = sanitizeSlug((0, node_path.basename)((0, node_path.basename)(mainRoot) === ".git" ? (0, node_path.dirname)(mainRoot) : mainRoot));
+		if (fromGit) repoSlug = fromGit;
+	}
+	let worktreeSlug = sanitizeSlug((0, node_path.basename)(absRoot));
+	const gitFile = (0, node_path.resolve)(absRoot, ".git");
+	if ((0, node_fs.existsSync)(gitFile)) try {
+		const match = (0, node_fs.readFileSync)(gitFile, "utf8").trim().match(/gitdir:\s*(.+)$/m);
+		if (match?.[1]) {
+			const parts = (0, node_path.resolve)(absRoot, match[1].trim()).split(/[/\\]/);
+			const wtIdx = parts.lastIndexOf("worktrees");
+			if (wtIdx >= 0 && parts[wtIdx + 1]) {
+				const fromWt = sanitizeSlug(parts[wtIdx + 1]);
+				if (fromWt) worktreeSlug = fromWt;
+			}
+		}
+	} catch {}
+	if (!repoSlug) repoSlug = "repo";
+	if (!worktreeSlug) worktreeSlug = "wt";
+	return {
+		root: absRoot,
+		repoSlug,
+		worktreeSlug,
+		pathHash
+	};
+}
+//#endregion
+//#region src/providers/autopg.ts
+const INSTALL_HINT = "autopg is required. Install with:\n  curl -fsSL https://raw.githubusercontent.com/automagik-dev/autopg/main/install.sh | bash\nThen ensure ~/.local/bin is on PATH, or set AUTOPG_BIN.";
+/** Password scheme v1: sha256(PASSWORD_SALT_PREFIX + "\\0" + databaseName) hex[:32]. Frozen for URL rebuild. */
+const ROLE_PASSWORD_SCHEME = "v1";
+function candidateBins() {
+	const out = [];
+	if (process.env.AUTOPG_BIN) out.push(process.env.AUTOPG_BIN);
+	out.push("autopg");
+	out.push((0, node_path.join)((0, node_os.homedir)(), ".local", "bin", "autopg"));
+	return out;
+}
+function resolveAutopgBin() {
+	for (const bin of candidateBins()) {
+		if (bin === "autopg") {
+			const which = (0, node_child_process.spawnSync)("which", ["autopg"], { encoding: "utf8" });
+			if (which.status === 0 && which.stdout.trim()) return which.stdout.trim();
+			continue;
+		}
+		if ((0, node_fs.existsSync)(bin)) return bin;
+	}
+	return null;
+}
+function requireAutopgBin() {
+	const bin = resolveAutopgBin();
+	if (!bin) throw new Error(INSTALL_HINT);
+	return bin;
+}
+/**
+* Parse `autopg status --json` output. Requires a numeric port and running !== false.
+*/
+function parseHostStatus(json) {
+	let parsed;
+	try {
+		parsed = JSON.parse(json);
+	} catch {
+		throw new Error(`autopg status --json returned invalid JSON.\n${INSTALL_HINT}`);
+	}
+	if (typeof parsed.port !== "number") throw new Error(`autopg status --json missing numeric port.\n${INSTALL_HINT}`);
+	if (parsed.running === false) throw new Error(`autopg host is not running.\n${INSTALL_HINT}`);
+	return { port: parsed.port };
+}
+function adminUrlFor(port) {
+	return `postgresql://postgres:postgres@127.0.0.1:${port}/postgres`;
+}
+/**
+* Discover a live autopg host via `autopg status --json`. Throws if the host is not proven live.
+*/
+function discoverHost(bin = requireAutopgBin()) {
+	let status;
+	try {
+		status = (0, node_child_process.execFileSync)(bin, ["status", "--json"], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+	} catch (err) {
+		const detail = err instanceof Error ? err.message : String(err);
+		throw new Error(`Failed to query autopg status.\n${detail}\n${INSTALL_HINT}`);
+	}
+	const { port } = parseHostStatus(status);
+	return {
+		port,
+		adminUrl: adminUrlFor(port),
+		bin
+	};
+}
+/**
+* Ensure the host postmaster is up. Runs `autopg install` only after status fails, then re-discovers.
+*/
+function ensureHostRunning(bin = requireAutopgBin()) {
+	try {
+		return discoverHost(bin);
+	} catch {}
+	const install = (0, node_child_process.spawnSync)(bin, ["install"], {
+		encoding: "utf8",
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	if (install.status !== 0) throw new Error(`Failed to start autopg host (exit ${install.status}).\n${install.stderr || install.stdout || ""}\n${INSTALL_HINT}`);
+	return discoverHost(bin);
+}
+function quoteIdent(name) {
+	return `"${name.replace(/"/g, "\"\"")}"`;
+}
+function quoteLiteral(value) {
+	return `'${value.replace(/'/g, "''")}'`;
+}
+/**
+* Deterministic local-only password for an app role (Prisma/TCP need it;
+* autopg hba uses `password` for 127.0.0.1).
+*/
+function rolePasswordFor(databaseName) {
+	return (0, node_crypto.createHash)("sha256").update(`${require_constants.PASSWORD_SALT_PREFIX}\0${databaseName}`).digest("hex").slice(0, 32);
+}
+/**
+* Idempotently CREATE ROLE + CREATE DATABASE with cedar-pg owned names.
+*/
+async function ensureDatabase(opts) {
+	const password = opts.password ?? rolePasswordFor(opts.databaseName);
+	const client = new pg.default.Client({ connectionString: opts.adminUrl });
+	await client.connect();
+	try {
+		if ((await client.query("SELECT 1 FROM pg_roles WHERE rolname = $1", [opts.roleName])).rowCount === 0) await client.query(`CREATE ROLE ${quoteIdent(opts.roleName)} WITH LOGIN PASSWORD ${quoteLiteral(password)}`);
+		else await client.query(`ALTER ROLE ${quoteIdent(opts.roleName)} WITH LOGIN PASSWORD ${quoteLiteral(password)}`);
+		if ((await client.query("SELECT 1 FROM pg_database WHERE datname = $1", [opts.databaseName])).rowCount === 0) await client.query(`CREATE DATABASE ${quoteIdent(opts.databaseName)} OWNER ${quoteIdent(opts.roleName)}`);
+		else await client.query(`ALTER DATABASE ${quoteIdent(opts.databaseName)} OWNER TO ${quoteIdent(opts.roleName)}`);
+	} finally {
+		await client.end();
+	}
+}
+/**
+* DROP DATABASE (force terminate backends) + DROP ROLE.
+*/
+async function dropDatabase(opts) {
+	const client = new pg.default.Client({ connectionString: opts.adminUrl });
+	await client.connect();
+	try {
+		await client.query(`
+      SELECT pg_terminate_backend(pid)
+      FROM pg_stat_activity
+      WHERE datname = $1 AND pid <> pg_backend_pid()
+      `, [opts.databaseName]);
+		await client.query(`DROP DATABASE IF EXISTS ${quoteIdent(opts.databaseName)}`);
+		if ((await client.query(`SELECT 1 FROM pg_database WHERE datdba = (SELECT oid FROM pg_roles WHERE rolname = $1) LIMIT 1`, [opts.roleName])).rowCount === 0) await client.query(`DROP ROLE IF EXISTS ${quoteIdent(opts.roleName)}`);
+	} finally {
+		await client.end();
+	}
+}
+function buildDatabaseUrl(opts) {
+	const password = opts.password ?? rolePasswordFor(opts.databaseName);
+	return `postgresql://${encodeURIComponent(opts.roleName)}:${encodeURIComponent(password)}@127.0.0.1:${opts.port}/${opts.databaseName}`;
+}
+//#endregion
+//#region src/core/lifecycle.ts
+function writeEnvFile(root, mode, databaseUrl) {
+	const dir = leaseDir(root);
+	(0, node_fs.mkdirSync)(dir, {
+		recursive: true,
+		mode: 448
+	});
+	let body = `DATABASE_URL=${databaseUrl}\n`;
+	if (mode === "test") body += `TEST_DATABASE_URL=${databaseUrl}\n`;
+	(0, node_fs.writeFileSync)((0, node_path.join)(dir, `${mode}.env`), body, { mode: 384 });
+}
+function urlFromLease(lease) {
+	return buildDatabaseUrl({
+		port: lease.port,
+		databaseName: lease.databaseName,
+		roleName: lease.roleName
+	});
+}
+/**
+* DROP the database, then forget lease/registry. Never forget without a successful DROP.
+*/
+async function dropThenForget(lease, adminUrl) {
+	await dropDatabase({
+		adminUrl,
+		databaseName: lease.databaseName,
+		roleName: lease.roleName
+	});
+	forgetLease(lease);
+}
+/**
+* Ensure a worktree-scoped database exists and return connection info.
+*
+* - `dev`: keep DB across restarts.
+* - `test`: DROP when `dispose()` is awaited (callers / test runners own teardown).
+*/
+async function ensure(options) {
+	const identity = resolveWorktreeIdentity(options.root);
+	const mode = options.mode;
+	const databaseName = buildDatabaseName(identity, mode);
+	const roleName = buildRoleName(databaseName);
+	const host = ensureHostRunning();
+	await ensureDatabase({
+		adminUrl: host.adminUrl,
+		databaseName,
+		roleName
+	});
+	const databaseUrl = buildDatabaseUrl({
+		port: host.port,
+		databaseName,
+		roleName
+	});
+	writeLease({
+		schemaVersion: 1,
+		mode,
+		root: identity.root,
+		repoSlug: identity.repoSlug,
+		worktreeSlug: identity.worktreeSlug,
+		pathHash: identity.pathHash,
+		databaseName,
+		roleName,
+		port: host.port,
+		pid: process.pid,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	writeEnvFile(identity.root, mode, databaseUrl);
+	if (options.setEnv !== false) {
+		process.env.DATABASE_URL = databaseUrl;
+		if (mode === "test") process.env.TEST_DATABASE_URL = databaseUrl;
+	}
+	const disposeFn = async () => {
+		await dispose({
+			root: identity.root,
+			mode
+		});
+	};
+	return {
+		databaseUrl,
+		databaseName,
+		roleName,
+		repoSlug: identity.repoSlug,
+		worktreeSlug: identity.worktreeSlug,
+		pathHash: identity.pathHash,
+		root: identity.root,
+		mode,
+		port: host.port,
+		dispose: disposeFn
+	};
+}
+/**
+* Resolve skip policy then ensure. Single entry for hosts (Cedar CLI, Jest, Vitest).
+* On external-url skip, sets DATABASE_URL when `setEnv` is not false.
+*/
+async function ensureIfNeeded(options) {
+	const skip = resolveEnsureSkip({
+		url: options.url,
+		force: options.force,
+		disabled: options.disabled
+	});
+	if (skip.skip) {
+		if (skip.reason === "external-url") {
+			if (options.setEnv !== false) process.env.DATABASE_URL = skip.databaseUrl;
+			return {
+				status: "skipped",
+				reason: "external-url",
+				databaseUrl: skip.databaseUrl
+			};
+		}
+		return {
+			status: "skipped",
+			reason: "disabled"
+		};
+	}
+	return {
+		status: "ensured",
+		...await ensure({
+			root: options.root,
+			mode: options.mode,
+			setEnv: options.setEnv
+		})
+	};
+}
+/**
+* DROP the worktree database for the given mode (default: test).
+* No-ops without a valid lease (never invents a name to DROP).
+* If the host is unavailable, leaves the lease so dispose/gc can retry.
+*/
+async function dispose(options = {}) {
+	const identity = resolveWorktreeIdentity(options.root);
+	const mode = options.mode ?? "test";
+	const lease = readLease(identity.root, mode);
+	if (!lease) return {
+		dropped: false,
+		reason: "no-lease"
+	};
+	let host;
+	try {
+		host = ensureHostRunning();
+	} catch {
+		return {
+			dropped: false,
+			reason: "host-unavailable"
+		};
+	}
+	await dropThenForget(lease, host.adminUrl);
+	return {
+		dropped: true,
+		databaseName: lease.databaseName
+	};
+}
+/**
+* Drop databases whose registered worktree root no longer exists on disk.
+* Registry entries are removed only after a successful DROP.
+*/
+async function gc() {
+	const dropped = [];
+	const orphans = listRegistryLeases().filter(isOrphanLease);
+	if (orphans.length === 0) return { dropped };
+	let host;
+	try {
+		host = ensureHostRunning();
+	} catch {
+		return { dropped };
+	}
+	for (const lease of orphans) try {
+		await dropThenForget(lease, host.adminUrl);
+		dropped.push(lease.databaseName);
+	} catch {}
+	return { dropped };
+}
+//#endregion
+Object.defineProperty(exports, "INSTALL_HINT", {
+	enumerable: true,
+	get: function() {
+		return INSTALL_HINT;
+	}
+});
+Object.defineProperty(exports, "ROLE_PASSWORD_SCHEME", {
+	enumerable: true,
+	get: function() {
+		return ROLE_PASSWORD_SCHEME;
+	}
+});
+Object.defineProperty(exports, "buildDatabaseName", {
+	enumerable: true,
+	get: function() {
+		return buildDatabaseName;
+	}
+});
+Object.defineProperty(exports, "buildDatabaseUrl", {
+	enumerable: true,
+	get: function() {
+		return buildDatabaseUrl;
+	}
+});
+Object.defineProperty(exports, "buildRoleName", {
+	enumerable: true,
+	get: function() {
+		return buildRoleName;
+	}
+});
+Object.defineProperty(exports, "discoverHost", {
+	enumerable: true,
+	get: function() {
+		return discoverHost;
+	}
+});
+Object.defineProperty(exports, "dispose", {
+	enumerable: true,
+	get: function() {
+		return dispose;
+	}
+});
+Object.defineProperty(exports, "ensure", {
+	enumerable: true,
+	get: function() {
+		return ensure;
+	}
+});
+Object.defineProperty(exports, "ensureHostRunning", {
+	enumerable: true,
+	get: function() {
+		return ensureHostRunning;
+	}
+});
+Object.defineProperty(exports, "ensureIfNeeded", {
+	enumerable: true,
+	get: function() {
+		return ensureIfNeeded;
+	}
+});
+Object.defineProperty(exports, "gc", {
+	enumerable: true,
+	get: function() {
+		return gc;
+	}
+});
+Object.defineProperty(exports, "isCedarPgManagedUrl", {
+	enumerable: true,
+	get: function() {
+		return isCedarPgManagedUrl;
+	}
+});
+Object.defineProperty(exports, "isExternalDatabaseEscapeHatch", {
+	enumerable: true,
+	get: function() {
+		return isExternalDatabaseEscapeHatch;
+	}
+});
+Object.defineProperty(exports, "isOrphanLease", {
+	enumerable: true,
+	get: function() {
+		return isOrphanLease;
+	}
+});
+Object.defineProperty(exports, "parseHostStatus", {
+	enumerable: true,
+	get: function() {
+		return parseHostStatus;
+	}
+});
+Object.defineProperty(exports, "parseLease", {
+	enumerable: true,
+	get: function() {
+		return parseLease;
+	}
+});
+Object.defineProperty(exports, "readLease", {
+	enumerable: true,
+	get: function() {
+		return readLease;
+	}
+});
+Object.defineProperty(exports, "requireAutopgBin", {
+	enumerable: true,
+	get: function() {
+		return requireAutopgBin;
+	}
+});
+Object.defineProperty(exports, "resolveAutopgBin", {
+	enumerable: true,
+	get: function() {
+		return resolveAutopgBin;
+	}
+});
+Object.defineProperty(exports, "resolveEnsureSkip", {
+	enumerable: true,
+	get: function() {
+		return resolveEnsureSkip;
+	}
+});
+Object.defineProperty(exports, "resolveRoot", {
+	enumerable: true,
+	get: function() {
+		return resolveRoot;
+	}
+});
+Object.defineProperty(exports, "resolveWorktreeIdentity", {
+	enumerable: true,
+	get: function() {
+		return resolveWorktreeIdentity;
+	}
+});
+Object.defineProperty(exports, "rolePasswordFor", {
+	enumerable: true,
+	get: function() {
+		return rolePasswordFor;
+	}
+});
+Object.defineProperty(exports, "urlFromLease", {
+	enumerable: true,
+	get: function() {
+		return urlFromLease;
+	}
+});
+
+//# sourceMappingURL=lifecycle-D10usEjM.cjs.map