@powerhousedao/switchboard 6.2.3-dev.9 → 6.2.3

package/dist/{server-CiKkVE6g.mjs → server-sQoWp21G.mjs}

@@ -1,33 +1,38 @@
 
-!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]="e2c62b7b-68fd-59c2-ab82-7d035e11698b")}catch(e){}}();
-import { n as addDefaultReactorDrive, r as isPostgresUrl, t as addDefaultDrive } from "./utils-Baw7rThP.mjs";
-import { register } from "node:module";
+!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]="66287c02-682f-57d0-8260-a1005691b2bc")}catch(e){}}();
+import { n as addDefaultReactorDrive, r as isPostgresUrl, t as addDefaultDrive } from "./utils-uaBlzyjS.mjs";
+import { createRequire, register } from "node:module";
 import { ReactorInstrumentation } from "@powerhousedao/opentelemetry-instrumentation-reactor";
 import * as Sentry from "@sentry/node";
 import { childLogger, documentModelDocumentModelModule, setLogLevel } from "document-model";
 import dotenv from "dotenv";
 import { getConfig } from "@powerhousedao/config/node";
 import { existsSync, promises, realpathSync } from "node:fs";
-import path from "node:path";
+import path, { resolve } from "node:path";
 import { AtomicNodeFs } from "@powerhousedao/pglite-fs";
-import { ChannelScheme, DriveCollectionId, EventBus, REACTOR_SCHEMA, ReactorBuilder, ReactorClientBuilder, createHybridProjectionCoordinatorFactory, instrumentPgPool, parseDriveUrl, supportsLiveReadModelRegistration } from "@powerhousedao/reactor";
-import { HttpPackageLoader, ImportPackageLoader, PGLITE_UTC_PARSERS, PackageManagementService, PackagesSubgraph, getUniqueDocumentModels, initializeAndStartAPI, resolveRenownConfig } from "@powerhousedao/reactor-api";
+import { ChannelScheme, DriveCollectionId, EventBus, REACTOR_SCHEMA, ReactorBuilder, ReactorClientBuilder, UnsupportedStoredProtocolError, createHybridProjectionCoordinatorFactory, instrumentPgPool, parseDriveUrl, supportsLiveReadModelRegistration } from "@powerhousedao/reactor";
+import { AuthorizationPolicy, BaseSubgraph, ForbiddenError, HttpPackageLoader, ImportPackageLoader, PGLITE_UTC_PARSERS, PackageManagementService, PackagesSubgraph, callerSubject, createCanonicalDocumentIdResolver, getUniqueDocumentModels, initializeAndStartAPI, resolveRenownConfig } from "@powerhousedao/reactor-api";
 import { httpsHooksPath } from "@powerhousedao/reactor-api/https-hooks";
-import { AttachmentAlreadyExists, AttachmentNotFound, AttachmentPending, AttachmentReferenceReadModel, AttachmentSchemaCompiler, HashMismatch, InvalidAttachmentRef, ReservationNotFound, SizeMismatch, UploadTooLarge, createRef, createRemoteAttachmentService, parseAttachmentDownloadTarget } from "@powerhousedao/reactor-attachments";
+import { AttachmentAlreadyExists, AttachmentNotFound, AttachmentPending, AttachmentReferenceReadModel, AttachmentSchemaCompiler, HashMismatch, InvalidAttachmentRef, ReservationNotFound, SizeMismatch, UploadTooLarge, createRef, createRemoteAttachmentService, parseAttachmentDownloadTarget, parseRef } from "@powerhousedao/reactor-attachments";
+import { createAttachmentClient } from "@powerhousedao/reactor-attachments/client";
 import { DriveNodeView, NodeProcessor, ReactorDriveClient, createReactorDriveResolvers, reactorDriveDocumentModelModule, reactorDriveSubgraphTypeDefs } from "@powerhousedao/reactor-drive";
-import { DEFAULT_RENOWN_URL, NodeKeyStorage, RENOWN_READ_MODEL_SUBGRAPH, RenownBuilder, RenownCryptoBuilder, createLocalCredentialVerifier, createSignatureVerifier } from "@renown/sdk/node";
+import { DEFAULT_KEYPAIR_PATH, DEFAULT_RENOWN_URL, NodeKeyStorage, RENOWN_READ_MODEL_SUBGRAPH, RenownBuilder, RenownCryptoBuilder, createLocalCredentialVerifier, createRenownTrustPolicy, resolveSwitchboardEndpoint } from "@renown/sdk/node";
 import { Kysely, PostgresDialect } from "kysely";
 import net from "node:net";
 import path$1 from "path";
 import { Pool } from "pg";
 import { Readable } from "node:stream";
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 import { ReactorGroupV1 } from "@powerhousedao/reactor-group";
 import { driveDocumentModelModule } from "@powerhousedao/shared/document-drive";
+import { DEFAULT_SIGNATURE_POLICY, isSignaturePolicy } from "@powerhousedao/shared/document-model";
 import { readFile } from "node:fs/promises";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
 import { EnvVarProvider } from "@openfeature/env-var-provider";
 import { OpenFeature } from "@openfeature/server-sdk";
+import { GraphQLError, Kind } from "graphql";
+import { gql } from "graphql-tag";
 import { PGliteDialect } from "kysely-pglite-dialect";
 //#region src/pglite-version.ts
 const SUPPORTED_PG_MAJORS = [16, 17];
@@ -74,7 +79,15 @@ const ANONYMOUS_ACTOR = {
 * enabled, the request must carry a verifiable Bearer token. The handler always
 * receives an actor context: the verified bearer user when auth is enabled, or
 * the anonymous context when it is disabled. With `allowAnonymous`, a missing
-* bearer yields an anonymous actor with `authEnabled: true` instead of a 401.
+* bearer yields an anonymous actor with `authEnabled: true` instead of a 401 —
+* unless `requireAuthenticatedCaller` says the deployment refuses anonymous
+* callers outright, which overrides it.
+*
+* With no `authService` there is no bearer to read and every caller is
+* anonymous, so nothing is refused here. That combination cannot carry the
+* floor: `assertRequireAuthenticatedCallerAllowed` refuses to boot with
+* `REQUIRE_AUTHENTICATED_CALLER` set and no identity resolution, and identity
+* resolution is what builds the service.
 */
 function requireAuth(authService, handler, options) {
 	if (!authService) return (req, res, body) => handler(req, res, body, ANONYMOUS_ACTOR);
@@ -96,11 +109,13 @@ function requireAuth(authService, handler, options) {
 			res.end(body);
 			return;
 		}
-		if (result.auth_enabled && !result.user && !options?.allowAnonymous) {
-			res.statusCode = 401;
-			res.setHeader("Content-Type", "application/json");
-			res.end(JSON.stringify({ error: "Authentication required" }));
-			return;
+		if (!result.user) {
+			if (options?.requireAuthenticatedCaller === true || result.auth_enabled && !options?.allowAnonymous) {
+				res.statusCode = 401;
+				res.setHeader("Content-Type", "application/json");
+				res.end(JSON.stringify({ error: "Authentication required" }));
+				return;
+			}
 		}
 		await handler(req, res, body, {
 			user: result.user,
@@ -118,14 +133,22 @@ function requireAuth(authService, handler, options) {
 * wrapping you must call `api.httpAdapter.mountNodeRoute` directly.
 *
 * `allowAnonymous` is reserved for routes whose handlers make a per-document
-* authorization decision themselves; identity-only routes must not use it.
+* authorization decision themselves; identity-only routes must not use it. It
+* is also not the last word: a deployment that refuses anonymous callers
+* (`REQUIRE_AUTHENTICATED_CALLER`) refuses them here too, because these routes
+* are mounted on the HTTP adapter and never reach the fetch chain that carries
+* that floor for GraphQL. The flag is read from the API, so every route
+* mounted through here inherits it without each one remembering to.
 */
 function mountAuthenticatedNodeRoute(api, method, path, handler, options) {
-	api.httpAdapter.mountNodeRoute(method, path, requireAuth(api.authService, handler, options));
+	api.httpAdapter.mountNodeRoute(method, path, requireAuth(api.authService, handler, {
+		...options,
+		requireAuthenticatedCaller: api.requireAuthenticatedCaller
+	}));
 }
 //#endregion
 //#region src/attachments/routes.ts
-const logger$1 = childLogger(["switchboard", "attachments"]);
+const logger$2 = childLogger(["switchboard", "attachments"]);
 const RETRY_AFTER_SECONDS = 5;
 const HASH_PATTERN = /^[a-f0-9]{64}$/i;
 const CONTROL_CHARS = /[\x00-\x1f\x7f]/;
@@ -150,7 +173,7 @@ function statusForError(err) {
 function sendErrorFromException(res, err) {
 	const status = statusForError(err);
 	if (status >= 500) {
-		logger$1.error("Attachment route error: @error", err);
+		logger$2.error("Attachment route error: @error", err);
 		sendError(res, status, "Internal error");
 		return;
 	}
@@ -279,24 +302,27 @@ function makeUploadHandler(attachments) {
 		}
 	};
 }
-function makeDownloadHandler(attachments) {
-	return async (req, res) => {
+function makeDownloadHandler(attachments, attachmentAccess, urlSigner) {
+	return async (req, res, _body, actor) => {
 		const hash = extractParam(req, "hash");
 		if (!hash || !HASH_PATTERN.test(hash)) {
 			sendError(res, 400, "Invalid attachment hash");
 			return;
 		}
+		const canonicalHash = hash.toLowerCase();
+		const grant = await resolveByteGrant(req, canonicalHash, actor, attachmentAccess, urlSigner);
+		if (!admitGrant(res, grant)) return;
 		const controller = new AbortController();
 		req.once("close", () => controller.abort());
-		const canonicalHash = hash.toLowerCase();
 		let response;
 		try {
-			response = await attachments.store.get(canonicalHash, controller.signal);
+			response = await attachments.store.get(canonicalHash, controller.signal, grant.documentId);
 		} catch (err) {
 			if (err instanceof AttachmentPending) {
 				res.statusCode = 202;
+				res.setHeader("Cache-Control", "private");
 				res.setHeader("Retry-After", String(RETRY_AFTER_SECONDS));
-				res.setHeader("Attachment-Pending", JSON.stringify({
+				res.setHeader("Attachment-Pending", buildPendingHeader({
 					expiresAtUtc: err.expiresAtUtc,
 					...err.metadata ?? {}
 				}));
@@ -308,6 +334,7 @@ function makeDownloadHandler(attachments) {
 		}
 		const { header, body } = response;
 		res.statusCode = 200;
+		res.setHeader("Cache-Control", "private");
 		res.setHeader("Content-Type", header.mimeType);
 		res.setHeader("Content-Length", String(header.sizeBytes));
 		res.setHeader("Content-Disposition", buildContentDisposition(header.fileName));
@@ -315,8 +342,14 @@ function makeDownloadHandler(attachments) {
 		Readable.fromWeb(body).pipe(res);
 	};
 }
+function toAsciiJson(value) {
+	return JSON.stringify(value).replace(/[\u007f-\uffff]/g, (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+function buildPendingHeader(pending) {
+	return toAsciiJson(pending);
+}
 function buildMetadataHeader(header) {
-	return JSON.stringify({
+	return toAsciiJson({
 		mimeType: header.mimeType,
 		fileName: header.fileName,
 		sizeBytes: header.sizeBytes,
@@ -325,14 +358,15 @@ function buildMetadataHeader(header) {
 		lastAccessedAtUtc: header.lastAccessedAtUtc
 	});
 }
-function makeStatHandler(attachments) {
-	return async (req, res) => {
+function makeStatHandler(attachments, attachmentAccess, urlSigner) {
+	return async (req, res, _body, actor) => {
 		const hash = extractParam(req, "hash");
 		if (!hash || !HASH_PATTERN.test(hash)) {
 			sendError(res, 400, "Invalid attachment hash");
 			return;
 		}
 		const canonicalHash = hash.toLowerCase();
+		if (!admitGrant(res, await resolveByteGrant(req, canonicalHash, actor, attachmentAccess, urlSigner))) return;
 		let header;
 		try {
 			header = await attachments.store.stat(canonicalHash);
@@ -340,10 +374,11 @@ function makeStatHandler(attachments) {
 			sendErrorFromException(res, err);
 			return;
 		}
+		res.setHeader("Cache-Control", "private");
 		if (header.status === "pending") {
 			res.statusCode = 202;
 			res.setHeader("Retry-After", String(RETRY_AFTER_SECONDS));
-			res.setHeader("Attachment-Pending", JSON.stringify({
+			res.setHeader("Attachment-Pending", buildPendingHeader({
 				expiresAtUtc: header.expiresAtUtc,
 				mimeType: header.mimeType,
 				fileName: header.fileName,
@@ -395,7 +430,37 @@ function extractParam(req, name) {
 }
 const MAX_DOCUMENT_ID_LEN = 512;
 const ATTACHMENT_NOT_FOUND_BODY = { error: "Attachment not found" };
-const MAX_DOWNLOAD_TARGET_TTL_SECONDS = 10080 * 60;
+const MAX_DOWNLOAD_TARGET_TTL_SECONDS = 604800;
+/**
+* How long a download target may live, by default.
+*
+* The authorization behind a presigned URL is decided once, when it is issued,
+* and the URL keeps working until it expires however the document's policy
+* changes in between. A week of that is a revocation that does not revoke: an
+* account deactivated, a company reassigned or a group left, and the bytes stay
+* fetchable by anyone holding the link. Minutes are enough to open a file;
+* days are only enough to lose control of it.
+*
+* A deployment that needs longer sets ATTACHMENT_DOWNLOAD_TARGET_MAX_TTL_SECONDS,
+* still bounded by the signing ceiling above.
+*/
+const DEFAULT_DOWNLOAD_TARGET_TTL_SECONDS = 300;
+/**
+* The ceiling in force, read per call so a deployment can set it without the
+* value being frozen at import — which is also what lets a test cover it.
+* Anything unparseable falls back to the default rather than to the maximum:
+* a typo must not quietly widen the window it was meant to narrow.
+*/
+function downloadTargetTtlCapSeconds() {
+	const configured = process.env.ATTACHMENT_DOWNLOAD_TARGET_MAX_TTL_SECONDS;
+	if (configured === void 0) return DEFAULT_DOWNLOAD_TARGET_TTL_SECONDS;
+	const parsed = Number(configured);
+	if (!Number.isInteger(parsed) || parsed <= 0) {
+		logger$2.warn(`Ignoring invalid ATTACHMENT_DOWNLOAD_TARGET_MAX_TTL_SECONDS="${configured}" (expected a positive integer number of seconds) — using ${DEFAULT_DOWNLOAD_TARGET_TTL_SECONDS}`);
+		return DEFAULT_DOWNLOAD_TARGET_TTL_SECONDS;
+	}
+	return Math.min(parsed, MAX_DOWNLOAD_TARGET_TTL_SECONDS);
+}
 /**
 * Returns the single `documentId` query value, or null when it is missing,
 * duplicated, blank, or oversized. Validation happens before authorization so
@@ -416,29 +481,95 @@ function extractSingleDocumentId(req) {
 	return value;
 }
 /**
-* Returns the requested target TTL in seconds: undefined when absent,
-* "invalid" when malformed (duplicated, non-integer, or non-positive), and
-* otherwise the value clamped to the presigning ceiling.
+* Returns the target TTL in seconds, or "invalid" when the caller's own value
+* is malformed (duplicated, non-integer, or non-positive).
+*
+* The cap applies whether or not the caller asked for a lifetime: omitting
+* `expiresIn` used to fall through to whatever the storage backend was
+* configured with, which would make the ceiling something a client opts out of
+* by saying nothing.
 */
 function extractExpiresIn(req) {
-	if (!req.url) return void 0;
+	const cap = downloadTargetTtlCapSeconds();
+	if (!req.url) return cap;
 	let url;
 	try {
 		url = new URL(req.url, "http://switchboard.invalid");
 	} catch {
-		return;
+		return cap;
 	}
 	const values = url.searchParams.getAll("expiresIn");
-	if (values.length === 0) return void 0;
+	if (values.length === 0) return cap;
 	if (values.length > 1) return "invalid";
 	const parsed = Number(values[0]);
 	if (!Number.isInteger(parsed) || parsed <= 0) return "invalid";
-	return Math.min(parsed, MAX_DOWNLOAD_TARGET_TTL_SECONDS);
+	return Math.min(parsed, cap);
+}
+function singleQueryValue(params, name) {
+	const values = params.getAll(name);
+	return values.length === 1 ? values[0] : null;
+}
+/**
+* Byte routes serve only under a grant: a signed URL minted by the
+* download-target route, or a documentId the caller may read the attachment
+* through. A signed request is judged by its signature alone.
+*/
+async function resolveByteGrant(req, hash, actor, attachmentAccess, urlSigner) {
+	let params;
+	try {
+		params = new URL(req.url ?? "", "http://switchboard.invalid").searchParams;
+	} catch {
+		return { kind: "denied" };
+	}
+	const documentId = extractSingleDocumentId(req);
+	if (documentId === null) return { kind: "denied" };
+	if (params.has("signature") || params.has("expires")) {
+		const signature = singleQueryValue(params, "signature");
+		const expires = singleQueryValue(params, "expires");
+		if (!urlSigner || signature === null || expires === null) return { kind: "denied" };
+		return urlSigner.verify(hash, documentId, expires, signature) ? {
+			kind: "granted",
+			documentId
+		} : { kind: "denied" };
+	}
+	let decision;
+	try {
+		decision = await attachmentAccess.canReadAttachment({
+			documentId,
+			attachmentRef: createRef(hash),
+			userAddress: actor?.user?.address,
+			appKey: actor?.user?.appKey
+		});
+	} catch (err) {
+		logger$2.error("Attachment access decision failed: @error", err);
+		return { kind: "error" };
+	}
+	if (decision.kind === "projection-unavailable") return { kind: "unavailable" };
+	if (decision.kind === "denied") return { kind: "denied" };
+	return {
+		kind: "granted",
+		documentId: decision.documentId
+	};
+}
+/** Answers a refused grant; true when the request may proceed. */
+function admitGrant(res, grant) {
+	switch (grant.kind) {
+		case "granted": return true;
+		case "denied":
+			sendJson(res, 404, ATTACHMENT_NOT_FOUND_BODY);
+			return false;
+		case "unavailable":
+			sendError(res, 503, "Attachment downloads are temporarily unavailable");
+			return false;
+		case "error":
+			sendError(res, 500, "Internal error");
+			return false;
+	}
 }
 /**
 * Base URL of this Switchboard as seen by the caller, used to build
-* filesystem `switchboard` download targets that point back at the existing
-* authenticated byte route.
+* filesystem `switchboard` download targets that point back at the signed
+* byte route.
 */
 function requestBaseUrl(req) {
 	const forwardedProto = req.headers["x-forwarded-proto"];
@@ -448,7 +579,7 @@ function requestBaseUrl(req) {
 	if (!host) return null;
 	return `${proto}://${host}`;
 }
-function makeDownloadTargetHandler(attachments, attachmentAccess) {
+function makeDownloadTargetHandler(attachments, attachmentAccess, urlSigner) {
 	return async (req, res, _body, actor) => {
 		res.setHeader("Cache-Control", "no-store");
 		const hash = extractParam(req, "hash");
@@ -472,10 +603,11 @@ function makeDownloadTargetHandler(attachments, attachmentAccess) {
 			decision = await attachmentAccess.canReadAttachment({
 				documentId,
 				attachmentRef: createRef(canonicalHash),
-				userAddress: actor?.user?.address
+				userAddress: actor?.user?.address,
+				appKey: actor?.user?.appKey
 			});
 		} catch (err) {
-			logger$1.error("Attachment access decision failed: @error", err);
+			logger$2.error("Attachment access decision failed: @error", err);
 			sendError(res, 500, "Internal error");
 			return;
 		}
@@ -495,7 +627,7 @@ function makeDownloadTargetHandler(attachments, attachmentAccess) {
 				sendJson(res, 404, ATTACHMENT_NOT_FOUND_BODY);
 				return;
 			}
-			logger$1.error("Attachment metadata lookup failed: @error", err);
+			logger$2.error("Attachment metadata lookup failed: @error", err);
 			sendError(res, 500, "Internal error");
 			return;
 		}
@@ -511,17 +643,23 @@ function makeDownloadTargetHandler(attachments, attachmentAccess) {
 			return;
 		}
 		else {
+			if (!urlSigner) {
+				sendError(res, 503, "Attachment download signing is not configured");
+				return;
+			}
 			const base = requestBaseUrl(req);
 			if (!base) {
 				sendError(res, 500, "Internal error");
 				return;
 			}
+			const signed = urlSigner.sign(canonicalHash, decision.documentId, expiresIn);
 			try {
 				target = parseAttachmentDownloadTarget({
 					kind: "switchboard",
 					method: "GET",
-					url: `${base}/attachments/${canonicalHash}`,
-					headers: {}
+					url: `${base}/attachments/${canonicalHash}?${signed.query}`,
+					headers: {},
+					expiresAtUtc: signed.expiresAtUtc
 				});
 			} catch {
 				sendError(res, 500, "Internal error");
@@ -532,16 +670,82 @@ function makeDownloadTargetHandler(attachments, attachmentAccess) {
 	};
 }
 //#endregion
+//#region src/attachments/url-signer.ts
+const ATTACHMENT_URL_SIGNING_SECRET_ENV = "PH_ATTACHMENT_URL_SIGNING_SECRET";
+const MIN_SECRET_LENGTH = 32;
+const EXPIRES_PATTERN = /^[1-9]\d{0,15}$/;
+const SIGNATURE_PATTERN = /^[A-Za-z0-9_-]{43}$/;
+var AttachmentUrlSigner = class {
+	secret;
+	now;
+	constructor(secret, now = Date.now) {
+		this.secret = secret;
+		this.now = now;
+	}
+	sign(hash, documentId, ttlSeconds) {
+		const expires = Math.floor(this.now() / 1e3) + ttlSeconds;
+		return {
+			query: new URLSearchParams({
+				documentId,
+				expires: String(expires),
+				signature: this.mac(hash, documentId, String(expires))
+			}).toString(),
+			expiresAtUtc: (/* @__PURE__ */ new Date(expires * 1e3)).toISOString()
+		};
+	}
+	verify(hash, documentId, expires, signature) {
+		if (!EXPIRES_PATTERN.test(expires) || !SIGNATURE_PATTERN.test(signature)) return false;
+		if (Number(expires) * 1e3 <= this.now()) return false;
+		const expected = Buffer.from(this.mac(hash, documentId, expires));
+		const presented = Buffer.from(signature);
+		return expected.length === presented.length && timingSafeEqual(expected, presented);
+	}
+	mac(hash, documentId, expires) {
+		return createHmac("sha256", this.secret).update(JSON.stringify([
+			"attachment-download/v1",
+			hash,
+			documentId,
+			expires
+		])).digest("base64url");
+	}
+};
+function resolveAttachmentUrlSigning(env = process.env) {
+	const secret = env[ATTACHMENT_URL_SIGNING_SECRET_ENV];
+	if (secret !== void 0) {
+		if (secret.trim() !== secret || secret.length < MIN_SECRET_LENGTH) throw new Error(`${ATTACHMENT_URL_SIGNING_SECRET_ENV} must be at least ${MIN_SECRET_LENGTH} characters with no leading or trailing whitespace`);
+		return {
+			status: "configured",
+			signer: new AttachmentUrlSigner(secret)
+		};
+	}
+	if (env.NODE_ENV === "production") return { status: "unconfigured" };
+	return {
+		status: "ephemeral",
+		signer: new AttachmentUrlSigner(randomBytes(32))
+	};
+}
+//#endregion
 //#region src/attachments/index.ts
-function registerAttachmentRoutes(api) {
-	const { attachments } = api;
+const logger$1 = childLogger(["switchboard", "attachments"]);
+function registerAttachmentRoutes(api, options = {}) {
+	const { attachments, attachmentAccess } = api;
+	const urlSigner = options.urlSigner === void 0 ? signerFromEnvironment(attachments.backend?.kind ?? "filesystem") : options.urlSigner;
 	mountAuthenticatedNodeRoute(api, "POST", "/attachments/reservations", makeReserveHandler(attachments));
 	mountAuthenticatedNodeRoute(api, "GET", "/attachments/reservations/:reservationId", makeGetReservationHandler(attachments));
 	mountAuthenticatedNodeRoute(api, "DELETE", "/attachments/reservations/:reservationId", makeDeleteReservationHandler(attachments));
 	mountAuthenticatedNodeRoute(api, "PUT", "/attachments/reservations/:reservationId", makeUploadHandler(attachments));
-	mountAuthenticatedNodeRoute(api, "HEAD", "/attachments/:hash", makeStatHandler(attachments));
-	mountAuthenticatedNodeRoute(api, "GET", "/attachments/:hash/download-target", makeDownloadTargetHandler(attachments, api.attachmentAccess), { allowAnonymous: true });
-	mountAuthenticatedNodeRoute(api, "GET", "/attachments/:hash", makeDownloadHandler(attachments));
+	mountAuthenticatedNodeRoute(api, "HEAD", "/attachments/:hash", makeStatHandler(attachments, attachmentAccess, urlSigner), { allowAnonymous: true });
+	mountAuthenticatedNodeRoute(api, "GET", "/attachments/:hash/download-target", makeDownloadTargetHandler(attachments, attachmentAccess, urlSigner), { allowAnonymous: true });
+	mountAuthenticatedNodeRoute(api, "GET", "/attachments/:hash", makeDownloadHandler(attachments, attachmentAccess, urlSigner), { allowAnonymous: true });
+}
+function signerFromEnvironment(backend) {
+	const signing = resolveAttachmentUrlSigning();
+	if (signing.status === "unconfigured") {
+		if (backend === "filesystem") logger$1.error(`${ATTACHMENT_URL_SIGNING_SECRET_ENV} is not set: filesystem attachment download targets are refused until it is`);
+		return null;
+	}
+	if (signing.status === "ephemeral" && backend === "filesystem") logger$1.warn(`${ATTACHMENT_URL_SIGNING_SECRET_ENV} is not set: signing attachment download URLs with a per-process secret`);
+	return signing.signer;
 }
 //#endregion
 //#region src/attachment-reference-read-model.mts
@@ -584,6 +788,43 @@ async function registerAttachmentReferenceReadModelOnModule(clientModule, attach
 	return { status: "available" };
 }
 //#endregion
+//#region src/fatal-shutdown.mts
+const FORCED_EXIT_MS = 15e3;
+const installed = /* @__PURE__ */ new WeakSet();
+/**
+* Sends an uncaught exception or unhandled rejection through the SIGTERM
+* shutdown that `withSignalHandlers()` installs, so the reactor and read-model
+* PGlite stores write their snapshots before the process exits with code 1.
+* Node's default is to exit at once, which drops every write AtomicNodeFs has
+* not flushed yet. A shutdown that hangs is cut off after FORCED_EXIT_MS.
+*
+* A rejection is fatal only when this is its sole listener: Node exits on an
+* unhandled rejection only when nothing listens for it, and Sentry's
+* listener deliberately keeps the process running.
+*/
+function installFatalErrorShutdown(logger, proc = process) {
+	if (installed.has(proc)) return;
+	installed.add(proc);
+	const realExit = proc.exit.bind(proc);
+	let shuttingDown = false;
+	const onFatal = (kind, err) => {
+		logger.error(`${kind}: @error`, err);
+		if (shuttingDown) return;
+		shuttingDown = true;
+		proc.exitCode = 1;
+		setTimeout(() => {
+			logger.error("Shutdown after fatal error timed out; exiting");
+			realExit(1);
+		}, FORCED_EXIT_MS).unref();
+		proc.kill(proc.pid, "SIGTERM");
+	};
+	proc.on("uncaughtException", (err) => onFatal("Uncaught exception", err));
+	proc.on("unhandledRejection", (reason) => {
+		if (proc.listenerCount("unhandledRejection") > 1) return;
+		onFatal("Unhandled rejection", reason);
+	});
+}
+//#endregion
 //#region src/builder-defaults.mts
 /**
 * Apply switchboard's standard configuration to a reactor + client builder
@@ -617,7 +858,13 @@ function applySwitchboardReactorDefaults(reactorBuilder, clientBuilder, options
 	});
 	if (options.documentModelLoader) reactorBuilder.withDocumentModelLoader(options.documentModelLoader);
 	if (options.logger) reactorBuilder.withLogger(options.logger);
-	if (options.signer) clientBuilder.withSigner(options.signer);
+	if (options.signer) {
+		clientBuilder.withSigner(options.signer);
+		reactorBuilder.withSigner(options.signer.signer, options.signer.workerSigner);
+	}
+	if (options.createSignaturePolicy) clientBuilder.withCreateSignaturePolicy(options.createSignaturePolicy);
+	const trust = options.trustPolicy ?? options.signer;
+	if (trust?.trustPolicy) reactorBuilder.withTrustPolicy(trust.trustPolicy, trust.workerTrustPolicy);
 }
 //#endregion
 //#region src/worker-pool.mts
@@ -865,6 +1112,914 @@ async function initFeatureFlags() {
 	return OpenFeature.getClient();
 }
 //#endregion
+//#region src/mcp-flag.mts
+/** The env var and OpenFeature flag key that can keep the MCP server unmounted. */
+const MCP_ENABLED = "MCP_ENABLED";
+/** Whether to mount the MCP server at `/mcp`. On unless the host passes
+* `mcp: false` or MCP_ENABLED is "false": the env var can turn a host's MCP
+* off, never on, so a deployment that serves no MCP client can close the
+* endpoint without the bin growing a flag of its own. */
+async function resolveMcpEnabled({ featureFlags, option }) {
+	if (option === false) return false;
+	return featureFlags.getBooleanValue(MCP_ENABLED, true);
+}
+//#endregion
+//#region src/workflow/oauth-callback.ts
+const OAUTH_CALLBACK_PATH = "oauth/callback";
+function escapeHtml(text) {
+	return text.replace(/[&<>"']/g, (char) => ({
+		"&": "&amp;",
+		"<": "&lt;",
+		">": "&gt;",
+		"\"": "&quot;",
+		"'": "&#39;"
+	})[char]);
+}
+function resultPage(ok, detail) {
+	const title = ok ? "Connected" : "Sign-in failed";
+	return `<!doctype html>
+<html><head><meta charset="utf-8"><title>${title}</title>
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<style>body{font:15px system-ui,sans-serif;margin:0;display:grid;place-items:center;min-height:100vh;background:#fafafa;color:#222}main{max-width:28rem;padding:1.5rem;text-align:center}h1{font-size:1.1rem}</style>
+</head><body><main><h1>${title}</h1><p>${ok ? "You can close this window." : escapeHtml(detail ?? "The sign-in did not finish.")}</p></main>
+${ok ? "<script>setTimeout(function(){window.close()},600)<\/script>" : ""}
+</body></html>`;
+}
+function registerOAuthCallback(http, runtime) {
+	return http.get(OAUTH_CALLBACK_PATH, { auth: "public" }, async (request) => {
+		const params = new URL(request.url).searchParams;
+		const state = params.get("state");
+		const result = state ? await runtime.completeOAuth({
+			state,
+			code: params.get("code") ?? void 0,
+			error: params.get("error") ?? void 0,
+			errorDescription: params.get("error_description") ?? void 0
+		}) : {
+			ok: false,
+			detail: "The provider sent no state",
+			returnUrl: null
+		};
+		if (result.returnUrl && state) {
+			const back = new URL(result.returnUrl);
+			back.searchParams.set("ph_oauth", state);
+			return new Response(null, {
+				status: 303,
+				headers: {
+					location: back.href,
+					"cache-control": "no-store"
+				}
+			});
+		}
+		return new Response(resultPage(result.ok, result.detail), {
+			status: result.ok ? 200 : 400,
+			headers: {
+				"content-type": "text/html; charset=utf-8",
+				"cache-control": "no-store",
+				"referrer-policy": "no-referrer"
+			}
+		});
+	});
+}
+function callbackUrlOf(http) {
+	return `${http.baseUrl.replace(/\/+$/, "")}/${OAUTH_CALLBACK_PATH}`;
+}
+//#endregion
+//#region src/workflow/resolvers.ts
+function blockRef(input) {
+	if (input.kind !== "action" && input.kind !== "trigger") throw new GraphQLError(`A block's kind is "action" or "trigger", got "${input.kind}"`);
+	return {
+		pieceName: input.pieceName,
+		pieceVersion: input.pieceVersion,
+		name: input.name,
+		kind: input.kind
+	};
+}
+async function cursorAware(call) {
+	try {
+		return await call();
+	} catch (error) {
+		if (error instanceof Error && error.name === "InvalidRunCursorError") throw new GraphQLError(error.message, { extensions: { code: "BAD_USER_INPUT" } });
+		throw error;
+	}
+}
+function selectsStepData(selections, path) {
+	let level = selections;
+	for (const name of [...path, "steps"]) {
+		const next = [];
+		for (const set of level) for (const selection of set.selections) {
+			if (selection.kind !== Kind.FIELD) return true;
+			if (selection.name.value === name && selection.selectionSet) next.push(selection.selectionSet);
+		}
+		if (next.length === 0) return false;
+		level = next;
+	}
+	return level.some((set) => set.selections.some((selection) => selection.kind !== Kind.FIELD || selection.name.value === "input" || selection.name.value === "output"));
+}
+function readsStepData(info, path) {
+	if (!info) return true;
+	return selectsStepData(info.fieldNodes.flatMap((node) => node.selectionSet ? [node.selectionSet] : []), path);
+}
+function requireAdmin(authorizationService, ctx) {
+	if (!authorizationService.isSupremeAdmin(ctx.user?.address)) throw new GraphQLError("Admin access required");
+}
+async function syncAware(call) {
+	try {
+		return await call();
+	} catch (error) {
+		if (error instanceof Error && error.name === "WorkflowSyncingError") throw new GraphQLError(error.message, { extensions: {
+			code: "WORKFLOW_SYNCING",
+			retryable: true
+		} });
+		throw error;
+	}
+}
+function parseJson(value) {
+	if (value === null) return null;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+function toStepRecord(row) {
+	return {
+		stepId: row.step_id,
+		stepKey: row.step_key,
+		pieceName: row.piece_name,
+		blockName: row.block_name,
+		status: row.status,
+		input: parseJson(row.input),
+		output: parseJson(row.output),
+		port: row.port,
+		error: row.error,
+		startedAt: row.started_at,
+		endedAt: row.ended_at,
+		pieceVersion: row.piece_version,
+		pieceSource: row.piece_source,
+		versionMatch: row.version_match,
+		versionNote: row.version_note
+	};
+}
+function toRunRecord(row, steps) {
+	return {
+		id: row.id,
+		workflowId: row.workflow_id,
+		workflowName: row.workflow_name,
+		workflowVersion: row.workflow_version,
+		triggerKind: row.trigger_kind,
+		triggerPayload: parseJson(row.trigger_payload),
+		status: row.status,
+		error: row.error,
+		startedAt: row.started_at,
+		endedAt: row.ended_at,
+		rerunOf: row.rerun_of,
+		warnings: row.warnings,
+		warningNotes: parseJson(row.warning_notes) ?? [],
+		steps: steps.map(toStepRecord)
+	};
+}
+function isAbsolute(url) {
+	return /^https?:\/\//i.test(url);
+}
+function redirectUriFor(routing, requested) {
+	if (!routing) throw new GraphQLError("This host serves no OAuth2 callback");
+	if (isAbsolute(routing.callbackUrl)) return routing.callbackUrl;
+	if (!requested) throw new GraphQLError("This host does not know its public URL; pass redirectUri");
+	let url;
+	try {
+		url = new URL(requested);
+	} catch {
+		throw new GraphQLError(`"${requested}" is not a URL`);
+	}
+	if (url.protocol !== "https:" && url.protocol !== "http:" || url.pathname !== routing.callbackUrl || url.search !== "" || url.hash !== "") throw new GraphQLError(`redirectUri must be this host's ${routing.callbackUrl}`);
+	return url.href;
+}
+function returnUrlFor(requested, ctx) {
+	if (!requested) return void 0;
+	const origin = ctx.headers.origin;
+	let url;
+	try {
+		url = new URL(requested);
+	} catch {
+		url = void 0;
+	}
+	if (!url || !origin || url.origin !== origin) throw new GraphQLError("returnUrl must be on the requesting page's origin");
+	return url.href;
+}
+const getResolvers = (runtime, authorizationService, oauth) => {
+	return {
+		Query: { workflowRuntime: () => ({}) },
+		WorkflowRuntimeQueries: {
+			health: () => "ok",
+			blockDescriptor: (_parent, args) => runtime.blockDescriptor(blockRef(args.block)),
+			blockOptions: (_parent, args, ctx) => runtime.blockOptions(blockRef(args.block), args.propName, args.input, args.connectionId ?? void 0, ctx, args.searchValue ?? void 0),
+			pieceCatalog: () => runtime.pieceCatalog(),
+			pieceActions: (_parent, args) => runtime.pieceActions(args.packageName, args.version ?? void 0),
+			pieceTriggers: (_parent, args) => runtime.pieceTriggers(args.packageName, args.version ?? void 0),
+			blockOutputTree: (_parent, args) => runtime.blockOutputTree(blockRef(args.block), args.config),
+			stepOutputTree: (_parent, args, ctx) => runtime.stepOutputTree(args.workflowId, args.stepId, ctx),
+			blockResolutions: (_parent, args, ctx) => runtime.blockResolutions(args.workflowId, ctx),
+			pieceDetail: (_parent, args) => runtime.pieceDetail(args.packageName, args.version ?? void 0),
+			searchBlocks: (_parent, args) => runtime.searchBlocks(args.query, args.limit ?? void 0),
+			connections: (_parent, _args, ctx) => runtime.connections(ctx),
+			webhookEndpoint: (_parent, args, ctx) => syncAware(() => runtime.webhookEndpoint(args.workflowId, ctx, { driveId: args.driveId ?? void 0 })),
+			secret: async (_parent, args) => {
+				try {
+					return await (await runtime.secrets()).stat(args.ref);
+				} catch {
+					return null;
+				}
+			},
+			secrets: async () => (await runtime.secrets()).list(),
+			oauthRedirectUri: () => oauth?.callbackUrl ?? null,
+			oauthAttempt: (_parent, args, ctx) => runtime.oauthAttempt(args.state, ctx),
+			triggerStates: async (_parent, _args, ctx) => (await runtime.triggerStates(ctx)).map((row) => ({
+				workflowId: row.workflow_id,
+				pieceName: row.piece_name,
+				triggerName: row.trigger_name,
+				status: row.status,
+				intervalMs: row.interval_ms,
+				nextPollAt: row.next_poll_at,
+				lastPollAt: row.last_poll_at,
+				lastError: row.last_error,
+				consecutiveFailures: row.consecutive_failures,
+				nextRenewAt: row.next_renew_at,
+				renewError: row.renew_error,
+				renewFailures: row.renew_failures,
+				pieceVersion: row.piece_version,
+				pieceSource: row.piece_source,
+				versionMatch: row.version_match,
+				versionNote: row.version_note
+			})),
+			runs: async (_parent, args, ctx, info) => (await runtime.runs({
+				...args,
+				withStepData: readsStepData(info, [])
+			}, ctx)).map((record) => toRunRecord(record.row, record.steps)),
+			runsPage: async (_parent, args, ctx, info) => {
+				const { paging, ...scope } = args;
+				const page = await cursorAware(() => runtime.runsPage({
+					...scope,
+					limit: paging?.limit ?? void 0,
+					cursor: paging?.cursor ?? null,
+					withStepData: readsStepData(info, ["items"])
+				}, ctx));
+				return {
+					items: page.records.map((record) => toRunRecord(record.row, record.steps)),
+					hasNextPage: page.hasNextPage,
+					hasPreviousPage: Boolean(paging?.cursor),
+					cursor: page.cursor
+				};
+			},
+			run: async (_parent, args, ctx) => {
+				const record = await runtime.run(args.id, ctx);
+				return record ? toRunRecord(record.row, record.steps) : null;
+			}
+		},
+		Mutation: { workflowRuntime: () => ({}) },
+		WorkflowRuntimeMutations: {
+			fire: (_parent, args, ctx) => runtime.fire(args.workflowId, args.payload, "manual", void 0, ctx),
+			testTrigger: (_parent, args, ctx) => syncAware(() => runtime.testTrigger(args.workflowId, ctx, {
+				...args.payload !== void 0 ? { payload: args.payload } : {},
+				...typeof args.timeoutSeconds === "number" ? { timeoutMs: args.timeoutSeconds * 1e3 } : {},
+				driveId: args.driveId ?? void 0
+			})),
+			cancelTriggerTest: (_parent, args, ctx) => runtime.cancelTriggerTestFor(args.workflowId, ctx),
+			testStep: (_parent, args, ctx) => syncAware(() => runtime.testStep(args.workflowId, args.stepId, ctx, { driveId: args.driveId ?? void 0 })),
+			rerun: (_parent, args, ctx) => runtime.rerun(args.runId, ctx),
+			createSecret: async (_parent, args, ctx) => {
+				requireAdmin(authorizationService, ctx);
+				return (await runtime.secrets()).create({
+					value: args.value,
+					label: args.label ?? void 0
+				});
+			},
+			rotateSecret: async (_parent, args, ctx) => {
+				requireAdmin(authorizationService, ctx);
+				return (await runtime.secrets()).rotate(args.ref, args.value);
+			},
+			deleteSecret: async (_parent, args, ctx) => {
+				requireAdmin(authorizationService, ctx);
+				await (await runtime.secrets()).delete(args.ref);
+				return true;
+			},
+			checkConnection: (_parent, args, ctx) => runtime.checkConnection(args.connectionId, ctx),
+			startOAuth: (_parent, args, ctx) => {
+				requireAdmin(authorizationService, ctx);
+				const returnUrl = returnUrlFor(args.returnUrl, ctx);
+				return runtime.startOAuth(args.connectionId, ctx, {
+					redirectUri: redirectUriFor(oauth, args.redirectUri),
+					...returnUrl ? { returnUrl } : {}
+				});
+			}
+		}
+	};
+};
+//#endregion
+//#region src/workflow/schema.ts
+const schema = gql`
+  """
+  WorkflowRuntime Queries
+  """
+  type WorkflowRuntimeQueries {
+    health: String!
+    """
+    Persisted runs, newest first. Scope them to one workflow, or to every
+    workflow a drive holds; workflowId wins when both are given.
+    """
+    runs(
+      workflowId: String
+      driveId: String
+      limit: Int
+      "Trigger kinds to leave out, e.g. test."
+      excludeTriggerKinds: [String!]
+    ): [WorkflowRunRecord!]!
+    """
+    The same listing a page at a time, newest journaled first. Pass a page's
+    cursor back in paging to read the next; a page is short only when
+    hasNextPage is false, or when the caller could read none of a long
+    stretch of runs. A run that starts between pages keeps its place.
+    """
+    runsPage(
+      workflowId: String
+      driveId: String
+      excludeTriggerKinds: [String!]
+      paging: WorkflowRunsPagingInput
+    ): WorkflowRunResultPage!
+    run(id: String!): WorkflowRunRecord
+    """
+    The descriptor (props, auth, ports) of one action or trigger, as the
+    version that runs it describes it; triggers come back under "trigger".
+    """
+    blockDescriptor(block: BlockInput!): Unknown
+    """
+    Resolves a dynamic prop against the current config values: a DROPDOWN
+    yields { options, placeholder, disabled }, a DYNAMIC prop yields the
+    resolved sub-property descriptor list.
+    """
+    blockOptions(
+      block: BlockInput!
+      propName: String!
+      input: Unknown
+      connectionId: String
+      "What the author typed, for a DROPDOWN declared with refreshOnSearch."
+      searchValue: String
+    ): Unknown
+    """
+    Every piece this reactor offers: the core piece, its package pieces, and
+    the pieces the registry and Activepieces publish.
+    """
+    pieceCatalog: Unknown
+    """
+    A piece's actions at one version; pin a step to that version.
+    """
+    pieceActions(
+      packageName: String!
+      "That version; the installed or latest one when omitted."
+      version: String
+    ): Unknown
+    """
+    A piece's triggers at one version; pin a trigger to that version.
+    """
+    pieceTriggers(
+      packageName: String!
+      "That version; the installed or latest one when omitted."
+      version: String
+    ): Unknown
+    """
+    Full piece detail (PieceMetadataModel-shaped), verbatim from the cloud API.
+    """
+    pieceDetail(
+      packageName: String!
+      "That version; the installed or latest one when omitted."
+      version: String
+    ): Unknown
+    """
+    Action/trigger name search across the catalog. The index builds lazily on
+    first use; poll while status is "indexing".
+    """
+    searchBlocks(query: String!, limit: Int): BlockSearchResult!
+    """
+    Health of every registered piece trigger (poll schedule, errors).
+    """
+    triggerStates: [TriggerStateRecord!]!
+    """
+    Authored output shape of a block (SDL / outputSchema / sampleData).
+    """
+    blockOutputTree(block: BlockInput!, config: Unknown): Unknown
+    """
+    Output shape of a draft step or trigger: its latest test output
+    (source "test", with sample and testedAt) when tested, else as blockOutputTree.
+    """
+    stepOutputTree(workflowId: String!, stepId: String!): Unknown
+    """
+    Every block of the draft (trigger first) as this reactor resolves it:
+    which piece version runs, from where, and how it matches the pin.
+    """
+    blockResolutions(workflowId: String!): [BlockResolutionRecord!]!
+    """
+    Every powerhouse/connection document, for connection pickers.
+    """
+    connections: [ConnectionRecord!]!
+    """
+    The webhook endpoint for a workflow: the URL to hand the provider. Minted
+    on first ask, whether or not the workflow is armed — an author needs the
+    URL before enabling, and the armed field carries that difference. Null
+    only when the host has no webhook service. With driveId, a workflow not
+    synced here yet is waited for briefly, then fails as WORKFLOW_SYNCING.
+    """
+    webhookEndpoint(workflowId: String!, driveId: String): WebhookEndpointRecord
+    """
+    Secret metadata (label, version, status). Never the value.
+    """
+    secret(ref: String!): SecretRecord
+    secrets: [SecretRecord!]!
+    """
+    The URL an OAuth2 app must register as its redirect. A bare path when
+    this host does not know its public origin; resolve it against the URL
+    this API is reached at. Null when the host serves no HTTP routes.
+    """
+    oauthRedirectUri: String
+    """
+    How an OAuth2 sign-in opened by startOAuth stands; null when unknown.
+    """
+    oauthAttempt(state: String!): OAuthAttempt
+  }
+
+  type OAuthAttempt {
+    connectionId: String!
+    "PENDING | EXCHANGING | OK | ERROR"
+    status: String!
+    error: String
+  }
+
+  type OAuthStart {
+    state: String!
+    "Where to send the user to sign in."
+    authorizationUrl: String!
+    redirectUri: String!
+    expiresAt: String!
+  }
+
+  """
+  One action or trigger of a piece, as a workflow pins it. The engine's own
+  blocks are the piece @powerhousedao/piece-core.
+  """
+  input BlockInput {
+    pieceName: String!
+    "Exact semver."
+    pieceVersion: String!
+    "The action or trigger name."
+    name: String!
+    "action | trigger"
+    kind: String!
+  }
+
+  type BlockSearchHit {
+    pieceName: String!
+    "The version the hit is listed at; pin to it when picking the block."
+    pieceVersion: String!
+    "The action or trigger name."
+    name: String!
+    pieceDisplayName: String!
+    logoUrl: String!
+    displayName: String!
+    description: String!
+    "action | trigger"
+    kind: String!
+    "Triggers only: POLLING | WEBHOOK | APP_WEBHOOK | MANUAL"
+    strategy: String
+    "Why this block cannot run on this reactor; null when it can."
+    unsupported: String
+  }
+
+  type BlockResolutionRecord {
+    "The trigger's or step's id."
+    stepId: String!
+    pieceName: String!
+    "The version the block pins."
+    pieceVersion: String!
+    "The action or trigger name."
+    name: String!
+    "action | trigger"
+    kind: String!
+    "The version that runs; null when nothing resolves."
+    resolvedVersion: String
+    "local | registry | activepieces | npm; null when nothing resolves."
+    source: String
+    "exact | compatible | fallback | installed | missing"
+    match: String!
+    "Why the version that runs differs from the pin, or why nothing resolves."
+    note: String
+    "The newest version any source offers."
+    latestVersion: String
+  }
+
+  type BlockSearchResult {
+    "ready | indexing | error"
+    status: String!
+    hits: [BlockSearchHit!]!
+    indexedPieces: Int!
+    error: String
+  }
+
+  type SecretRecord {
+    ref: String!
+    label: String
+    version: Int!
+    status: String!
+    createdAt: String!
+    updatedAt: String!
+  }
+
+  type ConnectionRecord {
+    id: String!
+    name: String!
+    connectorId: String!
+    authType: String!
+    status: String!
+    accountLabel: String
+  }
+
+  type ConnectionCheckResult {
+    ok: Boolean!
+    detail: String
+    """
+    From auth.getConnectionIdentifier when the check passes; otherwise the
+    label the connection already holds.
+    """
+    accountLabel: String
+  }
+
+  type WebhookEndpointRecord {
+    workflowId: String!
+    url: String!
+    """
+    False when the host gave the webhook service no public origin, so the url
+    above is a bare path. Switchboard always gives one, falling back to
+    http://localhost:<port> when PUBLIC_URL is unset.
+    """
+    absoluteUrl: Boolean!
+    "True while the workflow is ENABLED with a valid webhook trigger"
+    armed: Boolean!
+    createdAt: String!
+  }
+
+  type TriggerStateRecord {
+    workflowId: String!
+    pieceName: String!
+    triggerName: String!
+    status: String!
+    intervalMs: Int!
+    nextPollAt: String
+    lastPollAt: String
+    lastError: String
+    consecutiveFailures: Int!
+    "When a webhook trigger next renews its subscription; null if it never does."
+    nextRenewAt: String
+    "The last failed renewal, kept apart from lastError, the poll's."
+    renewError: String
+    renewFailures: Int!
+    "The piece version the trigger armed with; null for a host-fed trigger."
+    pieceVersion: String
+    pieceSource: String
+    versionMatch: String
+    versionNote: String
+  }
+
+  type Query {
+    workflowRuntime: WorkflowRuntimeQueries!
+  }
+
+  type WorkflowStepRunRecord {
+    stepId: String!
+    stepKey: String!
+    pieceName: String!
+    "The action the step ran, or the trigger a trigger test sampled."
+    blockName: String!
+    status: String!
+    input: Unknown
+    output: Unknown
+    port: String
+    error: String
+    startedAt: String
+    endedAt: String
+    "The piece version that ran; null for an unresolved block."
+    pieceVersion: String
+    "local | registry | activepieces | npm"
+    pieceSource: String
+    "exact | compatible | fallback | installed | missing"
+    versionMatch: String
+    "Why the version that ran differs from the pin."
+    versionNote: String
+  }
+
+  type WorkflowRunRecord {
+    id: String!
+    workflowId: String!
+    workflowName: String!
+    workflowVersion: Int!
+    triggerKind: String!
+    triggerPayload: Unknown
+    status: String!
+    error: String
+    "When the run began executing; a PENDING run's is when it was journaled."
+    startedAt: String!
+    endedAt: String
+    rerunOf: String
+    "How many warningNotes the run has; a run with any is not a plain success."
+    warnings: Int!
+    "Steps that ran a fallback piece version, edges on ports nothing emits."
+    warningNotes: [String!]!
+    steps: [WorkflowStepRunRecord!]!
+  }
+
+  input WorkflowRunsPagingInput {
+    "Page size; default 25, at most 100."
+    limit: Int
+    "The cursor of the previous page."
+    cursor: String
+  }
+
+  type WorkflowRunResultPage {
+    items: [WorkflowRunRecord!]!
+    hasNextPage: Boolean!
+    "True when the page was read after a cursor."
+    hasPreviousPage: Boolean!
+    "Resumes after this page's last run; null for an empty page."
+    cursor: String
+  }
+
+  type WorkflowStepRun {
+    stepId: String!
+    key: String!
+    pieceName: String!
+    blockName: String!
+    status: String!
+    input: Unknown
+    output: Unknown
+    port: String
+    error: String
+  }
+
+  type WorkflowRunPayload {
+    runId: String
+    status: String!
+    error: String
+    steps: [WorkflowStepRun!]!
+  }
+
+  type WorkflowStepTestResult {
+    "Null when the test never started, e.g. an upstream block is untested."
+    runId: String
+    "SUCCEEDED | FAILED"
+    status: String!
+    output: Unknown
+    error: String
+    durationMs: Int!
+  }
+
+  """
+  WorkflowRuntime Mutations
+  """
+  type WorkflowRuntimeMutations {
+    """
+    Fires a workflow's manual trigger (the core piece's) and runs it to completion.
+    """
+    fire(workflowId: String!, payload: Unknown): WorkflowRunPayload!
+    """
+    Samples the draft trigger and saves it as the trigger's last test. A piece
+    trigger runs its test hook (no cursor changes). Of the core piece's
+    triggers, manual takes payload, schedule samples a fire now, and webhook
+    waits for the next delivery to the workflow's endpoint, up to
+    timeoutSeconds (default and cap 300), and that delivery runs nothing.
+    """
+    testTrigger(
+      workflowId: String!
+      payload: Unknown
+      timeoutSeconds: Int
+      driveId: String
+    ): Unknown
+    """
+    Stops a webhook trigger test that is waiting; false when none was.
+    """
+    cancelTriggerTest(workflowId: String!): Boolean!
+    """
+    Runs one draft step against the latest test outputs of the blocks it
+    reads, journaled as a "test" run and noted as the step's lastTest.
+    driveId waits for an unsynced workflow, as for webhookEndpoint.
+    """
+    testStep(
+      workflowId: String!
+      stepId: String!
+      driveId: String
+    ): WorkflowStepTestResult!
+    """
+    Resumes a FAILED run: succeeded steps replay from the journal,
+    execution restarts at the failure. Produces a new run.
+    """
+    rerun(runId: String!): WorkflowRunPayload!
+    """
+    Mints a managed secret and returns its ref; the value is stored
+    encrypted and is never readable back over any API.
+    """
+    createSecret(value: String!, label: String): SecretRecord!
+    """
+    Replaces the value behind an existing ref; documents stay untouched.
+    """
+    rotateSecret(ref: String!, value: String!): SecretRecord!
+    """
+    Tombstones a secret; its value becomes unrecoverable.
+    """
+    deleteSecret(ref: String!): Boolean!
+    """
+    Runs the piece's auth.validate against the connection's credentials,
+    then auth.getConnectionIdentifier for the account label, and records the
+    outcome on the connection document.
+    """
+    checkConnection(connectionId: String!): ConnectionCheckResult!
+    """
+    Opens an OAuth2 sign-in with the connection's own app (client_id in its
+    config, client_secret in its secretRefs). redirectUri is needed only when
+    oauthRedirectUri is a bare path. With returnUrl, which must be on the
+    caller's origin, the callback sends the browser back there with
+    ?ph_oauth=<state> instead of closing the window.
+    """
+    startOAuth(
+      connectionId: String!
+      redirectUri: String
+      returnUrl: String
+    ): OAuthStart!
+  }
+
+  type Mutation {
+    workflowRuntime: WorkflowRuntimeMutations!
+  }
+`;
+//#endregion
+//#region src/workflow/subgraph.ts
+/** The runtime's read/write surface. The runtime itself is composed by the
+* host, so the subgraph only serves what it is handed. */
+function createWorkflowRuntimeSubgraph(runtime, oauth) {
+	return class WorkflowRuntimeSubgraph extends BaseSubgraph {
+		name = "workflow-runtime";
+		typeDefs = schema;
+		resolvers = getResolvers(runtime, this.authorizationService, oauth);
+		additionalContextFields = {};
+	};
+}
+//#endregion
+//#region src/workflow-runtime.mts
+/** The npm name the workflow package owns: its HTTP namespace and its models. */
+const WORKFLOW_PACKAGE_NAME = "@powerhousedao/workflow";
+/** The env var and OpenFeature flag key that turns workflows on. */
+const PH_WORKFLOWS_ENABLED = "PH_WORKFLOWS_ENABLED";
+/** Precedence, unchanged from the reactor-api resolver this replaces: the
+* host's option, then PH_WORKFLOWS_ENABLED, then the config file, then off. */
+async function resolveWorkflowsEnabled({ featureFlags, override, configEnabled = false, env = process.env }) {
+	if (override !== void 0) return override;
+	const raw = env[PH_WORKFLOWS_ENABLED]?.trim();
+	if (raw === "1") return true;
+	if (raw === "0") return false;
+	return featureFlags.getBooleanValue(PH_WORKFLOWS_ENABLED, configEnabled);
+}
+async function assertWorkflowPackageLoadable(load = () => import("@powerhousedao/workflow/document-models")) {
+	try {
+		await load();
+	} catch (error) {
+		throw new Error(`Workflows are enabled but ${WORKFLOW_PACKAGE_NAME} could not be loaded`, { cause: error });
+	}
+}
+function readAssertion(authorizationService, reactorClient) {
+	const resolveCanonical = createCanonicalDocumentIdResolver(reactorClient);
+	const hostCanRead = async (identifier, ctx) => {
+		if (authorizationService.isSupremeAdmin(ctx.user?.address)) return;
+		if (authorizationService.config.policy !== AuthorizationPolicy.DOCUMENT_PERMISSIONS) throw new ForbiddenError();
+		let documentId;
+		try {
+			documentId = await resolveCanonical(identifier);
+		} catch {
+			throw new ForbiddenError();
+		}
+		if (!await authorizationService.canRead(documentId, ctx.user?.address)) throw new ForbiddenError("to read this document");
+	};
+	return async (identifier, caller) => {
+		const ctx = caller;
+		await hostCanRead(identifier, ctx);
+		let served;
+		try {
+			served = await reactorClient.isServed(identifier, { subject: callerSubject(ctx.user) });
+		} catch {
+			throw new ForbiddenError();
+		}
+		if (!served) throw new ForbiddenError("to read this document");
+	};
+}
+/** The same, for a design-time call that writes what it names. */
+function writeAssertion(authorizationService, reactorClient) {
+	const resolveCanonical = createCanonicalDocumentIdResolver(reactorClient);
+	return async (identifier, caller) => {
+		const ctx = caller;
+		if (authorizationService.isSupremeAdmin(ctx.user?.address)) return;
+		if (authorizationService.config.policy !== AuthorizationPolicy.DOCUMENT_PERMISSIONS) throw new ForbiddenError();
+		let documentId;
+		try {
+			documentId = await resolveCanonical(identifier);
+		} catch {
+			throw new ForbiddenError();
+		}
+		if (!await authorizationService.canWrite(documentId, ctx.user?.address)) throw new ForbiddenError("to write this document");
+	};
+}
+/** Whether the workflow document really references the attachment. A step
+* carries no caller, so the relationship is the whole check. */
+function attachmentRefCheck(deps) {
+	const resolveCanonical = createCanonicalDocumentIdResolver(deps.reactorClient);
+	const references = deps.attachmentReferences;
+	const projection = deps.attachmentReferenceProjection;
+	return async (documentId, ref) => {
+		if (!references || projection?.status !== "available") return false;
+		let parsed;
+		try {
+			parsed = parseRef(ref);
+		} catch {
+			return false;
+		}
+		if (parsed.version !== 1) return false;
+		const canonicalRef = createRef(parsed.hash.toLowerCase());
+		try {
+			return await references.hasReference(await resolveCanonical(documentId), canonicalRef);
+		} catch {
+			return false;
+		}
+	};
+}
+async function registerWorkflowTriggersReadModel(engine, runtime, clientModule) {
+	const reactorModule = clientModule?.reactorModule;
+	if (!reactorModule) return {
+		status: "unavailable",
+		reason: "in-process-reactor-module-unavailable"
+	};
+	const coordinator = reactorModule.readModelCoordinator;
+	if (!supportsLiveReadModelRegistration(coordinator)) return {
+		status: "unavailable",
+		reason: "live-read-model-registration-unsupported"
+	};
+	const readModel = new engine.WorkflowTriggersReadModel(reactorModule.database.withSchema(REACTOR_SCHEMA), reactorModule.operationIndex, reactorModule.writeCache, reactorModule.processorManagerConsistencyTracker, runtime);
+	await readModel.init();
+	coordinator.addReadModel(readModel, engine.WORKFLOW_TRIGGERS_READ_MODEL_STAGE);
+	return { status: "available" };
+}
+function bindPackagePieces(registry, source) {
+	const apply = (byPackage) => {
+		registry.setPieces([...byPackage.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).flatMap(([, pieces]) => pieces));
+	};
+	apply(source.getPieces());
+	source.onPiecesChange(apply);
+}
+async function composeWorkflowRuntime(deps) {
+	const load = deps.load ?? (() => import("@powerhousedao/reactor-workflow"));
+	let engine;
+	try {
+		engine = await load();
+	} catch (error) {
+		throw new Error("Workflows are enabled but @powerhousedao/reactor-workflow could not be loaded", { cause: error });
+	}
+	engine.setPieceRegistryUrl(deps.pieceRegistryUrl);
+	if (deps.pieces) bindPackagePieces(engine.packagePieces, deps.pieces);
+	const runtime = engine.createWorkflowRuntime({
+		relationalDb: deps.relationalDb,
+		secretsKeyFile: deps.secretsKeyFile,
+		reactorClient: deps.reactorClient,
+		assertCanRead: readAssertion(deps.authorizationService, deps.reactorClient),
+		subjectOf: (caller) => callerSubject(caller.user),
+		assertCanWrite: writeAssertion(deps.authorizationService, deps.reactorClient),
+		webhooks: deps.webhooks,
+		attachments: deps.attachments,
+		canReadAttachmentRef: attachmentRefCheck(deps),
+		logger: deps.logger
+	});
+	const triggers = await registerWorkflowTriggersReadModel(engine, runtime, deps.clientModule);
+	if (triggers.status === "available") deps.logger.info(`Workflow trigger read model registered (${engine.WORKFLOW_TRIGGERS_READ_MODEL}, ${engine.WORKFLOW_TRIGGERS_READ_MODEL_STAGE})`);
+	else deps.logger.error("Workflow document triggers are NOT armed (@reason): this reactor's read-model coordinator takes no live registration, so no document operation reaches the runtime. Webhook and schedule triggers are unaffected.", triggers.reason);
+	let stopped = false;
+	const oauthCallback = deps.http ? registerOAuthCallback(deps.http, runtime) : void 0;
+	return {
+		subgraph: createWorkflowRuntimeSubgraph(runtime, deps.http ? { callbackUrl: callbackUrlOf(deps.http) } : void 0),
+		triggers,
+		async start() {
+			await runtime.registerWebhookEndpoint();
+			runtime.startTriggerSupervisor();
+		},
+		stop() {
+			if (stopped) return Promise.resolve();
+			stopped = true;
+			oauthCallback?.dispose();
+			runtime.shutdown();
+			return Promise.resolve();
+		}
+	};
+}
+//#endregion
 //#region src/pglite-dialect.ts
 var ClosablePGliteDialect = class extends PGliteDialect {
 	#pglite;
@@ -1003,6 +2158,26 @@ function resolveReactorFeatureFlags(env) {
 	};
 }
 //#endregion
+//#region src/create-signature-policy.mts
+/**
+* What new documents are created as, from CREATE_SIGNATURE_POLICY. Without a
+* signer this switchboard cannot write to a v2-required document, so it falls
+* back to legacy and says so.
+*/
+function resolveCreateSignaturePolicy(env, options) {
+	const raw = env.CREATE_SIGNATURE_POLICY?.trim();
+	let policy = DEFAULT_SIGNATURE_POLICY;
+	if (raw) {
+		if (!isSignaturePolicy(raw)) throw new Error(`CREATE_SIGNATURE_POLICY must be "legacy" or "v2-required", got "${raw}"`);
+		policy = raw;
+	}
+	if (policy === "v2-required" && !options.hasSigner) {
+		options.logger?.warn("No signer is configured, so new documents are created legacy: a v2-required document refuses the unsigned operations this switchboard would write. Set up an identity (ph login) to create v2-required documents.");
+		return "legacy";
+	}
+	return policy;
+}
+//#endregion
 //#region src/renown.ts
 const logger = childLogger(["switchboard", "renown"]);
 /**
@@ -1025,14 +2200,122 @@ async function initRenown(options = {}) {
 * Get the signer config for the given renown instance.
 *
 * @param renown - The renown instance
-* @param requireSignature - If true, unsigned actions are rejected
+* @param keypairPath - Where `initRenown` loaded the key from
 */
-function getRenownSignerConfig(renown, requireSignature) {
+function getRenownSignerConfig(renown, keypairPath) {
 	return {
 		signer: renown.signer,
-		verifier: createSignatureVerifier(requireSignature)
+		workerSigner: getRenownWorkerSignerSpec(renown, keypairPath)
 	};
 }
+/**
+* What a pooled executor worker imports to sign as this switchboard: it
+* reloads the key `initRenown` stored, and takes the user known at boot.
+*/
+function getRenownWorkerSignerSpec(renown, keypairPath) {
+	const { signer } = renown;
+	const user = signer.user;
+	return {
+		module: {
+			filePath: createRequire(import.meta.url).resolve("@renown/sdk/node"),
+			exportName: "createNodeRenownSigner"
+		},
+		initArgs: {
+			appName: signer.app?.name ?? "switchboard",
+			keypairPath: resolve(keypairPath ?? DEFAULT_KEYPAIR_PATH),
+			...signer.app?.key ? { did: signer.app.key } : {},
+			...user ? { user: {
+				address: user.address,
+				networkId: user.networkId,
+				chainId: user.chainId
+			} } : {}
+		}
+	};
+}
+/**
+* Admits a key as a signer for an address a Renown credential binds it to; a
+* `self` source has no worker spec. In process, the switchboard's own key is
+* matched against its current user; the worker spec carries the user known now.
+*/
+async function getRenownTrustPolicyConfig(trustSource, renown) {
+	const ownSigner = renown?.signer;
+	if (trustSource.source === "self") return { trustPolicy: createRenownTrustPolicy({
+		switchboard: trustSource.request,
+		ownSigner
+	}) };
+	const switchboardUrl = await resolveSwitchboardEndpoint({
+		switchboardUrl: trustSource.switchboardUrl,
+		baseUrl: trustSource.renownUrl
+	});
+	const options = {
+		...switchboardUrl ? { switchboard: switchboardUrl } : {},
+		...trustSource.renownUrl ? { renownUrl: trustSource.renownUrl } : {}
+	};
+	const self = ownIdentity(renown);
+	return {
+		trustPolicy: createRenownTrustPolicy({
+			...options,
+			ownSigner
+		}),
+		workerTrustPolicy: {
+			module: {
+				filePath: createRequire(import.meta.url).resolve("@renown/sdk/node"),
+				exportName: "createRenownTrustPolicy"
+			},
+			initArgs: {
+				...options,
+				...self ? { self } : {}
+			}
+		}
+	};
+}
+/**
+* Fails the boot when pooled workers would refuse every signed write the
+* in-process executor accepts: a `self` Renown source gives workers no trust
+* policy spec, so under authEnforcement they apply the default.
+*/
+function assertWorkerTrustPolicy(config) {
+	if (config.workers > 0 && config.authEnforcement && config.renownSource === "self") throw new Error("The executor worker pool (REACTOR_WORKERS) cannot verify signers when REACTOR_AUTH_ENFORCEMENT is on and Renown credentials are read from this switchboard (\"self\" via auth.renown.source or RENOWN_SOURCE): pooled workers have no trust policy and would refuse every signed write. Set RENOWN_SOURCE=remote, or disable the worker pool (REACTOR_WORKERS=0).");
+}
+function ownIdentity(renown) {
+	const key = renown?.signer.app?.key;
+	if (!key) return;
+	const user = renown.signer.user;
+	return {
+		key,
+		user: {
+			address: user?.address ?? "",
+			networkId: user?.networkId ?? "",
+			chainId: user?.chainId ?? 0
+		}
+	};
+}
+//#endregion
+//#region src/unsupported-stored-documents.mts
+const MODES = ["refuse", "read-only"];
+/** From REACTOR_UNSUPPORTED_STORED_DOCUMENTS; `input` wins when defined. */
+function resolveUnsupportedStoredDocuments(input, env) {
+	if (input !== void 0) return input;
+	const raw = env.REACTOR_UNSUPPORTED_STORED_DOCUMENTS?.trim();
+	if (!raw) return "refuse";
+	if (!MODES.includes(raw)) throw new Error(`REACTOR_UNSUPPORTED_STORED_DOCUMENTS must be "refuse" or "read-only", got "${raw}"`);
+	return raw;
+}
+/** The reactor refused to start over documents this build does not run. */
+var StoredDocumentsRefusedError = class extends Error {
+	versions;
+	documents;
+	constructor(cause) {
+		const named = cause.versions.map(({ protocol, version }) => `${protocol} ${version}`).join(", ");
+		super(`Refusing to start: ${cause.documents} stored document(s) require ${named}, which this switchboard does not run. Either start a switchboard build that runs ${named}, or set REACTOR_UNSUPPORTED_STORED_DOCUMENTS=read-only to start with those documents read-only.`, { cause });
+		this.name = "StoredDocumentsRefusedError";
+		this.versions = cause.versions;
+		this.documents = cause.documents;
+	}
+	static isError(error) {
+		return Error.isError(error) && error.name === "StoredDocumentsRefusedError";
+	}
+};
 //#endregion
 //#region src/server.mts
 const defaultLogger = childLogger(["switchboard"]);
@@ -1041,8 +2324,6 @@ setLogLevel(LogLevel);
 dotenv.config();
 const DOCUMENT_MODEL_SUBGRAPHS_ENABLED = "DOCUMENT_MODEL_SUBGRAPHS_ENABLED";
 const DOCUMENT_MODEL_SUBGRAPHS_ENABLED_DEFAULT = true;
-const REQUIRE_SIGNATURES = "REQUIRE_SIGNATURES";
-const REQUIRE_SIGNATURES_DEFAULT = false;
 const DEFAULT_PORT = process.env.PORT ? Number(process.env.PORT) : 4001;
 const PORT_FALLBACK_ATTEMPTS = 20;
 const PGLITE_FLUSH_INTERVAL_MS = (() => {
@@ -1077,6 +2358,13 @@ function isPortAvailable(port) {
 function resolveConfigPath(configFile) {
 	return configFile ?? path$1.join(process.cwd(), "powerhouse.config.json");
 }
+function readConfigWorkflowsEnabled(configPath) {
+	try {
+		return getConfig(configPath).workflows?.enabled ?? false;
+	} catch {
+		return false;
+	}
+}
 async function resolveServerPort(requested, strictPort, logger) {
 	if (strictPort) return requested;
 	for (let i = 0; i < PORT_FALLBACK_ATTEMPTS; i++) {
@@ -1189,8 +2477,14 @@ async function initServer(serverPort, options, renown, renownConfig) {
 	}
 	if (workerPool) {
 		if (dev) throw new Error("The executor worker pool (REACTOR_WORKERS) is not supported in dev mode: Vite-loaded document models cannot cross a worker-thread boundary");
+		assertWorkerTrustPolicy({
+			workers: workerPool.numWorkers,
+			authEnforcement: resolveReactorFeatureFlags(process.env).flags.authEnforcement === true,
+			renownSource: renownConfig.source
+		});
 		if (!reactorDbUrl || !isPostgresUrl(reactorDbUrl)) throw new Error("The executor worker pool (REACTOR_WORKERS) requires a Postgres reactor database — set PH_REACTOR_DATABASE_URL or PH_SWITCHBOARD_DATABASE_URL. PGlite cannot be shared across worker threads.");
 	}
+	const unsupportedStoredDocuments = resolveUnsupportedStoredDocuments(options.unsupportedStoredDocuments, process.env);
 	let projectionWorker = resolveProjectionWorkerOptions(options.projectionWorker, process.env);
 	if (projectionWorker && options.reactor) {
 		logger.warn("Projection worker configuration ignored: the caller-provided reactor owns its own read-model coordinator");
@@ -1224,7 +2518,13 @@ async function initServer(serverPort, options, renown, renownConfig) {
 		reactorLogger.error(`Projection worker ${shardId} died; shutting down so the supervisor restarts a healthy process`, reason);
 		process.kill(process.pid, "SIGTERM");
 	};
+	const workflowsEnabled = options.workflows?.enabled === true;
+	if (workflowsEnabled) {
+		await assertWorkflowPackageLoadable();
+		if (!packages.includes("@powerhousedao/workflow")) packages.push(WORKFLOW_PACKAGE_NAME);
+	}
 	let ownedReactorModule;
+	let localRenownRequest;
 	const initializeClient = async (documentModels, { attachmentReferenceWriter, upgradeManifests }) => {
 		if (options.reactor) {
 			const attachmentReferenceProjection = await registerAttachmentReferenceReadModelOnModule(options.reactor, attachmentReferenceWriter);
@@ -1251,7 +2551,7 @@ async function initServer(serverPort, options, renown, renownConfig) {
 		if (hasSkipThreshold) logger.info(`Reactor maxSkipThreshold set to ${maxSkipThreshold}`);
 		const { flags: reactorFeatureFlags, enabled: enabledFeatureFlags } = resolveReactorFeatureFlags(process.env);
 		if (enabledFeatureFlags.length > 0) logger.info(`Reactor feature flags enabled: ${enabledFeatureFlags.join(", ")}`);
-		const reactorBuilder = new ReactorBuilder().withEventBus(new EventBus()).withKysely(baseKysely).withFeatures({ legacyProcessorIds: process.env.REACTOR_LEGACY_PROCESSOR_IDS !== "false" });
+		const reactorBuilder = new ReactorBuilder().withEventBus(new EventBus()).withKysely(baseKysely).withFeatures({ legacyProcessorIds: process.env.REACTOR_LEGACY_PROCESSOR_IDS !== "false" }).withUnsupportedStoredDocuments(unsupportedStoredDocuments);
 		if (poolInstrumentation) reactorBuilder.withInstrumentedPool(poolInstrumentation);
 		const clientBuilder = new ReactorClientBuilder().withReactorBuilder(reactorBuilder);
 		const vetraDocumentModels = dev ? Object.values(await import("@powerhousedao/vetra/document-models")).filter((m) => typeof m === "object" && m !== null && "documentModel" in m && "reducer" in m) : [];
@@ -1264,7 +2564,19 @@ async function initServer(serverPort, options, renown, renownConfig) {
 			} : void 0,
 			documentModelLoader: httpLoader && dynamicModelLoading ? httpLoader.documentModelLoader : void 0,
 			logger: reactorLogger,
-			signer: renown ? getRenownSignerConfig(renown, options.identity?.requireSignatures) : void 0
+			signer: renown ? getRenownSignerConfig(renown, options.identity?.keypairPath) : void 0,
+			createSignaturePolicy: resolveCreateSignaturePolicy(process.env, {
+				hasSigner: renown !== null,
+				logger
+			}),
+			trustPolicy: reactorFeatureFlags.authEnforcement ? await getRenownTrustPolicyConfig(renownConfig.source === "self" ? {
+				source: "self",
+				request: (query, variables) => localRenownRequest ? localRenownRequest(query, variables) : Promise.reject(/* @__PURE__ */ new Error("The local renown read model is not bound yet"))
+			} : {
+				source: "remote",
+				renownUrl: renownConfig.url,
+				switchboardUrl: renownConfig.switchboardUrl
+			}, renown) : void 0
 		});
 		if (workerPool) {
 			if (!reactorDbUrl) throw new Error("unreachable: worker pool enabled without a reactor database URL");
@@ -1308,17 +2620,30 @@ async function initServer(serverPort, options, renown, renownConfig) {
 		reactorBuilder.withShutdownHook(async () => {
 			if (apiRef.current) await apiRef.current.dispose();
 		});
-		const module = await clientBuilder.buildModule();
+		let module;
+		try {
+			module = await clientBuilder.buildModule();
+		} catch (error) {
+			try {
+				await baseKysely.destroy();
+			} catch (destroyError) {
+				logger.error("Aborting boot: reactor database destroy failed: @error", destroyError);
+			}
+			if (UnsupportedStoredProtocolError.isError(error)) throw new StoredDocumentsRefusedError(error);
+			throw error;
+		}
 		if (module.reactorModule) {
 			new ReactorInstrumentation(module.reactorModule).start();
 			reactorLogger.info("Reactor metrics instrumentation started");
 		}
-		driveNodeView = new DriveNodeView(baseKysely.withSchema(REACTOR_SCHEMA));
+		const reactorDriveSchemaDb = baseKysely.withSchema(REACTOR_SCHEMA);
+		driveNodeView = new DriveNodeView(reactorDriveSchemaDb);
 		const reactorDriveClient = new ReactorDriveClient({
 			reactor: module.client,
 			readModel: driveNodeView
 		});
 		ownedReactorModule = module;
+		if (options.fatalErrorShutdown) installFatalErrorShutdown(logger);
 		return {
 			module,
 			reactorDriveClient,
@@ -1352,7 +2677,7 @@ async function initServer(serverPort, options, renown, renownConfig) {
 	if (dev) {
 		const { VitePackageLoader, createViteLogger, startViteServer } = await import("@powerhousedao/reactor-api/vite");
 		vite = await startViteServer(process.cwd(), createViteLogger(logger));
-		viteLoader = VitePackageLoader.build(vite);
+		viteLoader = VitePackageLoader.build(vite, { resolveFrom: [import.meta.url] });
 	}
 	const vetraProcessorFactory = dev ? (await import("@powerhousedao/vetra/processors")).processorFactory : void 0;
 	if (!options.disableLocalPackages) packages.push(basePath);
@@ -1401,7 +2726,8 @@ async function initServer(serverPort, options, renown, renownConfig) {
 			await abortBoot(api);
 			throw new Error(`Renown credential verification is set to "self" (auth.renown.source or RENOWN_SOURCE) but no loaded package serves the "${RENOWN_READ_MODEL_SUBGRAPH}" subgraph. Install one (@powerhousedao/renown-package) or set RENOWN_SOURCE=remote.`);
 		}
-		localCredentialCheck = createLocalCredentialVerifier((query, variables) => manager.executeSubgraphQuery(RENOWN_READ_MODEL_SUBGRAPH, query, variables), { onError: (error) => logger.error("Renown read model query failed: @error", error) });
+		localRenownRequest = (query, variables) => manager.executeSubgraphQuery(RENOWN_READ_MODEL_SUBGRAPH, query, variables);
+		localCredentialCheck = createLocalCredentialVerifier(localRenownRequest, { onError: (error) => logger.error("Renown read model query failed: @error", error) });
 		logger.info("Renown credentials will be verified against this switchboard's own renown read model");
 	}
 	registerAttachmentRoutes(api);
@@ -1409,6 +2735,45 @@ async function initServer(serverPort, options, renown, renownConfig) {
 	if (process.env.SENTRY_DSN) api.httpAdapter.setupSentryErrorHandler(Sentry);
 	const { client, graphqlManager, documentModelRegistry } = api;
 	const lateSubgraphs = [];
+	let workflows;
+	if (workflowsEnabled) {
+		workflows = await composeWorkflowRuntime({
+			reactorClient: client,
+			clientModule: options.reactor ?? ownedReactorModule,
+			relationalDb: api.relationalDb,
+			secretsKeyFile: readModelPgliteDir === null ? false : void 0,
+			attachments: createAttachmentClient(api.attachments.service),
+			attachmentReferences: api.attachmentReferenceIndex.store,
+			attachmentReferenceProjection: api.attachmentReferenceProjection,
+			webhooks: api.httpRoutes.scopeFor(WORKFLOW_PACKAGE_NAME).webhooks,
+			http: api.httpRoutes.scopeFor(WORKFLOW_PACKAGE_NAME),
+			authorizationService: api.authorizationService,
+			pieces: api.packageManager,
+			pieceRegistryUrl: registryUrl,
+			logger: logger.child(["workflow-runtime"])
+		});
+		const WorkflowRuntimeSubgraph = workflows.subgraph;
+		const workflowSubgraph = new WorkflowRuntimeSubgraph({
+			reactorClient: client,
+			http: graphqlManager.scopeForPackage(WORKFLOW_PACKAGE_NAME),
+			relationalDb: api.relationalDb,
+			analyticsStore: void 0,
+			graphqlManager,
+			syncManager: api.syncManager,
+			authorizationService: graphqlManager.getAuthorizationService(),
+			path: graphqlManager.getBasePath()
+		});
+		lateSubgraphs.push(graphqlManager.registerSubgraphInstance(workflowSubgraph, "graphql", false).catch((error) => {
+			logger.error("Failed to register workflow-runtime subgraph: @error", error);
+		}));
+		await workflows.start();
+		logger.info("Workflow runtime started");
+	}
+	const shutdown = async () => {
+		await workflows?.stop();
+		await api.dispose();
+	};
+	apiRef.current = { dispose: shutdown };
 	if (httpLoader) {
 		const packageManagementService = new PackageManagementService({
 			defaultRegistryUrl: registryUrl,
@@ -1438,10 +2803,15 @@ async function initServer(serverPort, options, renown, renownConfig) {
 	}
 	if (driveNodeView) {
 		graphqlManager.setAdditionalContextFields({ readModel: driveNodeView });
+		const authorizationService = graphqlManager.getAuthorizationService();
 		const reactorDriveSubgraph = {
 			name: "reactor-drive",
 			path: graphqlManager.getBasePath(),
-			resolvers: createReactorDriveResolvers(),
+			resolvers: createReactorDriveResolvers({
+				reactorClient: client,
+				readModel: driveNodeView,
+				hostCanRead: (documentId, address) => authorizationService.canRead(documentId, address)
+			}),
 			typeDefs: reactorDriveSubgraphTypeDefs,
 			reactorClient: client,
 			relationalDb: void 0
@@ -1492,9 +2862,12 @@ async function initServer(serverPort, options, renown, renownConfig) {
 		reactor: client,
 		attachmentService,
 		attachmentReferenceProjection: api.attachmentReferenceProjection,
+		workflowTriggers: workflows?.triggers,
+		workflowsEnabled,
+		mcpEnabled: options.mcp !== false,
 		renown,
 		port: serverPort,
-		shutdown: () => api.dispose()
+		shutdown
 	};
 }
 /**
@@ -1521,16 +2894,26 @@ const startSwitchboard = async (options = {}) => {
 	const featureFlags = await initFeatureFlags();
 	const enableDocumentModelSubgraphs = await featureFlags.getBooleanValue(DOCUMENT_MODEL_SUBGRAPHS_ENABLED, options.enableDocumentModelSubgraphs ?? DOCUMENT_MODEL_SUBGRAPHS_ENABLED_DEFAULT);
 	options.enableDocumentModelSubgraphs = enableDocumentModelSubgraphs;
-	const requireSignatures = options.identity?.requireSignatures ?? await featureFlags.getBooleanValue(REQUIRE_SIGNATURES, REQUIRE_SIGNATURES_DEFAULT);
+	options.mcp = await resolveMcpEnabled({
+		featureFlags,
+		option: options.mcp
+	});
+	const configPathForFlags = resolveConfigPath(options.configFile);
+	const workflowsEnabled = await resolveWorkflowsEnabled({
+		featureFlags,
+		override: options.workflows?.enabled,
+		configEnabled: readConfigWorkflowsEnabled(configPathForFlags)
+	});
+	options.workflows = { enabled: workflowsEnabled };
 	const renownConfig = resolveRenownConfig(getConfig(resolveConfigPath(options.configFile)).auth?.renown, process.env, logger);
 	options.identity = {
 		...options.identity,
-		requireSignatures,
 		baseUrl: options.identity?.baseUrl ?? renownConfig.url
 	};
 	logger.info("Feature flags: @flags", JSON.stringify({
 		DOCUMENT_MODEL_SUBGRAPHS_ENABLED: enableDocumentModelSubgraphs,
-		REQUIRE_SIGNATURES: requireSignatures
+		MCP_ENABLED: options.mcp,
+		PH_WORKFLOWS_ENABLED: workflowsEnabled
 	}, null, 2));
 	let renown = null;
 	try {
@@ -1543,13 +2926,14 @@ const startSwitchboard = async (options = {}) => {
 		return await initServer(serverPort, options, renown, renownConfig);
 	} catch (e) {
 		Sentry.captureException(e);
-		logger.error("App crashed: @error", e);
+		if (StoredDocumentsRefusedError.isError(e)) logger.error(e.message);
+		else logger.error("App crashed: @error", e);
 		throw e;
 	}
 };
-if (import.meta.main) await startSwitchboard();
+if (import.meta.main) await startSwitchboard({ fatalErrorShutdown: true });
 //#endregion
-export { parseForcePgVersion as a, applySwitchboardReactorDefaults as i, isPortAvailable as n, startSwitchboard as r, deriveAttachmentServiceConfig as t };
+export { resolveUnsupportedStoredDocuments as a, StoredDocumentsRefusedError as i, isPortAvailable as n, applySwitchboardReactorDefaults as o, startSwitchboard as r, parseForcePgVersion as s, deriveAttachmentServiceConfig as t };
 
-//# sourceMappingURL=server-CiKkVE6g.mjs.map
-//# debugId=e2c62b7b-68fd-59c2-ab82-7d035e11698b
+//# sourceMappingURL=server-sQoWp21G.mjs.map
+//# debugId=66287c02-682f-57d0-8260-a1005691b2bc