@hachej/boring-workspace 0.1.53 → 0.1.55

package/dist/app-server.js

@@ -649,6 +649,406 @@ function normalizeBoringPluginPiPackages(plugins) {
   );
 }
 
+// src/shared/workspace-bridge-rpc.ts
+var WORKSPACE_BRIDGE_URL_ENV = "BORING_WORKSPACE_BRIDGE_URL";
+var WORKSPACE_BRIDGE_TOKEN_ENV = "BORING_WORKSPACE_BRIDGE_TOKEN";
+var WORKSPACE_BRIDGE_TOKEN_URL_ENV = "BORING_WORKSPACE_BRIDGE_TOKEN_URL";
+var WORKSPACE_BRIDGE_REFRESH_TOKEN_ENV = "BORING_WORKSPACE_BRIDGE_REFRESH_TOKEN";
+var WORKSPACE_BRIDGE_DISABLED_ENV = "BORING_WORKSPACE_BRIDGE_DISABLED";
+var WorkspaceBridgeErrorCode = /* @__PURE__ */ ((WorkspaceBridgeErrorCode2) => {
+  WorkspaceBridgeErrorCode2["OpNotFound"] = "BRIDGE_OP_NOT_FOUND";
+  WorkspaceBridgeErrorCode2["DuplicateOp"] = "BRIDGE_DUPLICATE_OP";
+  WorkspaceBridgeErrorCode2["CallerNotAllowed"] = "BRIDGE_CALLER_NOT_ALLOWED";
+  WorkspaceBridgeErrorCode2["AuthRequired"] = "BRIDGE_AUTH_REQUIRED";
+  WorkspaceBridgeErrorCode2["CapabilityDenied"] = "BRIDGE_CAPABILITY_DENIED";
+  WorkspaceBridgeErrorCode2["ResourceScopeDenied"] = "BRIDGE_RESOURCE_SCOPE_DENIED";
+  WorkspaceBridgeErrorCode2["SchemaInvalid"] = "BRIDGE_SCHEMA_INVALID";
+  WorkspaceBridgeErrorCode2["OutputSchemaInvalid"] = "BRIDGE_OUTPUT_SCHEMA_INVALID";
+  WorkspaceBridgeErrorCode2["InputTooLarge"] = "BRIDGE_INPUT_TOO_LARGE";
+  WorkspaceBridgeErrorCode2["OutputTooLarge"] = "BRIDGE_OUTPUT_TOO_LARGE";
+  WorkspaceBridgeErrorCode2["Timeout"] = "BRIDGE_TIMEOUT";
+  WorkspaceBridgeErrorCode2["HandlerFailed"] = "BRIDGE_HANDLER_FAILED";
+  WorkspaceBridgeErrorCode2["IdempotencyRequired"] = "BRIDGE_IDEMPOTENCY_REQUIRED";
+  WorkspaceBridgeErrorCode2["IdempotencyConflict"] = "BRIDGE_IDEMPOTENCY_CONFLICT";
+  WorkspaceBridgeErrorCode2["ReplayRejected"] = "BRIDGE_REPLAY_REJECTED";
+  WorkspaceBridgeErrorCode2["RateLimited"] = "BRIDGE_RATE_LIMITED";
+  WorkspaceBridgeErrorCode2["InvalidToken"] = "BRIDGE_INVALID_TOKEN";
+  WorkspaceBridgeErrorCode2["ExpiredToken"] = "BRIDGE_EXPIRED_TOKEN";
+  WorkspaceBridgeErrorCode2["InvalidRequest"] = "BRIDGE_INVALID_REQUEST";
+  WorkspaceBridgeErrorCode2["UnsupportedRuntime"] = "BRIDGE_UNSUPPORTED_RUNTIME";
+  return WorkspaceBridgeErrorCode2;
+})(WorkspaceBridgeErrorCode || {});
+function createWorkspaceBridgeError(code, message, details) {
+  return details === void 0 ? { code, message } : { code, message, details };
+}
+
+// src/server/workspaceBridge/json.ts
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
+}
+function measureJsonBytes(value) {
+  try {
+    return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+}
+
+// src/server/workspaceBridge/registry.ts
+var RESERVED_WORKSPACE_BRIDGE_OP_PREFIXES = ["workspace-files.v1."];
+var BRIDGE_CALLER_CLASSES = /* @__PURE__ */ new Set(["browser", "runtime", "server"]);
+var BRIDGE_IDEMPOTENCY_POLICIES = /* @__PURE__ */ new Set(["none", "required", "request-id"]);
+function validateWorkspaceBridgeOperationDefinition(definition) {
+  if (!definition || typeof definition !== "object") {
+    throw invalidDefinition("WorkspaceBridge operation definition must be an object");
+  }
+  if (typeof definition.op !== "string" || definition.op.trim().length === 0) {
+    throw invalidDefinition("WorkspaceBridge operation definition op must be a non-empty string");
+  }
+  const reservedPrefix = RESERVED_WORKSPACE_BRIDGE_OP_PREFIXES.find((prefix) => definition.op.startsWith(prefix));
+  if (reservedPrefix) {
+    throw invalidDefinition(`WorkspaceBridge operation ${definition.op} uses reserved prefix ${reservedPrefix}`);
+  }
+  if (!Number.isInteger(definition.version) || definition.version < 1) {
+    throw invalidDefinition(`WorkspaceBridge operation ${definition.op} version must be a positive integer`);
+  }
+  if (typeof definition.owner !== "string" || definition.owner.trim().length === 0) {
+    throw invalidDefinition(`WorkspaceBridge operation ${definition.op} owner must be a non-empty string`);
+  }
+  if (!Array.isArray(definition.callerClassesAllowed) || definition.callerClassesAllowed.length === 0) {
+    throw invalidDefinition(`WorkspaceBridge operation ${definition.op} callerClassesAllowed must be a non-empty array`);
+  }
+  for (const callerClass of definition.callerClassesAllowed) {
+    if (!BRIDGE_CALLER_CLASSES.has(callerClass)) {
+      throw invalidDefinition(`WorkspaceBridge operation ${definition.op} callerClassesAllowed contains invalid caller class`);
+    }
+  }
+  if (!Array.isArray(definition.requiredCapabilities)) {
+    throw invalidDefinition(`WorkspaceBridge operation ${definition.op} requiredCapabilities must be an array`);
+  }
+  if (definition.allowCrossWorkspace !== void 0 && typeof definition.allowCrossWorkspace !== "boolean") {
+    throw invalidDefinition(`WorkspaceBridge operation ${definition.op} allowCrossWorkspace must be a boolean when provided`);
+  }
+  for (const capability of definition.requiredCapabilities) {
+    if (typeof capability !== "string" || capability.trim().length === 0) {
+      throw invalidDefinition(`WorkspaceBridge operation ${definition.op} requiredCapabilities must contain non-empty strings`);
+    }
+  }
+  validateSchemaDefinition(definition.op, "inputSchema", definition.inputSchema, true);
+  validateSchemaDefinition(definition.op, "outputSchema", definition.outputSchema, false);
+  assertPositiveFiniteNumber(definition.op, "timeoutMs", definition.timeoutMs);
+  assertPositiveFiniteNumber(definition.op, "maxInputBytes", definition.maxInputBytes);
+  assertPositiveFiniteNumber(definition.op, "maxOutputBytes", definition.maxOutputBytes);
+  if (!BRIDGE_IDEMPOTENCY_POLICIES.has(definition.idempotencyPolicy)) {
+    throw invalidDefinition(`WorkspaceBridge operation ${definition.op} idempotencyPolicy is invalid`);
+  }
+}
+function validateSchemaDefinition(op, field, schema, required) {
+  if (schema === void 0) {
+    if (required) throw invalidDefinition(`WorkspaceBridge operation ${op} ${field} is required`);
+    return;
+  }
+  if (typeof schema !== "object" && typeof schema !== "function" || schema === null) {
+    throw invalidDefinition(`WorkspaceBridge operation ${op} ${field} must be a schema object`);
+  }
+  if (hasSafeParse(schema)) return;
+  validateJsonSchemaDefinition(schema, `${op} ${field}`);
+}
+var SUPPORTED_JSON_SCHEMA_KEYS = /* @__PURE__ */ new Set(["type", "properties", "required", "items", "enum", "const", "additionalProperties", "description", "title"]);
+function validateJsonSchemaDefinition(schema, label) {
+  if (!isPlainSchemaObject(schema)) {
+    throw invalidDefinition(`WorkspaceBridge operation ${label} must be a schema object`);
+  }
+  for (const key of Object.keys(schema)) {
+    if (!SUPPORTED_JSON_SCHEMA_KEYS.has(key)) {
+      throw invalidDefinition(`WorkspaceBridge operation ${label}.${key} is not supported by the bridge schema subset`);
+    }
+  }
+  if (!isSupportedJsonSchemaType(schema.type)) {
+    throw invalidDefinition(`WorkspaceBridge operation ${label}.type must be a supported JSON schema type`);
+  }
+  if (schema.required !== void 0 && (!Array.isArray(schema.required) || schema.required.some((item) => typeof item !== "string"))) {
+    throw invalidDefinition(`WorkspaceBridge operation ${label}.required must be an array of strings`);
+  }
+  if (schema.required !== void 0 && schema.type !== "object") {
+    throw invalidDefinition(`WorkspaceBridge operation ${label}.required is only supported for object schemas`);
+  }
+  if (schema.enum !== void 0 && !Array.isArray(schema.enum)) {
+    throw invalidDefinition(`WorkspaceBridge operation ${label}.enum must be an array`);
+  }
+  if (schema.additionalProperties !== void 0 && schema.additionalProperties !== false && schema.additionalProperties !== true) {
+    throw invalidDefinition(`WorkspaceBridge operation ${label}.additionalProperties must be boolean when provided`);
+  }
+  if (schema.additionalProperties !== void 0 && schema.type !== "object") {
+    throw invalidDefinition(`WorkspaceBridge operation ${label}.additionalProperties is only supported for object schemas`);
+  }
+  if (schema.properties !== void 0) {
+    if (schema.type !== "object") throw invalidDefinition(`WorkspaceBridge operation ${label}.properties is only supported for object schemas`);
+    if (!isRecord2(schema.properties)) throw invalidDefinition(`WorkspaceBridge operation ${label}.properties must be an object`);
+    for (const [key, child] of Object.entries(schema.properties)) validateJsonSchemaDefinition(child, `${label}.properties.${key}`);
+  }
+  if (schema.items !== void 0) {
+    if (schema.type !== "array") throw invalidDefinition(`WorkspaceBridge operation ${label}.items is only supported for array schemas`);
+    validateJsonSchemaDefinition(schema.items, `${label}.items`);
+  }
+}
+function isSupportedJsonSchemaType(type) {
+  return type === "object" || type === "array" || type === "string" || type === "number" || type === "integer" || type === "boolean" || type === "null";
+}
+function hasSafeParse(schema) {
+  return (typeof schema === "object" || typeof schema === "function") && schema !== null && typeof schema.safeParse === "function";
+}
+function isPlainSchemaObject(value) {
+  return isRecord2(value);
+}
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function hasOwn(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+function assertPositiveFiniteNumber(op, field, value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    throw invalidDefinition(`WorkspaceBridge operation ${op} ${field} must be a positive finite number`);
+  }
+}
+function invalidDefinition(message) {
+  throw createWorkspaceBridgeError("BRIDGE_INVALID_REQUEST" /* InvalidRequest */, message);
+}
+var WorkspaceBridgeRegistry = class {
+  handlers = /* @__PURE__ */ new Map();
+  logger;
+  ownerWorkspaceId;
+  constructor(options = {}) {
+    if (options.ownerWorkspaceId !== void 0 && options.ownerWorkspaceId.trim().length === 0) {
+      throw createWorkspaceBridgeError("BRIDGE_INVALID_REQUEST" /* InvalidRequest */, "WorkspaceBridge registry ownerWorkspaceId must be non-empty when provided");
+    }
+    this.logger = options.logger;
+    this.ownerWorkspaceId = options.ownerWorkspaceId;
+  }
+  registerHandler(definition, handler, options = {}) {
+    validateWorkspaceBridgeOperationDefinition(definition);
+    const existing = this.handlers.get(definition.op);
+    if (existing && !options.replace) {
+      throw createWorkspaceBridgeError(
+        "BRIDGE_DUPLICATE_OP" /* DuplicateOp */,
+        `WorkspaceBridge operation is already registered: ${definition.op}`
+      );
+    }
+    this.handlers.set(definition.op, {
+      definition,
+      handler
+    });
+  }
+  getDefinition(op) {
+    return this.handlers.get(op)?.definition;
+  }
+  listDefinitions() {
+    return Array.from(this.handlers.values(), ({ definition }) => definition);
+  }
+  async call(request, context, options = {}) {
+    const requestId = request.requestId ?? context.requestId ?? createRequestId();
+    const registered = this.handlers.get(request.op);
+    if (!registered) {
+      return this.failure(request.op, requestId, "BRIDGE_OP_NOT_FOUND" /* OpNotFound */, "WorkspaceBridge operation is not registered");
+    }
+    const { definition, handler } = registered;
+    const logBase = {
+      requestId,
+      op: request.op,
+      callerClass: context.callerClass,
+      workspaceId: context.workspaceId,
+      sessionId: context.sessionId,
+      pluginId: context.pluginId,
+      tokenId: context.tokenId,
+      capabilities: context.capabilities,
+      actor: context.actor
+    };
+    if (!definition.callerClassesAllowed.includes(context.callerClass)) {
+      return this.failure(request.op, requestId, "BRIDGE_CALLER_NOT_ALLOWED" /* CallerNotAllowed */, "Caller class is not allowed for operation", logBase);
+    }
+    const expectedWorkspaceId = options.expectedWorkspaceId ?? this.ownerWorkspaceId;
+    if (expectedWorkspaceId && context.workspaceId !== expectedWorkspaceId && definition.allowCrossWorkspace !== true) {
+      return this.failure(request.op, requestId, "BRIDGE_RESOURCE_SCOPE_DENIED" /* ResourceScopeDenied */, "Caller workspace is not authorized for this bridge registry", {
+        ...logBase,
+        expectedWorkspaceId
+      });
+    }
+    const missingCapability = definition.requiredCapabilities.find((capability) => !context.capabilities.includes(capability));
+    if (missingCapability) {
+      return this.failure(request.op, requestId, "BRIDGE_CAPABILITY_DENIED" /* CapabilityDenied */, "Caller is missing a required capability", {
+        ...logBase,
+        missingCapability
+      });
+    }
+    const inputBytes = measureJsonBytes(request.input);
+    if (inputBytes > definition.maxInputBytes) {
+      return this.failure(request.op, requestId, "BRIDGE_INPUT_TOO_LARGE" /* InputTooLarge */, "Bridge input exceeds operation limit", {
+        ...logBase,
+        inputBytes,
+        maxInputBytes: definition.maxInputBytes
+      });
+    }
+    const inputValidation = validateSchema(definition.inputSchema, request.input);
+    if (!inputValidation.success) {
+      return this.failure(request.op, requestId, "BRIDGE_SCHEMA_INVALID" /* SchemaInvalid */, "Bridge input failed schema validation", {
+        ...logBase,
+        schemaMessage: inputValidation.message
+      });
+    }
+    const controller = new AbortController();
+    const abortFromCaller = () => controller.abort(context.signal?.reason);
+    if (context.signal?.aborted) abortFromCaller();
+    else context.signal?.addEventListener("abort", abortFromCaller, { once: true });
+    const timeoutResult = /* @__PURE__ */ Symbol("workspace-bridge-timeout");
+    let timeout;
+    try {
+      this.logger?.debug?.("workspace bridge call started", logBase);
+      const handlerPromise = Promise.resolve().then(() => handler({
+        input: request.input,
+        context: { ...context, requestId },
+        definition,
+        signal: controller.signal,
+        emitUiEffect: context.emitUiEffect
+      }));
+      const timeoutPromise = new Promise((resolve8) => {
+        timeout = setTimeout(() => {
+          controller.abort("timeout");
+          resolve8(timeoutResult);
+        }, definition.timeoutMs);
+      });
+      const output = await Promise.race([handlerPromise, timeoutPromise]);
+      if (output === timeoutResult) {
+        return this.failure(request.op, requestId, "BRIDGE_TIMEOUT" /* Timeout */, "Bridge handler timed out", logBase);
+      }
+      const outputValidation = definition.outputSchema ? validateSchema(definition.outputSchema, output) : { success: true };
+      if (!outputValidation.success) {
+        return this.failure(request.op, requestId, "BRIDGE_OUTPUT_SCHEMA_INVALID" /* OutputSchemaInvalid */, "Bridge output failed schema validation", {
+          ...logBase,
+          schemaMessage: outputValidation.message
+        });
+      }
+      const outputBytes = measureJsonBytes(output);
+      if (outputBytes > definition.maxOutputBytes) {
+        return this.failure(request.op, requestId, "BRIDGE_OUTPUT_TOO_LARGE" /* OutputTooLarge */, "Bridge output exceeds operation limit", {
+          ...logBase,
+          outputBytes,
+          maxOutputBytes: definition.maxOutputBytes
+        });
+      }
+      this.logger?.info?.("workspace bridge call completed", logBase);
+      return { ok: true, op: request.op, requestId, output };
+    } catch (err) {
+      if (controller.signal.aborted && controller.signal.reason === "timeout") {
+        return this.failure(request.op, requestId, "BRIDGE_TIMEOUT" /* Timeout */, "Bridge handler timed out", logBase);
+      }
+      const bridgeError = isWorkspaceBridgeError(err) ? err : void 0;
+      this.logger?.error?.("workspace bridge call failed", {
+        ...logBase,
+        errorName: err instanceof Error ? err.name : typeof err,
+        errorCode: bridgeError?.code
+      });
+      return this.failure(request.op, requestId, bridgeError?.code ?? "BRIDGE_HANDLER_FAILED" /* HandlerFailed */, bridgeError?.message ?? "Bridge handler failed", logBase);
+    } finally {
+      if (timeout) clearTimeout(timeout);
+      context.signal?.removeEventListener("abort", abortFromCaller);
+    }
+  }
+  failure(op, requestId, code, message, logFields) {
+    const error = createWorkspaceBridgeError(code, message);
+    this.logger?.warn?.("workspace bridge call rejected", {
+      ...logFields,
+      op,
+      requestId,
+      errorCode: code
+    });
+    return { ok: false, op, requestId, error };
+  }
+};
+function createWorkspaceBridgeRegistry(options = {}) {
+  return new WorkspaceBridgeRegistry(options);
+}
+var WORKSPACE_BRIDGE_ERROR_CODES = new Set(Object.values(WorkspaceBridgeErrorCode));
+function isWorkspaceBridgeError(err) {
+  if (!err || typeof err !== "object") return false;
+  const candidate = err;
+  return typeof candidate.code === "string" && WORKSPACE_BRIDGE_ERROR_CODES.has(candidate.code) && typeof candidate.message === "string";
+}
+function validateSchema(schema, value) {
+  if (schema === void 0) return { success: true };
+  if (hasSafeParse(schema)) {
+    const result = schema.safeParse(value);
+    return result.success ? { success: true } : { success: false, message: result.error?.message };
+  }
+  if (isPlainSchemaObject(schema)) return validateJsonSchema(schema, value, "$");
+  return { success: false, message: "Unsupported schema" };
+}
+function validateJsonSchema(schema, value, path) {
+  if (schema.const !== void 0 && !jsonEqual(value, schema.const)) {
+    return { success: false, message: `${path}: Expected const value` };
+  }
+  if (Array.isArray(schema.enum) && !schema.enum.some((candidate) => jsonEqual(value, candidate))) {
+    return { success: false, message: `${path}: Expected one of enum values` };
+  }
+  const typeValidation = validateJsonSchemaType(schema.type, value, path);
+  if (!typeValidation.success) return typeValidation;
+  if (schema.type === "object") {
+    if (!isRecord2(value)) return { success: false, message: `${path}: Expected object` };
+    const properties = isRecord2(schema.properties) ? schema.properties : {};
+    const required = Array.isArray(schema.required) ? schema.required.filter((item) => typeof item === "string") : [];
+    for (const key of required) {
+      if (!hasOwn(value, key)) return { success: false, message: `${path}.${key}: Required property missing` };
+    }
+    if (schema.additionalProperties === false) {
+      for (const key of Object.keys(value)) {
+        if (!hasOwn(properties, key)) return { success: false, message: `${path}.${key}: Additional properties are not allowed` };
+      }
+    }
+    for (const [key, child] of Object.entries(properties)) {
+      if (hasOwn(value, key)) {
+        const childResult = validateJsonSchema(child, value[key], `${path}.${key}`);
+        if (!childResult.success) return childResult;
+      }
+    }
+  }
+  if (schema.type === "array" && schema.items !== void 0) {
+    if (!Array.isArray(value)) return { success: false, message: `${path}: Expected array` };
+    for (let i = 0; i < value.length; i += 1) {
+      const childResult = validateJsonSchema(schema.items, value[i], `${path}[${i}]`);
+      if (!childResult.success) return childResult;
+    }
+  }
+  return { success: true };
+}
+function validateJsonSchemaType(type, value, path) {
+  switch (type) {
+    case "object":
+      return isRecord2(value) ? { success: true } : { success: false, message: `${path}: Expected object` };
+    case "array":
+      return Array.isArray(value) ? { success: true } : { success: false, message: `${path}: Expected array` };
+    case "string":
+      return typeof value === "string" ? { success: true } : { success: false, message: `${path}: Expected string` };
+    case "number":
+      return typeof value === "number" && Number.isFinite(value) ? { success: true } : { success: false, message: `${path}: Expected number` };
+    case "integer":
+      return Number.isInteger(value) ? { success: true } : { success: false, message: `${path}: Expected integer` };
+    case "boolean":
+      return typeof value === "boolean" ? { success: true } : { success: false, message: `${path}: Expected boolean` };
+    case "null":
+      return value === null ? { success: true } : { success: false, message: `${path}: Expected null` };
+    default:
+      return { success: false, message: `${path}: Unsupported schema type` };
+  }
+}
+function jsonEqual(a, b) {
+  return stableStringify(a) === stableStringify(b);
+}
+function createRequestId() {
+  return `bridge_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
 // src/server/plugins/piPackages.ts
 import {
   compactPiPackages,
@@ -739,6 +1139,26 @@ function validatePluginAssets(pluginId, assets) {
     }
   }
 }
+function validateWorkspaceBridgeHandlers(pluginId, handlers) {
+  for (let i = 0; i < handlers.length; i++) {
+    const entry = handlers[i];
+    if (!entry || typeof entry !== "object") {
+      fail(pluginId, `workspaceBridgeHandlers[${i}] must be an object`);
+    }
+    if (!entry.definition || typeof entry.definition !== "object") {
+      fail(pluginId, `workspaceBridgeHandlers[${i}].definition must be an object`);
+    }
+    try {
+      validateWorkspaceBridgeOperationDefinition(entry.definition);
+    } catch (error) {
+      const message = error && typeof error === "object" && "message" in error ? String(error.message) : "invalid WorkspaceBridge operation definition";
+      fail(pluginId, `workspaceBridgeHandlers[${i}].definition invalid: ${message}`);
+    }
+    if (typeof entry.handler !== "function") {
+      fail(pluginId, `workspaceBridgeHandlers[${i}].handler must be a function`);
+    }
+  }
+}
 function validateProvisioning(pluginId, provisioning) {
   if (!provisioning || typeof provisioning !== "object") {
     fail(pluginId, "provisioning must be an object");
@@ -858,6 +1278,12 @@ function validateServerPlugin(plugin) {
     }
     validatePluginAssets(plugin.id, plugin.assets);
   }
+  if (plugin.workspaceBridgeHandlers !== void 0) {
+    if (!Array.isArray(plugin.workspaceBridgeHandlers)) {
+      fail(plugin.id, "workspaceBridgeHandlers must be an array when provided");
+    }
+    validateWorkspaceBridgeHandlers(plugin.id, plugin.workspaceBridgeHandlers);
+  }
   if (plugin.routes !== void 0 && typeof plugin.routes !== "function") {
     fail(plugin.id, "routes must be a Fastify plugin function when provided");
   }
@@ -902,6 +1328,7 @@ function bootstrapServer(options) {
     ...plugin.provisioning ? { provisioning: plugin.provisioning } : {}
   }));
   const routeContributions = finalPlugins.filter((p) => p.routes).map((p) => ({ id: p.id, routes: p.routes }));
+  const workspaceBridgeHandlers = finalPlugins.flatMap((p) => p.workspaceBridgeHandlers ?? []);
   const preservedUiStateKeys = [...new Set(finalPlugins.flatMap((p) => p.preservedUiStateKeys ?? []))];
   return {
     registered: finalPlugins.map((p) => p.id),
@@ -912,6 +1339,7 @@ function bootstrapServer(options) {
     runtimePlugins,
     provisioningContributions,
     routeContributions,
+    workspaceBridgeHandlers,
     preservedUiStateKeys
   };
 }
@@ -1886,6 +2314,18 @@ async function resolveDirServerPlugin(entry, ctx) {
 function isDirEntry(entry) {
   return typeof entry === "object" && entry !== null && "dir" in entry;
 }
+function isTrustedWorkspaceBridgeHandlerEntry(entry) {
+  if (!isDirEntry(entry)) return true;
+  return entry.trust === "internal";
+}
+function assertWorkspaceBridgeHandlersTrusted(plugin, entry) {
+  if ((plugin.workspaceBridgeHandlers?.length ?? 0) === 0) return;
+  if (isTrustedWorkspaceBridgeHandlerEntry(entry)) return;
+  const label = isDirEntry(entry) ? resolve5(entry.dir) : plugin.id;
+  throw new Error(
+    `server plugin "${plugin.id}" from ${label} declares workspaceBridgeHandlers, but host bridge handlers are only allowed for pre-built host plugins or directory entries marked trust: "internal"`
+  );
+}
 async function resolveOnePluginEntry(entry, ctx) {
   if (isDirEntry(entry)) return await resolveDirServerPlugin(entry, ctx);
   return entry;
@@ -1964,6 +2404,16 @@ function createInMemoryBridge() {
       pendingCommands.splice(0, pendingCommands.length - MAX_PENDING_COMMANDS);
     }
   }
+  async function dispatchCommand(cmd) {
+    const seq = nextSeq++;
+    const annotated = { ...cmd, seq };
+    let delivered = false;
+    for (const handler of subscribers) {
+      if (handler(annotated) !== false) delivered = true;
+    }
+    if (!delivered) enqueuePending(annotated);
+    return { seq, status: "ok" };
+  }
   return {
     async getState() {
       return state;
@@ -1972,14 +2422,10 @@ function createInMemoryBridge() {
       state = s;
     },
     async postCommand(cmd) {
-      const seq = nextSeq++;
-      const annotated = { ...cmd, seq };
-      let delivered = false;
-      for (const handler of subscribers) {
-        if (handler(annotated) !== false) delivered = true;
-      }
-      if (!delivered) enqueuePending(annotated);
-      return { seq, status: "ok" };
+      return dispatchCommand(cmd);
+    },
+    async emitUiEffect(cmd) {
+      return dispatchCommand(cmd);
     },
     subscribeCommands(handler) {
       subscribers.add(handler);
@@ -2068,7 +2514,7 @@ async function validateExistingPath(workspaceRoot, relPath) {
     };
   }
 }
-function createGetUiStateTool(uiBridge) {
+function createGetUiStateTool(workspaceBridge) {
   return {
     name: "get_ui_state",
     readinessRequirements: ["ui-bridge"],
@@ -2094,7 +2540,7 @@ function createGetUiStateTool(uiBridge) {
     },
     async execute() {
       try {
-        const state = await uiBridge.getState();
+        const state = await workspaceBridge.getState();
         return {
           content: [{ type: "text", text: JSON.stringify(state ?? {}) }],
           details: state
@@ -2124,7 +2570,7 @@ function isVerified(kind, params, state) {
   }
   return true;
 }
-function createExecUiTool(uiBridge, opts = {}) {
+function createExecUiTool(workspaceBridge, opts = {}) {
   const { workspaceRoot, resolvePathKind } = opts;
   const verifyDelayMs = opts.verifyDelayMs ?? 250;
   const verifyRetries = opts.verifyRetries ?? 20;
@@ -2281,7 +2727,7 @@ function createExecUiTool(uiBridge, opts = {}) {
       }
       try {
         const command = { kind: effectiveKind, params: cmdParams };
-        const result = await uiBridge.postCommand(command);
+        const result = await workspaceBridge.emitUiEffect(command);
         if (result.status === "error") {
           return {
             content: [{ type: "text", text: JSON.stringify(result) }],
@@ -2291,11 +2737,11 @@ function createExecUiTool(uiBridge, opts = {}) {
         }
         if (verifyDelayMs > 0 && VERIFIABLE_KINDS.has(effectiveKind)) {
           await new Promise((r) => setTimeout(r, verifyDelayMs));
-          let uiState = await uiBridge.getState();
+          let uiState = await workspaceBridge.getState();
           for (let i = 0; i < verifyRetries; i++) {
             if (uiState === null || isVerified(effectiveKind, cmdParams, uiState)) break;
             await new Promise((r) => setTimeout(r, verifyIntervalMs));
-            uiState = await uiBridge.getState();
+            uiState = await workspaceBridge.getState();
           }
           const combined = { ...result, uiState };
           return {
@@ -2314,8 +2760,8 @@ function createExecUiTool(uiBridge, opts = {}) {
     }
   };
 }
-function createWorkspaceUiTools(uiBridge, opts = {}) {
-  return [createGetUiStateTool(uiBridge), createExecUiTool(uiBridge, opts)];
+function createWorkspaceUiTools(workspaceBridge, opts = {}) {
+  return [createGetUiStateTool(workspaceBridge), createExecUiTool(workspaceBridge, opts)];
 }
 
 // src/server/ui-control/http/uiRoutes.ts
@@ -2611,6 +3057,728 @@ data: ${JSON.stringify({ v: UI_BRIDGE_PROTOCOL_VERSION })}
   done();
 }
 
+// src/server/workspaceBridge/authPolicy.ts
+function createLocalCliBridgeAuthPolicy(options) {
+  return {
+    resolve(input) {
+      if (input.callerClass !== "browser") {
+        throw createWorkspaceBridgeError(
+          "BRIDGE_CALLER_NOT_ALLOWED" /* CallerNotAllowed */,
+          "Local CLI auth policy only accepts browser callers"
+        );
+      }
+      ensureCallerAllowed(input.definition, "browser");
+      if (input.workspaceId !== options.workspaceId) {
+        throw createWorkspaceBridgeError(
+          "BRIDGE_RESOURCE_SCOPE_DENIED" /* ResourceScopeDenied */,
+          "Local CLI bridge caller is not authorized for workspace"
+        );
+      }
+      const capabilities = options.capabilities ?? input.definition.requiredCapabilities;
+      ensureCapabilities(capabilities, input.requiredCapabilities ?? input.definition.requiredCapabilities);
+      const context = makeContext({
+        callerClass: "browser",
+        workspaceId: input.workspaceId,
+        sessionId: input.sessionId,
+        pluginId: input.pluginId,
+        capabilities,
+        actor: { actorKind: "human", performedBy: { label: "local-cli:user" } }
+      });
+      return {
+        context,
+        effectiveCapabilities: capabilities,
+        principal: { userId: "local-cli" },
+        resourceScope: { workspaceId: input.workspaceId, sessionId: input.sessionId }
+      };
+    }
+  };
+}
+function ensureCallerAllowed(definition, callerClass) {
+  if (!definition.callerClassesAllowed.includes(callerClass)) {
+    throw createWorkspaceBridgeError(
+      "BRIDGE_CALLER_NOT_ALLOWED" /* CallerNotAllowed */,
+      "Bridge caller class is not allowed for operation"
+    );
+  }
+}
+function ensureCapabilities(actual, required) {
+  const missing = required.find((capability) => !actual.includes(capability));
+  if (missing) {
+    throw createWorkspaceBridgeError(
+      "BRIDGE_CAPABILITY_DENIED" /* CapabilityDenied */,
+      "Bridge caller is missing a required capability"
+    );
+  }
+}
+function makeContext(context) {
+  return {
+    ...context,
+    capabilities: [...context.capabilities],
+    actor: sanitizeActor(context.actor)
+  };
+}
+function sanitizeActor(actor) {
+  return {
+    actorKind: actor.actorKind,
+    performedBy: actor.performedBy ? { label: actor.performedBy.label, id: actor.performedBy.id } : void 0,
+    onBehalfOf: actor.onBehalfOf ? { label: actor.onBehalfOf.label, id: actor.onBehalfOf.id } : void 0
+  };
+}
+
+// src/server/workspaceBridge/httpRoutes.ts
+import { z as z3 } from "zod";
+
+// src/server/workspaceBridge/idempotency.ts
+import { createHash as createHash2 } from "crypto";
+var InMemoryWorkspaceBridgeIdempotencyStore = class {
+  records = /* @__PURE__ */ new Map();
+  lastGcMs = 0;
+  async begin(options) {
+    const prepared = prepareIdempotency(options);
+    if ("error" in prepared) return { action: "reject", error: prepared.error };
+    const nowMs = options.nowMs ?? Date.now();
+    if (nowMs - this.lastGcMs >= DEFAULT_IDEMPOTENCY_GC_INTERVAL_MS) {
+      await this.gc(nowMs);
+      this.lastGcMs = nowMs;
+    }
+    const existing = this.records.get(prepared.scopeKey);
+    if (existing && Date.parse(existing.expiresAt) > nowMs) {
+      if (existing.inputHash !== prepared.inputHash) {
+        return { action: "reject", error: replayRejectedError() };
+      }
+      return { action: "replay", record: existing };
+    }
+    this.records.set(prepared.scopeKey, createPendingRecord(prepared.scopeKey, prepared.inputHash, nowMs, options.ttlMs));
+    return { action: "execute", scopeKey: prepared.scopeKey, inputHash: prepared.inputHash };
+  }
+  async complete(options) {
+    const existing = this.records.get(options.scopeKey);
+    if (!existing || existing.inputHash !== options.inputHash) return;
+    const nowMs = options.nowMs ?? Date.now();
+    this.records.set(options.scopeKey, {
+      ...existing,
+      // Only successful responses are completed; failures release the key
+      // (see runWithWorkspaceBridgeIdempotency), so there is no "failed" record.
+      status: "completed",
+      response: options.response,
+      updatedAt: new Date(nowMs).toISOString(),
+      expiresAt: new Date(nowMs + (options.ttlMs ?? DEFAULT_IDEMPOTENCY_TTL_MS)).toISOString()
+    });
+  }
+  async release(scopeKey, inputHash) {
+    const existing = this.records.get(scopeKey);
+    if (existing && existing.inputHash === inputHash) this.records.delete(scopeKey);
+  }
+  async gc(nowMs = Date.now()) {
+    let removed = 0;
+    for (const [key, record] of this.records) {
+      if (Date.parse(record.expiresAt) <= nowMs) {
+        this.records.delete(key);
+        removed++;
+      }
+    }
+    return removed;
+  }
+};
+async function runWithWorkspaceBridgeIdempotency(store, options, execute) {
+  if (options.definition.idempotencyPolicy === "none") return await execute();
+  if (!store) {
+    return {
+      ok: false,
+      op: options.definition.op,
+      requestId: options.request.requestId,
+      error: createWorkspaceBridgeError(
+        "BRIDGE_UNSUPPORTED_RUNTIME" /* UnsupportedRuntime */,
+        "WorkspaceBridge mutation requires an atomic idempotency store"
+      )
+    };
+  }
+  const begin = await store.begin(options);
+  if (begin.action === "reject") {
+    return { ok: false, op: options.definition.op, requestId: options.request.requestId, error: begin.error };
+  }
+  if (begin.action === "replay") {
+    return begin.record.response ?? {
+      ok: false,
+      op: options.definition.op,
+      requestId: options.request.requestId,
+      error: createWorkspaceBridgeError(
+        "BRIDGE_IDEMPOTENCY_CONFLICT" /* IdempotencyConflict */,
+        "WorkspaceBridge idempotency key is already pending"
+      )
+    };
+  }
+  const response = await execute();
+  if (response.ok) {
+    await store.complete({
+      scopeKey: begin.scopeKey,
+      inputHash: begin.inputHash,
+      response,
+      nowMs: options.nowMs,
+      ttlMs: options.ttlMs
+    });
+  } else if (response.error.code !== "BRIDGE_TIMEOUT" /* Timeout */) {
+    await store.release(begin.scopeKey, begin.inputHash);
+  }
+  return response;
+}
+var DEFAULT_IDEMPOTENCY_TTL_MS = 15 * 6e4;
+var DEFAULT_IDEMPOTENCY_GC_INTERVAL_MS = 6e4;
+function prepareIdempotency(options) {
+  const key = semanticKey(options);
+  if (!key) {
+    return {
+      error: createWorkspaceBridgeError(
+        "BRIDGE_IDEMPOTENCY_REQUIRED" /* IdempotencyRequired */,
+        "WorkspaceBridge operation requires an idempotency key"
+      )
+    };
+  }
+  return {
+    scopeKey: stableStringify({
+      workspaceId: options.auth.workspaceId,
+      sessionId: options.auth.sessionId,
+      pluginId: options.auth.pluginId,
+      op: options.definition.op,
+      key
+    }),
+    inputHash: hashNormalizedInput(options.request.input)
+  };
+}
+function semanticKey(options) {
+  if (options.definition.idempotencyPolicy === "none") return "none";
+  if (options.definition.idempotencyPolicy === "required") return options.request.idempotencyKey;
+  if (options.definition.idempotencyPolicy === "request-id") return options.request.requestId ?? options.request.idempotencyKey;
+  return void 0;
+}
+function hashNormalizedInput(input) {
+  return hashString(stableStringify(input));
+}
+function createPendingRecord(scopeKey, inputHash, nowMs, ttlMs = DEFAULT_IDEMPOTENCY_TTL_MS) {
+  const now = new Date(nowMs).toISOString();
+  return {
+    scopeKey,
+    inputHash,
+    status: "pending",
+    createdAt: now,
+    updatedAt: now,
+    expiresAt: new Date(nowMs + ttlMs).toISOString()
+  };
+}
+function replayRejectedError() {
+  return createWorkspaceBridgeError(
+    "BRIDGE_REPLAY_REJECTED" /* ReplayRejected */,
+    "WorkspaceBridge idempotency key was reused with a different payload"
+  );
+}
+function hashString(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+
+// src/server/workspaceBridge/runtimeToken.ts
+import { createHmac, randomUUID, timingSafeEqual } from "crypto";
+var WORKSPACE_BRIDGE_TOKEN_AUDIENCE = "workspace-bridge";
+var WORKSPACE_BRIDGE_REFRESH_TOKEN_AUDIENCE = "workspace-bridge-refresh";
+var DEFAULT_WORKSPACE_BRIDGE_RUNTIME_TOKEN_TTL_MS = 5 * 6e4;
+var DEFAULT_WORKSPACE_BRIDGE_RUNTIME_REFRESH_TOKEN_TTL_MS = 60 * 6e4;
+var MAX_WORKSPACE_BRIDGE_RUNTIME_TOKEN_TTL_MS = 15 * 6e4;
+function mintWorkspaceBridgeRuntimeToken(options) {
+  return mintWorkspaceBridgeToken({
+    ...options,
+    audience: WORKSPACE_BRIDGE_TOKEN_AUDIENCE,
+    ttlMs: options.ttlMs ?? DEFAULT_WORKSPACE_BRIDGE_RUNTIME_TOKEN_TTL_MS
+  });
+}
+function mintWorkspaceBridgeRuntimeRefreshToken(options) {
+  return mintWorkspaceBridgeToken({
+    ...options,
+    audience: WORKSPACE_BRIDGE_REFRESH_TOKEN_AUDIENCE,
+    // Refresh tokens intentionally outlive short call tokens, but remain
+    // sandbox-bound by workspace/session/runtime/capabilities claims.
+    ttlMs: options.ttlMs ?? DEFAULT_WORKSPACE_BRIDGE_RUNTIME_REFRESH_TOKEN_TTL_MS,
+    tokenTtlMs: clampWorkspaceBridgeRuntimeTokenTtlMs(options.tokenTtlMs)
+  });
+}
+function verifyWorkspaceBridgeRuntimeToken(token, options) {
+  assertUsableSecret(options.secret);
+  const claims = parseAndVerifyToken(token, options.secret);
+  const now = Math.floor((options.nowMs ?? Date.now()) / 1e3);
+  ensureLiveTokenClaims(claims, now, WORKSPACE_BRIDGE_TOKEN_AUDIENCE, "Runtime bridge token");
+  const missingCapability = (options.requiredCapabilities ?? []).find(
+    (capability) => !claims.capabilities.includes(capability)
+  );
+  if (missingCapability) {
+    throw bridgeTokenError("BRIDGE_CAPABILITY_DENIED" /* CapabilityDenied */, "Runtime bridge token is missing a required capability");
+  }
+  const runtimeClaims = claims;
+  return {
+    claims: runtimeClaims,
+    authContext: runtimeClaimsToBridgeAuthContext(runtimeClaims)
+  };
+}
+function verifyWorkspaceBridgeRuntimeRefreshToken(token, options) {
+  assertUsableSecret(options.secret);
+  const claims = parseAndVerifyToken(token, options.secret);
+  const now = Math.floor((options.nowMs ?? Date.now()) / 1e3);
+  ensureLiveTokenClaims(claims, now, WORKSPACE_BRIDGE_REFRESH_TOKEN_AUDIENCE, "Runtime bridge refresh token");
+  return { claims };
+}
+function clampWorkspaceBridgeRuntimeTokenTtlMs(ttlMs) {
+  if (ttlMs === void 0) return void 0;
+  if (!Number.isFinite(ttlMs) || ttlMs <= 0) return void 0;
+  return Math.min(ttlMs, MAX_WORKSPACE_BRIDGE_RUNTIME_TOKEN_TTL_MS);
+}
+function runtimeClaimsToBridgeAuthContext(claims) {
+  return {
+    callerClass: "runtime",
+    workspaceId: claims.workspaceId,
+    sessionId: claims.sessionId,
+    capabilities: claims.capabilities,
+    tokenId: claims.jti,
+    expiresAt: new Date(claims.exp * 1e3).toISOString(),
+    actor: {
+      actorKind: "agent",
+      performedBy: {
+        label: claims.runtimeId ? `runtime:${claims.runtimeId}` : "runtime:agent",
+        id: claims.runtimeId
+      },
+      onBehalfOf: claims.sessionId ? { label: `session:${claims.sessionId}` } : void 0
+    }
+  };
+}
+function mintWorkspaceBridgeToken(options) {
+  assertUsableSecret(options.secret);
+  const nowMs = options.nowMs ?? Date.now();
+  const claims = {
+    aud: options.audience,
+    workspaceId: options.workspaceId,
+    sessionId: options.sessionId,
+    runtimeId: options.runtimeId,
+    capabilities: [...options.capabilities],
+    iat: Math.floor(nowMs / 1e3),
+    exp: Math.floor((nowMs + options.ttlMs) / 1e3),
+    jti: options.jti ?? randomUUID(),
+    ...options.tokenTtlMs !== void 0 ? { tokenTtlMs: options.tokenTtlMs } : {}
+  };
+  return signClaims(claims, options.secret);
+}
+function ensureLiveTokenClaims(claims, now, expectedAudience, label) {
+  if (claims.aud !== expectedAudience) {
+    throw bridgeTokenError("BRIDGE_INVALID_TOKEN" /* InvalidToken */, `${label} has invalid audience`);
+  }
+  if (claims.exp <= now) {
+    throw bridgeTokenError("BRIDGE_EXPIRED_TOKEN" /* ExpiredToken */, `${label} has expired`);
+  }
+  if (claims.iat > now + 60) {
+    throw bridgeTokenError("BRIDGE_INVALID_TOKEN" /* InvalidToken */, `${label} is not valid yet`);
+  }
+}
+function signClaims(claims, secret) {
+  const header = { alg: "HS256", typ: "JWT" };
+  const encodedHeader = base64UrlEncode(JSON.stringify(header));
+  const encodedPayload = base64UrlEncode(JSON.stringify(claims));
+  const signingInput = `${encodedHeader}.${encodedPayload}`;
+  return `${signingInput}.${hmac(signingInput, secret)}`;
+}
+function parseAndVerifyToken(token, secret) {
+  const parts = token.split(".");
+  if (parts.length !== 3 || parts.some((part) => part.length === 0)) {
+    throw bridgeTokenError("BRIDGE_INVALID_TOKEN" /* InvalidToken */, "Runtime bridge token is malformed");
+  }
+  const [headerPart, payloadPart, signature] = parts;
+  const signingInput = `${headerPart}.${payloadPart}`;
+  const expected = hmac(signingInput, secret);
+  if (!safeEqual(signature, expected)) {
+    throw bridgeTokenError("BRIDGE_INVALID_TOKEN" /* InvalidToken */, "Runtime bridge token signature is invalid");
+  }
+  let header;
+  let payload;
+  try {
+    header = JSON.parse(base64UrlDecode(headerPart));
+    payload = JSON.parse(base64UrlDecode(payloadPart));
+  } catch {
+    throw bridgeTokenError("BRIDGE_INVALID_TOKEN" /* InvalidToken */, "Runtime bridge token payload is invalid");
+  }
+  if (!header || typeof header !== "object" || header.alg !== "HS256") {
+    throw bridgeTokenError("BRIDGE_INVALID_TOKEN" /* InvalidToken */, "Runtime bridge token algorithm is invalid");
+  }
+  return parseClaims(payload);
+}
+function parseClaims(payload) {
+  if (!payload || typeof payload !== "object") {
+    throw bridgeTokenError("BRIDGE_INVALID_TOKEN" /* InvalidToken */, "Runtime bridge token claims are invalid");
+  }
+  const claims = payload;
+  if (typeof claims.aud !== "string" || typeof claims.workspaceId !== "string" || !Array.isArray(claims.capabilities) || !claims.capabilities.every((capability) => typeof capability === "string") || typeof claims.iat !== "number" || typeof claims.exp !== "number" || typeof claims.jti !== "string") {
+    throw bridgeTokenError("BRIDGE_INVALID_TOKEN" /* InvalidToken */, "Runtime bridge token claims are invalid");
+  }
+  if (claims.tokenTtlMs !== void 0 && (typeof claims.tokenTtlMs !== "number" || !Number.isFinite(claims.tokenTtlMs) || claims.tokenTtlMs <= 0)) {
+    throw bridgeTokenError("BRIDGE_INVALID_TOKEN" /* InvalidToken */, "Runtime bridge token claims are invalid");
+  }
+  return {
+    aud: claims.aud,
+    workspaceId: claims.workspaceId,
+    sessionId: optionalString(claims.sessionId),
+    runtimeId: optionalString(claims.runtimeId),
+    capabilities: [...claims.capabilities],
+    iat: claims.iat,
+    exp: claims.exp,
+    jti: claims.jti,
+    ...typeof claims.tokenTtlMs === "number" ? { tokenTtlMs: clampWorkspaceBridgeRuntimeTokenTtlMs(claims.tokenTtlMs) } : {}
+  };
+}
+function bridgeTokenError(code, message) {
+  return createWorkspaceBridgeError(code, message);
+}
+function assertUsableSecret(secret) {
+  if (secret.length < 32) {
+    throw bridgeTokenError("BRIDGE_INVALID_TOKEN" /* InvalidToken */, "Runtime bridge token secret is too short");
+  }
+}
+function hmac(value, secret) {
+  return createHmac("sha256", secret).update(value).digest("base64url");
+}
+function safeEqual(actual, expected) {
+  const actualBuffer = Buffer.from(actual);
+  const expectedBuffer = Buffer.from(expected);
+  return actualBuffer.length === expectedBuffer.length && timingSafeEqual(actualBuffer, expectedBuffer);
+}
+function base64UrlEncode(value) {
+  return Buffer.from(value).toString("base64url");
+}
+function base64UrlDecode(value) {
+  return Buffer.from(value, "base64url").toString("utf8");
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+
+// src/server/workspaceBridge/refreshTokenStore.ts
+var InMemoryWorkspaceBridgeRuntimeRefreshTokenStore = class {
+  revoked = /* @__PURE__ */ new Map();
+  rateLimits = /* @__PURE__ */ new Map();
+  lastGcMs = 0;
+  revoke(jti, expiresAtMs) {
+    this.gc();
+    this.revoked.set(jti, expiresAtMs);
+    this.rateLimits.delete(jti);
+  }
+  recordUse(options) {
+    const nowMs = options.nowMs ?? Date.now();
+    this.gc(nowMs);
+    if (this.revoked.has(options.jti)) return { allowed: false, reason: "revoked" };
+    if (options.maxUses <= 0) return { allowed: false, reason: "rate-limited", retryAfterMs: options.windowMs };
+    const existing = this.rateLimits.get(options.jti);
+    if (!existing || nowMs - existing.windowStartMs >= existing.windowMs || isExpired(existing.expiresAtMs, nowMs)) {
+      this.rateLimits.set(options.jti, {
+        windowStartMs: nowMs,
+        windowMs: options.windowMs,
+        count: 1,
+        expiresAtMs: options.expiresAtMs
+      });
+      return { allowed: true };
+    }
+    if (existing.count >= options.maxUses) {
+      return { allowed: false, reason: "rate-limited", retryAfterMs: Math.max(0, existing.windowStartMs + existing.windowMs - nowMs) };
+    }
+    existing.count += 1;
+    existing.windowMs = options.windowMs;
+    existing.expiresAtMs = options.expiresAtMs ?? existing.expiresAtMs;
+    return { allowed: true };
+  }
+  gc(nowMs = Date.now()) {
+    if (nowMs - this.lastGcMs < 6e4) return 0;
+    this.lastGcMs = nowMs;
+    let removed = 0;
+    for (const [jti, record] of this.rateLimits) {
+      if (isExpired(record.expiresAtMs, nowMs) || nowMs - record.windowStartMs >= record.windowMs) {
+        this.rateLimits.delete(jti);
+        removed += 1;
+      }
+    }
+    for (const [jti, expiresAtMs] of this.revoked) {
+      if (isExpired(expiresAtMs, nowMs)) {
+        this.revoked.delete(jti);
+        removed += 1;
+      }
+    }
+    return removed;
+  }
+};
+function isExpired(expiresAtMs, nowMs) {
+  return expiresAtMs !== void 0 && expiresAtMs <= nowMs;
+}
+
+// src/server/workspaceBridge/httpRoutes.ts
+var bridgeCallBodySchema = z3.object({
+  op: z3.string().min(1),
+  input: z3.unknown().default({}),
+  requestId: z3.string().optional(),
+  idempotencyKey: z3.string().optional()
+});
+var DEFAULT_REFRESH_TOKEN_RATE_LIMIT_MAX_USES = 30;
+var DEFAULT_REFRESH_TOKEN_RATE_LIMIT_WINDOW_MS = 6e4;
+function workspaceBridgeHttpRoutes(app, opts, done) {
+  const defaultRefreshTokenStore = opts.runtimeRefreshTokenStore ?? new InMemoryWorkspaceBridgeRuntimeRefreshTokenStore();
+  app.post("/api/v1/workspace-bridge/call", async (request, reply) => {
+    reply.header("Cache-Control", "no-store");
+    const contentType = String(request.headers["content-type"] ?? "");
+    if (!contentType.toLowerCase().startsWith("application/json")) {
+      return sendBridgeError(reply, 415, void 0, "BRIDGE_INVALID_REQUEST" /* InvalidRequest */, "WorkspaceBridge transport requires application/json");
+    }
+    const rawBodySize = measureJsonBytes(request.body);
+    if (opts.maxBodyBytes && rawBodySize > opts.maxBodyBytes) {
+      return sendBridgeError(reply, 413, void 0, "BRIDGE_INPUT_TOO_LARGE" /* InputTooLarge */, "WorkspaceBridge request body is too large");
+    }
+    const parsed = bridgeCallBodySchema.safeParse(request.body);
+    if (!parsed.success) {
+      return sendBridgeError(reply, 400, void 0, "BRIDGE_SCHEMA_INVALID" /* SchemaInvalid */, "WorkspaceBridge request body is invalid");
+    }
+    const body = { ...parsed.data, input: parsed.data.input ?? {} };
+    try {
+      const registry = await resolveRegistry(request, body, opts);
+      const definition = registry.getDefinition(body.op);
+      if (!definition) {
+        return sendBridgeError(reply, statusForBridgeError("BRIDGE_OP_NOT_FOUND" /* OpNotFound */), body.requestId, "BRIDGE_OP_NOT_FOUND" /* OpNotFound */, "WorkspaceBridge operation is not registered");
+      }
+      const authHeader = firstHeader(request.headers.authorization);
+      const authContext = authHeader?.startsWith("Bearer ") ? resolveRuntimeContext(authHeader.slice("Bearer ".length), opts, definition) : await resolveBrowserContext(request, opts, definition, body);
+      const idempotencyStore = opts.getIdempotencyStore ? await opts.getIdempotencyStore(request, body) : opts.idempotencyStore;
+      const expectedWorkspaceId = opts.getOwnerWorkspaceId ? await opts.getOwnerWorkspaceId(request, body, authContext) : opts.ownerWorkspaceId;
+      const response = await runWithWorkspaceBridgeIdempotency(idempotencyStore, {
+        definition,
+        request: body,
+        auth: authContext
+      }, async () => await registry.call(body, authContext, { expectedWorkspaceId }));
+      return await sendResponse(reply, response);
+    } catch (err) {
+      const bridgeError = isBridgeError(err) ? err : createWorkspaceBridgeError("BRIDGE_HANDLER_FAILED" /* HandlerFailed */, "WorkspaceBridge transport failed");
+      return sendBridgeError(reply, statusForBridgeError(bridgeError.code), body.requestId, bridgeError.code, bridgeError.message);
+    }
+  });
+  app.post("/api/v1/workspace-bridge/token", async (request, reply) => {
+    reply.header("Cache-Control", "no-store");
+    const authHeader = firstHeader(request.headers.authorization);
+    if (!authHeader?.startsWith("Bearer ")) {
+      return sendBridgeError(reply, 401, void 0, "BRIDGE_AUTH_REQUIRED" /* AuthRequired */, "WorkspaceBridge refresh token is required");
+    }
+    if (!opts.runtimeTokenSecret || !opts.runtimeRefreshTokenSecret) {
+      return sendBridgeError(reply, 401, void 0, "BRIDGE_AUTH_REQUIRED" /* AuthRequired */, "WorkspaceBridge token refresh is not configured");
+    }
+    try {
+      const nowMs = Date.now();
+      const verified = verifyWorkspaceBridgeRuntimeRefreshToken(authHeader.slice("Bearer ".length), {
+        secret: opts.runtimeRefreshTokenSecret,
+        nowMs
+      });
+      const store = opts.getRuntimeRefreshTokenStore ? await opts.getRuntimeRefreshTokenStore(request, verified.claims) ?? defaultRefreshTokenStore : defaultRefreshTokenStore;
+      const refreshUse = await store.recordUse({
+        jti: verified.claims.jti,
+        nowMs,
+        maxUses: opts.refreshTokenRateLimit?.maxUses ?? DEFAULT_REFRESH_TOKEN_RATE_LIMIT_MAX_USES,
+        windowMs: opts.refreshTokenRateLimit?.windowMs ?? DEFAULT_REFRESH_TOKEN_RATE_LIMIT_WINDOW_MS,
+        expiresAtMs: verified.claims.exp * 1e3
+      });
+      if (!refreshUse.allowed) {
+        if (refreshUse.reason === "revoked") {
+          return sendBridgeError(reply, 401, void 0, "BRIDGE_INVALID_TOKEN" /* InvalidToken */, "WorkspaceBridge refresh token is revoked");
+        }
+        reply.header("Retry-After", Math.ceil(refreshUse.retryAfterMs / 1e3).toString());
+        return sendBridgeError(reply, 429, void 0, "BRIDGE_RATE_LIMITED" /* RateLimited */, "WorkspaceBridge refresh token rate limit exceeded");
+      }
+      const ttlMs = refreshMintTtlMs(verified.claims, Date.now());
+      if (ttlMs === void 0) {
+        return sendBridgeError(reply, 401, void 0, "BRIDGE_EXPIRED_TOKEN" /* ExpiredToken */, "Runtime bridge refresh token has expired");
+      }
+      const token = mintWorkspaceBridgeRuntimeToken({
+        secret: opts.runtimeTokenSecret,
+        workspaceId: verified.claims.workspaceId,
+        sessionId: verified.claims.sessionId,
+        runtimeId: verified.claims.runtimeId,
+        capabilities: verified.claims.capabilities,
+        ttlMs
+      });
+      return reply.code(200).send({ ok: true, token });
+    } catch (err) {
+      const bridgeError = isBridgeError(err) ? err : createWorkspaceBridgeError("BRIDGE_INVALID_TOKEN" /* InvalidToken */, "WorkspaceBridge refresh token is invalid");
+      return sendBridgeError(reply, statusForBridgeError(bridgeError.code), void 0, bridgeError.code, bridgeError.message);
+    }
+  });
+  done();
+}
+async function resolveRegistry(request, body, opts) {
+  const registry = opts.getRegistry ? await opts.getRegistry(request, body) : opts.registry;
+  if (!registry) {
+    throw createWorkspaceBridgeError("BRIDGE_OP_NOT_FOUND" /* OpNotFound */, "WorkspaceBridge registry is not configured");
+  }
+  return registry;
+}
+function resolveRuntimeContext(token, opts, definition) {
+  if (!opts.runtimeTokenSecret) {
+    throw createWorkspaceBridgeError("BRIDGE_AUTH_REQUIRED" /* AuthRequired */, "Runtime bridge token auth is not configured");
+  }
+  return verifyWorkspaceBridgeRuntimeToken(token, {
+    secret: opts.runtimeTokenSecret,
+    requiredCapabilities: definition.requiredCapabilities
+  }).authContext;
+}
+async function resolveBrowserContext(request, opts, definition, body) {
+  if (!opts.browserAuthPolicy) {
+    throw createWorkspaceBridgeError("BRIDGE_AUTH_REQUIRED" /* AuthRequired */, "Browser bridge auth is not configured");
+  }
+  const workspaceId = firstHeader(request.headers["x-boring-workspace-id"]) ?? "default";
+  const sessionId = firstHeader(request.headers["x-boring-session-id"]);
+  return (await opts.browserAuthPolicy.resolve({
+    callerClass: "browser",
+    definition,
+    workspaceId,
+    sessionId,
+    request: { headers: request.headers, method: request.method, user: request.user },
+    body
+  })).context;
+}
+async function sendResponse(reply, response) {
+  return reply.code(response.ok ? 200 : statusForBridgeError(response.error.code)).send(response);
+}
+function refreshMintTtlMs(claims, nowMs) {
+  const requested = clampWorkspaceBridgeRuntimeTokenTtlMs(claims.tokenTtlMs) ?? DEFAULT_WORKSPACE_BRIDGE_RUNTIME_TOKEN_TTL_MS;
+  const remaining = claims.exp * 1e3 - nowMs;
+  if (remaining <= 0) return void 0;
+  return Math.min(requested, remaining);
+}
+function sendBridgeError(reply, status, requestId, code, message) {
+  reply.header("Cache-Control", "no-store");
+  return reply.code(status).send({ ok: false, requestId, error: { code, message } });
+}
+function statusForBridgeError(code) {
+  if (code === "BRIDGE_AUTH_REQUIRED" /* AuthRequired */ || code === "BRIDGE_INVALID_TOKEN" /* InvalidToken */ || code === "BRIDGE_EXPIRED_TOKEN" /* ExpiredToken */) return 401;
+  if (code === "BRIDGE_RATE_LIMITED" /* RateLimited */) return 429;
+  if (code === "BRIDGE_CALLER_NOT_ALLOWED" /* CallerNotAllowed */ || code === "BRIDGE_CAPABILITY_DENIED" /* CapabilityDenied */ || code === "BRIDGE_RESOURCE_SCOPE_DENIED" /* ResourceScopeDenied */) return 403;
+  if (code === "BRIDGE_OP_NOT_FOUND" /* OpNotFound */) return 404;
+  if (code === "BRIDGE_INPUT_TOO_LARGE" /* InputTooLarge */ || code === "BRIDGE_OUTPUT_TOO_LARGE" /* OutputTooLarge */) return 413;
+  return 400;
+}
+function firstHeader(value) {
+  return Array.isArray(value) ? value[0] : value;
+}
+function isBridgeError(err) {
+  return !!err && typeof err === "object" && "code" in err && "message" in err;
+}
+
+// src/server/workspaceBridge/runtimeEnv.ts
+var BRIDGE_CALL_PATH = "/api/v1/workspace-bridge/call";
+var BRIDGE_TOKEN_PATH = "/api/v1/workspace-bridge/token";
+function createWorkspaceBridgeRuntimeEnvContribution(options) {
+  const enabled = options.runtimeEnv?.enabled ?? Boolean(options.runtimeEnv?.bridgeUrl);
+  if (!enabled) return void 0;
+  const bridgeUrl = resolveBridgeCallUrl(options.runtimeEnv?.bridgeUrl);
+  const tokenUrl = resolveBridgeTokenUrl(options.runtimeEnv?.bridgeUrl);
+  const capabilities = options.runtimeEnv?.capabilities;
+  return {
+    id: "workspace-bridge-runtime-env",
+    getEnv: (ctx) => {
+      const runtimePlacement = resolveRuntimePlacement(ctx?.runtimeBundle, options.runtimePlacement);
+      const disabledReason = validateRuntimeBridgeUrl({
+        bridgeUrl,
+        runtimePlacement,
+        allowInsecureHttp: options.runtimeEnv?.allowInsecureHttp,
+        hasRuntimeTokenSecret: Boolean(options.runtimeTokenSecret),
+        hasCapabilities: Array.isArray(capabilities) && capabilities.length > 0
+      });
+      if (disabledReason) {
+        return { [WORKSPACE_BRIDGE_DISABLED_ENV]: disabledReason };
+      }
+      const token = mintWorkspaceBridgeRuntimeToken({
+        secret: options.runtimeTokenSecret,
+        workspaceId: options.workspaceId,
+        sessionId: options.runtimeEnv?.sessionId,
+        runtimeId: options.runtimeMode,
+        capabilities,
+        ttlMs: options.runtimeEnv?.tokenTtlMs
+      });
+      const refreshToken = options.runtimeRefreshTokenSecret && tokenUrl && isRefreshTokenUrlSafe(tokenUrl) ? mintWorkspaceBridgeRuntimeRefreshToken({
+        secret: options.runtimeRefreshTokenSecret,
+        workspaceId: options.workspaceId,
+        sessionId: options.runtimeEnv?.sessionId,
+        runtimeId: options.runtimeMode,
+        capabilities,
+        ttlMs: options.runtimeEnv?.refreshTokenTtlMs,
+        tokenTtlMs: options.runtimeEnv?.tokenTtlMs
+      }) : void 0;
+      return {
+        [WORKSPACE_BRIDGE_URL_ENV]: bridgeUrl,
+        [WORKSPACE_BRIDGE_TOKEN_ENV]: token,
+        ...refreshToken ? {
+          [WORKSPACE_BRIDGE_TOKEN_URL_ENV]: tokenUrl,
+          [WORKSPACE_BRIDGE_REFRESH_TOKEN_ENV]: refreshToken
+        } : {},
+        BORING_WORKSPACE_ID: options.workspaceId,
+        BORING_AGENT_SESSION_ID: options.runtimeEnv?.sessionId ?? options.workspaceId
+      };
+    }
+  };
+}
+function resolveBridgeCallUrl(value) {
+  return resolveBridgeUrl(value, BRIDGE_CALL_PATH);
+}
+function resolveBridgeTokenUrl(value) {
+  return resolveBridgeUrl(value, BRIDGE_TOKEN_PATH);
+}
+function resolveBridgeUrl(value, path) {
+  if (!value?.trim()) return void 0;
+  try {
+    const url = new URL(value);
+    if (url.pathname === "" || url.pathname === "/" || url.pathname === BRIDGE_CALL_PATH || url.pathname === BRIDGE_TOKEN_PATH) {
+      url.pathname = path;
+    }
+    return url.toString();
+  } catch {
+    return void 0;
+  }
+}
+function isRefreshTokenUrlSafe(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" || url.protocol === "http:" && isLoopbackHost(url.hostname);
+  } catch {
+    return false;
+  }
+}
+function isLoopbackHost(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
+}
+function resolveRuntimePlacement(runtimeBundle, fallback) {
+  if (runtimeBundle?.filesystem?.kind === "remote-workspace" || runtimeBundle?.bash?.kind === "remote") return "remote";
+  return fallback ?? "local";
+}
+function validateRuntimeBridgeUrl(options) {
+  if (!options.bridgeUrl) return "bridge-url-missing";
+  if (!options.hasRuntimeTokenSecret) return "runtime-token-secret-missing";
+  if (!options.hasCapabilities) return "runtime-capabilities-missing";
+  let url;
+  try {
+    url = new URL(options.bridgeUrl);
+  } catch {
+    return "bridge-url-invalid";
+  }
+  const isRemote = options.runtimePlacement === "remote";
+  const isLocalhost = isLoopbackHost(url.hostname);
+  if (isRemote && url.protocol !== "https:") return "remote-bridge-url-must-be-https";
+  if (isRemote && isLocalhost) return "remote-bridge-url-must-not-be-localhost";
+  if (url.protocol === "http:" && !options.allowInsecureHttp && !isLocalhost) return "remote-bridge-url-must-be-https";
+  if (url.protocol !== "http:" && url.protocol !== "https:") return "bridge-url-invalid";
+  return void 0;
+}
+
+// src/server/workspaceBridge/runtimeCore.ts
+function createWorkspaceBridgeRuntimeCore(options = {}) {
+  const registry = options.registry ?? createWorkspaceBridgeRegistry({ ownerWorkspaceId: options.ownerWorkspaceId });
+  for (const entry of options.handlers ?? []) {
+    registry.registerHandler(entry.definition, entry.handler);
+  }
+  return { registry };
+}
+
 // src/app/server/createWorkspaceAgentServer.ts
 var __dirname = dirname7(fileURLToPath(import.meta.url));
 var require4 = createRequire4(import.meta.url);
@@ -2758,6 +3926,7 @@ function collectWorkspaceAgentServerPlugins(opts = {}) {
       ...result.runtimePlugins
     ],
     routeContributions: result.routeContributions,
+    workspaceBridgeHandlers: result.workspaceBridgeHandlers,
     preservedUiStateKeys: result.preservedUiStateKeys,
     agentOptions: {
       extraTools: result.agentTools,
@@ -2919,6 +4088,23 @@ function readWorkspacePluginPackagePiSnapshot(pluginDirs) {
     return emptyPackageJsonPiSnapshot();
   }
 }
+function resolveWorkspaceBridgeBrowserAuthPolicy(opts, registry) {
+  if (opts.workspaceBridge?.browserAuthPolicy) return opts.workspaceBridge.browserAuthPolicy;
+  if (opts.workspaceBridge?.allowInsecureLocalCliBrowserAuth !== true) return void 0;
+  emitLocalCliBridgeAuthWarning();
+  return createLocalCliBridgeAuthPolicy({
+    workspaceId: "default",
+    capabilities: registry.listDefinitions().flatMap((definition) => [...definition.requiredCapabilities])
+  });
+}
+function emitLocalCliBridgeAuthWarning() {
+  const message = "createWorkspaceAgentServer is using createLocalCliBridgeAuthPolicy for WorkspaceBridge browser calls. This policy is unauthenticated, grants registered bridge capabilities to a fixed local-cli principal, and is intended only for local/dev CLI usage. Provide workspaceBridge.browserAuthPolicy before exposing this server.";
+  if (typeof process.emitWarning === "function") {
+    process.emitWarning(message, { code: "BORING_WORKSPACE_BRIDGE_INSECURE_AUTH" });
+    return;
+  }
+  console.warn(message);
+}
 async function createWorkspaceAgentServer(opts = {}) {
   const workspaceRoot = opts.workspaceRoot ?? process.cwd();
   const bridge = createInMemoryBridge();
@@ -2937,13 +4123,17 @@ async function createWorkspaceAgentServer(opts = {}) {
     defaultPluginPackages: opts.defaultPluginPackages,
     anchorDir: opts.appRoot
   });
-  const defaultPluginDirEntries = defaultPluginPackagePaths.map((dir) => ({ dir, hotReload: true })).filter((entry) => hasDirServerPlugin(entry));
+  const defaultPluginDirEntries = defaultPluginPackagePaths.map((dir) => ({ dir, hotReload: true, trust: "internal" })).filter((entry) => hasDirServerPlugin(entry));
   const allPluginEntries = [
     ...defaultPluginDirEntries,
     ...opts.plugins ?? []
   ];
   const resolvedPlugins = await Promise.all(
-    allPluginEntries.map((entry) => resolveOnePluginEntry(entry, ctx))
+    allPluginEntries.map(async (entry) => {
+      const plugin = await resolveOnePluginEntry(entry, ctx);
+      assertWorkspaceBridgeHandlersTrusted(plugin, entry);
+      return plugin;
+    })
   );
   const pluginAuthoringEnabled = externalPluginsEnabled && (opts.installPluginAuthoring ?? workspaceFsCapability === "strong") && !(opts.excludeDefaults ?? []).includes("boring-ui-plugin-cli-package");
   const pluginCollection = collectWorkspaceAgentServerPlugins({
@@ -2951,6 +4141,14 @@ async function createWorkspaceAgentServer(opts = {}) {
     plugins: resolvedPlugins,
     installPluginAuthoring: pluginAuthoringEnabled
   });
+  const { registry: workspaceBridgeRegistry } = createWorkspaceBridgeRuntimeCore({
+    registry: opts.workspaceBridge?.registry,
+    ownerWorkspaceId: "default",
+    handlers: [
+      ...opts.workspaceBridge?.handlers ?? [],
+      ...pluginCollection.workspaceBridgeHandlers ?? []
+    ]
+  });
   const workspacePackagePiPackage = pluginAuthoringEnabled ? createBoringPiPackageSource(workspaceRoot) : void 0;
   const baseStaticPiSkillPaths = [
     ...pluginAuthoringEnabled ? resolveBoringPiSkillPaths(workspaceRoot) : [],
@@ -3027,11 +4225,28 @@ async function createWorkspaceAgentServer(opts = {}) {
   const rebuildPlugins = async () => {
     return rebuildServerPlugins({ entries: allPluginEntries, ctx });
   };
+  const callerRuntimeProvisioner = opts.runtimeProvisioner;
+  const boringUiCliCommandAvailable = opts.provisionWorkspace !== false && pluginCollection.provisioningContributions.some(
+    (entry) => entry.id === "boring-ui-cli-package"
+  );
+  const workspaceBridgeRuntimeEnvContribution = createWorkspaceBridgeRuntimeEnvContribution({
+    workspaceId: "default",
+    runtimeMode: resolvedMode,
+    registry: workspaceBridgeRegistry,
+    runtimeTokenSecret: opts.workspaceBridge?.runtimeTokenSecret,
+    runtimeRefreshTokenSecret: opts.workspaceBridge?.runtimeRefreshTokenSecret,
+    runtimeEnv: opts.workspaceBridge?.runtimeEnv,
+    runtimePlacement: workspaceFsCapability === "strong" ? "local" : "remote"
+  });
   const app = await createAgentApp({
     ...opts,
     mode: resolvedMode,
     workspaceRoot,
     externalPlugins: externalPluginsEnabled,
+    runtimeEnvContributions: [
+      ...opts.runtimeEnvContributions ?? [],
+      ...workspaceBridgeRuntimeEnvContribution ? [workspaceBridgeRuntimeEnvContribution] : []
+    ],
     extraTools: [
       ...opts.extraTools ?? [],
       ...uiTools,
@@ -3114,6 +4329,19 @@ async function createWorkspaceAgentServer(opts = {}) {
     });
   }
   await app.register(uiRoutes, { bridge, preserveStateKeys: pluginCollection.preservedUiStateKeys });
+  await app.register(workspaceBridgeHttpRoutes, {
+    registry: workspaceBridgeRegistry,
+    runtimeTokenSecret: opts.workspaceBridge?.runtimeTokenSecret,
+    runtimeRefreshTokenSecret: opts.workspaceBridge?.runtimeRefreshTokenSecret,
+    ownerWorkspaceId: "default",
+    idempotencyStore: new InMemoryWorkspaceBridgeIdempotencyStore(),
+    browserAuthPolicy: resolveWorkspaceBridgeBrowserAuthPolicy(opts, workspaceBridgeRegistry)
+  });
+  const internals = app;
+  internals.__boringWorkspaceBridgeRegistry = workspaceBridgeRegistry;
+  internals.__boringRebuildPlugins = rebuildPlugins;
+  internals.__boringAssetManager = boringAssetManager;
+  internals.__boringRuntimeBackendRegistry = runtimeBackendRegistry;
   await app.register(boringPluginRoutes, {
     manager: boringAssetManager
   });
@@ -3121,18 +4349,16 @@ async function createWorkspaceAgentServer(opts = {}) {
   for (const { routes } of pluginCollection.routeContributions) {
     await app.register(routes);
   }
-  ;
-  app.__boringRebuildPlugins = rebuildPlugins;
-  app.__boringAssetManager = boringAssetManager;
-  app.__boringRuntimeBackendRegistry = runtimeBackendRegistry;
   return app;
 }
 export {
   PLUGIN_AUTHORING_PROVISIONING_IDS,
+  assertWorkspaceBridgeHandlersTrusted,
   buildWorkspaceContextPrompt,
   collectWorkspaceAgentServerPlugins,
   createWorkspaceAgentServer,
   hasDirServerPlugin,
+  isTrustedWorkspaceBridgeHandlerEntry,
   omitPluginAuthoringProvisioning,
   provisionWorkspaceAgentServer,
   readWorkspacePluginPackagePiSnapshot,