@hachej/boring-workspace 0.1.54 → 0.1.56

package/dist/server.js

@@ -11,6 +11,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;
@@ -19,14 +29,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);
@@ -394,7 +400,7 @@ async function validateExistingPath(workspaceRoot, relPath) {
     };
   }
 }
-function createGetUiStateTool(uiBridge) {
+function createGetUiStateTool(workspaceBridge) {
   return {
     name: "get_ui_state",
     readinessRequirements: ["ui-bridge"],
@@ -420,7 +426,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
@@ -450,7 +456,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;
@@ -607,7 +613,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) }],
@@ -617,11 +623,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 {
@@ -640,8 +646,1269 @@ 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/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 (!isRecord(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 isRecord(value);
+}
+function isRecord(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((resolve6) => {
+        timeout = setTimeout(() => {
+          controller.abort("timeout");
+          resolve6(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 (!isRecord(value)) return { success: false, message: `${path}: Expected object` };
+    const properties = isRecord(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 isRecord(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/workspaceBridge/authPolicy.ts
+function createBrowserBridgeAuthPolicy(options) {
+  return {
+    async resolve(input) {
+      if (input.callerClass !== "browser") {
+        throw createWorkspaceBridgeError(
+          "BRIDGE_CALLER_NOT_ALLOWED" /* CallerNotAllowed */,
+          "Browser auth policy only accepts browser callers"
+        );
+      }
+      ensureCallerAllowed(input.definition, "browser");
+      ensureBrowserRequestAllowed(input, options);
+      const principal = await options.getPrincipal(input);
+      if (!principal) {
+        throw createWorkspaceBridgeError(
+          "BRIDGE_AUTH_REQUIRED" /* AuthRequired */,
+          "Browser bridge caller is not authenticated"
+        );
+      }
+      const grant = await options.authorizeWorkspace({
+        principal,
+        workspaceId: input.workspaceId,
+        sessionId: input.sessionId,
+        definition: input.definition,
+        request: input.request
+      });
+      if (!grant.allowed) {
+        throw createWorkspaceBridgeError(
+          "BRIDGE_RESOURCE_SCOPE_DENIED" /* ResourceScopeDenied */,
+          "Browser bridge caller is not authorized for workspace"
+        );
+      }
+      const capabilities = grant.capabilities;
+      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: principal.email ? `user:${principal.email}` : `user:${principal.userId}`,
+            id: principal.userId
+          }
+        }
+      });
+      return {
+        context,
+        effectiveCapabilities: capabilities,
+        principal,
+        resourceScope: {
+          workspaceId: input.workspaceId,
+          sessionId: input.sessionId,
+          role: grant.role,
+          ...grant.resourceScope
+        }
+      };
+    }
+  };
+}
+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 ensureBrowserRequestAllowed(input, options) {
+  if (options.allowedOrigins && options.allowedOrigins.length > 0) {
+    const origin = firstHeader(input.request?.headers, "origin");
+    if (!origin || !options.allowedOrigins.includes(origin)) {
+      throw createWorkspaceBridgeError(
+        "BRIDGE_AUTH_REQUIRED" /* AuthRequired */,
+        "Browser bridge request origin is not allowed"
+      );
+    }
+  }
+  if (options.requireCsrfHeader) {
+    const csrf = firstHeader(input.request?.headers, "x-csrf-token");
+    if (!csrf) {
+      throw createWorkspaceBridgeError(
+        "BRIDGE_AUTH_REQUIRED" /* AuthRequired */,
+        "Browser bridge request is missing CSRF proof"
+      );
+    }
+  }
+}
+function firstHeader(headers, name) {
+  if (!headers) return void 0;
+  const direct = headers[name] ?? headers[name.toLowerCase()];
+  return Array.isArray(direct) ? direct[0] : direct;
+}
+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 } 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 createHash("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 = firstHeader2(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 = firstHeader2(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 = firstHeader2(request.headers["x-boring-workspace-id"]) ?? "default";
+  const sessionId = firstHeader2(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 firstHeader2(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/trustedDomainHandler.ts
+var DEFAULT_RESERVED_OP_PREFIXES = RESERVED_WORKSPACE_BRIDGE_OP_PREFIXES;
+var VERSIONED_OP_PATTERN = /^[a-z][a-z0-9-]*\.v[1-9][0-9]*\.[a-z][a-z0-9.-]*$/;
+function defineTrustedDomainBridgeHandler(options) {
+  validateTrustedDomainMetadata(options);
+  return {
+    definition: {
+      op: options.op,
+      version: options.version,
+      owner: options.owner,
+      callerClassesAllowed: [...options.callerClassesAllowed],
+      requiredCapabilities: [...options.requiredCapabilities],
+      inputSchema: options.inputSchema,
+      ...options.outputSchema ? { outputSchema: options.outputSchema } : {},
+      timeoutMs: options.timeoutMs ?? 5e3,
+      maxInputBytes: options.maxInputBytes ?? 64 * 1024,
+      maxOutputBytes: options.maxOutputBytes,
+      idempotencyPolicy: options.idempotencyPolicy ?? "none"
+    },
+    handler: options.handler
+  };
+}
+function validateTrustedDomainMetadata(options) {
+  if (!options || typeof options !== "object") {
+    throw invalid("Trusted domain bridge handler metadata is required");
+  }
+  if (!options.op?.trim()) throw invalid("Trusted domain bridge handler op is required");
+  if (!Number.isInteger(options.version) || options.version < 1) throw invalid("Trusted domain bridge handler version is required");
+  if (!options.owner?.trim()) throw invalid("Trusted domain bridge handler owner is required");
+  if (!Array.isArray(options.callerClassesAllowed) || options.callerClassesAllowed.length === 0) {
+    throw invalid("Trusted domain bridge handler callerClassesAllowed is required");
+  }
+  if (!Array.isArray(options.requiredCapabilities)) throw invalid("Trusted domain bridge handler requiredCapabilities is required");
+  if (options.inputSchema === void 0) throw invalid("Trusted domain bridge handler inputSchema is required");
+  if (typeof options.handler !== "function") throw invalid("Trusted domain bridge handler function is required");
+  if (!Number.isFinite(options.maxOutputBytes) || options.maxOutputBytes <= 0) {
+    throw invalid("Trusted domain bridge handler maxOutputBytes must be positive");
+  }
+  const policy = options.policy ?? {};
+  const requireVersionedOp = policy.requireVersionedOp ?? true;
+  if (requireVersionedOp && !VERSIONED_OP_PATTERN.test(options.op)) {
+    throw invalid("Trusted domain bridge handler op must be versioned as domain.v1.action");
+  }
+  const reservedPrefixes = policy.reservedOpPrefixes ?? DEFAULT_RESERVED_OP_PREFIXES;
+  const reservedPrefix = reservedPrefixes.find((prefix) => options.op.startsWith(prefix));
+  if (reservedPrefix) {
+    throw invalid(`Trusted domain bridge handler op uses reserved prefix ${reservedPrefix}`);
+  }
+}
+function invalid(message) {
+  throw createWorkspaceBridgeError("BRIDGE_INVALID_REQUEST" /* InvalidRequest */, message);
+}
+
+// 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/server/plugins/piPackages.ts
@@ -734,6 +2001,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");
@@ -853,6 +2140,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");
   }
@@ -915,6 +2208,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),
@@ -925,6 +2219,7 @@ function bootstrapServer(options) {
     runtimePlugins,
     provisioningContributions,
     routeContributions,
+    workspaceBridgeHandlers,
     preservedUiStateKeys
   };
 }
@@ -1037,7 +2332,7 @@ function buildBoringSystemPrompt(opts) {
 }
 
 // src/server/agentPlugins/manager.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import { existsSync as existsSync4, lstatSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync2, realpathSync as realpathSync2, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync2 } from "fs";
 import { dirname as dirname6, isAbsolute as isAbsolute3, join as join5, relative as relative3, resolve as resolve5 } from "path";
 
@@ -1053,7 +2348,7 @@ function isSafePluginRelativePath(value) {
 function issue(code, field, message) {
   return { code, field, message };
 }
-function isRecord(value) {
+function isRecord2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function validateStringArray(issues, value, field, pathLike) {
@@ -1076,7 +2371,7 @@ function validateStringArray(issues, value, field, pathLike) {
 var REMOVED_BORING_UI_FIELDS = ["outputs", "panels", "commands", "leftTabs", "surfaceResolvers", "providers", "bindings", "catalogs"];
 function validateBoringField(issues, boring) {
   if (boring === void 0) return void 0;
-  if (!isRecord(boring)) {
+  if (!isRecord2(boring)) {
     issues.push(issue("INVALID_FIELD", "boring", "boring must be an object when provided"));
     return void 0;
   }
@@ -1136,7 +2431,7 @@ function validatePiPackages2(issues, value) {
       }
       return;
     }
-    if (!isRecord(entry)) {
+    if (!isRecord2(entry)) {
       issues.push(issue("INVALID_FIELD", field, `${field} must be a string or package source object`));
       return;
     }
@@ -1149,7 +2444,7 @@ function validatePiPackages2(issues, value) {
 }
 function validatePiField(issues, pi) {
   if (pi === void 0) return void 0;
-  if (!isRecord(pi)) {
+  if (!isRecord2(pi)) {
     issues.push(issue("INVALID_FIELD", "pi", "pi must be an object when provided"));
     return void 0;
   }
@@ -1163,7 +2458,7 @@ function validatePiField(issues, pi) {
 }
 function validateBoringPluginManifest(raw) {
   const issues = [];
-  if (!isRecord(raw)) {
+  if (!isRecord2(raw)) {
     return {
       valid: false,
       issues: [issue("INVALID_FIELD", "<root>", "package.json manifest must be an object")]
@@ -1551,11 +2846,11 @@ function skillPathForPiLoader(path) {
   return existsSync4(join5(path, "SKILL.md")) ? dirname6(path) : path;
 }
 function preflightErrorId(pluginDir) {
-  return `preflight-${createHash("sha256").update(pluginDir).digest("hex").slice(0, 12)}`;
+  return `preflight-${createHash2("sha256").update(pluginDir).digest("hex").slice(0, 12)}`;
 }
 function directorySignature(root) {
   if (!root || !existsSync4(root)) return "missing";
-  const hash = createHash("sha256");
+  const hash = createHash2("sha256");
   const visited = /* @__PURE__ */ new Set();
   let rootReal;
   try {
@@ -1618,7 +2913,7 @@ function frontSignatureRoot(plugin) {
   return rel === "" || !rel.startsWith("..") && !isAbsolute3(rel) ? frontRoot : dirname6(plugin.frontPath);
 }
 function pluginSignature(plugin) {
-  return createHash("sha256").update(JSON.stringify(plugin.boring)).update(JSON.stringify(plugin.pi ?? {})).update(plugin.version).update(JSON.stringify(plugin.source)).update(plugin.frontPath ?? "").update(pluginFileSignature(plugin.frontPath)).update(directorySignature(frontSignatureRoot(plugin))).update(directorySignature(join5(plugin.rootDir, "shared"))).update(plugin.serverPath ?? "").update(pluginFileSignature(plugin.serverPath)).update(directorySignature(plugin.serverPath ? dirname6(plugin.serverPath) : void 0)).update((plugin.extensionPaths ?? []).join("\0")).update((plugin.skillPaths ?? []).join("\0")).digest("hex");
+  return createHash2("sha256").update(JSON.stringify(plugin.boring)).update(JSON.stringify(plugin.pi ?? {})).update(plugin.version).update(JSON.stringify(plugin.source)).update(plugin.frontPath ?? "").update(pluginFileSignature(plugin.frontPath)).update(directorySignature(frontSignatureRoot(plugin))).update(directorySignature(join5(plugin.rootDir, "shared"))).update(plugin.serverPath ?? "").update(pluginFileSignature(plugin.serverPath)).update(directorySignature(plugin.serverPath ? dirname6(plugin.serverPath) : void 0)).update((plugin.extensionPaths ?? []).join("\0")).update((plugin.skillPaths ?? []).join("\0")).digest("hex");
 }
 function computeRequiresRestart(previous, next) {
   if (!previous) return [];
@@ -2463,29 +3758,58 @@ async function runtimeBackendGateway(app, opts) {
 }
 export {
   BoringPluginAssetManager,
+  DEFAULT_WORKSPACE_BRIDGE_RUNTIME_REFRESH_TOKEN_TTL_MS,
+  DEFAULT_WORKSPACE_BRIDGE_RUNTIME_TOKEN_TTL_MS,
+  InMemoryWorkspaceBridgeIdempotencyStore,
+  InMemoryWorkspaceBridgeRuntimeRefreshTokenStore,
+  MAX_WORKSPACE_BRIDGE_RUNTIME_TOKEN_TTL_MS,
   RuntimeBackendError,
   RuntimeBackendRegistry,
+  WORKSPACE_BRIDGE_REFRESH_TOKEN_AUDIENCE,
+  WORKSPACE_BRIDGE_TOKEN_AUDIENCE,
+  WorkspaceBridgeErrorCode,
+  WorkspaceBridgeRegistry,
   aggregatePluginPrompts,
   bootstrapServer,
   boringPluginRoutes,
   buildBoringSystemPrompt,
+  clampWorkspaceBridgeRuntimeTokenTtlMs,
   collectRestartWarnings,
+  createBrowserBridgeAuthPolicy,
   createExecUiTool,
   createGetUiStateTool,
   createInMemoryBridge,
+  createLocalCliBridgeAuthPolicy,
+  createWorkspaceBridgeError,
+  createWorkspaceBridgeRegistry,
+  createWorkspaceBridgeRuntimeCore,
+  createWorkspaceBridgeRuntimeEnvContribution,
   createWorkspaceUiTools,
   definePluginAsset,
   defineRuntimeServerPlugin,
   defineServerPlugin,
+  defineTrustedDomainBridgeHandler,
+  hashNormalizedInput,
+  mintWorkspaceBridgeRuntimeRefreshToken,
+  mintWorkspaceBridgeRuntimeToken,
   pluginFileSignature,
   preflightBoringPlugins,
   readBoringPlugins,
   readPluginSignatureCache,
+  resolveBridgeCallUrl,
+  resolveBridgeTokenUrl,
   resolvePluginAssetPath,
+  runWithWorkspaceBridgeIdempotency,
   runtimeBackendGateway,
+  runtimeClaimsToBridgeAuthContext,
   scanBoringPlugins,
+  stableStringify,
   uiRoutes,
   validateRuntimeServerPlugin,
   validateServerPlugin,
+  validateWorkspaceBridgeOperationDefinition,
+  verifyWorkspaceBridgeRuntimeRefreshToken,
+  verifyWorkspaceBridgeRuntimeToken,
+  workspaceBridgeHttpRoutes,
   writePluginSignatureCache
 };