@powerhousedao/switchboard 6.2.3-dev.5 → 6.2.3-dev.51

package/dist/server-CiKkVE6g.mjs

@@ -1,1555 +0,0 @@
-
-!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";
-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 { 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 { 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 { 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 { Kysely, PostgresDialect } from "kysely";
-import net from "node:net";
-import path$1 from "path";
-import { Pool } from "pg";
-import { Readable } from "node:stream";
-import { ReactorGroupV1 } from "@powerhousedao/reactor-group";
-import { driveDocumentModelModule } from "@powerhousedao/shared/document-drive";
-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 { PGliteDialect } from "kysely-pglite-dialect";
-//#region src/pglite-version.ts
-const SUPPORTED_PG_MAJORS = [16, 17];
-async function readPgVersionFile(dataDir) {
-	try {
-		const raw = await promises.readFile(path.join(dataDir, "PG_VERSION"), "utf8");
-		const major = parseInt(raw.trim(), 10);
-		return Number.isFinite(major) ? major : null;
-	} catch {
-		return null;
-	}
-}
-function isSupportedMajor(major) {
-	return SUPPORTED_PG_MAJORS.includes(major);
-}
-/**
-* Parses the `PH_FORCE_PG_VERSION` env var. Returns the validated major, or
-* `null` when the var is unset/empty. Throws on any value that is not a
-* supported major — invalid configuration must fail before the server starts
-* touching disk.
-*/
-function parseForcePgVersion(raw) {
-	if (raw === void 0 || raw.trim() === "") return null;
-	const parsed = Number(raw);
-	if (Number.isInteger(parsed) && isSupportedMajor(parsed)) return parsed;
-	throw new Error(`PH_FORCE_PG_VERSION must be one of: ${SUPPORTED_PG_MAJORS.join(", ")} (got: ${raw})`);
-}
-async function loadPGliteModule(major) {
-	if (major === 16) return await import("pglite-legacy-02");
-	return import("@electric-sql/pglite");
-}
-async function loadPgDump(major) {
-	if (major === 16) return (await import("pglite-tools-legacy-02/pg_dump")).pgDump;
-	return (await import("@electric-sql/pglite-tools/pg_dump")).pgDump;
-}
-//#endregion
-//#region src/attachments/auth.ts
-const ANONYMOUS_ACTOR = {
-	user: void 0,
-	authEnabled: false
-};
-/**
-* Wrap a Node-style handler so that, when `authService` is provided and auth is
-* 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.
-*/
-function requireAuth(authService, handler, options) {
-	if (!authService) return (req, res, body) => handler(req, res, body, ANONYMOUS_ACTOR);
-	return async (req, res, body) => {
-		let result;
-		try {
-			result = await authService.verifyBearer(req.headers.authorization);
-		} catch {
-			res.statusCode = 500;
-			res.setHeader("Content-Type", "application/json");
-			res.end(JSON.stringify({ error: "Internal authentication error" }));
-			return;
-		}
-		if (result instanceof Response) {
-			const body = await result.text();
-			res.statusCode = result.status;
-			const contentType = result.headers.get("content-type");
-			if (contentType) res.setHeader("Content-Type", contentType);
-			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;
-		}
-		await handler(req, res, body, {
-			user: result.user,
-			authEnabled: result.auth_enabled
-		});
-	};
-}
-//#endregion
-//#region src/attachments/mount-auth.ts
-/**
-* Mount a Node-style attachment route with `requireAuth` applied unconditionally.
-* When `api.authService` is undefined (auth disabled), the handler still runs
-* through `requireAuth` and receives the anonymous actor context — that is the
-* only way to opt out of bearer verification. To register a route without auth
-* 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.
-*/
-function mountAuthenticatedNodeRoute(api, method, path, handler, options) {
-	api.httpAdapter.mountNodeRoute(method, path, requireAuth(api.authService, handler, options));
-}
-//#endregion
-//#region src/attachments/routes.ts
-const logger$1 = childLogger(["switchboard", "attachments"]);
-const RETRY_AFTER_SECONDS = 5;
-const HASH_PATTERN = /^[a-f0-9]{64}$/i;
-const CONTROL_CHARS = /[\x00-\x1f\x7f]/;
-const MIME_TYPE_PATTERN = /^[!#$%&'*+\-.^_`|~\w]+\/[!#$%&'*+\-.^_`|~\w]+(?:\s*;\s*[!#$%&'*+\-.^_`|~\w]+=(?:[!#$%&'*+\-.^_`|~\w]+|"(?:[^"\\\r\n]|\\[^\r\n])*"))*$/;
-const MAX_FILENAME_LEN = 255;
-const MAX_MIMETYPE_LEN = 255;
-function sendJson(res, status, body) {
-	res.statusCode = status;
-	res.setHeader("Content-Type", "application/json");
-	res.end(JSON.stringify(body));
-}
-function sendError(res, status, message) {
-	sendJson(res, status, { error: message });
-}
-function statusForError(err) {
-	if (err instanceof AttachmentNotFound) return 404;
-	if (err instanceof ReservationNotFound) return 404;
-	if (err instanceof InvalidAttachmentRef) return 400;
-	if (err instanceof UploadTooLarge) return 413;
-	return 500;
-}
-function sendErrorFromException(res, err) {
-	const status = statusForError(err);
-	if (status >= 500) {
-		logger$1.error("Attachment route error: @error", err);
-		sendError(res, status, "Internal error");
-		return;
-	}
-	sendError(res, status, err instanceof Error ? err.message : String(err));
-}
-async function readJsonBody(req, body) {
-	if (body !== void 0 && body !== null && typeof body === "object") return body;
-	const chunks = [];
-	for await (const chunk of req) chunks.push(chunk);
-	if (chunks.length === 0) return void 0;
-	const text = Buffer.concat(chunks).toString("utf8");
-	if (text.length === 0) return void 0;
-	return JSON.parse(text);
-}
-function parseReserveOptions(input) {
-	if (input === null || typeof input !== "object") return null;
-	const obj = input;
-	if (typeof obj.mimeType !== "string" || obj.mimeType.length === 0 || obj.mimeType.length > MAX_MIMETYPE_LEN || !MIME_TYPE_PATTERN.test(obj.mimeType)) return null;
-	if (typeof obj.fileName !== "string" || obj.fileName.length === 0 || obj.fileName.length > MAX_FILENAME_LEN || CONTROL_CHARS.test(obj.fileName)) return null;
-	let extension = null;
-	if (typeof obj.extension === "string") {
-		if (obj.extension.length === 0 || /[\\/]/.test(obj.extension)) return null;
-		extension = obj.extension;
-	} else if (obj.extension !== void 0 && obj.extension !== null) return null;
-	if (obj.clientHash !== void 0) {
-		if (typeof obj.clientHash !== "string" || !HASH_PATTERN.test(obj.clientHash)) return null;
-		if (typeof obj.sizeBytes !== "number" || !Number.isInteger(obj.sizeBytes) || obj.sizeBytes <= 0 || !Number.isSafeInteger(obj.sizeBytes)) return null;
-		return {
-			mimeType: obj.mimeType,
-			fileName: obj.fileName,
-			extension,
-			clientHash: obj.clientHash.toLowerCase(),
-			sizeBytes: obj.sizeBytes
-		};
-	}
-	return {
-		mimeType: obj.mimeType,
-		fileName: obj.fileName,
-		extension
-	};
-}
-function quoteFilename(name) {
-	return `"${name.replace(/[\\"]/g, "\\$&")}"`;
-}
-function buildContentDisposition(fileName) {
-	const ascii = fileName.replace(/[^\x20-\x21\x23-\x5b\x5d-\x7e]/g, "_");
-	const encoded = encodeURIComponent(fileName).replace(/['()*!]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
-	return `attachment; filename=${quoteFilename(ascii)}; filename*=UTF-8''${encoded}`;
-}
-function makeReserveHandler(attachments) {
-	return async (req, res, body) => {
-		let parsed;
-		try {
-			parsed = await readJsonBody(req, body);
-		} catch {
-			sendError(res, 400, "Invalid JSON body");
-			return;
-		}
-		const opts = parseReserveOptions(parsed);
-		if (!opts) {
-			sendError(res, 400, "Body must be { mimeType: string (type/subtype), fileName: string (no control characters, max 255 chars), extension?: string|null, clientHash?: string (64 hex chars), sizeBytes?: number (required with clientHash) }");
-			return;
-		}
-		let upload;
-		try {
-			upload = await attachments.service.reserve(opts);
-		} catch (err) {
-			if (err instanceof AttachmentAlreadyExists) {
-				sendJson(res, 409, {
-					error: "already_exists",
-					ref: err.ref
-				});
-				return;
-			}
-			sendErrorFromException(res, err);
-			return;
-		}
-		sendJson(res, 201, {
-			reservationId: upload.reservationId,
-			ref: upload.ref,
-			expiresAtUtc: upload.expiresAtUtc,
-			...upload.uploadTarget ? { uploadTarget: upload.uploadTarget } : {}
-		});
-	};
-}
-function makeUploadHandler(attachments) {
-	return async (req, res) => {
-		const reservationId = extractParam(req, "reservationId");
-		if (!reservationId) {
-			sendError(res, 400, "Missing reservationId");
-			return;
-		}
-		if (attachments.backend?.kind === "s3") {
-			sendError(res, 405, "Use the reservation uploadTarget for S3 uploads");
-			return;
-		}
-		let reservation;
-		try {
-			reservation = await attachments.reservations.get(reservationId);
-		} catch (err) {
-			sendErrorFromException(res, err);
-			return;
-		}
-		const upload = attachments.uploadFactory.createUpload(reservation);
-		const webStream = Readable.toWeb(req);
-		try {
-			sendJson(res, 200, await upload.send(webStream));
-		} catch (err) {
-			if (err instanceof HashMismatch) {
-				sendJson(res, 422, {
-					error: "hash_mismatch",
-					claimed: err.claimed,
-					actual: err.actual
-				});
-				return;
-			}
-			if (err instanceof SizeMismatch) {
-				sendJson(res, 422, {
-					error: "size_mismatch",
-					declared: err.declared,
-					actual: err.actual
-				});
-				return;
-			}
-			sendErrorFromException(res, err);
-		}
-	};
-}
-function makeDownloadHandler(attachments) {
-	return async (req, res) => {
-		const hash = extractParam(req, "hash");
-		if (!hash || !HASH_PATTERN.test(hash)) {
-			sendError(res, 400, "Invalid attachment hash");
-			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);
-		} catch (err) {
-			if (err instanceof AttachmentPending) {
-				res.statusCode = 202;
-				res.setHeader("Retry-After", String(RETRY_AFTER_SECONDS));
-				res.setHeader("Attachment-Pending", JSON.stringify({
-					expiresAtUtc: err.expiresAtUtc,
-					...err.metadata ?? {}
-				}));
-				res.end();
-				return;
-			}
-			sendErrorFromException(res, err);
-			return;
-		}
-		const { header, body } = response;
-		res.statusCode = 200;
-		res.setHeader("Content-Type", header.mimeType);
-		res.setHeader("Content-Length", String(header.sizeBytes));
-		res.setHeader("Content-Disposition", buildContentDisposition(header.fileName));
-		res.setHeader("Attachment-Metadata", buildMetadataHeader(header));
-		Readable.fromWeb(body).pipe(res);
-	};
-}
-function buildMetadataHeader(header) {
-	return JSON.stringify({
-		mimeType: header.mimeType,
-		fileName: header.fileName,
-		sizeBytes: header.sizeBytes,
-		extension: header.extension,
-		createdAtUtc: header.createdAtUtc,
-		lastAccessedAtUtc: header.lastAccessedAtUtc
-	});
-}
-function makeStatHandler(attachments) {
-	return async (req, res) => {
-		const hash = extractParam(req, "hash");
-		if (!hash || !HASH_PATTERN.test(hash)) {
-			sendError(res, 400, "Invalid attachment hash");
-			return;
-		}
-		const canonicalHash = hash.toLowerCase();
-		let header;
-		try {
-			header = await attachments.store.stat(canonicalHash);
-		} catch (err) {
-			sendErrorFromException(res, err);
-			return;
-		}
-		if (header.status === "pending") {
-			res.statusCode = 202;
-			res.setHeader("Retry-After", String(RETRY_AFTER_SECONDS));
-			res.setHeader("Attachment-Pending", JSON.stringify({
-				expiresAtUtc: header.expiresAtUtc,
-				mimeType: header.mimeType,
-				fileName: header.fileName,
-				sizeBytes: header.sizeBytes
-			}));
-			res.end();
-			return;
-		}
-		res.statusCode = 200;
-		res.setHeader("Content-Type", header.mimeType);
-		res.setHeader("Content-Length", String(header.sizeBytes));
-		res.setHeader("Content-Disposition", buildContentDisposition(header.fileName));
-		res.setHeader("Attachment-Metadata", buildMetadataHeader(header));
-		res.end();
-	};
-}
-function makeGetReservationHandler(attachments) {
-	return async (req, res) => {
-		const reservationId = extractParam(req, "reservationId");
-		if (!reservationId) {
-			sendError(res, 400, "Missing reservationId");
-			return;
-		}
-		try {
-			sendJson(res, 200, await attachments.reservations.get(reservationId));
-		} catch (err) {
-			sendErrorFromException(res, err);
-		}
-	};
-}
-function makeDeleteReservationHandler(attachments) {
-	return async (req, res) => {
-		const reservationId = extractParam(req, "reservationId");
-		if (!reservationId) {
-			sendError(res, 400, "Missing reservationId");
-			return;
-		}
-		try {
-			await attachments.reservations.delete(reservationId);
-			res.statusCode = 204;
-			res.end();
-		} catch (err) {
-			sendErrorFromException(res, err);
-		}
-	};
-}
-function extractParam(req, name) {
-	return req.params?.[name];
-}
-const MAX_DOCUMENT_ID_LEN = 512;
-const ATTACHMENT_NOT_FOUND_BODY = { error: "Attachment not found" };
-const MAX_DOWNLOAD_TARGET_TTL_SECONDS = 10080 * 60;
-/**
-* Returns the single `documentId` query value, or null when it is missing,
-* duplicated, blank, or oversized. Validation happens before authorization so
-* malformed requests never reach the access service.
-*/
-function extractSingleDocumentId(req) {
-	if (!req.url) return null;
-	let url;
-	try {
-		url = new URL(req.url, "http://switchboard.invalid");
-	} catch {
-		return null;
-	}
-	const values = url.searchParams.getAll("documentId");
-	if (values.length !== 1) return null;
-	const value = values[0];
-	if (value.trim().length === 0 || value.length > MAX_DOCUMENT_ID_LEN) return null;
-	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.
-*/
-function extractExpiresIn(req) {
-	if (!req.url) return void 0;
-	let url;
-	try {
-		url = new URL(req.url, "http://switchboard.invalid");
-	} catch {
-		return;
-	}
-	const values = url.searchParams.getAll("expiresIn");
-	if (values.length === 0) return void 0;
-	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);
-}
-/**
-* 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.
-*/
-function requestBaseUrl(req) {
-	const forwardedProto = req.headers["x-forwarded-proto"];
-	const proto = (Array.isArray(forwardedProto) ? forwardedProto[0] : forwardedProto)?.split(",")[0]?.trim() || (req.socket.encrypted ? "https" : "http");
-	const forwardedHost = req.headers["x-forwarded-host"];
-	const host = (Array.isArray(forwardedHost) ? forwardedHost[0] : forwardedHost) ?? req.headers.host;
-	if (!host) return null;
-	return `${proto}://${host}`;
-}
-function makeDownloadTargetHandler(attachments, attachmentAccess) {
-	return async (req, res, _body, actor) => {
-		res.setHeader("Cache-Control", "no-store");
-		const hash = extractParam(req, "hash");
-		if (!hash || !HASH_PATTERN.test(hash)) {
-			sendError(res, 400, "Invalid attachment hash");
-			return;
-		}
-		const documentId = extractSingleDocumentId(req);
-		if (documentId === null) {
-			sendError(res, 400, "documentId is required exactly once as a non-empty query parameter");
-			return;
-		}
-		const expiresIn = extractExpiresIn(req);
-		if (expiresIn === "invalid") {
-			sendError(res, 400, "expiresIn must be a single positive integer number of seconds");
-			return;
-		}
-		const canonicalHash = hash.toLowerCase();
-		let decision;
-		try {
-			decision = await attachmentAccess.canReadAttachment({
-				documentId,
-				attachmentRef: createRef(canonicalHash),
-				userAddress: actor?.user?.address
-			});
-		} catch (err) {
-			logger$1.error("Attachment access decision failed: @error", err);
-			sendError(res, 500, "Internal error");
-			return;
-		}
-		if (decision.kind === "projection-unavailable") {
-			sendError(res, 503, "Attachment downloads are temporarily unavailable");
-			return;
-		}
-		if (decision.kind === "denied") {
-			sendJson(res, 404, ATTACHMENT_NOT_FOUND_BODY);
-			return;
-		}
-		let header;
-		try {
-			header = await attachments.store.stat(canonicalHash);
-		} catch (err) {
-			if (err instanceof AttachmentNotFound) {
-				sendJson(res, 404, ATTACHMENT_NOT_FOUND_BODY);
-				return;
-			}
-			logger$1.error("Attachment metadata lookup failed: @error", err);
-			sendError(res, 500, "Internal error");
-			return;
-		}
-		if (header.status !== "available") {
-			sendJson(res, 404, ATTACHMENT_NOT_FOUND_BODY);
-			return;
-		}
-		let target;
-		if (attachments.backend && attachments.backend.kind !== "filesystem") try {
-			target = await attachments.backend.prepareDownloadTarget(canonicalHash, expiresIn);
-		} catch {
-			sendError(res, 502, "Attachment download target unavailable");
-			return;
-		}
-		else {
-			const base = requestBaseUrl(req);
-			if (!base) {
-				sendError(res, 500, "Internal error");
-				return;
-			}
-			try {
-				target = parseAttachmentDownloadTarget({
-					kind: "switchboard",
-					method: "GET",
-					url: `${base}/attachments/${canonicalHash}`,
-					headers: {}
-				});
-			} catch {
-				sendError(res, 500, "Internal error");
-				return;
-			}
-		}
-		sendJson(res, 200, target);
-	};
-}
-//#endregion
-//#region src/attachments/index.ts
-function registerAttachmentRoutes(api) {
-	const { attachments } = api;
-	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));
-}
-//#endregion
-//#region src/attachment-reference-read-model.mts
-const attachmentSchemaCompiler = new AttachmentSchemaCompiler();
-function createAttachmentReferenceReadModel(baseKysely, dependencies, attachmentReferenceWriter) {
-	return new AttachmentReferenceReadModel(baseKysely.withSchema(REACTOR_SCHEMA), dependencies.operationIndex, dependencies.writeCache, dependencies.processorManagerConsistencyTracker, dependencies.documentModelRegistry, attachmentSchemaCompiler, attachmentReferenceWriter);
-}
-function registerAttachmentReferenceReadModel(reactorBuilder, registration) {
-	reactorBuilder.withReadModelFactory(async ({ documentModelRegistry, operationIndex, writeCache, processorManagerConsistencyTracker }) => {
-		const readModel = createAttachmentReferenceReadModel(registration.baseKysely, {
-			operationIndex,
-			writeCache,
-			processorManagerConsistencyTracker,
-			documentModelRegistry
-		}, registration.attachmentReferenceWriter);
-		await readModel.init();
-		return readModel;
-	});
-}
-async function registerAttachmentReferenceReadModelOnModule(clientModule, attachmentReferenceWriter) {
-	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 = createAttachmentReferenceReadModel(reactorModule.database, {
-		operationIndex: reactorModule.operationIndex,
-		writeCache: reactorModule.writeCache,
-		processorManagerConsistencyTracker: reactorModule.processorManagerConsistencyTracker,
-		documentModelRegistry: reactorModule.documentModelRegistry
-	}, attachmentReferenceWriter);
-	await readModel.init();
-	coordinator.addReadModel(readModel, "pre_ready");
-	await readModel.init();
-	return { status: "available" };
-}
-//#endregion
-//#region src/builder-defaults.mts
-/**
-* Apply switchboard's standard configuration to a reactor + client builder
-* pair. Each piece is opt-out via the options object; defaults mirror what
-* `startSwitchboard` does when building a reactor itself. Mutates both
-* builders in place.
-*
-* Does NOT touch kysely or read models — callers wire those themselves
-* (see `withKysely` / `withReadModelFactory` on the reactor builder).
-*/
-/** The models switchboard always registers alongside package models. */
-function switchboardBaseDocumentModels() {
-	return [
-		documentModelDocumentModelModule,
-		driveDocumentModelModule,
-		reactorDriveDocumentModelModule,
-		ReactorGroupV1
-	];
-}
-function applySwitchboardReactorDefaults(reactorBuilder, clientBuilder, options = {}) {
-	const baseModels = options.includeBaseModels !== false ? switchboardBaseDocumentModels() : [];
-	const extra = options.documentModels ?? [];
-	if (baseModels.length || extra.length) reactorBuilder.withDocumentModelSources(getUniqueDocumentModels(baseModels, extra));
-	if (options.upgradeManifests?.length) reactorBuilder.withUpgradeManifests(options.upgradeManifests);
-	const scheme = options.channelScheme === void 0 ? ChannelScheme.SWITCHBOARD : options.channelScheme;
-	if (scheme !== false) reactorBuilder.withChannelScheme(scheme);
-	if (options.signalHandlers !== false) reactorBuilder.withSignalHandlers();
-	if (options.executorConfig?.maxSkipThreshold !== void 0 || options.executorConfig?.featureFlags !== void 0) reactorBuilder.withExecutorConfig({
-		...options.executorConfig.maxSkipThreshold !== void 0 ? { maxSkipThreshold: options.executorConfig.maxSkipThreshold } : {},
-		...options.executorConfig.featureFlags !== void 0 ? { featureFlags: options.executorConfig.featureFlags } : {}
-	});
-	if (options.documentModelLoader) reactorBuilder.withDocumentModelLoader(options.documentModelLoader);
-	if (options.logger) reactorBuilder.withLogger(options.logger);
-	if (options.signer) clientBuilder.withSigner(options.signer);
-}
-//#endregion
-//#region src/worker-pool.mts
-const DEFAULT_DB_POOL_SIZE_PER_WORKER = 2;
-const DEFAULT_ACQUIRE_TIMEOUT_MS = 5e3;
-const DEFAULT_DB_POOL_SIZE_HOST = 16;
-const AUTO_RESERVED_CORES = 2;
-const AUTO_WORKER_CAP = 8;
-/** Worker count for "auto": always at least 1 — auto sizes the pool, it does not turn worker mode off. */
-function autoWorkerCount(availableCores) {
-	return Math.max(1, Math.min(AUTO_WORKER_CAP, availableCores - AUTO_RESERVED_CORES));
-}
-/**
-* Effective worker-pool config from programmatic options (which win) and the
-* REACTOR_* env vars; null when disabled (numWorkers 0, the default).
-* `"auto"` sizes the pool from the machine's available cores.
-*/
-function resolveWorkerPoolOptions(input, env, availableCores = os.availableParallelism()) {
-	const requested = input?.numWorkers ?? parseWorkerCount(env.REACTOR_WORKERS) ?? 0;
-	const mode = requested === "auto" ? "auto" : "explicit";
-	const numWorkers = requested === "auto" ? autoWorkerCount(availableCores) : requested;
-	if (!Number.isInteger(numWorkers) || numWorkers < 0) throw new Error(`workerPool.numWorkers must be "auto" or a non-negative integer, got ${numWorkers}`);
-	if (numWorkers === 0) return null;
-	return {
-		numWorkers,
-		mode,
-		dbPoolSizePerWorker: input?.dbPoolSizePerWorker ?? parseNonNegativeInt(env.REACTOR_DB_POOL_SIZE_WORKER, "REACTOR_DB_POOL_SIZE_WORKER") ?? DEFAULT_DB_POOL_SIZE_PER_WORKER,
-		acquireTimeoutMs: input?.acquireTimeoutMs ?? parseNonNegativeInt(env.REACTOR_DB_ACQUIRE_TIMEOUT_MS, "REACTOR_DB_ACQUIRE_TIMEOUT_MS") ?? DEFAULT_ACQUIRE_TIMEOUT_MS
-	};
-}
-/**
-* Size of the reactor's own (host) Postgres pool. Unlike the worker pool there
-* is no "disabled" state — the host pool is the only Postgres pool in the
-* server path, backing both reactor storage and the read models that reach it
-* via `withSchema` — so 0 is rejected rather than read as "off".
-*
-* The acquire timeout is deliberately not configurable here: the host pool
-* waits indefinitely today, and making it finite converts saturation from a
-* latency problem into a thrown error on the read-model path. That is a
-* behavior change worth making separately, once the retry semantics of a
-* rejected `pool.connect()` inside the read-model coordinator are settled.
-*/
-function resolveHostPoolSize(env) {
-	const poolSize = parseNonNegativeInt(env.REACTOR_DB_POOL_SIZE_HOST, "REACTOR_DB_POOL_SIZE_HOST") ?? DEFAULT_DB_POOL_SIZE_HOST;
-	if (poolSize < 1) throw new Error("REACTOR_DB_POOL_SIZE_HOST must be at least 1; the host pool cannot be disabled");
-	return poolSize;
-}
-/**
-* DbConfig for each worker's own pool, parsed from a postgres:// URL.
-* Explicit host, database, and user are required — no pg-side defaults.
-*/
-function buildWorkerDbConfig(postgresUrl, options) {
-	let parsed;
-	try {
-		parsed = new URL(postgresUrl);
-	} catch {
-		throw new Error(`Worker pool requires a valid postgres:// URL for the reactor database, got "${postgresUrl}"`);
-	}
-	const database = decodeURIComponent(parsed.pathname.replace(/^\//, ""));
-	if (!parsed.hostname || !database) throw new Error(`Worker pool requires a postgres URL with a host and database name, got "${postgresUrl}"`);
-	if (!parsed.username) throw new Error(`Worker pool requires explicit credentials in the postgres URL (workers open their own connections), got "${postgresUrl}"`);
-	const sslmode = parsed.searchParams.get("sslmode");
-	const ssl = parsed.searchParams.get("ssl") === "true" || sslmode !== null && sslmode !== "disable";
-	return {
-		host: parsed.hostname,
-		port: parsed.port ? Number(parsed.port) : 5432,
-		database,
-		user: decodeURIComponent(parsed.username),
-		password: decodeURIComponent(parsed.password),
-		ssl,
-		applicationName: "switchboard-worker",
-		poolSize: options.dbPoolSizePerWorker,
-		connectionTimeoutMillis: options.acquireTimeoutMs
-	};
-}
-/** Specifiers of the base models switchboard always registers. */
-const BASE_MODEL_SPECIFIERS = [
-	"document-model",
-	"@powerhousedao/shared/document-drive",
-	"@powerhousedao/reactor-drive",
-	"@powerhousedao/reactor-group/document-models"
-];
-/**
-* Resolves base models and configured package identifiers to `{ filePath }`
-* sources for the reactor builder. Resolution to absolute paths happens here
-* because workers (and the builder) resolve bare specifiers from the reactor
-* package's own dependency context, which cannot see switchboard or project
-* packages. Unresolvable identifiers are skipped with a warning; the builder
-* fails the boot if a registered model ends up without an importable source.
-*/
-async function resolveWorkerModelSources(packages, logger) {
-	const sources = [];
-	for (const identifier of [...BASE_MODEL_SPECIFIERS, ...packages]) {
-		const filePath = await resolveModelModuleFile(identifier);
-		if (!filePath) {
-			logger.warn(`Worker model sources: no importable document-models entry for "${identifier}", skipping`);
-			continue;
-		}
-		sources.push({ filePath });
-	}
-	return sources;
-}
-/**
-* Absolute file path of a source's models barrel. Mirrors reactor-api's
-* import-resolver: import.meta.resolve, then the project's node_modules via
-* the package.json exports map / dist layout.
-*/
-async function resolveModelModuleFile(source) {
-	if (isFsPath(source)) return resolveFromPackageDir(source, "./document-models");
-	const specifier = BASE_MODEL_SPECIFIERS.includes(source) ? source : `${source}/document-models`;
-	try {
-		const resolved = import.meta.resolve(specifier);
-		if (resolved.startsWith("file:")) return fileURLToPath(resolved);
-	} catch {}
-	const { packageName, subpath } = splitSpecifier(specifier);
-	const packageDir = path.join(process.cwd(), "node_modules", packageName);
-	if (!existsSync(packageDir)) return null;
-	let realDir;
-	try {
-		realDir = realpathSync(packageDir);
-	} catch {
-		return null;
-	}
-	return resolveFromPackageDir(realDir, subpath);
-}
-function splitSpecifier(specifier) {
-	const parts = specifier.split("/");
-	const packageSegments = specifier.startsWith("@") ? 2 : 1;
-	const packageName = parts.slice(0, packageSegments).join("/");
-	const rest = parts.slice(packageSegments).join("/");
-	return {
-		packageName,
-		subpath: rest ? `./${rest}` : "."
-	};
-}
-/** Exports-map lookup (import condition), then conventional dist paths. */
-async function resolveFromPackageDir(packageDir, subpath) {
-	const fromManifest = await resolveViaManifest(packageDir, subpath);
-	if (fromManifest) return fromManifest;
-	const candidates = subpath === "." ? [path.join(packageDir, "dist", "index.js")] : [
-		path.join(packageDir, "dist", subpath.slice(2), "index.js"),
-		path.join(packageDir, "dist", `${subpath.slice(2)}.js`),
-		path.join(packageDir, subpath.slice(2), "index.js")
-	];
-	for (const candidate of candidates) if (existsSync(candidate)) return candidate;
-	return null;
-}
-async function resolveViaManifest(packageDir, subpath) {
-	let raw;
-	try {
-		raw = await readFile(path.join(packageDir, "package.json"), "utf8");
-	} catch {
-		return null;
-	}
-	let manifest;
-	try {
-		manifest = JSON.parse(raw);
-	} catch {
-		return null;
-	}
-	let entry;
-	const exportsField = manifest.exports;
-	if (exportsField !== null && typeof exportsField === "object" && !Array.isArray(exportsField)) {
-		const map = exportsField;
-		entry = Object.keys(map).some((key) => key.startsWith(".")) ? map[subpath] : subpath === "." ? map : void 0;
-	} else if (typeof exportsField === "string" && subpath === ".") entry = exportsField;
-	let target = pickImportTarget(entry);
-	if (!target && subpath === "." && typeof manifest.main === "string") target = manifest.main;
-	if (!target) return null;
-	const resolved = path.join(packageDir, target);
-	return existsSync(resolved) ? resolved : null;
-}
-function pickImportTarget(entry) {
-	if (typeof entry === "string") return entry;
-	if (typeof entry !== "object" || entry === null) return null;
-	const conditions = entry;
-	for (const condition of [
-		"import",
-		"node",
-		"default"
-	]) {
-		const value = conditions[condition];
-		if (typeof value === "string") return value;
-	}
-	return null;
-}
-function isFsPath(identifier) {
-	return path.isAbsolute(identifier) || identifier.startsWith("./") || identifier.startsWith("../");
-}
-function parseWorkerCount(raw) {
-	if (raw === void 0 || raw.trim() === "") return;
-	if (raw.trim().toLowerCase() === "auto") return "auto";
-	const value = Number.parseInt(raw, 10);
-	if (!Number.isInteger(value) || value < 0 || String(value) !== raw.trim()) throw new Error(`REACTOR_WORKERS must be "auto" or a non-negative integer, got "${raw}"`);
-	return value;
-}
-function parseNonNegativeInt(raw, name) {
-	if (raw === void 0 || raw.trim() === "") return;
-	const value = Number.parseInt(raw, 10);
-	if (!Number.isInteger(value) || value < 0 || String(value) !== raw.trim()) throw new Error(`${name} must be a non-negative integer, got "${raw}"`);
-	return value;
-}
-//#endregion
-//#region src/projection-worker.mts
-const DEFAULT_DB_POOL_SIZE_PROJECTION = 8;
-const ON_TOKENS = [
-	"1",
-	"true",
-	"on",
-	"yes"
-];
-const OFF_TOKENS = [
-	"0",
-	"false",
-	"off",
-	"no"
-];
-/**
-* Enabled by REACTOR_PROJECTION_WORKER (1/true/on/yes, case-insensitive) or
-* `input.enabled`, which wins when defined; null when off (the default).
-*/
-function resolveProjectionWorkerOptions(input, env) {
-	if (!(input?.enabled ?? parseOnOff(env.REACTOR_PROJECTION_WORKER) ?? false)) return null;
-	const dbPoolSize = input?.dbPoolSize ?? parseNonNegativeInt(env.REACTOR_DB_POOL_SIZE_PROJECTION, "REACTOR_DB_POOL_SIZE_PROJECTION") ?? DEFAULT_DB_POOL_SIZE_PROJECTION;
-	if (dbPoolSize < 1) throw new Error("REACTOR_DB_POOL_SIZE_PROJECTION must be at least 1; the projection worker cannot run without a pool");
-	return { dbPoolSize };
-}
-/** Same preconditions as the executor worker pool; message shape mirrors server.mts. */
-function assertProjectionWorkerSupported(args) {
-	if (args.dev) throw new Error("The projection worker (REACTOR_PROJECTION_WORKER) is not supported in dev mode: Vite-loaded document models cannot cross a worker-thread boundary");
-	if (!args.reactorDbUrl || !isPostgresUrl(args.reactorDbUrl)) throw new Error("The projection worker (REACTOR_PROJECTION_WORKER) requires a Postgres reactor database — set PH_REACTOR_DATABASE_URL or PH_SWITCHBOARD_DATABASE_URL. PGlite cannot be shared across worker threads.");
-}
-function parseOnOff(raw) {
-	if (raw === void 0 || raw.trim() === "") return;
-	const token = raw.trim().toLowerCase();
-	if (ON_TOKENS.includes(token)) return true;
-	if (OFF_TOKENS.includes(token)) return false;
-	throw new Error(`REACTOR_PROJECTION_WORKER must be one of 1, true, on, yes, 0, false, off, no, got "${raw}"`);
-}
-//#endregion
-//#region src/feature-flags.ts
-async function initFeatureFlags() {
-	const provider = new EnvVarProvider();
-	await OpenFeature.setProviderAndWait(provider);
-	return OpenFeature.getClient();
-}
-//#endregion
-//#region src/pglite-dialect.ts
-var ClosablePGliteDialect = class extends PGliteDialect {
-	#pglite;
-	constructor(pglite) {
-		super(pglite);
-		this.#pglite = pglite;
-	}
-	createDriver() {
-		const driver = super.createDriver();
-		const pglite = this.#pglite;
-		const innerDestroy = driver.destroy.bind(driver);
-		driver.destroy = async () => {
-			await innerDestroy();
-			if (!pglite.closed) await pglite.close();
-		};
-		return driver;
-	}
-};
-//#endregion
-//#region src/pglite-migration.ts
-function backupPath(dataDir, major) {
-	return `${dataDir}.backup-pg${major}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-}
-async function pathExists(p) {
-	try {
-		await promises.stat(p);
-		return true;
-	} catch {
-		return false;
-	}
-}
-function logRestoreFailure(dataDir, sql, err, logger) {
-	const errObj = err;
-	const position = typeof errObj.position === "string" ? parseInt(errObj.position, 10) : typeof errObj.position === "number" ? errObj.position : NaN;
-	logger.error(`[pglite-migration] Restore failed for ${dataDir}: code=${errObj.code ?? ""} severity=${errObj.severity ?? ""} message=${errObj.message ?? ""} sqlLength=${sql.length}`);
-	if (Number.isFinite(position) && position > 0) {
-		const zeroBased = position - 1;
-		const start = Math.max(0, zeroBased - 200);
-		const end = Math.min(sql.length, zeroBased + 200);
-		const before = sql.slice(start, zeroBased);
-		const at = sql.slice(zeroBased, zeroBased + 1);
-		const after = sql.slice(zeroBased + 1, end);
-		logger.error(`[pglite-migration] SQL context around position ${position}:\n${before}»${at}«${after}`);
-	} else logger.error(`[pglite-migration] No position info. First 2000 chars of dump:\n${sql.slice(0, 2e3)}`);
-}
-/**
-* Migrate a filesystem PGLite data directory from a legacy PG major to the
-* current one. Renames the existing dir to a timestamped backup, dumps via the
-* matching legacy `pg_dump`, restores into a fresh current-version PGLite at
-* the original path. On failure, the original dir is restored from the backup.
-*
-* No-op when the dir is missing or already at the current major.
-*/
-async function migratePgliteDir(dataDir, logger) {
-	const major = await readPgVersionFile(dataDir);
-	if (major === null) {
-		logger.info(`[pglite-migration] No PG_VERSION at ${dataDir}; skipping migration`);
-		return;
-	}
-	if (major === 17) return;
-	if (!isSupportedMajor(major)) throw new Error(`Unsupported legacy PGlite data dir: PG_VERSION=${major} for ${dataDir}`);
-	const backupDir = backupPath(dataDir, major);
-	logger.info(`[pglite-migration] Migrating ${dataDir} from PG${major} to PG17; backup: ${backupDir}`);
-	await promises.rename(dataDir, backupDir);
-	let sql;
-	try {
-		const [legacyMod, pgDump] = await Promise.all([loadPGliteModule(major), loadPgDump(major)]);
-		const LegacyPGlite = legacyMod.PGlite;
-		const pg = new LegacyPGlite(backupDir);
-		try {
-			await pg.waitReady;
-			sql = await (await pgDump({ pg })).text();
-		} finally {
-			await pg.close();
-		}
-	} catch (err) {
-		await rollback(dataDir, backupDir, err, logger);
-		throw err;
-	}
-	try {
-		const CurrentPGlite = (await loadPGliteModule(17)).PGlite;
-		const pg = new CurrentPGlite(dataDir, { relaxedDurability: false });
-		try {
-			await pg.waitReady;
-			try {
-				await pg.exec("SET standard_conforming_strings = off;");
-			} catch (gucErr) {
-				logger.warn(`[pglite-migration] Could not force standard_conforming_strings=off: ${String(gucErr)}`);
-			}
-			try {
-				await pg.exec(sql);
-			} catch (execErr) {
-				logRestoreFailure(dataDir, sql, execErr, logger);
-				throw execErr;
-			}
-		} finally {
-			await pg.close();
-		}
-	} catch (err) {
-		await rollback(dataDir, backupDir, err, logger);
-		throw err;
-	}
-	logger.info(`[pglite-migration] Migration of ${dataDir} complete. Backup retained at ${backupDir}; remove it manually once you have verified the upgrade.`);
-}
-async function rollback(dataDir, backupDir, originalError, logger) {
-	try {
-		if (await pathExists(dataDir)) await promises.rm(dataDir, {
-			recursive: true,
-			force: true
-		});
-		if (await pathExists(backupDir)) await promises.rename(backupDir, dataDir);
-	} catch (rollbackErr) {
-		logger.error(`[pglite-migration] Migration AND rollback failed for ${dataDir}. Original error: ${String(originalError)}; rollback error: ${String(rollbackErr)}; backup may still exist at ${backupDir}.`);
-		return;
-	}
-	logger.error(`[pglite-migration] Migration failed for ${dataDir}; rolled back from ${backupDir}. Original error: ${String(originalError)}`);
-}
-//#endregion
-//#region src/reactor-feature-flags.mts
-/**
-* Enforcement flags from the REACTOR_* env vars. Each flag requires the ones
-* before it; the reactor rejects an inconsistent set rather than enforcing less
-* than the operator asked for, so this reports what was asked without
-* correcting it.
-*/
-function resolveReactorFeatureFlags(env) {
-	const flags = {
-		documentDecisions: env.REACTOR_DOCUMENT_DECISIONS === "true",
-		authEnforcement: env.REACTOR_AUTH_ENFORCEMENT === "true",
-		authGroups: env.REACTOR_AUTH_GROUPS === "true",
-		authConditions: env.REACTOR_AUTH_CONDITIONS === "true"
-	};
-	return {
-		flags,
-		enabled: Object.entries(flags).filter(([, isEnabled]) => isEnabled).map(([name]) => name)
-	};
-}
-//#endregion
-//#region src/renown.ts
-const logger = childLogger(["switchboard", "renown"]);
-/**
-* Initialize Renown for the Switchboard instance.
-* This allows Switchboard to authenticate with remote services
-* using the same identity established during `ph login`.
-*/
-async function initRenown(options = {}) {
-	const { keypairPath, requireExisting = false, baseUrl = DEFAULT_RENOWN_URL } = options;
-	const keyStorage = new NodeKeyStorage(keypairPath, { logger });
-	const existingKeyPair = await keyStorage.loadKeyPair();
-	if (!existingKeyPair && requireExisting) throw new Error("No existing keypair found and requireExisting is true. Run \"ph login\" to create one.");
-	if (!existingKeyPair) logger.info("No existing keypair found. A new one will be generated.");
-	const renownCrypto = await new RenownCryptoBuilder().withKeyPairStorage(keyStorage).build();
-	const renown = await new RenownBuilder("switchboard", {}).withCrypto(renownCrypto).withBaseUrl(baseUrl).build();
-	logger.info("Switchboard identity initialized: @did", renownCrypto.did);
-	return renown;
-}
-/**
-* Get the signer config for the given renown instance.
-*
-* @param renown - The renown instance
-* @param requireSignature - If true, unsigned actions are rejected
-*/
-function getRenownSignerConfig(renown, requireSignature) {
-	return {
-		signer: renown.signer,
-		verifier: createSignatureVerifier(requireSignature)
-	};
-}
-//#endregion
-//#region src/server.mts
-const defaultLogger = childLogger(["switchboard"]);
-const LogLevel = process.env.LOG_LEVEL || "info";
-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 = (() => {
-	const raw = process.env.PGLITE_FLUSH_INTERVAL_MS;
-	if (raw === void 0) return 100;
-	const parsed = Number(raw);
-	return Number.isFinite(parsed) && parsed >= 0 ? parsed : 100;
-})();
-const PGLITE_IN_MEMORY = process.env.PH_PGLITE_IN_MEMORY === "1";
-/**
-* Attempt to bind a throwaway TCP server to the given port. Resolves true if
-* the port is free, false if the OS reports it in use. Any other error is
-* surfaced so we don't silently mask real issues (permissions, bad host, …).
-*/
-function isPortAvailable(port) {
-	return new Promise((resolve, reject) => {
-		const tester = net.createServer();
-		tester.once("error", (err) => {
-			if (err.code === "EADDRINUSE" || err.code === "EACCES") resolve(false);
-			else reject(err);
-		});
-		tester.once("listening", () => {
-			tester.close(() => resolve(true));
-		});
-		tester.listen({
-			port,
-			host: "::"
-		});
-	});
-}
-/** The powerhouse.config.json this run reads, defaulting to the cwd copy. */
-function resolveConfigPath(configFile) {
-	return configFile ?? path$1.join(process.cwd(), "powerhouse.config.json");
-}
-async function resolveServerPort(requested, strictPort, logger) {
-	if (strictPort) return requested;
-	for (let i = 0; i < PORT_FALLBACK_ATTEMPTS; i++) {
-		const candidate = requested + i;
-		if (await isPortAvailable(candidate)) {
-			if (candidate !== requested) logger.info(`Port ${requested} is in use. Falling back to port ${candidate}.`);
-			return candidate;
-		}
-	}
-	return requested;
-}
-async function createReactorKysely(opts) {
-	const { reactorDbUrl, reactorPgliteDir, reactorPgliteMajor, inMemory, flushIntervalMs, hostPoolSize, logger } = opts;
-	if (reactorDbUrl && isPostgresUrl(reactorDbUrl)) {
-		const connectionString = reactorDbUrl.includes("?") ? reactorDbUrl : `${reactorDbUrl}?sslmode=disable`;
-		const poolSize = hostPoolSize();
-		const pool = new Pool({
-			connectionString,
-			max: poolSize
-		});
-		const poolInstrumentation = instrumentPgPool(pool, "reactor-host");
-		logger.info(`Using PostgreSQL for reactor storage (host pool max ${poolSize})`);
-		return {
-			kysely: new Kysely({ dialect: new PostgresDialect({ pool }) }),
-			poolInstrumentation
-		};
-	}
-	if (!reactorPgliteDir || reactorPgliteMajor === null) throw new Error("Reactor PGLite directory not resolved");
-	const { PGlite } = await loadPGliteModule(reactorPgliteMajor);
-	const pglite = inMemory ? new PGlite() : new PGlite({ fs: new AtomicNodeFs(reactorPgliteDir, {
-		logger,
-		flushIntervalMs
-	}) });
-	logger.info(inMemory ? `Using in-memory PGlite (PG${reactorPgliteMajor}) for reactor storage [PH_PGLITE_IN_MEMORY=1]` : `Using PGlite (PG${reactorPgliteMajor}) for reactor storage at ${reactorPgliteDir}`);
-	return {
-		kysely: new Kysely({ dialect: new ClosablePGliteDialect(pglite) }),
-		poolInstrumentation: void 0
-	};
-}
-/** Derive the remote attachment service config for switchboard's own `/attachments/*` API. */
-function deriveAttachmentServiceConfig(options, serverPort, renown) {
-	const protocol = options.https ? "https" : "http";
-	return {
-		remoteUrl: options.attachmentServiceUrl ?? process.env.PH_SWITCHBOARD_PUBLIC_URL ?? `${protocol}://localhost:${serverPort}`,
-		jwtHandler: renown ? async (url) => renown.user ? renown.getBearerToken({
-			expiresIn: 10,
-			aud: url
-		}) : void 0 : void 0
-	};
-}
-async function initServer(serverPort, options, renown, renownConfig) {
-	const { dev, packages = [], remoteDrives = [], logger = defaultLogger } = options;
-	logger.level = LogLevel;
-	const dbPath = options.dbPath ?? process.env.DATABASE_URL ?? process.env.PH_SWITCHBOARD_DATABASE_URL;
-	const readModelPath = dbPath || ".ph/read-storage";
-	const reactorDbUrl = options.dbPath ?? process.env.PH_REACTOR_DATABASE_URL ?? process.env.PH_SWITCHBOARD_DATABASE_URL;
-	const reactorPath = reactorDbUrl || "./.ph/reactor-storage";
-	const reactorPgliteDir = options.reactor ? null : !reactorDbUrl || !isPostgresUrl(reactorDbUrl) ? reactorPath : null;
-	const readModelPgliteDir = !dbPath || !isPostgresUrl(dbPath) ? readModelPath : null;
-	const pgliteDirs = [reactorPgliteDir, readModelPgliteDir].filter((d) => d !== null);
-	const detectedMajors = /* @__PURE__ */ new Map();
-	for (const dir of pgliteDirs) {
-		const lockPath = path$1.join(dir, "postmaster.pid");
-		try {
-			await promises.unlink(lockPath);
-			logger.warn(`Removed stale PGLite lockfile ${lockPath}`);
-		} catch (err) {
-			if (err.code !== "ENOENT") throw err;
-		}
-	}
-	if (options.forcePgVersion !== void 0 && pgliteDirs.length > 0) {
-		if (options.migratePglite) logger.warn("PH_FORCE_PG_VERSION is set; ignoring --migrate-pglite/PH_MIGRATE_PGLITE because the data dirs will be wiped.");
-		logger.warn(`PH_FORCE_PG_VERSION=${options.forcePgVersion} set; wiping PGLite data dirs and re-initializing at PG${options.forcePgVersion}.`);
-		for (const dir of pgliteDirs) {
-			await promises.rm(dir, {
-				recursive: true,
-				force: true
-			});
-			logger.info(`Wiped PGLite data dir ${dir}`);
-		}
-	} else if (options.forcePgVersion === void 0) {
-		for (const dir of pgliteDirs) {
-			const major = await readPgVersionFile(dir);
-			if (major !== null) detectedMajors.set(dir, major);
-		}
-		if (options.migratePglite) for (const [dir, major] of detectedMajors) {
-			if (major === 17) continue;
-			await migratePgliteDir(dir, logger);
-			const after = await readPgVersionFile(dir);
-			if (after !== null) detectedMajors.set(dir, after);
-		}
-		else for (const [dir, major] of detectedMajors) {
-			if (major === 17) continue;
-			logger.warn(`PGLite data dir at ${dir} was created with PG${major} but Switchboard ships PG17. Running on legacy PGLite. Re-start with --migrate-pglite (or PH_MIGRATE_PGLITE=true) to upgrade.`);
-		}
-	}
-	function resolvePgliteMajorForDir(dir) {
-		if (options.forcePgVersion !== void 0) return options.forcePgVersion;
-		const detected = detectedMajors.get(dir);
-		if (detected === void 0) return 17;
-		if (!isSupportedMajor(detected)) throw new Error(`Unsupported PGLite data dir at ${dir}: PG_VERSION=${detected}`);
-		return detected;
-	}
-	const reactorPgliteMajor = reactorPgliteDir ? resolvePgliteMajorForDir(reactorPgliteDir) : null;
-	const readModelPgliteMajor = readModelPgliteDir ? resolvePgliteMajorForDir(readModelPgliteDir) : null;
-	let workerPool = resolveWorkerPoolOptions(options.workerPool, process.env);
-	if (workerPool && options.reactor) {
-		logger.warn("Worker pool configuration ignored: the caller-provided reactor owns its own executor");
-		workerPool = null;
-	}
-	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");
-		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.");
-	}
-	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");
-		projectionWorker = null;
-	}
-	if (projectionWorker) assertProjectionWorkerSupported({
-		dev: dev === true,
-		reactorDbUrl
-	});
-	const apiRef = { current: void 0 };
-	let driveNodeView;
-	const configPath = resolveConfigPath(options.configFile);
-	const config = getConfig(configPath);
-	const registryUrl = options.registryUrl ?? process.env.PH_REGISTRY_URL ?? config.packageRegistryUrl;
-	const registryPackages = process.env.PH_REGISTRY_PACKAGES;
-	const dynamicModelLoading = options.dynamicModelLoading ?? process.env.DYNAMIC_MODEL_LOADING === "true";
-	let httpLoader;
-	if (registryUrl) {
-		register(httpsHooksPath, import.meta.url);
-		httpLoader = new HttpPackageLoader({ registryUrl });
-		registryPackages?.split(",").forEach((p) => {
-			const name = p.trim();
-			if (!packages.includes(name)) packages.push(name);
-		});
-	}
-	const reactorLogger = logger.child(["reactor"]);
-	let projectionWorkerFatalFired = false;
-	const onProjectionWorkerFatal = (shardId, reason) => {
-		if (projectionWorkerFatalFired) return;
-		projectionWorkerFatalFired = true;
-		reactorLogger.error(`Projection worker ${shardId} died; shutting down so the supervisor restarts a healthy process`, reason);
-		process.kill(process.pid, "SIGTERM");
-	};
-	let ownedReactorModule;
-	const initializeClient = async (documentModels, { attachmentReferenceWriter, upgradeManifests }) => {
-		if (options.reactor) {
-			const attachmentReferenceProjection = await registerAttachmentReferenceReadModelOnModule(options.reactor, attachmentReferenceWriter);
-			if (options.reactor.reactorModule) {
-				new ReactorInstrumentation(options.reactor.reactorModule).start();
-				reactorLogger.info("Reactor metrics instrumentation started (using caller-provided reactor)");
-			}
-			return {
-				module: options.reactor,
-				attachmentReferenceProjection
-			};
-		}
-		const { kysely: baseKysely, poolInstrumentation } = await createReactorKysely({
-			reactorDbUrl,
-			reactorPgliteDir,
-			reactorPgliteMajor,
-			inMemory: PGLITE_IN_MEMORY,
-			flushIntervalMs: PGLITE_FLUSH_INTERVAL_MS,
-			hostPoolSize: () => resolveHostPoolSize(process.env),
-			logger
-		});
-		const maxSkipThreshold = parseInt(process.env.MAX_SKIP_THRESHOLD ?? "", 10);
-		const hasSkipThreshold = !isNaN(maxSkipThreshold) && maxSkipThreshold > 0;
-		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" });
-		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) : [];
-		applySwitchboardReactorDefaults(reactorBuilder, clientBuilder, {
-			documentModels: [...documentModels, ...vetraDocumentModels],
-			upgradeManifests,
-			executorConfig: hasSkipThreshold || enabledFeatureFlags.length > 0 ? {
-				...hasSkipThreshold ? { maxSkipThreshold } : {},
-				...enabledFeatureFlags.length > 0 ? { featureFlags: reactorFeatureFlags } : {}
-			} : void 0,
-			documentModelLoader: httpLoader && dynamicModelLoading ? httpLoader.documentModelLoader : void 0,
-			logger: reactorLogger,
-			signer: renown ? getRenownSignerConfig(renown, options.identity?.requireSignatures) : void 0
-		});
-		if (workerPool) {
-			if (!reactorDbUrl) throw new Error("unreachable: worker pool enabled without a reactor database URL");
-			const workerSources = await resolveWorkerModelSources(packages, reactorLogger);
-			reactorBuilder.withDocumentModelSources(workerSources).withWorkerPool({
-				numWorkers: workerPool.numWorkers,
-				db: buildWorkerDbConfig(reactorDbUrl, workerPool)
-			});
-			reactorLogger.info(`Executor worker pool enabled: ${workerPool.numWorkers} worker threads${workerPool.mode === "auto" ? " (auto-sized from cores)" : ""}`);
-		}
-		reactorBuilder.withReadModelFactory(async ({ operationIndex, writeCache, processorManagerConsistencyTracker }) => {
-			const nodeProcessor = new NodeProcessor(baseKysely, REACTOR_SCHEMA, operationIndex, writeCache, processorManagerConsistencyTracker);
-			await nodeProcessor.init();
-			return nodeProcessor;
-		});
-		registerAttachmentReferenceReadModel(reactorBuilder, {
-			baseKysely,
-			attachmentReferenceWriter
-		});
-		if (projectionWorker) {
-			if (!reactorDbUrl) throw new Error("unreachable: projection worker enabled without a reactor database URL");
-			if (!workerPool) {
-				const workerSources = await resolveWorkerModelSources(packages, reactorLogger);
-				reactorBuilder.withDocumentModelSources(workerSources);
-			}
-			const db = {
-				...buildWorkerDbConfig(reactorDbUrl, {
-					dbPoolSizePerWorker: projectionWorker.dbPoolSize,
-					acquireTimeoutMs: workerPool?.acquireTimeoutMs ?? 5e3
-				}),
-				applicationName: "switchboard-projection"
-			};
-			reactorBuilder.withReadModelCoordinatorFactory(createHybridProjectionCoordinatorFactory({
-				shardCount: 1,
-				poolSize: projectionWorker.dbPoolSize,
-				db,
-				onFatal: onProjectionWorkerFatal
-			}));
-			reactorLogger.info(`Projection worker enabled: 1 worker thread, pool size ${projectionWorker.dbPoolSize}`);
-		}
-		reactorBuilder.withShutdownHook(async () => {
-			if (apiRef.current) await apiRef.current.dispose();
-		});
-		const module = await clientBuilder.buildModule();
-		if (module.reactorModule) {
-			new ReactorInstrumentation(module.reactorModule).start();
-			reactorLogger.info("Reactor metrics instrumentation started");
-		}
-		driveNodeView = new DriveNodeView(baseKysely.withSchema(REACTOR_SCHEMA));
-		const reactorDriveClient = new ReactorDriveClient({
-			reactor: module.client,
-			readModel: driveNodeView
-		});
-		ownedReactorModule = module;
-		return {
-			module,
-			reactorDriveClient,
-			attachmentReferenceProjection: { status: "available" }
-		};
-	};
-	const abortBoot = async (api) => {
-		const owned = ownedReactorModule;
-		if (owned) try {
-			await owned.reactor.kill().completed;
-		} catch (error) {
-			logger.error("Aborting boot: reactor shutdown failed: @error", error);
-		}
-		try {
-			await api.dispose();
-		} catch (error) {
-			logger.error("Aborting boot: api dispose failed: @error", error);
-		}
-		if (owned?.reactorModule) try {
-			await owned.reactorModule.database.destroy();
-		} catch (error) {
-			logger.error("Aborting boot: database destroy failed: @error", error);
-		}
-	};
-	let localCredentialCheck;
-	const verifyCredential = renownConfig.source === "self" ? (params) => localCredentialCheck ? localCredentialCheck(params) : Promise.reject(/* @__PURE__ */ new Error("The local renown read model is not bound yet")) : void 0;
-	let defaultDriveUrl = void 0;
-	const basePath = process.cwd();
-	let vite;
-	let viteLoader;
-	if (dev) {
-		const { VitePackageLoader, createViteLogger, startViteServer } = await import("@powerhousedao/reactor-api/vite");
-		vite = await startViteServer(process.cwd(), createViteLogger(logger));
-		viteLoader = VitePackageLoader.build(vite);
-	}
-	const vetraProcessorFactory = dev ? (await import("@powerhousedao/vetra/processors")).processorFactory : void 0;
-	if (!options.disableLocalPackages) packages.push(basePath);
-	const packageLoaders = [];
-	if (viteLoader) packageLoaders.push(viteLoader);
-	else packageLoaders.push(new ImportPackageLoader());
-	if (httpLoader) {
-		packageLoaders.push(httpLoader);
-		registryPackages?.split(",").forEach((p) => {
-			const name = p.trim();
-			if (!packages.includes(name)) packages.push(name);
-		});
-	}
-	const apiLogger = logger.child(["reactor-api"]);
-	let pgliteFactory;
-	if (readModelPgliteDir && readModelPgliteMajor !== null) {
-		const { PGlite: ReadModelPGlite } = await loadPGliteModule(readModelPgliteMajor);
-		pgliteFactory = PGLITE_IN_MEMORY ? () => new ReadModelPGlite({ parsers: PGLITE_UTC_PARSERS }) : (connectionString) => new ReadModelPGlite({
-			fs: new AtomicNodeFs(connectionString ?? readModelPgliteDir, {
-				logger,
-				flushIntervalMs: PGLITE_FLUSH_INTERVAL_MS
-			}),
-			parsers: PGLITE_UTC_PARSERS
-		});
-	}
-	const api = await initializeAndStartAPI(initializeClient, {
-		port: serverPort,
-		dbPath: readModelPath,
-		pgliteFactory,
-		https: options.https,
-		packageLoaders: packageLoaders.length > 0 ? packageLoaders : void 0,
-		packages,
-		processorConfig: options.processorConfig,
-		processors: vetraProcessorFactory ? { "@powerhousedao/vetra": [vetraProcessorFactory] } : {},
-		configFile: configPath,
-		mcp: options.mcp ?? true,
-		logger: apiLogger,
-		enableDocumentModelSubgraphs: options.enableDocumentModelSubgraphs,
-		renown: renownConfig,
-		verifyCredential
-	}, "switchboard");
-	apiRef.current = api;
-	if (renownConfig.source === "self") {
-		const { graphqlManager: manager } = api;
-		if (!manager.hasSubgraphHandler(RENOWN_READ_MODEL_SUBGRAPH)) {
-			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) });
-		logger.info("Renown credentials will be verified against this switchboard's own renown read model");
-	}
-	registerAttachmentRoutes(api);
-	const attachmentService = createRemoteAttachmentService(deriveAttachmentServiceConfig(options, serverPort, renown));
-	if (process.env.SENTRY_DSN) api.httpAdapter.setupSentryErrorHandler(Sentry);
-	const { client, graphqlManager, documentModelRegistry } = api;
-	const lateSubgraphs = [];
-	if (httpLoader) {
-		const packageManagementService = new PackageManagementService({
-			defaultRegistryUrl: registryUrl,
-			httpLoader,
-			documentModelRegistry,
-			packageManager: api.packageManager
-		});
-		packageManagementService.setOnModelsChanged(() => {
-			graphqlManager.regenerateDocumentModelSubgraphs().catch((error) => {
-				logger.error("Failed to regenerate document model subgraphs: @error", error);
-			});
-		});
-		const packagesSubgraph = new PackagesSubgraph({
-			relationalDb: void 0,
-			analyticsStore: void 0,
-			reactorClient: client,
-			graphqlManager,
-			syncManager: api.syncManager,
-			path: graphqlManager.getBasePath(),
-			authorizationService: graphqlManager.getAuthorizationService(),
-			packageManagementService,
-			http: graphqlManager.scopeForPackage("@powerhousedao/switchboard")
-		});
-		lateSubgraphs.push(graphqlManager.registerSubgraphInstance(packagesSubgraph, "graphql", false).catch((error) => {
-			logger.error("Failed to register packages subgraph: @error", error);
-		}));
-	}
-	if (driveNodeView) {
-		graphqlManager.setAdditionalContextFields({ readModel: driveNodeView });
-		const reactorDriveSubgraph = {
-			name: "reactor-drive",
-			path: graphqlManager.getBasePath(),
-			resolvers: createReactorDriveResolvers(),
-			typeDefs: reactorDriveSubgraphTypeDefs,
-			reactorClient: client,
-			relationalDb: void 0
-		};
-		lateSubgraphs.push(graphqlManager.registerSubgraphInstance(reactorDriveSubgraph, "graphql", false).catch((error) => {
-			logger.error("Failed to register reactor-drive subgraph: @error", error);
-		}));
-	}
-	(async () => {
-		await Promise.all(lateSubgraphs);
-		try {
-			await graphqlManager.updateRouter(true);
-		} catch (error) {
-			logger.error("Final router update before readiness failed: @error", error);
-		}
-		api.readiness.markReady();
-	})();
-	if (options.drive) {
-		if (!renown) throw new Error("Cannot create default drive without Renown identity");
-		if ((options.drive.documentType ?? "powerhouse/document-drive") === "powerhouse/reactor-drive") defaultDriveUrl = await addDefaultReactorDrive(client, options.drive, serverPort);
-		else defaultDriveUrl = await addDefaultDrive(client, options.drive, serverPort);
-	}
-	if (vite) api.httpAdapter.mountRawMiddleware(vite.middlewares);
-	if (remoteDrives.length > 0) for (const remoteDriveUrl of remoteDrives) {
-		let driveId;
-		try {
-			const { syncManager } = api;
-			const parsed = parseDriveUrl(remoteDriveUrl);
-			driveId = parsed.driveId;
-			const remoteName = `remote-drive-${driveId}-${crypto.randomUUID()}`;
-			await syncManager.add(remoteName, DriveCollectionId.forDrive(driveId), {
-				type: "gql",
-				parameters: { url: parsed.graphqlEndpoint }
-			});
-			logger.debug("Remote drive @remoteDriveUrl synced", remoteDriveUrl);
-		} catch (error) {
-			if (error instanceof Error && error.message.includes("already exists")) {
-				logger.debug("Remote drive already added: @remoteDriveUrl", remoteDriveUrl);
-				driveId = remoteDriveUrl.split("/").pop();
-			} else logger.error("Failed to connect to remote drive @remoteDriveUrl: @error", remoteDriveUrl, error);
-		} finally {
-			if (!defaultDriveUrl && driveId) defaultDriveUrl = `${options.https ? "https" : "http"}://localhost:${serverPort}/d/${driveId}`;
-		}
-	}
-	return {
-		defaultDriveUrl,
-		api,
-		reactor: client,
-		attachmentService,
-		attachmentReferenceProjection: api.attachmentReferenceProjection,
-		renown,
-		port: serverPort,
-		shutdown: () => api.dispose()
-	};
-}
-/**
-* Boot the switchboard HTTP/GraphQL/MCP stack on top of a reactor.
-*
-* If `options.reactor` is provided, the switchboard reuses it instead of
-* building its own — the caller then owns the reactor's lifecycle and is
-* responsible for invoking `SwitchboardReactor.shutdown()` from their own
-* teardown / SIGINT path. The switchboard will not reach into the caller's
-* reactor; killing the reactor alone leaves the api/GraphQL/MCP resources
-* dangling until the process exits.
-*
-* When `options.reactor` is omitted, the switchboard builds and owns the
-* reactor. `shutdown()` on the returned handle only drains the api (HTTP
-* server, GraphQL, MCP, attachments); the reactor itself is torn down by
-* its own signal handlers (`withSignalHandlers`), which call `kill()` and
-* trigger the `withShutdownHook` chain that disposes the api. Programmatic
-* full teardown isn't currently exposed — wire it via SIGINT/SIGTERM.
-*/
-const startSwitchboard = async (options = {}) => {
-	const requestedPort = options.port ?? DEFAULT_PORT;
-	const logger = options.logger ?? defaultLogger;
-	const serverPort = await resolveServerPort(requestedPort, options.strictPort ?? false, logger);
-	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);
-	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
-	}, null, 2));
-	let renown = null;
-	try {
-		renown = await initRenown(options.identity);
-	} catch (e) {
-		logger.warn("Failed to initialize ConnectCrypto: @error", e);
-		if (options.identity.requireExisting) throw new Error("Identity required but failed to initialize. Run \"ph login\" first.", { cause: e });
-	}
-	try {
-		return await initServer(serverPort, options, renown, renownConfig);
-	} catch (e) {
-		Sentry.captureException(e);
-		logger.error("App crashed: @error", e);
-		throw e;
-	}
-};
-if (import.meta.main) await startSwitchboard();
-//#endregion
-export { parseForcePgVersion as a, applySwitchboardReactorDefaults as i, isPortAvailable as n, startSwitchboard as r, deriveAttachmentServiceConfig as t };
-
-//# sourceMappingURL=server-CiKkVE6g.mjs.map
-//# debugId=e2c62b7b-68fd-59c2-ab82-7d035e11698b