@powerhousedao/switchboard 6.2.3-dev.23 → 6.2.3-dev.25

package/dist/{server-DVotaGIp.mjs → server-C3WaP3kE.mjs}

@@ -1,14 +1,14 @@
 
-!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]="f230ad22-7960-58f9-8fa7-97e55fa64a8d")}catch(e){}}();
-import { n as addDefaultReactorDrive, r as isPostgresUrl, t as addDefaultDrive } from "./utils-Baw7rThP.mjs";
-import { register } from "node:module";
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="8174bb20-5463-598a-9c2d-44a8760037a5")}catch(e){}}();
+import { n as addDefaultReactorDrive, r as isPostgresUrl, t as addDefaultDrive } from "./utils-uaBlzyjS.mjs";
+import { createRequire, register } from "node:module";
 import { ReactorInstrumentation } from "@powerhousedao/opentelemetry-instrumentation-reactor";
 import * as Sentry from "@sentry/node";
 import { childLogger, documentModelDocumentModelModule, setLogLevel } from "document-model";
 import dotenv from "dotenv";
 import { getConfig } from "@powerhousedao/config/node";
 import { existsSync, promises, realpathSync } from "node:fs";
-import path from "node:path";
+import path, { resolve } from "node:path";
 import { AtomicNodeFs } from "@powerhousedao/pglite-fs";
 import { ChannelScheme, DriveCollectionId, EventBus, REACTOR_SCHEMA, ReactorBuilder, ReactorClientBuilder, createHybridProjectionCoordinatorFactory, instrumentPgPool, parseDriveUrl, supportsLiveReadModelRegistration } from "@powerhousedao/reactor";
 import { AuthorizationPolicy, BaseSubgraph, ForbiddenError, HttpPackageLoader, ImportPackageLoader, PGLITE_UTC_PARSERS, PackageManagementService, PackagesSubgraph, createCanonicalDocumentIdResolver, getUniqueDocumentModels, initializeAndStartAPI, resolveRenownConfig } from "@powerhousedao/reactor-api";
@@ -16,7 +16,7 @@ import { httpsHooksPath } from "@powerhousedao/reactor-api/https-hooks";
 import { AttachmentAlreadyExists, AttachmentNotFound, AttachmentPending, AttachmentReferenceReadModel, AttachmentSchemaCompiler, HashMismatch, InvalidAttachmentRef, ReservationNotFound, SizeMismatch, UploadTooLarge, createRef, createRemoteAttachmentService, parseAttachmentDownloadTarget, parseRef } from "@powerhousedao/reactor-attachments";
 import { createAttachmentClient } from "@powerhousedao/reactor-attachments/client";
 import { DriveNodeView, NodeProcessor, ReactorDriveClient, createReactorDriveResolvers, reactorDriveDocumentModelModule, reactorDriveSubgraphTypeDefs } from "@powerhousedao/reactor-drive";
-import { DEFAULT_RENOWN_URL, NodeKeyStorage, RENOWN_READ_MODEL_SUBGRAPH, RenownBuilder, RenownCryptoBuilder, createLocalCredentialVerifier, createSignatureVerifier } from "@renown/sdk/node";
+import { DEFAULT_KEYPAIR_PATH, DEFAULT_RENOWN_URL, NodeKeyStorage, RENOWN_READ_MODEL_SUBGRAPH, RenownBuilder, RenownCryptoBuilder, createLocalCredentialVerifier, createRenownTrustPolicy, resolveSwitchboardEndpoint } from "@renown/sdk/node";
 import { Kysely, PostgresDialect } from "kysely";
 import net from "node:net";
 import path$1 from "path";
@@ -24,6 +24,7 @@ import { Pool } from "pg";
 import { Readable } from "node:stream";
 import { ReactorGroupV1 } from "@powerhousedao/reactor-group";
 import { driveDocumentModelModule } from "@powerhousedao/shared/document-drive";
+import { DEFAULT_SIGNATURE_POLICY, isSignaturePolicy } from "@powerhousedao/shared/document-model";
 import { readFile } from "node:fs/promises";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
@@ -77,7 +78,15 @@ const ANONYMOUS_ACTOR = {
 * enabled, the request must carry a verifiable Bearer token. The handler always
 * receives an actor context: the verified bearer user when auth is enabled, or
 * the anonymous context when it is disabled. With `allowAnonymous`, a missing
-* bearer yields an anonymous actor with `authEnabled: true` instead of a 401.
+* bearer yields an anonymous actor with `authEnabled: true` instead of a 401 —
+* unless `requireAuthenticatedCaller` says the deployment refuses anonymous
+* callers outright, which overrides it.
+*
+* With no `authService` there is no bearer to read and every caller is
+* anonymous, so nothing is refused here. That combination cannot carry the
+* floor: `assertRequireAuthenticatedCallerAllowed` refuses to boot with
+* `REQUIRE_AUTHENTICATED_CALLER` set and no identity resolution, and identity
+* resolution is what builds the service.
 */
 function requireAuth(authService, handler, options) {
 	if (!authService) return (req, res, body) => handler(req, res, body, ANONYMOUS_ACTOR);
@@ -99,11 +108,13 @@ function requireAuth(authService, handler, options) {
 			res.end(body);
 			return;
 		}
-		if (result.auth_enabled && !result.user && !options?.allowAnonymous) {
-			res.statusCode = 401;
-			res.setHeader("Content-Type", "application/json");
-			res.end(JSON.stringify({ error: "Authentication required" }));
-			return;
+		if (!result.user) {
+			if (options?.requireAuthenticatedCaller === true || result.auth_enabled && !options?.allowAnonymous) {
+				res.statusCode = 401;
+				res.setHeader("Content-Type", "application/json");
+				res.end(JSON.stringify({ error: "Authentication required" }));
+				return;
+			}
 		}
 		await handler(req, res, body, {
 			user: result.user,
@@ -121,10 +132,18 @@ function requireAuth(authService, handler, options) {
 * wrapping you must call `api.httpAdapter.mountNodeRoute` directly.
 *
 * `allowAnonymous` is reserved for routes whose handlers make a per-document
-* authorization decision themselves; identity-only routes must not use it.
+* authorization decision themselves; identity-only routes must not use it. It
+* is also not the last word: a deployment that refuses anonymous callers
+* (`REQUIRE_AUTHENTICATED_CALLER`) refuses them here too, because these routes
+* are mounted on the HTTP adapter and never reach the fetch chain that carries
+* that floor for GraphQL. The flag is read from the API, so every route
+* mounted through here inherits it without each one remembering to.
 */
 function mountAuthenticatedNodeRoute(api, method, path, handler, options) {
-	api.httpAdapter.mountNodeRoute(method, path, requireAuth(api.authService, handler, options));
+	api.httpAdapter.mountNodeRoute(method, path, requireAuth(api.authService, handler, {
+		...options,
+		requireAuthenticatedCaller: api.requireAuthenticatedCaller
+	}));
 }
 //#endregion
 //#region src/attachments/routes.ts
@@ -404,7 +423,37 @@ function extractParam(req, name) {
 }
 const MAX_DOCUMENT_ID_LEN = 512;
 const ATTACHMENT_NOT_FOUND_BODY = { error: "Attachment not found" };
-const MAX_DOWNLOAD_TARGET_TTL_SECONDS = 10080 * 60;
+const MAX_DOWNLOAD_TARGET_TTL_SECONDS = 604800;
+/**
+* How long a download target may live, by default.
+*
+* The authorization behind a presigned URL is decided once, when it is issued,
+* and the URL keeps working until it expires however the document's policy
+* changes in between. A week of that is a revocation that does not revoke: an
+* account deactivated, a company reassigned or a group left, and the bytes stay
+* fetchable by anyone holding the link. Minutes are enough to open a file;
+* days are only enough to lose control of it.
+*
+* A deployment that needs longer sets ATTACHMENT_DOWNLOAD_TARGET_MAX_TTL_SECONDS,
+* still bounded by the signing ceiling above.
+*/
+const DEFAULT_DOWNLOAD_TARGET_TTL_SECONDS = 300;
+/**
+* The ceiling in force, read per call so a deployment can set it without the
+* value being frozen at import — which is also what lets a test cover it.
+* Anything unparseable falls back to the default rather than to the maximum:
+* a typo must not quietly widen the window it was meant to narrow.
+*/
+function downloadTargetTtlCapSeconds() {
+	const configured = process.env.ATTACHMENT_DOWNLOAD_TARGET_MAX_TTL_SECONDS;
+	if (configured === void 0) return DEFAULT_DOWNLOAD_TARGET_TTL_SECONDS;
+	const parsed = Number(configured);
+	if (!Number.isInteger(parsed) || parsed <= 0) {
+		logger$1.warn(`Ignoring invalid ATTACHMENT_DOWNLOAD_TARGET_MAX_TTL_SECONDS="${configured}" (expected a positive integer number of seconds) — using ${DEFAULT_DOWNLOAD_TARGET_TTL_SECONDS}`);
+		return DEFAULT_DOWNLOAD_TARGET_TTL_SECONDS;
+	}
+	return Math.min(parsed, MAX_DOWNLOAD_TARGET_TTL_SECONDS);
+}
 /**
 * Returns the single `documentId` query value, or null when it is missing,
 * duplicated, blank, or oversized. Validation happens before authorization so
@@ -425,24 +474,29 @@ function extractSingleDocumentId(req) {
 	return value;
 }
 /**
-* Returns the requested target TTL in seconds: undefined when absent,
-* "invalid" when malformed (duplicated, non-integer, or non-positive), and
-* otherwise the value clamped to the presigning ceiling.
+* Returns the target TTL in seconds, or "invalid" when the caller's own value
+* is malformed (duplicated, non-integer, or non-positive).
+*
+* The cap applies whether or not the caller asked for a lifetime: omitting
+* `expiresIn` used to fall through to whatever the storage backend was
+* configured with, which would make the ceiling something a client opts out of
+* by saying nothing.
 */
 function extractExpiresIn(req) {
-	if (!req.url) return void 0;
+	const cap = downloadTargetTtlCapSeconds();
+	if (!req.url) return cap;
 	let url;
 	try {
 		url = new URL(req.url, "http://switchboard.invalid");
 	} catch {
-		return;
+		return cap;
 	}
 	const values = url.searchParams.getAll("expiresIn");
-	if (values.length === 0) return void 0;
+	if (values.length === 0) return cap;
 	if (values.length > 1) return "invalid";
 	const parsed = Number(values[0]);
 	if (!Number.isInteger(parsed) || parsed <= 0) return "invalid";
-	return Math.min(parsed, MAX_DOWNLOAD_TARGET_TTL_SECONDS);
+	return Math.min(parsed, cap);
 }
 /**
 * Base URL of this Switchboard as seen by the caller, used to build
@@ -481,7 +535,8 @@ function makeDownloadTargetHandler(attachments, attachmentAccess) {
 			decision = await attachmentAccess.canReadAttachment({
 				documentId,
 				attachmentRef: createRef(canonicalHash),
-				userAddress: actor?.user?.address
+				userAddress: actor?.user?.address,
+				appKey: actor?.user?.appKey
 			});
 		} catch (err) {
 			logger$1.error("Attachment access decision failed: @error", err);
@@ -663,7 +718,13 @@ function applySwitchboardReactorDefaults(reactorBuilder, clientBuilder, options
 	});
 	if (options.documentModelLoader) reactorBuilder.withDocumentModelLoader(options.documentModelLoader);
 	if (options.logger) reactorBuilder.withLogger(options.logger);
-	if (options.signer) clientBuilder.withSigner(options.signer);
+	if (options.signer) {
+		clientBuilder.withSigner(options.signer);
+		reactorBuilder.withSigner(options.signer.signer, options.signer.workerSigner);
+	}
+	if (options.createSignaturePolicy) clientBuilder.withCreateSignaturePolicy(options.createSignaturePolicy);
+	const trust = options.trustPolicy ?? options.signer;
+	if (trust?.trustPolicy) reactorBuilder.withTrustPolicy(trust.trustPolicy, trust.workerTrustPolicy);
 }
 //#endregion
 //#region src/worker-pool.mts
@@ -932,7 +993,9 @@ function toStepRecord(row) {
 		input: parseJson(row.input),
 		output: parseJson(row.output),
 		port: row.port,
-		error: row.error
+		error: row.error,
+		startedAt: row.started_at,
+		endedAt: row.ended_at
 	};
 }
 function toRunRecord(row, steps) {
@@ -1100,8 +1163,10 @@ const schema = gql`
     description: String!
     "action | trigger"
     kind: String!
-    "Triggers only: POLLING | WEBHOOK | APP_WEBHOOK"
+    "Triggers only: POLLING | WEBHOOK | APP_WEBHOOK | MANUAL"
     strategy: String
+    "Why this block cannot run on this reactor; null when it can."
+    unsupported: String
   }
 
   type BlockSearchResult {
@@ -1133,6 +1198,10 @@ const schema = gql`
   type ConnectionCheckResult {
     ok: Boolean!
     detail: String
+    """
+    From auth.getConnectionIdentifier when the check passes; otherwise the
+    label the connection already holds.
+    """
     accountLabel: String
   }
 
@@ -1173,6 +1242,8 @@ const schema = gql`
     output: Unknown
     port: String
     error: String
+    startedAt: String
+    endedAt: String
   }
 
   type WorkflowRunRecord {
@@ -1239,8 +1310,9 @@ const schema = gql`
     """
     deleteSecret(ref: String!): Boolean!
     """
-    Runs the piece's app.checkConnection against the connection's
-    credentials and records the outcome on the connection document.
+    Runs the piece's auth.validate against the connection's credentials,
+    then auth.getConnectionIdentifier for the account label, and records the
+    outcome on the connection document.
     """
     checkConnection(connectionId: String!): ConnectionCheckResult!
   }
@@ -1538,6 +1610,26 @@ function resolveReactorFeatureFlags(env) {
 	};
 }
 //#endregion
+//#region src/create-signature-policy.mts
+/**
+* What new documents are created as, from CREATE_SIGNATURE_POLICY. Without a
+* signer this switchboard cannot write to a v2-required document, so it falls
+* back to legacy and says so.
+*/
+function resolveCreateSignaturePolicy(env, options) {
+	const raw = env.CREATE_SIGNATURE_POLICY?.trim();
+	let policy = DEFAULT_SIGNATURE_POLICY;
+	if (raw) {
+		if (!isSignaturePolicy(raw)) throw new Error(`CREATE_SIGNATURE_POLICY must be "legacy" or "v2-required", got "${raw}"`);
+		policy = raw;
+	}
+	if (policy === "v2-required" && !options.hasSigner) {
+		options.logger?.warn("No signer is configured, so new documents are created legacy: a v2-required document refuses the unsigned operations this switchboard would write. Set up an identity (ph login) to create v2-required documents.");
+		return "legacy";
+	}
+	return policy;
+}
+//#endregion
 //#region src/renown.ts
 const logger = childLogger(["switchboard", "renown"]);
 /**
@@ -1560,12 +1652,94 @@ async function initRenown(options = {}) {
 * Get the signer config for the given renown instance.
 *
 * @param renown - The renown instance
-* @param requireSignature - If true, unsigned actions are rejected
+* @param keypairPath - Where `initRenown` loaded the key from
 */
-function getRenownSignerConfig(renown, requireSignature) {
+function getRenownSignerConfig(renown, keypairPath) {
 	return {
 		signer: renown.signer,
-		verifier: createSignatureVerifier(requireSignature)
+		workerSigner: getRenownWorkerSignerSpec(renown, keypairPath)
+	};
+}
+/**
+* What a pooled executor worker imports to sign as this switchboard: it
+* reloads the key `initRenown` stored, and takes the user known at boot.
+*/
+function getRenownWorkerSignerSpec(renown, keypairPath) {
+	const { signer } = renown;
+	const user = signer.user;
+	return {
+		module: {
+			filePath: createRequire(import.meta.url).resolve("@renown/sdk/node"),
+			exportName: "createNodeRenownSigner"
+		},
+		initArgs: {
+			appName: signer.app?.name ?? "switchboard",
+			keypairPath: resolve(keypairPath ?? DEFAULT_KEYPAIR_PATH),
+			...signer.app?.key ? { did: signer.app.key } : {},
+			...user ? { user: {
+				address: user.address,
+				networkId: user.networkId,
+				chainId: user.chainId
+			} } : {}
+		}
+	};
+}
+/**
+* Admits a key as a signer for an address a Renown credential binds it to; a
+* `self` source has no worker spec. In process, the switchboard's own key is
+* matched against its current user; the worker spec carries the user known now.
+*/
+async function getRenownTrustPolicyConfig(trustSource, renown) {
+	const ownSigner = renown?.signer;
+	if (trustSource.source === "self") return { trustPolicy: createRenownTrustPolicy({
+		switchboard: trustSource.request,
+		ownSigner
+	}) };
+	const switchboardUrl = await resolveSwitchboardEndpoint({
+		switchboardUrl: trustSource.switchboardUrl,
+		baseUrl: trustSource.renownUrl
+	});
+	const options = {
+		...switchboardUrl ? { switchboard: switchboardUrl } : {},
+		...trustSource.renownUrl ? { renownUrl: trustSource.renownUrl } : {}
+	};
+	const self = ownIdentity(renown);
+	return {
+		trustPolicy: createRenownTrustPolicy({
+			...options,
+			ownSigner
+		}),
+		workerTrustPolicy: {
+			module: {
+				filePath: createRequire(import.meta.url).resolve("@renown/sdk/node"),
+				exportName: "createRenownTrustPolicy"
+			},
+			initArgs: {
+				...options,
+				...self ? { self } : {}
+			}
+		}
+	};
+}
+/**
+* Fails the boot when pooled workers would refuse every signed write the
+* in-process executor accepts: a `self` Renown source gives workers no trust
+* policy spec, so under authEnforcement they apply the default.
+*/
+function assertWorkerTrustPolicy(config) {
+	if (config.workers > 0 && config.authEnforcement && config.renownSource === "self") throw new Error("The executor worker pool (REACTOR_WORKERS) cannot verify signers when REACTOR_AUTH_ENFORCEMENT is on and Renown credentials are read from this switchboard (\"self\" via auth.renown.source or RENOWN_SOURCE): pooled workers have no trust policy and would refuse every signed write. Set RENOWN_SOURCE=remote, or disable the worker pool (REACTOR_WORKERS=0).");
+}
+function ownIdentity(renown) {
+	const key = renown?.signer.app?.key;
+	if (!key) return;
+	const user = renown.signer.user;
+	return {
+		key,
+		user: {
+			address: user?.address ?? "",
+			networkId: user?.networkId ?? "",
+			chainId: user?.chainId ?? 0
+		}
 	};
 }
 //#endregion
@@ -1576,8 +1750,6 @@ setLogLevel(LogLevel);
 dotenv.config();
 const DOCUMENT_MODEL_SUBGRAPHS_ENABLED = "DOCUMENT_MODEL_SUBGRAPHS_ENABLED";
 const DOCUMENT_MODEL_SUBGRAPHS_ENABLED_DEFAULT = true;
-const REQUIRE_SIGNATURES = "REQUIRE_SIGNATURES";
-const REQUIRE_SIGNATURES_DEFAULT = false;
 const DEFAULT_PORT = process.env.PORT ? Number(process.env.PORT) : 4001;
 const PORT_FALLBACK_ATTEMPTS = 20;
 const PGLITE_FLUSH_INTERVAL_MS = (() => {
@@ -1731,6 +1903,11 @@ async function initServer(serverPort, options, renown, renownConfig) {
 	}
 	if (workerPool) {
 		if (dev) throw new Error("The executor worker pool (REACTOR_WORKERS) is not supported in dev mode: Vite-loaded document models cannot cross a worker-thread boundary");
+		assertWorkerTrustPolicy({
+			workers: workerPool.numWorkers,
+			authEnforcement: resolveReactorFeatureFlags(process.env).flags.authEnforcement === true,
+			renownSource: renownConfig.source
+		});
 		if (!reactorDbUrl || !isPostgresUrl(reactorDbUrl)) throw new Error("The executor worker pool (REACTOR_WORKERS) requires a Postgres reactor database — set PH_REACTOR_DATABASE_URL or PH_SWITCHBOARD_DATABASE_URL. PGlite cannot be shared across worker threads.");
 	}
 	let projectionWorker = resolveProjectionWorkerOptions(options.projectionWorker, process.env);
@@ -1772,6 +1949,7 @@ async function initServer(serverPort, options, renown, renownConfig) {
 		if (!packages.includes("@powerhousedao/workflow")) packages.push(WORKFLOW_PACKAGE_NAME);
 	}
 	let ownedReactorModule;
+	let localRenownRequest;
 	const initializeClient = async (documentModels, { attachmentReferenceWriter, upgradeManifests }) => {
 		if (options.reactor) {
 			const attachmentReferenceProjection = await registerAttachmentReferenceReadModelOnModule(options.reactor, attachmentReferenceWriter);
@@ -1811,7 +1989,19 @@ async function initServer(serverPort, options, renown, renownConfig) {
 			} : void 0,
 			documentModelLoader: httpLoader && dynamicModelLoading ? httpLoader.documentModelLoader : void 0,
 			logger: reactorLogger,
-			signer: renown ? getRenownSignerConfig(renown, options.identity?.requireSignatures) : void 0
+			signer: renown ? getRenownSignerConfig(renown, options.identity?.keypairPath) : void 0,
+			createSignaturePolicy: resolveCreateSignaturePolicy(process.env, {
+				hasSigner: renown !== null,
+				logger
+			}),
+			trustPolicy: reactorFeatureFlags.authEnforcement ? await getRenownTrustPolicyConfig(renownConfig.source === "self" ? {
+				source: "self",
+				request: (query, variables) => localRenownRequest ? localRenownRequest(query, variables) : Promise.reject(/* @__PURE__ */ new Error("The local renown read model is not bound yet"))
+			} : {
+				source: "remote",
+				renownUrl: renownConfig.url,
+				switchboardUrl: renownConfig.switchboardUrl
+			}, renown) : void 0
 		});
 		if (workerPool) {
 			if (!reactorDbUrl) throw new Error("unreachable: worker pool enabled without a reactor database URL");
@@ -1860,7 +2050,8 @@ async function initServer(serverPort, options, renown, renownConfig) {
 			new ReactorInstrumentation(module.reactorModule).start();
 			reactorLogger.info("Reactor metrics instrumentation started");
 		}
-		driveNodeView = new DriveNodeView(baseKysely.withSchema(REACTOR_SCHEMA));
+		const reactorDriveSchemaDb = baseKysely.withSchema(REACTOR_SCHEMA);
+		driveNodeView = new DriveNodeView(reactorDriveSchemaDb);
 		const reactorDriveClient = new ReactorDriveClient({
 			reactor: module.client,
 			readModel: driveNodeView
@@ -1949,7 +2140,8 @@ async function initServer(serverPort, options, renown, renownConfig) {
 			await abortBoot(api);
 			throw new Error(`Renown credential verification is set to "self" (auth.renown.source or RENOWN_SOURCE) but no loaded package serves the "${RENOWN_READ_MODEL_SUBGRAPH}" subgraph. Install one (@powerhousedao/renown-package) or set RENOWN_SOURCE=remote.`);
 		}
-		localCredentialCheck = createLocalCredentialVerifier((query, variables) => manager.executeSubgraphQuery(RENOWN_READ_MODEL_SUBGRAPH, query, variables), { onError: (error) => logger.error("Renown read model query failed: @error", error) });
+		localRenownRequest = (query, variables) => manager.executeSubgraphQuery(RENOWN_READ_MODEL_SUBGRAPH, query, variables);
+		localCredentialCheck = createLocalCredentialVerifier(localRenownRequest, { onError: (error) => logger.error("Renown read model query failed: @error", error) });
 		logger.info("Renown credentials will be verified against this switchboard's own renown read model");
 	}
 	registerAttachmentRoutes(api);
@@ -2107,7 +2299,6 @@ const startSwitchboard = async (options = {}) => {
 	const featureFlags = await initFeatureFlags();
 	const enableDocumentModelSubgraphs = await featureFlags.getBooleanValue(DOCUMENT_MODEL_SUBGRAPHS_ENABLED, options.enableDocumentModelSubgraphs ?? DOCUMENT_MODEL_SUBGRAPHS_ENABLED_DEFAULT);
 	options.enableDocumentModelSubgraphs = enableDocumentModelSubgraphs;
-	const requireSignatures = options.identity?.requireSignatures ?? await featureFlags.getBooleanValue(REQUIRE_SIGNATURES, REQUIRE_SIGNATURES_DEFAULT);
 	const configPathForFlags = resolveConfigPath(options.configFile);
 	const workflowsEnabled = await resolveWorkflowsEnabled({
 		featureFlags,
@@ -2118,12 +2309,10 @@ const startSwitchboard = async (options = {}) => {
 	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,
 		PH_WORKFLOWS_ENABLED: workflowsEnabled
 	}, null, 2));
 	let renown = null;
@@ -2145,5 +2334,5 @@ if (import.meta.main) await startSwitchboard({ fatalErrorShutdown: true });
 //#endregion
 export { parseForcePgVersion as a, applySwitchboardReactorDefaults as i, isPortAvailable as n, startSwitchboard as r, deriveAttachmentServiceConfig as t };
 
-//# sourceMappingURL=server-DVotaGIp.mjs.map
-//# debugId=f230ad22-7960-58f9-8fa7-97e55fa64a8d
+//# sourceMappingURL=server-C3WaP3kE.mjs.map
+//# debugId=8174bb20-5463-598a-9c2d-44a8760037a5