@powerhousedao/switchboard 6.2.3-dev.50 → 6.2.3-dev.52

package/dist/server.d.mts

@@ -1,6 +1,6 @@
 import { ILogger } from "document-model";
 import "@powerhousedao/reactor-api/pglite-node";
-import { ChannelScheme, Database, IDocumentModelLoader, IReactorClient, InProcessReactorClientModule, JwtHandler, ModelManifestEntry, PoolInstrumentation, ReactorBuilder, ReactorClientBuilder, ReactorFeatureFlags, SignerConfig, UnsupportedStoredDocuments, UnsupportedStoredProtocolError } from "@powerhousedao/reactor";
+import { ChannelScheme, Database, IDocumentModelLoader, IReactorClient, InProcessReactorClientModule, JwtHandler, ModelManifestEntry, PoolInstrumentation, ReactorBuilder, ReactorClientBuilder, ReactorFeatureFlags, ReactorStorageFacts, SignerConfig, UnsupportedStoredDocuments, UnsupportedStoredProtocolError } from "@powerhousedao/reactor";
 import { AttachmentReferenceProjectionCapability } from "@powerhousedao/reactor-api";
 import { IAttachmentService } from "@powerhousedao/reactor-attachments";
 import { IRenown } from "@renown/sdk/node";
@@ -33,7 +33,7 @@ type WorkflowTriggersCapability = {
   status: "available";
 } | {
   status: "unavailable";
-  reason: "in-process-reactor-module-unavailable" | "live-read-model-registration-unsupported";
+  reason: "in-process-reactor-module-unavailable" | "live-read-model-registration-unsupported" | "workflow-singleton-lost";
 };
 //#endregion
 //#region src/types.d.ts
@@ -312,6 +312,7 @@ export declare function isPortAvailable(port: number): Promise<boolean>;
 type ReactorStorage = {
   kysely: Kysely<Database>;
   poolInstrumentation: PoolInstrumentation | undefined;
+  storageFacts: ReactorStorageFacts;
 };
 export declare function createReactorKysely(opts: {
   reactorDbUrl: string | undefined;

package/dist/server.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.mts","names":[],"sources":["../src/pglite-version.ts","../src/privacy.mts","../src/workflow-runtime.mts","../src/types.ts","../src/builder-defaults.mts","../src/unsupported-stored-documents.mts","../src/server.mts"],"mappings":";;;;;;;;;;;;;;;cASa;KACD,2BAA2B;;;KCe3B;;EAEV;;EAEA;;EAEA,SAAS;;;;;;KCiCC;EACN;;EAEA;EACA;;;;;;;;;;YC9CM;;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;;;;;;;EAOA,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;;;;wBC5EK,kCACd,OAAO,wCACP,KAAK,OAAO,aACX;;qBAaU,oCAAoC;WACtC;IAAqB;IAAkB;;WACvC;EAET,YAAY,OAAO;SAcZ,QAAQ,iBAAiB,SAAS;;;;;;;;;wBC0K3B,gBAAgB,eAAe;;;;;;KA6D1C;EACH,QAAQ,OAAO;EACf,qBAAqB;;wBAGD,oBAAoB;EACxC;EACA;EACA,oBAAoB;EACpB;;;;;;;EAOA;EACA,QAAQ;IACN,QAAQ;;wBAwDI,8BACd,SAAS,KAAK,uDACd,oBACA,QAAQ;EACL;EAAmB,YAAY;;;;;;;;;;;;;;;;;;;qBAy7BvB,mBAAgB,UAClB,uBACR,QAAQ"}
+{"version":3,"file":"server.d.mts","names":[],"sources":["../src/pglite-version.ts","../src/privacy.mts","../src/workflow-runtime.mts","../src/types.ts","../src/builder-defaults.mts","../src/unsupported-stored-documents.mts","../src/server.mts"],"mappings":";;;;;;;;;;;;;;;cASa;KACD,2BAA2B;;;KCe3B;;EAEV;;EAEA;;EAEA,SAAS;;;;;;KCkCC;EACN;;EAEA;EACA;;;;;;;;;;YC/CM;;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;;;;;;;EAOA,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;;;;wBC5EK,kCACd,OAAO,wCACP,KAAK,OAAO,aACX;;qBAaU,oCAAoC;WACtC;IAAqB;IAAkB;;WACvC;EAET,YAAY,OAAO;SAcZ,QAAQ,iBAAiB,SAAS;;;;;;;;;wBCkL3B,gBAAgB,eAAe;;;;;;KA6D1C;EACH,QAAQ,OAAO;EACf,qBAAqB;EACrB,cAAc;;wBAGM,oBAAoB;EACxC;EACA;EACA,oBAAoB;EACpB;;;;;;;EAOA;EACA,QAAQ;IACN,QAAQ;;wBA4DI,8BACd,SAAS,KAAK,uDACd,oBACA,QAAQ;EACL;EAAmB,YAAY;;;;;;;;;;;;;;;;;;;qBAk/BvB,mBAAgB,UAClB,uBACR,QAAQ"}

package/dist/server.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as StoredDocumentsRefusedError, i as startSwitchboard, n as deriveAttachmentServiceConfig, o as resolveUnsupportedStoredDocuments, r as isPortAvailable, s as applySwitchboardReactorDefaults, t as createReactorKysely } from "./server-Zz7SqTwO.mjs";
+import { a as StoredDocumentsRefusedError, i as startSwitchboard, n as deriveAttachmentServiceConfig, o as resolveUnsupportedStoredDocuments, r as isPortAvailable, s as applySwitchboardReactorDefaults, t as createReactorKysely } from "./server-J9fpd42v.mjs";
 export { StoredDocumentsRefusedError, applySwitchboardReactorDefaults, createReactorKysely, 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]="ecf769b3-3c50-5e91-915e-6761e372127f")}catch(e){}}();
-//# debugId=ecf769b3-3c50-5e91-915e-6761e372127f
+!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]="b1cfc1e4-6226-5b66-81fa-c82cbc28b4ee")}catch(e){}}();
+//# debugId=b1cfc1e4-6226-5b66-81fa-c82cbc28b4ee

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@powerhousedao/switchboard",
   "type": "module",
-  "version": "6.2.3-dev.50",
+  "version": "6.2.3-dev.52",
   "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.50",
+    "@powerhousedao/config": "6.2.3-dev.52",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/exporter-metrics-otlp-http": "^0.218.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.218.0",
@@ -55,22 +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.50",
-    "@powerhousedao/reactor": "6.2.3-dev.50",
-    "@powerhousedao/shared": "6.2.3-dev.50",
-    "@powerhousedao/vetra": "6.2.3-dev.50",
-    "@powerhousedao/reactor-api": "6.2.3-dev.50",
-    "@powerhousedao/reactor-attachments": "6.2.3-dev.50",
-    "@powerhousedao/reactor-drive": "6.2.3-dev.50",
-    "@powerhousedao/reactor-group": "6.2.3-dev.50",
-    "@powerhousedao/reactor-privacy": "6.2.3-dev.50",
-    "@powerhousedao/reactor-workflow": "6.2.3-dev.50",
-    "@powerhousedao/workflow": "6.2.3-dev.50",
+    "@powerhousedao/opentelemetry-instrumentation-reactor": "6.2.3-dev.52",
+    "@powerhousedao/reactor": "6.2.3-dev.52",
+    "@powerhousedao/shared": "6.2.3-dev.52",
+    "@powerhousedao/vetra": "6.2.3-dev.52",
+    "@powerhousedao/reactor-api": "6.2.3-dev.52",
+    "@powerhousedao/reactor-attachments": "6.2.3-dev.52",
+    "@powerhousedao/reactor-drive": "6.2.3-dev.52",
+    "@powerhousedao/reactor-group": "6.2.3-dev.52",
+    "@powerhousedao/reactor-privacy": "6.2.3-dev.52",
+    "@powerhousedao/reactor-workflow": "6.2.3-dev.52",
+    "@powerhousedao/workflow": "6.2.3-dev.52",
     "@pyroscope/nodejs": "^0.4.5",
-    "@renown/sdk": "6.2.3-dev.50",
+    "@renown/sdk": "6.2.3-dev.52",
     "@sentry/node": "^10.53.1",
     "@sentry/opentelemetry": "^10.53.1",
-    "document-model": "6.2.3-dev.50",
+    "document-model": "6.2.3-dev.52",
     "dotenv": "^16.4.7",
     "express": "^4.22.1",
     "graphql": "^16",

package/test/boot-workflow-singleton-conflict.test.ts

@@ -0,0 +1,107 @@
+// Losing the workflow singleton claim must not take the whole API down.
+//
+// It used to: WorkflowSingletonConflictError propagated out of startSwitchboard
+// and aborted the boot. With the old random per-process owner name, an unclean
+// kill left a lease nobody could re-claim, so every restart inside the 60s TTL
+// crash-looped the entire Switchboard — inspection, GraphQL, sync and all —
+// over a component this host is merely not allowed to run.
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type * as WorkflowEngine from "@powerhousedao/reactor-workflow";
+import type { ILogger } from "document-model";
+import { describe, expect, it, vi } from "vitest";
+
+const HOLDER = "another-live-replica";
+const HELD_UNTIL = "2030-01-01T00:00:00.000Z";
+
+// The lease itself is the engine's to test (reactor-workflow,
+// singleton-lease.test.ts). What is under test here is what THIS host does
+// when the claim is refused, so only the claim is faked.
+vi.mock("@powerhousedao/reactor-workflow", async (importOriginal) => {
+  const actual = await importOriginal<typeof WorkflowEngine>();
+  return {
+    ...actual,
+    acquireWorkflowSingletonLease: () => {
+      const error = new Error(
+        `Workflow execution is a singleton and "${HOLDER}" holds it until ${HELD_UNTIL}`,
+      );
+      error.name = "WorkflowSingletonConflictError";
+      return Promise.reject(
+        Object.assign(error, {
+          owner: HOLDER,
+          expiresAt: HELD_UNTIL,
+          wouldBe: "this-host",
+        }),
+      );
+    },
+  };
+});
+
+const { startSwitchboard } = await import("../src/server.mjs");
+
+function stubLogger(): ILogger & { warn: ReturnType<typeof vi.fn> } {
+  const logger = {
+    verbose: vi.fn(),
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    child: vi.fn(),
+  };
+  logger.child.mockReturnValue(logger);
+  return logger as unknown as ILogger & { warn: ReturnType<typeof vi.fn> };
+}
+
+describe("booting Switchboard when another process holds the singleton", () => {
+  it("boots the API without the workflow runtime, naming the owner", async () => {
+    const tempRoot = await mkdtemp(join(tmpdir(), "switchboard-wf-conflict-"));
+    const previousReactorDb = process.env.PH_REACTOR_DATABASE_URL;
+    process.env.PH_REACTOR_DATABASE_URL = join(tempRoot, "reactor-storage");
+    const logger = stubLogger();
+    let switchboard: Awaited<ReturnType<typeof startSwitchboard>> | undefined;
+
+    try {
+      // The boot RESOLVES. That is the whole finding.
+      switchboard = await startSwitchboard({
+        workflows: { enabled: true },
+        dbPath: join(tempRoot, "read-model"),
+        port: 0,
+        mcp: false,
+        disableLocalPackages: true,
+        identity: { keypairPath: join(tempRoot, "identity.json") },
+        logger,
+      });
+
+      // The API is up and serving: the reactor answers, the document models
+      // are registered, everything but workflows works.
+      const { results } = await switchboard.reactor.getDocumentModelModules();
+      expect(results.length).toBeGreaterThan(0);
+
+      // And the runtime is absent, said so rather than half-present.
+      expect(switchboard.workflowTriggers).toBeUndefined();
+
+      // Warned, not errored into silence, and the warning names who holds it
+      // and how to get workflows back.
+      const warning = logger.warn.mock.calls
+        .map((call) => String(call[0]))
+        .find((line) => line.includes("workflow singleton"));
+      expect(warning).toBeDefined();
+      expect(warning).toContain(HOLDER);
+      expect(warning).toContain(HELD_UNTIL);
+      expect(warning).toContain("WITHOUT the workflow runtime");
+      expect(warning).toContain("PH_WORKFLOWS_SINGLETON_OWNER");
+
+      await switchboard.shutdown();
+      switchboard = undefined;
+    } finally {
+      await switchboard?.shutdown();
+      if (previousReactorDb === undefined) {
+        delete process.env.PH_REACTOR_DATABASE_URL;
+      } else {
+        process.env.PH_REACTOR_DATABASE_URL = previousReactorDb;
+      }
+      await rm(tempRoot, { recursive: true, force: true });
+    }
+  }, 60_000);
+});

package/test/boot-workflow-singleton-retry.test.ts

@@ -0,0 +1,133 @@
+// A Switchboard refused the workflow singleton at boot retries the claim and
+// starts workflows once the holder lets go. The runtime it composes then has
+// to be reachable: its GraphQL face mounted, not only registered.
+import { mkdtemp, rm } from "node:fs/promises";
+import { createServer } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  acquireWorkflowSingletonLease,
+  type WorkflowSingletonLease,
+} from "@powerhousedao/reactor-workflow";
+import {
+  createRelationalDb,
+  type IRelationalDb,
+} from "@powerhousedao/shared/processors";
+import type { ILogger } from "document-model";
+import { Kysely, PostgresDialect } from "kysely";
+import pg from "pg";
+import { describe, expect, it, vi } from "vitest";
+import { startSwitchboard } from "../src/server.mjs";
+
+const PG_URL = process.env.REACTOR_TEST_PG_URL;
+const DATABASE = "switchboard_workflow_retry";
+
+function stubLogger(): ILogger {
+  const logger = {
+    verbose: vi.fn(),
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    child: vi.fn(),
+  };
+  logger.child.mockReturnValue(logger);
+  return logger as unknown as ILogger;
+}
+
+async function freePort(): Promise<number> {
+  const server = createServer();
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  await new Promise((resolve) => server.close(resolve));
+  if (address === null || typeof address === "string") {
+    throw new Error("no port");
+  }
+  return address.port;
+}
+
+async function queryHealth(port: number): Promise<string | undefined> {
+  const response = await fetch(`http://127.0.0.1:${port}/graphql`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ query: "{ workflowRuntime { health } }" }),
+  });
+  const body = (await response.json()) as {
+    data?: { workflowRuntime?: { health?: string } };
+  };
+  return body.data?.workflowRuntime?.health;
+}
+
+describe.skipIf(!PG_URL)(
+  "a Switchboard that claims the workflow singleton after boot [Postgres]",
+  () => {
+    it("serves the workflow GraphQL API once it has the claim", async () => {
+      const admin = new pg.Pool({ connectionString: PG_URL });
+      await admin.query(`DROP DATABASE IF EXISTS "${DATABASE}" WITH (FORCE)`);
+      await admin.query(`CREATE DATABASE "${DATABASE}"`);
+      const url = new URL(PG_URL!);
+      url.pathname = `/${DATABASE}`;
+      const readModelUrl = url.toString();
+      const holderDb = new Kysely<unknown>({
+        dialect: new PostgresDialect({
+          pool: new pg.Pool({ connectionString: readModelUrl, max: 2 }),
+        }),
+      });
+      const tempRoot = await mkdtemp(join(tmpdir(), "switchboard-wf-retry-"));
+      const previousReactorDb = process.env.PH_REACTOR_DATABASE_URL;
+      process.env.PH_REACTOR_DATABASE_URL = join(tempRoot, "reactor-storage");
+      let holder: WorkflowSingletonLease | undefined;
+      let switchboard: Awaited<ReturnType<typeof startSwitchboard>> | undefined;
+      try {
+        // Another live host holds the singleton over the same journal.
+        holder = await acquireWorkflowSingletonLease({
+          relationalDb: createRelationalDb(holderDb) as IRelationalDb,
+          logger: stubLogger(),
+          owner: "the-other-host",
+        });
+
+        switchboard = await startSwitchboard({
+          workflows: { enabled: true },
+          dbPath: readModelUrl,
+          port: await freePort(),
+          strictPort: true,
+          mcp: false,
+          disableLocalPackages: true,
+          identity: { keypairPath: join(tempRoot, "identity.json") },
+          logger: stubLogger(),
+        });
+        expect(switchboard.workflowTriggers).toBeUndefined();
+        expect(await queryHealth(switchboard.port)).toBeUndefined();
+
+        await holder.release();
+        holder = undefined;
+
+        const port = switchboard.port;
+        await vi.waitFor(
+          async () => expect(await queryHealth(port)).toBe("ok"),
+          { timeout: 60_000, interval: 500 },
+        );
+        expect(switchboard.workflowTriggers).toEqual({ status: "available" });
+
+        await switchboard.shutdown();
+        switchboard = undefined;
+      } finally {
+        await holder?.release();
+        await switchboard?.shutdown();
+        await holderDb.destroy();
+        if (previousReactorDb === undefined) {
+          delete process.env.PH_REACTOR_DATABASE_URL;
+        } else {
+          process.env.PH_REACTOR_DATABASE_URL = previousReactorDb;
+        }
+        // Not forced: terminating a pool's idle connections under it raises
+        // an unhandled error. A database left behind is dropped next run.
+        await admin
+          .query(`DROP DATABASE IF EXISTS "${DATABASE}"`)
+          .catch(() => undefined);
+        await admin.end();
+        await rm(tempRoot, { recursive: true, force: true });
+      }
+    }, 120_000);
+  },
+);

package/test/pglite-dialect.test.ts

@@ -2,6 +2,14 @@ import { PGlite } from "@electric-sql/pglite";
 import { Kysely, sql } from "kysely";
 import type { ILogger } from "document-model";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  IN_MEMORY_PGLITE_STORAGE_FACTS,
+  PGLITE_PATH_STORAGE_FACTS,
+  POSTGRES_STORAGE_FACTS,
+} from "@powerhousedao/reactor";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { createReactorKysely } from "../src/server.mjs";
 import { EventEmitter } from "node:events";
 import { installFatalErrorShutdown } from "../src/fatal-shutdown.mjs";
@@ -152,6 +160,56 @@ describe("switchboard's reactor storage factory", () => {
 
     await storage.kysely.destroy();
   });
+
+  describe("storage facts", () => {
+    let dataDir: string | undefined;
+
+    afterEach(async () => {
+      if (dataDir) await rm(dataDir, { recursive: true, force: true });
+      dataDir = undefined;
+    });
+
+    const open = (opts: Partial<Parameters<typeof createReactorKysely>[0]>) =>
+      createReactorKysely({
+        reactorDbUrl: undefined,
+        reactorPgliteDir: ".ph/unused-by-the-in-memory-branch",
+        reactorPgliteMajor: 17,
+        inMemory: false,
+        hostPoolSize: () => 1,
+        logger: stubLogger(),
+        ...opts,
+      });
+
+    // Kysely closes only a driver that has run a query; an unopened PGlite
+    // would still be initialising its data dir when afterEach removes it.
+    const openAndDestroy = async (
+      kysely: Awaited<ReturnType<typeof createReactorKysely>>["kysely"],
+    ) => {
+      await sql`select 1`.execute(kysely);
+      await kysely.destroy();
+    };
+
+    it("reports in-memory PGlite as not durable", async () => {
+      const storage = await open({ inMemory: true });
+      expect(storage.storageFacts).toEqual(IN_MEMORY_PGLITE_STORAGE_FACTS);
+      await openAndDestroy(storage.kysely);
+    });
+
+    it("reports a PGlite data directory as durable on a path", async () => {
+      dataDir = await mkdtemp(join(tmpdir(), "sb-facts-"));
+      const storage = await open({ reactorPgliteDir: dataDir });
+      expect(storage.storageFacts).toEqual(PGLITE_PATH_STORAGE_FACTS);
+      await openAndDestroy(storage.kysely);
+    }, 30_000);
+
+    it("reports a Postgres url as a durable server", async () => {
+      const storage = await open({
+        reactorDbUrl: "postgres://postgres:postgres@127.0.0.1:1/never-dialed",
+      });
+      expect(storage.storageFacts).toEqual(POSTGRES_STORAGE_FACTS);
+      await storage.kysely.destroy();
+    });
+  });
 });
 
 describe("a poisoned reactor PGlite session", () => {

package/test/workflow/resolvers.test.ts

@@ -48,6 +48,9 @@ function fakeRuntime() {
     testStep: vi.fn(() => Promise.resolve({})),
     stepOutputTree: vi.fn(() => Promise.resolve({})),
     blockResolutions: vi.fn(() => Promise.resolve([])),
+    searchPieces: vi.fn(() =>
+      Promise.resolve({ status: "ready", pieces: [], indexedPieces: 0 }),
+    ),
     reactorAccessDenial: vi.fn((): string | undefined => undefined),
     testTrigger: vi.fn(() => Promise.resolve(null)),
     cancelTriggerTestFor: vi.fn(() => Promise.resolve(true)),
@@ -320,3 +323,35 @@ describe("the runs page", () => {
     expect(error.extensions?.code).toBe("BAD_USER_INPUT");
   });
 });
+
+describe("piece search", () => {
+  it("passes a valid filter through", async () => {
+    const { runtime, queries } = build(false);
+    await queries.searchPieces(
+      {},
+      { query: "send", kind: "trigger", sources: ["registry", "local"] },
+      CTX,
+    );
+    expect(runtime.searchPieces).toHaveBeenCalledWith("send", {
+      kind: "trigger",
+      sources: ["registry", "local"],
+      categories: undefined,
+      limit: undefined,
+    });
+  });
+
+  it("refuses a kind or source it does not know, rather than widen", () => {
+    const { runtime, queries } = build(false);
+    expect(() =>
+      queries.searchPieces({}, { query: "send", kind: "triggers" }, CTX),
+    ).toThrow(/kind is "action" or "trigger"/);
+    expect(() =>
+      queries.searchPieces(
+        {},
+        { query: "send", kind: "action", sources: ["Registry"] },
+        CTX,
+      ),
+    ).toThrow(/got Registry/);
+    expect(runtime.searchPieces).not.toHaveBeenCalled();
+  });
+});

package/test/workflow-reactor-enforcement.test.ts

@@ -319,6 +319,9 @@ async function harness(authEnforcement: boolean): Promise<Harness> {
     authorizationService: OPEN,
     pieces: { getPieces: () => pieces, onPiecesChange: () => undefined },
     logger,
+    // Two harnesses share one database on purpose; placement has its own
+    // suite.
+    singletonLease: false,
   });
   const subgraph = new runtime.subgraph({
     reactorClient: built.client,

package/test/workflow-read-gate.test.ts

@@ -158,6 +158,9 @@ describe("the workflow runtime's access checks", () => {
       attachments: {} as never,
       authorizationService: authorizationService as never,
       logger,
+      // This suite is about the read gate, not placement; the lease has its
+      // own suite in reactor-workflow.
+      singletonLease: false,
       load: () =>
         Promise.resolve({
           ...engine,