@wrongstack/webui-server 0.293.0 → 0.295.1

package/dist/protocol/index.js

@@ -0,0 +1,874 @@
+// src/protocol/connection-fsm.ts
+var DEFAULT_SURFACE_CONNECTION_CONFIG = {
+  maxReconnectAttempts: 10,
+  initialBackoffMs: 1e3,
+  maxBackoffMs: 3e4,
+  backoffMultiplier: 2,
+  jitterRatio: 0,
+  queueLimit: 1e3,
+  heartbeatIntervalMs: 0,
+  heartbeatTimeoutMs: 0
+};
+function createSurfaceConnectionState() {
+  return { phase: "idle", reconnectAttempt: 0, lastActivityAt: null, stopped: false };
+}
+function markConnectionConnecting(state) {
+  if (state.stopped) return state;
+  return { ...state, phase: "connecting" };
+}
+function markConnectionOpen(state, now = Date.now()) {
+  return {
+    ...state,
+    phase: "open",
+    reconnectAttempt: 0,
+    lastActivityAt: now,
+    stopped: false
+  };
+}
+function markConnectionActivity(state, now = Date.now()) {
+  return { ...state, lastActivityAt: now };
+}
+function stopConnection(state) {
+  return { ...state, phase: "closed", stopped: true };
+}
+function resetConnection(state) {
+  return { ...state, phase: "idle", reconnectAttempt: 0, stopped: false };
+}
+function planConnectionReconnect(state, config, now = Date.now(), random = Math.random) {
+  if (state.stopped || state.reconnectAttempt >= config.maxReconnectAttempts) {
+    return { state: { ...state, phase: "closed" }, plan: null };
+  }
+  const attempt = state.reconnectAttempt + 1;
+  const base = Math.min(
+    config.initialBackoffMs * config.backoffMultiplier ** (attempt - 1),
+    config.maxBackoffMs
+  );
+  const centeredJitter = (random() * 2 - 1) * config.jitterRatio;
+  const delayMs = Math.max(0, Math.round(base * (1 + centeredJitter)));
+  return {
+    state: { ...state, phase: "reconnecting", reconnectAttempt: attempt },
+    plan: { attempt, delayMs, retryAt: now + delayMs }
+  };
+}
+function isConnectionHeartbeatTimedOut(state, config, now = Date.now()) {
+  if (state.phase !== "open" || state.lastActivityAt === null) return false;
+  if (config.heartbeatIntervalMs <= 0) return false;
+  return now - state.lastActivityAt > config.heartbeatIntervalMs + config.heartbeatTimeoutMs;
+}
+function enqueueBounded(queue, item, limit) {
+  if (limit <= 0) return { queue: [], dropped: item };
+  if (queue.length < limit) return { queue: [...queue, item], dropped: null };
+  return { queue: [...queue.slice(queue.length - limit + 1), item], dropped: queue[0] ?? null };
+}
+
+// src/protocol/client-conversation.ts
+var CLIENT_CONVERSATION_MESSAGE_TYPES = [
+  "abort",
+  "ping",
+  "user_message",
+  "tool.confirm_result",
+  "completion.request",
+  "model.switch",
+  "model.refine",
+  "autonomy.switch",
+  "context.clear",
+  "context.compact",
+  "context.debug",
+  "context.mode.create",
+  "context.mode.delete",
+  "context.mode.switch",
+  "context.mode.update",
+  "context.modes.list",
+  "context.repair",
+  "mode.switch",
+  "modes.list",
+  "session.checkpoints",
+  "session.delete",
+  "session.new",
+  "session.rename",
+  "session.resume",
+  "session.rewind",
+  "session.save",
+  "sessions.list",
+  "side_effects.list",
+  "stats.get",
+  "todo.update",
+  "todos.clear",
+  "todos.get",
+  "todos.remove"
+];
+var CLIENT_COLLABORATION_MESSAGE_TYPES = [
+  "collab.join",
+  "collab.leave",
+  "collab.annotate",
+  "collab.resolve",
+  "collab.request_pause",
+  "collab.resume",
+  "collab.grant_control",
+  "collab.inject_tool",
+  "mailbox.agents",
+  "mailbox.clear",
+  "mailbox.compact",
+  "mailbox.messages",
+  "mailbox.purge",
+  "mailbox.send"
+];
+
+// src/protocol/client-integrations.ts
+var CLIENT_KNOWLEDGE_MESSAGE_TYPES = [
+  "brain.ask",
+  "brain.config.get",
+  "brain.config.set",
+  "brain.risk",
+  "brain.status",
+  "chronicle.facet",
+  "chronicle.facets",
+  "chronicle.graph",
+  "chronicle.metrics",
+  "chronicle.query",
+  "config.doctor",
+  "design.list",
+  "design.materialize",
+  "design.set",
+  "design.state",
+  "design.swap",
+  "design.tune",
+  "design.use",
+  "design.verify",
+  "memory.list",
+  "memory.sage.backfillRecoverable",
+  "memory.sage.candidateResolve",
+  "memory.sage.delete",
+  "memory.sage.forFile",
+  "memory.sage.get",
+  "memory.sage.graph",
+  "memory.sage.list",
+  "memory.sage.listPage",
+  "memory.sage.recover",
+  "memory.sage.remember",
+  "memory.sage.update"
+];
+var CLIENT_EXTENSION_MESSAGE_TYPES = [
+  "auth.oauth.cancel",
+  "auth.oauth.code",
+  "auth.oauth.start",
+  "mcp.add",
+  "mcp.disable",
+  "mcp.discover",
+  "mcp.enable",
+  "mcp.list",
+  "mcp.prompt.get",
+  "mcp.prompts",
+  "mcp.remove",
+  "mcp.resource.read",
+  "mcp.resources",
+  "mcp.restart",
+  "mcp.sleep",
+  "mcp.update",
+  "mcp.wake",
+  "prompts.content",
+  "prompts.create",
+  "prompts.favorite",
+  "prompts.list",
+  "prompts.recent",
+  "prompts.search",
+  "prompts.used",
+  "skills.content",
+  "skills.create",
+  "skills.edit",
+  "skills.export",
+  "skills.install",
+  "skills.list",
+  "skills.uninstall",
+  "skills.update"
+];
+
+// src/protocol/client-operations.ts
+var CLIENT_GOAL_MESSAGE_TYPES = [
+  "goal-state.get",
+  "goal.addTask",
+  "goal.assignTask",
+  "goal.clear",
+  "goal.get",
+  "goal.list",
+  "goal.load",
+  "goal.moveTask",
+  "goal.pause",
+  "goal.resume",
+  "goal.retryTask",
+  "goal.revert",
+  "goal.runTask",
+  "goal.save",
+  "goal.selectPhase",
+  "goal.start",
+  "goal.state",
+  "goal.status",
+  "goal.stop",
+  "goal.taskStatus",
+  "goal.toggleAutonomous",
+  "plan.get",
+  "plan.item.update",
+  "plan.template_use",
+  "task.update",
+  "tasks.get"
+];
+var CLIENT_SDD_MESSAGE_TYPES = [
+  "sdd.board.cancel_task",
+  "sdd.board.cleanup_worktrees",
+  "sdd.board.delete_task",
+  "sdd.board.destroy",
+  "sdd.board.get",
+  "sdd.board.list",
+  "sdd.board.pause",
+  "sdd.board.reassign",
+  "sdd.board.resume",
+  "sdd.board.retry",
+  "sdd.board.retry_all_failed",
+  "sdd.board.rollback",
+  "sdd.board.set_task_fallbacks",
+  "sdd.board.set_task_model",
+  "sdd.board.set_task_verification",
+  "sdd.board.split_task",
+  "sdd.board.stop",
+  "sdd.run.start",
+  "sdd.spec.approve",
+  "sdd.spec.get",
+  "sdd.spec.message",
+  "sdd.spec.start",
+  "specs.get",
+  "specs.list",
+  "specs.taskStatus"
+];
+
+// src/protocol/client-workspace.ts
+var CLIENT_WORKSPACE_MESSAGE_TYPES = [
+  "files.list",
+  "files.read",
+  "files.tree",
+  "files.write",
+  "git.changes",
+  "git.diff",
+  "git.info",
+  "projects.add",
+  "projects.list",
+  "projects.select",
+  "working_dir.set",
+  "worktree.cleanup",
+  "worktree.diff",
+  "worktree.merge",
+  "worktree.remove",
+  "worktree.scan",
+  "shell.open",
+  "process.kill",
+  "process.killAll",
+  "process.list",
+  "terminal.close",
+  "terminal.create",
+  "terminal.input",
+  "terminal.resize"
+];
+var CLIENT_CONFIGURATION_MESSAGE_TYPES = [
+  "diag.get",
+  "key.add",
+  "key.delete",
+  "key.set_active",
+  "key.update",
+  "prefs.get",
+  "prefs.update",
+  "provider.add",
+  "provider.clear_models",
+  "provider.models",
+  "provider.probe",
+  "provider.remove",
+  "provider.undo_clear",
+  "provider.update",
+  "providers.list",
+  "providers.saved",
+  "tool.disable",
+  "tool.enable",
+  "tools.list",
+  "webui.shutdown"
+];
+
+// src/protocol/server-conversation.ts
+var SERVER_CONVERSATION_MESSAGE_TYPES = [
+  "error",
+  "log",
+  "pong",
+  "side_effects",
+  "agent.status_changed",
+  "agent.timeline.message",
+  "client.status_update",
+  "compaction.failed",
+  "completion.result",
+  "context.compacted",
+  "context.debug",
+  "context.mode.changed",
+  "context.modes.list",
+  "context.repaired",
+  "ctx.max_context",
+  "ctx.pct",
+  "delegate.completed",
+  "delegate.started",
+  "iteration.completed",
+  "iteration.limit_reached",
+  "iteration.started",
+  "model.refine_result",
+  "modes.list",
+  "provider.active_blocked",
+  "provider.error",
+  "provider.fallback",
+  "provider.response",
+  "provider.retry",
+  "provider.status_changed",
+  "provider.stream_error",
+  "provider.text_delta",
+  "provider.thinking_delta",
+  "run.result",
+  "session.checkpoints",
+  "session.damaged",
+  "session.end",
+  "session.rewound",
+  "session.start",
+  "session.stats",
+  "sessions.list",
+  "sessions.status_update",
+  "stats.get",
+  "token.cost_estimate_unavailable",
+  "token.threshold",
+  "tool.confirm_needed",
+  "tool.disabled",
+  "tool.enabled",
+  "tool.executed",
+  "tool.loop_detected",
+  "tool.progress",
+  "tool.started",
+  "tools.list",
+  "trust.persisted"
+];
+var SERVER_COLLABORATION_MESSAGE_TYPES = [
+  "collab.annotation.added",
+  "collab.annotation.resolved",
+  "collab.event",
+  "collab.injection.granted",
+  "collab.participant.joined",
+  "collab.participant.left",
+  "collab.pause.granted",
+  "collab.pause.released",
+  "collab.state",
+  "mailbox.agent_registered",
+  "mailbox.agents",
+  "mailbox.cleared",
+  "mailbox.compacted",
+  "mailbox.event",
+  "mailbox.messages",
+  "mailbox.sent",
+  "mailbox.purged",
+  "mailbox.received",
+  "subagent.budget_extended",
+  "subagent.event"
+];
+
+// src/protocol/server-integrations.ts
+var SERVER_KNOWLEDGE_MESSAGE_TYPES = [
+  "brain.answer",
+  "brain.config",
+  "brain.event",
+  "brain.status",
+  "chronicle.error",
+  "chronicle.facet_result",
+  "chronicle.facets_result",
+  "chronicle.graph_result",
+  "chronicle.metrics_result",
+  "chronicle.query_result",
+  "config.doctor.result",
+  "design.list",
+  "design.materialize",
+  "design.set",
+  "design.state",
+  "design.swap",
+  "design.tune",
+  "design.use",
+  "design.verify",
+  "memory.event",
+  "memory.list",
+  "memory.sage.backfillRecoverable",
+  "memory.sage.candidateResolve",
+  "memory.sage.delete",
+  "memory.sage.forFile",
+  "memory.sage.get",
+  "memory.sage.graph",
+  "memory.sage.list",
+  "memory.sage.listPage",
+  "memory.sage.recover",
+  "memory.sage.remember",
+  "memory.sage.update"
+];
+var SERVER_EXTENSION_MESSAGE_TYPES = [
+  "mcp.content.error",
+  "mcp.content.selected",
+  "mcp.list",
+  "mcp.operation_result",
+  "mcp.prompts",
+  "mcp.resources",
+  "mcp.server.added",
+  "mcp.server.connected",
+  "mcp.server.disconnected",
+  "mcp.server.discovered",
+  "mcp.server.error",
+  "mcp.server.reconnected",
+  "mcp.server.removed",
+  "mcp.server.sleeping",
+  "mcp.server.updated",
+  "mcp.server.waking",
+  "prompts.content",
+  "prompts.created",
+  "prompts.favorite",
+  "prompts.list",
+  "prompts.recent",
+  "prompts.search",
+  "prompts.used",
+  "skills.content",
+  "skills.created",
+  "skills.edited",
+  "skills.exported",
+  "skills.installed",
+  "skills.list",
+  "skills.uninstalled",
+  "skills.updated"
+];
+
+// src/protocol/server-operations.ts
+var SERVER_GOAL_MESSAGE_TYPES = [
+  "budget.decision",
+  "budget.threshold_reached",
+  "coordinator.stats",
+  "coordinator.status",
+  "eternal.iteration",
+  "fleet.concurrency_update",
+  "goal-state.updated",
+  "goal.list",
+  "goal.paused",
+  "goal.resumed",
+  "goal.saved",
+  "goal.error",
+  "goal.stopped",
+  "goal.failed",
+  "goal.completed",
+  "goal.cleared",
+  "goal.reverted",
+  "goal.progress",
+  "goal.state",
+  "in_flight.ended",
+  "in_flight.started",
+  "plan.updated",
+  "task.completed",
+  "task.failed",
+  "task.pending",
+  "task.started",
+  "tasks.updated",
+  "todos.cleared",
+  "todos.updated"
+];
+var SERVER_SDD_MESSAGE_TYPES = [
+  "kanban.task.activity",
+  "sdd.board.lifecycle_result",
+  "sdd.board.list",
+  "sdd.board.snapshot",
+  "sdd.run.started",
+  "sdd.spec.agent_text",
+  "sdd.spec.error",
+  "sdd.spec.snapshot",
+  "specs.detail",
+  "specs.list"
+];
+var SERVER_AUTOMATION_MESSAGE_TYPES = [
+  "consensus.vote_cast",
+  "consensus.vote_initiated",
+  "consensus.vote_resolved",
+  "cron.job_fired",
+  "cron.snapshot",
+  "techstack.job.cancelled",
+  "techstack.job.failed",
+  "techstack.job.progress",
+  "techstack.job.started",
+  "techstack.report.delivered",
+  "techstack.report.ready",
+  "techstack.snapshot.updated",
+  "techstack.workspace.completed"
+];
+
+// src/protocol/server-workspace.ts
+var SERVER_WORKSPACE_MESSAGE_TYPES = [
+  "checkpoint.written",
+  "codemap.file_event",
+  "codemap.index_updated",
+  "codemap.tool_executed",
+  "codemap.tool_started",
+  "file.saved",
+  "files.list",
+  "files.read",
+  "files.tree",
+  "files.written",
+  "git.changes",
+  "git.diff",
+  "git.info",
+  "process.list",
+  "projects.added",
+  "projects.list",
+  "projects.selected",
+  "terminal.exit",
+  "terminal.output",
+  "working_dir.changed",
+  "worktree.cleanup_result",
+  "worktree.diff_result",
+  "worktree.event",
+  "worktree.merge_result",
+  "worktree.orphans",
+  "worktree.state"
+];
+var SERVER_CONFIGURATION_MESSAGE_TYPES = [
+  "auth.oauth.status",
+  "diag.get",
+  "key.operation_result",
+  "prefs.updated",
+  "provider.catalog",
+  "provider.models",
+  "provider.probe",
+  "providers.saved"
+];
+
+// src/protocol/registry.ts
+var CLIENT_MESSAGE_TYPES = [
+  ...CLIENT_CONVERSATION_MESSAGE_TYPES,
+  ...CLIENT_COLLABORATION_MESSAGE_TYPES,
+  ...CLIENT_WORKSPACE_MESSAGE_TYPES,
+  ...CLIENT_CONFIGURATION_MESSAGE_TYPES,
+  ...CLIENT_GOAL_MESSAGE_TYPES,
+  ...CLIENT_SDD_MESSAGE_TYPES,
+  ...CLIENT_KNOWLEDGE_MESSAGE_TYPES,
+  ...CLIENT_EXTENSION_MESSAGE_TYPES
+];
+var SERVER_MESSAGE_TYPES = [
+  ...SERVER_CONVERSATION_MESSAGE_TYPES,
+  ...SERVER_COLLABORATION_MESSAGE_TYPES,
+  ...SERVER_WORKSPACE_MESSAGE_TYPES,
+  ...SERVER_CONFIGURATION_MESSAGE_TYPES,
+  ...SERVER_GOAL_MESSAGE_TYPES,
+  ...SERVER_SDD_MESSAGE_TYPES,
+  ...SERVER_AUTOMATION_MESSAGE_TYPES,
+  ...SERVER_KNOWLEDGE_MESSAGE_TYPES,
+  ...SERVER_EXTENSION_MESSAGE_TYPES
+];
+var CLIENT_TYPE_SET = new Set(CLIENT_MESSAGE_TYPES);
+var SERVER_TYPE_SET = new Set(SERVER_MESSAGE_TYPES);
+function isRegisteredMessageType(type, direction) {
+  const exact = direction === "client" ? CLIENT_TYPE_SET : SERVER_TYPE_SET;
+  return exact.has(type) || type.startsWith("kanban.") && type.length > "kanban.".length || type.startsWith("agent-roster.") && type.length > "agent-roster.".length;
+}
+
+// src/protocol/decoder.ts
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var MAX_PAYLOAD_DEPTH = 32;
+function inspectValue(value, path, depth) {
+  if (depth > MAX_PAYLOAD_DEPTH) {
+    return { code: "too_deep", message: "Protocol payload exceeds the nesting limit", path };
+  }
+  if (value === null || typeof value !== "object") return null;
+  for (const key of Object.keys(value)) {
+    const childPath = `${path}.${key}`;
+    if (FORBIDDEN_KEYS.has(key)) {
+      return { code: "unsafe_key", message: `Unsafe protocol key: ${key}`, path: childPath };
+    }
+    const issue = inspectValue(value[key], childPath, depth + 1);
+    if (issue) return issue;
+  }
+  return null;
+}
+function decodeProtocolMessage(input, direction) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    return {
+      ok: false,
+      issue: { code: "invalid_envelope", message: "Protocol message must be an object" }
+    };
+  }
+  const envelope = input;
+  if (typeof envelope["type"] !== "string" || envelope["type"].length === 0) {
+    return {
+      ok: false,
+      issue: { code: "invalid_type", message: "Protocol message type must be a non-empty string" }
+    };
+  }
+  if (!isRegisteredMessageType(envelope["type"], direction)) {
+    return {
+      ok: false,
+      issue: { code: "unknown_type", message: `Unknown ${direction} message: ${envelope["type"]}` }
+    };
+  }
+  if (direction === "server" && !Object.hasOwn(envelope, "payload")) {
+    return {
+      ok: false,
+      issue: { code: "invalid_envelope", message: "Server protocol messages require a payload" }
+    };
+  }
+  const issue = inspectValue(envelope, "$", 0);
+  if (issue) return { ok: false, issue };
+  return { ok: true, message: input };
+}
+function decodeProtocolFrame(frame, direction) {
+  try {
+    return decodeProtocolMessage(JSON.parse(frame), direction);
+  } catch {
+    return {
+      ok: false,
+      issue: { code: "invalid_envelope", message: "Protocol frame is not valid JSON" }
+    };
+  }
+}
+
+// src/protocol/projections.ts
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function text(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function finite(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function optionalArray(value) {
+  return value === void 0 || Array.isArray(value);
+}
+function isValidHqTotals(totals) {
+  return finite(totals["activeProjects"]) === totals["activeProjects"] && finite(totals["activeClients"]) === totals["activeClients"] && finite(totals["activeSessions"]) === totals["activeSessions"] && finite(totals["activeSubagents"]) === totals["activeSubagents"] && finite(totals["unreadMailboxMessages"]) === totals["unreadMailboxMessages"] && finite(totals["incompleteMailboxMessages"]) === totals["incompleteMailboxMessages"] && finite(totals["totalCostUsd"]) === totals["totalCostUsd"];
+}
+function projectSessionMessage(message) {
+  if (message.type !== "session.start") return null;
+  const payload = record(message.payload);
+  if (!payload) return null;
+  return {
+    kind: "session",
+    id: text(payload["sessionId"]),
+    provider: text(payload["provider"]),
+    model: text(payload["model"]),
+    projectName: text(payload["projectName"], "Project"),
+    cwd: text(payload["cwd"]),
+    maxContext: finite(payload["maxContext"]),
+    reset: payload["reset"] === true,
+    replayMessages: Array.isArray(payload["replayMessages"]) ? payload["replayMessages"] : null,
+    replayMarkers: Array.isArray(payload["replayMarkers"]) ? payload["replayMarkers"] : null,
+    replayUsage: record(payload["replayUsage"])
+  };
+}
+function projectChatMessage(message) {
+  const payload = record(message.payload);
+  if (!payload) return null;
+  switch (message.type) {
+    case "provider.thinking_delta": {
+      const value = text(payload["text"]);
+      return value ? { kind: "thinking-delta", text: value } : null;
+    }
+    case "provider.text_delta": {
+      const value = text(payload["text"]);
+      return value ? { kind: "text-delta", text: value, messageId: text(payload["messageId"]) } : null;
+    }
+    case "provider.response":
+      return { kind: "response", content: payload["content"] };
+    case "run.result":
+      return {
+        kind: "run-result",
+        status: text(payload["status"]),
+        iterations: finite(payload["iterations"], 1),
+        ...typeof payload["finalText"] === "string" ? { finalText: payload["finalText"] } : {}
+      };
+    case "error":
+      return { kind: "error", message: text(payload["message"], "Run failed") };
+    default:
+      return null;
+  }
+}
+function projectToolMessage(message) {
+  const payload = record(message.payload);
+  if (!payload) return null;
+  if (message.type === "tool.started") {
+    const name = text(payload["name"], "tool");
+    return {
+      kind: "started",
+      id: text(payload["id"], name),
+      name,
+      input: payload["input"],
+      messageId: text(payload["messageId"])
+    };
+  }
+  if (message.type === "tool.progress") {
+    const event = record(payload["event"]);
+    return {
+      kind: "progress",
+      id: text(payload["id"]),
+      name: text(payload["name"], "tool"),
+      eventType: text(event?.["type"]),
+      text: text(event?.["text"]).trim()
+    };
+  }
+  if (message.type === "tool.executed") {
+    return {
+      kind: "executed",
+      id: text(payload["id"]),
+      name: text(payload["name"]),
+      ok: payload["ok"] !== false,
+      durationMs: finite(payload["durationMs"]),
+      ...typeof payload["output"] === "string" ? { output: payload["output"] } : {}
+    };
+  }
+  return null;
+}
+function projectFleetMessage(message) {
+  const payload = record(message.payload);
+  if (!payload) return null;
+  switch (message.type) {
+    case "fleet.concurrency_update":
+      return {
+        kind: "concurrency",
+        active: finite(payload["fleetConcurrency"]),
+        maximum: finite(payload["fleetConcurrencyMax"])
+      };
+    case "client.status_update":
+      return { kind: "client-status", status: payload };
+    case "sessions.status_update":
+      return {
+        kind: "sessions",
+        sessions: Array.isArray(payload["sessions"]) ? payload["sessions"] : []
+      };
+    case "coordinator.stats":
+      return {
+        kind: "coordinator",
+        agents: Array.isArray(payload["subagentStatuses"]) ? payload["subagentStatuses"].filter(
+          (item) => record(item) !== null
+        ) : []
+      };
+    default:
+      return null;
+  }
+}
+function projectHqFleetMessage(message) {
+  if (message.type !== "hq.snapshot") return null;
+  const snapshot = record(message.snapshot);
+  const totals = snapshot ? record(snapshot["totals"]) : null;
+  if (!snapshot || typeof snapshot["generatedAt"] !== "string" || !Array.isArray(snapshot["clients"]) || !Array.isArray(snapshot["projects"]) || !Array.isArray(snapshot["sessions"]) || !Array.isArray(snapshot["fleets"]) || !Array.isArray(snapshot["mailboxes"]) || !totals || !isValidHqTotals(totals) || !optionalArray(snapshot["machines"]) || !optionalArray(snapshot["liveSessions"]) || !optionalArray(snapshot["mcpServers"])) {
+    return null;
+  }
+  return { kind: "hq-snapshot", snapshot };
+}
+function projectHqEventMessage(message) {
+  if (message.type !== "hq.event") return null;
+  const event = record(message.event);
+  if (!event || typeof event["id"] !== "string" || typeof event["type"] !== "string" || typeof event["timestamp"] !== "string" || typeof event["clientId"] !== "string" || typeof event["projectId"] !== "string" || typeof event["seq"] !== "number") {
+    return null;
+  }
+  return { kind: "hq-event", event };
+}
+function projectHqAlertMessage(message) {
+  if (message.type !== "hq.alert") return null;
+  if (typeof message["severity"] !== "string" || !["info", "warn", "error"].includes(message["severity"]) || typeof message["message"] !== "string" || typeof message["timestamp"] !== "string") {
+    return null;
+  }
+  return { kind: "hq-alert", alert: message };
+}
+function projectHqCommandStatusMessage(message) {
+  if (message.type !== "hq.command_status") return null;
+  const command = record(message.command);
+  if (!command || typeof command["commandId"] !== "string" || typeof command["type"] !== "string" || typeof command["clientId"] !== "string" || typeof command["enqueuedBy"] !== "string" || typeof command["enqueuedAt"] !== "string" || typeof command["status"] !== "string" || !["queued", "delivered", "acked"].includes(command["status"])) {
+    return null;
+  }
+  return { kind: "hq-command-status", command };
+}
+
+// src/protocol/replay-payload.ts
+import { CHAT_MARKER_SOURCES, projectSessionMarkers } from "@wrongstack/core/types";
+var REPLAY_MESSAGE_CAP = 2e3;
+function buildReplayPayload(source) {
+  const out = {};
+  const messages = source.messages;
+  if (messages.length > 0) {
+    out.replayMessages = messages.length > REPLAY_MESSAGE_CAP ? messages.slice(-REPLAY_MESSAGE_CAP) : [...messages];
+  }
+  if (source.events && source.events.length > 0) {
+    const markers = projectSessionMarkers(source.events, CHAT_MARKER_SOURCES);
+    if (markers.length > 0) out.replayMarkers = markers;
+  }
+  const usage = source.usage;
+  if (usage && usage.input + usage.output + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0) > 0) {
+    out.replayUsage = {
+      input: usage.input,
+      output: usage.output,
+      cacheRead: usage.cacheRead ?? 0,
+      cacheWrite: usage.cacheWrite ?? 0
+    };
+  }
+  return out;
+}
+
+// src/protocol/version.ts
+var SURFACE_PROTOCOL_VERSION = 1;
+var SURFACE_PROTOCOL_MIN_VERSION = 1;
+var SURFACE_PROTOCOL_CAPABILITIES = [
+  "protocol.directional-decoder",
+  "protocol.recursive-key-safety",
+  "chronicle.query",
+  "chronicle.facet",
+  "chronicle.facets",
+  "chronicle.graph",
+  "chronicle.metrics"
+];
+function protocolAdvertisement() {
+  return {
+    protocolVersion: SURFACE_PROTOCOL_VERSION,
+    protocolCapabilities: [...SURFACE_PROTOCOL_CAPABILITIES]
+  };
+}
+function negotiateProtocol(peer) {
+  const peerVersion = peer.protocolVersion;
+  const legacyPeer = peerVersion === void 0;
+  const version = legacyPeer ? SURFACE_PROTOCOL_VERSION : Math.min(peerVersion, SURFACE_PROTOCOL_VERSION);
+  const compatible = legacyPeer || Number.isInteger(peerVersion) && peerVersion >= SURFACE_PROTOCOL_MIN_VERSION;
+  const advertised = new Set(peer.protocolCapabilities ?? []);
+  return {
+    compatible,
+    legacyPeer,
+    version,
+    capabilities: SURFACE_PROTOCOL_CAPABILITIES.filter((item) => advertised.has(item))
+  };
+}
+export {
+  CLIENT_MESSAGE_TYPES,
+  DEFAULT_SURFACE_CONNECTION_CONFIG,
+  REPLAY_MESSAGE_CAP,
+  SERVER_MESSAGE_TYPES,
+  SURFACE_PROTOCOL_CAPABILITIES,
+  SURFACE_PROTOCOL_MIN_VERSION,
+  SURFACE_PROTOCOL_VERSION,
+  buildReplayPayload,
+  createSurfaceConnectionState,
+  decodeProtocolFrame,
+  decodeProtocolMessage,
+  enqueueBounded,
+  isConnectionHeartbeatTimedOut,
+  isRegisteredMessageType,
+  markConnectionActivity,
+  markConnectionConnecting,
+  markConnectionOpen,
+  negotiateProtocol,
+  planConnectionReconnect,
+  projectChatMessage,
+  projectFleetMessage,
+  projectHqAlertMessage,
+  projectHqCommandStatusMessage,
+  projectHqEventMessage,
+  projectHqFleetMessage,
+  projectSessionMessage,
+  projectToolMessage,
+  protocolAdvertisement,
+  resetConnection,
+  stopConnection
+};
+//# sourceMappingURL=index.js.map