@cedarjs/pg 0.1.0-alpha.1 → 0.2.0-beta.0

package/dist/index.d.mts

@@ -1,59 +1,10 @@
-//#region src/core/worktree.d.ts
-type WorktreeIdentity = {
-  /** Absolute path to the worktree / project root. */
-  root: string;
-  /** Basename of the git common dir / main checkout (e.g. `cedar`). */
-  repoSlug: string;
-  /** Basename of this worktree directory (e.g. `feat-auth`). */
-  worktreeSlug: string;
-  /** First 8 hex chars of sha256(absolute root). */
-  pathHash: string;
-};
-/**
- * Resolve the project / worktree root.
- * Explicit `root` wins (app project path). Otherwise prefer git toplevel, then cwd.
- */
-declare function resolveRoot(root?: string): string;
-/**
- * Identify repo + worktree for observable DB naming.
- */
-declare function resolveWorktreeIdentity(root?: string): WorktreeIdentity;
-//#endregion
-//#region src/core/naming.d.ts
-type DbMode = "dev" | "test";
-/**
- * Build an observable Postgres database name:
- *   cpg_<repoSlug>_<worktreeSlug>_<mode>_<pathHash8>
- *
- * Never drops `mode` or `pathHash`. Truncates slugs to fit ≤63 chars.
- */
-declare function buildDatabaseName(identity: WorktreeIdentity, mode: DbMode): string;
-declare function buildRoleName(databaseName: string): string;
-//#endregion
-//#region src/core/lease.d.ts
-type Lease = {
-  schemaVersion: 1;
-  mode: DbMode;
-  root: string;
-  repoSlug: string;
-  worktreeSlug: string;
-  pathHash: string;
-  databaseName: string;
-  roleName: string;
-  port: number;
-  pid: number;
-  createdAt: string;
-};
-/** Narrow-parse a lease; reject incomplete or wrong-version records. */
-declare function parseLease(raw: unknown): Lease | null;
-declare function readLease(root: string, mode: DbMode): Lease | null;
-declare function isOrphanLease(lease: Lease): boolean;
-//#endregion
+import { a as WorktreeIdentity, i as buildRoleName, n as buildCloneDatabaseName, o as resolveRoot, r as buildDatabaseName, s as resolveWorktreeIdentity, t as DbMode } from "./naming-C2nGVxPk.mjs";
+import { a as readLease, i as parseLease, n as envFilePath, r as isOrphanLease, t as Lease } from "./lease-B3TuX92y.mjs";
 //#region src/core/policy.d.ts
 /**
- * Shared ensure skip policy for test-runner adapters and Cedar CLI bridges.
+ * Shared acquire skip policy for test-runner adapters and Cedar CLI bridges.
  */
-type EnsureSkip = {
+type AcquireSkip = {
   skip: false;
 } | {
   skip: true;
@@ -63,45 +14,55 @@ type EnsureSkip = {
   reason: "external-url";
   databaseUrl: string;
 };
-type ResolveEnsureSkipInput = {
+type ResolveAcquireSkipInput = {
   /** Candidate URL (TEST_DATABASE_URL for tests, DATABASE_URL for dev). */
   url?: string;
   /** When true, never skip (CEDAR_PG_FORCE=1). */
   force?: boolean;
   /**
-   * When true, skip ensure entirely.
+   * When true, skip acquire entirely.
    * Defaults from CEDAR_PG=0|false (opt-out adapters). Pass `false` for Cedar opt-in flows.
    */
   disabled?: boolean;
 };
+/**
+ * Inject DATABASE_URL (and TEST_DATABASE_URL for test mode) from a resolved URL.
+ * Single env path for acquire, clone, and external-url skip.
+ */
+declare function applyDatabaseUrlEnv(databaseUrl: string, options?: {
+  mode?: "dev" | "test";
+}): void;
 /**
  * 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
+ * These must never be treated as an external escape hatch; always re-acquire so
  * disposed/stale shell env cannot skip provisioning.
  */
 declare function isCedarPgManagedUrl(url: string | undefined): boolean;
 /**
- * True when `url` is a real external database and ensure should be skipped.
- * Sqlite `file:` URLs and cedarpg `cpg_*` URLs are not external.
+ * True when `url` is a real external database and acquire should be skipped.
+ * Sqlite `file:` URLs, cedarpg `cpg_*` URLs, and unset template placeholders
+ * are not external.
  */
 declare function isExternalDatabaseEscapeHatch(url: string | undefined): boolean;
 /**
- * Decide whether ensure should run.
+ * Decide whether acquire 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`).
  */
-declare function resolveEnsureSkip(input?: ResolveEnsureSkipInput): EnsureSkip;
+declare function resolveAcquireSkip(input?: ResolveAcquireSkipInput): AcquireSkip;
 //#endregion
 //#region src/core/lifecycle.d.ts
 declare function urlFromLease(lease: Lease): string;
-type EnsureOptions = {
+type AcquireOptions = {
   root?: string;
   mode: DbMode;
   /** Inject DATABASE_URL / TEST_DATABASE_URL into process.env (default true). */
   setEnv?: boolean;
 };
-type EnsureResult = {
+type AcquireResult = {
   databaseUrl: string;
+  /** Superuser URL for privileged DDL (mark template, CREATE DATABASE … TEMPLATE). */
+  adminUrl: string;
   databaseName: string;
   roleName: string;
   repoSlug: string;
@@ -113,14 +74,14 @@ type EnsureResult = {
   dispose: () => Promise<void>;
 };
 /**
- * Ensure a worktree-scoped database exists and return connection info.
+ * Acquire a worktree-scoped database and return connection info.
  *
  * - `dev`: keep DB across restarts.
  * - `test`: DROP when `dispose()` is awaited (callers / test runners own teardown).
  */
-declare function ensure(options: EnsureOptions): Promise<EnsureResult>;
-type EnsureIfNeededOptions = EnsureOptions & ResolveEnsureSkipInput;
-type EnsureIfNeededResult = {
+declare function acquire(options: AcquireOptions): Promise<AcquireResult>;
+type AcquireIfNeededOptions = AcquireOptions & ResolveAcquireSkipInput;
+type AcquireIfNeededResult = {
   status: "skipped";
   reason: "disabled";
 } | {
@@ -128,13 +89,13 @@ type EnsureIfNeededResult = {
   reason: "external-url";
   databaseUrl: string;
 } | ({
-  status: "ensured";
-} & EnsureResult);
+  status: "acquired";
+} & AcquireResult);
 /**
- * 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.
+ * Resolve skip policy then acquire. Single entry for hosts (Cedar CLI, Jest, Vitest).
+ * On external-url skip, applies DATABASE_URL / TEST_DATABASE_URL when `setEnv` is not false.
  */
-declare function ensureIfNeeded(options: EnsureIfNeededOptions): Promise<EnsureIfNeededResult>;
+declare function acquireIfNeeded(options: AcquireIfNeededOptions): Promise<AcquireIfNeededResult>;
 type DisposeOptions = {
   root?: string;
   mode?: DbMode;
@@ -142,24 +103,170 @@ type DisposeOptions = {
 type DisposeResult = {
   dropped: true;
   databaseName: string;
+  droppedDatabases: string[];
 } | {
   dropped: false;
   reason: "no-lease" | "host-unavailable";
 };
 /**
- * DROP the worktree database for the given mode (default: test).
- * No-ops without a valid lease (never invents a name to DROP).
+ * Role-scoped suite teardown: DROP every database owned by the lease role
+ * (TEMPLATE + clones), then DROP ROLE and forget the lease. Unsets `IS_TEMPLATE`
+ * as needed. This is not per-clone cleanup — use `CloneResult.dropClone` for that.
+ * No-ops without a valid lease; never invents a DROP target beyond role ownership.
  * If the host is unavailable, leaves the lease so dispose/gc can retry.
  */
 declare function dispose(options?: DisposeOptions): Promise<DisposeResult>;
 /**
  * Drop databases whose registered worktree root no longer exists on disk.
- * Registry entries are removed only after a successful DROP.
+ * Registry entries are removed only after a successful DROP (owned DBs + lease DB).
  */
 declare function gc(): Promise<{
   dropped: string[];
 }>;
 //#endregion
+//#region src/core/template.d.ts
+type MarkTemplateOptions = {
+  root?: string;
+  mode: DbMode;
+  /** Superuser URL from `acquire`; when omitted, discovers/starts the host. */
+  adminUrl?: string;
+};
+/**
+ * After migrations, mark the leased DB as a PostgreSQL TEMPLATE so workers can clone it.
+ * Requires a lease from `acquire` (no datname override).
+ */
+declare function markTemplate(options: MarkTemplateOptions): Promise<{
+  databaseName: string;
+  adminUrl: string;
+}>;
+type CloneFromTemplateOptions = {
+  root?: string;
+  mode: DbMode;
+  /** Superuser URL from `acquire`; when omitted, discovers/starts the host. */
+  adminUrl?: string;
+  /**
+   * Suffix for the clone datname (e.g. Jest worker id).
+   * Defaults to `<pid>_<base36 time>`.
+   */
+  name?: string;
+  /**
+   * Inject DATABASE_URL / TEST_DATABASE_URL for this clone (default false).
+   * Host `cloneFromTemplateIfNeeded` defaults true; worker adapters pass true explicitly.
+   */
+  setEnv?: boolean;
+};
+type CloneResult = {
+  databaseUrl: string;
+  adminUrl: string;
+  databaseName: string;
+  roleName: string;
+  templateName: string;
+  port: number;
+  /**
+   * DROP this clone only (leaves TEMPLATE + role if still owned elsewhere).
+   * Not suite teardown — use role-scoped `dispose` for that.
+   */
+  dropClone: () => Promise<void>;
+};
+/**
+ * Clone the leased TEMPLATE database via admin (`CREATE DATABASE … TEMPLATE`).
+ * Reuses the template role so `databaseUrl` passwords stay valid (scheme v2).
+ * Provider rejects when the leased DB is not marked TEMPLATE.
+ * Port comes from the lease; admin URL is passed through or rediscovered.
+ */
+declare function cloneFromTemplate(options: CloneFromTemplateOptions): Promise<CloneResult>;
+type CloneFromTemplateIfNeededOptions = CloneFromTemplateOptions & ResolveAcquireSkipInput;
+type CloneFromTemplateIfNeededResult = {
+  status: "skipped";
+  reason: "disabled";
+} | {
+  status: "skipped";
+  reason: "external-url";
+  databaseUrl: string;
+} | ({
+  status: "cloned";
+} & CloneResult);
+/**
+ * Resolve skip policy then clone. Host entry for worker adapters (same skip
+ * semantics as `acquireIfNeeded`). Defaults `setEnv` on for skip and clone paths.
+ */
+declare function cloneFromTemplateIfNeeded(options: CloneFromTemplateIfNeededOptions): Promise<CloneFromTemplateIfNeededResult>;
+//#endregion
+//#region src/core/constants.d.ts
+/**
+ * Product identity vs frozen crypto.
+ *
+ * State dirs follow the CLI name (`.cedarpg`): product-owned, not nested under
+ * autopg's `~/.autopg/` (host owns that) and not a generic `.pg` (collision-prone).
+ * Password salt is an opaque crypto constant; bump ROLE_PASSWORD_SCHEME to change it.
+ */
+/** User-facing CLI binary (`package.json` bin) and log prefix */
+declare const CLI_NAME = "cedarpg";
+/**
+ * Worktree-local state dir and home-registry parent (`~/.cedarpg/registry`).
+ * Frozen for lease/gc discovery after first alpha consumers appear.
+ */
+declare const STATE_DIRNAME = ".cedarpg";
+//#endregion
+//#region src/adapters/load-mode-env.d.ts
+type LoadModeEnvOptions = {
+  root?: string;
+  /** Overwrite existing `process.env` keys (default: only fill undefined). */
+  overwrite?: boolean;
+};
+//#endregion
+//#region src/adapters/load-test-env.d.ts
+type LoadTestEnvOptions = LoadModeEnvOptions;
+/**
+ * Load `.cedarpg/test.env` into `process.env` (worker-side).
+ *
+ * Jest (and optional Vitest `setupFiles`) run tests in a different process than
+ * `globalSetup`, so `setEnv` in acquire does not reach workers — the env file does.
+ *
+ * No-ops unless a matching `test.json` lease exists, so a leftover env after dispose
+ * cannot inject a dropped DATABASE_URL.
+ */
+declare function loadTestEnv(rootOrOptions?: string | LoadTestEnvOptions): void;
+//#endregion
+//#region src/adapters/load-dev-env.d.ts
+type LoadDevEnvOptions = LoadModeEnvOptions;
+/** Load `.cedarpg/dev.env` into `process.env`. Use `{ overwrite: true }` to beat `.env`. */
+declare function loadDevEnv(rootOrOptions?: string | LoadDevEnvOptions): void;
+//#endregion
+//#region src/adapters/acquire-task.d.ts
+type AcquireTaskContext = Pick<AcquireResult, "databaseUrl" | "adminUrl" | "databaseName" | "roleName" | "root" | "mode" | "port">;
+type CreateAcquireTaskOptions = {
+  mode: DbMode;
+  root?: string;
+  /** Ignore external-URL escape hatch (`CEDAR_PG_FORCE=1` also works). */
+  force?: boolean;
+  setEnv?: boolean;
+  /** App-owned migrate/seed after a successful acquire. */
+  afterAcquire?: (ctx: AcquireTaskContext) => void | Promise<void>;
+};
+/** Run acquireIfNeeded, then optional afterAcquire (migrate / db:ready). */
+declare function createAcquireTask(options: CreateAcquireTaskOptions): () => Promise<void>;
+//#endregion
+//#region src/core/status.d.ts
+type ResolveDevStatusOptions = {
+  root?: string;
+  mode?: DbMode;
+};
+type DevStatus = {
+  ok: true;
+  mode: DbMode;
+  root: string;
+  lease: Lease;
+  databaseUrl: string;
+  envPath: string;
+} | {
+  ok: false;
+  mode: DbMode;
+  root: string;
+};
+/** Read-only lease snapshot for CLI / Vite panel (no acquire, no host). */
+declare function resolveDevStatus(options?: ResolveDevStatusOptions): DevStatus;
+//#endregion
 //#region src/providers/autopg.d.ts
 type AutopgDiscovery = {
   port: number;
@@ -167,29 +274,36 @@ type AutopgDiscovery = {
   bin: string;
 };
 declare const INSTALL_HINT: string;
-/** Password scheme v1: sha256(PASSWORD_SALT_PREFIX + "\\0" + databaseName) hex[:32]. Frozen for URL rebuild. */
-declare const ROLE_PASSWORD_SCHEME: "v1";
+/** Password scheme v2: sha256(PASSWORD_SALT_PREFIX + "\\0" + roleName) hex[:32]. Frozen for URL rebuild. */
+declare const ROLE_PASSWORD_SCHEME: "v2";
 declare function resolveAutopgBin(): string | null;
 declare function requireAutopgBin(): string;
 /**
- * Parse `autopg status --json` output. Requires a numeric port and running !== false.
+ * Parse `autopg status --json` → the **registered** port. Throws only when the
+ * output is not autopg status JSON.
+ *
+ * Registration is not liveness: autopg reports a port for a stopped host too,
+ * and its `status` string is supervisor-specific (pm2 `online`, systemd-user /
+ * launchd differ). Liveness is a TCP accept on the port, proven by the caller —
+ * `acquire` does that before it connects.
  */
 declare function parseHostStatus(json: string): {
   port: number;
 };
 /**
- * Discover a live autopg host via `autopg status --json`. Throws if the host is not proven live.
+ * Discover the registered autopg host (port + admin URL) via `autopg status --json`.
+ * Throws when autopg cannot be queried; does **not** prove a listener — probe TCP
+ * (or use `acquire`, which does) before connecting.
  */
 declare function discoverHost(bin?: string): AutopgDiscovery;
-/**
- * Ensure the host postmaster is up. Runs `autopg install` only after status fails, then re-discovers.
- */
-declare function ensureHostRunning(bin?: string): AutopgDiscovery;
 /**
  * Deterministic local-only password for an app role (Prisma/TCP need it;
  * autopg hba uses `password` for 127.0.0.1).
+ *
+ * Keyed by `roleName` (not databaseName) so TEMPLATE clones that reuse the
+ * same role keep working when `buildDatabaseUrl` is called with a new database.
  */
-declare function rolePasswordFor(databaseName: string): string;
+declare function rolePasswordFor(roleName: string): string;
 declare function buildDatabaseUrl(opts: {
   port: number;
   databaseName: string;
@@ -197,5 +311,5 @@ declare function buildDatabaseUrl(opts: {
   password?: string;
 }): string;
 //#endregion
-export { type DbMode, type DisposeOptions, type DisposeResult, type EnsureIfNeededOptions, type EnsureIfNeededResult, type EnsureOptions, type EnsureResult, type EnsureSkip, INSTALL_HINT, type Lease, ROLE_PASSWORD_SCHEME, type ResolveEnsureSkipInput, type WorktreeIdentity, buildDatabaseName, buildDatabaseUrl, buildRoleName, discoverHost, dispose, ensure, ensureHostRunning, ensureIfNeeded, gc, isCedarPgManagedUrl, isExternalDatabaseEscapeHatch, isOrphanLease, parseHostStatus, parseLease, readLease, requireAutopgBin, resolveAutopgBin, resolveEnsureSkip, resolveRoot, resolveWorktreeIdentity, rolePasswordFor, urlFromLease };
+export { type AcquireIfNeededOptions, type AcquireIfNeededResult, type AcquireOptions, type AcquireResult, type AcquireSkip, type AcquireTaskContext, type AutopgDiscovery, CLI_NAME, type CloneFromTemplateIfNeededOptions, type CloneFromTemplateIfNeededResult, type CloneFromTemplateOptions, type CloneResult, type CreateAcquireTaskOptions, type DbMode, type DevStatus, type DisposeOptions, type DisposeResult, INSTALL_HINT, type Lease, type LoadDevEnvOptions, type LoadTestEnvOptions, type MarkTemplateOptions, ROLE_PASSWORD_SCHEME, type ResolveAcquireSkipInput, type ResolveDevStatusOptions, STATE_DIRNAME, type WorktreeIdentity, acquire, acquireIfNeeded, applyDatabaseUrlEnv, buildCloneDatabaseName, buildDatabaseName, buildDatabaseUrl, buildRoleName, cloneFromTemplate, cloneFromTemplateIfNeeded, createAcquireTask, discoverHost, dispose, envFilePath, gc, isCedarPgManagedUrl, isExternalDatabaseEscapeHatch, isOrphanLease, loadDevEnv, loadTestEnv, markTemplate, parseHostStatus, parseLease, readLease, requireAutopgBin, resolveAcquireSkip, resolveAutopgBin, resolveDevStatus, resolveRoot, resolveWorktreeIdentity, rolePasswordFor, urlFromLease };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,2 +1,32 @@
-import { C as buildDatabaseName, S as readLease, _ as isCedarPgManagedUrl, a as urlFromLease, b as isOrphanLease, c as buildDatabaseUrl, d as parseHostStatus, f as requireAutopgBin, g as resolveWorktreeIdentity, h as resolveRoot, i as gc, l as discoverHost, m as rolePasswordFor, n as ensure, o as INSTALL_HINT, p as resolveAutopgBin, r as ensureIfNeeded, s as ROLE_PASSWORD_SCHEME, t as dispose, u as ensureHostRunning, v as isExternalDatabaseEscapeHatch, w as buildRoleName, x as parseLease, y as resolveEnsureSkip } from "./lifecycle-CT_8AWPv.mjs";
-export { INSTALL_HINT, ROLE_PASSWORD_SCHEME, buildDatabaseName, buildDatabaseUrl, buildRoleName, discoverHost, dispose, ensure, ensureHostRunning, ensureIfNeeded, gc, isCedarPgManagedUrl, isExternalDatabaseEscapeHatch, isOrphanLease, parseHostStatus, parseLease, readLease, requireAutopgBin, resolveAutopgBin, resolveEnsureSkip, resolveRoot, resolveWorktreeIdentity, rolePasswordFor, urlFromLease };
+import { C as buildCloneDatabaseName, T as buildRoleName, a as urlFromLease, b as isExternalDatabaseEscapeHatch, c as ROLE_PASSWORD_SCHEME, d as discoverHost, g as rolePasswordFor, h as resolveAutopgBin, i as gc, l as buildDatabaseUrl, m as requireAutopgBin, n as acquireIfNeeded, p as parseHostStatus, r as dispose, s as INSTALL_HINT, t as acquire, v as applyDatabaseUrlEnv, w as buildDatabaseName, x as resolveAcquireSkip, y as isCedarPgManagedUrl } from "./lifecycle-BvIx0xqq.mjs";
+import { c as parseLease, d as resolveRoot, f as resolveWorktreeIdentity, h as STATE_DIRNAME, i as isOrphanLease, l as readLease, p as CLI_NAME, t as envFilePath } from "./lease-DS1SX8U_.mjs";
+import { n as cloneFromTemplateIfNeeded, r as markTemplate, t as cloneFromTemplate } from "./template-BiJ-0TIF.mjs";
+import { t as loadTestEnv } from "./load-test-env-BqtA6V-d.mjs";
+import { t as loadDevEnv } from "./load-dev-env-BULkXyen.mjs";
+import { t as resolveDevStatus } from "./status-Dcnpgnlz.mjs";
+//#region src/adapters/acquire-task.ts
+/** Run acquireIfNeeded, then optional afterAcquire (migrate / db:ready). */
+function createAcquireTask(options) {
+	return async () => {
+		const result = await acquireIfNeeded({
+			root: options.root,
+			mode: options.mode,
+			setEnv: options.setEnv !== false,
+			force: options.force
+		});
+		if (result.status !== "acquired" || !options.afterAcquire) return;
+		await options.afterAcquire({
+			databaseUrl: result.databaseUrl,
+			adminUrl: result.adminUrl,
+			databaseName: result.databaseName,
+			roleName: result.roleName,
+			root: result.root,
+			mode: result.mode,
+			port: result.port
+		});
+	};
+}
+//#endregion
+export { CLI_NAME, INSTALL_HINT, ROLE_PASSWORD_SCHEME, STATE_DIRNAME, acquire, acquireIfNeeded, applyDatabaseUrlEnv, buildCloneDatabaseName, buildDatabaseName, buildDatabaseUrl, buildRoleName, cloneFromTemplate, cloneFromTemplateIfNeeded, createAcquireTask, discoverHost, dispose, envFilePath, gc, isCedarPgManagedUrl, isExternalDatabaseEscapeHatch, isOrphanLease, loadDevEnv, loadTestEnv, markTemplate, parseHostStatus, parseLease, readLease, requireAutopgBin, resolveAcquireSkip, resolveAutopgBin, resolveDevStatus, resolveRoot, resolveWorktreeIdentity, rolePasswordFor, urlFromLease };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/adapters/acquire-task.ts"],"sourcesContent":["import { acquireIfNeeded, type AcquireResult } from \"../core/lifecycle.ts\";\nimport type { DbMode } from \"../core/naming.ts\";\n\nexport type AcquireTaskContext = Pick<\n  AcquireResult,\n  \"databaseUrl\" | \"adminUrl\" | \"databaseName\" | \"roleName\" | \"root\" | \"mode\" | \"port\"\n>;\n\nexport type CreateAcquireTaskOptions = {\n  mode: DbMode;\n  root?: string;\n  /** Ignore external-URL escape hatch (`CEDAR_PG_FORCE=1` also works). */\n  force?: boolean;\n  setEnv?: boolean;\n  /** App-owned migrate/seed after a successful acquire. */\n  afterAcquire?: (ctx: AcquireTaskContext) => void | Promise<void>;\n};\n\n/** Run acquireIfNeeded, then optional afterAcquire (migrate / db:ready). */\nexport function createAcquireTask(options: CreateAcquireTaskOptions): () => Promise<void> {\n  return async () => {\n    const result = await acquireIfNeeded({\n      root: options.root,\n      mode: options.mode,\n      setEnv: options.setEnv !== false,\n      force: options.force,\n    });\n    if (result.status !== \"acquired\" || !options.afterAcquire) return;\n    await options.afterAcquire({\n      databaseUrl: result.databaseUrl,\n      adminUrl: result.adminUrl,\n      databaseName: result.databaseName,\n      roleName: result.roleName,\n      root: result.root,\n      mode: result.mode,\n      port: result.port,\n    });\n  };\n}\n"],"mappings":";;;;;;;;AAmBA,SAAgB,kBAAkB,SAAwD;CACxF,OAAO,YAAY;EACjB,MAAM,SAAS,MAAM,gBAAgB;GACnC,MAAM,QAAQ;GACd,MAAM,QAAQ;GACd,QAAQ,QAAQ,WAAW;GAC3B,OAAO,QAAQ;EACjB,CAAC;EACD,IAAI,OAAO,WAAW,cAAc,CAAC,QAAQ,cAAc;EAC3D,MAAM,QAAQ,aAAa;GACzB,aAAa,OAAO;GACpB,UAAU,OAAO;GACjB,cAAc,OAAO;GACrB,UAAU,OAAO;GACjB,MAAM,OAAO;GACb,MAAM,OAAO;GACb,MAAM,OAAO;EACf,CAAC;CACH;AACF"}

package/dist/jest-teardown.cjs

@@ -0,0 +1,18 @@
+const require_lifecycle = require("./lifecycle-BbrvFQvg.cjs");
+//#region src/adapters/jest-teardown.ts
+/**
+* Jest `globalTeardown` entry (default export).
+*
+* ```js
+* globalTeardown: require.resolve('@cedarjs/pg/jest-teardown')
+* ```
+*
+* Lease-gated dispose; no skip re-check (env may flip mid-suite).
+*/
+async function teardown() {
+	await require_lifecycle.dispose({ mode: "test" });
+}
+//#endregion
+module.exports = teardown;
+
+//# sourceMappingURL=jest-teardown.cjs.map

package/dist/jest-teardown.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest-teardown.cjs","names":["dispose"],"sources":["../src/adapters/jest-teardown.ts"],"sourcesContent":["import { dispose } from \"../core/lifecycle.ts\";\n\n/**\n * Jest `globalTeardown` entry (default export).\n *\n * ```js\n * globalTeardown: require.resolve('@cedarjs/pg/jest-teardown')\n * ```\n *\n * Lease-gated dispose; no skip re-check (env may flip mid-suite).\n */\nexport default async function teardown(): Promise<void> {\n  await dispose({ mode: \"test\" });\n}\n"],"mappings":";;;;;;;;;;;AAWA,eAA8B,WAA0B;CACtD,MAAMA,kBAAAA,QAAQ,EAAE,MAAM,OAAO,CAAC;AAChC"}

package/dist/jest-teardown.d.cts

@@ -0,0 +1,13 @@
+//#region src/adapters/jest-teardown.d.ts
+/**
+ * Jest `globalTeardown` entry (default export).
+ *
+ * ```js
+ * globalTeardown: require.resolve('@cedarjs/pg/jest-teardown')
+ * ```
+ *
+ * Lease-gated dispose; no skip re-check (env may flip mid-suite).
+ */
+declare function teardown(): Promise<void>;
+export = teardown;
+//# sourceMappingURL=jest-teardown.d.cts.map

package/dist/jest-teardown.d.mts

@@ -0,0 +1,14 @@
+//#region src/adapters/jest-teardown.d.ts
+/**
+ * Jest `globalTeardown` entry (default export).
+ *
+ * ```js
+ * globalTeardown: require.resolve('@cedarjs/pg/jest-teardown')
+ * ```
+ *
+ * Lease-gated dispose; no skip re-check (env may flip mid-suite).
+ */
+declare function teardown(): Promise<void>;
+//#endregion
+export { teardown as default };
+//# sourceMappingURL=jest-teardown.d.mts.map

package/dist/jest-teardown.mjs

@@ -0,0 +1,18 @@
+import { r as dispose } from "./lifecycle-BvIx0xqq.mjs";
+//#region src/adapters/jest-teardown.ts
+/**
+* Jest `globalTeardown` entry (default export).
+*
+* ```js
+* globalTeardown: require.resolve('@cedarjs/pg/jest-teardown')
+* ```
+*
+* Lease-gated dispose; no skip re-check (env may flip mid-suite).
+*/
+async function teardown() {
+	await dispose({ mode: "test" });
+}
+//#endregion
+export { teardown as default };
+
+//# sourceMappingURL=jest-teardown.mjs.map

package/dist/jest-teardown.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest-teardown.mjs","names":[],"sources":["../src/adapters/jest-teardown.ts"],"sourcesContent":["import { dispose } from \"../core/lifecycle.ts\";\n\n/**\n * Jest `globalTeardown` entry (default export).\n *\n * ```js\n * globalTeardown: require.resolve('@cedarjs/pg/jest-teardown')\n * ```\n *\n * Lease-gated dispose; no skip re-check (env may flip mid-suite).\n */\nexport default async function teardown(): Promise<void> {\n  await dispose({ mode: \"test\" });\n}\n"],"mappings":";;;;;;;;;;;AAWA,eAA8B,WAA0B;CACtD,MAAM,QAAQ,EAAE,MAAM,OAAO,CAAC;AAChC"}

package/dist/jest-template.cjs

@@ -0,0 +1,44 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_template_mode = require("./template-mode-JTOxrEgE.cjs");
+//#region src/adapters/jest-template.ts
+/**
+* Jest globalSetup (template mode).
+*
+* ```js
+* // jest.cedar-global.cjs
+* const { createGlobalSetup } = require("@cedarjs/pg/jest/template");
+* module.exports = createGlobalSetup({ migrate: async ({ databaseUrl }) => {} });
+*
+* // jest.config.cjs
+* // When .env has a real TEST_DATABASE_URL, set once here (inherits to workers):
+* // process.env.CEDAR_PG_FORCE = "1";
+* globalSetup: "<rootDir>/jest.cedar-global.cjs",
+* globalTeardown: require.resolve("@cedarjs/pg/jest-teardown"),
+* // Prefer setupFilesAfterEnv + beforeAll; setupFiles also works (memo is process-scoped).
+* setupFilesAfterEnv: ["<rootDir>/jest.cedar-worker.cjs"],
+*
+* // jest.cedar-worker.cjs
+* const { cloneWorkerDatabase } = require("@cedarjs/pg/jest/template");
+* beforeAll(() => cloneWorkerDatabase());
+* ```
+*
+* Stock `@cedarjs/pg/jest` is one shared test DB only.
+*/
+function createGlobalSetup(options) {
+	return async () => {
+		await require_template_mode.setupTemplateMode(options);
+	};
+}
+/** String `require.resolve` without a migrate hook is unsupported — use `createGlobalSetup`. */
+async function globalSetup() {
+	throw new Error("@cedarjs/pg/jest/template requires createGlobalSetup({ migrate }). Point globalSetup at a local module that exports createGlobalSetup({ migrate }).");
+}
+//#endregion
+exports.cloneWorkerDatabase = require_template_mode.cloneWorkerDatabase;
+exports.createGlobalSetup = createGlobalSetup;
+exports.default = globalSetup;
+
+//# sourceMappingURL=jest-template.cjs.map

package/dist/jest-template.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest-template.cjs","names":["setupTemplateMode"],"sources":["../src/adapters/jest-template.ts"],"sourcesContent":["import {\n  cloneWorkerDatabase,\n  setupTemplateMode,\n  type SetupTemplateModeOptions,\n} from \"./template-mode.ts\";\n\nexport { cloneWorkerDatabase };\nexport type {\n  SetupTemplateModeOptions,\n  TemplateMigrateFn,\n  TemplateMigrateContext,\n} from \"./template-mode.ts\";\n\n/**\n * Jest globalSetup (template mode).\n *\n * ```js\n * // jest.cedar-global.cjs\n * const { createGlobalSetup } = require(\"@cedarjs/pg/jest/template\");\n * module.exports = createGlobalSetup({ migrate: async ({ databaseUrl }) => {} });\n *\n * // jest.config.cjs\n * // When .env has a real TEST_DATABASE_URL, set once here (inherits to workers):\n * // process.env.CEDAR_PG_FORCE = \"1\";\n * globalSetup: \"<rootDir>/jest.cedar-global.cjs\",\n * globalTeardown: require.resolve(\"@cedarjs/pg/jest-teardown\"),\n * // Prefer setupFilesAfterEnv + beforeAll; setupFiles also works (memo is process-scoped).\n * setupFilesAfterEnv: [\"<rootDir>/jest.cedar-worker.cjs\"],\n *\n * // jest.cedar-worker.cjs\n * const { cloneWorkerDatabase } = require(\"@cedarjs/pg/jest/template\");\n * beforeAll(() => cloneWorkerDatabase());\n * ```\n *\n * Stock `@cedarjs/pg/jest` is one shared test DB only.\n */\nexport function createGlobalSetup(options: SetupTemplateModeOptions) {\n  return async () => {\n    await setupTemplateMode(options);\n  };\n}\n\n/** String `require.resolve` without a migrate hook is unsupported — use `createGlobalSetup`. */\nexport default async function globalSetup(): Promise<void> {\n  throw new Error(\n    \"@cedarjs/pg/jest/template requires createGlobalSetup({ migrate }). \" +\n      \"Point globalSetup at a local module that exports createGlobalSetup({ migrate }).\",\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,SAAgB,kBAAkB,SAAmC;CACnE,OAAO,YAAY;EACjB,MAAMA,sBAAAA,kBAAkB,OAAO;CACjC;AACF;;AAGA,eAA8B,cAA6B;CACzD,MAAM,IAAI,MACR,qJAEF;AACF"}

package/dist/jest-template.d.cts

@@ -0,0 +1,31 @@
+import { i as cloneWorkerDatabase, n as TemplateMigrateContext, r as TemplateMigrateFn, t as SetupTemplateModeOptions } from "./template-mode-CzyVwHsi.cjs";
+//#region src/adapters/jest-template.d.ts
+/**
+ * Jest globalSetup (template mode).
+ *
+ * ```js
+ * // jest.cedar-global.cjs
+ * const { createGlobalSetup } = require("@cedarjs/pg/jest/template");
+ * module.exports = createGlobalSetup({ migrate: async ({ databaseUrl }) => {} });
+ *
+ * // jest.config.cjs
+ * // When .env has a real TEST_DATABASE_URL, set once here (inherits to workers):
+ * // process.env.CEDAR_PG_FORCE = "1";
+ * globalSetup: "<rootDir>/jest.cedar-global.cjs",
+ * globalTeardown: require.resolve("@cedarjs/pg/jest-teardown"),
+ * // Prefer setupFilesAfterEnv + beforeAll; setupFiles also works (memo is process-scoped).
+ * setupFilesAfterEnv: ["<rootDir>/jest.cedar-worker.cjs"],
+ *
+ * // jest.cedar-worker.cjs
+ * const { cloneWorkerDatabase } = require("@cedarjs/pg/jest/template");
+ * beforeAll(() => cloneWorkerDatabase());
+ * ```
+ *
+ * Stock `@cedarjs/pg/jest` is one shared test DB only.
+ */
+declare function createGlobalSetup(options: SetupTemplateModeOptions): () => Promise<void>;
+/** String `require.resolve` without a migrate hook is unsupported — use `createGlobalSetup`. */
+declare function globalSetup(): Promise<void>;
+//#endregion
+export { type SetupTemplateModeOptions, type TemplateMigrateContext, type TemplateMigrateFn, cloneWorkerDatabase, createGlobalSetup, globalSetup as default };
+//# sourceMappingURL=jest-template.d.cts.map

package/dist/jest-template.d.mts

@@ -0,0 +1,31 @@
+import { i as cloneWorkerDatabase, n as TemplateMigrateContext, r as TemplateMigrateFn, t as SetupTemplateModeOptions } from "./template-mode-CzyVwHsi.mjs";
+//#region src/adapters/jest-template.d.ts
+/**
+ * Jest globalSetup (template mode).
+ *
+ * ```js
+ * // jest.cedar-global.cjs
+ * const { createGlobalSetup } = require("@cedarjs/pg/jest/template");
+ * module.exports = createGlobalSetup({ migrate: async ({ databaseUrl }) => {} });
+ *
+ * // jest.config.cjs
+ * // When .env has a real TEST_DATABASE_URL, set once here (inherits to workers):
+ * // process.env.CEDAR_PG_FORCE = "1";
+ * globalSetup: "<rootDir>/jest.cedar-global.cjs",
+ * globalTeardown: require.resolve("@cedarjs/pg/jest-teardown"),
+ * // Prefer setupFilesAfterEnv + beforeAll; setupFiles also works (memo is process-scoped).
+ * setupFilesAfterEnv: ["<rootDir>/jest.cedar-worker.cjs"],
+ *
+ * // jest.cedar-worker.cjs
+ * const { cloneWorkerDatabase } = require("@cedarjs/pg/jest/template");
+ * beforeAll(() => cloneWorkerDatabase());
+ * ```
+ *
+ * Stock `@cedarjs/pg/jest` is one shared test DB only.
+ */
+declare function createGlobalSetup(options: SetupTemplateModeOptions): () => Promise<void>;
+/** String `require.resolve` without a migrate hook is unsupported — use `createGlobalSetup`. */
+declare function globalSetup(): Promise<void>;
+//#endregion
+export { type SetupTemplateModeOptions, type TemplateMigrateContext, type TemplateMigrateFn, cloneWorkerDatabase, createGlobalSetup, globalSetup as default };
+//# sourceMappingURL=jest-template.d.mts.map