@tekmidian/pai 0.66.0 → 0.66.2

package/dist/factory-CNpPQQ-5.mjs

@@ -1,249 +0,0 @@
-//#region src/storage/outage.ts
-let current = null;
-/** Record that the backend is currently unreachable. */
-function setBackendOutage(outage) {
-	current = outage;
-}
-/**
-* Record that the backend answered.
-*
-* Called on every successful connection, including the first — so a daemon that
-* never had a problem reports none, and one that recovered stops reporting an
-* outage that has ended.
-*/
-function clearBackendOutage() {
-	current = null;
-}
-/** The current outage, or null when the backend is answering. */
-function getBackendOutage() {
-	return current;
-}
-/**
-* Human-readable elapsed time, for a status line rather than a log.
-*
-* Exported because the status command needs the duration on its own, to colour
-* it separately from the rest of the sentence. Without this it kept a second
-* copy of the same rounding, which is how two renderings of one outage drift.
-*/
-function humanDuration(ms) {
-	const mins = Math.max(1, Math.round(ms / 6e4));
-	return mins < 60 ? `${mins} min` : `${(mins / 60).toFixed(1)} h`;
-}
-
-//#endregion
-//#region src/storage/factory.ts
-/** Backoff schedule (ms) for the bounded CLI retry path. */
-const CLI_RETRY_DELAYS_MS = [
-	500,
-	1e3,
-	2e3
-];
-/** Backoff cap (ms) for the daemon's infinite retry path. */
-const DAEMON_RETRY_CAP_MS = 15e3;
-/**
-* Create and return the configured StorageBackend.
-*
-* Auto-behaviour:
-*  - storageBackend = "sqlite"   → SQLiteBackend always
-*  - storageBackend = "postgres" → PostgresBackend (retried; never falls back)
-*/
-async function createStorageBackend(config, opts = {}) {
-	if (config.storageBackend === "postgres") return await getSharedPostgresBackend(config, opts.waitForPostgres ?? false);
-	return createSQLiteBackend();
-}
-/**
-* Attempt a single Postgres connection (ensure DB + test). Returns the live
-* backend on success, or an error string describing why it failed.
-*/
-async function attemptPostgres(config) {
-	const { PostgresBackend } = await import("./postgres-Ceqsa64C.mjs");
-	const pgConfig = config.postgres ?? {};
-	let backend = null;
-	try {
-		await PostgresBackend.ensureDatabase(pgConfig);
-		backend = new PostgresBackend(pgConfig);
-		const err = await backend.testConnection();
-		if (err) {
-			await backend.close().catch(() => {});
-			return { error: err };
-		}
-		return { backend };
-	} catch (e) {
-		if (backend) await backend.close().catch(() => {});
-		return { error: e instanceof Error ? e.message : String(e) };
-	}
-}
-/**
-* Consecutive failures before the outage is escalated to the user.
-*
-* Not the first failure: a container restarting, or the daemon starting before
-* Docker is up, recovers within a few seconds and is not worth a notification.
-* By the fifth attempt the backoff has already spent tens of seconds, which is
-* long enough that something is actually wrong.
-*/
-const ESCALATE_AFTER_ATTEMPTS = 5;
-/** Tell the user the backend is down, through whatever channels are configured. */
-async function notifyBackendDown(attempts, lastError) {
-	try {
-		const { routeNotification } = await import("./router-CXUGsv85.mjs");
-		const { loadConfig } = await import("./config-YinjgXEJ.mjs");
-		await routeNotification({
-			event: "error",
-			title: "PAI: storage backend unreachable",
-			message: `Postgres has not answered in ${attempts} attempts (${lastError}). Indexing, session notes and the work queue are stalled until it returns. Check the container, then \`pai daemon status\`.`
-		}, loadConfig().notifications);
-	} catch {}
-}
-/** And say when it comes back, so the alert is not left hanging. */
-async function notifyBackendRecovered(attempts, since) {
-	try {
-		const { routeNotification } = await import("./router-CXUGsv85.mjs");
-		const { loadConfig } = await import("./config-YinjgXEJ.mjs");
-		const mins = since ? Math.max(1, Math.round((Date.now() - since) / 6e4)) : null;
-		await routeNotification({
-			event: "completion",
-			title: "PAI: storage backend back",
-			message: `Postgres answered after ${attempts} attempts` + (mins ? `, ${mins} min down` : "") + `. The queue will drain on its own.`
-		}, loadConfig().notifications);
-	} catch {}
-}
-/**
-* Shared retry loop: attempt a connection, back off, escalate, repeat — used
-* by both the federation and registry Postgres connectors so the retry/outage
-* behaviour (§6, "never falls back to SQLite silently") stays in one place.
-*/
-async function retryConnect(attempt, waitForever, label) {
-	let attemptN = 0;
-	let outageSince = null;
-	let escalated = false;
-	while (true) {
-		attemptN++;
-		const result = await attempt();
-		if ("backend" in result) {
-			if (attemptN > 1) process.stderr.write(`[pai-daemon] Connected to ${label} (after ${attemptN} attempts).\n`);
-			clearBackendOutage();
-			if (escalated) notifyBackendRecovered(attemptN, outageSince);
-			return result.backend;
-		}
-		const lastError = result.error;
-		if (!waitForever && attemptN > CLI_RETRY_DELAYS_MS.length) throw new Error(`${label} unreachable after ${attemptN} attempts: ${lastError}. Is Docker Desktop / Postgres running? Refusing to fall back to SQLite (would split the corpus). Start Postgres and retry.`);
-		const delayMs = waitForever ? Math.min(DAEMON_RETRY_CAP_MS, 1e3 * 2 ** Math.min(attemptN - 1, 4)) : CLI_RETRY_DELAYS_MS[attemptN - 1];
-		process.stderr.write(`[pai-daemon] ${label} unavailable (${lastError}). Retry ${attemptN}${waitForever ? "" : `/${CLI_RETRY_DELAYS_MS.length + 1}`} in ${delayMs}ms...\n`);
-		setBackendOutage({
-			backend: label,
-			since: outageSince ?? (outageSince = Date.now()),
-			attempts: attemptN,
-			lastError: String(lastError)
-		});
-		if (waitForever && attemptN === ESCALATE_AFTER_ATTEMPTS && !escalated) {
-			escalated = true;
-			notifyBackendDown(attemptN, String(lastError));
-		}
-		await new Promise((r) => setTimeout(r, delayMs));
-	}
-}
-async function connectPostgres(config, waitForever) {
-	return retryConnect(() => attemptPostgres(config), waitForever, "PostgreSQL backend");
-}
-/**
-* The process's one Postgres connection: storage and registry share a
-* single pg Pool (one connection budget) instead of each opening their own.
-* Whichever of createStorageBackend()/createRegistryBackend() runs first
-* creates it via connectPostgres()'s retry/outage handling; the other
-* reuses its pool through PostgresBackend.getPool(). Reset by closeStorage().
-*/
-let pgBackendPromise = null;
-function getSharedPostgresBackend(config, waitForever) {
-	if (!pgBackendPromise) pgBackendPromise = connectPostgres(config, waitForever);
-	return pgBackendPromise;
-}
-async function createSQLiteBackend() {
-	const { openFederation } = await import("./federation-db-HfIFc7FG.mjs");
-	const { SQLiteBackend } = await import("./sqlite-CqsTy6xo.mjs");
-	return new SQLiteBackend(openFederation());
-}
-/**
-* Create and return the configured RegistryBackend (projects, sessions,
-* tags, aliases, links, compaction_log). Same auto-behaviour and same
-* never-fall-back-to-SQLite rule as createStorageBackend().
-*/
-async function createRegistryBackend(config, opts = {}) {
-	if (config.storageBackend === "postgres") {
-		const storage = await getSharedPostgresBackend(config, opts.waitForPostgres ?? false);
-		const { PostgresRegistryBackend } = await import("./registry-postgres-nOfyBSIW.mjs");
-		return new PostgresRegistryBackend(storage.getPool());
-	}
-	return createSQLiteRegistryBackend();
-}
-async function createSQLiteRegistryBackend() {
-	const { openRegistry } = await import("./registry-db-JHPhA8vF.mjs");
-	const { SQLiteRegistryBackend } = await import("./registry-sqlite-DrCW1aRK.mjs");
-	return new SQLiteRegistryBackend(openRegistry());
-}
-/**
-* Process-wide backend accessors.
-*
-* Callers across the codebase must get their StorageBackend/RegistryBackend
-* from here rather than constructing SQLite or Postgres directly — this is
-* the one place that decides which backend a process uses, and the one place
-* that closes it on exit.
-*/
-let storagePromise = null;
-let registryPromise = null;
-let beforeExitRegistered = false;
-function registerBeforeExit() {
-	if (beforeExitRegistered) return;
-	beforeExitRegistered = true;
-	process.once("beforeExit", () => {
-		closeStorage();
-	});
-}
-/**
-* Returns the process-wide StorageBackend, creating it on first call.
-*
-* The whole body up to and including the `storagePromise = (async () =>
-* ...)()` assignment must run synchronously (no `await` before it) — two
-* calls issued in the same tick (e.g. `Promise.all([get(), get()])`) must
-* both observe the same cached promise rather than each racing to create
-* their own backend.
-*/
-async function getStorageBackend() {
-	if (!storagePromise) storagePromise = (async () => {
-		const { loadConfig } = await import("./config-YinjgXEJ.mjs");
-		registerBeforeExit();
-		return await createStorageBackend(loadConfig());
-	})();
-	return storagePromise;
-}
-/** Returns the process-wide RegistryBackend, creating it on first call. Same synchronous-caching requirement as getStorageBackend(). */
-async function getRegistryBackend() {
-	if (!registryPromise) registryPromise = (async () => {
-		const { loadConfig } = await import("./config-YinjgXEJ.mjs");
-		registerBeforeExit();
-		return await createRegistryBackend(loadConfig());
-	})();
-	return registryPromise;
-}
-/** Closes any backends created via getStorageBackend()/getRegistryBackend(). Idempotent. */
-async function closeStorage() {
-	const pending = [storagePromise, registryPromise];
-	const pg = pgBackendPromise;
-	storagePromise = null;
-	registryPromise = null;
-	pgBackendPromise = null;
-	for (const p of pending) {
-		if (!p) continue;
-		try {
-			const backend = await p;
-			if (backend.backendType === "postgres") continue;
-			await backend.close();
-		} catch {}
-	}
-	if (pg) try {
-		await (await pg).close();
-	} catch {}
-}
-
-//#endregion
-export { getStorageBackend as a, getRegistryBackend as i, createRegistryBackend as n, getBackendOutage as o, createStorageBackend as r, humanDuration as s, closeStorage as t };
-//# sourceMappingURL=factory-CNpPQQ-5.mjs.map

package/dist/factory-CNpPQQ-5.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"factory-CNpPQQ-5.mjs","names":[],"sources":["../src/storage/outage.ts","../src/storage/factory.ts"],"sourcesContent":["/**\n * outage.ts — is the storage backend actually reachable right now?\n *\n * The daemon retries a dead backend forever, which is correct: a Postgres\n * container that is down will usually come back, and giving up would lose the\n * work queue. What was wrong is that it did so in complete silence.\n *\n * Observed 2026-07-26: the container was down for roughly two days. The daemon\n * logged \"Postgres unavailable\" 144 times over 36 minutes, the work queue backed\n * up, session notes for the whole period were never written — and\n * `pai daemon status` reported \"Index: idle\" throughout. The one command anyone\n * would run to check said everything was fine.\n *\n * So the outage is recorded where the status command can see it, and escalated\n * once through the notification channels that were already configured and\n * already unused for this.\n */\n\nexport interface BackendOutage {\n  backend: string;\n  /** When the current run of failures began. */\n  since: number;\n  /** Consecutive failed attempts so far. */\n  attempts: number;\n  lastError: string;\n}\n\nlet current: BackendOutage | null = null;\n\n/** Record that the backend is currently unreachable. */\nexport function setBackendOutage(outage: BackendOutage): void {\n  current = outage;\n}\n\n/**\n * Record that the backend answered.\n *\n * Called on every successful connection, including the first — so a daemon that\n * never had a problem reports none, and one that recovered stops reporting an\n * outage that has ended.\n */\nexport function clearBackendOutage(): void {\n  current = null;\n}\n\n/** The current outage, or null when the backend is answering. */\nexport function getBackendOutage(): BackendOutage | null {\n  return current;\n}\n\n/**\n * Human-readable elapsed time, for a status line rather than a log.\n *\n * Exported because the status command needs the duration on its own, to colour\n * it separately from the rest of the sentence. Without this it kept a second\n * copy of the same rounding, which is how two renderings of one outage drift.\n */\nexport function humanDuration(ms: number): string {\n  const mins = Math.max(1, Math.round(ms / 60_000));\n  return mins < 60 ? `${mins} min` : `${(mins / 60).toFixed(1)} h`;\n}\n\n/** Human-readable duration, for a status line rather than a log. */\nexport function describeOutage(o: BackendOutage, now = Date.now()): string {\n  return `${o.backend} unreachable for ${humanDuration(now - o.since)}, ${o.attempts} attempts — ${o.lastError}`;\n}\n","/**\n * Storage backend factory.\n *\n * Reads the daemon config and returns the appropriate StorageBackend.\n *\n * When Postgres is the configured backend we NEVER silently fall back to\n * SQLite — doing so would split the corpus across two databases. Instead:\n *  - Daemon (waitForPostgres: true) retries Postgres forever with capped\n *    backoff until it comes up (handles the boot race where launchd starts\n *    the daemon before Docker Desktop / Postgres is ready).\n *  - CLI / one-shot callers (default) retry a few times, then throw a clear\n *    error rather than returning a wrong/empty SQLite database.\n */\n\nimport type { PaiDaemonConfig } from \"../daemon/config.js\";\nimport type { StorageBackend } from \"./interface.js\";\nimport type { RegistryBackend } from \"./registry-interface.js\";\nimport { setBackendOutage, clearBackendOutage } from \"./outage.js\";\n\nexport interface StorageBackendOptions {\n  /**\n   * When true, retry Postgres indefinitely instead of giving up. Used by the\n   * long-lived daemon so a not-yet-ready Postgres at boot is tolerated.\n   * Defaults to false (one-shot CLI behaviour: bounded retries, then throw).\n   */\n  waitForPostgres?: boolean;\n}\n\n/** Backoff schedule (ms) for the bounded CLI retry path. */\nconst CLI_RETRY_DELAYS_MS = [500, 1_000, 2_000];\n\n/** Backoff cap (ms) for the daemon's infinite retry path. */\nconst DAEMON_RETRY_CAP_MS = 15_000;\n\n/**\n * Create and return the configured StorageBackend.\n *\n * Auto-behaviour:\n *  - storageBackend = \"sqlite\"   → SQLiteBackend always\n *  - storageBackend = \"postgres\" → PostgresBackend (retried; never falls back)\n */\nexport async function createStorageBackend(\n  config: PaiDaemonConfig,\n  opts: StorageBackendOptions = {}\n): Promise<StorageBackend> {\n  if (config.storageBackend === \"postgres\") {\n    return await getSharedPostgresBackend(config, opts.waitForPostgres ?? false);\n  }\n\n  // Default: SQLite\n  return createSQLiteBackend();\n}\n\n/**\n * Attempt a single Postgres connection (ensure DB + test). Returns the live\n * backend on success, or an error string describing why it failed.\n */\nasync function attemptPostgres(\n  config: PaiDaemonConfig\n): Promise<{ backend: StorageBackend } | { error: string }> {\n  const { PostgresBackend } = await import(\"./postgres.js\");\n  const pgConfig = config.postgres ?? {};\n\n  let backend: InstanceType<typeof PostgresBackend> | null = null;\n  try {\n    // Ensure the per-user database exists and has the schema applied.\n    await PostgresBackend.ensureDatabase(pgConfig);\n\n    backend = new PostgresBackend(pgConfig);\n    const err = await backend.testConnection();\n    if (err) {\n      await backend.close().catch(() => {});\n      return { error: err };\n    }\n    return { backend };\n  } catch (e) {\n    if (backend) await backend.close().catch(() => {});\n    return { error: e instanceof Error ? e.message : String(e) };\n  }\n}\n\n/**\n * Consecutive failures before the outage is escalated to the user.\n *\n * Not the first failure: a container restarting, or the daemon starting before\n * Docker is up, recovers within a few seconds and is not worth a notification.\n * By the fifth attempt the backoff has already spent tens of seconds, which is\n * long enough that something is actually wrong.\n */\nconst ESCALATE_AFTER_ATTEMPTS = 5;\n\n/** Tell the user the backend is down, through whatever channels are configured. */\nasync function notifyBackendDown(attempts: number, lastError: string): Promise<void> {\n  try {\n    const { routeNotification } = await import(\"../notifications/router.js\");\n    const { loadConfig } = await import(\"../daemon/config.js\");\n    await routeNotification(\n      {\n        event: \"error\",\n        title: \"PAI: storage backend unreachable\",\n        message:\n          `Postgres has not answered in ${attempts} attempts (${lastError}). ` +\n          `Indexing, session notes and the work queue are stalled until it returns. ` +\n          `Check the container, then \\`pai daemon status\\`.`,\n      },\n      loadConfig().notifications\n    );\n  } catch {\n    // A notification that cannot be sent must never take the daemon down with\n    // it — the daemon retrying is still the useful behaviour here.\n  }\n}\n\n/** And say when it comes back, so the alert is not left hanging. */\nasync function notifyBackendRecovered(\n  attempts: number,\n  since: number | null\n): Promise<void> {\n  try {\n    const { routeNotification } = await import(\"../notifications/router.js\");\n    const { loadConfig } = await import(\"../daemon/config.js\");\n    const mins = since ? Math.max(1, Math.round((Date.now() - since) / 60_000)) : null;\n    await routeNotification(\n      {\n        event: \"completion\",\n        title: \"PAI: storage backend back\",\n        message:\n          `Postgres answered after ${attempts} attempts` +\n          (mins ? `, ${mins} min down` : \"\") +\n          `. The queue will drain on its own.`,\n      },\n      loadConfig().notifications\n    );\n  } catch {\n    /* same reasoning as above */\n  }\n}\n\n/**\n * Shared retry loop: attempt a connection, back off, escalate, repeat — used\n * by both the federation and registry Postgres connectors so the retry/outage\n * behaviour (§6, \"never falls back to SQLite silently\") stays in one place.\n */\nasync function retryConnect<T>(\n  attempt: () => Promise<{ backend: T } | { error: string }>,\n  waitForever: boolean,\n  label: string\n): Promise<T> {\n  let attemptN = 0;\n  let outageSince: number | null = null;\n  let escalated = false;\n\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    attemptN++;\n    const result = await attempt();\n    if (\"backend\" in result) {\n      if (attemptN > 1) process.stderr.write(`[pai-daemon] Connected to ${label} (after ${attemptN} attempts).\\n`);\n      // An outage that ended must stop being reported, or the status command\n      // trades one wrong answer for another.\n      clearBackendOutage();\n      if (escalated) void notifyBackendRecovered(attemptN, outageSince);\n      return result.backend;\n    }\n\n    const lastError = result.error;\n\n    if (!waitForever && attemptN > CLI_RETRY_DELAYS_MS.length) {\n      // Bounded CLI path exhausted — fail loudly, never silently use SQLite.\n      throw new Error(\n        `${label} unreachable after ${attemptN} attempts: ${lastError}. ` +\n          `Is Docker Desktop / Postgres running? Refusing to fall back to SQLite ` +\n          `(would split the corpus). Start Postgres and retry.`\n      );\n    }\n\n    const delayMs = waitForever\n      ? Math.min(DAEMON_RETRY_CAP_MS, 1_000 * 2 ** Math.min(attemptN - 1, 4))\n      : CLI_RETRY_DELAYS_MS[attemptN - 1];\n\n    process.stderr.write(\n      `[pai-daemon] ${label} unavailable (${lastError}). ` +\n        `Retry ${attemptN}${waitForever ? \"\" : `/${CLI_RETRY_DELAYS_MS.length + 1}`} ` +\n        `in ${delayMs}ms...\\n`\n    );\n\n    // Publish the outage so `pai daemon status` can report it. Without this the\n    // daemon retries silently forever and status still reads \"idle\" — which is\n    // what happened for two days in July: 144 retries over 36 minutes, session\n    // notes never written, and the one command anyone would run to check\n    // reporting that everything was fine.\n    setBackendOutage({\n      backend: label,\n      since: outageSince ?? (outageSince = Date.now()),\n      attempts: attemptN,\n      lastError: String(lastError),\n    });\n\n    // And escalate once, out loud, rather than only into a log nobody tails.\n    // Once — not per retry — because a notification that repeats every few\n    // seconds is filtered within a minute and stops being a signal at all.\n    if (waitForever && attemptN === ESCALATE_AFTER_ATTEMPTS && !escalated) {\n      escalated = true;\n      void notifyBackendDown(attemptN, String(lastError));\n    }\n\n    await new Promise((r) => setTimeout(r, delayMs));\n  }\n}\n\nasync function connectPostgres(\n  config: PaiDaemonConfig,\n  waitForever: boolean\n): Promise<StorageBackend> {\n  return retryConnect(() => attemptPostgres(config), waitForever, \"PostgreSQL backend\");\n}\n\n/**\n * The process's one Postgres connection: storage and registry share a\n * single pg Pool (one connection budget) instead of each opening their own.\n * Whichever of createStorageBackend()/createRegistryBackend() runs first\n * creates it via connectPostgres()'s retry/outage handling; the other\n * reuses its pool through PostgresBackend.getPool(). Reset by closeStorage().\n */\nlet pgBackendPromise: Promise<StorageBackend> | null = null;\n\nfunction getSharedPostgresBackend(\n  config: PaiDaemonConfig,\n  waitForever: boolean\n): Promise<StorageBackend> {\n  if (!pgBackendPromise) {\n    pgBackendPromise = connectPostgres(config, waitForever);\n  }\n  return pgBackendPromise;\n}\n\nasync function createSQLiteBackend(): Promise<StorageBackend> {\n  const { openFederation } = await import(\"./sqlite/federation-db.js\");\n  const { SQLiteBackend } = await import(\"./sqlite.js\");\n  const db = openFederation();\n  return new SQLiteBackend(db);\n}\n\n/**\n * Create and return the configured RegistryBackend (projects, sessions,\n * tags, aliases, links, compaction_log). Same auto-behaviour and same\n * never-fall-back-to-SQLite rule as createStorageBackend().\n */\nexport async function createRegistryBackend(\n  config: PaiDaemonConfig,\n  opts: StorageBackendOptions = {}\n): Promise<RegistryBackend> {\n  if (config.storageBackend === \"postgres\") {\n    // Reuses the storage backend's pool (getSharedPostgresBackend) rather\n    // than opening a second one against the same database.\n    const storage = await getSharedPostgresBackend(config, opts.waitForPostgres ?? false);\n    const { PostgresRegistryBackend } = await import(\"./registry-postgres.js\");\n    const pool = (storage as unknown as { getPool: () => import(\"pg\").Pool }).getPool();\n    return new PostgresRegistryBackend(pool);\n  }\n  return createSQLiteRegistryBackend();\n}\n\nasync function createSQLiteRegistryBackend(): Promise<RegistryBackend> {\n  const { openRegistry } = await import(\"./sqlite/registry-db.js\");\n  const { SQLiteRegistryBackend } = await import(\"./registry-sqlite.js\");\n  const db = openRegistry();\n  return new SQLiteRegistryBackend(db);\n}\n\n/**\n * Process-wide backend accessors.\n *\n * Callers across the codebase must get their StorageBackend/RegistryBackend\n * from here rather than constructing SQLite or Postgres directly — this is\n * the one place that decides which backend a process uses, and the one place\n * that closes it on exit.\n */\n\nlet storagePromise: Promise<StorageBackend> | null = null;\nlet registryPromise: Promise<RegistryBackend> | null = null;\nlet beforeExitRegistered = false;\n\nfunction registerBeforeExit(): void {\n  if (beforeExitRegistered) return;\n  beforeExitRegistered = true;\n  process.once(\"beforeExit\", () => {\n    void closeStorage();\n  });\n}\n\n/**\n * Returns the process-wide StorageBackend, creating it on first call.\n *\n * The whole body up to and including the `storagePromise = (async () =>\n * ...)()` assignment must run synchronously (no `await` before it) — two\n * calls issued in the same tick (e.g. `Promise.all([get(), get()])`) must\n * both observe the same cached promise rather than each racing to create\n * their own backend.\n */\nexport async function getStorageBackend(): Promise<StorageBackend> {\n  if (!storagePromise) {\n    storagePromise = (async () => {\n      const { loadConfig } = await import(\"../daemon/config.js\");\n      registerBeforeExit();\n      return await createStorageBackend(loadConfig());\n    })();\n  }\n  return storagePromise;\n}\n\n/** Returns the process-wide RegistryBackend, creating it on first call. Same synchronous-caching requirement as getStorageBackend(). */\nexport async function getRegistryBackend(): Promise<RegistryBackend> {\n  if (!registryPromise) {\n    registryPromise = (async () => {\n      const { loadConfig } = await import(\"../daemon/config.js\");\n      registerBeforeExit();\n      return await createRegistryBackend(loadConfig());\n    })();\n  }\n  return registryPromise;\n}\n\n/** Closes any backends created via getStorageBackend()/getRegistryBackend(). Idempotent. */\nexport async function closeStorage(): Promise<void> {\n  const pending = [storagePromise, registryPromise];\n  const pg = pgBackendPromise;\n  storagePromise = null;\n  registryPromise = null;\n  pgBackendPromise = null;\n  for (const p of pending) {\n    if (!p) continue;\n    try {\n      const backend = await p;\n      // Postgres backends share one pool owned by pgBackendPromise (closed\n      // below) — closing them here too would end() it twice.\n      if (backend.backendType === \"postgres\") continue;\n      await backend.close();\n    } catch {\n      // A backend that never connected has nothing to close.\n    }\n  }\n  if (pg) {\n    try {\n      await (await pg).close();\n    } catch {\n      // Never connected — nothing to close.\n    }\n  }\n}\n\n/** Test-only: clear the process-wide cache without closing (tests own their own lifecycle). */\nexport function __resetStorageForTests(): void {\n  storagePromise = null;\n  registryPromise = null;\n  pgBackendPromise = null;\n}\n"],"mappings":"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"}

package/dist/factory-DY7x73mE.mjs

@@ -1,3 +0,0 @@
-import { a as getStorageBackend, i as getRegistryBackend, n as createRegistryBackend, r as createStorageBackend, t as closeStorage } from "./factory-CNpPQQ-5.mjs";
-
-export { createStorageBackend, getRegistryBackend };