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

package/dist/{server-Zz7SqTwO.mjs → server-J9fpd42v.mjs}

@@ -1,5 +1,5 @@
 
-!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]="12676ab9-2bd3-55f1-9a41-559509adace0")}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]="e3d937b6-2957-5fe0-8fc9-bf4fd0c18c93")}catch(e){}}();
 import { n as addDefaultReactorDrive, r as isPostgresUrl, t as addDefaultDrive } from "./utils-uaBlzyjS.mjs";
 import { createRequire, register } from "node:module";
 import { metrics, trace } from "@opentelemetry/api";
@@ -11,7 +11,7 @@ import { getConfig } from "@powerhousedao/config/node";
 import { existsSync, promises, realpathSync } from "node:fs";
 import path, { resolve } from "node:path";
 import { createDurableNodeFs, preparePgliteDataDir, removeStalePgliteFiles, resolvePgliteFsync, syncTree } from "@powerhousedao/reactor-api/pglite-node";
-import { ChannelScheme, DriveCollectionId, EventBus, HardenedPGliteDialect, REACTOR_SCHEMA, ReactorBuilder, ReactorClientBuilder, UnsupportedStoredProtocolError, createHybridProjectionCoordinatorFactory, instrumentPgPool, parseDriveUrl, supportsLiveReadModelRegistration } from "@powerhousedao/reactor";
+import { ChannelScheme, DriveCollectionId, EventBus, HardenedPGliteDialect, IN_MEMORY_PGLITE_STORAGE_FACTS, PGLITE_PATH_STORAGE_FACTS, POSTGRES_STORAGE_FACTS, REACTOR_SCHEMA, ReactorBuilder, ReactorClientBuilder, UnsupportedStoredProtocolError, createHybridProjectionCoordinatorFactory, instrumentPgPool, parseDriveUrl, supportsLiveReadModelRegistration } from "@powerhousedao/reactor";
 import { AuthorizationPolicy, BaseSubgraph, ForbiddenError, HttpPackageLoader, ImportPackageLoader, PGLITE_UTC_PARSERS, PackageManagementService, PackagesSubgraph, PrivacyPermissionAdapter, callerSubject, createCanonicalDocumentIdResolver, getUniqueDocumentModels, initializeAndStartAPI, resolveRenownConfig } from "@powerhousedao/reactor-api";
 import { httpsHooksPath } from "@powerhousedao/reactor-api/https-hooks";
 import { AttachmentAlreadyExists, AttachmentNotFound, AttachmentPending, AttachmentReferenceReadModel, AttachmentSchemaCompiler, HashMismatch, InvalidAttachmentMetadata, InvalidAttachmentRef, ReservationNotFound, SizeMismatch, UploadTooLarge, createRef, createRemoteAttachmentService, parseAttachmentDownloadTarget, parseRef, validateReserveMetadata } from "@powerhousedao/reactor-attachments";
@@ -1363,6 +1363,14 @@ function callbackUrlOf(http) {
 }
 //#endregion
 //#region src/workflow/resolvers.ts
+const PIECE_SOURCES = [
+	"local",
+	"registry",
+	"activepieces"
+];
+function isPieceSource(value) {
+	return PIECE_SOURCES.includes(value);
+}
 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 {
@@ -1516,7 +1524,17 @@ const getResolvers = (runtime, authorizationService, oauth, access = UNKNOWN_ACC
 			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),
+			searchPieces: (_parent, args) => {
+				if (args.kind !== "action" && args.kind !== "trigger") throw new GraphQLError(`A search's kind is "action" or "trigger", got "${args.kind}"`);
+				const unknown = (args.sources ?? []).filter((source) => !isPieceSource(source));
+				if (unknown.length > 0) throw new GraphQLError(`A search's sources are ${PIECE_SOURCES.join(", ")}, got ${unknown.join(", ")}`);
+				return runtime.searchPieces(args.query, {
+					kind: args.kind,
+					sources: (args.sources ?? []).filter(isPieceSource),
+					categories: args.categories ?? void 0,
+					limit: 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) => {
@@ -1714,10 +1732,20 @@ const schema = gql`
       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!
+    Piece and block search across the catalog, grouped by piece. The index
+    builds lazily on first use; poll while status is "indexing".
+    """
+    searchPieces(
+      query: String!
+      "action | trigger"
+      kind: String!
+      "local | registry | activepieces; all when omitted."
+      sources: [String!]
+      "Category ids, any of; all when omitted."
+      categories: [String!]
+      "Pieces returned."
+      limit: Int
+    ): PieceSearchResult!
     """
     Health of every registered piece trigger (poll schedule, errors).
     """
@@ -1834,10 +1862,28 @@ const schema = gql`
     latestVersion: String
   }
 
-  type BlockSearchResult {
+  type PieceSearchMatch {
+    pieceName: String!
+    pieceVersion: String!
+    displayName: String!
+    description: String!
+    logoUrl: String!
+    categories: [String!]!
+    "local | registry | activepieces"
+    source: String!
+    deprecated: Boolean
+    "Why no block of the piece can run on this reactor."
+    unsupported: String
+    "Every query token matched the piece's own name."
+    namedPiece: Boolean!
+    "Matching blocks of the kind asked for, best first."
+    blocks: [BlockSearchHit!]!
+  }
+
+  type PieceSearchResult {
     "ready | indexing | error"
     status: String!
-    hits: [BlockSearchHit!]!
+    pieces: [PieceSearchMatch!]!
     indexedPieces: Int!
     error: String
   }
@@ -2111,6 +2157,10 @@ const WORKFLOW_PACKAGE_NAME = "@powerhousedao/workflow";
 const WORKFLOW_TELEMETRY_SCOPE = "@powerhousedao/reactor-workflow";
 /** The env var and OpenFeature flag key that turns workflows on. */
 const PH_WORKFLOWS_ENABLED = "PH_WORKFLOWS_ENABLED";
+const SINGLETON_LOST = {
+	status: "unavailable",
+	reason: "workflow-singleton-lost"
+};
 /** 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 }) {
@@ -2127,6 +2177,88 @@ async function assertWorkflowPackageLoadable(load = () => import("@powerhousedao
 		throw new Error(`Workflows are enabled but ${WORKFLOW_PACKAGE_NAME} could not be loaded`, { cause: error });
 	}
 }
+/**
+* Whether a composition failure was the workflow singleton refusing this
+* process, rather than something that should take the boot down.
+*
+* Matched by NAME: the engine loads lazily, and importing it here for the
+* constructor would defeat that. The fields the engine's error carries are
+* typed optional for the same reason.
+*/
+function isWorkflowSingletonConflict(error) {
+	return error instanceof Error && error.name === "WorkflowSingletonConflictError";
+}
+/**
+* Retries the singleton claim for a host that booted without it, and hands
+* the runtime over once a claim succeeds.
+*
+* Without it a rolling deploy whose slots have different owner names ends
+* with nobody running workflows: the new pod is refused while the old one
+* still holds the lease, and nothing retries once the old pod releases it.
+* Only for a host that never composed; one that lost the lease after
+* composing stays without workflows until it restarts.
+*/
+function retryWorkflowSingleton(options) {
+	const intervalMs = options.intervalMs ?? 2e4;
+	let stopped = false;
+	let timer;
+	let attempt;
+	const run = async () => {
+		let workflows;
+		try {
+			workflows = await options.compose();
+		} catch (error) {
+			if (!isWorkflowSingletonConflict(error)) options.logger.error("Composing the workflow runtime after the singleton came free failed: @error", error);
+			schedule();
+			return;
+		}
+		if (stopped) {
+			await workflows.stop();
+			return;
+		}
+		options.logger.info("Claimed the workflow singleton after boot; starting the workflow runtime");
+		await options.onComposed(workflows);
+	};
+	const schedule = () => {
+		if (stopped) return;
+		timer = setTimeout(() => {
+			timer = void 0;
+			attempt = run().finally(() => {
+				attempt = void 0;
+			});
+		}, intervalMs);
+		timer.unref();
+	};
+	schedule();
+	return { async stop() {
+		stopped = true;
+		if (timer) clearTimeout(timer);
+		timer = void 0;
+		await attempt?.catch(() => void 0);
+	} };
+}
+/**
+* What a host does once its composed runtime has shut down for losing the
+* workflow singleton.
+*
+* Taken over by another claim: that process runs workflows now, so this one
+* stays without them until it restarts. Unrenewable with no takeover seen (a
+* database blip): nothing else runs them, so the process goes down through
+* the fatal shutdown and its supervisor restarts it, which re-claims at boot.
+* A host with no fatal shutdown installed (embedded) stays without workflows
+* and says a restart is needed.
+*/
+function workflowSingletonLossHandler(logger, fatal = triggerFatalShutdown) {
+	return (loss) => {
+		if (loss.reason === "taken") {
+			logger.error(`Another process ("${loss.heldBy ?? "unknown"}") took the workflow singleton. This Switchboard has stopped its workflow runtime and runs no workflows until it is restarted; everything else serves normally.`);
+			return;
+		}
+		const error = /* @__PURE__ */ new Error(`The workflow singleton lease could not be renewed for ${Math.round(loss.silentMs)}ms; no other process was seen taking it over`);
+		if (fatal("Workflow singleton lease unrenewable", error)) return;
+		logger.error(`${error.message}. This Switchboard has stopped its workflow runtime and runs no workflows until it is restarted.`);
+	};
+}
 function modelManifestSource(builder) {
 	return {
 		modelManifest: () => builder.getResolvedModelManifest() ?? [],
@@ -2235,7 +2367,7 @@ function attachmentReadPolicy(access, retryMs = REFERENCE_INDEX_RETRY_MS) {
 		return false;
 	};
 }
-async function registerWorkflowTriggersReadModel(engine, runtime, clientModule) {
+async function registerWorkflowTriggersReadModel(engine, runtime, clientModule, registration) {
 	const reactorModule = clientModule?.reactorModule;
 	if (!reactorModule) return {
 		status: "unavailable",
@@ -2248,7 +2380,9 @@ async function registerWorkflowTriggersReadModel(engine, runtime, clientModule)
 	};
 	const readModel = new engine.WorkflowTriggersReadModel(reactorModule.database.withSchema(REACTOR_SCHEMA), reactorModule.operationIndex, reactorModule.writeCache, reactorModule.processorManagerConsistencyTracker, runtime);
 	await readModel.init();
+	if (registration.tornDown) return SINGLETON_LOST;
 	coordinator.addReadModel(readModel, engine.WORKFLOW_TRIGGERS_READ_MODEL_STAGE);
+	registration.detach = () => coordinator.removeReadModel(readModel);
 	return { status: "available" };
 }
 function bindPackagePieces(registry, source) {
@@ -2266,8 +2400,37 @@ async function composeWorkflowRuntime(deps) {
 	} catch (error) {
 		throw new Error("Workflows are enabled but @powerhousedao/reactor-workflow could not be loaded", { cause: error });
 	}
+	const loss = { lost: false };
+	const lease = deps.singletonLease === false ? void 0 : await engine.acquireWorkflowSingletonLease({
+		relationalDb: deps.relationalDb,
+		logger: deps.logger,
+		...deps.storageId ? { storageId: deps.storageId } : {},
+		selfFence: deps.exclusiveJournal !== true,
+		onLost: (lost) => {
+			loss.lost = true;
+			if (lost.reason === "taken") loss.heldBy = lost.heldBy;
+			loss.tearDown?.();
+			if (loss.composed) deps.onSingletonLost?.(lost);
+		}
+	});
+	try {
+		const composed = await composeClaimed(engine, deps, lease, loss);
+		if (loss.lost) throw singletonLostError(engine, loss, lease);
+		loss.composed = true;
+		return composed;
+	} catch (error) {
+		loss.tearDown?.();
+		await lease?.release();
+		throw error;
+	}
+}
+function singletonLostError(engine, loss, lease) {
+	return new engine.WorkflowSingletonConflictError(loss.heldBy ?? "unknown", "unknown", lease?.owner ?? "unknown");
+}
+async function composeClaimed(engine, deps, lease, loss) {
 	engine.setPieceRegistryUrl(deps.pieceRegistryUrl);
 	if (deps.pieces) bindPackagePieces(engine.packagePieces, deps.pieces);
+	if (loss.lost) throw singletonLostError(engine, loss, lease);
 	const access = reactorAccessOf(deps.clientModule);
 	const models = deps.models;
 	const runtime = engine.createWorkflowRuntime({
@@ -2290,24 +2453,40 @@ async function composeWorkflowRuntime(deps) {
 		logger: deps.logger,
 		...deps.telemetry ? { telemetry: deps.telemetry } : {}
 	});
-	const triggers = await registerWorkflowTriggersReadModel(engine, runtime, deps.clientModule);
+	const routes = {};
+	const registration = { tornDown: false };
+	const tearDown = () => {
+		if (registration.tornDown) return;
+		registration.tornDown = true;
+		routes.oauthCallback?.dispose();
+		runtime.shutdown();
+		registration.detach?.();
+	};
+	loss.tearDown = tearDown;
+	const triggers = await registerWorkflowTriggersReadModel(engine, runtime, deps.clientModule, registration);
+	if (registration.tornDown) throw singletonLostError(engine, loss, lease);
 	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;
+	if (deps.http) routes.oauthCallback = registerOAuthCallback(deps.http, runtime);
 	return {
 		subgraph: createWorkflowRuntimeSubgraph(runtime, deps.http ? { callbackUrl: callbackUrlOf(deps.http) } : void 0, access),
-		triggers,
+		get triggers() {
+			return loss.lost ? SINGLETON_LOST : triggers;
+		},
+		...lease ? { singletonOwner: lease.owner } : {},
 		async start() {
+			if (registration.tornDown) return;
 			await runtime.registerWebhookEndpoint();
+			if (loss.lost || stopped) return;
 			runtime.startTriggerSupervisor();
+			runtime.warmPieceSearch();
 		},
-		stop() {
-			if (stopped) return Promise.resolve();
+		async stop() {
+			if (stopped) return;
 			stopped = true;
-			oauthCallback?.dispose();
-			runtime.shutdown();
-			return Promise.resolve();
+			tearDown();
+			await lease?.release();
 		}
 	};
 }
@@ -2785,7 +2964,8 @@ async function createReactorKysely(opts) {
 		logger.info(`Using PostgreSQL for reactor storage (host pool max ${poolSize})`);
 		return {
 			kysely: new Kysely({ dialect: new PostgresDialect({ pool }) }),
-			poolInstrumentation
+			poolInstrumentation,
+			storageFacts: POSTGRES_STORAGE_FACTS
 		};
 	}
 	if (!reactorPgliteDir || reactorPgliteMajor === null) throw new Error("Reactor PGLite directory not resolved");
@@ -2794,7 +2974,8 @@ async function createReactorKysely(opts) {
 	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, reactorPgliteDialectOptions(logger)) }),
-		poolInstrumentation: void 0
+		poolInstrumentation: void 0,
+		storageFacts: inMemory ? IN_MEMORY_PGLITE_STORAGE_FACTS : PGLITE_PATH_STORAGE_FACTS
 	};
 }
 /** Derive the remote attachment service config for switchboard's own `/attachments/*` API. */
@@ -2906,7 +3087,7 @@ async function initServer(serverPort, options, renown, renownConfig) {
 				attachmentReferenceProjection
 			};
 		}
-		const { kysely: baseKysely, poolInstrumentation } = await createReactorKysely({
+		const { kysely: baseKysely, poolInstrumentation, storageFacts } = await createReactorKysely({
 			reactorDbUrl,
 			reactorPgliteDir,
 			reactorPgliteMajor,
@@ -2919,7 +3100,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" }).withUnsupportedStoredDocuments(unsupportedStoredDocuments);
+		const reactorBuilder = new ReactorBuilder().withEventBus(new EventBus()).withKysely(baseKysely).withStorageFacts(storageFacts).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) : [];
@@ -3102,27 +3283,31 @@ async function initServer(serverPort, options, renown, renownConfig) {
 	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),
-			attachmentAccess: api.attachmentAccess,
-			webhooks: api.httpRoutes.scopeFor(WORKFLOW_PACKAGE_NAME).webhooks,
-			http: api.httpRoutes.scopeFor(WORKFLOW_PACKAGE_NAME),
-			authorizationService: api.authorizationService,
-			pieces: api.packageManager,
-			pieceRegistryUrl: registryUrl,
-			models: workerModels,
-			logger: logger.child(["workflow-runtime"]),
-			telemetry: {
-				tracer: trace.getTracer(WORKFLOW_TELEMETRY_SCOPE),
-				meter: metrics.getMeter(WORKFLOW_TELEMETRY_SCOPE)
-			}
-		});
-		const WorkflowRuntimeSubgraph = workflows.subgraph;
+	let workflowsRetry;
+	const composeWorkflows = () => composeWorkflowRuntime({
+		reactorClient: client,
+		clientModule: options.reactor ?? ownedReactorModule,
+		relationalDb: api.relationalDb,
+		secretsKeyFile: readModelPgliteDir === null ? false : void 0,
+		storageId: readModelPgliteDir === null ? readModelPath : path$1.resolve(readModelPath),
+		attachments: createAttachmentClient(api.attachments.service),
+		attachmentAccess: api.attachmentAccess,
+		webhooks: api.httpRoutes.scopeFor(WORKFLOW_PACKAGE_NAME).webhooks,
+		http: api.httpRoutes.scopeFor(WORKFLOW_PACKAGE_NAME),
+		authorizationService: api.authorizationService,
+		pieces: api.packageManager,
+		pieceRegistryUrl: registryUrl,
+		models: workerModels,
+		logger: logger.child(["workflow-runtime"]),
+		exclusiveJournal: readModelPgliteDir !== null,
+		onSingletonLost: workflowSingletonLossHandler(logger),
+		telemetry: {
+			tracer: trace.getTracer(WORKFLOW_TELEMETRY_SCOPE),
+			meter: metrics.getMeter(WORKFLOW_TELEMETRY_SCOPE)
+		}
+	});
+	const registerWorkflowSubgraph = (composed) => {
+		const WorkflowRuntimeSubgraph = composed.subgraph;
 		const workflowSubgraph = new WorkflowRuntimeSubgraph({
 			reactorClient: client,
 			http: graphqlManager.scopeForPackage(WORKFLOW_PACKAGE_NAME),
@@ -3134,11 +3319,36 @@ async function initServer(serverPort, options, renown, renownConfig) {
 			path: graphqlManager.getBasePath(),
 			attachments: api.attachmentClientProvider
 		});
-		lateSubgraphs.push(graphqlManager.registerSubgraphInstance(workflowSubgraph, "graphql", false).catch((error) => {
+		return graphqlManager.registerSubgraphInstance(workflowSubgraph, "graphql", false).catch((error) => {
 			logger.error("Failed to register workflow-runtime subgraph: @error", error);
-		}));
+		});
+	};
+	if (workflowsEnabled) try {
+		workflows = await composeWorkflows();
+	} catch (error) {
+		if (!isWorkflowSingletonConflict(error)) throw error;
+		logger.warn(`Workflows are enabled but another live process ("${error.owner ?? "unknown"}") holds the workflow singleton until ${error.expiresAt ?? "unknown"}. This Switchboard has booted WITHOUT the workflow runtime: no trigger of any kind fires here, and the workflow GraphQL face is absent. Everything else serves normally. Stop the other owner, or set PH_WORKFLOWS_SINGLETON_OWNER to the same stable name on the slot that owns workflows. This Switchboard retries the claim and starts workflows once the lease comes free.`);
+		workflowsRetry = retryWorkflowSingleton({
+			compose: composeWorkflows,
+			onComposed: async (composed) => {
+				workflows = composed;
+				await registerWorkflowSubgraph(composed);
+				try {
+					await graphqlManager.updateRouter();
+				} catch (error) {
+					logger.error("Mounting the late workflow-runtime subgraph failed: @error", error);
+				}
+				await composed.start();
+				logger.info("Workflow runtime started");
+			},
+			logger
+		});
+	}
+	if (workflows) {
+		lateSubgraphs.push(registerWorkflowSubgraph(workflows));
 		await workflows.start();
 		logger.info("Workflow runtime started");
+		api.inspection?.facts.setWorkflows(true);
 	}
 	let privacy;
 	if (privacyConfig.enabled) {
@@ -3155,6 +3365,7 @@ async function initServer(serverPort, options, renown, renownConfig) {
 				logger: logger.child(["privacy"])
 			});
 		} catch (error) {
+			await workflowsRetry?.stop();
 			await workflows?.stop();
 			await abortBoot(api);
 			throw error;
@@ -3162,6 +3373,7 @@ async function initServer(serverPort, options, renown, renownConfig) {
 	}
 	const shutdown = async () => {
 		await privacy?.stop();
+		await workflowsRetry?.stop();
 		await workflows?.stop();
 		await api.dispose();
 	};
@@ -3255,7 +3467,9 @@ async function initServer(serverPort, options, renown, renownConfig) {
 		reactor: client,
 		attachmentService,
 		attachmentReferenceProjection: api.attachmentReferenceProjection,
-		workflowTriggers: workflows?.triggers,
+		get workflowTriggers() {
+			return workflows?.triggers;
+		},
 		workflowsEnabled,
 		modelManifest: () => workerModels?.modelManifest() ?? [],
 		privacy: privacy ? { erasure: privacy.erasure } : void 0,
@@ -3331,5 +3545,5 @@ if (import.meta.main) await startSwitchboard({ fatalErrorShutdown: true });
 //#endregion
 export { StoredDocumentsRefusedError as a, initProfilerFromEnv as c, startSwitchboard as i, parseForcePgVersion as l, deriveAttachmentServiceConfig as n, resolveUnsupportedStoredDocuments as o, isPortAvailable as r, applySwitchboardReactorDefaults as s, createReactorKysely as t };
 
-//# sourceMappingURL=server-Zz7SqTwO.mjs.map
-//# debugId=12676ab9-2bd3-55f1-9a41-559509adace0
+//# sourceMappingURL=server-J9fpd42v.mjs.map
+//# debugId=e3d937b6-2957-5fe0-8fc9-bf4fd0c18c93