@powerhousedao/switchboard 6.2.3-dev.43 → 6.2.3-dev.45

package/dist/server.d.mts

@@ -1,5 +1,5 @@
 import { ILogger } from "document-model";
-import { ChannelScheme, IDocumentModelLoader, IReactorClient, InProcessReactorClientModule, JwtHandler, ReactorBuilder, ReactorClientBuilder, ReactorFeatureFlags, SignerConfig, UnsupportedStoredDocuments, UnsupportedStoredProtocolError } from "@powerhousedao/reactor";
+import { ChannelScheme, IDocumentModelLoader, IReactorClient, InProcessReactorClientModule, JwtHandler, ModelManifestEntry, ReactorBuilder, ReactorClientBuilder, ReactorFeatureFlags, SignerConfig, UnsupportedStoredDocuments, UnsupportedStoredProtocolError } from "@powerhousedao/reactor";
 import { AttachmentReferenceProjectionCapability } from "@powerhousedao/reactor-api";
 import { IAttachmentService } from "@powerhousedao/reactor-attachments";
 import { IRenown } from "@renown/sdk/node";
@@ -206,6 +206,8 @@ export type SwitchboardReactor = {
   workflowTriggers?: WorkflowTriggersCapability;
   /** Whether workflows are on, after the option, PH_WORKFLOWS_ENABLED and the config file. */
   workflowsEnabled: boolean;
+  /** The boot list of importable models workers and workflow pieces load; empty when none are resolved. */
+  modelManifest(): ModelManifestEntry[];
   /** Present when the privacy add-on runs: its erasure service. */
   privacy?: {
     erasure: IErasureService;

package/dist/server.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.mts","names":[],"sources":["../src/privacy.mts","../src/workflow-runtime.mts","../src/types.ts","../src/builder-defaults.mts","../src/unsupported-stored-documents.mts","../src/server.mts"],"mappings":";;;;;;;;;;;;KAyBY;;EAEV;;EAEA;;EAEA,SAAS;;;;;;KCsBC;EACN;;EAEA;EACA;;;;;;;;;;YCpCM;;YAKA,wBAAwB;EAClC,eAAe;;YAGL;EACV;EACA;EACA;;YAGU;;EAEV;;;;;EAKA;;EAGA;;YAGU;;;;;;;;;;;;;;;;;;;;;EAqBV,UAAU;;;;;;;;EAQV;;;;;;;EAOA;EACA;EACA;;;;;;EAMA;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA;IAEM;IACA;;;;;;;EASN,WAAW;;EAEX;;;EAGA;;;EAGA;IACE;;;EAGF,UAAU;EACV,kBAAkB;EAClB;EACA;;;;;;EAMA;EACA,SAAS;;;;;;;;;;EAUT;;;;;;;;;;EAUA;;;;;;;;;EASA;IACE;IACA;IACA;;;;;;;;;;;EAWF;IACE;IACA;;;;;;;;;EASF,6BAA6B;;YAGnB;EACV;EACA,SAAS;;EAET,mBAAmB;;EAEnB,+BAA+B;;;EAG/B,mBAAmB;;EAEnB;;EAEA;IAAY,SAAS;;;EAErB;;EAEA,QAAQ;;;;;EAKR;;;;;;;;;;;;;EAaA,gBAAgB;;;;KC5MN;EAIV,iBAAiB;;EAEjB,mBAAmB;;EAEnB;;;;;;EAMA,gBAAgB;;EAEhB;;EAEA;IACE;IACA,eAAe,QAAQ;;;EAGzB,sBAAsB;EACtB,SAAS;;;;;;EAMT,SAAS;;;;;EAKT,cAAc,KAAK;;EAEnB,wBAAwB;;wBAsBV,gCACd,gBAAgB,gBAChB,eAAe,sBACf,UAAS;;;;wBC3EK,kCACd,OAAO,wCACP,KAAK,OAAO,aACX;;qBAaU,oCAAoC;WACtC;IAAqB;IAAkB;;WACvC;EAET,YAAY,OAAO;SAcZ,QAAQ,iBAAiB,SAAS;;;;;;;;;wBCyH3B,gBAAgB,eAAe;;wBAwI/B,8BACd,SAAS,KAAK,uDACd,oBACA,QAAQ;EACL;EAAmB,YAAY;;;;;;;;;;;;;;;;;;;qBAi+BvB,mBAAgB,UAClB,uBACR,QAAQ"}
+{"version":3,"file":"server.d.mts","names":[],"sources":["../src/privacy.mts","../src/workflow-runtime.mts","../src/types.ts","../src/builder-defaults.mts","../src/unsupported-stored-documents.mts","../src/server.mts"],"mappings":";;;;;;;;;;;;KAyBY;;EAEV;;EAEA;;EAEA,SAAS;;;;;;KC8BC;EACN;;EAEA;EACA;;;;;;;;;;YC3CM;;YAKA,wBAAwB;EAClC,eAAe;;YAGL;EACV;EACA;EACA;;YAGU;;EAEV;;;;;EAKA;;EAGA;;YAGU;;;;;;;;;;;;;;;;;;;;;EAqBV,UAAU;;;;;;;;EAQV;;;;;;;EAOA;EACA;EACA;;;;;;EAMA;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA;IAEM;IACA;;;;;;;EASN,WAAW;;EAEX;;;EAGA;;;EAGA;IACE;;;EAGF,UAAU;EACV,kBAAkB;EAClB;EACA;;;;;;EAMA;EACA,SAAS;;;;;;;;;;EAUT;;;;;;;;;;EAUA;;;;;;;;;EASA;IACE;IACA;IACA;;;;;;;;;;;EAWF;IACE;IACA;;;;;;;;;EASF,6BAA6B;;YAGnB;EACV;EACA,SAAS;;EAET,mBAAmB;;EAEnB,+BAA+B;;;EAG/B,mBAAmB;;EAEnB;;EAEA,iBAAiB;;EAEjB;IAAY,SAAS;;;EAErB;;EAEA,QAAQ;;;;;EAKR;;;;;;;;;;;;;EAaA,gBAAgB;;;;KC/MN;EAIV,iBAAiB;;EAEjB,mBAAmB;;EAEnB;;;;;;EAMA,gBAAgB;;EAEhB;;EAEA;IACE;IACA,eAAe,QAAQ;;;EAGzB,sBAAsB;EACtB,SAAS;;;;;;EAMT,SAAS;;;;;EAKT,cAAc,KAAK;;EAEnB,wBAAwB;;wBAsBV,gCACd,gBAAgB,gBAChB,eAAe,sBACf,UAAS;;;;wBC3EK,kCACd,OAAO,wCACP,KAAK,OAAO,aACX;;qBAaU,oCAAoC;WACtC;IAAqB;IAAkB;;WACvC;EAET,YAAY,OAAO;SAcZ,QAAQ,iBAAiB,SAAS;;;;;;;;;wBCoK3B,gBAAgB,eAAe;;wBAoI/B,8BACd,SAAS,KAAK,uDACd,oBACA,QAAQ;EACL;EAAmB,YAAY;;;;;;;;;;;;;;;;;;;qBAm7BvB,mBAAgB,UAClB,uBACR,QAAQ"}

package/dist/server.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as resolveUnsupportedStoredDocuments, i as StoredDocumentsRefusedError, n as isPortAvailable, o as applySwitchboardReactorDefaults, r as startSwitchboard, t as deriveAttachmentServiceConfig } from "./server-CMAxYG6D.mjs";
+import { a as resolveUnsupportedStoredDocuments, i as StoredDocumentsRefusedError, n as isPortAvailable, o as applySwitchboardReactorDefaults, r as startSwitchboard, t as deriveAttachmentServiceConfig } from "./server-Dvw8_NeM.mjs";
 export { StoredDocumentsRefusedError, applySwitchboardReactorDefaults, deriveAttachmentServiceConfig, isPortAvailable, resolveUnsupportedStoredDocuments, startSwitchboard };
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a4c8ff4a-a754-5a57-860f-5cadf1712728")}catch(e){}}();
-//# debugId=a4c8ff4a-a754-5a57-860f-5cadf1712728
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="b5bdc179-e9e6-50c3-a581-a82e554e7130")}catch(e){}}();
+//# debugId=b5bdc179-e9e6-50c3-a581-a82e554e7130

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@powerhousedao/switchboard",
   "type": "module",
-  "version": "6.2.3-dev.43",
+  "version": "6.2.3-dev.45",
   "main": "dist/index.mjs",
   "exports": {
     ".": {
@@ -41,7 +41,7 @@
     "@openfeature/core": "1.9.1",
     "@openfeature/env-var-provider": "0.3.1",
     "@openfeature/server-sdk": "1.19.0",
-    "@powerhousedao/config": "6.2.3-dev.43",
+    "@powerhousedao/config": "6.2.3-dev.45",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/exporter-metrics-otlp-http": "^0.218.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.218.0",
@@ -55,23 +55,22 @@
     "@opentelemetry/sdk-node": "^0.218.0",
     "@opentelemetry/sdk-trace-base": "^2.7.1",
     "@opentelemetry/semantic-conventions": "^1.41.1",
-    "@powerhousedao/opentelemetry-instrumentation-reactor": "6.2.3-dev.43",
-    "@powerhousedao/reactor": "6.2.3-dev.43",
-    "@powerhousedao/shared": "6.2.3-dev.43",
-    "@powerhousedao/vetra": "6.2.3-dev.43",
-    "@powerhousedao/reactor-api": "6.2.3-dev.43",
-    "@powerhousedao/reactor-attachments": "6.2.3-dev.43",
-    "@powerhousedao/reactor-drive": "6.2.3-dev.43",
-    "@powerhousedao/reactor-group": "6.2.3-dev.43",
-    "@powerhousedao/reactor-privacy": "6.2.3-dev.43",
-    "@powerhousedao/reactor-workflow": "6.2.3-dev.43",
-    "@powerhousedao/workflow": "6.2.3-dev.43",
-    "@powerhousedao/pglite-fs": "6.2.3-dev.43",
+    "@powerhousedao/opentelemetry-instrumentation-reactor": "6.2.3-dev.45",
+    "@powerhousedao/reactor": "6.2.3-dev.45",
+    "@powerhousedao/shared": "6.2.3-dev.45",
+    "@powerhousedao/vetra": "6.2.3-dev.45",
+    "@powerhousedao/reactor-api": "6.2.3-dev.45",
+    "@powerhousedao/reactor-attachments": "6.2.3-dev.45",
+    "@powerhousedao/reactor-drive": "6.2.3-dev.45",
+    "@powerhousedao/reactor-group": "6.2.3-dev.45",
+    "@powerhousedao/reactor-privacy": "6.2.3-dev.45",
+    "@powerhousedao/reactor-workflow": "6.2.3-dev.45",
+    "@powerhousedao/workflow": "6.2.3-dev.45",
     "@pyroscope/nodejs": "^0.4.5",
-    "@renown/sdk": "6.2.3-dev.43",
+    "@renown/sdk": "6.2.3-dev.45",
     "@sentry/node": "^10.53.1",
     "@sentry/opentelemetry": "^10.53.1",
-    "document-model": "6.2.3-dev.43",
+    "document-model": "6.2.3-dev.45",
     "dotenv": "^16.4.7",
     "express": "^4.22.1",
     "graphql": "^16",

package/test/boot-unsupported-stored-documents.test.ts

@@ -1,5 +1,5 @@
 import { PGlite } from "@electric-sql/pglite";
-import { AtomicNodeFs } from "@powerhousedao/pglite-fs";
+import { NodeFS } from "@electric-sql/pglite/nodefs";
 import {
   JobStatus,
   ReactorBuilder,
@@ -65,9 +65,7 @@ function stubLogger(): StubLogger {
 /** A reactor store holding one drive created at base-reducer 7. */
 async function seedStore(dir: string): Promise<void> {
   const db = new Kysely<Database>({
-    dialect: new ClosablePGliteDialect(
-      new PGlite({ fs: new AtomicNodeFs(dir) }),
-    ),
+    dialect: new ClosablePGliteDialect(new PGlite({ fs: new NodeFS(dir) })),
   });
   const module = await new ReactorBuilder()
     .withKysely(db)
@@ -89,7 +87,7 @@ async function seedStore(dir: string): Promise<void> {
       const { status } = await module.reactor.getJobStatus(created.id);
       return status === JobStatus.READ_READY || status === JobStatus.FAILED;
     },
-    // One job is ~40 full snapshots; the Windows runner needs the boot budget.
+    // PGlite is several times slower on the Windows runner.
     { timeout: BOOT_TIMEOUT, interval: 5 },
   );
   expect((await module.reactor.getJobStatus(created.id)).status).toBe(
@@ -97,6 +95,8 @@ async function seedStore(dir: string): Promise<void> {
   );
   await module.reactor.kill().completed;
   await db.destroy();
+  // PGlite leaves its lockfile behind after a clean close.
+  await rm(join(dir, "postmaster.pid"), { force: true });
 }
 
 // PGlite boots are several times slower on Windows runners.

package/test/durable-node-fs-pg16.test.ts

@@ -0,0 +1,80 @@
+import { createDurableNodeFs } from "@powerhousedao/reactor-api/pglite-node";
+import nodeFs, { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { loadNodeFsClass, loadPGliteModule } from "../src/pglite-version.js";
+
+// A fresh initdb takes ~10 s under suite load; the Windows runner is slower.
+const BOOT = 180_000;
+const COMMITS = 10;
+const RM = { recursive: true, force: true, maxRetries: 10 } as const;
+
+describe("durable NodeFS over pglite-legacy-02 (PG16)", () => {
+  const tempDirs: string[] = [];
+
+  afterEach(async () => {
+    for (const dir of tempDirs.splice(0)) {
+      await fs.rm(dir, RM);
+    }
+  });
+
+  it(
+    "opens a PG16 dir over pglite-legacy-02 with the durable fs",
+    async () => {
+      const dir = await fs.mkdtemp(path.join(os.tmpdir(), "durable-pg16-"));
+      tempDirs.push(dir);
+      const counts = { fsync: 0, fdatasync: 0 };
+      const hostFs = {
+        fsyncSync: (fd: number) => {
+          counts.fsync++;
+          nodeFs.fsyncSync(fd);
+        },
+        fdatasyncSync: (fd: number) => {
+          counts.fdatasync++;
+          nodeFs.fdatasyncSync(fd);
+        },
+      };
+      const [{ PGlite }, NodeFS] = await Promise.all([
+        loadPGliteModule(16),
+        loadNodeFsClass(16),
+      ]);
+      const pg = new PGlite({
+        fs: createDurableNodeFs(NodeFS, dir, {
+          hostFs,
+          maintenanceIntervalMs: 0,
+        }),
+      });
+      try {
+        await pg.waitReady;
+        const version = await pg.query<{ v: string }>(
+          "SELECT current_setting('server_version_num') AS v",
+        );
+        expect(version.rows[0].v.startsWith("16")).toBe(true);
+        await pg.exec("CREATE TABLE t (v int)");
+        const before = counts.fdatasync;
+        for (let i = 0; i < COMMITS; i++) {
+          await pg.exec(`INSERT INTO t VALUES (${i})`);
+        }
+        const perCommit = counts.fdatasync - before;
+        const fsyncBefore = counts.fsync;
+        await pg.exec("CHECKPOINT");
+        const checkpointSyncs = counts.fsync - fsyncBefore;
+        console.info(
+          `pglite-legacy-02: ${perCommit} host fdatasync over ${COMMITS} commits, ${checkpointSyncs} host fsync on CHECKPOINT, ${fsyncBefore} host fsync since open`,
+        );
+        // Pins decision 5's outcome on 0.2.17: WAL goes through
+        // open_datasync, which never reaches the fdatasync hook, so commits
+        // are not synced; the stream-op patch does take (CHECKPOINT syncs).
+        expect(perCommit).toBe(0);
+        expect(checkpointSyncs).toBeGreaterThan(0);
+      } finally {
+        await pg.close();
+      }
+      expect(
+        (await fs.readFile(path.join(dir, "PG_VERSION"), "utf8")).trim(),
+      ).toBe("16");
+    },
+    BOOT,
+  );
+});

package/test/fatal-shutdown.test.ts

@@ -94,6 +94,39 @@ describe("installFatalErrorShutdown", () => {
     expect(proc.exit).not.toHaveBeenCalled();
   });
 
+  it("still reaches exit when the logger itself throws EPIPE inside onFatal", () => {
+    vi.useFakeTimers();
+    const proc = makeProc();
+    const onSigterm = vi.fn();
+    proc.on("SIGTERM", onSigterm);
+    const error = vi.fn(() => {
+      throw Object.assign(new Error("write EPIPE"), { code: "EPIPE" });
+    });
+    const throwingLogger = { error } as unknown as Parameters<
+      typeof installFatalErrorShutdown
+    >[0];
+    installFatalErrorShutdown(throwingLogger, proc as never);
+
+    // Without the guard the EPIPE propagates out of the uncaughtException
+    // listener, which in a real process re-enters fatal handling instead of
+    // running the shutdown.
+    expect(() =>
+      proc.emit("uncaughtException", new Error("boom")),
+    ).not.toThrow();
+
+    expect(proc.kill).toHaveBeenCalledOnce();
+    expect(onSigterm).toHaveBeenCalledOnce();
+    expect(proc.exitCode).toBe(1);
+
+    vi.advanceTimersByTime(15_000);
+
+    expect(proc.exit).toHaveBeenCalledTimes(1);
+    expect(proc.exit).toHaveBeenCalledWith(1);
+    // Exactly the two guarded log attempts: the fatal report and the
+    // forced-exit notice. A re-entered handler would log again.
+    expect(error).toHaveBeenCalledTimes(2);
+  });
+
   it("routes a triggered fatal error through SIGTERM with exit code 1", () => {
     const proc = makeProc();
     const onSigterm = vi.fn();

package/test/observability-signals.test.ts

@@ -0,0 +1,131 @@
+import { EventEmitter } from "node:events";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { installFatalErrorShutdown } from "../src/fatal-shutdown.mjs";
+import { installObservabilitySignalHandlers } from "../src/observability-signals.mjs";
+
+function makeProc() {
+  const emitter = new EventEmitter();
+  const proc = Object.assign(emitter, {
+    pid: 1234,
+    exitCode: undefined as number | undefined,
+    kill: vi.fn((_pid: number, signal: string) => {
+      emitter.emit(signal);
+      return true;
+    }),
+    exit: vi.fn(),
+  });
+  return proc;
+}
+
+const logger = {
+  error: vi.fn(),
+} as unknown as Parameters<typeof installFatalErrorShutdown>[0];
+
+/** Lets the finally callback behind the flush promise run. */
+async function settleMicrotasks(): Promise<void> {
+  await Promise.resolve();
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
+describe("installObservabilitySignalHandlers", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it.each(["SIGINT", "SIGTERM"])(
+    "exits 0 after the flush on an ordinary %s",
+    async (signal) => {
+      const proc = makeProc();
+      const flush = vi.fn(() => Promise.resolve());
+      installObservabilitySignalHandlers(flush, proc as never);
+
+      proc.emit(signal);
+      await settleMicrotasks();
+
+      expect(flush).toHaveBeenCalledOnce();
+      expect(proc.exit).toHaveBeenCalledExactlyOnceWith(0);
+    },
+  );
+
+  it("does not exit before the flush settles", async () => {
+    const proc = makeProc();
+    let finish: () => void = () => undefined;
+    const flush = vi.fn(
+      () => new Promise<void>((resolve) => (finish = resolve)),
+    );
+    installObservabilitySignalHandlers(flush, proc as never);
+
+    proc.emit("SIGTERM");
+    await settleMicrotasks();
+    expect(proc.exit).not.toHaveBeenCalled();
+
+    finish();
+    await settleMicrotasks();
+    expect(proc.exit).toHaveBeenCalledExactlyOnceWith(0);
+  });
+
+  it("keeps exit code 1 when a fatal error raised the SIGTERM", async () => {
+    vi.useFakeTimers();
+    const proc = makeProc();
+    const flush = vi.fn(() => Promise.resolve());
+    // Production order: observability's handlers install at module load,
+    // before the fatal handlers.
+    installObservabilitySignalHandlers(flush, proc as never);
+    installFatalErrorShutdown(logger, proc as never);
+
+    proc.emit("uncaughtException", new Error("boom"));
+    expect(proc.exitCode).toBe(1);
+    await settleMicrotasks();
+
+    // The flush ran, but observability never lowered the code to 0; the
+    // process is still alive inside the fatal path's drain budget.
+    expect(flush).toHaveBeenCalledOnce();
+    expect(proc.exit).not.toHaveBeenCalled();
+
+    // Fatal-shutdown's backstop owns the exit and preserves code 1.
+    vi.advanceTimersByTime(15_000);
+    expect(proc.exit).toHaveBeenCalledExactlyOnceWith(1);
+    expect(proc.exit).not.toHaveBeenCalledWith(0);
+    expect(proc.exitCode).toBe(1);
+  });
+
+  it("leaves the fatal drain budget intact even when the flush is slow", async () => {
+    vi.useFakeTimers();
+    const proc = makeProc();
+    let finish: () => void = () => undefined;
+    const flush = vi.fn(
+      () => new Promise<void>((resolve) => (finish = resolve)),
+    );
+    installObservabilitySignalHandlers(flush, proc as never);
+    installFatalErrorShutdown(logger, proc as never);
+
+    proc.emit("uncaughtException", new Error("boom"));
+
+    // The flush gives up at its own ~5s budget (simulated by resolving it
+    // here); that settling must not force an exit ahead of the drain.
+    vi.advanceTimersByTime(5_000);
+    finish();
+    await settleMicrotasks();
+    expect(proc.exit).not.toHaveBeenCalled();
+
+    // Only the 15s fatal backstop ends the process, with code 1.
+    vi.advanceTimersByTime(9_999);
+    expect(proc.exit).not.toHaveBeenCalled();
+    vi.advanceTimersByTime(1);
+    expect(proc.exit).toHaveBeenCalledExactlyOnceWith(1);
+  });
+
+  it("respects a non-zero exit code set by any other module", async () => {
+    const proc = makeProc();
+    proc.exitCode = 1;
+    const flush = vi.fn(() => Promise.resolve());
+    installObservabilitySignalHandlers(flush, proc as never);
+
+    proc.emit("SIGTERM");
+    await settleMicrotasks();
+
+    expect(flush).toHaveBeenCalledOnce();
+    expect(proc.exit).not.toHaveBeenCalled();
+  });
+});

package/test/pglite-dialect.test.ts

@@ -26,6 +26,34 @@ describe("ClosablePGliteDialect", () => {
     expect(pglite.closed).toBe(true);
   });
 
+  it("tolerates a close that rejects because the runtime aborted", async () => {
+    const pglite = new PGlite();
+    created.push(pglite);
+    const db = new Kysely({ dialect: new ClosablePGliteDialect(pglite) });
+    await sql`select 1`.execute(db);
+    const realClose = pglite.close.bind(pglite);
+    pglite.close = () => {
+      pglite.close = realClose;
+      return Promise.reject(new Error("PGlite aborted: ENOSPC"));
+    };
+
+    await expect(db.destroy()).resolves.toBeUndefined();
+  });
+
+  it("rethrows a close that fails for any other reason", async () => {
+    const pglite = new PGlite();
+    created.push(pglite);
+    const db = new Kysely({ dialect: new ClosablePGliteDialect(pglite) });
+    await sql`select 1`.execute(db);
+    const realClose = pglite.close.bind(pglite);
+    pglite.close = () => {
+      pglite.close = realClose;
+      return Promise.reject(new Error("disk gone"));
+    };
+
+    await expect(db.destroy()).rejects.toThrow("disk gone");
+  });
+
   it("is idempotent if the PGlite is already closed", async () => {
     const pglite = new PGlite();
     created.push(pglite);