spectrum-ts 1.18.0 → 3.0.0

package/dist/{chunk-YN6WOTBF.js → chunk-AYCMTRVC.js}

@@ -1,29 +1,36 @@
 import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
+import {
+  asRichlink
+} from "./chunk-CHY5YLLV.js";
 import {
   asGroup,
-  asRichlink,
   groupSchema
-} from "./chunk-JQN6CRSC.js";
+} from "./chunk-MHGCPC2V.js";
 import {
   asPoll,
   asPollOption
 } from "./chunk-2D27WW5B.js";
 import {
-  cloud,
+  cloud
+} from "./chunk-3GEJYGZK.js";
+import {
+  asContact
+} from "./chunk-NZ5WCMTY.js";
+import {
   mergeStreams,
   stream
-} from "./chunk-MC6ZKFSG.js";
+} from "./chunk-5XEFJBN2.js";
 import {
-  asContact,
   fromVCard,
   toVCard
-} from "./chunk-QGJFZMD5.js";
+} from "./chunk-6UZFVXQF.js";
 import {
   UnsupportedError,
   buildPhotoAction,
   definePlatform,
+  markdownSchema,
   photoActionSchema
-} from "./chunk-IPOFBAIM.js";
+} from "./chunk-LX437ZTY.js";
 import {
   asAttachment,
   asCustom,
@@ -32,7 +39,7 @@ import {
   reactionSchema,
   text,
   textSchema
-} from "./chunk-2ILTJC35.js";
+} from "./chunk-LQMDV75O.js";
 
 // src/providers/imessage/index.ts
 import { createClient as createClient2, MessageEffect as MessageEffect2 } from "@photon-ai/advanced-imessage";
@@ -127,6 +134,7 @@ import {
 import z3 from "zod";
 var effectInnerSchema = z3.discriminatedUnion("type", [
   textSchema,
+  markdownSchema,
   attachmentSchema
 ]);
 var messageEffectSchema = z3.object({
@@ -147,9 +155,9 @@ function effect(input, messageEffect) {
         );
       }
       const inner = await resolveContent(input);
-      if (inner.type !== "text" && inner.type !== "attachment") {
+      if (inner.type !== "text" && inner.type !== "markdown" && inner.type !== "attachment") {
         throw new Error(
-          `imessage effect() only supports text and attachment content, got "${inner.type}"`
+          `imessage effect() only supports text, markdown, and attachment content, got "${inner.type}"`
         );
       }
       return messageEffectSchema.parse({
@@ -565,6 +573,7 @@ var getMessage2 = async (client, id) => getMessage(client, id);
 // src/providers/imessage/remote/ids.ts
 var PART_PREFIX = /^p:(\d+)\//;
 var dmChatGuid = (address) => `any;-;${address}`;
+var chatTypeFromGuid = (guid) => guid.includes(";+;") ? "group" : "dm";
 var toChatGuid = (value) => value;
 var toMessageGuid = (value) => value;
 var formatChildId = (partIndex, parentGuid) => `p:${partIndex}/${parentGuid}`;
@@ -799,7 +808,7 @@ var buildMessageBase = (message, chatGuidHint, timestamp, phone) => {
     sender: { id: resolveSenderId(message) },
     space: {
       id: chat,
-      type: chat.includes(";+;") ? "group" : "dm",
+      type: chatTypeFromGuid(chat),
       phone
     },
     timestamp
@@ -1084,7 +1093,7 @@ var toReactionMessages = async (client, cache, event, phone) => {
       sender: { id: senderAddress },
       space: {
         id: event.chatGuid,
-        type: event.chatGuid.includes(";+;") ? "group" : "dm",
+        type: chatTypeFromGuid(event.chatGuid),
         phone
       },
       timestamp: event.occurredAt,
@@ -1093,23 +1102,39 @@ var toReactionMessages = async (client, cache, event, phone) => {
     }
   ];
 };
+var toSettableReaction = (emoji) => {
+  const native = EMOJI_TO_TAPBACK[emoji];
+  return native ? { kind: native } : { kind: "emoji", emoji };
+};
+var tapbackTarget = (target) => ({
+  guid: toMessageGuid(target.parentId ?? target.id),
+  opts: typeof target.partIndex === "number" ? { partIndex: target.partIndex } : void 0
+});
 var reactToMessage = async (remote, spaceId, target, reaction) => {
-  const chat = toChatGuid(spaceId);
-  const parentGuid = target.parentId ?? target.id;
-  const guid = toMessageGuid(parentGuid);
-  const opts = typeof target.partIndex === "number" ? { partIndex: target.partIndex } : void 0;
-  const native = EMOJI_TO_TAPBACK[reaction];
-  if (native) {
-    await remote.messages.setReaction(chat, guid, { kind: native }, true, opts);
-  } else {
-    await remote.messages.setReaction(
-      chat,
-      guid,
-      { kind: "emoji", emoji: reaction },
-      true,
-      opts
-    );
-  }
+  const { guid, opts } = tapbackTarget(target);
+  const sent = await remote.messages.setReaction(
+    toChatGuid(spaceId),
+    guid,
+    toSettableReaction(reaction),
+    true,
+    opts
+  );
+  return {
+    id: sent.guid,
+    content: asProviderReaction(reaction, target),
+    space: { id: spaceId },
+    timestamp: sent.dateCreated
+  };
+};
+var unsendReaction = async (remote, spaceId, target, reaction) => {
+  const { guid, opts } = tapbackTarget(target);
+  await remote.messages.setReaction(
+    toChatGuid(spaceId),
+    guid,
+    toSettableReaction(reaction),
+    false,
+    opts
+  );
 };
 
 // src/providers/imessage/remote/read.ts
@@ -1245,13 +1270,314 @@ var ensureM4a = async (buffer, mimeType) => {
   return transcodeToM4a(buffer);
 };
 
+// src/providers/imessage/remote/markdown.ts
+import { Marked } from "marked";
+var markdownLexer = new Marked();
+var BULLET = "\u2022 ";
+var HR_LINE = "\u2014\u2014\u2014";
+var NESTED_LIST_INDENT = "  ";
+var BLOCK_SEPARATOR = "\n\n";
+var TABLE_CELL_SEPARATOR = " | ";
+var DEFAULT_LIST_START = 1;
+var LEADING_WHITESPACE = /^\s+/;
+var TRAILING_WHITESPACE = /\s+$/;
+var MONOSPACE_UPPER_A = 120432;
+var MONOSPACE_LOWER_A = 120458;
+var MONOSPACE_DIGIT_ZERO = 120822;
+var UPPER_A = 65;
+var UPPER_Z = 90;
+var LOWER_A = 97;
+var LOWER_Z = 122;
+var DIGIT_ZERO = 48;
+var DIGIT_NINE = 57;
+var monospaceCodePoint = (codePoint) => {
+  if (codePoint >= UPPER_A && codePoint <= UPPER_Z) {
+    return MONOSPACE_UPPER_A + (codePoint - UPPER_A);
+  }
+  if (codePoint >= LOWER_A && codePoint <= LOWER_Z) {
+    return MONOSPACE_LOWER_A + (codePoint - LOWER_A);
+  }
+  if (codePoint >= DIGIT_ZERO && codePoint <= DIGIT_NINE) {
+    return MONOSPACE_DIGIT_ZERO + (codePoint - DIGIT_ZERO);
+  }
+  return codePoint;
+};
+var toMonospace = (text2) => {
+  let out = "";
+  for (const char of text2) {
+    const codePoint = char.codePointAt(0);
+    out += codePoint === void 0 ? char : String.fromCodePoint(monospaceCodePoint(codePoint));
+  }
+  return out;
+};
+var STYLE_ORDER = ["bold", "italic", "strikethrough"];
+var plain = (text2) => ({ text: text2, styles: [] });
+var withStyle = (spans, style) => spans.map(
+  (span) => span.styles.includes(style) ? span : { ...span, styles: [...span.styles, style] }
+);
+var asLink = (spans) => spans.map((span) => ({ ...span, link: true }));
+var spanText = (spans) => {
+  let out = "";
+  for (const span of spans) {
+    out += span.text;
+  }
+  return out;
+};
+var joinSpans = (blocks, separator) => {
+  const out = [];
+  for (const [index, block] of blocks.entries()) {
+    if (index > 0) {
+      out.push(plain(separator));
+    }
+    out.push(...block);
+  }
+  return out;
+};
+var splitSpanLines = (spans) => {
+  let current = [];
+  const lines = [current];
+  for (const span of spans) {
+    const parts = span.text.split("\n");
+    for (const [index, part] of parts.entries()) {
+      if (index > 0) {
+        current = [];
+        lines.push(current);
+      }
+      if (part) {
+        current.push({ ...span, text: part });
+      }
+    }
+  }
+  return lines;
+};
+var asMarkedToken = (token) => token;
+var checkboxPrefix = (item) => {
+  if (!item.task) {
+    return "";
+  }
+  return item.checked ? "[x] " : "[ ] ";
+};
+var listMarker = (list, index) => {
+  if (!list.ordered) {
+    return BULLET;
+  }
+  const start = list.start === "" ? DEFAULT_LIST_START : list.start;
+  return `${start + index}. `;
+};
+var renderLink = (token) => {
+  if (token.text === token.href) {
+    return [{ text: token.href, styles: [], link: true }];
+  }
+  return [
+    ...asLink(renderInlineTokens(token.tokens)),
+    { text: ` (${token.href})`, styles: [], link: true }
+  ];
+};
+var renderImage = (token) => [
+  {
+    text: token.text ? `${token.text} (${token.href})` : token.href,
+    styles: [],
+    link: true
+  }
+];
+var renderInlineToken = (token) => {
+  switch (token.type) {
+    case "strong":
+      return withStyle(renderInlineTokens(token.tokens), "bold");
+    case "em":
+      return withStyle(renderInlineTokens(token.tokens), "italic");
+    case "del":
+      return withStyle(renderInlineTokens(token.tokens), "strikethrough");
+    case "codespan":
+      return [plain(toMonospace(token.text))];
+    case "br":
+      return [plain("\n")];
+    case "link":
+      return renderLink(token);
+    case "image":
+      return renderImage(token);
+    case "escape":
+      return [plain(token.text)];
+    case "text":
+      return token.tokens ? renderInlineTokens(token.tokens) : [plain(token.text)];
+    // Raw HTML in markdown source stays literal — styled text has no markup.
+    case "html":
+      return [plain(token.text)];
+    // Task-item checkboxes are rendered from `ListItem.task`/`checked`.
+    case "checkbox":
+      return [];
+    default:
+      return "raw" in token ? [plain(String(token.raw))] : [];
+  }
+};
+var renderInlineTokens = (tokens) => {
+  const out = [];
+  for (const token of tokens) {
+    out.push(...renderInlineToken(asMarkedToken(token)));
+  }
+  return out;
+};
+var renderBlockquote = (quote) => {
+  const lines = splitSpanLines(renderBlockTokens(quote.tokens));
+  const out = [];
+  for (const [index, line] of lines.entries()) {
+    if (index > 0) {
+      out.push(plain("\n"));
+    }
+    out.push(plain(line.length > 0 ? "> " : ">"), ...line);
+  }
+  return out;
+};
+var renderList = (list) => {
+  const out = [];
+  for (const [index, item] of list.items.entries()) {
+    const prefix = `${listMarker(list, index)}${checkboxPrefix(item)}`;
+    const blocks = [];
+    for (const token of item.tokens) {
+      const rendered = renderBlockToken(asMarkedToken(token));
+      if (spanText(rendered)) {
+        blocks.push(rendered);
+      }
+    }
+    const [first = [], ...rest] = splitSpanLines(joinSpans(blocks, "\n"));
+    if (out.length > 0) {
+      out.push(plain("\n"));
+    }
+    out.push(plain(prefix), ...first);
+    for (const line of rest) {
+      out.push(plain(`
+${NESTED_LIST_INDENT}`), ...line);
+    }
+  }
+  return out;
+};
+var renderTable = (table) => {
+  const out = [];
+  const pushRow = (cells, rowIndex) => {
+    if (rowIndex > 0) {
+      out.push(plain("\n"));
+    }
+    for (const [cellIndex, cell] of cells.entries()) {
+      if (cellIndex > 0) {
+        out.push(plain(TABLE_CELL_SEPARATOR));
+      }
+      out.push(...renderInlineTokens(cell.tokens));
+    }
+  };
+  pushRow(table.header, 0);
+  for (const [index, row] of table.rows.entries()) {
+    pushRow(row, index + 1);
+  }
+  return out;
+};
+var renderBlockToken = (token) => {
+  switch (token.type) {
+    // iMessage formatting has no heading sizes; bold is the conventional
+    // stand-in (Telegram precedent).
+    case "heading":
+      return withStyle(renderInlineTokens(token.tokens), "bold");
+    case "paragraph":
+      return renderInlineTokens(token.tokens);
+    case "code":
+      return [plain(toMonospace(token.text))];
+    case "blockquote":
+      return renderBlockquote(token);
+    case "list":
+      return renderList(token);
+    case "table":
+      return renderTable(token);
+    case "hr":
+      return [plain(HR_LINE)];
+    case "space":
+    case "def":
+      return [];
+    default:
+      return renderInlineToken(token);
+  }
+};
+var renderBlockTokens = (tokens) => {
+  const blocks = [];
+  for (const token of tokens) {
+    const rendered = renderBlockToken(asMarkedToken(token));
+    if (spanText(rendered)) {
+      blocks.push(rendered);
+    }
+  }
+  return joinSpans(blocks, BLOCK_SEPARATOR);
+};
+var trimSpans = (spans) => {
+  const trimmed = [...spans];
+  while (trimmed.length > 0) {
+    const first = trimmed.at(0);
+    const text2 = first?.text.replace(LEADING_WHITESPACE, "");
+    if (first && text2) {
+      trimmed[0] = { ...first, text: text2 };
+      break;
+    }
+    trimmed.shift();
+  }
+  while (trimmed.length > 0) {
+    const last = trimmed.at(-1);
+    const text2 = last?.text.replace(TRAILING_WHITESPACE, "");
+    if (last && text2) {
+      trimmed[trimmed.length - 1] = { ...last, text: text2 };
+      break;
+    }
+    trimmed.pop();
+  }
+  return trimmed;
+};
+var finalize = (spans) => {
+  let text2 = "";
+  let hasLinks = false;
+  const open = /* @__PURE__ */ new Map();
+  const ranges = [];
+  const close = (style, end) => {
+    const start = open.get(style);
+    open.delete(style);
+    if (start !== void 0 && end > start) {
+      ranges.push({ type: style, start, length: end - start });
+    }
+  };
+  for (const span of spans) {
+    if (!span.text) {
+      continue;
+    }
+    hasLinks ||= span.link === true;
+    const offset = text2.length;
+    for (const style of STYLE_ORDER) {
+      if (span.styles.includes(style)) {
+        if (!open.has(style)) {
+          open.set(style, offset);
+        }
+      } else {
+        close(style, offset);
+      }
+    }
+    text2 += span.text;
+  }
+  for (const style of STYLE_ORDER) {
+    close(style, text2.length);
+  }
+  ranges.sort(
+    (a, b) => a.start - b.start || STYLE_ORDER.indexOf(a.type) - STYLE_ORDER.indexOf(b.type)
+  );
+  return { text: text2, formatting: ranges, hasLinks };
+};
+var markdownToIMessageText = (markdown) => finalize(trimSpans(renderBlockTokens(markdownLexer.lexer(markdown))));
+
 // src/providers/imessage/remote/send.ts
 var GROUP_ITEM_ALLOWED = /* @__PURE__ */ new Set([
   "text",
+  "markdown",
   "attachment",
   "contact",
   "voice"
 ]);
+var GROUP_TEXT_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "markdown"
+]);
 var MAX_GROUP_TEXT_ITEMS = 1;
 var outboundRecord = (spaceId, id, content, timestamp, extras) => ({
   id,
@@ -1268,6 +1594,18 @@ var providerGroup = (items) => asGroup({ items });
 var withReply = (options, replyTo) => replyTo ? { ...options, replyTo } : options;
 var replyOptions = (replyTo) => replyTo ? { replyTo } : void 0;
 var effectOption = (effect2) => effect2 ? { effect: effect2 } : {};
+var formattingOption = (formatting) => formatting.length > 0 ? { formatting } : {};
+var dataDetectionOption = (hasLinks) => hasLinks ? { enableDataDetection: true } : {};
+var renderMarkdown = (markdown) => {
+  const rendered = markdownToIMessageText(markdown);
+  if (!rendered.text) {
+    throw unsupportedRemoteContent(
+      "markdown",
+      "renders to empty text \u2014 nothing to send"
+    );
+  }
+  return rendered;
+};
 var replyTargetFromId = (messageId) => {
   const childRef = parseChildId(messageId);
   if (childRef) {
@@ -1325,6 +1663,22 @@ var sendContent = async (remote, spaceId, chat, content, replyTo, effect2) => {
       );
       return outboundMessage(spaceId, message, content);
     }
+    case "markdown": {
+      const rendered = renderMarkdown(content.markdown);
+      const message = await remote.messages.sendText(
+        chat,
+        rendered.text,
+        withReply(
+          {
+            ...effectOption(effect2),
+            ...formattingOption(rendered.formatting),
+            ...dataDetectionOption(rendered.hasLinks)
+          },
+          replyTo
+        )
+      );
+      return outboundMessage(spaceId, message, content);
+    }
     case "richlink": {
       const message = await remote.messages.sendText(
         chat,
@@ -1389,7 +1743,7 @@ var validateGroupContent = (content) => {
         `"${itemType}" items are not supported inside a group`
       );
     }
-    if (itemType === "text" && ++textCount > MAX_GROUP_TEXT_ITEMS) {
+    if (GROUP_TEXT_TYPES.has(itemType) && ++textCount > MAX_GROUP_TEXT_ITEMS) {
       throw unsupportedRemoteContent(
         "group",
         `groups can contain at most ${MAX_GROUP_TEXT_ITEMS} text item`
@@ -1401,6 +1755,10 @@ var resolvePart = async (remote, content) => {
   switch (content.type) {
     case "text":
       return { text: content.text };
+    case "markdown": {
+      const rendered = renderMarkdown(content.markdown);
+      return { text: rendered.text, ...formattingOption(rendered.formatting) };
+    }
     case "attachment": {
       const { guid, name } = await uploadAttachment(remote, content);
       return { attachmentGuid: guid, attachmentName: name };
@@ -1463,20 +1821,29 @@ var editMessage = async (remote, spaceId, msgId, content) => {
     childRef ? { partIndex: childRef.partIndex } : void 0
   );
 };
+var unsendMessage = async (remote, spaceId, msgId) => {
+  const childRef = parseChildId(msgId);
+  await remote.messages.unsend(
+    toChatGuid(spaceId),
+    toMessageGuid(childRef?.parentGuid ?? msgId),
+    childRef ? { partIndex: childRef.partIndex } : void 0
+  );
+};
 
 // src/providers/imessage/remote/stream.ts
 import {
-  AuthenticationError,
-  IMessageError,
-  NotFoundError as NotFoundError3,
   ValidationError
 } from "@photon-ai/advanced-imessage";
+import { sanitizePhone } from "@photon-ai/otel";
 
 // src/utils/resumable-stream.ts
+import { createLogger } from "@photon-ai/otel";
 var CATCH_UP_PAGE_SIZE = 100;
 var MAX_BUFFERED_LIVE_EVENTS = 1e3;
 var RECONNECT_INITIAL_DELAY_MS = 500;
 var RECONNECT_MAX_DELAY_MS = 3e4;
+var PERSISTENT_FAILURE_ERROR_THRESHOLD = 5;
+var log = createLogger("spectrum.stream");
 var RetryableStreamError = class extends Error {
   constructor(message) {
     super(message);
@@ -1489,6 +1856,12 @@ var LiveBufferOverflowError = class extends RetryableStreamError {
     this.name = "LiveBufferOverflowError";
   }
 };
+var CursorRejectedError = class extends Error {
+  constructor(cause) {
+    super("Server rejected resume cursor", { cause });
+    this.name = "CursorRejectedError";
+  }
+};
 var closeIterable = async (iterable) => {
   if (!iterable) {
     return;
@@ -1496,7 +1869,15 @@ var closeIterable = async (iterable) => {
   await iterable.close?.();
 };
 var ignoreCleanupError = () => void 0;
-var jitterDelay = (delayMs) => Math.random() * delayMs;
+var jitterDelay = (delayMs) => delayMs * (0.5 + Math.random() * 0.5);
+var errorMessage = (error) => error instanceof Error ? error.message : String(error);
+async function* throwOnCursorRejection(source, isCursorRejected) {
+  try {
+    yield* source;
+  } catch (error) {
+    throw isCursorRejected(error) ? new CursorRejectedError(error) : error;
+  }
+}
 var numericCursor = (cursor) => {
   if (!cursor) {
     return;
@@ -1514,15 +1895,23 @@ var resumableOrderedStream = (options) => stream((emit, end) => {
   const bufferLimit = options.bufferLimit ?? MAX_BUFFERED_LIVE_EVENTS;
   const initialRetryDelayMs = options.initialRetryDelayMs ?? RECONNECT_INITIAL_DELAY_MS;
   const maxRetryDelayMs = options.maxRetryDelayMs ?? RECONNECT_MAX_DELAY_MS;
+  const jitter = options.jitter ?? jitterDelay;
+  const label = options.label;
   let activeLive;
   let closed = false;
+  let failedAttempts = 0;
   let lastCursor;
   let retryDelayMs = initialRetryDelayMs;
   let sleepTimer;
   let wakeSleep;
   const deliveredSinceCursor = /* @__PURE__ */ new Set();
-  const resetRetryDelay = () => {
+  const noteRecovery = () => {
     retryDelayMs = initialRetryDelayMs;
+    if (failedAttempts === 0) {
+      return;
+    }
+    log.info("stream recovered", { attempts: failedAttempts, label });
+    failedAttempts = 0;
   };
   const advanceCursor = (cursor, clearDelivered) => {
     if (!cursor || cursor === lastCursor || isCursorRegression(cursor, lastCursor)) {
@@ -1543,17 +1932,17 @@ var resumableOrderedStream = (options) => stream((emit, end) => {
     advanceCursor(item.cursor, clearOnCursorAdvance);
     deliveredSinceCursor.add(item.id);
     if (resetRetry) {
-      resetRetryDelay();
+      noteRecovery();
     }
   };
-  const retryable = (error) => error instanceof RetryableStreamError || options.isRetryableError(error);
+  const isCursorRejected = (error) => options.isCursorRejectedError?.(error) === true;
   const sleep2 = async (delayMs) => {
     if (delayMs <= 0 || closed) {
       return;
     }
     await new Promise((resolve) => {
       wakeSleep = resolve;
-      sleepTimer = setTimeout(resolve, jitterDelay(delayMs));
+      sleepTimer = setTimeout(resolve, jitter(delayMs));
     });
     sleepTimer = void 0;
     wakeSleep = void 0;
@@ -1571,6 +1960,37 @@ var resumableOrderedStream = (options) => stream((emit, end) => {
     retryDelayMs = Math.min(retryDelayMs * 2, maxRetryDelayMs);
     return delay;
   };
+  const handleFailure = (error) => {
+    failedAttempts += 1;
+    const delayMs = nextRetryDelay();
+    if (error instanceof CursorRejectedError) {
+      lastCursor = void 0;
+      deliveredSinceCursor.clear();
+      log.warn(
+        "resume cursor rejected; accepting event gap and resuming live",
+        {
+          attempt: failedAttempts,
+          delayMs,
+          error: errorMessage(error.cause),
+          label
+        }
+      );
+      return delayMs;
+    }
+    const attrs = {
+      attempt: failedAttempts,
+      delayMs,
+      error: errorMessage(error),
+      hasCursor: lastCursor !== void 0,
+      label
+    };
+    if (failedAttempts >= PERSISTENT_FAILURE_ERROR_THRESHOLD) {
+      log.error("stream persistently failing; still retrying", attrs, error);
+      return delayMs;
+    }
+    log.warn("stream interrupted; reconnecting", attrs);
+    return delayMs;
+  };
   const consumeLive = async () => {
     const live = options.subscribeLive(lastCursor);
     activeLive = live;
@@ -1619,15 +2039,17 @@ var resumableOrderedStream = (options) => stream((emit, end) => {
     };
   };
   const replayMissed = async (cursor, getLiveError) => {
-    for await (const event of options.fetchMissed(cursor, {
-      limit: catchUpPageSize
-    })) {
+    const missed = throwOnCursorRejection(
+      options.fetchMissed(cursor, { limit: catchUpPageSize }),
+      isCursorRejected
+    );
+    for await (const event of missed) {
       throwLiveError(getLiveError());
       await deliverItem(await options.processMissed(event), false, false);
     }
     throwLiveError(getLiveError());
   };
-  const flushLiveBuffer = async (liveBuffer, getLiveError) => {
+  const flushLiveBuffer = async (liveBuffer, getLiveError, stopBuffering) => {
     let index = 0;
     let lastFlushedId;
     while (index < liveBuffer.length) {
@@ -1643,7 +2065,8 @@ var resumableOrderedStream = (options) => stream((emit, end) => {
     }
     liveBuffer.length = 0;
     throwLiveError(getLiveError());
-    return lastFlushedId;
+    compactDeliveredIds(lastFlushedId);
+    stopBuffering();
   };
   const compactDeliveredIds = (lastId) => {
     if (!lastId) {
@@ -1660,13 +2083,10 @@ var resumableOrderedStream = (options) => stream((emit, end) => {
     const livePump = startLivePump(live, () => buffering, liveBuffer);
     try {
       await replayMissed(cursor, livePump.getError);
-      const lastFlushedId = await flushLiveBuffer(
-        liveBuffer,
-        livePump.getError
-      );
-      compactDeliveredIds(lastFlushedId);
-      buffering = false;
-      resetRetryDelay();
+      await flushLiveBuffer(liveBuffer, livePump.getError, () => {
+        buffering = false;
+      });
+      noteRecovery();
       await livePump.pump;
       throwLiveError(livePump.getError());
     } finally {
@@ -1687,21 +2107,18 @@ var resumableOrderedStream = (options) => stream((emit, end) => {
           await consumeLive();
         }
       } catch (error) {
-        await closeIterable(activeLive);
+        await closeIterable(activeLive).catch(ignoreCleanupError);
         activeLive = void 0;
         if (closed) {
           break;
         }
-        if (!retryable(error)) {
-          end(error);
-          return;
-        }
-        await sleep2(nextRetryDelay());
+        await sleep2(handleFailure(error));
       }
     }
     end();
   };
   const pump = run().catch((error) => {
+    log.error("resumable stream loop crashed", { label }, error);
     if (!closed) {
       end(error);
     }
@@ -1834,7 +2251,7 @@ var buildPollOptionMessage = (input) => {
     sender: { id: input.senderAddress },
     space: {
       id: input.chatGuid,
-      type: input.chatGuid.includes(";+;") ? "group" : "dm",
+      type: chatTypeFromGuid(input.chatGuid),
       phone: input.phone
     },
     timestamp: input.event.occurredAt,
@@ -1890,15 +2307,8 @@ var toPollDeltaMessages = async (client, pollCache, event, phone) => {
 };
 
 // src/providers/imessage/remote/stream.ts
-var isRetryableIMessageStreamError = (error) => {
-  if (error instanceof AuthenticationError || error instanceof NotFoundError3 || error instanceof ValidationError) {
-    return false;
-  }
-  if (error instanceof IMessageError) {
-    return true;
-  }
-  return false;
-};
+var isCursorRejectedIMessageError = (error) => error instanceof ValidationError;
+var streamLabel = (kind, phone) => `imessage.${kind}:${phone === SHARED_PHONE ? phone : sanitizePhone(phone)}`;
 var isEventFromCurrentAccount = (event, phone) => event.isFromMe || phone !== SHARED_PHONE && event.actor?.address !== void 0 && event.actor.address === phone;
 var toMessageItem = async (client, event, phone, cursor, onInbound) => {
   if (event.type === "message.received") {
@@ -2001,7 +2411,8 @@ var withClose = (source, cursor) => Object.assign(afterCursor(source, cursor), {
 });
 var messageStream = (client, phone, onInbound) => resumableOrderedStream({
   fetchMissed: (cursor) => catchUpEvents(client, cursor, isMessageEvent),
-  isRetryableError: isRetryableIMessageStreamError,
+  isCursorRejectedError: isCursorRejectedIMessageError,
+  label: streamLabel("messages", phone),
   processLive: (event) => toMessageItem(client, event, phone, String(event.sequence), onInbound),
   processMissed: (event) => event.type === "catchup.complete" ? Promise.resolve(toCatchUpCompleteItem(event)) : toMessageItem(
     client,
@@ -2014,7 +2425,8 @@ var messageStream = (client, phone, onInbound) => resumableOrderedStream({
 });
 var pollStream = (client, pollCache, phone) => resumableOrderedStream({
   fetchMissed: (cursor) => catchUpEvents(client, cursor, isPollEvent),
-  isRetryableError: isRetryableIMessageStreamError,
+  isCursorRejectedError: isCursorRejectedIMessageError,
+  label: streamLabel("polls", phone),
   processLive: (event) => toPollItem(client, pollCache, event, phone, String(event.sequence)),
   processMissed: (event) => event.type === "catchup.complete" ? Promise.resolve(toCatchUpCompleteItem(event)) : toPollItem(client, pollCache, event, phone, String(event.sequence)),
   subscribeLive: (cursor) => withClose(client.polls.subscribeEvents(), cursor)
@@ -2039,6 +2451,61 @@ var messages3 = (clients, projectConfig) => {
   );
 };
 
+// src/providers/imessage/remote/stream-text.ts
+var INITIAL_THROTTLE_MS = 1e3;
+var BACKOFF_FACTOR = 2;
+var MAX_EDITS = 5;
+var sendStreamText = async (remote, spaceId, content) => {
+  if (content.format === "markdown") {
+    throw unsupportedRemoteContent(
+      "streamText",
+      "markdown-formatted streams have no native iMessage delivery"
+    );
+  }
+  const chat = toChatGuid(spaceId);
+  let sent;
+  let full = "";
+  let lastSentText = "";
+  let lastEditAt = 0;
+  let editCount = 0;
+  const flushEdit = async (text2) => {
+    if (!sent || text2 === lastSentText) {
+      return;
+    }
+    await remote.messages.edit(chat, toMessageGuid(sent.guid), text2);
+    lastSentText = text2;
+    lastEditAt = Date.now();
+    editCount += 1;
+  };
+  for await (const delta of content.stream()) {
+    full += delta;
+    if (!sent) {
+      sent = await remote.messages.sendText(chat, full);
+      lastSentText = full;
+      lastEditAt = Date.now();
+      continue;
+    }
+    const hasBudgetForInterimEdit = editCount < MAX_EDITS - 1;
+    const requiredGap = INITIAL_THROTTLE_MS * BACKOFF_FACTOR ** editCount;
+    if (hasBudgetForInterimEdit && Date.now() - lastEditAt >= requiredGap) {
+      await flushEdit(full);
+    }
+  }
+  if (!sent) {
+    throw unsupportedRemoteContent(
+      "streamText",
+      "stream produced no text \u2014 nothing to send"
+    );
+  }
+  await flushEdit(full);
+  return {
+    id: sent.guid,
+    content: asText(full),
+    space: { id: spaceId },
+    timestamp: sent.dateCreated
+  };
+};
+
 // src/providers/imessage/remote/typing.ts
 var startTyping = async (remote, spaceId) => {
   await remote.chats.setTyping(toChatGuid(spaceId), true);
@@ -2063,11 +2530,12 @@ var stopTyping2 = async (remote, spaceId) => {
   await stopTyping(remote, spaceId);
 };
 var send4 = async (remote, spaceId, content) => send3(remote, spaceId, content);
+var sendStreamText2 = async (remote, spaceId, content) => sendStreamText(remote, spaceId, content);
 var replyToMessage2 = async (remote, spaceId, msgId, content) => replyToMessage(remote, spaceId, msgId, content);
 var editMessage2 = async (remote, spaceId, msgId, content) => editMessage(remote, spaceId, msgId, content);
-var reactToMessage2 = async (remote, spaceId, target, reaction) => {
-  await reactToMessage(remote, spaceId, target, reaction);
-};
+var reactToMessage2 = async (remote, spaceId, target, reaction) => reactToMessage(remote, spaceId, target, reaction);
+var unsendMessage2 = async (remote, spaceId, msgId) => unsendMessage(remote, spaceId, msgId);
+var unsendReaction2 = async (remote, spaceId, target, reaction) => unsendReaction(remote, spaceId, target, reaction);
 var getMessage4 = async (remote, spaceId, msgId, phone) => getMessage3(remote, spaceId, msgId, phone);
 
 // src/providers/imessage/remote/client.ts
@@ -2120,6 +2588,41 @@ var handleEdit = async (client, space, content) => {
   const remote = clientForPhone(client, space.phone);
   await editMessage2(remote, space.id, content.target.id, content.content);
 };
+var handleUnsend = async (client, space, content) => {
+  if (isLocal(client)) {
+    throw UnsupportedError.action("unsend", "iMessage (local mode)");
+  }
+  if (isPollContent(content.target.content)) {
+    throw UnsupportedError.action(
+      "unsend",
+      "iMessage",
+      "iMessage polls cannot be unsent"
+    );
+  }
+  const remote = clientForPhone(client, space.phone);
+  const targetContent = content.target.content;
+  if (targetContent.type === "reaction") {
+    await unsendReaction2(
+      remote,
+      space.id,
+      targetContent.target,
+      targetContent.emoji
+    );
+    return;
+  }
+  await unsendMessage2(remote, space.id, content.target.id);
+};
+var handleStreamText = async (client, space, content) => {
+  if (isLocal(client)) {
+    throw UnsupportedError.action(
+      "streamText",
+      "iMessage (local mode)",
+      "streaming text responses require remote iMessage"
+    );
+  }
+  const remote = clientForPhone(client, space.phone);
+  return await sendStreamText2(remote, space.id, content);
+};
 var handleBackground = async (client, space, content) => {
   if (isLocal(client)) {
     throw UnsupportedError.action(
@@ -2249,10 +2752,10 @@ var imessage = definePlatform("iMessage", {
   space: {
     schema: spaceSchema,
     params: spaceParamsSchema,
-    resolve: async ({ input, client }) => {
+    create: async ({ input, client }) => {
       if (isLocal(client)) {
         throw UnsupportedError.action(
-          "createSpace",
+          "space.create",
           "iMessage (local mode)",
           "local mode only supports replying to existing messages"
         );
@@ -2263,18 +2766,52 @@ var imessage = definePlatform("iMessage", {
       if (client.length === 0) {
         throw new Error("No iMessage clients configured");
       }
-      const phone = isSharedMode(client) ? SHARED_PHONE : input.params?.phone ?? randomPhone(client);
-      const remote = clientForPhone(client, phone);
       const addresses = input.users.map((u) => u.id);
-      if (input.users.length === 1) {
+      if (isSharedMode(client)) {
+        if (addresses.length > 1) {
+          throw UnsupportedError.action(
+            "space.create",
+            "iMessage (shared mode)",
+            "shared mode cannot create group chats \u2014 use a dedicated number, or space.get(chatGuid) for an existing group"
+          );
+        }
         return {
           id: dmChatGuid(addresses[0] ?? ""),
           type: "dm",
-          phone
+          phone: SHARED_PHONE
         };
       }
+      const phone = input.params?.phone ?? randomPhone(client);
+      const remote = clientForPhone(client, phone);
       const { chat } = await remote.chats.create(addresses);
-      return { id: chat.guid, type: "group", phone };
+      return {
+        id: chat.guid,
+        type: chat.isGroup ? "group" : "dm",
+        phone
+      };
+    },
+    get: async ({ input, client }) => {
+      if (isLocal(client)) {
+        throw UnsupportedError.action(
+          "space.get",
+          "iMessage (local mode)",
+          "local mode only supports replying to existing messages"
+        );
+      }
+      if (client.length === 0) {
+        throw new Error("No iMessage clients configured");
+      }
+      const phone = isSharedMode(client) ? SHARED_PHONE : input.params?.phone ?? (client.length === 1 ? client[0]?.phone : void 0);
+      if (!phone) {
+        throw new Error(
+          `iMessage space.get requires params.phone when multiple clients are configured. Available: ${availablePhones(client).join(", ")}`
+        );
+      }
+      return {
+        id: input.id,
+        type: chatTypeFromGuid(input.id),
+        phone
+      };
     },
     actions: {
       // Sugar: `space.background(input, opts?)` →
@@ -2334,13 +2871,12 @@ var imessage = definePlatform("iMessage", {
         );
       }
       const remote2 = clientForPhone(client, space.phone);
-      await reactToMessage2(
+      return await reactToMessage2(
         remote2,
         space.id,
         content.target,
         content.emoji
       );
-      return;
     }
     if (content.type === "typing") {
       await handleTyping(client, space, content.state);
@@ -2350,6 +2886,13 @@ var imessage = definePlatform("iMessage", {
       await handleEdit(client, space, content);
       return;
     }
+    if (content.type === "unsend") {
+      await handleUnsend(client, space, content);
+      return;
+    }
+    if (content.type === "streamText") {
+      return await handleStreamText(client, space, content);
+    }
     if (content.type === "rename") {
       await handleRename(client, space, content);
       return;