@powerhousedao/switchboard 6.2.2-dev.1 → 6.2.2-dev.11

package/.tsbuild/tsdown.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("tsdown").UserConfig;
+export default _default;
+//# sourceMappingURL=tsdown.config.d.ts.map

package/.tsbuild/tsdown.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsdown.config.d.ts","sourceRoot":"","sources":["../tsdown.config.ts"],"names":[],"mappings":";AAEA,wBAaG"}

package/.tsbuild/vitest.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("vite").UserConfig;
+export default _default;
+//# sourceMappingURL=vitest.config.d.ts.map

package/.tsbuild/vitest.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.config.d.ts","sourceRoot":"","sources":["../vitest.config.ts"],"names":[],"mappings":";AAEA,wBAQG"}

package/CHANGELOG.md

@@ -1,3 +1,62 @@
+## 6.2.2-dev.11 (2026-07-22)
+
+### 🚀 Features
+
+- **connect:** dynamic packages can contribute to the PWA configuration ([da867e21d](https://github.com/powerhouse-inc/powerhouse/commit/da867e21d))
+
+### ❤️ Thank You
+
+- Yasiel Cabrera @YasielCabrera
+
+## 6.2.2-dev.10 (2026-07-21)
+
+This was a version bump only for @powerhousedao/switchboard to align it with other projects, there were no code changes.
+
+## 6.2.2-dev.9 (2026-07-20)
+
+This was a version bump only for @powerhousedao/switchboard to align it with other projects, there were no code changes.
+
+## 6.2.2-dev.8 (2026-07-19)
+
+This was a version bump only for @powerhousedao/switchboard to align it with other projects, there were no code changes.
+
+## 6.2.2-dev.7 (2026-07-18)
+
+This was a version bump only for @powerhousedao/switchboard to align it with other projects, there were no code changes.
+
+## 6.2.2-dev.6 (2026-07-17)
+
+This was a version bump only for @powerhousedao/switchboard to align it with other projects, there were no code changes.
+
+## 6.2.2-dev.5 (2026-07-17)
+
+This was a version bump only for @powerhousedao/switchboard to align it with other projects, there were no code changes.
+
+## 6.2.2-dev.4 (2026-07-17)
+
+### 🚀 Features
+
+- **switchboard, reactor:** worker config integration on switchboard, including auto mode ([38c3b3de6](https://github.com/powerhouse-inc/powerhouse/commit/38c3b3de6))
+- **vetra-e2e:** full e2e spec for shared worker ([ed1b3fbd2](https://github.com/powerhouse-inc/powerhouse/commit/ed1b3fbd2))
+
+### ❤️ Thank You
+
+- Benjamin Jordan
+
+## 6.2.2-dev.3 (2026-07-16)
+
+### 🚀 Features
+
+- **registry:** postgres-backed auth plugin with persistent accounts and package ownership ([0c1ffbeb4](https://github.com/powerhouse-inc/powerhouse/commit/0c1ffbeb4))
+
+### ❤️ Thank You
+
+- Guillermo Puente @gpuente
+
+## 6.2.2-dev.2 (2026-07-16)
+
+This was a version bump only for @powerhousedao/switchboard to align it with other projects, there were no code changes.
+
 ## 6.2.2-dev.1 (2026-07-15)
 
 This was a version bump only for @powerhousedao/switchboard to align it with other projects, there were no code changes.

package/README.md

@@ -112,6 +112,50 @@ pnpm add -g @powerhousedao/switchboard
 
 See [Observability](#observability) below for Sentry and OpenTelemetry variables.
 
+### Executor Worker Pool
+
+By default the reactor executes jobs on a single in-process executor. Setting
+`REACTOR_WORKERS` to a value greater than 0 moves job execution into N
+`node:worker_threads` workers; jobs route to a worker stickily by document id,
+and each worker opens its own Postgres pool.
+
+| Variable                        | Description                                                    | Default |
+| ------------------------------- | -------------------------------------------------------------- | ------- |
+| `REACTOR_WORKERS`               | Executor worker threads: a number (0 = in-process) or `auto`   | `0`     |
+| `REACTOR_DB_POOL_SIZE_WORKER`   | Per-worker Postgres pool size                                  | `2`     |
+| `REACTOR_DB_ACQUIRE_TIMEOUT_MS` | Pool connection acquire timeout (ms)                           | `5000`  |
+
+`REACTOR_WORKERS=auto` lets the runtime size the pool from the machine's
+available cores (`os.availableParallelism()`, which respects container CPU
+limits): `max(1, min(8, cores - 2))`. Two cores stay reserved for the host
+event loop and the cap keeps the worker connection budget bounded; `auto`
+always enables worker mode with at least one worker.
+
+Requirements when `REACTOR_WORKERS > 0`:
+
+- **Postgres only.** The reactor database must be a `postgres://` URL with
+  explicit credentials (`PH_REACTOR_DATABASE_URL` or
+  `PH_SWITCHBOARD_DATABASE_URL`). PGlite cannot be shared across threads,
+  so switchboard refuses to start on local PGlite storage.
+- **Built packages only.** Worker threads import document models by file path,
+  so every configured package needs a built `document-models` entry. `dev`
+  mode (Vite-loaded models, e.g. `ph vetra`) is rejected.
+- **Connection budget.** Total Postgres connections are roughly
+  `host pool + REACTOR_WORKERS x REACTOR_DB_POOL_SIZE_WORKER`; keep this
+  under the server's `max_connections`.
+
+Example:
+
+```bash
+PH_SWITCHBOARD_DATABASE_URL=postgres://reactor:reactor@localhost:5433/switchboard \
+REACTOR_WORKERS=4 \
+ph switchboard
+```
+
+The same settings are available programmatically via
+`startSwitchboard({ workerPool: { numWorkers, dbPoolSizePerWorker, acquireTimeoutMs } })`,
+which takes precedence over the environment variables.
+
 ### Authentication Configuration
 
 ```typescript

package/dist/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 !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]="5a65c537-fadb-5705-95c0-4cec44d7b4d2")}catch(e){}}();
-import { a as parseForcePgVersion, r as startSwitchboard } from "./server-DgBz3TJW.mjs";
+import { a as parseForcePgVersion, r as startSwitchboard } from "./server-Cgud_ONM.mjs";
 import "./utils-Baw7rThP.mjs";
 import { metrics } from "@opentelemetry/api";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";

package/dist/{server-DgBz3TJW.mjs → server-Cgud_ONM.mjs}

@@ -1,12 +1,12 @@
 
-!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]="8a8055ab-2ceb-59fe-9007-f1d1fde8a019")}catch(e){}}();
+!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]="5eb0a978-689a-51dd-978a-cd3d7fe5df4b")}catch(e){}}();
 import { n as addDefaultReactorDrive, r as isPostgresUrl, t as addDefaultDrive } from "./utils-Baw7rThP.mjs";
 import { register } from "node:module";
 import * as Sentry from "@sentry/node";
 import { childLogger, documentModelDocumentModelModule, setLogLevel } from "document-model";
 import dotenv from "dotenv";
 import { getConfig } from "@powerhousedao/config/node";
-import { promises } from "node:fs";
+import { existsSync, promises, realpathSync } from "node:fs";
 import path from "node:path";
 import { ReactorInstrumentation } from "@powerhousedao/opentelemetry-instrumentation-reactor";
 import { AtomicNodeFs } from "@powerhousedao/pglite-fs";
@@ -21,6 +21,9 @@ import path$1 from "path";
 import { Pool } from "pg";
 import { Readable } from "node:stream";
 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";
@@ -392,14 +395,18 @@ function registerAttachmentRoutes(api) {
 * Does NOT touch kysely or read models — callers wire those themselves
 * (see `withKysely` / `withReadModelFactory` on the reactor builder).
 */
-function applySwitchboardReactorDefaults(reactorBuilder, clientBuilder, options = {}) {
-	const baseModels = options.includeBaseModels !== false ? [
+/** The models switchboard always registers alongside package models. */
+function switchboardBaseDocumentModels() {
+	return [
 		documentModelDocumentModelModule,
 		driveDocumentModelModule,
 		reactorDriveDocumentModelModule
-	] : [];
+	];
+}
+function applySwitchboardReactorDefaults(reactorBuilder, clientBuilder, options = {}) {
+	const baseModels = options.includeBaseModels !== false ? switchboardBaseDocumentModels() : [];
 	const extra = options.documentModels ?? [];
-	if (baseModels.length || extra.length) reactorBuilder.withDocumentModels(getUniqueDocumentModels(baseModels, extra));
+	if (baseModels.length || extra.length) reactorBuilder.withDocumentModelSources(getUniqueDocumentModels(baseModels, extra));
 	const scheme = options.channelScheme === void 0 ? ChannelScheme.SWITCHBOARD : options.channelScheme;
 	if (scheme !== false) reactorBuilder.withChannelScheme(scheme);
 	if (options.signalHandlers !== false) reactorBuilder.withSignalHandlers();
@@ -409,6 +416,188 @@ function applySwitchboardReactorDefaults(reactorBuilder, clientBuilder, options
 	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 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
+	};
+}
+/**
+* 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"
+];
+/**
+* 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/feature-flags.ts
 async function initFeatureFlags() {
 	const provider = new EnvVarProvider();
@@ -697,6 +886,15 @@ async function initServer(serverPort, options, renown) {
 	}
 	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.");
+	}
 	const apiRef = { current: void 0 };
 	let driveNodeView;
 	const config = getConfig(options.configFile ?? path$1.join(process.cwd(), "powerhouse.config.json"));
@@ -732,6 +930,7 @@ async function initServer(serverPort, options, renown) {
 		const maxSkipThreshold = parseInt(process.env.MAX_SKIP_THRESHOLD ?? "", 10);
 		const hasSkipThreshold = !isNaN(maxSkipThreshold) && maxSkipThreshold > 0;
 		if (hasSkipThreshold) logger.info(`Reactor maxSkipThreshold set to ${maxSkipThreshold}`);
+		if (hasSkipThreshold && workerPool) logger.warn("MAX_SKIP_THRESHOLD is not forwarded to executor workers and has no effect in worker-pool mode");
 		const reactorBuilder = new ReactorBuilder().withEventBus(new EventBus()).withKysely(baseKysely);
 		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) : [];
@@ -742,6 +941,15 @@ async function initServer(serverPort, options, renown) {
 			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();
@@ -949,5 +1157,5 @@ 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-DgBz3TJW.mjs.map
-//# debugId=8a8055ab-2ceb-59fe-9007-f1d1fde8a019
+//# sourceMappingURL=server-Cgud_ONM.mjs.map
+//# debugId=5eb0a978-689a-51dd-978a-cd3d7fe5df4b