pinomad 0.6.0 → 0.8.0

package/dist/chunk-jgd38rna.js

@@ -0,0 +1,622 @@
+import {
+  HOST_SETTING_KEYS,
+  isQueueMode,
+  isThinkingLevel
+} from "./chunk-sygeb9qb.js";
+
+// packages/protocol/src/auth.ts
+var CUSTOM_PROVIDER_APIS = ["openai-completions", "openai-responses", "anthropic-messages", "google-generative-ai"];
+var isCustomProviderApi = (value) => CUSTOM_PROVIDER_APIS.includes(value);
+
+// packages/protocol/src/frames.ts
+var HOST_STREAMS = { conversations: 0, index: 0, devices: 0, mcp: 0, models: 1, auth: 1, settings: 2, agents: 6, providers: 21 };
+var HOST_STREAM_NAMES = Object.keys(HOST_STREAMS);
+function hostStreams(hostMinor) {
+  return HOST_STREAM_NAMES.filter((name) => HOST_STREAMS[name] <= hostMinor);
+}
+var conversationStream = (id) => `conversation:${id}`;
+var docStream = (kind, id) => `doc:${kind}:${id}`;
+var UNAUTHORIZED_CLOSE_CODE = 4401;
+var INVALID_FRAME_CLOSE_CODE = 4400;
+var PROTOCOL = { major: 5, minor: 25 };
+var CALL_SINCE = {
+  addProject: 0,
+  removeProject: 0,
+  listFolders: 3,
+  listFiles: 10,
+  listSkills: 13,
+  listCommands: 17,
+  createConversation: 0,
+  archive: 0,
+  renameConversation: 4,
+  submit: 0,
+  submission: 25,
+  withdrawQueued: 14,
+  steerQueued: 14,
+  abort: 0,
+  compact: 0,
+  runCommand: 17,
+  setModel: 0,
+  setThinkingLevel: 0,
+  setAgent: 18,
+  fork: 0,
+  answer: 0,
+  changes: 0,
+  createPairing: 0,
+  revokeDevice: 0,
+  logout: 1,
+  beginLogin: 21,
+  answerLogin: 21,
+  cancelLogin: 21,
+  saveCustomProvider: 21,
+  removeCustomProvider: 21,
+  listEndpointModels: 21,
+  updateSettings: 2,
+  createAgent: 6,
+  updateAgent: 6,
+  deleteAgent: 6,
+  setPushToken: 7,
+  image: 15,
+  beginAttachment: 19,
+  appendAttachment: 19,
+  rtcOffer: 23,
+  ping: 23
+};
+function hostSupportsCall(hostMinor, method) {
+  return hostMinor >= CALL_SINCE[method];
+}
+var FEATURE_SINCE = {
+  images: 5,
+  acceptAccountDevices: 8,
+  apnsPush: 9,
+  agentConversations: 10,
+  liveBranch: 11,
+  hostName: 12,
+  imageRefs: 15,
+  boundSkills: 16,
+  attachments: 19,
+  imageVariants: 20,
+  rtc: 23,
+  submitEntry: 25
+};
+function hostSupportsFeature(hostMinor, feature) {
+  return hostMinor >= FEATURE_SINCE[feature];
+}
+function parseClientFrame(value) {
+  if (!record(value) || typeof value.type !== "string")
+    return { kind: "malformed" };
+  if (value.type === "subscribe" || value.type === "unsubscribe") {
+    const stream = value.stream;
+    if (typeof stream !== "string")
+      return { kind: "malformed" };
+    if (isStreamName(stream)) {
+      const refs = value.type === "subscribe" && value.images === "ref";
+      return { kind: "frame", frame: refs ? { type: "subscribe", stream, images: "ref" } : { type: value.type, stream } };
+    }
+    const prefix = stream.slice(0, stream.indexOf(":") === -1 ? undefined : stream.indexOf(":"));
+    if (STREAM_KINDS.has(prefix))
+      return { kind: "malformed" };
+    return { kind: "unsupportedStream", type: value.type, stream };
+  }
+  if (value.type !== "call")
+    return { kind: "unknownType" };
+  const { id, method, args } = value;
+  if (typeof id !== "number" || !Number.isSafeInteger(id) || !record(args) || typeof method !== "string") {
+    return { kind: "malformed" };
+  }
+  if (!isCallMethod(method))
+    return { kind: "unsupportedCall", id, method };
+  return validCallArgs(method, args) ? { kind: "frame", frame: { type: "call", id, method, args } } : { kind: "malformed" };
+}
+var STREAM_KINDS = new Set(["conversation", "doc", "tasks", ...HOST_STREAM_NAMES]);
+function isStreamName(stream) {
+  return stream === "tasks" || HOST_STREAM_NAMES.includes(stream) || /^(?:conversation:|doc:.+:)[1-9]\d*$/.test(stream);
+}
+var isCallMethod = (method) => CALL_METHODS.includes(method);
+var CALL_METHODS = Object.keys(CALL_SINCE);
+var SETTING_VALIDATORS = {
+  defaultModel: (value) => value === null || record(value) && nonempty(value.provider) && nonempty(value.modelId),
+  defaultThinkingLevel: (value) => value === null || isThinkingLevel(value),
+  steeringMode: (value) => value === null || isQueueMode(value),
+  followUpMode: (value) => value === null || isQueueMode(value),
+  acceptAccountDevices: (value) => value === null || typeof value === "boolean",
+  rtcStun: (value) => value === null || Array.isArray(value) && value.every(nonempty),
+  hostName: (value) => value === null || typeof value === "string"
+};
+function validCallArgs(method, args) {
+  const conversationId = () => typeof args.conversationId === "number" && Number.isSafeInteger(args.conversationId) && args.conversationId >= 1;
+  const submissionId = () => typeof args.submissionId === "number" && Number.isSafeInteger(args.submissionId) && args.submissionId >= 1;
+  const images = () => args.images === undefined || Array.isArray(args.images) && args.images.every((image) => record(image) && ("data" in image ? typeof image.data === "string" && typeof image.mimeType === "string" : nonempty(image.ref)));
+  const skills = () => args.skills === undefined || Array.isArray(args.skills) && args.skills.every(nonempty);
+  const attachments = () => args.attachments === undefined || Array.isArray(args.attachments) && args.attachments.every(nonempty);
+  const role = () => record(args.role) && typeof args.role.name === "string" && typeof args.role.description === "string" && typeof args.role.prompt === "string" && (args.role.model === undefined || typeof args.role.model === "string") && (args.role.thinkingLevel === undefined || typeof args.role.thinkingLevel === "string");
+  switch (method) {
+    case "submit":
+      return conversationId() && typeof args.text === "string" && (args.whenBusy === "steer" || args.whenBusy === "followUp") && nonempty(args.requestId) && images() && skills() && attachments();
+    case "submission":
+      return conversationId() && nonempty(args.requestId);
+    case "withdrawQueued":
+    case "steerQueued":
+      return conversationId() && submissionId();
+    case "abort":
+      return conversationId();
+    case "setThinkingLevel":
+      return conversationId() && nonempty(args.level);
+    case "setAgent":
+      return conversationId() && (args.agent === null || nonempty(args.agent));
+    case "compact":
+      return conversationId() && (args.instructions === undefined || typeof args.instructions === "string");
+    case "listCommands":
+      return conversationId();
+    case "runCommand":
+      return conversationId() && nonempty(args.name) && (args.args === undefined || typeof args.args === "string");
+    case "setModel":
+      return conversationId() && record(args.model) && nonempty(args.model.provider) && nonempty(args.model.modelId);
+    case "fork":
+      return conversationId() && typeof args.entryId === "string" && /^[1-9]\d*$/.test(args.entryId) && (args.removeTools === undefined || Array.isArray(args.removeTools) && args.removeTools.every(nonempty));
+    case "answer":
+      return conversationId() && nonempty(args.kind) && nonempty(args.requestId) && Array.isArray(args.answers) && args.answers.every((answer) => record(answer) && Array.isArray(answer.selected) && answer.selected.every((l) => typeof l === "string") && (answer.other === undefined || typeof answer.other === "string"));
+    case "changes":
+      return conversationId();
+    case "image":
+      return nonempty(args.ref) && (args.variant === undefined || args.variant === "thumbnail" || args.variant === "preview");
+    case "beginAttachment":
+      return nonempty(args.name) && typeof args.size === "number" && Number.isSafeInteger(args.size) && args.size >= 0;
+    case "appendAttachment":
+      return nonempty(args.attachmentId) && typeof args.offset === "number" && Number.isSafeInteger(args.offset) && args.offset >= 0 && typeof args.data === "string";
+    case "addProject":
+    case "removeProject":
+      return nonempty(args.path);
+    case "listFolders":
+      return args.path === undefined || nonempty(args.path);
+    case "createConversation":
+      return record(args.home) && (args.home.kind === "chat" || args.home.kind === "project" && nonempty(args.home.path)) && typeof args.text === "string" && (nonempty(args.text) || Array.isArray(args.images) && args.images.length > 0 || Array.isArray(args.attachments) && args.attachments.length > 0) && nonempty(args.requestId) && images() && skills() && attachments() && (args.checkout === undefined || args.checkout === "worktree" || args.checkout === "project") && (args.model === undefined || record(args.model) && nonempty(args.model.provider) && nonempty(args.model.modelId)) && (args.thinkingLevel === undefined || nonempty(args.thinkingLevel)) && (args.agent === undefined || nonempty(args.agent));
+    case "listFiles":
+      return typeof args.query === "string" && record(args.scope) && (args.scope.kind === "conversation" && typeof args.scope.conversationId === "number" && Number.isSafeInteger(args.scope.conversationId) && args.scope.conversationId >= 1 || args.scope.kind === "project" && nonempty(args.scope.path) && (args.scope.checkout === "worktree" || args.scope.checkout === "project"));
+    case "listSkills":
+      return record(args.scope) && (args.scope.kind === "conversation" && typeof args.scope.conversationId === "number" && Number.isSafeInteger(args.scope.conversationId) && args.scope.conversationId >= 1 || args.scope.kind === "project" && nonempty(args.scope.path) && (args.scope.checkout === "worktree" || args.scope.checkout === "project") || args.scope.kind === "chat");
+    case "archive":
+      return conversationId() && typeof args.archived === "boolean";
+    case "renameConversation":
+      return conversationId() && typeof args.title === "string";
+    case "createPairing":
+      return Object.keys(args).length === 0;
+    case "rtcOffer":
+      return nonempty(args.attempt) && nonempty(args.sdp);
+    case "ping":
+      return nonempty(args.id);
+    case "revokeDevice":
+      return nonempty(args.publicKey) && /^[A-Za-z0-9_-]+$/.test(args.publicKey);
+    case "logout":
+    case "removeCustomProvider":
+      return nonempty(args.providerId);
+    case "beginLogin":
+      return nonempty(args.providerId) && (args.method === "oauth" || args.method === "api_key");
+    case "answerLogin":
+      return nonempty(args.loginId) && typeof args.promptId === "number" && Number.isSafeInteger(args.promptId) && typeof args.value === "string";
+    case "cancelLogin":
+      return nonempty(args.loginId);
+    case "saveCustomProvider":
+      return record(args.provider) && nonempty(args.provider.id) && typeof args.provider.name === "string" && isCustomProviderApi(args.provider.api) && typeof args.provider.baseUrl === "string" && Array.isArray(args.provider.models) && args.provider.models.every((model) => typeof model === "string") && (args.apiKey === undefined || args.apiKey === null || typeof args.apiKey === "string");
+    case "listEndpointModels":
+      return isCustomProviderApi(args.api) && typeof args.baseUrl === "string" && (args.apiKey === undefined || typeof args.apiKey === "string") && (args.providerId === undefined || nonempty(args.providerId));
+    case "createAgent":
+    case "updateAgent":
+      return role();
+    case "deleteAgent":
+      return typeof args.name === "string";
+    case "setPushToken":
+      return args.token === null || typeof args.token === "string" || record(args.token) && typeof args.token.apns === "string" && (args.token.environment === "production" || args.token.environment === "development");
+    case "updateSettings":
+      return record(args.patch) && Object.keys(args.patch).every((key) => HOST_SETTING_KEYS.includes(key)) && Object.entries(args.patch).every(([key, value]) => SETTING_VALIDATORS[key]?.(value) === true);
+  }
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function nonempty(value) {
+  return typeof value === "string" && value.length > 0;
+}
+
+// packages/protocol/src/rtc.ts
+function rtcAddressScope(address) {
+  const ip = parseRtcAddress(address);
+  if (ip === undefined)
+    return "unknown";
+  if (ip.family === 4)
+    return ipv4Scope(ip.octets);
+  const octets = mappedIpv4(ip.segments);
+  return octets === undefined ? ipv6Scope(ip.segments) : ipv4Scope(octets);
+}
+function rtcCandidateEnd(info) {
+  return {
+    ...info.type === undefined ? {} : { type: info.type },
+    ...info.address === undefined ? {} : { address: info.address },
+    scope: rtcAddressScope(info.address)
+  };
+}
+function rtcSelectedPair(local, remote) {
+  return { local: rtcCandidateEnd(local), remote: rtcCandidateEnd(remote) };
+}
+function parseRtcAddress(address) {
+  if (address === undefined)
+    return;
+  const text = address.trim();
+  if (text === "")
+    return;
+  let host = text;
+  if (text.startsWith("[")) {
+    const close = text.indexOf("]");
+    if (close === -1)
+      return;
+    const tail = text.slice(close + 1);
+    if (tail !== "" && !/^:\d+$/.test(tail))
+      return;
+    host = text.slice(1, close);
+  } else if (text.split(":").length === 2) {
+    const [candidate, port] = text.split(":");
+    if (/^\d+$/.test(port))
+      host = candidate;
+  }
+  const zone = host.indexOf("%");
+  if (zone !== -1)
+    host = host.slice(0, zone);
+  const ipv4 = parseIpv4(host);
+  if (ipv4 !== undefined)
+    return { family: 4, octets: ipv4 };
+  const ipv6 = parseIpv6(host);
+  return ipv6 === undefined ? undefined : { family: 6, segments: ipv6 };
+}
+function parseIpv4(text) {
+  const parts = text.split(".");
+  if (parts.length !== 4)
+    return;
+  const octets = [];
+  for (const part of parts) {
+    if (!/^(?:0|[1-9]\d{0,2})$/.test(part))
+      return;
+    const value = Number(part);
+    if (value > 255)
+      return;
+    octets.push(value);
+  }
+  return octets;
+}
+function parseIpv6(text) {
+  const halves = text.split("::");
+  if (halves.length > 2)
+    return;
+  const parsePart = (part, allowIpv4) => {
+    if (part === "")
+      return [];
+    const tokens = part.split(":");
+    const groups = [];
+    for (let index = 0;index < tokens.length; index++) {
+      const token = tokens[index];
+      if (allowIpv4 && index === tokens.length - 1 && token.includes(".")) {
+        const v4 = parseIpv4(token);
+        if (v4 === undefined)
+          return;
+        groups.push(v4[0] << 8 | v4[1], v4[2] << 8 | v4[3]);
+        continue;
+      }
+      if (!/^[0-9a-fA-F]{1,4}$/.test(token))
+        return;
+      groups.push(Number.parseInt(token, 16));
+    }
+    return groups;
+  };
+  if (halves.length === 1) {
+    const groups = parsePart(text, true);
+    return groups?.length === 8 ? groups : undefined;
+  }
+  const left = parsePart(halves[0], false);
+  const right = parsePart(halves[1], true);
+  if (left === undefined || right === undefined)
+    return;
+  const zeros = 8 - left.length - right.length;
+  if (zeros < 1)
+    return;
+  return [...left, ...new Array(zeros).fill(0), ...right];
+}
+function mappedIpv4(segments) {
+  if (!segments.slice(0, 5).every((group) => group === 0) || segments[5] !== 65535)
+    return;
+  return [segments[6] >> 8, segments[6] & 255, segments[7] >> 8, segments[7] & 255];
+}
+function ipv4Scope(octets) {
+  const [a, b] = octets;
+  if (a === 127)
+    return "loopback";
+  if (a === 100 && b >= 64 && b <= 127)
+    return "tailnet";
+  if (a === 10 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 169 && b === 254) {
+    return "lan";
+  }
+  return "public";
+}
+function ipv6Scope(segments) {
+  if (segments[0] === 64890 && segments[1] === 4444 && segments[2] === 41440)
+    return "tailnet";
+  if ((segments[0] & 65024) === 64512 || (segments[0] & 65472) === 65152)
+    return "lan";
+  if (segments.slice(0, 7).every((group) => group === 0) && segments[7] === 1)
+    return "loopback";
+  return "public";
+}
+var RTC_DEFAULT_STUN = ["stun:stun.cloudflare.com:3478"];
+var RTC_DATA_CHANNEL_LABEL = "pinomad";
+var RTC_MAX_RECORD_BYTES = 65535;
+var RTC_DEFAULT_MAX_MESSAGE_SIZE = 65536;
+var RTC_MIN_MAX_MESSAGE_SIZE = RTC_MAX_RECORD_BYTES;
+function isRtcHello(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const hello = value;
+  return Array.isArray(hello.stun) && hello.stun.every((server) => typeof server === "string" && server.length > 0) && hello.signalOnly === true;
+}
+function rtcCandidateType(candidate) {
+  const parts = candidate.trim().split(/\s+/);
+  const at = parts.indexOf("typ");
+  return at === -1 ? undefined : parts[at + 1];
+}
+function sdpCandidates(sdp) {
+  return sdp.split(/\r?\n/).filter((line) => line.startsWith("a=candidate:")).map((line) => line.slice("a=".length));
+}
+function withRtcCandidates(sdp, candidates) {
+  const lines = sdp.split(/\r?\n/).filter((line) => line !== "" && !line.startsWith("a=candidate:") && line !== "a=end-of-candidates");
+  const unique = [...new Set(candidates.map((candidate) => candidate.replace(/^a=/, "")))];
+  return [...lines, ...unique.map((candidate) => `a=${candidate}`), "a=end-of-candidates", ""].join(`\r
+`);
+}
+function parseRtcMaxMessageSize(sdp) {
+  const line = sdp.split(/\r?\n/).find((entry) => entry.startsWith("a=max-message-size:"));
+  if (line === undefined)
+    return { kind: "bounded", bytes: RTC_DEFAULT_MAX_MESSAGE_SIZE };
+  const raw = line.slice("a=max-message-size:".length).trim();
+  if (!/^\d+$/.test(raw))
+    return { kind: "invalid", reason: `malformed a=max-message-size: ${raw}` };
+  const bytes = Number(raw);
+  if (!Number.isSafeInteger(bytes))
+    return { kind: "invalid", reason: `a=max-message-size is not a safe integer: ${raw}` };
+  if (bytes === 0)
+    return { kind: "unlimited" };
+  if (bytes < RTC_MIN_MAX_MESSAGE_SIZE) {
+    return { kind: "invalid", reason: `a=max-message-size ${bytes} cannot carry a ${RTC_MIN_MAX_MESSAGE_SIZE}-byte record` };
+  }
+  return { kind: "bounded", bytes };
+}
+
+// packages/protocol/src/attachments.ts
+var MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+var MAX_ATTACHMENTS_PER_MESSAGE = 10;
+var ATTACHMENT_CHUNK_BYTES = 512 * 1024;
+var MAX_PENDING_ATTACHMENTS = 20;
+var MAX_PENDING_ATTACHMENT_BYTES = 200 * 1024 * 1024;
+var ATTACHMENT_TTL_MS = 24 * 60 * 60 * 1000;
+var MAX_ATTACHMENT_NAME_LENGTH = 255;
+var ATTACHMENT_ID_PATTERN = /^[A-Za-z0-9_-]{22}$/;
+function isAttachmentId(value) {
+  return ATTACHMENT_ID_PATTERN.test(value);
+}
+var ATTACHMENTS_OPEN = '<attachments v="1">';
+var ATTACHMENTS_INSTRUCTION = "The user attached these files. They are read-only originals on this machine: read them with your tools when relevant, and copy one into the working directory before changing it.";
+var ATTACHMENTS_CLOSE = "</attachments>";
+var BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
+function base64DecodedLength(data) {
+  if (data.length % 4 !== 0 || !BASE64.test(data))
+    return;
+  const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
+  return data.length * 3 / 4 - padding;
+}
+function attachmentBeginProblem(name, size) {
+  if (name.trim() === "")
+    return "Attachment name cannot be empty";
+  if (!Number.isSafeInteger(size) || size < 0)
+    return "Attachment size must be a non-negative integer";
+  if (size > MAX_ATTACHMENT_BYTES)
+    return `Attachment is larger than ${MAX_ATTACHMENT_BYTES / (1024 * 1024)} MB`;
+  return;
+}
+function attachmentChunkProblem(data) {
+  const size = base64DecodedLength(data);
+  if (size === undefined)
+    return "Attachment chunk is not valid base64";
+  if (size > ATTACHMENT_CHUNK_BYTES)
+    return `Attachment chunk is larger than ${ATTACHMENT_CHUNK_BYTES / 1024} KiB`;
+  return;
+}
+function xmlAttribute(value) {
+  let out = "";
+  for (let i = 0;i < value.length; i++) {
+    const unit = value.charCodeAt(i);
+    if (unit === 38)
+      out += "&amp;";
+    else if (unit === 60)
+      out += "&lt;";
+    else if (unit === 62)
+      out += "&gt;";
+    else if (unit === 34)
+      out += "&quot;";
+    else if (unit < 32 || unit === 127)
+      out += `&#x${unit.toString(16)};`;
+    else
+      out += value[i];
+  }
+  return out;
+}
+function attachmentBlock(files) {
+  const lines = [
+    ATTACHMENTS_OPEN,
+    ATTACHMENTS_INSTRUCTION,
+    ...files.map((file) => `<file id="${xmlAttribute(file.id)}" name="${xmlAttribute(file.name)}" path="${xmlAttribute(file.path)}" size="${file.size}"/>`),
+    ATTACHMENTS_CLOSE
+  ];
+  return lines.join(`
+`);
+}
+var FILE_OPEN = '<file id="';
+var FILE_NAME = '" name="';
+var FILE_PATH = '" path="';
+var FILE_SIZE = '" size="';
+var FILE_END = '"/>';
+var SIZE = /^(?:0|[1-9][0-9]*)$/;
+function decodeXmlAttribute(value) {
+  return value.replace(/&(amp|lt|gt|quot|apos|#x[0-9A-Fa-f]+|#[0-9]+);/g, (entity, body) => {
+    if (body === "amp")
+      return "&";
+    if (body === "lt")
+      return "<";
+    if (body === "gt")
+      return ">";
+    if (body === "quot")
+      return '"';
+    if (body === "apos")
+      return "'";
+    const code = body.startsWith("#x") ? parseInt(body.slice(2), 16) : parseInt(body.slice(1), 10);
+    return code >= 0 && code <= 1114111 ? String.fromCodePoint(code) : entity;
+  });
+}
+function quoted(text, at, marker) {
+  if (!text.startsWith(marker, at))
+    return;
+  const start = at + marker.length;
+  const end = text.indexOf('"', start);
+  if (end === -1)
+    return;
+  return { value: text.slice(start, end), next: end };
+}
+function parseFileLine(line) {
+  const id = quoted(line, 0, FILE_OPEN);
+  if (id === undefined)
+    return;
+  const name = quoted(line, id.next, FILE_NAME);
+  if (name === undefined)
+    return;
+  const path = quoted(line, name.next, FILE_PATH);
+  if (path === undefined)
+    return;
+  const size = quoted(line, path.next, FILE_SIZE);
+  if (size === undefined || !line.startsWith(FILE_END, size.next) || size.next + FILE_END.length !== line.length) {
+    return;
+  }
+  if (!isAttachmentId(id.value) || !SIZE.test(size.value))
+    return;
+  const bytes = Number(size.value);
+  if (!Number.isSafeInteger(bytes))
+    return;
+  return { id: id.value, name: decodeXmlAttribute(name.value), size: bytes };
+}
+function parseAttachmentBlock(text) {
+  if (!text.startsWith(ATTACHMENTS_OPEN + `
+`) || !text.endsWith(`
+` + ATTACHMENTS_CLOSE))
+    return;
+  const lines = text.slice(ATTACHMENTS_OPEN.length + 1, -(ATTACHMENTS_CLOSE.length + 1)).split(`
+`);
+  if (lines[0] !== ATTACHMENTS_INSTRUCTION || lines.length < 2)
+    return;
+  const files = [];
+  for (const line of lines.slice(1)) {
+    const file = parseFileLine(line);
+    if (file === undefined)
+      return;
+    files.push(file);
+  }
+  return files;
+}
+
+// packages/protocol/src/organization.ts
+function organize(index, summaries) {
+  const summaryById = new Map(summaries.map((summary) => [summary.id, summary]));
+  const nodes = new Map;
+  const topLevel = new Map;
+  for (const entry of index.conversations) {
+    const home = entry.home;
+    if (home.kind === "project" && !index.projects.some((project) => project.path === home.path))
+      continue;
+    const summary = summaryById.get(entry.id);
+    if (summary === undefined)
+      continue;
+    topLevel.set(entry.id, entry);
+    nodes.set(entry.id, { summary, children: [] });
+  }
+  for (const summary of summaries) {
+    const chain = [summary];
+    let current = summary;
+    while (!topLevel.has(current.id)) {
+      const parent = current.parent === undefined ? undefined : summaryById.get(current.parent);
+      if (parent === undefined || chain.includes(parent))
+        break;
+      chain.push(parent);
+      current = parent;
+    }
+    if (!topLevel.has(current.id))
+      continue;
+    for (let i = chain.length - 1;i >= 0; i--) {
+      const member = chain[i];
+      if (!nodes.has(member.id))
+        nodes.set(member.id, { summary: member, children: [] });
+      if (i < chain.length - 1) {
+        const parent = nodes.get(chain[i + 1].id);
+        const child = nodes.get(member.id);
+        if (!parent.children.includes(child))
+          parent.children.push(child);
+      }
+    }
+  }
+  const byIdAscending = (a, b) => a.summary.id - b.summary.id;
+  const nodeList = (entry) => sortChildren(nodes.get(entry.id));
+  const sortChildren = (node) => ({
+    summary: node.summary,
+    children: [...node.children].sort(byIdAscending).map(sortChildren)
+  });
+  const sorted = [...topLevel.values()].sort((a, b) => b.createdAt - a.createdAt);
+  const entries = sorted.filter((entry) => entry.archived !== true);
+  return {
+    chats: entries.filter((entry) => entry.home.kind === "chat").map(nodeList),
+    projects: [...index.projects].sort((a, b) => b.addedAt - a.addedAt).map((project) => ({
+      project,
+      conversations: entries.filter((entry) => entry.home.kind === "project" && entry.home.path === project.path).map(nodeList)
+    })),
+    archived: sorted.filter((entry) => entry.archived === true).map((entry) => {
+      const home = entry.home;
+      const project = home.kind === "project" ? index.projects.find((each) => each.path === home.path) : undefined;
+      return { node: nodeList(entry), ...project === undefined ? {} : { project } };
+    })
+  };
+}
+function checkoutOf(index, summaries, id) {
+  const record2 = index.checkouts?.find((checkout) => checkout.conversationId === id);
+  if (record2 !== undefined)
+    return record2;
+  const summaryById = new Map(summaries.map((summary) => [summary.id, summary]));
+  const seen = new Set;
+  let current = summaryById.get(id);
+  while (current !== undefined && !seen.has(current.id)) {
+    seen.add(current.id);
+    const ancestor = index.checkouts?.find((checkout) => checkout.conversationId === current.id);
+    if (ancestor !== undefined)
+      return ancestor;
+    current = current.parent === undefined ? undefined : summaryById.get(current.parent);
+  }
+  return;
+}
+function homeOf(index, summaries, id) {
+  const entry = index.conversations.find((candidate) => candidate.id === id);
+  if (entry !== undefined)
+    return entry.home;
+  const summaryById = new Map(summaries.map((summary) => [summary.id, summary]));
+  const seen = new Set;
+  let current = summaryById.get(id);
+  while (current !== undefined && !seen.has(current.id)) {
+    seen.add(current.id);
+    const ancestor = index.conversations.find((candidate) => candidate.id === current.id);
+    if (ancestor !== undefined)
+      return ancestor.home;
+    current = current.parent === undefined ? undefined : summaryById.get(current.parent);
+  }
+  return;
+}
+
+export { isCustomProviderApi, HOST_STREAM_NAMES, hostStreams, conversationStream, docStream, UNAUTHORIZED_CLOSE_CODE, INVALID_FRAME_CLOSE_CODE, PROTOCOL, hostSupportsCall, hostSupportsFeature, parseClientFrame, rtcSelectedPair, RTC_DEFAULT_STUN, RTC_DATA_CHANNEL_LABEL, RTC_MAX_RECORD_BYTES, isRtcHello, rtcCandidateType, sdpCandidates, withRtcCandidates, parseRtcMaxMessageSize, MAX_ATTACHMENTS_PER_MESSAGE, MAX_PENDING_ATTACHMENTS, MAX_PENDING_ATTACHMENT_BYTES, ATTACHMENT_TTL_MS, MAX_ATTACHMENT_NAME_LENGTH, isAttachmentId, base64DecodedLength, attachmentBeginProblem, attachmentChunkProblem, attachmentBlock, parseAttachmentBlock, organize, checkoutOf, homeOf };