@koed-labs/server 0.0.0-bootstrap.0 → 0.10.3

package/vendor/chunk-JJNLH5GA.js

@@ -0,0 +1,2470 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+import {
+  disconnectUpstreamBackendEnrollment,
+  getUpstreamEnrollmentStatus,
+  readUpstreamEnrollmentBinding,
+  startUpstreamEnrollment
+} from "./chunk-SKVYP7NY.js";
+import {
+  applyPersistedLocalPorts
+} from "./chunk-HFM6ROJL.js";
+import {
+  removeProjectTeamWorkspaceLinksForBackend,
+  removeProjectTeamWorkspaceLinksForMismatchedBinding
+} from "./chunk-6JRWGOQG.js";
+import {
+  applyActiveRuntimeUrls,
+  readActiveRuntimeState
+} from "./chunk-G4IIVVJO.js";
+import {
+  beginUpstreamDisconnectCleanup,
+  completeUpstreamDisconnectCleanup,
+  createSecureUpstreamFetch,
+  getActiveUpstreamBackend,
+  listUpstreamBackends,
+  listUpstreamDisconnectCleanupRecords,
+  refreshUpstreamBackendCapabilities,
+  registerUpstreamBackend,
+  registeredPrivateNetworkPolicy,
+  setActiveUpstreamBackend,
+  updateUpstreamBackendRoutePolicy,
+  updateUpstreamDisconnectCleanup,
+  upstreamDisconnectCleanupPending
+} from "./chunk-YJWREXN6.js";
+import "./chunk-XNFVSVBS.js";
+import "./chunk-7NXKPDF3.js";
+import {
+  resolveKoedServerPaths
+} from "./chunk-K2EIFEQF.js";
+import "./chunk-UI5RLBKQ.js";
+import {
+  loadRepoEnv,
+  resolveApiUrl
+} from "./chunk-W2HNI6AA.js";
+import {
+  COLLABORATION_CONTRACT_VERSION,
+  COLLABORATION_RECONNECT_BACKOFF_CAP_MS,
+  COLLABORATION_RECONNECT_MAX_ATTEMPTS,
+  COLLABORATION_RECONNECT_UNAVAILABLE_COOLDOWN_MS,
+  COLLABORATION_RECONNECT_WINDOW_MS,
+  COLLABORATION_RENDERER_MAX_PENDING_BYTES,
+  COLLABORATION_SEND_RETRY_MAX_ATTEMPTS,
+  calculateCollaborationReconnectDelay,
+  clearCollaborationActionGrantCustodyForBackend,
+  clearCollaborationPendingTeamSends,
+  collaborationBackendIdentitySchema,
+  collaborationCommandResultSchema,
+  collaborationCommandReturnsSnapshot,
+  collaborationConnectionEventSchema,
+  collaborationDeliveryIdSchema,
+  collaborationDurableSendEventSchema,
+  collaborationDurableSendSchema,
+  collaborationRemoteBackendUrlSchema,
+  collaborationRendererCommandSchema,
+  collaborationRendererEventSchema,
+  collaborationSafeErrorMessages,
+  collaborationSnapshotSchema,
+  collaborationSubscriptionSchema,
+  deleteCollaborationPendingSend,
+  external_exports,
+  isTeamCollaborationSelection,
+  listCollaborationPendingSends,
+  readBoundedJsonObject,
+  readDesktopLocalCredentialAuthorization,
+  readLocalEdgeClientCredentialAuthorization,
+  storeCollaborationPendingSend,
+  updateCollaborationPendingSendState
+} from "./chunk-473OA62O.js";
+import "./chunk-BTS4ZTF3.js";
+
+// packages/koed-server/dist/desktop-collaboration-broker.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// packages/koed-server/dist/desktop-collaboration-broker-contract.js
+import { Buffer as Buffer2 } from "node:buffer";
+var DESKTOP_COLLABORATION_BROKER_PROTOCOL_VERSION = 1;
+var DESKTOP_COLLABORATION_BROKER_MAX_MESSAGE_BYTES = 32 * 1024 * 1024;
+var ownerIdSchema = external_exports.string().min(1).max(128).regex(/^[A-Za-z0-9:_-]+$/);
+var sessionTokenSchema = external_exports.string().min(32).max(256).regex(/^[A-Za-z0-9_-]+$/);
+var browserUrlSchema = collaborationRemoteBackendUrlSchema.or(external_exports.string().trim().min(1).max(4096).superRefine((value, context) => {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    context.addIssue({ code: "custom", message: "Browser URL is invalid" });
+    return;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    context.addIssue({
+      code: "custom",
+      message: "Browser URL must use HTTP or HTTPS"
+    });
+  }
+  if (!parsed.hostname || parsed.username || parsed.password) {
+    context.addIssue({
+      code: "custom",
+      message: "Browser URL must be credential-free"
+    });
+  }
+  if (parsed.search || parsed.hash) {
+    context.addIssue({
+      code: "custom",
+      message: "Browser URL must not include a query string or fragment"
+    });
+  }
+}));
+var baseEnvelopeSchema = external_exports.object({
+  protocolVersion: external_exports.literal(DESKTOP_COLLABORATION_BROKER_PROTOCOL_VERSION),
+  contractVersion: external_exports.literal(COLLABORATION_CONTRACT_VERSION),
+  sessionToken: sessionTokenSchema
+});
+var desktopCollaborationBrokerParentMessageSchema = external_exports.discriminatedUnion("type", [
+  baseEnvelopeSchema.extend({
+    type: external_exports.literal("command"),
+    envelopeId: external_exports.uuid(),
+    ownerId: ownerIdSchema,
+    command: collaborationRendererCommandSchema
+  }),
+  baseEnvelopeSchema.extend({
+    type: external_exports.literal("release_owner"),
+    envelopeId: external_exports.uuid(),
+    ownerId: ownerIdSchema
+  }),
+  baseEnvelopeSchema.extend({
+    type: external_exports.literal("shutdown"),
+    envelopeId: external_exports.uuid()
+  })
+]);
+var desktopCollaborationBrokerChildErrorCodeSchema = external_exports.enum([
+  "invalid_message",
+  "duplicate_request",
+  "unknown_owner",
+  "unknown_command",
+  "timeout",
+  "internal_error"
+]);
+var desktopCollaborationBrokerChildMessageSchema = external_exports.discriminatedUnion("type", [
+  baseEnvelopeSchema.extend({
+    type: external_exports.literal("ready"),
+    brokerPid: external_exports.number().int().positive()
+  }),
+  baseEnvelopeSchema.extend({
+    type: external_exports.literal("command_result"),
+    envelopeId: external_exports.uuid(),
+    ownerId: ownerIdSchema,
+    result: collaborationCommandResultSchema
+  }),
+  baseEnvelopeSchema.extend({
+    type: external_exports.literal("renderer_event"),
+    ownerId: ownerIdSchema,
+    event: collaborationRendererEventSchema
+  }),
+  baseEnvelopeSchema.extend({
+    type: external_exports.literal("open_external"),
+    envelopeId: external_exports.uuid(),
+    ownerId: ownerIdSchema,
+    url: browserUrlSchema
+  }),
+  baseEnvelopeSchema.extend({
+    type: external_exports.literal("owner_released"),
+    envelopeId: external_exports.uuid(),
+    ownerId: ownerIdSchema
+  }),
+  baseEnvelopeSchema.extend({
+    type: external_exports.literal("shutdown_ack"),
+    envelopeId: external_exports.uuid()
+  }),
+  baseEnvelopeSchema.extend({
+    type: external_exports.literal("error"),
+    envelopeId: external_exports.uuid().nullable(),
+    ownerId: ownerIdSchema.nullable(),
+    code: desktopCollaborationBrokerChildErrorCodeSchema,
+    message: external_exports.string().min(1).max(512)
+  })
+]);
+var measureDesktopCollaborationBrokerMessageBytes = (value) => Buffer2.byteLength(JSON.stringify(value), "utf8");
+
+// packages/koed-server/dist/desktop-collaboration-broker-local-transport.js
+import { randomUUID } from "node:crypto";
+
+// packages/shared/src/durable-realtime.ts
+var negotiateDurableRealtimeTransport = (offered, supported) => {
+  const supportedSet = new Set(supported);
+  return offered.find((transportId) => supportedSet.has(transportId)) ?? null;
+};
+var defaultSleep = (delayMs, signal) => new Promise((resolve) => {
+  if (signal.aborted) return resolve();
+  const finish = () => {
+    clearTimeout(timer);
+    signal.removeEventListener("abort", finish);
+    resolve();
+  };
+  const timer = setTimeout(finish, delayMs);
+  timer.unref?.();
+  signal.addEventListener("abort", finish, { once: true });
+});
+var assertRetryPolicy = (policy) => {
+  if (!Number.isSafeInteger(policy.maxAttempts) || policy.maxAttempts < 1 || !Number.isSafeInteger(policy.attemptWindowMs) || policy.attemptWindowMs < 1 || !Number.isSafeInteger(policy.unavailableCooldownMs) || policy.unavailableCooldownMs < 1) {
+    throw new TypeError("Durable realtime retry policy is invalid");
+  }
+};
+var retryDelay = (policy, attempt) => {
+  const delay = policy.delayForAttempt(attempt);
+  if (!Number.isFinite(delay) || delay < 0) {
+    throw new TypeError("Durable realtime retry delay is invalid");
+  }
+  return Math.round(delay);
+};
+var runDurableRealtime = async (options) => {
+  assertRetryPolicy(options.retry);
+  const now = options.now ?? Date.now;
+  const sleep = options.sleep ?? defaultSleep;
+  const isCurrent = () => !options.signal.aborted && (options.isCurrent?.() ?? true);
+  const emitState = (state) => {
+    if (!isCurrent()) return false;
+    options.onState(state);
+    return isCurrent();
+  };
+  const attempts = [];
+  let reconnecting = false;
+  if (!emitState({
+    state: "connecting",
+    reconnectAttempt: 0,
+    retryAtMs: null,
+    retryDelayMs: null
+  })) {
+    return;
+  }
+  while (isCurrent()) {
+    try {
+      let live = false;
+      const outcome = await options.connect({
+        signal: options.signal,
+        reconnecting,
+        isCurrent,
+        markLive: () => {
+          if (live) return;
+          live = true;
+          emitState({
+            state: "live",
+            reconnectAttempt: 0,
+            retryAtMs: null,
+            retryDelayMs: null
+          });
+        }
+      });
+      if (!isCurrent() || outcome === "terminal") return;
+    } catch {
+      if (!isCurrent()) return;
+    }
+    reconnecting = true;
+    const attemptNow = now();
+    while (attempts.length > 0 && attemptNow - attempts[0] >= options.retry.attemptWindowMs) {
+      attempts.shift();
+    }
+    if (attempts.length >= options.retry.maxAttempts) {
+      const delay2 = options.retry.unavailableCooldownMs;
+      if (!emitState({
+        state: "unavailable",
+        reconnectAttempt: options.retry.maxAttempts,
+        retryAtMs: attemptNow + delay2,
+        retryDelayMs: delay2
+      })) {
+        return;
+      }
+      await sleep(delay2, options.signal);
+      attempts.length = 0;
+      continue;
+    }
+    attempts.push(attemptNow);
+    const attempt = attempts.length;
+    const delay = retryDelay(options.retry, attempt);
+    if (!emitState({
+      state: "reconnecting",
+      reconnectAttempt: attempt,
+      retryAtMs: attemptNow + delay,
+      retryDelayMs: delay
+    })) {
+      return;
+    }
+    await sleep(delay, options.signal);
+  }
+};
+var utf8Bytes = (value) => new TextEncoder().encode(value).byteLength;
+var readBoundedSse = async (options) => {
+  if (!Number.isSafeInteger(options.maxFrameBytes) || options.maxFrameBytes < 1) {
+    throw new TypeError("SSE frame byte limit is invalid");
+  }
+  const reader = options.body.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let buffer = "";
+  let previousChunkEndedWithCr = false;
+  const appendDecoded = (text) => {
+    if (!text) return;
+    if (previousChunkEndedWithCr && text.startsWith("\n")) {
+      text = text.slice(1);
+    }
+    previousChunkEndedWithCr = text.endsWith("\r");
+    buffer += text.replace(/\r\n|\r/g, "\n");
+  };
+  const consumeFrame = async (frame) => {
+    if (utf8Bytes(frame) > options.maxFrameBytes) {
+      throw new Error("SSE frame exceeded its byte limit");
+    }
+    const lines = frame.split("\n");
+    if (lines.every((line) => line === "" || line.startsWith(":"))) {
+      return "continue";
+    }
+    let event = "message";
+    const data = [];
+    for (const line of lines) {
+      if (line.startsWith(":")) continue;
+      const separator = line.indexOf(":");
+      const field = separator < 0 ? line : line.slice(0, separator);
+      let value = separator < 0 ? "" : line.slice(separator + 1);
+      if (value.startsWith(" ")) value = value.slice(1);
+      if (field === "event") event = value;
+      else if (field === "data") data.push(value);
+    }
+    return options.onFrame({ event, data: data.join("\n") });
+  };
+  try {
+    for (; ; ) {
+      if (options.signal.aborted) return "terminal";
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      appendDecoded(decoder.decode(chunk.value, { stream: true }));
+      for (; ; ) {
+        const boundary = buffer.indexOf("\n\n");
+        if (boundary < 0) break;
+        const frame = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        if (await consumeFrame(frame) === "terminal") return "terminal";
+      }
+      if (utf8Bytes(buffer) > options.maxFrameBytes) {
+        throw new Error("SSE frame exceeded its byte limit");
+      }
+    }
+    appendDecoded(decoder.decode());
+    if (buffer.trim() && await consumeFrame(buffer) === "terminal") {
+      return "terminal";
+    }
+    return "ended";
+  } finally {
+    await reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+};
+
+// packages/koed-server/dist/desktop-collaboration-broker-local-transport.js
+var collaborationCommandPath = "/v1/local-edge/collaboration/command";
+var collaborationRealtimeSubscriptionsPath = "/v1/local-edge/collaboration/realtime/subscriptions";
+var collaborationRealtimeBackendSubscriptionsPath = (backendId) => `/v1/local-edge/collaboration/realtime/backends/${encodeURIComponent(backendId)}/subscriptions`;
+var commandRequestMaxBytes = 128 * 1024;
+var commandResponseMaxBytes = 32 * 1024 * 1024;
+var commandTimeoutMs = 3e4;
+var reconnectBaseMs = 250;
+var reconnectJitterRatio = 0.2;
+var commandRequiresTeamBackend = (command, existing) => {
+  if (existing)
+    return existing.scope === "team";
+  switch (command.command) {
+    case "collaboration.load":
+    case "collaboration.connect_backend":
+    case "collaboration.reconnect_backend":
+    case "collaboration.disconnect_backend":
+    case "collaboration.create_personal_channel":
+    case "collaboration.preview_shared_memory_candidate":
+      return false;
+    case "collaboration.select":
+      return isTeamCollaborationSelection(command.input.selection);
+    case "collaboration.rename_thread":
+    case "collaboration.update_thread_topic":
+    case "collaboration.archive_thread":
+    case "collaboration.restore_thread":
+    case "collaboration.send_message":
+    case "collaboration.retry_message":
+    case "collaboration.mark_read":
+    case "collaboration.load_message_page":
+      return command.input.thread.scope === "team";
+    case "collaboration.subscribe":
+      return command.input.scope.scope === "team";
+    case "collaboration.unsubscribe":
+    case "collaboration.acknowledge_delivery":
+      return false;
+    default:
+      return true;
+  }
+};
+var safeError = (code, retryAfterMs = null) => ({
+  code,
+  userMessage: collaborationSafeErrorMessages[code],
+  retryable: code === "offline" || code === "temporarily_unavailable" || code === "rate_limited" || code === "conflict",
+  retryAfterMs
+});
+var failureResult = (command, error) => collaborationCommandResultSchema.parse({
+  contractVersion: COLLABORATION_CONTRACT_VERSION,
+  requestId: command.requestId,
+  command: command.command,
+  ok: false,
+  error
+});
+var retryAfterFrom = (response) => {
+  const value = response.headers.get("retry-after");
+  if (value === null)
+    return null;
+  const seconds = Number(value);
+  return Number.isFinite(seconds) && seconds >= 0 ? Math.min(3e5, Math.round(seconds * 1e3)) : null;
+};
+var errorForStatus = (response) => {
+  if (response.status === 400 || response.status === 422) {
+    return safeError("invalid_input");
+  }
+  if (response.status === 401 || response.status === 403) {
+    return safeError("permission_denied");
+  }
+  if (response.status === 404)
+    return safeError("not_available");
+  if (response.status === 409)
+    return safeError("conflict");
+  if (response.status === 410)
+    return safeError("access_revoked");
+  if (response.status === 429) {
+    return safeError("rate_limited", retryAfterFrom(response));
+  }
+  if ([502, 503, 504].includes(response.status)) {
+    return safeError("temporarily_unavailable", retryAfterFrom(response));
+  }
+  return safeError("internal_error");
+};
+var linkedAbortController = (signal, timeoutMs) => {
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  if (signal.aborted)
+    controller.abort();
+  else
+    signal.addEventListener("abort", abort, { once: true });
+  const timer = timeoutMs === void 0 ? null : setTimeout(() => controller.abort(), timeoutMs);
+  timer?.unref?.();
+  return {
+    controller,
+    dispose: () => {
+      signal.removeEventListener("abort", abort);
+      if (timer)
+        clearTimeout(timer);
+    }
+  };
+};
+var calculateCollaborationReconnectDelay2 = (attempt, random) => calculateCollaborationReconnectDelay({
+  attempt: Math.max(0, attempt - 1),
+  baseMs: reconnectBaseMs,
+  maxMs: COLLABORATION_RECONNECT_BACKOFF_CAP_MS,
+  jitter: reconnectJitterRatio,
+  random
+});
+var parseCorrelatedResult = (payload, command) => {
+  const parsed = collaborationCommandResultSchema.safeParse(payload);
+  if (!parsed.success || parsed.data.requestId !== command.requestId || parsed.data.command !== command.command) {
+    return null;
+  }
+  return parsed.data;
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var hasExactKeys = (value, keys) => {
+  const actual = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+};
+var parseBrokerSubscription = (raw, expectedScope, expectedTeamId) => {
+  if (!isRecord(raw) || !hasExactKeys(raw, [
+    "id",
+    "protocolVersion",
+    "scope",
+    "state",
+    "version",
+    "expiresAt"
+  ]) || raw.protocolVersion !== COLLABORATION_CONTRACT_VERSION || !Number.isSafeInteger(raw.version) || Number(raw.version) < 0 || !isRecord(raw.scope)) {
+    throw new Error("Collaboration broker subscription is invalid");
+  }
+  const scope = expectedScope === "team" ? { scope: "team", teamId: expectedTeamId } : { scope: "personal" };
+  if (expectedScope === "personal" && (!hasExactKeys(raw.scope, ["scope"]) || raw.scope.scope !== "personal") || expectedScope === "team" && (!hasExactKeys(raw.scope, ["scope", "teamId"]) || raw.scope.scope !== "team" || raw.scope.teamId !== expectedTeamId)) {
+    throw new Error("Collaboration broker subscription binding is invalid");
+  }
+  const brokerVersion = Number(raw.version);
+  return {
+    brokerVersion,
+    subscription: collaborationSubscriptionSchema.parse({
+      id: raw.id,
+      scope,
+      state: raw.state,
+      version: Math.max(1, brokerVersion),
+      expiresAt: raw.expiresAt
+    })
+  };
+};
+var parseBrokerSnapshotResponse = (raw, scope, teamId) => {
+  if (!isRecord(raw) || !hasExactKeys(raw, ["protocolVersion", "subscription", "delivery"]) || raw.protocolVersion !== COLLABORATION_CONTRACT_VERSION || !isRecord(raw.delivery) || !hasExactKeys(raw.delivery, [
+    "deliveryId",
+    "eventId",
+    "type",
+    "snapshot"
+  ]) || raw.delivery.type !== "snapshot" || raw.delivery.eventId !== null || !isRecord(raw.delivery.snapshot) || !Array.isArray(raw.delivery.snapshot.threads) || raw.delivery.snapshot.threads.length > 5e3) {
+    throw new Error("Collaboration broker snapshot response is invalid");
+  }
+  const snapshot = raw.delivery.snapshot;
+  const threads = snapshot.threads;
+  const snapshotMatches = scope === "team" ? hasExactKeys(snapshot, ["scope", "teamId", "threads"]) && snapshot.scope === "team" && snapshot.teamId === teamId && threads.every((thread) => isRecord(thread) && thread.scope === "team" && thread.teamId === teamId) : hasExactKeys(snapshot, [
+    "scope",
+    "personalOwnerUserId",
+    "highWaterCursor",
+    "threads"
+  ]) && snapshot.scope === "personal" && typeof snapshot.personalOwnerUserId === "string" && Number.isSafeInteger(snapshot.highWaterCursor) && Number(snapshot.highWaterCursor) >= 0 && threads.every((thread) => isRecord(thread) && thread.scope === "personal");
+  if (!snapshotMatches) {
+    throw new Error("Collaboration broker snapshot binding is invalid");
+  }
+  const parsed = parseBrokerSubscription(raw.subscription, scope, teamId);
+  if (parsed.subscription.state !== "awaiting_snapshot_ack") {
+    throw new Error("Collaboration broker snapshot is not awaiting ack");
+  }
+  return {
+    ...parsed,
+    deliveryId: collaborationDeliveryIdSchema.parse(raw.delivery.deliveryId)
+  };
+};
+var parseBrokerAckResponse = (raw, subscription) => {
+  if (!isRecord(raw) || !hasExactKeys(raw, ["protocolVersion", "subscription"]) || raw.protocolVersion !== COLLABORATION_CONTRACT_VERSION) {
+    throw new Error("Collaboration broker acknowledgement is invalid");
+  }
+  const parsed = parseBrokerSubscription(raw.subscription, subscription.scope, subscription.teamId);
+  if (parsed.subscription.id !== subscription.id || parsed.subscription.state !== "active") {
+    throw new Error("Collaboration broker acknowledgement binding is invalid");
+  }
+  return parsed;
+};
+var createDesktopCollaborationBrokerLocalTransport = (options) => {
+  const random = options.random ?? Math.random;
+  const now = options.now ?? Date.now;
+  const subscriptions = /* @__PURE__ */ new Map();
+  const latestTeamSelections = /* @__PURE__ */ new Map();
+  const activeTeamIds = /* @__PURE__ */ new Map();
+  const snapshotRequestGenerations = /* @__PURE__ */ new Map();
+  const authorityGenerations = /* @__PURE__ */ new Map();
+  let preferredBackendId;
+  const authorityGeneration = (ownerId) => authorityGenerations.get(ownerId) ?? 0;
+  const commandAffectsActiveSelection = (command) => collaborationCommandReturnsSnapshot(command.command) && !(command.command === "collaboration.select" && command.input.navigationIntent === "prewarm");
+  const invalidateAuthority = (ownerId, teamId) => {
+    authorityGenerations.set(ownerId, authorityGeneration(ownerId) + 1);
+    if (teamId) {
+      const selections = latestTeamSelections.get(ownerId);
+      selections?.delete(teamId);
+      if (selections?.size === 0)
+        latestTeamSelections.delete(ownerId);
+    } else {
+      latestTeamSelections.delete(ownerId);
+    }
+  };
+  const rememberTeamSelection = (ownerId, selection) => {
+    if (!("teamId" in selection))
+      return;
+    const selections = latestTeamSelections.get(ownerId) ?? /* @__PURE__ */ new Map();
+    selections.set(selection.teamId, selection);
+    latestTeamSelections.set(ownerId, selections);
+  };
+  const eventInvalidatesSelection = (event) => event.type === "connection" && (event.connection.state === "disconnected" || event.connection.state === "access_revoked") || event.type === "control" && event.reason === "access_revoked" || event.type === "update" && event.family === "access_revoked";
+  const emit = (subscription, event) => {
+    const parsed = collaborationRendererEventSchema.parse(event);
+    const matchesSubscription = parsed.type === "snapshot" && parsed.subscription.id === subscription.id && parsed.subscription.scope.scope === subscription.scope && (subscription.scope !== "team" || parsed.subscription.scope.scope === "team" && parsed.subscription.scope.teamId === subscription.teamId) || parsed.type === "update" && parsed.subscriptionId === subscription.id && (subscription.scope !== "team" || parsed.resource.teamId === subscription.teamId) || parsed.type === "control" && parsed.subscriptionId === subscription.id || parsed.type === "connection" && subscription.scope === "team" && parsed.connection.backendId === subscription.connection.backendId;
+    if (!matchesSubscription) {
+      throw new Error("Collaboration stream event binding is invalid");
+    }
+    if (eventInvalidatesSelection(parsed)) {
+      invalidateAuthority(subscription.ownerId, subscription.teamId);
+    }
+    if (parsed.type === "connection" && parsed.connection.state !== "access_revoked" && activeTeamIds.get(subscription.ownerId) !== subscription.teamId) {
+      return;
+    }
+    subscription.emit(parsed);
+  };
+  const emitConnection = (subscription, state, reconnectAttempt, retryAt, error) => {
+    if (subscription.scope === "personal")
+      return;
+    emit(subscription, {
+      contractVersion: COLLABORATION_CONTRACT_VERSION,
+      type: "connection",
+      connection: {
+        state,
+        backendId: subscription.connection.backendId,
+        connectedAt: state === "live" ? new Date(now()).toISOString() : null,
+        retryAt,
+        reconnectAttempt,
+        protocolVersion: COLLABORATION_CONTRACT_VERSION
+      },
+      error
+    });
+  };
+  const emitTerminalControl = (subscription, reason) => {
+    emit(subscription, {
+      contractVersion: COLLABORATION_CONTRACT_VERSION,
+      type: "control",
+      subscriptionId: subscription.id,
+      occurredAt: new Date(now()).toISOString(),
+      reason
+    });
+  };
+  const parseBrokerStreamFrame = (subscription, eventName, payload) => {
+    const sharedEvent = collaborationRendererEventSchema.safeParse(payload);
+    if (sharedEvent.success) {
+      if (sharedEvent.data.type === "connection" && subscription.scope === "personal") {
+        return "continue";
+      }
+      emit(subscription, sharedEvent.data);
+      return sharedEvent.data.type === "control" ? "terminal" : "continue";
+    }
+    if (!isRecord(payload) || payload.protocolVersion !== COLLABORATION_CONTRACT_VERSION) {
+      throw new Error("Collaboration broker frame is invalid");
+    }
+    if (eventName === "ready") {
+      if (!hasExactKeys(payload, ["protocolVersion", "subscription"]) || !isRecord(payload.subscription) || !hasExactKeys(payload.subscription, ["id", "state", "version"]) || payload.subscription.id !== subscription.id || payload.subscription.state !== "active" || !Number.isSafeInteger(payload.subscription.version) || Number(payload.subscription.version) !== subscription.brokerVersion) {
+        throw new Error("Collaboration broker ready frame is invalid");
+      }
+      return "continue";
+    }
+    if (eventName === "heartbeat") {
+      if (!hasExactKeys(payload, ["protocolVersion", "subscription"]) || !isRecord(payload.subscription) || !hasExactKeys(payload.subscription, ["id"]) || payload.subscription.id !== subscription.id) {
+        throw new Error("Collaboration broker heartbeat frame is invalid");
+      }
+      return "continue";
+    }
+    if (eventName === "control" || eventName === "access_revoked") {
+      if (!hasExactKeys(payload, ["protocolVersion", "subscription", "reason"]) || !isRecord(payload.subscription) || !hasExactKeys(payload.subscription, ["id"]) || payload.subscription.id !== subscription.id || ![
+        "access_revoked",
+        "requires_snapshot",
+        "backpressure",
+        "server_shutdown"
+      ].includes(String(payload.reason))) {
+        throw new Error("Collaboration broker control frame is invalid");
+      }
+      const reason = eventName === "access_revoked" ? "access_revoked" : payload.reason;
+      emit(subscription, {
+        contractVersion: COLLABORATION_CONTRACT_VERSION,
+        type: "control",
+        subscriptionId: subscription.id,
+        occurredAt: new Date(now()).toISOString(),
+        reason
+      });
+      return "terminal";
+    }
+    if (eventName === "collaboration_event") {
+      if (!hasExactKeys(payload, [
+        "protocolVersion",
+        "deliveryId",
+        "eventId",
+        "type",
+        "occurredAt",
+        "subscription",
+        "resource",
+        "actor"
+      ]) || !isRecord(payload.subscription) || !hasExactKeys(payload.subscription, ["id"]) || payload.subscription.id !== subscription.id || !isRecord(payload.resource) || payload.resource.scope !== subscription.scope || subscription.scope === "team" && payload.resource.teamId !== subscription.teamId || !isRecord(payload.actor)) {
+        throw new Error("Collaboration broker event frame is invalid");
+      }
+      collaborationDeliveryIdSchema.parse(payload.deliveryId);
+      emitTerminalControl(subscription, "requires_snapshot");
+      return "terminal";
+    }
+    throw new Error("Collaboration broker event type is unsupported");
+  };
+  const runStream = async (subscription) => {
+    await runDurableRealtime({
+      signal: subscription.controller.signal,
+      isCurrent: () => subscriptions.get(subscription.id) === subscription,
+      now,
+      sleep: options.sleep,
+      retry: {
+        maxAttempts: COLLABORATION_RECONNECT_MAX_ATTEMPTS,
+        attemptWindowMs: COLLABORATION_RECONNECT_WINDOW_MS,
+        unavailableCooldownMs: COLLABORATION_RECONNECT_UNAVAILABLE_COOLDOWN_MS,
+        delayForAttempt: (attempt) => calculateCollaborationReconnectDelay2(attempt, random())
+      },
+      onState: (state) => {
+        if (state.state === "connecting" || state.state === "live") {
+          emitConnection(subscription, state.state, 0, null, null);
+          return;
+        }
+        emitConnection(subscription, state.state, state.reconnectAttempt, new Date(state.retryAtMs).toISOString(), safeError("temporarily_unavailable", state.retryDelayMs));
+      },
+      connect: async ({ signal, reconnecting, isCurrent, markLive }) => {
+        if (reconnecting) {
+          const backendId = subscription.connection.backendId;
+          const refreshedConnection = await options.resolveConnection(subscription.scope === "team", backendId ?? void 0).catch(() => null);
+          if (!refreshedConnection || refreshedConnection.backendId !== backendId) {
+            throw new Error("Collaboration stream connection is unavailable");
+          }
+          subscription.connection = refreshedConnection;
+        }
+        if (!isCurrent())
+          return "terminal";
+        const transportId = negotiateDurableRealtimeTransport(options.offeredRealtimeTransports?.(subscription.connection) ?? [
+          "sse"
+        ], ["sse"]);
+        if (transportId !== "sse") {
+          throw new Error("Collaboration realtime transport is unavailable");
+        }
+        const url = new URL(`${collaborationRealtimeSubscriptionsPath}/${encodeURIComponent(subscription.id)}/stream`, subscription.connection.apiUrl);
+        if (subscription.connection.backendId) {
+          url.searchParams.set("scope", "team");
+          url.searchParams.set("upstream_backend_id", subscription.connection.backendId);
+        }
+        if (subscription.teamId)
+          url.searchParams.set("team_id", subscription.teamId);
+        else
+          url.searchParams.set("scope", "personal");
+        const response = await options.fetch(url, {
+          method: "GET",
+          headers: {
+            accept: "text/event-stream",
+            authorization: subscription.connection.authorization
+          },
+          redirect: "error",
+          signal
+        });
+        if (!response.ok || !response.body || !response.headers.get("content-type")?.toLowerCase().startsWith("text/event-stream")) {
+          await response.body?.cancel().catch(() => void 0);
+          if ([401, 403, 410].includes(response.status)) {
+            emitConnection(subscription, "access_revoked", 0, null, safeError("access_revoked"));
+            return "terminal";
+          }
+          if (response.status === 404 || response.status === 409) {
+            emitTerminalControl(subscription, "requires_snapshot");
+            return "terminal";
+          }
+          throw new Error("Collaboration stream is unavailable");
+        }
+        markLive();
+        return readBoundedSse({
+          body: response.body,
+          signal,
+          maxFrameBytes: COLLABORATION_RENDERER_MAX_PENDING_BYTES,
+          onFrame: ({ event, data }) => {
+            if (!isCurrent())
+              return "terminal";
+            if (!data) {
+              throw new Error("Collaboration stream frame has no payload");
+            }
+            const payload = JSON.parse(data);
+            return parseBrokerStreamFrame(subscription, event, payload);
+          }
+        });
+      }
+    });
+  };
+  const stopSubscription = (subscriptionId) => {
+    const subscription = subscriptions.get(subscriptionId);
+    if (!subscription)
+      return;
+    subscription.controller.abort();
+    subscriptions.delete(subscriptionId);
+  };
+  const serializeSubscriptionOperation = (subscription, operation) => {
+    const result = subscription.operationTail.then(operation, operation);
+    subscription.operationTail = result.then(() => void 0, () => void 0);
+    return result;
+  };
+  const realtimeBinding = (subscription) => subscription.scope === "team" ? {
+    scope: "team",
+    upstream_backend_id: subscription.connection.backendId,
+    team_id: subscription.teamId
+  } : { scope: "personal" };
+  const acknowledgeDelivery = async (command, subscription, context) => {
+    if (subscription.scope === "team" && (!subscription.connection.backendId || !subscription.teamId)) {
+      return failureResult(command, safeError("not_available"));
+    }
+    if (command.input.expectedSubscriptionVersion !== subscription.version) {
+      emitTerminalControl(subscription, "requires_snapshot");
+      stopSubscription(subscription.id);
+      return failureResult(command, safeError("conflict"));
+    }
+    const linked = linkedAbortController(context.signal, commandTimeoutMs);
+    try {
+      const response = await options.fetch(new URL(`${collaborationRealtimeSubscriptionsPath}/${encodeURIComponent(subscription.id)}/ack`, subscription.connection.apiUrl), {
+        method: "POST",
+        headers: {
+          accept: "application/json",
+          authorization: subscription.connection.authorization,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          ...realtimeBinding(subscription),
+          delivery_id: command.input.deliveryId,
+          event_id: command.input.eventId,
+          expected_version: subscription.brokerVersion
+        }),
+        redirect: "error",
+        signal: linked.controller.signal
+      });
+      const payload = await readBoundedJsonObject(response, 1024 * 1024).catch(() => null);
+      if (!response.ok) {
+        if ([401, 403, 410].includes(response.status)) {
+          emitTerminalControl(subscription, "access_revoked");
+          stopSubscription(subscription.id);
+          return failureResult(command, safeError("access_revoked"));
+        }
+        if (response.status === 404 || response.status === 409) {
+          emitTerminalControl(subscription, "requires_snapshot");
+          stopSubscription(subscription.id);
+          return failureResult(command, safeError("conflict"));
+        }
+        return failureResult(command, errorForStatus(response));
+      }
+      const acknowledged = parseBrokerAckResponse(payload, subscription);
+      subscription.brokerVersion = acknowledged.brokerVersion;
+      subscription.version = acknowledged.subscription.version;
+      const startsStream = subscription.initialDeliveryId === command.input.deliveryId;
+      if (startsStream)
+        subscription.initialDeliveryId = null;
+      if (startsStream && !subscription.streamStarted) {
+        subscription.streamStarted = true;
+        void runStream(subscription).finally(() => {
+          if (subscriptions.get(subscription.id) === subscription) {
+            subscriptions.delete(subscription.id);
+          }
+        });
+      }
+      return collaborationCommandResultSchema.parse({
+        contractVersion: COLLABORATION_CONTRACT_VERSION,
+        requestId: command.requestId,
+        command: command.command,
+        ok: true,
+        data: {
+          subscriptionId: subscription.id,
+          acknowledgedEventId: command.input.eventId,
+          subscriptionVersion: subscription.version
+        }
+      });
+    } catch {
+      return failureResult(command, safeError("offline"));
+    } finally {
+      linked.dispose();
+    }
+  };
+  const unsubscribe = async (command, subscription, context) => {
+    if (subscription.scope === "team" && (!subscription.connection.backendId || !subscription.teamId)) {
+      return failureResult(command, safeError("not_available"));
+    }
+    subscription.controller.abort();
+    const linked = linkedAbortController(context.signal, commandTimeoutMs);
+    try {
+      const response = await options.fetch(new URL(`${collaborationRealtimeSubscriptionsPath}/${encodeURIComponent(subscription.id)}`, subscription.connection.apiUrl), {
+        method: "DELETE",
+        headers: {
+          accept: "application/json",
+          authorization: subscription.connection.authorization,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          ...realtimeBinding(subscription),
+          expected_version: subscription.version
+        }),
+        redirect: "error",
+        signal: linked.controller.signal
+      });
+      await response.body?.cancel().catch(() => void 0);
+      if (!response.ok) {
+        if ([401, 403, 409, 410].includes(response.status)) {
+          emitTerminalControl(subscription, "access_revoked");
+          stopSubscription(subscription.id);
+          return failureResult(command, safeError("access_revoked"));
+        }
+        return failureResult(command, errorForStatus(response));
+      }
+      stopSubscription(subscription.id);
+      return collaborationCommandResultSchema.parse({
+        contractVersion: COLLABORATION_CONTRACT_VERSION,
+        requestId: command.requestId,
+        command: command.command,
+        ok: true,
+        data: {}
+      });
+    } catch {
+      return failureResult(command, safeError("offline"));
+    } finally {
+      linked.dispose();
+      stopSubscription(subscription.id);
+    }
+  };
+  const fetchAuthorizedResnapshot = async (scope, teamId, connection, context) => {
+    const latestSelection = teamId ? latestTeamSelections.get(context.ownerId)?.get(teamId) : void 0;
+    let selection = null;
+    if (scope === "team") {
+      if (!latestSelection || teamId === null || !("teamId" in latestSelection) || latestSelection.teamId !== teamId) {
+        return null;
+      }
+      selection = latestSelection;
+    }
+    const command = collaborationRendererCommandSchema.parse({
+      contractVersion: COLLABORATION_CONTRACT_VERSION,
+      requestId: randomUUID(),
+      command: scope === "team" ? "collaboration.select" : "collaboration.load",
+      input: scope === "team" ? { selection } : {}
+    });
+    const body = JSON.stringify({
+      ...scope === "team" ? { upstream_backend_id: connection.backendId } : {},
+      command
+    });
+    const linked = linkedAbortController(context.signal, commandTimeoutMs);
+    try {
+      const response = await options.fetch(new URL(collaborationCommandPath, connection.apiUrl), {
+        method: "POST",
+        headers: {
+          accept: "application/json",
+          authorization: connection.authorization,
+          "content-type": "application/json"
+        },
+        body,
+        redirect: "error",
+        signal: linked.controller.signal
+      });
+      const payload = await readBoundedJsonObject(response, commandResponseMaxBytes).catch(() => null);
+      const result = parseCorrelatedResult(payload, command);
+      if (!response.ok || !result?.ok || !("snapshot" in result.data)) {
+        return null;
+      }
+      return collaborationSnapshotSchema.parse(result.data.snapshot);
+    } catch {
+      return null;
+    } finally {
+      linked.dispose();
+    }
+  };
+  const realtimeSnapshotFrom = (scope, teamId, full) => {
+    if (scope === "personal") {
+      const personalSelection = !("teamId" in full.selection);
+      return {
+        scope: "personal",
+        snapshotRevision: full.snapshotRevision,
+        personalOwner: full.navigation.personalOwner,
+        personal: full.navigation.personal,
+        selection: personalSelection ? full.selection : { kind: "personal_memory" },
+        view: personalSelection ? full.view : {
+          kind: "personal_memory",
+          entries: full.navigation.personal.memory
+        }
+      };
+    }
+    const team = full.navigation.teams.find((item) => item.id === teamId);
+    if (!team || !full.navigation.teamPrincipal || !("teamId" in full.selection) || full.selection.teamId !== teamId) {
+      throw new Error("Authorized Team resnapshot binding is invalid");
+    }
+    return {
+      scope: "team",
+      teamId: team.id,
+      snapshotRevision: full.snapshotRevision,
+      teamPrincipal: full.navigation.teamPrincipal,
+      team,
+      selection: full.selection,
+      view: full.view
+    };
+  };
+  const subscribeRealtime = async (command, connection, context, expectedAuthorityGeneration) => {
+    const scope = command.input.scope.scope;
+    const teamId = command.input.scope.scope === "team" ? command.input.scope.teamId : null;
+    if (scope === "team" && !connection.backendId) {
+      return failureResult(command, safeError("not_available"));
+    }
+    const binding = scope === "team" ? {
+      scope: "team",
+      upstream_backend_id: connection.backendId,
+      team_id: teamId
+    } : { scope: "personal" };
+    const linked = linkedAbortController(context.signal, commandTimeoutMs);
+    try {
+      const response = await options.fetch(new URL(collaborationRealtimeSubscriptionsPath, connection.apiUrl), {
+        method: "POST",
+        headers: {
+          accept: "application/json",
+          authorization: connection.authorization,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(binding),
+        redirect: "error",
+        signal: linked.controller.signal
+      });
+      const payload = await readBoundedJsonObject(response, commandResponseMaxBytes).catch(() => null);
+      if (authorityGeneration(context.ownerId) !== expectedAuthorityGeneration) {
+        return failureResult(command, safeError("access_revoked"));
+      }
+      if (!response.ok) {
+        return failureResult(command, [401, 403, 409, 410].includes(response.status) ? safeError("access_revoked") : errorForStatus(response));
+      }
+      const broker = parseBrokerSnapshotResponse(payload, scope, teamId);
+      const full = await fetchAuthorizedResnapshot(scope, teamId, connection, context);
+      if (authorityGeneration(context.ownerId) !== expectedAuthorityGeneration) {
+        return failureResult(command, safeError("access_revoked"));
+      }
+      if (!full)
+        return failureResult(command, safeError("internal_error"));
+      const event = collaborationRendererEventSchema.parse({
+        contractVersion: COLLABORATION_CONTRACT_VERSION,
+        type: "snapshot",
+        subscription: broker.subscription,
+        deliveryId: broker.deliveryId,
+        eventId: null,
+        snapshot: realtimeSnapshotFrom(scope, teamId, full)
+      });
+      stopSubscription(broker.subscription.id);
+      const active = {
+        id: broker.subscription.id,
+        ownerId: context.ownerId,
+        scope,
+        teamId,
+        version: broker.subscription.version,
+        brokerVersion: broker.brokerVersion,
+        initialDeliveryId: broker.deliveryId,
+        streamStarted: false,
+        connection,
+        controller: new AbortController(),
+        emit: context.emitCollaborationEvent,
+        operationTail: Promise.resolve()
+      };
+      subscriptions.set(active.id, active);
+      const abortForOwner = () => stopSubscription(active.id);
+      context.signal.addEventListener("abort", abortForOwner, { once: true });
+      setTimeout(() => {
+        if (subscriptions.get(active.id) !== active || active.controller.signal.aborted) {
+          return;
+        }
+        try {
+          emit(active, event);
+        } catch {
+          stopSubscription(active.id);
+        }
+      }, 0);
+      return collaborationCommandResultSchema.parse({
+        contractVersion: COLLABORATION_CONTRACT_VERSION,
+        requestId: command.requestId,
+        command: command.command,
+        ok: true,
+        data: { subscription: broker.subscription }
+      });
+    } catch {
+      return failureResult(command, safeError("internal_error"));
+    } finally {
+      linked.dispose();
+    }
+  };
+  const request = async (command, context) => {
+    const snapshotRequestGeneration = commandAffectsActiveSelection(command) ? (snapshotRequestGenerations.get(context.ownerId) ?? 0) + 1 : null;
+    if (snapshotRequestGeneration !== null) {
+      snapshotRequestGenerations.set(context.ownerId, snapshotRequestGeneration);
+    }
+    const requestAuthorityGeneration = authorityGeneration(context.ownerId);
+    const existing = "subscriptionId" in command.input ? subscriptions.get(command.input.subscriptionId) : void 0;
+    if (existing && existing.ownerId !== context.ownerId) {
+      return failureResult(command, safeError("not_available"));
+    }
+    const connection = existing?.connection ?? await options.resolveConnection(commandRequiresTeamBackend(command, existing), preferredBackendId, ...command.command === "collaboration.amend_rule_detail" || command.command === "collaboration.amend_rule_content_policy" || command.command === "collaboration.control_sharing_rule" || command.command === "collaboration.create_conversation_rule" || command.command === "collaboration.create_repository_rule" || command.command === "collaboration.list_sharing_rule_deliveries" ? [true] : []).catch(() => null);
+    if (!connection)
+      return failureResult(command, safeError("offline"));
+    const requiresTeamBackend = commandRequiresTeamBackend(command, existing);
+    if (requiresTeamBackend && !connection.backendId) {
+      return failureResult(command, safeError("offline"));
+    }
+    if (command.command === "collaboration.acknowledge_delivery") {
+      return existing ? serializeSubscriptionOperation(existing, () => acknowledgeDelivery(command, existing, context)) : failureResult(command, safeError("not_available"));
+    }
+    if (command.command === "collaboration.unsubscribe") {
+      existing?.controller.abort();
+      return existing ? serializeSubscriptionOperation(existing, () => unsubscribe(command, existing, context)) : failureResult(command, safeError("not_available"));
+    }
+    if (command.command === "collaboration.subscribe") {
+      return subscribeRealtime(command, connection, context, requestAuthorityGeneration);
+    }
+    const body = JSON.stringify({
+      ...requiresTeamBackend ? { upstream_backend_id: connection.backendId } : {},
+      command
+    });
+    if (Buffer.byteLength(body, "utf8") > commandRequestMaxBytes) {
+      return failureResult(command, safeError("invalid_input"));
+    }
+    const linked = linkedAbortController(context.signal, commandTimeoutMs);
+    try {
+      const response = await options.fetch(new URL(collaborationCommandPath, connection.apiUrl), {
+        method: "POST",
+        headers: {
+          accept: "application/json",
+          authorization: connection.authorization,
+          "content-type": "application/json"
+        },
+        body,
+        redirect: "error",
+        signal: linked.controller.signal
+      });
+      const payload = await readBoundedJsonObject(response, commandResponseMaxBytes).catch(() => null);
+      const result = parseCorrelatedResult(payload, command);
+      if (!result) {
+        return failureResult(command, response.ok ? safeError("internal_error") : errorForStatus(response));
+      }
+      if (authorityGeneration(context.ownerId) !== requestAuthorityGeneration) {
+        return failureResult(command, safeError("access_revoked"));
+      }
+      if (result.ok && result.command === "collaboration.connect_backend") {
+        preferredBackendId = result.data.backend.id;
+      }
+      if (result.ok && result.command === "collaboration.disconnect_backend") {
+        invalidateAuthority(context.ownerId);
+      }
+      if (result.ok && "snapshot" in result.data && snapshotRequestGeneration !== null && snapshotRequestGenerations.get(context.ownerId) === snapshotRequestGeneration) {
+        const parsedSnapshot = collaborationSnapshotSchema.parse(result.data.snapshot);
+        rememberTeamSelection(context.ownerId, parsedSnapshot.selection);
+        activeTeamIds.set(context.ownerId, "teamId" in parsedSnapshot.selection ? parsedSnapshot.selection.teamId : null);
+      }
+      return result;
+    } catch {
+      return failureResult(command, safeError("offline"));
+    } finally {
+      linked.dispose();
+    }
+  };
+  const stopOwner = (ownerId) => {
+    for (const subscription of [...subscriptions.values()]) {
+      if (subscription.ownerId === ownerId)
+        stopSubscription(subscription.id);
+    }
+    latestTeamSelections.delete(ownerId);
+    activeTeamIds.delete(ownerId);
+    snapshotRequestGenerations.delete(ownerId);
+    authorityGenerations.delete(ownerId);
+  };
+  const stop = () => {
+    for (const subscription of [...subscriptions.values()]) {
+      stopSubscription(subscription.id);
+    }
+    latestTeamSelections.clear();
+    activeTeamIds.clear();
+    snapshotRequestGenerations.clear();
+    authorityGenerations.clear();
+  };
+  const revokeBackendSubscriptions = async (backendId) => {
+    const connection = await options.resolveConnection(false).catch(() => null);
+    if (!connection)
+      return false;
+    const linked = linkedAbortController(new AbortController().signal, commandTimeoutMs);
+    try {
+      const response = await options.fetch(new URL(collaborationRealtimeBackendSubscriptionsPath(backendId), connection.apiUrl), {
+        method: "DELETE",
+        headers: {
+          accept: "application/json",
+          authorization: connection.authorization
+        },
+        redirect: "error",
+        signal: linked.controller.signal
+      });
+      await response.body?.cancel().catch(() => void 0);
+      return response.ok;
+    } catch {
+      return false;
+    } finally {
+      linked.dispose();
+    }
+  };
+  return { request, revokeBackendSubscriptions, stop, stopOwner };
+};
+
+// packages/koed-server/dist/desktop-collaboration-broker.js
+var requestHistoryMaxPerOwner = 512;
+var requestResultCacheMaxBytesPerOwner = 16 * 1024 * 1024;
+var capabilityRefreshLeadMs = 6e4;
+var capabilityRefreshRetryMs = 3e4;
+var disconnectCleanupRetryMs = 5e3;
+var uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var isOkRecord = (value) => Boolean(value && typeof value === "object" && "ok" in value);
+var collaborationSafeError = (code, retryAfterMs = null) => ({
+  code,
+  userMessage: collaborationSafeErrorMessages[code],
+  retryable: code === "offline" || code === "temporarily_unavailable" || code === "rate_limited" || code === "conflict",
+  retryAfterMs
+});
+var commandFailure = (command, error) => collaborationCommandResultSchema.parse({
+  contractVersion: COLLABORATION_CONTRACT_VERSION,
+  requestId: command.requestId,
+  command: command.command,
+  ok: false,
+  error
+});
+var resultState = (value) => value && typeof value === "object" && typeof value.state === "string" ? value.state : null;
+var backendIdentityFromSummary = (value) => {
+  if (!value || typeof value !== "object")
+    return null;
+  const parsed = collaborationBackendIdentitySchema.safeParse({
+    id: value.id,
+    baseUrl: value.baseUrl
+  });
+  return parsed.success ? parsed.data : null;
+};
+var findBackendIdentity = (paths, preferredBackendId) => {
+  const backends = listUpstreamBackends(paths).backends ?? [];
+  if (preferredBackendId) {
+    const preferred = backends.find((item) => item.id === preferredBackendId);
+    const parsedPreferred = backendIdentityFromSummary(preferred);
+    if (parsedPreferred)
+      return parsedPreferred;
+    return null;
+  }
+  return backendIdentityFromSummary(getActiveUpstreamBackend(paths));
+};
+var enrollmentSupportsCollaboration = (value) => {
+  if (!value || typeof value !== "object")
+    return false;
+  const enrollment = value.enrollment;
+  if (!enrollment || typeof enrollment !== "object")
+    return false;
+  const families = enrollment.requestedOperationFamilies;
+  return Array.isArray(families) && families.includes("personal_collaboration_read") && families.includes("personal_collaboration_write") && families.includes("team_workspace_read") && families.includes("team_chat_read") && families.includes("team_chat_write") && families.includes("share_grant_management") && families.includes("sync") && families.includes("managed_execution") && families.includes("managed_file_read") && families.includes("managed_terminal") && families.includes("action_grant");
+};
+var enableCollaborationRoutePolicy = (paths, backendId) => updateUpstreamBackendRoutePolicy(paths, backendId, {
+  personalCollaboration: "enabled",
+  teamWorkspaceRead: "enabled",
+  shareGrantManagement: "enabled",
+  sync: "enabled",
+  managedExecution: "enabled",
+  admin: "enabled"
+});
+var browserActivationUrlFromResult = (value) => {
+  if (!value || typeof value !== "object")
+    return null;
+  const enrollment = value.enrollment;
+  if (!enrollment || typeof enrollment !== "object")
+    return null;
+  const activationUrl = enrollment.activationUrl;
+  if (typeof activationUrl !== "string" || !activationUrl.trim())
+    return null;
+  const parsed = collaborationRemoteBackendUrlSchema.safeParse(activationUrl.trim());
+  if (parsed.success)
+    return parsed.data;
+  try {
+    const url = new URL(activationUrl.trim());
+    return (url.protocol === "http:" || url.protocol === "https:") && url.hostname && !url.username && !url.password && !url.search && !url.hash ? url.toString() : null;
+  } catch {
+    return null;
+  }
+};
+var pruneOwnerRequests = (owner) => {
+  let inspected = 0;
+  while ((owner.requestOrder.length > requestHistoryMaxPerOwner || owner.resultCacheBytes > requestResultCacheMaxBytesPerOwner) && inspected < owner.requestOrder.length) {
+    const requestId = owner.requestOrder.shift();
+    if (!requestId)
+      break;
+    const record = owner.requests.get(requestId);
+    if (record?.inFlight) {
+      owner.requestOrder.push(requestId);
+      inspected += 1;
+      continue;
+    }
+    if (record) {
+      owner.resultCacheBytes -= record.resultBytes;
+      owner.requests.delete(requestId);
+    }
+  }
+};
+var claimOwnerRequest = (owner, command) => {
+  const serialized = JSON.stringify(command);
+  const existing = owner.requests.get(command.requestId);
+  if (existing) {
+    if (existing.command !== serialized || existing.inFlight) {
+      return { state: "conflict" };
+    }
+    if (existing.result && !existing.retryable) {
+      return { state: "cached", result: existing.result };
+    }
+    if (!existing.retryable)
+      return { state: "conflict" };
+    owner.resultCacheBytes -= existing.resultBytes;
+    existing.inFlight = true;
+    existing.retryable = false;
+    existing.result = null;
+    existing.resultBytes = 0;
+    return { state: "execute" };
+  }
+  owner.requests.set(command.requestId, {
+    command: serialized,
+    inFlight: true,
+    retryable: false,
+    result: null,
+    resultBytes: 0
+  });
+  owner.requestOrder.push(command.requestId);
+  pruneOwnerRequests(owner);
+  return { state: "execute" };
+};
+var finishOwnerRequest = (owner, requestId, result) => {
+  const record = owner.requests.get(requestId);
+  if (!record)
+    return;
+  const resultBytes = Buffer.byteLength(JSON.stringify(result), "utf8");
+  record.inFlight = false;
+  record.retryable = !result.ok && result.error.retryable;
+  record.result = result;
+  record.resultBytes = resultBytes;
+  owner.resultCacheBytes += resultBytes;
+  pruneOwnerRequests(owner);
+};
+var failOwnerRequest = (owner, requestId) => {
+  const record = owner.requests.get(requestId);
+  if (!record)
+    return;
+  record.inFlight = false;
+  record.retryable = true;
+};
+var createConnectionEvent = (state, backendId, error = null, now = Date.now()) => collaborationConnectionEventSchema.parse({
+  contractVersion: COLLABORATION_CONTRACT_VERSION,
+  type: "connection",
+  connection: {
+    state,
+    backendId,
+    connectedAt: state === "live" ? new Date(now).toISOString() : null,
+    retryAt: null,
+    reconnectAttempt: state === "reconnecting" ? 1 : 0,
+    protocolVersion: COLLABORATION_CONTRACT_VERSION
+  },
+  error
+});
+var lifecycleFailure = (command, error) => commandFailure(command, error);
+var createDesktopCollaborationBroker = (dependencies = {}) => {
+  const environment = dependencies.environment ?? process.env;
+  const paths = dependencies.paths ?? resolveKoedServerPaths(environment);
+  const fetcher = dependencies.fetch ?? globalThis.fetch.bind(globalThis);
+  const ownedUpstreamFetcher = dependencies.fetch ? null : createSecureUpstreamFetch({
+    allowPrivateNetworkForUrl: registeredPrivateNetworkPolicy(() => (listUpstreamBackends(paths).backends ?? []).map((backend) => ({
+      baseUrl: backend.baseUrl,
+      profile: backend.profile
+    })))
+  });
+  const upstreamFetcher = dependencies.fetch ? fetcher : ownedUpstreamFetcher;
+  const enrollmentStatus = dependencies.getUpstreamEnrollmentStatus ?? getUpstreamEnrollmentStatus;
+  const refreshCapabilities = dependencies.refreshUpstreamBackendCapabilities ?? refreshUpstreamBackendCapabilities;
+  const startEnrollment = dependencies.startUpstreamEnrollment ?? startUpstreamEnrollment;
+  const disconnectEnrollment = dependencies.disconnectUpstreamBackendEnrollment ?? disconnectUpstreamBackendEnrollment;
+  const sleep = dependencies.sleep ?? ((delayMs, signal) => new Promise((resolve) => {
+    if (signal.aborted)
+      return resolve();
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, delayMs);
+    signal.addEventListener("abort", onAbort, { once: true });
+  }));
+  const repoEnv = loadRepoEnv(paths.repoRoot);
+  const ownerContexts = /* @__PURE__ */ new Map();
+  const enrollmentMonitors = /* @__PURE__ */ new Map();
+  const capabilityRefreshes = /* @__PURE__ */ new Map();
+  const capabilityRefreshTimers = /* @__PURE__ */ new Map();
+  const pendingSendExecutions = /* @__PURE__ */ new Map();
+  const pendingSendStarts = /* @__PURE__ */ new Map();
+  let disconnectCleanupTimer = null;
+  let lifecycleTail = Promise.resolve();
+  const sessionSend = (message) => {
+    const parsed = desktopCollaborationBrokerChildMessageSchema.parse(message);
+    if (measureDesktopCollaborationBrokerMessageBytes(parsed) > DESKTOP_COLLABORATION_BROKER_MAX_MESSAGE_BYTES) {
+      throw new Error("Desktop collaboration broker message exceeded its byte limit.");
+    }
+    dependencies.sendMessage?.(parsed);
+  };
+  const ownerContext = (ownerId) => {
+    const current = ownerContexts.get(ownerId);
+    if (current)
+      return current;
+    const created = {
+      ownerId,
+      controller: new AbortController(),
+      requests: /* @__PURE__ */ new Map(),
+      requestOrder: [],
+      resultCacheBytes: 0,
+      snapshot: null
+    };
+    ownerContexts.set(ownerId, created);
+    return created;
+  };
+  const eventInvalidatesProtectedCustody = (event) => event.type === "connection" && (event.connection.state === "disconnected" || event.connection.state === "access_revoked") || event.type === "control" && event.reason === "access_revoked" || event.type === "update" && ([
+    "team_lifecycle",
+    "team_membership_access",
+    "workspace_lifecycle_access",
+    "share_grant_lifecycle",
+    "access_revoked"
+  ].includes(event.family) || event.family === "thread_lifecycle" && (event.update.type === "thread_removed" || event.update.type === "thread_upserted" && (!event.update.thread.canPost || event.update.thread.lifecycle !== "active")));
+  const cachedProtectedThreadIds = (owner, event) => {
+    const threadIds = /* @__PURE__ */ new Set();
+    if (event.resource.threadId)
+      threadIds.add(event.resource.threadId);
+    for (const record of owner.requests.values()) {
+      if (!record.result?.ok)
+        continue;
+      const data = record.result.data;
+      const cached = collaborationSnapshotSchema.safeParse(data.snapshot);
+      if (!cached.success)
+        continue;
+      for (const team of cached.data.navigation.teams) {
+        if (event.resource.teamId && team.id !== event.resource.teamId)
+          continue;
+        if (!event.resource.workspaceId) {
+          for (const thread of team.directMessages)
+            threadIds.add(thread.id);
+        }
+        for (const workspace of team.workspaces) {
+          if (event.resource.workspaceId && workspace.id !== event.resource.workspaceId) {
+            continue;
+          }
+          for (const thread of workspace.channels)
+            threadIds.add(thread.id);
+          for (const session of workspace.sharedMemory) {
+            if (event.resource.sharedSessionId && session.id !== event.resource.sharedSessionId) {
+              continue;
+            }
+            threadIds.add(session.companionThreadId);
+          }
+        }
+      }
+      if (cached.data.view.kind === "shared_session" && (!event.resource.sharedSessionId || cached.data.view.session.id === event.resource.sharedSessionId)) {
+        threadIds.add(cached.data.view.companion.thread.id);
+      }
+    }
+    return threadIds;
+  };
+  const clearOwnerProtectedCustody = (owner, event) => {
+    if (!eventInvalidatesProtectedCustody(event))
+      return;
+    const backendId = findBackendIdentity(paths)?.id ?? null;
+    const fullBackendRevocation = event.type !== "update" || (event.family === "access_revoked" || event.family === "team_membership_access" || event.family === "team_lifecycle") && !event.resource.shareGrantId && !event.resource.workspaceId;
+    if (backendId && fullBackendRevocation) {
+      clearCollaborationActionGrantCustodyForBackend(paths.koedHome, backendId);
+      clearCollaborationPendingTeamSends(paths.koedHome, backendId);
+    } else if (event.type === "update") {
+      const revokedThreadIds = cachedProtectedThreadIds(owner, event);
+      for (const pending of listCollaborationPendingSends(paths.koedHome)) {
+        if (pending.thread.scope === "team" && revokedThreadIds.has(pending.thread.threadId)) {
+          deleteCollaborationPendingSend(paths.koedHome, pending.key);
+        }
+      }
+    }
+    owner.requests.clear();
+    owner.requestOrder = [];
+    owner.resultCacheBytes = 0;
+    owner.snapshot = null;
+  };
+  const sendOwnerEvent = (ownerId, event) => {
+    clearOwnerProtectedCustody(ownerContext(ownerId), event);
+    sessionSend({
+      protocolVersion: DESKTOP_COLLABORATION_BROKER_PROTOCOL_VERSION,
+      contractVersion: COLLABORATION_CONTRACT_VERSION,
+      sessionToken: environment.KOED_DESKTOP_COLLABORATION_BROKER_SESSION_TOKEN,
+      type: "renderer_event",
+      ownerId,
+      event
+    });
+  };
+  const transportContextForOwner = (ownerId) => {
+    const owner = ownerContext(ownerId);
+    return {
+      ownerId,
+      signal: owner.controller.signal,
+      emitCollaborationEvent: (event) => sendOwnerEvent(ownerId, event)
+    };
+  };
+  const durablePendingSendOwnerId = () => readDesktopLocalCredentialAuthorization(paths.koedHome)?.ownerUserId ?? null;
+  const pendingSendThreadKey = (record) => [
+    record.backendId ?? "personal",
+    record.remotePrincipalId ?? record.ownerId,
+    record.thread.scope === "team" ? record.thread.teamId : "personal",
+    record.thread.threadId
+  ].join(":");
+  const durableSendFromRecord = (record, snapshot, overrides = {}) => {
+    if (record.ownerId !== durablePendingSendOwnerId())
+      return null;
+    let authority;
+    let bodyAuthorized = overrides.bodyAuthorized ?? true;
+    if (record.thread.scope === "personal") {
+      const thread = snapshot?.navigation.personal.channels.find((candidate) => candidate.id === record.thread.threadId);
+      if (snapshot && (!thread || !thread.canPost))
+        return null;
+      authority = {
+        scope: "personal",
+        ownerUserId: record.ownerId,
+        threadId: record.thread.threadId
+      };
+    } else {
+      const activeBackendId = findBackendIdentity(paths)?.id ?? null;
+      const binding = activeBackendId ? readUpstreamEnrollmentBinding(paths, activeBackendId) : null;
+      if (!snapshot || snapshot.connection.backendId !== record.backendId || snapshot.navigation.teamPrincipal?.id !== record.remotePrincipalId || !overrides.allowStaleTeamBinding && (!binding || activeBackendId !== record.backendId || binding.principalUserId !== record.remotePrincipalId || binding.deviceCredentialId !== record.deviceCredentialId)) {
+        return null;
+      }
+      const teamId = record.thread.teamId;
+      const team = snapshot.navigation.teams.find((candidate) => candidate.id === teamId && candidate.lifecycle === "active");
+      if (!team)
+        return null;
+      const directMessage = team.directMessages.find((candidate) => candidate.id === record.thread.threadId);
+      let workspaceId = null;
+      let canPost = directMessage?.canPost ?? false;
+      if (!directMessage) {
+        for (const workspace of team.workspaces) {
+          if (workspace.lifecycle !== "active" || workspace.access !== "write") {
+            continue;
+          }
+          const channel = workspace.channels.find((candidate) => candidate.id === record.thread.threadId);
+          const sharedSession = workspace.sharedMemory.find((candidate) => candidate.companionThreadId === record.thread.threadId);
+          if (channel || sharedSession) {
+            workspaceId = workspace.id;
+            canPost = channel?.canPost ?? (snapshot.view.kind === "shared_session" && snapshot.view.companion.thread.id === record.thread.threadId && snapshot.view.companion.thread.canPost);
+            break;
+          }
+        }
+      }
+      if (!canPost)
+        return null;
+      authority = {
+        scope: "team",
+        backendId: record.backendId,
+        principalUserId: record.remotePrincipalId,
+        teamId: record.thread.teamId,
+        workspaceId,
+        threadId: record.thread.threadId
+      };
+    }
+    const state = overrides.state ?? (record.state === "pending" ? "queued" : record.state);
+    const failure = overrides.failure === void 0 ? record.failure : overrides.failure;
+    if (overrides.bodyAuthorized === false)
+      bodyAuthorized = false;
+    return collaborationDurableSendSchema.parse({
+      clientMessageId: record.clientMessageId,
+      authority,
+      body: bodyAuthorized ? record.body : null,
+      localCreationOrder: record.localCreationOrder,
+      state,
+      retryable: state === "queued" || state === "manual_retry",
+      removalSupported: false,
+      failure,
+      createdAt: record.createdAt,
+      updatedAt: record.updatedAt
+    });
+  };
+  const snapshotWithDurableSends = (value, purgeUnauthorized = true) => {
+    const outbox = [];
+    for (const record of listCollaborationPendingSends(paths.koedHome)) {
+      const projected = durableSendFromRecord(record, value);
+      if (projected) {
+        outbox.push(projected);
+      } else if (purgeUnauthorized && record.thread.scope === "team") {
+        deleteCollaborationPendingSend(paths.koedHome, record.key);
+      }
+    }
+    return collaborationSnapshotSchema.parse({ ...value, outbox });
+  };
+  const emitDurableSend = (ownerId, send, message) => {
+    sendOwnerEvent(ownerId, collaborationDurableSendEventSchema.parse({
+      contractVersion: COLLABORATION_CONTRACT_VERSION,
+      type: "durable_send",
+      eventId: randomUUID2(),
+      send,
+      message
+    }));
+  };
+  const runLifecycleExclusive = async (operation) => {
+    const previous = lifecycleTail;
+    let release;
+    lifecycleTail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  };
+  const broadcastEvent = (event) => {
+    for (const owner of ownerContexts.values()) {
+      sendOwnerEvent(owner.ownerId, event);
+    }
+  };
+  const stopEnrollmentMonitors = () => {
+    for (const controller of enrollmentMonitors.values())
+      controller.abort();
+    enrollmentMonitors.clear();
+  };
+  const clearCapabilityRefreshTimers = () => {
+    for (const timer of capabilityRefreshTimers.values())
+      clearTimeout(timer);
+    capabilityRefreshTimers.clear();
+  };
+  const scheduleCapabilityRefresh = (backendId, expiresAt) => {
+    const existing = capabilityRefreshTimers.get(backendId);
+    if (existing)
+      clearTimeout(existing);
+    capabilityRefreshTimers.delete(backendId);
+    if (getActiveUpstreamBackend(paths)?.id !== backendId)
+      return;
+    const now = dependencies.now?.() ?? Date.now();
+    const delay = expiresAt === null ? capabilityRefreshRetryMs : Math.max(0, expiresAt - now - capabilityRefreshLeadMs);
+    const timer = setTimeout(() => {
+      capabilityRefreshTimers.delete(backendId);
+      void ensureBackendCapabilities(backendId);
+    }, delay);
+    timer.unref?.();
+    capabilityRefreshTimers.set(backendId, timer);
+  };
+  async function ensureBackendCapabilities(preferredBackendId) {
+    const backend = preferredBackendId ? (listUpstreamBackends(paths).backends ?? []).find((candidate) => candidate.id === preferredBackendId) : getActiveUpstreamBackend(paths);
+    if (!backend)
+      return false;
+    const now = dependencies.now?.() ?? Date.now();
+    const expiresAt = backend.capabilities.expiresAt ? Date.parse(backend.capabilities.expiresAt) : Number.NaN;
+    if (backend.capabilities.state === "validated" && Number.isFinite(expiresAt) && expiresAt > now + capabilityRefreshLeadMs) {
+      scheduleCapabilityRefresh(backend.id, expiresAt);
+      return true;
+    }
+    const existing = capabilityRefreshes.get(backend.id);
+    if (existing)
+      return existing;
+    const refresh = refreshCapabilities(paths, backend.id, {
+      fetch: upstreamFetcher,
+      now: () => new Date(dependencies.now?.() ?? Date.now())
+    }).then((result) => {
+      const refreshed = (listUpstreamBackends(paths).backends ?? []).find((candidate) => candidate.id === backend.id);
+      const refreshedExpiry = refreshed?.capabilities.expiresAt ? Date.parse(refreshed.capabilities.expiresAt) : Number.NaN;
+      scheduleCapabilityRefresh(backend.id, result.ok && Number.isFinite(refreshedExpiry) ? refreshedExpiry : null);
+      return result.ok;
+    }).catch(() => {
+      scheduleCapabilityRefresh(backend.id, null);
+      return false;
+    }).finally(() => capabilityRefreshes.delete(backend.id));
+    capabilityRefreshes.set(backend.id, refresh);
+    return refresh;
+  }
+  const createTransport = () => createDesktopCollaborationBrokerLocalTransport({
+    fetch: fetcher,
+    random: dependencies.random,
+    now: dependencies.now,
+    sleep: dependencies.sleep,
+    resolveConnection: async (requiresTeamBackend, preferredBackendId, localDeliveryOnly) => {
+      if (requiresTeamBackend && !localDeliveryOnly && !await ensureBackendCapabilities(preferredBackendId)) {
+        return null;
+      }
+      const credential = readDesktopLocalCredentialAuthorization(paths.koedHome);
+      if (!credential)
+        return Promise.resolve(null);
+      const backendId = requiresTeamBackend ? findBackendIdentity(paths, preferredBackendId)?.id ?? null : null;
+      if (requiresTeamBackend && !backendId)
+        return Promise.resolve(null);
+      const activeRuntime = readActiveRuntimeState(paths.runtimeStatePath);
+      return Promise.resolve({
+        apiUrl: (activeRuntime?.apiUrl ?? resolveApiUrl(applyActiveRuntimeUrls(applyPersistedLocalPorts(paths, environment, { force: true }), activeRuntime), repoEnv)).replace(/\/$/, ""),
+        backendId,
+        authorization: credential.authorization
+      });
+    }
+  });
+  let transport = createTransport();
+  const resetTransport = () => {
+    transport.stop();
+    transport = createTransport();
+  };
+  const clearOwnerTeamRuntimeState = () => {
+    for (const owner of ownerContexts.values()) {
+      owner.controller.abort();
+      owner.controller = new AbortController();
+      owner.requests.clear();
+      owner.requestOrder = [];
+      owner.resultCacheBytes = 0;
+      owner.snapshot = null;
+    }
+    pendingSendExecutions.clear();
+  };
+  const clearBackendDurableState = async (backendId) => {
+    let complete = true;
+    try {
+      if (!await transport.revokeBackendSubscriptions(backendId)) {
+        complete = false;
+      }
+    } catch {
+      complete = false;
+    }
+    for (const clear of [
+      () => clearCollaborationActionGrantCustodyForBackend(paths.koedHome, backendId),
+      () => clearCollaborationPendingTeamSends(paths.koedHome, backendId),
+      () => removeProjectTeamWorkspaceLinksForBackend(paths, backendId)
+    ]) {
+      try {
+        clear();
+      } catch {
+        complete = false;
+      }
+    }
+    if (complete) {
+      completeUpstreamDisconnectCleanup(paths, backendId);
+    } else if (upstreamDisconnectCleanupPending(paths, backendId)) {
+      updateUpstreamDisconnectCleanup(paths, backendId, {
+        phase: "local_cleanup_pending",
+        lastFailureCategory: "local_cleanup_failed"
+      });
+    }
+    return complete;
+  };
+  const clearBackendLocalState = async (backendId) => {
+    transport.stop();
+    const complete = await clearBackendDurableState(backendId);
+    clearOwnerTeamRuntimeState();
+    transport = createTransport();
+    return complete;
+  };
+  const retryRevokedBackendDurableCleanup = async () => {
+    for (const record of listUpstreamDisconnectCleanupRecords(paths)) {
+      if (record.phase === "remote_revocation_pending") {
+        const backend = (listUpstreamBackends(paths).backends ?? []).find((candidate) => candidate.id === record.backendId);
+        if (!backend)
+          continue;
+        const disconnected = await disconnectBackend(backend);
+        if (!disconnected.revoked)
+          continue;
+      } else {
+        await clearBackendDurableState(record.backendId);
+      }
+    }
+  };
+  const scheduleDisconnectCleanupRetry = () => {
+    if (disconnectCleanupTimer || !upstreamDisconnectCleanupPending(paths)) {
+      return;
+    }
+    disconnectCleanupTimer = setTimeout(() => {
+      disconnectCleanupTimer = null;
+      void runLifecycleExclusive(retryRevokedBackendDurableCleanup).finally(scheduleDisconnectCleanupRetry);
+    }, disconnectCleanupRetryMs);
+    disconnectCleanupTimer.unref?.();
+  };
+  const disconnectBackend = async (backend) => {
+    const disconnected = await disconnectEnrollment(paths, backend.id, {
+      fetch: upstreamFetcher
+    });
+    if (!isOkRecord(disconnected) || disconnected.ok !== true) {
+      return { revoked: false, cleanupComplete: false };
+    }
+    if (!upstreamDisconnectCleanupPending(paths, backend.id)) {
+      beginUpstreamDisconnectCleanup(paths, backend.id);
+      updateUpstreamDisconnectCleanup(paths, backend.id, {
+        phase: "local_cleanup_pending",
+        lastFailureCategory: null
+      });
+    }
+    return {
+      revoked: true,
+      cleanupComplete: await clearBackendLocalState(backend.id)
+    };
+  };
+  const remapSendResult = (command, result) => collaborationCommandResultSchema.parse({
+    ...result,
+    requestId: command.requestId,
+    command: command.command
+  });
+  const executePendingSend = async (command, pending, context) => {
+    if (pending.backendId) {
+      const activeBackend = getActiveUpstreamBackend(paths);
+      const activeBackendId = activeBackend?.id ?? null;
+      const binding = activeBackendId ? readUpstreamEnrollmentBinding(paths, activeBackendId) : null;
+      const credential = activeBackendId ? readLocalEdgeClientCredentialAuthorization(paths.koedHome, activeBackendId) : null;
+      const requiredFamily = pending.thread.scope === "personal" ? "personal_collaboration_write" : "team_chat_write";
+      if (pending.backendId !== activeBackendId || pending.thread.scope === "personal" && activeBackend?.routePolicy.personalCollaboration !== "enabled" || !binding || !credential?.operationFamilies.includes(requiredFamily) || pending.remotePrincipalId !== binding.principalUserId || pending.deviceCredentialId !== binding.deviceCredentialId) {
+        const error = collaborationSafeError("access_revoked");
+        const failed = durableSendFromRecord(pending, ownerContext(context.ownerId).snapshot, {
+          state: "failed",
+          failure: error,
+          bodyAuthorized: false,
+          allowStaleTeamBinding: true
+        });
+        deleteCollaborationPendingSend(paths.koedHome, pending.key);
+        if (failed)
+          emitDurableSend(context.ownerId, failed, null);
+        return commandFailure(command, error);
+      }
+    }
+    const currentExecution = pendingSendExecutions.get(pending.key);
+    if (currentExecution) {
+      return remapSendResult(command, await currentExecution);
+    }
+    const earlierBlockingSend = listCollaborationPendingSends(paths.koedHome).find((candidate) => pendingSendThreadKey(candidate) === pendingSendThreadKey(pending) && candidate.localCreationOrder < pending.localCreationOrder && (candidate.state === "pending" || candidate.state === "manual_retry"));
+    if (earlierBlockingSend) {
+      return commandFailure(command, collaborationSafeError("temporarily_unavailable"));
+    }
+    const execution = (async () => {
+      let record = pending;
+      let lastResult = null;
+      while (!context.signal.aborted && record.attemptCount < COLLABORATION_SEND_RETRY_MAX_ATTEMPTS) {
+        if (record.nextAttemptAt) {
+          const delayMs2 = Math.max(0, Date.parse(record.nextAttemptAt) - (dependencies.now?.() ?? Date.now()));
+          if (delayMs2 > 0)
+            await sleep(delayMs2, context.signal);
+          if (context.signal.aborted)
+            break;
+        }
+        const attemptCommand = collaborationRendererCommandSchema.parse({
+          contractVersion: COLLABORATION_CONTRACT_VERSION,
+          requestId: record.attemptCount === 0 ? command.requestId : randomUUID2(),
+          command: record.attemptCount === 0 ? command.command : "collaboration.retry_message",
+          input: {
+            thread: record.thread,
+            clientMessageId: record.clientMessageId,
+            body: record.body
+          }
+        });
+        lastResult = await transport.request(attemptCommand, context);
+        const attemptCount = record.attemptCount + 1;
+        if (lastResult.ok) {
+          if (lastResult.command !== "collaboration.send_message" && lastResult.command !== "collaboration.retry_message" || !("message" in lastResult.data)) {
+            return commandFailure(command, collaborationSafeError("internal_error"));
+          }
+          const confirmedMessage = {
+            ...lastResult.data.message,
+            clientMessageId: record.clientMessageId
+          };
+          const sent = durableSendFromRecord(record, ownerContext(context.ownerId).snapshot, { state: "sent", failure: null });
+          deleteCollaborationPendingSend(paths.koedHome, record.key);
+          if (sent)
+            emitDurableSend(context.ownerId, sent, confirmedMessage);
+          return collaborationCommandResultSchema.parse({
+            ...lastResult,
+            data: { message: confirmedMessage }
+          });
+        }
+        if (!lastResult.error.retryable) {
+          const protectedAuthorityLost = record.thread.scope === "team" && (lastResult.error.code === "access_revoked" || lastResult.error.code === "permission_denied" || lastResult.error.code === "not_available");
+          const failedRecord = protectedAuthorityLost ? record : updateCollaborationPendingSendState(paths.koedHome, {
+            key: record.key,
+            attemptCount,
+            state: "failed",
+            failure: lastResult.error,
+            nextAttemptAt: null
+          }) ?? record;
+          const failed = durableSendFromRecord(failedRecord, ownerContext(context.ownerId).snapshot, {
+            state: "failed",
+            failure: lastResult.error,
+            bodyAuthorized: !protectedAuthorityLost
+          });
+          if (protectedAuthorityLost) {
+            deleteCollaborationPendingSend(paths.koedHome, record.key);
+          }
+          if (failed)
+            emitDurableSend(context.ownerId, failed, null);
+          return lastResult;
+        }
+        if (attemptCount >= COLLABORATION_SEND_RETRY_MAX_ATTEMPTS) {
+          const manualRetry = updateCollaborationPendingSendState(paths.koedHome, {
+            key: record.key,
+            attemptCount,
+            state: "manual_retry",
+            failure: lastResult.error,
+            nextAttemptAt: null
+          }) ?? record;
+          const projected = durableSendFromRecord(manualRetry, ownerContext(context.ownerId).snapshot);
+          if (projected)
+            emitDurableSend(context.ownerId, projected, null);
+          return lastResult;
+        }
+        const delayMs = Math.min(Math.max(lastResult.error.retryAfterMs ?? 250 * 2 ** (attemptCount - 1), 250), 3e4);
+        record = updateCollaborationPendingSendState(paths.koedHome, {
+          key: record.key,
+          attemptCount,
+          state: "pending",
+          failure: null,
+          nextAttemptAt: new Date((dependencies.now?.() ?? Date.now()) + delayMs).toISOString()
+        }) ?? record;
+      }
+      return lastResult ?? commandFailure(command, collaborationSafeError("offline"));
+    })();
+    pendingSendExecutions.set(pending.key, execution);
+    try {
+      return remapSendResult(command, await execution);
+    } finally {
+      if (pendingSendExecutions.get(pending.key) === execution) {
+        pendingSendExecutions.delete(pending.key);
+      }
+      await startNextPendingSend(pending, context);
+    }
+  };
+  async function startNextPendingSend(completed, context) {
+    if (context.signal.aborted)
+      return;
+    const next = listCollaborationPendingSends(paths.koedHome).find((candidate) => pendingSendThreadKey(candidate) === pendingSendThreadKey(completed) && (candidate.state === "pending" || candidate.state === "manual_retry"));
+    if (!next || next.state !== "pending")
+      return;
+    const retryCommand = collaborationRendererCommandSchema.parse({
+      contractVersion: COLLABORATION_CONTRACT_VERSION,
+      requestId: randomUUID2(),
+      command: "collaboration.retry_message",
+      input: {
+        thread: next.thread,
+        clientMessageId: next.clientMessageId,
+        body: next.body
+      }
+    });
+    if (retryCommand.command === "collaboration.retry_message") {
+      await executePendingSend(retryCommand, next, context);
+    }
+  }
+  const persistAndExecuteSend = (command, context) => {
+    const pendingOwnerId = durablePendingSendOwnerId();
+    if (!pendingOwnerId) {
+      return commandFailure(command, collaborationSafeError("not_available"));
+    }
+    const activeBackend = getActiveUpstreamBackend(paths);
+    const activeBackendId = activeBackend?.id ?? null;
+    const activeCredential = activeBackendId ? readLocalEdgeClientCredentialAuthorization(paths.koedHome, activeBackendId) : null;
+    const backendId = command.input.thread.scope === "team" || activeBackend?.routePolicy.personalCollaboration === "enabled" && activeCredential?.operationFamilies.includes("personal_collaboration_write") ? activeBackendId : null;
+    if (command.input.thread.scope === "team" && !backendId) {
+      return commandFailure(command, collaborationSafeError("not_available"));
+    }
+    const remoteBinding = backendId ? readUpstreamEnrollmentBinding(paths, backendId) : null;
+    if (command.input.thread.scope === "team" && !remoteBinding) {
+      return commandFailure(command, collaborationSafeError("not_available"));
+    }
+    let existing;
+    if (command.command === "collaboration.retry_message") {
+      existing = listCollaborationPendingSends(paths.koedHome).find((record) => record.ownerId === pendingOwnerId && record.thread.scope === command.input.thread.scope && record.thread.threadId === command.input.thread.threadId && record.clientMessageId === command.input.clientMessageId);
+      if (existing?.backendId && (existing.backendId !== backendId || existing.remotePrincipalId !== remoteBinding?.principalUserId || existing.deviceCredentialId !== remoteBinding?.deviceCredentialId)) {
+        deleteCollaborationPendingSend(paths.koedHome, existing.key);
+        return commandFailure(command, collaborationSafeError("access_revoked"));
+      }
+      if (!existing || existing.state !== "manual_retry") {
+        return commandFailure(command, collaborationSafeError("conflict"));
+      }
+    }
+    const pending = storeCollaborationPendingSend(paths.koedHome, {
+      ownerId: pendingOwnerId,
+      backendId,
+      remotePrincipalId: remoteBinding?.principalUserId ?? null,
+      deviceCredentialId: remoteBinding?.deviceCredentialId ?? null,
+      thread: command.input.thread,
+      clientMessageId: command.input.clientMessageId,
+      body: command.input.body
+    }, { resetAttempts: command.command === "collaboration.retry_message" });
+    const projected = durableSendFromRecord(pending, ownerContext(context.ownerId).snapshot);
+    if (!projected) {
+      deleteCollaborationPendingSend(paths.koedHome, pending.key);
+      return commandFailure(command, collaborationSafeError("not_available"));
+    }
+    pendingSendStarts.set(command.requestId, { command, pending, context });
+    return collaborationCommandResultSchema.parse({
+      contractVersion: COLLABORATION_CONTRACT_VERSION,
+      requestId: command.requestId,
+      command: command.command,
+      ok: true,
+      data: { durableSend: projected }
+    });
+  };
+  const resumeInterruptedSends = async (context, snapshot) => {
+    const pendingOwnerId = durablePendingSendOwnerId();
+    if (!pendingOwnerId)
+      return;
+    const activeBackendId = findBackendIdentity(paths)?.id ?? null;
+    const binding = activeBackendId ? readUpstreamEnrollmentBinding(paths, activeBackendId) : null;
+    const pending = listCollaborationPendingSends(paths.koedHome).filter((record) => record.ownerId === pendingOwnerId && record.state === "pending");
+    if (activeBackendId && binding) {
+      removeProjectTeamWorkspaceLinksForMismatchedBinding(paths, {
+        backendId: binding.backendId,
+        remotePrincipalId: binding.principalUserId,
+        deviceCredentialId: binding.deviceCredentialId
+      });
+    }
+    if (activeBackendId && (!binding || snapshot.navigation.teamPrincipal?.id !== binding.principalUserId)) {
+      clearCollaborationActionGrantCustodyForBackend(paths.koedHome, activeBackendId);
+      clearCollaborationPendingTeamSends(paths.koedHome, activeBackendId);
+      removeProjectTeamWorkspaceLinksForBackend(paths, activeBackendId);
+      return;
+    }
+    const startedThreads = /* @__PURE__ */ new Set();
+    for (const record of pending) {
+      if (context.signal.aborted)
+        return;
+      if (record.thread.scope === "team" && (!binding || snapshot.navigation.teamPrincipal?.id !== binding.principalUserId || record.backendId !== binding.backendId || record.remotePrincipalId !== binding.principalUserId || record.deviceCredentialId !== binding.deviceCredentialId)) {
+        deleteCollaborationPendingSend(paths.koedHome, record.key);
+        continue;
+      }
+      const threadKey = pendingSendThreadKey(record);
+      if (startedThreads.has(threadKey))
+        continue;
+      const earliestBlocking = listCollaborationPendingSends(paths.koedHome).find((candidate) => pendingSendThreadKey(candidate) === threadKey && (candidate.state === "pending" || candidate.state === "manual_retry"));
+      if (!earliestBlocking || earliestBlocking.state !== "pending")
+        continue;
+      startedThreads.add(threadKey);
+      const command = collaborationRendererCommandSchema.parse({
+        contractVersion: COLLABORATION_CONTRACT_VERSION,
+        requestId: randomUUID2(),
+        command: "collaboration.retry_message",
+        input: {
+          thread: earliestBlocking.thread,
+          clientMessageId: earliestBlocking.clientMessageId,
+          body: earliestBlocking.body
+        }
+      });
+      if (command.command !== "collaboration.retry_message") {
+        throw new Error("Collaboration retry command validation failed.");
+      }
+      await executePendingSend(command, earliestBlocking, context);
+    }
+  };
+  const releaseOwner = (ownerId) => {
+    const owner = ownerContexts.get(ownerId);
+    if (!owner)
+      return;
+    owner.controller.abort();
+    transport.stopOwner(ownerId);
+    ownerContexts.delete(ownerId);
+  };
+  const loadSnapshot = async (requestId, context) => {
+    const command = collaborationRendererCommandSchema.parse({
+      contractVersion: COLLABORATION_CONTRACT_VERSION,
+      requestId,
+      command: "collaboration.load",
+      input: {}
+    });
+    const result = await transport.request(command, context);
+    if (!result.ok)
+      return { ok: false, error: result.error };
+    return result.command === "collaboration.load" ? {
+      ok: true,
+      snapshot: snapshotWithDurableSends(result.data.snapshot)
+    } : { ok: false, error: collaborationSafeError("internal_error") };
+  };
+  const connectBackend = async (remoteUrl, sourceOwnerPrincipalId) => {
+    const parsed = collaborationRemoteBackendUrlSchema.safeParse(remoteUrl);
+    if (!parsed.success) {
+      return { ok: false };
+    }
+    const registered = registerUpstreamBackend(paths, {
+      url: parsed.data,
+      displayName: "Team Backend",
+      profile: "team_self_hosted"
+    });
+    if (!registered.ok || !registered.backend)
+      return { ok: false };
+    const refreshed = await refreshCapabilities(paths, registered.backend.id, {
+      fetch: upstreamFetcher
+    });
+    if (!refreshed.ok)
+      return { ok: false };
+    const policy = enableCollaborationRoutePolicy(paths, registered.backend.id);
+    if (!policy.ok)
+      return { ok: false };
+    const enrollment = await startEnrollment(paths, registered.backend.id, {
+      fetch: upstreamFetcher,
+      sourceOwnerPrincipalId
+    });
+    const enrollmentState = resultState(enrollment);
+    if (enrollmentState === "pending" || enrollmentState === "approved" || enrollmentState === "exchanged") {
+      const activated = setActiveUpstreamBackend(paths, registered.backend.id);
+      if (!activated.ok)
+        return { ok: false };
+    }
+    const backend = backendIdentityFromSummary(registered.backend);
+    return backend ? { ok: true, backend, enrollment } : { ok: false };
+  };
+  const reconnectBackend = async (sourceOwnerPrincipalId) => {
+    const backend = backendIdentityFromSummary(getActiveUpstreamBackend(paths));
+    if (!backend)
+      return { ok: false };
+    if (!await ensureBackendCapabilities(backend.id)) {
+      return { ok: false };
+    }
+    const policy = enableCollaborationRoutePolicy(paths, backend.id);
+    if (!policy.ok)
+      return { ok: false };
+    let enrollment = await enrollmentStatus(paths, backend.id, {
+      fetch: upstreamFetcher
+    });
+    let state = resultState(enrollment);
+    if ((state === "pending" || state === "approved" || state === "exchanged") && !enrollmentSupportsCollaboration(enrollment)) {
+      return { ok: false };
+    }
+    if (state === "pending" || state === "approved" || state === "exchanged") {
+      return { ok: true, backend, enrollment };
+    }
+    const restarted = await connectBackend(backend.baseUrl, sourceOwnerPrincipalId);
+    if (!restarted.ok)
+      return { ok: false };
+    enrollment = restarted.enrollment;
+    state = resultState(enrollment);
+    return state ? { ok: true, backend, enrollment } : { ok: false };
+  };
+  const resolveLocalOwnerPrincipalId = async (ownerId) => {
+    const durableOwnerId = readDesktopLocalCredentialAuthorization(paths.koedHome)?.ownerUserId;
+    if (durableOwnerId && uuidPattern.test(durableOwnerId)) {
+      return durableOwnerId;
+    }
+    const owner = ownerContext(ownerId);
+    const cachedOwnerId = owner.snapshot?.navigation.personalOwner.id;
+    if (cachedOwnerId && uuidPattern.test(cachedOwnerId)) {
+      return cachedOwnerId;
+    }
+    const loaded = await loadSnapshot(randomUUID2(), transportContextForOwner(ownerId));
+    if (!loaded.ok)
+      return null;
+    owner.snapshot = loaded.snapshot;
+    const loadedOwnerId = loaded.snapshot.navigation.personalOwner.id;
+    return uuidPattern.test(loadedOwnerId) ? loadedOwnerId : null;
+  };
+  const handleLifecycleCommand = async (command, ownerId) => {
+    if (command.command === "collaboration.disconnect_backend") {
+      stopEnrollmentMonitors();
+      clearCapabilityRefreshTimers();
+      const backend = backendIdentityFromSummary(getActiveUpstreamBackend(paths));
+      if (backend) {
+        const disconnected = await disconnectBackend(backend);
+        if (!disconnected.revoked) {
+          return lifecycleFailure(command, collaborationSafeError("temporarily_unavailable"));
+        }
+        if (!disconnected.cleanupComplete) {
+          scheduleDisconnectCleanupRetry();
+          for (const owner of ownerContexts.values()) {
+            sendOwnerEvent(owner.ownerId, createConnectionEvent("disconnected", null));
+          }
+          return lifecycleFailure(command, collaborationSafeError("temporarily_unavailable"));
+        }
+      } else {
+        resetTransport();
+        clearOwnerTeamRuntimeState();
+      }
+      for (const owner of ownerContexts.values()) {
+        sendOwnerEvent(owner.ownerId, createConnectionEvent("disconnected", null));
+      }
+      const loaded2 = await loadSnapshot(command.requestId, transportContextForOwner(ownerId));
+      if (!loaded2.ok)
+        return lifecycleFailure(command, loaded2.error);
+      return collaborationCommandResultSchema.parse({
+        contractVersion: COLLABORATION_CONTRACT_VERSION,
+        requestId: command.requestId,
+        command: command.command,
+        ok: true,
+        data: {
+          snapshot: {
+            ...loaded2.snapshot,
+            connection: {
+              state: "disconnected",
+              backendId: null,
+              connectedAt: null,
+              retryAt: null,
+              reconnectAttempt: 0,
+              protocolVersion: COLLABORATION_CONTRACT_VERSION
+            },
+            navigation: {
+              ...loaded2.snapshot.navigation,
+              teamPrincipal: null,
+              teams: []
+            }
+          }
+        }
+      });
+    }
+    const sourceOwnerPrincipalId = await resolveLocalOwnerPrincipalId(ownerId);
+    if (!sourceOwnerPrincipalId) {
+      return lifecycleFailure(command, collaborationSafeError("temporarily_unavailable"));
+    }
+    let connectResult;
+    await retryRevokedBackendDurableCleanup();
+    if (upstreamDisconnectCleanupPending(paths)) {
+      return lifecycleFailure(command, collaborationSafeError("temporarily_unavailable"));
+    }
+    if (command.command === "collaboration.connect_backend") {
+      const parsedTarget = collaborationRemoteBackendUrlSchema.safeParse(command.input.remoteUrl);
+      if (!parsedTarget.success) {
+        return lifecycleFailure(command, collaborationSafeError("invalid_input"));
+      }
+      const activeBackend = backendIdentityFromSummary(getActiveUpstreamBackend(paths));
+      const normalizedTarget = parsedTarget.data.replace(/\/+$/, "");
+      const sameBackend = activeBackend?.baseUrl.replace(/\/+$/, "") === normalizedTarget;
+      if (activeBackend && !sameBackend) {
+        stopEnrollmentMonitors();
+        clearCapabilityRefreshTimers();
+        const disconnected = await disconnectBackend(activeBackend);
+        if (!disconnected.revoked) {
+          return lifecycleFailure(command, collaborationSafeError("temporarily_unavailable"));
+        }
+        if (!disconnected.cleanupComplete) {
+          scheduleDisconnectCleanupRetry();
+          return lifecycleFailure(command, collaborationSafeError("temporarily_unavailable"));
+        }
+      }
+      connectResult = sameBackend ? await reconnectBackend(sourceOwnerPrincipalId) : await connectBackend(parsedTarget.data, sourceOwnerPrincipalId);
+    } else {
+      connectResult = await reconnectBackend(sourceOwnerPrincipalId);
+    }
+    if (!connectResult.ok) {
+      return lifecycleFailure(command, collaborationSafeError("not_available"));
+    }
+    const enrollment = connectResult.enrollment;
+    const state = resultState(enrollment);
+    if (!enrollmentSupportsCollaboration(enrollment)) {
+      return lifecycleFailure(command, collaborationSafeError("not_available"));
+    }
+    if (state === "pending" || state === "approved") {
+      const activationUrl = browserActivationUrlFromResult(enrollment);
+      if (activationUrl) {
+        dependencies.onBrowserOpenRequest?.({
+          ownerId,
+          url: activationUrl
+        });
+      }
+      sendOwnerEvent(ownerId, createConnectionEvent(command.command === "collaboration.connect_backend" ? "connecting" : "reconnecting", connectResult.backend.id));
+      const enrollmentId = enrollment.enrollment?.requestId;
+      if (enrollmentId) {
+        const monitorKey = `${connectResult.backend.id}:${enrollmentId}`;
+        if (!enrollmentMonitors.has(monitorKey)) {
+          const monitorController = new AbortController();
+          enrollmentMonitors.set(monitorKey, monitorController);
+          void (async () => {
+            const expiresAt = enrollment.enrollment?.expiresAt ? Date.parse(enrollment.enrollment.expiresAt) : Number.NaN;
+            try {
+              while (!monitorController.signal.aborted) {
+                if (Number.isFinite(expiresAt) && (dependencies.now?.() ?? Date.now()) >= expiresAt) {
+                  broadcastEvent(createConnectionEvent("unavailable", connectResult.backend.id, collaborationSafeError("not_available")));
+                  return;
+                }
+                await sleep(1e3, monitorController.signal);
+                if (monitorController.signal.aborted)
+                  return;
+                const current = await enrollmentStatus(paths, connectResult.backend.id, { fetch: upstreamFetcher });
+                if (current.enrollment?.requestId !== enrollmentId)
+                  return;
+                if (current.state === "pending" || current.state === "approved") {
+                  continue;
+                }
+                if (current.state === "exchanged" && findBackendIdentity(paths)?.id === connectResult.backend.id) {
+                  resetTransport();
+                  broadcastEvent(createConnectionEvent("live", connectResult.backend.id, null, dependencies.now?.() ?? Date.now()));
+                  return;
+                }
+                broadcastEvent(createConnectionEvent("unavailable", connectResult.backend.id, collaborationSafeError("not_available")));
+                return;
+              }
+            } catch {
+              if (!monitorController.signal.aborted) {
+                broadcastEvent(createConnectionEvent("unavailable", connectResult.backend.id, collaborationSafeError("temporarily_unavailable")));
+              }
+            } finally {
+              enrollmentMonitors.delete(monitorKey);
+            }
+          })();
+        }
+      }
+      return lifecycleFailure(command, collaborationSafeError("temporarily_unavailable"));
+    }
+    if (state !== "exchanged") {
+      return lifecycleFailure(command, collaborationSafeError("not_available"));
+    }
+    const loaded = await loadSnapshot(command.requestId, transportContextForOwner(ownerId));
+    if (!loaded.ok)
+      return lifecycleFailure(command, loaded.error);
+    return collaborationCommandResultSchema.parse({
+      contractVersion: COLLABORATION_CONTRACT_VERSION,
+      requestId: command.requestId,
+      command: command.command,
+      ok: true,
+      data: command.command === "collaboration.connect_backend" ? {
+        backend: connectResult.backend,
+        snapshot: loaded.snapshot
+      } : {
+        snapshot: loaded.snapshot
+      }
+    });
+  };
+  const sendCommandResult = (envelopeId, ownerId, result) => {
+    sessionSend({
+      protocolVersion: DESKTOP_COLLABORATION_BROKER_PROTOCOL_VERSION,
+      contractVersion: COLLABORATION_CONTRACT_VERSION,
+      sessionToken: environment.KOED_DESKTOP_COLLABORATION_BROKER_SESSION_TOKEN,
+      type: "command_result",
+      envelopeId,
+      ownerId,
+      result
+    });
+  };
+  const sendError = (error) => {
+    sessionSend({
+      protocolVersion: DESKTOP_COLLABORATION_BROKER_PROTOCOL_VERSION,
+      contractVersion: COLLABORATION_CONTRACT_VERSION,
+      sessionToken: environment.KOED_DESKTOP_COLLABORATION_BROKER_SESSION_TOKEN,
+      type: "error",
+      ...error
+    });
+  };
+  const rejectInvalidMessage = (value, message = "Desktop collaboration broker rejected an invalid message.") => {
+    sendError({
+      envelopeId: value && typeof value === "object" && typeof value.envelopeId === "string" ? value.envelopeId : null,
+      ownerId: value && typeof value === "object" && typeof value.ownerId === "string" ? value.ownerId : null,
+      code: "invalid_message",
+      message
+    });
+  };
+  const handleMessage = async (value) => {
+    let claimedRequest;
+    try {
+      if (measureDesktopCollaborationBrokerMessageBytes(value) > DESKTOP_COLLABORATION_BROKER_MAX_MESSAGE_BYTES) {
+        throw new Error("Desktop collaboration broker message exceeded its byte limit.");
+      }
+      const message = desktopCollaborationBrokerParentMessageSchema.parse(value);
+      if (message.sessionToken !== environment.KOED_DESKTOP_COLLABORATION_BROKER_SESSION_TOKEN) {
+        rejectInvalidMessage(message, "Desktop collaboration broker session token is invalid.");
+        return;
+      }
+      if (message.type === "release_owner") {
+        releaseOwner(message.ownerId);
+        sessionSend({
+          protocolVersion: DESKTOP_COLLABORATION_BROKER_PROTOCOL_VERSION,
+          contractVersion: COLLABORATION_CONTRACT_VERSION,
+          sessionToken: environment.KOED_DESKTOP_COLLABORATION_BROKER_SESSION_TOKEN,
+          type: "owner_released",
+          envelopeId: message.envelopeId,
+          ownerId: message.ownerId
+        });
+        return;
+      }
+      if (message.type === "shutdown") {
+        stopEnrollmentMonitors();
+        transport.stop();
+        for (const ownerId of [...ownerContexts.keys()]) {
+          releaseOwner(ownerId);
+        }
+        await ownedUpstreamFetcher?.close();
+        sessionSend({
+          protocolVersion: DESKTOP_COLLABORATION_BROKER_PROTOCOL_VERSION,
+          contractVersion: COLLABORATION_CONTRACT_VERSION,
+          sessionToken: environment.KOED_DESKTOP_COLLABORATION_BROKER_SESSION_TOKEN,
+          type: "shutdown_ack",
+          envelopeId: message.envelopeId
+        });
+        return;
+      }
+      const owner = ownerContext(message.ownerId);
+      const command = collaborationRendererCommandSchema.parse(message.command);
+      const claim = claimOwnerRequest(owner, command);
+      if (claim.state === "conflict") {
+        sendCommandResult(message.envelopeId, message.ownerId, commandFailure(command, collaborationSafeError("conflict")));
+        return;
+      }
+      if (claim.state === "cached") {
+        sendCommandResult(message.envelopeId, message.ownerId, claim.result);
+        return;
+      }
+      claimedRequest = { owner, requestId: command.requestId };
+      const context = {
+        ownerId: message.ownerId,
+        signal: owner.controller.signal,
+        emitCollaborationEvent: (event) => sendOwnerEvent(message.ownerId, event)
+      };
+      if (command.command === "collaboration.load") {
+        await retryRevokedBackendDurableCleanup();
+        await ensureBackendCapabilities();
+      }
+      let result = command.command === "collaboration.connect_backend" || command.command === "collaboration.reconnect_backend" || command.command === "collaboration.disconnect_backend" ? await runLifecycleExclusive(() => handleLifecycleCommand(command, message.ownerId)) : command.command === "collaboration.send_message" || command.command === "collaboration.retry_message" ? persistAndExecuteSend(command, context) : await transport.request(command, context);
+      if (result.ok) {
+        const resultData = result.data;
+        if (resultData.snapshot) {
+          const projectedSnapshot = snapshotWithDurableSends(resultData.snapshot);
+          result = collaborationCommandResultSchema.parse({
+            ...result,
+            data: { ...result.data, snapshot: projectedSnapshot }
+          });
+          owner.snapshot = projectedSnapshot;
+        }
+      }
+      const shouldResumeInterruptedSends = result.ok && result.command === "collaboration.load" && !upstreamDisconnectCleanupPending(paths);
+      if (result.ok && result.command === "collaboration.request_action_grant" && result.data.status.state === "pending" && result.data.status.activationUrl) {
+        dependencies.onBrowserOpenRequest?.({
+          ownerId: context.ownerId,
+          url: result.data.status.activationUrl
+        });
+      }
+      finishOwnerRequest(owner, command.requestId, result);
+      claimedRequest = void 0;
+      sendCommandResult(message.envelopeId, message.ownerId, result);
+      const pendingSendStart = pendingSendStarts.get(command.requestId);
+      if (pendingSendStart) {
+        pendingSendStarts.delete(command.requestId);
+        await executePendingSend(pendingSendStart.command, pendingSendStart.pending, pendingSendStart.context);
+      }
+      if (shouldResumeInterruptedSends && result.ok && result.command === "collaboration.load") {
+        await resumeInterruptedSends(context, result.data.snapshot);
+      }
+    } catch (error) {
+      if (claimedRequest) {
+        failOwnerRequest(claimedRequest.owner, claimedRequest.requestId);
+      }
+      console.error(JSON.stringify({
+        event: "desktop.collaboration.command.failed",
+        errorName: error instanceof Error ? error.name : "UnknownError"
+      }));
+      rejectInvalidMessage(value);
+    }
+  };
+  const sendReady = () => {
+    sessionSend({
+      protocolVersion: DESKTOP_COLLABORATION_BROKER_PROTOCOL_VERSION,
+      contractVersion: COLLABORATION_CONTRACT_VERSION,
+      sessionToken: environment.KOED_DESKTOP_COLLABORATION_BROKER_SESSION_TOKEN,
+      type: "ready",
+      brokerPid: process.pid
+    });
+  };
+  scheduleDisconnectCleanupRetry();
+  return {
+    handleMessage,
+    releaseOwner,
+    shutdown: async () => {
+      stopEnrollmentMonitors();
+      clearCapabilityRefreshTimers();
+      if (disconnectCleanupTimer)
+        clearTimeout(disconnectCleanupTimer);
+      disconnectCleanupTimer = null;
+      transport.stop();
+      for (const ownerId of [...ownerContexts.keys()]) {
+        releaseOwner(ownerId);
+      }
+      await ownedUpstreamFetcher?.close();
+    },
+    sendReady
+  };
+};
+var runDesktopCollaborationBrokerProcess = () => {
+  const sessionToken = process.env.KOED_DESKTOP_COLLABORATION_BROKER_SESSION_TOKEN?.trim();
+  if (!sessionToken) {
+    throw new Error("KOED_DESKTOP_COLLABORATION_BROKER_SESSION_TOKEN is required.");
+  }
+  if (typeof process.send !== "function") {
+    throw new Error("Desktop collaboration broker requires an inherited Node IPC channel.");
+  }
+  const broker = createDesktopCollaborationBroker({
+    sendMessage: (message) => {
+      process.send?.(message);
+    },
+    onBrowserOpenRequest: ({ ownerId, url }) => {
+      process.send?.(desktopCollaborationBrokerChildMessageSchema.parse({
+        protocolVersion: DESKTOP_COLLABORATION_BROKER_PROTOCOL_VERSION,
+        contractVersion: COLLABORATION_CONTRACT_VERSION,
+        sessionToken,
+        type: "open_external",
+        envelopeId: randomUUID2(),
+        ownerId,
+        url
+      }));
+    }
+  });
+  process.on("message", (value) => {
+    void broker.handleMessage(value);
+  });
+  process.once("disconnect", () => {
+    void broker.shutdown().finally(() => process.exit(0));
+  });
+  broker.sendReady();
+  return Promise.resolve();
+};
+export {
+  createDesktopCollaborationBroker,
+  runDesktopCollaborationBrokerProcess
+};