spectrum-ts 1.0.1 → 1.1.1

package/dist/providers/imessage/index.js

@@ -1,23 +1,25 @@
 import {
-  asGroup,
-  asRichlink
-} from "../../chunk-LAGNM6I7.js";
+  asRichlink,
+  groupSchema
+} from "../../chunk-TY3RT4OB.js";
 import {
+  asPoll,
+  asPollOption,
   cloud,
   mergeStreams,
   stream
-} from "../../chunk-2Y5GBI6W.js";
+} from "../../chunk-PXX7ISZ6.js";
 import {
   UnsupportedError,
   asAttachment,
   asContact,
   asCustom,
-  asReaction,
   asText,
   definePlatform,
   fromVCard,
+  reactionSchema,
   toVCard
-} from "../../chunk-XMAI2AAN.js";
+} from "../../chunk-7D6FHYKT.js";
 
 // src/providers/imessage/index.ts
 import { createClient as createClient2, directChat } from "@photon-ai/advanced-imessage";
@@ -109,17 +111,12 @@ async function disposeCloudAuth(clients) {
   }
 }
 
-// src/providers/imessage/local.ts
+// src/providers/imessage/local/attachments.ts
 import { createReadStream } from "fs";
-import { mkdtemp, readFile, rm, writeFile } from "fs/promises";
-import { tmpdir } from "os";
-import { basename, join } from "path";
+import { readFile } from "fs/promises";
 import { Readable } from "stream";
-var synthSendResult = () => ({
-  id: crypto.randomUUID(),
-  timestamp: /* @__PURE__ */ new Date()
-});
-var DEFAULT_ATTACHMENT_NAME = "attachment";
+
+// src/providers/imessage/shared/vcard.ts
 var VCARD_MIME_TYPES = /* @__PURE__ */ new Set([
   "text/vcard",
   "text/x-vcard",
@@ -134,6 +131,13 @@ var isVCardAttachment = (mimeType, fileName) => {
   }
   return Boolean(fileName?.toLowerCase().endsWith(".vcf"));
 };
+var vcardFileName = (contact) => {
+  const base = contact.name?.formatted ?? contact.user?.id ?? "contact";
+  return `${base.replace(/[^a-zA-Z0-9_\-.]/g, "_")}.vcf`;
+};
+
+// src/providers/imessage/local/attachments.ts
+var DEFAULT_ATTACHMENT_NAME = "attachment";
 var readLocalAttachment = async (att) => {
   if (!att.localPath) {
     throw new Error(
@@ -162,6 +166,9 @@ var toVCardContent = async (att) => {
     return toAttachmentContent(att);
   }
 };
+var localAttachmentContent = async (att) => isVCardAttachment(att.mimeType, att.fileName) ? await toVCardContent(att) : toAttachmentContent(att);
+
+// src/providers/imessage/local/inbound.ts
 var toMessages = async (message) => {
   const { chatId, chatKind } = message;
   if (!chatId || chatKind === "unknown") {
@@ -180,7 +187,7 @@ var toMessages = async (message) => {
       message.attachments.map(async (att) => ({
         ...base,
         id: `${message.id}:${att.id}`,
-        content: isVCardAttachment(att.mimeType, att.fileName) ? await toVCardContent(att) : toAttachmentContent(att)
+        content: await localAttachmentContent(att)
       }))
     );
   }
@@ -212,10 +219,23 @@ var messages = (client) => stream((emit, end) => {
     });
   };
 });
-var vcardFileName = (content) => {
-  const base = content.name?.formatted ?? content.user?.id ?? "contact";
-  return `${base.replace(/[^a-zA-Z0-9_\-.]/g, "_")}.vcf`;
-};
+
+// src/providers/imessage/local/send.ts
+import { mkdtemp, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { basename, join } from "path";
+
+// src/providers/imessage/shared/errors.ts
+var IMESSAGE_PLATFORM = "iMessage";
+var LOCAL_IMESSAGE_PLATFORM = "iMessage (local mode)";
+var unsupportedRemoteContent = (type, detail) => UnsupportedError.content(type, IMESSAGE_PLATFORM, detail);
+var unsupportedLocalContent = (type) => UnsupportedError.content(type, LOCAL_IMESSAGE_PLATFORM);
+
+// src/providers/imessage/local/send.ts
+var synthSendResult = () => ({
+  id: crypto.randomUUID(),
+  timestamp: /* @__PURE__ */ new Date()
+});
 var sendTempFile = async (client, spaceId, name, data) => {
   const safeName = basename(name) || DEFAULT_ATTACHMENT_NAME;
   const dir = await mkdtemp(join(tmpdir(), "spectrum-"));
@@ -246,246 +266,181 @@ var send = async (client, spaceId, content) => {
       );
       return synthSendResult();
     }
+    case "poll":
+      throw unsupportedLocalContent("poll");
     default:
-      throw UnsupportedError.content(content.type, "iMessage (local mode)");
+      throw unsupportedLocalContent(content.type);
   }
 };
 var getMessage = async (_client, _id) => void 0;
 
-// src/providers/imessage/remote.ts
+// src/providers/imessage/local/api.ts
+var messages2 = (client) => messages(client);
+var send2 = async (client, spaceId, content) => send(client, spaceId, content);
+var getMessage2 = async (client, id) => getMessage(client, id);
+
+// src/providers/imessage/remote/client.ts
+var REMOTE_CLIENT_MISSING = "No remote iMessage client available";
+var firstRemoteClient = (clients) => clients[0];
+var primaryRemoteClient = (clients) => {
+  const remote = firstRemoteClient(clients);
+  if (!remote) {
+    throw new Error(REMOTE_CLIENT_MISSING);
+  }
+  return remote;
+};
+
+// src/providers/imessage/remote/inbound.ts
 import {
-  chatGuid,
   messageGuid,
-  Reaction
+  NotFoundError
 } from "@photon-ai/advanced-imessage";
 
-// src/utils/audio.ts
-import { spawn } from "child_process";
-import { mkdtemp as mkdtemp2, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join2 } from "path";
-var M4A_BRANDS = /* @__PURE__ */ new Set([
-  "M4A ",
-  "M4B ",
-  "M4P ",
-  "mp42",
-  "mp41",
-  "isom",
-  "iso2"
-]);
-var M4A_MIME_TYPES = /* @__PURE__ */ new Set([
-  "audio/mp4",
-  "audio/mp4a-latm",
-  "audio/x-m4a",
-  "audio/aac",
-  "audio/aacp"
-]);
-var FFMPEG_MISSING_MESSAGE = "voice content: input is not m4a/aac and ffmpeg is unavailable. Install `ffmpeg-static` or ensure `ffmpeg` is on PATH.";
-var isM4a = (buffer) => {
-  if (buffer.length < 12) {
-    return false;
-  }
-  if (buffer.toString("ascii", 4, 8) !== "ftyp") {
-    return false;
-  }
-  return M4A_BRANDS.has(buffer.toString("ascii", 8, 12));
-};
-var isM4aMimeType = (mimeType) => M4A_MIME_TYPES.has(mimeType.toLowerCase());
-var cachedFfmpegPath;
-var tryStaticBinary = async () => {
-  try {
-    const mod = await import("ffmpeg-static");
-    return mod.default ?? void 0;
-  } catch {
-    return void 0;
-  }
-};
-var resolveFfmpegPath = async () => {
-  if (cachedFfmpegPath) {
-    return cachedFfmpegPath;
-  }
-  cachedFfmpegPath = await tryStaticBinary() ?? "ffmpeg";
-  return cachedFfmpegPath;
-};
-var collectStream = (stream2) => {
-  if (!stream2) {
-    return Promise.resolve("");
+// src/providers/imessage/cache.ts
+var DEFAULT_MAX = 1e3;
+var MessageCache = class {
+  map = /* @__PURE__ */ new Map();
+  max;
+  constructor(max = DEFAULT_MAX) {
+    this.max = max;
   }
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    stream2.on("data", (chunk) => {
-      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-    });
-    stream2.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
-    stream2.on("error", reject);
-  });
-};
-var isMissingBinaryError = (err) => err?.code === "ENOENT";
-var runFfmpeg = (ffmpegPath, args) => {
-  const proc = spawn(ffmpegPath, args, { stdio: ["ignore", "ignore", "pipe"] });
-  const stderr = collectStream(proc.stderr);
-  const exit = new Promise((resolve, reject) => {
-    proc.on(
-      "error",
-      (err) => reject(
-        isMissingBinaryError(err) ? new Error(FFMPEG_MISSING_MESSAGE) : err
-      )
-    );
-    proc.on("exit", (code) => resolve(code ?? -1));
-  });
-  return Promise.all([exit, stderr]).then(([code, text]) => ({
-    code,
-    stderr: text
-  }));
-};
-var DURATION_PATTERN = /Duration:\s*(\d+):(\d{2}):(\d{2})(?:\.(\d{1,3}))?/;
-var parseDuration = (stderr) => {
-  const match = stderr.match(DURATION_PATTERN);
-  if (!match) {
-    return void 0;
+  get(id) {
+    return this.map.get(id);
   }
-  const [, hh, mm, ss, frac] = match;
-  const seconds = Number(hh) * 3600 + Number(mm) * 60 + Number(ss) + Number(`0.${frac ?? 0}`);
-  return Number.isFinite(seconds) ? seconds : void 0;
-};
-var transcodeToM4a = async (buffer) => {
-  const ffmpeg = await resolveFfmpegPath();
-  const dir = await mkdtemp2(join2(tmpdir2(), "spectrum-voice-"));
-  const inPath = join2(dir, "in");
-  const outPath = join2(dir, "out.m4a");
-  try {
-    await writeFile2(inPath, buffer);
-    const { code, stderr } = await runFfmpeg(ffmpeg, [
-      "-y",
-      "-i",
-      inPath,
-      "-f",
-      "ipod",
-      "-c:a",
-      "aac",
-      outPath
-    ]);
-    if (code !== 0) {
-      throw new Error(`ffmpeg conversion failed (exit ${code}): ${stderr}`);
+  set(id, message) {
+    if (this.map.has(id)) {
+      this.map.delete(id);
+    }
+    this.map.set(id, message);
+    if (this.map.size > this.max) {
+      const first = this.map.keys().next().value;
+      if (first !== void 0) {
+        this.map.delete(first);
+      }
     }
-    const out = await readFile2(outPath);
-    return { buffer: out, duration: parseDuration(stderr) };
-  } finally {
-    await rm2(dir, { recursive: true, force: true }).catch(() => {
-    });
   }
-};
-var ensureM4a = async (buffer, mimeType) => {
-  if (isM4aMimeType(mimeType) || isM4a(buffer)) {
-    return { buffer };
+  clear() {
+    this.map.clear();
   }
-  return transcodeToM4a(buffer);
 };
-
-// src/providers/imessage/cache.ts
-var DEFAULT_MAX = 1e3;
-var MessageCache = class {
+var PollCache = class {
   map = /* @__PURE__ */ new Map();
   max;
+  selectionEventTimesByPoll = /* @__PURE__ */ new Map();
+  selectionsByPoll = /* @__PURE__ */ new Map();
   constructor(max = DEFAULT_MAX) {
     this.max = max;
   }
   get(id) {
     return this.map.get(id);
   }
-  set(id, message) {
+  set(id, poll) {
     if (this.map.has(id)) {
       this.map.delete(id);
     }
-    this.map.set(id, message);
+    this.map.set(id, poll);
     if (this.map.size > this.max) {
       const first = this.map.keys().next().value;
       if (first !== void 0) {
         this.map.delete(first);
+        this.selectionEventTimesByPoll.delete(first);
+        this.selectionsByPoll.delete(first);
       }
     }
   }
   clear() {
     this.map.clear();
+    this.selectionEventTimesByPoll.clear();
+    this.selectionsByPoll.clear();
+  }
+  actorSelectionDeltas(pollId, actorId, optionIds) {
+    const previous = this.selectionsByPoll.get(pollId)?.get(actorId);
+    if (!previous) {
+      return optionIds.map((optionId) => ({ optionId, selected: true }));
+    }
+    const current = new Set(optionIds);
+    const selected = optionIds.filter((optionId) => !previous.has(optionId)).map((optionId) => ({ optionId, selected: true }));
+    const deselected = [...previous].filter((optionId) => !current.has(optionId)).map((optionId) => ({ optionId, selected: false }));
+    return [...selected, ...deselected];
+  }
+  clearedActorSelectionDeltas(pollId, actorId) {
+    const previous = this.selectionsByPoll.get(pollId)?.get(actorId);
+    if (!previous) {
+      return [];
+    }
+    return [...previous].map((optionId) => ({ optionId, selected: false }));
+  }
+  actorSelection(pollId, actorId) {
+    const selection = this.selectionsByPoll.get(pollId)?.get(actorId);
+    return selection ? [...selection] : void 0;
+  }
+  commitActorSelection(pollId, actorId, optionIds, at) {
+    let selections = this.selectionsByPoll.get(pollId);
+    if (!selections) {
+      selections = /* @__PURE__ */ new Map();
+      this.selectionsByPoll.set(pollId, selections);
+    }
+    selections.set(actorId, new Set(optionIds));
+    if (!at) {
+      return;
+    }
+    let eventTimes = this.selectionEventTimesByPoll.get(pollId);
+    if (!eventTimes) {
+      eventTimes = /* @__PURE__ */ new Map();
+      this.selectionEventTimesByPoll.set(pollId, eventTimes);
+    }
+    const eventTime = at.getTime();
+    const previousTime = eventTimes.get(actorId);
+    if (previousTime === void 0 || eventTime >= previousTime) {
+      eventTimes.set(actorId, eventTime);
+    }
+  }
+  isStaleActorSelectionEvent(pollId, actorId, at) {
+    const previousTime = this.selectionEventTimesByPoll.get(pollId)?.get(actorId);
+    return previousTime !== void 0 && at.getTime() < previousTime;
   }
 };
-var caches = /* @__PURE__ */ new WeakMap();
+var messageCaches = /* @__PURE__ */ new WeakMap();
+var pollCaches = /* @__PURE__ */ new WeakMap();
 var getMessageCache = (owner) => {
-  let cache = caches.get(owner);
+  let cache = messageCaches.get(owner);
   if (!cache) {
     cache = new MessageCache();
-    caches.set(owner, cache);
+    messageCaches.set(owner, cache);
   }
   return cache;
 };
-
-// src/providers/imessage/remote.ts
-var PLATFORM = "iMessage";
-var URL_BALLOON_BUNDLE_ID = "com.apple.messages.URLBalloonProvider";
-var GROUP_ITEM_ALLOWED = /* @__PURE__ */ new Set([
-  "attachment",
-  "contact",
-  "voice"
-]);
-var unsupportedContent = (type, detail) => UnsupportedError.content(type, PLATFORM, detail);
-var toSendResult = (receipt) => ({
-  id: receipt.guid,
-  timestamp: /* @__PURE__ */ new Date()
-});
-var VCARD_MIME_TYPES2 = /* @__PURE__ */ new Set([
-  "text/vcard",
-  "text/x-vcard",
-  "text/directory",
-  "application/vcard",
-  "application/x-vcard"
-]);
-var isVCardAttachment2 = (mimeType, fileName) => {
-  if (mimeType && VCARD_MIME_TYPES2.has(mimeType.toLowerCase())) {
-    return true;
+var getPollCache = (owner) => {
+  let cache = pollCaches.get(owner);
+  if (!cache) {
+    cache = new PollCache();
+    pollCaches.set(owner, cache);
   }
-  return Boolean(fileName?.toLowerCase().endsWith(".vcf"));
-};
-var EMOJI_TO_TAPBACK = {
-  "\u2764\uFE0F": Reaction.love,
-  "\u{1F44D}": Reaction.like,
-  "\u{1F44E}": Reaction.dislike,
-  "\u{1F602}": Reaction.laugh,
-  "\u203C\uFE0F": Reaction.emphasize,
-  "\u2753": Reaction.question
+  return cache;
 };
-var TAPBACK_TO_EMOJI = Object.fromEntries(
-  Object.entries(EMOJI_TO_TAPBACK).map(([emoji, kind]) => [kind, emoji])
-);
-var TAPBACK_CODE_TO_KIND = {
-  "2000": Reaction.love,
-  "2001": Reaction.like,
-  "2002": Reaction.dislike,
-  "2003": Reaction.laugh,
-  "2004": Reaction.emphasize,
-  "2005": Reaction.question,
-  "2006": Reaction.emoji,
-  "2007": Reaction.sticker
+
+// src/providers/imessage/remote/ids.ts
+var PART_PREFIX = /^p:(\d+)\//;
+var formatChildId = (partIndex, parentGuid) => `p:${partIndex}/${parentGuid}`;
+var parseTapbackTarget = (target) => {
+  const match = target.match(PART_PREFIX);
+  const guid = target.replace(PART_PREFIX, "");
+  const partIndex = match ? Number(match[1]) : 0;
+  return { guid, partIndex };
 };
-var isTapbackRemoval = (code) => code.startsWith("3");
-var resolveReactionEmoji = (type, emoji) => {
-  if (emoji) {
-    return emoji;
-  }
-  if (!type) {
+var parseChildId = (id) => {
+  const match = id.match(PART_PREFIX);
+  if (!match) {
     return null;
   }
-  const kind = TAPBACK_CODE_TO_KIND[type] ?? type;
-  return TAPBACK_TO_EMOJI[kind] ?? null;
-};
-var getAssociatedMessageType = (message) => {
-  const direct = message.associatedMessageType;
-  if (typeof direct === "string") {
-    return direct;
-  }
-  const raw = message._raw;
-  const fromRaw = raw?.associatedMessageType;
-  return typeof fromRaw === "string" ? fromRaw : void 0;
+  return {
+    parentGuid: id.replace(PART_PREFIX, ""),
+    partIndex: Number(match[1])
+  };
 };
+
+// src/providers/imessage/remote/inbound.ts
+var URL_BALLOON_BUNDLE_ID = "com.apple.messages.URLBalloonProvider";
 var getBalloonBundleId = (message) => {
   const raw = message._raw;
   const id = raw?.balloonBundleId;
@@ -499,6 +454,31 @@ var resolveChatGuid = (message, hint) => {
   return first ?? "";
 };
 var resolveSenderId = (message) => message.sender?.address ?? "";
+var isIMessageMessage = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const record = value;
+  return typeof record.id === "string" && record.id.length > 0 && typeof record.content === "object" && record.content !== null && typeof record.sender === "object" && record.sender !== null && typeof record.space === "object" && record.space !== null;
+};
+var asProviderGroup = (items) => groupSchema.parse({ type: "group", items });
+var buildMessageBase = (message, chatGuidHint, timestamp) => {
+  const chat = resolveChatGuid(message, chatGuidHint);
+  return {
+    sender: { id: resolveSenderId(message) },
+    space: {
+      id: chat,
+      type: chat.includes(";+;") ? "group" : "dm"
+    },
+    timestamp
+  };
+};
+var receivedEventFromMessage = (message) => ({
+  chatGuid: resolveChatGuid(message, void 0),
+  message,
+  timestamp: message.dateCreated ?? /* @__PURE__ */ new Date(),
+  type: "message.received"
+});
 var toAttachmentContent2 = (client, info) => asAttachment({
   name: info.fileName,
   mimeType: info.mimeType,
@@ -510,22 +490,15 @@ var toVCardContent2 = async (client, info) => {
   try {
     const buf = Buffer.from(await client.attachments.downloadBuffer(info.guid));
     return asContact(fromVCard(buf.toString("utf8")));
-  } catch {
+  } catch (err) {
+    console.warn(
+      "[spectrum-ts][imessage] failed to parse vCard attachment; falling back to attachment content",
+      { error: err, guid: info.guid }
+    );
     return toAttachmentContent2(client, info);
   }
 };
-var attachmentContent = async (client, info) => isVCardAttachment2(info.mimeType, info.fileName) ? await toVCardContent2(client, info) : toAttachmentContent2(client, info);
-var baseShape = (message, chatGuidHint, timestamp) => {
-  const chat = resolveChatGuid(message, chatGuidHint);
-  return {
-    sender: { id: resolveSenderId(message) },
-    space: {
-      id: chat,
-      type: chat.includes(";+;") ? "group" : "dm"
-    },
-    timestamp
-  };
-};
+var attachmentContent = async (client, info) => isVCardAttachment(info.mimeType, info.fileName) ? await toVCardContent2(client, info) : toAttachmentContent2(client, info);
 var buildAttachmentMessage = async (client, base, info, id, partIndex, parentId) => {
   const content = await attachmentContent(client, info);
   const msg = { ...base, id, content, partIndex };
@@ -534,10 +507,26 @@ var buildAttachmentMessage = async (client, base, info, id, partIndex, parentId)
   }
   return msg;
 };
+var toRichlinkMessage = (message, base, id) => {
+  const url = message.text ?? "";
+  try {
+    return { ...base, id, content: asRichlink({ url }) };
+  } catch (err) {
+    console.warn(
+      "[spectrum-ts][imessage] failed to convert message to rich link; falling back to text/custom content",
+      { error: err, message, url }
+    );
+    return {
+      ...base,
+      id,
+      content: url ? asText(url) : asCustom(message)
+    };
+  }
+};
 var rebuildFromAppleMessage = async (client, message, chatGuidHint) => {
   const messageGuidStr = message.guid;
   const timestamp = message.dateCreated ?? /* @__PURE__ */ new Date();
-  const base = baseShape(message, chatGuidHint, timestamp);
+  const base = buildMessageBase(message, chatGuidHint, timestamp);
   if (message.attachments.length === 1) {
     const info = message.attachments[0];
     if (!info) {
@@ -566,22 +555,13 @@ var rebuildFromAppleMessage = async (client, message, chatGuidHint) => {
     return {
       ...base,
       id: messageGuidStr,
-      content: asGroup({ items })
+      content: asProviderGroup(items)
     };
   }
-  const text = message.text;
   if (getBalloonBundleId(message) === URL_BALLOON_BUNDLE_ID) {
-    const url = text ?? "";
-    try {
-      return { ...base, id: messageGuidStr, content: asRichlink({ url }) };
-    } catch {
-      return {
-        ...base,
-        id: messageGuidStr,
-        content: url ? asText(url) : asCustom(message)
-      };
-    }
+    return toRichlinkMessage(message, base, messageGuidStr);
   }
+  const text = message.text;
   return {
     ...base,
     id: messageGuidStr,
@@ -592,403 +572,1116 @@ var cacheMessage = (cache, message) => {
   cache.set(message.id, message);
   if (message.content.type === "group") {
     for (const item of message.content.items) {
-      cache.set(item.id, item);
+      if (isIMessageMessage(item)) {
+        cache.set(item.id, item);
+      }
     }
   }
 };
-var toRichlinkMessage = (event, base, id) => {
-  const url = event.message.text ?? "";
-  try {
-    return { ...base, id, content: asRichlink({ url }) };
-  } catch {
-    return {
+var toInboundMessages = async (client, cache, event) => {
+  const base = buildMessageBase(event.message, event.chatGuid, event.timestamp);
+  const messageGuidStr = event.message.guid;
+  if (getBalloonBundleId(event.message) === URL_BALLOON_BUNDLE_ID) {
+    const msg2 = toRichlinkMessage(event.message, base, messageGuidStr);
+    cacheMessage(cache, msg2);
+    return [msg2];
+  }
+  if (event.message.attachments.length === 1) {
+    const info = event.message.attachments[0];
+    if (!info) {
+      throw new Error("Unreachable: attachments.length === 1 but no element");
+    }
+    const msg2 = await buildAttachmentMessage(
+      client,
+      base,
+      info,
+      messageGuidStr,
+      0
+    );
+    cacheMessage(cache, msg2);
+    return [msg2];
+  }
+  if (event.message.attachments.length > 1) {
+    const items = [];
+    for (let i = 0; i < event.message.attachments.length; i++) {
+      const info = event.message.attachments[i];
+      if (!info) {
+        continue;
+      }
+      items.push(
+        await buildAttachmentMessage(
+          client,
+          base,
+          info,
+          formatChildId(i, messageGuidStr),
+          i,
+          messageGuidStr
+        )
+      );
+    }
+    const parent = {
       ...base,
-      id,
-      content: url ? asText(url) : asCustom(event.message)
+      id: messageGuidStr,
+      content: asProviderGroup(items)
     };
+    cacheMessage(cache, parent);
+    return [parent];
   }
+  const text = event.message.text;
+  const msg = {
+    ...base,
+    id: messageGuidStr,
+    content: text ? asText(text) : asCustom(event.message)
+  };
+  cacheMessage(cache, msg);
+  return [msg];
 };
-var PART_PREFIX = /^p:(\d+)\//;
-var formatChildId = (partIndex, parentGuid) => `p:${partIndex}/${parentGuid}`;
-var parseTapbackTarget = (target) => {
-  const match = target.match(PART_PREFIX);
-  const guid = target.replace(PART_PREFIX, "");
-  const partIndex = match ? Number(match[1]) : 0;
-  return { guid, partIndex };
+var getMessage3 = async (remote, spaceId, msgId) => {
+  const cache = getMessageCache(remote);
+  const cached = cache.get(msgId);
+  if (cached) {
+    return cached;
+  }
+  const childRef = parseChildId(msgId);
+  if (childRef) {
+    try {
+      const fetched = await remote.messages.get(
+        messageGuid(childRef.parentGuid)
+      );
+      const parent = await rebuildFromAppleMessage(remote, fetched, spaceId);
+      cacheMessage(cache, parent);
+      if (parent.content.type !== "group") {
+        return;
+      }
+      const item = parent.content.items[childRef.partIndex];
+      return isIMessageMessage(item) ? item : void 0;
+    } catch (err) {
+      if (err instanceof NotFoundError) {
+        return;
+      }
+      throw err;
+    }
+  }
+  try {
+    const fetched = await remote.messages.get(messageGuid(msgId));
+    const rebuilt = await rebuildFromAppleMessage(remote, fetched, spaceId);
+    cacheMessage(cache, rebuilt);
+    return rebuilt;
+  } catch (err) {
+    if (err instanceof NotFoundError) {
+      return;
+    }
+    throw err;
+  }
 };
-var parseChildId = (id) => {
-  const match = id.match(PART_PREFIX);
-  if (!match) {
+
+// src/providers/imessage/remote/reactions.ts
+import {
+  chatGuid,
+  messageGuid as messageGuid2,
+  Reaction
+} from "@photon-ai/advanced-imessage";
+var EMOJI_TO_TAPBACK = {
+  "\u2764\uFE0F": Reaction.love,
+  "\u{1F44D}": Reaction.like,
+  "\u{1F44E}": Reaction.dislike,
+  "\u{1F602}": Reaction.laugh,
+  "\u203C\uFE0F": Reaction.emphasize,
+  "\u2753": Reaction.question
+};
+var TAPBACK_TO_EMOJI = Object.fromEntries(
+  Object.entries(EMOJI_TO_TAPBACK).map(([emoji, kind]) => [kind, emoji])
+);
+var TAPBACK_CODE_TO_KIND = {
+  "2000": Reaction.love,
+  "2001": Reaction.like,
+  "2002": Reaction.dislike,
+  "2003": Reaction.laugh,
+  "2004": Reaction.emphasize,
+  "2005": Reaction.question,
+  "2006": Reaction.emoji,
+  "2007": Reaction.sticker
+};
+var isTapbackRemoval = (code) => code.startsWith("3");
+var resolveReactionEmoji = (type, emoji) => {
+  if (emoji) {
+    return emoji;
+  }
+  if (!type) {
     return null;
   }
+  const kind = TAPBACK_CODE_TO_KIND[type] ?? type;
+  return TAPBACK_TO_EMOJI[kind] ?? null;
+};
+var getAssociatedMessageType = (message) => {
+  const direct = message.associatedMessageType;
+  if (typeof direct === "string") {
+    return direct;
+  }
+  const raw = message._raw;
+  const fromRaw = raw?.associatedMessageType;
+  return typeof fromRaw === "string" ? fromRaw : void 0;
+};
+var asProviderReaction = (emoji, target) => reactionSchema.parse({
+  emoji,
+  target,
+  type: "reaction"
+});
+var resolveReactionTarget = async (client, cache, strippedGuid, partIndex) => {
+  let candidate = cache.get(strippedGuid);
+  if (!candidate) {
+    try {
+      const fetched = await client.messages.get(messageGuid2(strippedGuid));
+      candidate = await rebuildFromAppleMessage(client, fetched);
+      cacheMessage(cache, candidate);
+    } catch {
+      return;
+    }
+  }
+  if (candidate.content.type === "group") {
+    const items = candidate.content.items;
+    if (!Array.isArray(items)) {
+      return candidate;
+    }
+    const item = items[partIndex];
+    return isIMessageMessage(item) ? item : candidate;
+  }
+  return candidate;
+};
+var toReactionMessages = async (client, cache, event, target) => {
+  const type = getAssociatedMessageType(event.message);
+  if (type && isTapbackRemoval(type)) {
+    return [];
+  }
+  const emoji = resolveReactionEmoji(
+    type,
+    event.message.associatedMessageEmoji
+  );
+  if (!emoji) {
+    return [];
+  }
+  const { guid: strippedGuid, partIndex } = parseTapbackTarget(target);
+  const resolved = await resolveReactionTarget(
+    client,
+    cache,
+    strippedGuid,
+    partIndex
+  );
+  if (!resolved) {
+    return [];
+  }
+  const messageId = event.message.guid;
+  if (typeof messageId !== "string" || messageId.length === 0) {
+    return [];
+  }
+  const base = buildMessageBase(event.message, event.chatGuid, event.timestamp);
+  return [
+    {
+      ...base,
+      id: messageId,
+      content: asProviderReaction(emoji, resolved)
+    }
+  ];
+};
+var reactToMessage = async (remote, spaceId, target, reaction) => {
+  const chat = chatGuid(spaceId);
+  const parentGuid = target.parentId ?? target.id;
+  const guid = messageGuid2(parentGuid);
+  const opts = typeof target.partIndex === "number" ? { partIndex: target.partIndex } : void 0;
+  const native = EMOJI_TO_TAPBACK[reaction];
+  if (native) {
+    await remote.messages.react(chat, guid, native, opts);
+  } else {
+    await remote.messages.reactEmoji(chat, guid, reaction, opts);
+  }
+};
+
+// src/providers/imessage/remote/send.ts
+import {
+  chatGuid as chatGuid2,
+  messageGuid as messageGuid3
+} from "@photon-ai/advanced-imessage";
+
+// src/utils/audio.ts
+import { spawn } from "child_process";
+import { mkdtemp as mkdtemp2, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join2 } from "path";
+var M4A_BRANDS = /* @__PURE__ */ new Set([
+  "M4A ",
+  "M4B ",
+  "M4P ",
+  "mp42",
+  "mp41",
+  "isom",
+  "iso2"
+]);
+var M4A_MIME_TYPES = /* @__PURE__ */ new Set([
+  "audio/mp4",
+  "audio/mp4a-latm",
+  "audio/x-m4a",
+  "audio/aac",
+  "audio/aacp"
+]);
+var FFMPEG_MISSING_MESSAGE = "voice content: input is not m4a/aac and ffmpeg is unavailable. Install `ffmpeg-static` or ensure `ffmpeg` is on PATH.";
+var isM4a = (buffer) => {
+  if (buffer.length < 12) {
+    return false;
+  }
+  if (buffer.toString("ascii", 4, 8) !== "ftyp") {
+    return false;
+  }
+  return M4A_BRANDS.has(buffer.toString("ascii", 8, 12));
+};
+var isM4aMimeType = (mimeType) => M4A_MIME_TYPES.has(mimeType.toLowerCase());
+var cachedFfmpegPath;
+var tryStaticBinary = async () => {
+  try {
+    const mod = await import("ffmpeg-static");
+    return mod.default ?? void 0;
+  } catch {
+    return void 0;
+  }
+};
+var resolveFfmpegPath = async () => {
+  if (cachedFfmpegPath) {
+    return cachedFfmpegPath;
+  }
+  cachedFfmpegPath = await tryStaticBinary() ?? "ffmpeg";
+  return cachedFfmpegPath;
+};
+var collectStream = (stream2) => {
+  if (!stream2) {
+    return Promise.resolve("");
+  }
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stream2.on("data", (chunk) => {
+      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    });
+    stream2.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    stream2.on("error", reject);
+  });
+};
+var isMissingBinaryError = (err) => err?.code === "ENOENT";
+var runFfmpeg = (ffmpegPath, args) => {
+  const proc = spawn(ffmpegPath, args, { stdio: ["ignore", "ignore", "pipe"] });
+  const stderr = collectStream(proc.stderr);
+  const exit = new Promise((resolve, reject) => {
+    proc.on(
+      "error",
+      (err) => reject(
+        isMissingBinaryError(err) ? new Error(FFMPEG_MISSING_MESSAGE) : err
+      )
+    );
+    proc.on("exit", (code) => resolve(code ?? -1));
+  });
+  return Promise.all([exit, stderr]).then(([code, text]) => ({
+    code,
+    stderr: text
+  }));
+};
+var DURATION_PATTERN = /Duration:\s*(\d+):(\d{2}):(\d{2})(?:\.(\d{1,3}))?/;
+var parseDuration = (stderr) => {
+  const match = stderr.match(DURATION_PATTERN);
+  if (!match) {
+    return void 0;
+  }
+  const [, hh, mm, ss, frac] = match;
+  const seconds = Number(hh) * 3600 + Number(mm) * 60 + Number(ss) + Number(`0.${frac ?? 0}`);
+  return Number.isFinite(seconds) ? seconds : void 0;
+};
+var transcodeToM4a = async (buffer) => {
+  const ffmpeg = await resolveFfmpegPath();
+  const dir = await mkdtemp2(join2(tmpdir2(), "spectrum-voice-"));
+  const inPath = join2(dir, "in");
+  const outPath = join2(dir, "out.m4a");
+  try {
+    await writeFile2(inPath, buffer);
+    const { code, stderr } = await runFfmpeg(ffmpeg, [
+      "-y",
+      "-i",
+      inPath,
+      "-f",
+      "ipod",
+      "-c:a",
+      "aac",
+      outPath
+    ]);
+    if (code !== 0) {
+      throw new Error(`ffmpeg conversion failed (exit ${code}): ${stderr}`);
+    }
+    const out = await readFile2(outPath);
+    return { buffer: out, duration: parseDuration(stderr) };
+  } finally {
+    await rm2(dir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+};
+var ensureM4a = async (buffer, mimeType) => {
+  if (isM4aMimeType(mimeType) || isM4a(buffer)) {
+    return { buffer };
+  }
+  return transcodeToM4a(buffer);
+};
+
+// src/providers/imessage/remote/send.ts
+var GROUP_ITEM_ALLOWED = /* @__PURE__ */ new Set([
+  "attachment",
+  "contact",
+  "voice"
+]);
+var PartialGroupSendError = class extends Error {
+  cause;
+  groupMembers;
+  constructor(groupMembers, cause) {
+    super("iMessage group send failed after one or more items were sent");
+    this.name = "PartialGroupSendError";
+    this.cause = cause;
+    this.groupMembers = groupMembers;
+  }
+};
+var toDate = (value) => {
+  if (value instanceof Date) {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "string") {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? void 0 : date;
+  }
+};
+var receiptTimestamp = (receipt) => toDate(receipt.timestamp) ?? toDate(receipt.date) ?? toDate(receipt.dateCreated) ?? /* @__PURE__ */ new Date();
+var toSendResult = (receipt) => {
+  if (typeof receipt.guid !== "string" || receipt.guid.length === 0) {
+    throw new Error("iMessage send receipt is missing a message guid");
+  }
+  return {
+    id: receipt.guid,
+    timestamp: receiptTimestamp(receipt)
+  };
+};
+var withReply = (options, replyTo) => replyTo ? { ...options, replyTo } : options;
+var replyOptions = (replyTo) => replyTo ? { replyTo } : void 0;
+var sendVCardAttachment = (remote, name, vcf) => remote.attachments.upload({
+  data: Buffer.from(vcf, "utf8"),
+  fileName: name,
+  mimeType: "text/vcard"
+});
+var sendContactAttachment = async (remote, content) => {
+  const vcf = await toVCard(content);
+  const upload = await sendVCardAttachment(remote, vcardFileName(content), vcf);
+  return upload.guid;
+};
+var uploadAttachment = async (remote, content) => {
+  const attachment = await remote.attachments.upload({
+    data: await content.read(),
+    fileName: content.name,
+    mimeType: content.mimeType
+  });
+  return attachment.guid;
+};
+var uploadVoice = async (remote, content) => {
+  const { buffer } = await ensureM4a(await content.read(), content.mimeType);
+  const attachment = await remote.attachments.upload({
+    data: buffer,
+    fileName: content.name ?? "voice.m4a",
+    mimeType: "audio/x-m4a"
+  });
+  return attachment.guid;
+};
+var sendContent = async (remote, chat, content, replyTo) => {
+  switch (content.type) {
+    case "text":
+      return toSendResult(
+        await remote.messages.send(chat, content.text, withReply({}, replyTo))
+      );
+    case "richlink":
+      return toSendResult(
+        await remote.messages.send(
+          chat,
+          content.url,
+          withReply({ richLink: true }, replyTo)
+        )
+      );
+    case "attachment":
+      return toSendResult(
+        await remote.messages.send(chat, "", {
+          attachment: await uploadAttachment(remote, content),
+          ...replyOptions(replyTo)
+        })
+      );
+    case "contact":
+      return toSendResult(
+        await remote.messages.send(chat, "", {
+          attachment: await sendContactAttachment(remote, content),
+          ...replyOptions(replyTo)
+        })
+      );
+    case "voice":
+      return toSendResult(
+        await remote.messages.send(chat, "", {
+          attachment: await uploadVoice(remote, content),
+          audioMessage: true,
+          ...replyOptions(replyTo)
+        })
+      );
+    case "poll":
+      if (replyTo) {
+        throw unsupportedRemoteContent(
+          "poll",
+          "polls cannot be sent as replies"
+        );
+      }
+      return toSendResult(
+        await remote.polls.create(
+          chat,
+          content.title,
+          content.options.map((option) => option.title)
+        )
+      );
+    default:
+      throw unsupportedRemoteContent(content.type);
+  }
+};
+var validateGroupContent = (content) => {
+  for (const sub of content.items) {
+    const itemType = sub.content.type;
+    if (!GROUP_ITEM_ALLOWED.has(itemType)) {
+      throw unsupportedRemoteContent(
+        "group",
+        `"${itemType}" items are not supported inside a group`
+      );
+    }
+  }
+};
+var send3 = async (remote, spaceId, content) => {
+  const chat = chatGuid2(spaceId);
+  if (content.type === "group") {
+    validateGroupContent(content);
+    const groupMembers = [];
+    try {
+      for (const sub of content.items) {
+        groupMembers.push(await sendContent(remote, chat, sub.content));
+      }
+    } catch (err) {
+      throw new PartialGroupSendError(groupMembers, err);
+    }
+    const first = groupMembers[0];
+    if (!first) {
+      throw new Error("Empty group");
+    }
+    return { ...first, groupMembers };
+  }
+  return sendContent(remote, chat, content);
+};
+var replyToMessage = async (remote, spaceId, msgId, content) => {
+  const chat = chatGuid2(spaceId);
+  const replyTo = messageGuid3(msgId);
+  return sendContent(remote, chat, content, replyTo);
+};
+var editMessage = async (remote, spaceId, msgId, content) => {
+  if (content.type !== "text") {
+    throw unsupportedRemoteContent(
+      content.type,
+      "only text content can be edited"
+    );
+  }
+  await remote.messages.edit(
+    chatGuid2(spaceId),
+    messageGuid3(msgId),
+    content.text
+  );
+};
+
+// src/providers/imessage/remote/stream.ts
+import {
+  AuthenticationError,
+  IMessageError,
+  NotFoundError as NotFoundError2,
+  ValidationError
+} from "@photon-ai/advanced-imessage";
+
+// src/utils/resumable-stream.ts
+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 RetryableStreamError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RetryableStreamError";
+  }
+};
+var LiveBufferOverflowError = class extends RetryableStreamError {
+  constructor(limit) {
+    super(`Live stream buffer exceeded ${limit} events during catch-up`);
+    this.name = "LiveBufferOverflowError";
+  }
+};
+var closeIterable = async (iterable) => {
+  if (!iterable) {
+    return;
+  }
+  await iterable.close?.();
+};
+var jitterDelay = (delayMs) => Math.random() * delayMs;
+var resumableOrderedStream = (options) => stream((emit, end) => {
+  const catchUpPageSize = options.catchUpPageSize ?? CATCH_UP_PAGE_SIZE;
+  const bufferLimit = options.bufferLimit ?? MAX_BUFFERED_LIVE_EVENTS;
+  const initialRetryDelayMs = options.initialRetryDelayMs ?? RECONNECT_INITIAL_DELAY_MS;
+  const maxRetryDelayMs = options.maxRetryDelayMs ?? RECONNECT_MAX_DELAY_MS;
+  let activeLive;
+  let closed = false;
+  let lastCursor;
+  let retryDelayMs = initialRetryDelayMs;
+  let sleepTimer;
+  let wakeSleep;
+  const deliveredSinceCursor = /* @__PURE__ */ new Set();
+  const resetRetryDelay = () => {
+    retryDelayMs = initialRetryDelayMs;
+  };
+  const advanceCursor = (cursor, clearDelivered) => {
+    if (!cursor || cursor === lastCursor) {
+      return;
+    }
+    lastCursor = cursor;
+    if (clearDelivered) {
+      deliveredSinceCursor.clear();
+    }
+  };
+  const deliverItem = async (item, resetRetry, clearOnCursorAdvance) => {
+    const alreadyDelivered = deliveredSinceCursor.has(item.id);
+    if (!alreadyDelivered) {
+      for (const value of item.values) {
+        await emit(value);
+      }
+    }
+    advanceCursor(item.cursor, clearOnCursorAdvance);
+    deliveredSinceCursor.add(item.id);
+    if (resetRetry) {
+      resetRetryDelay();
+    }
+  };
+  const retryable = (error) => error instanceof RetryableStreamError || options.isRetryableError(error);
+  const sleep = async (delayMs) => {
+    if (delayMs <= 0 || closed) {
+      return;
+    }
+    await new Promise((resolve) => {
+      wakeSleep = resolve;
+      sleepTimer = setTimeout(resolve, jitterDelay(delayMs));
+    });
+    sleepTimer = void 0;
+    wakeSleep = void 0;
+  };
+  const cancelSleep = () => {
+    if (sleepTimer) {
+      clearTimeout(sleepTimer);
+      sleepTimer = void 0;
+    }
+    wakeSleep?.();
+    wakeSleep = void 0;
+  };
+  const nextRetryDelay = () => {
+    const delay = retryDelayMs;
+    retryDelayMs = Math.min(retryDelayMs * 2, maxRetryDelayMs);
+    return delay;
+  };
+  const consumeLive = async () => {
+    const live = options.subscribeLive();
+    activeLive = live;
+    try {
+      for await (const event of live) {
+        await deliverItem(await options.processLive(event), true, true);
+      }
+      throw new RetryableStreamError("Live stream ended");
+    } finally {
+      if (activeLive === live) {
+        activeLive = void 0;
+      }
+      await closeIterable(live);
+    }
+  };
+  const throwLiveError = (liveError) => {
+    if (liveError) {
+      throw liveError;
+    }
+  };
+  const bufferLiveEvent = (buffer, event) => {
+    if (buffer.length >= bufferLimit) {
+      throw new LiveBufferOverflowError(bufferLimit);
+    }
+    buffer.push(event);
+  };
+  const startLivePump = (live, isBuffering, liveBuffer) => {
+    let liveError;
+    const pump2 = (async () => {
+      try {
+        for await (const event of live) {
+          if (isBuffering()) {
+            bufferLiveEvent(liveBuffer, event);
+            continue;
+          }
+          await deliverItem(await options.processLive(event), true, true);
+        }
+        throw new RetryableStreamError("Live stream ended");
+      } catch (error) {
+        liveError = error;
+      }
+    })();
+    return {
+      getError: () => liveError,
+      pump: pump2
+    };
+  };
+  const replayMissed = async (cursor, getLiveError) => {
+    for await (const event of options.fetchMissed(cursor, {
+      limit: catchUpPageSize
+    })) {
+      throwLiveError(getLiveError());
+      await deliverItem(await options.processMissed(event), false, false);
+    }
+    throwLiveError(getLiveError());
+  };
+  const flushLiveBuffer = async (liveBuffer, getLiveError) => {
+    let index = 0;
+    let lastFlushedId;
+    while (index < liveBuffer.length) {
+      throwLiveError(getLiveError());
+      const event = liveBuffer[index];
+      if (event === void 0) {
+        throw new RetryableStreamError("Live stream buffer index missing");
+      }
+      const item = await options.processLive(event);
+      await deliverItem(item, true, false);
+      lastFlushedId = item.id;
+      index += 1;
+    }
+    liveBuffer.length = 0;
+    throwLiveError(getLiveError());
+    return lastFlushedId;
+  };
+  const compactDeliveredIds = (lastId) => {
+    if (!lastId) {
+      return;
+    }
+    deliveredSinceCursor.clear();
+    deliveredSinceCursor.add(lastId);
+  };
+  const catchUpThenConsumeLive = async (cursor) => {
+    const live = options.subscribeLive();
+    activeLive = live;
+    let buffering = true;
+    const liveBuffer = [];
+    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 livePump.pump;
+      throwLiveError(livePump.getError());
+    } finally {
+      buffering = false;
+      if (activeLive === live) {
+        activeLive = void 0;
+      }
+      await closeIterable(live);
+      await livePump.pump.catch(() => void 0);
+    }
+  };
+  const run = async () => {
+    while (!closed) {
+      try {
+        if (lastCursor) {
+          await catchUpThenConsumeLive(lastCursor);
+        } else {
+          await consumeLive();
+        }
+      } catch (error) {
+        await closeIterable(activeLive);
+        activeLive = void 0;
+        if (closed) {
+          break;
+        }
+        if (!retryable(error)) {
+          end(error);
+          return;
+        }
+        await sleep(nextRetryDelay());
+      }
+    }
+    end();
+  };
+  const pump = run().catch((error) => {
+    if (!closed) {
+      end(error);
+    }
+  });
+  return async () => {
+    closed = true;
+    cancelSleep();
+    await closeIterable(activeLive);
+    await pump;
+  };
+});
+
+// src/providers/imessage/remote/polls.ts
+var isVotedPollEvent = (event) => event.delta.type === "voted";
+var isUnvotedPollEvent = (event) => event.delta.type === "unvoted";
+var toCachedPoll = (input) => {
+  const poll = asPoll({
+    title: input.title,
+    options: input.options.map((optionInfo) => ({
+      title: optionInfo.text
+    }))
+  });
+  const optionsByIdentifier = /* @__PURE__ */ new Map();
+  for (const [index, optionInfo] of input.options.entries()) {
+    const option = poll.options[index];
+    if (option && optionInfo.optionIdentifier) {
+      optionsByIdentifier.set(optionInfo.optionIdentifier, option);
+    }
+  }
+  return { poll, optionsByIdentifier };
+};
+var cachePollInfo = (cache, info) => {
+  const cached = toCachedPoll(info);
+  cache.set(info.messageGuid, cached);
+  return cached;
+};
+var cachePollEvent = (cache, event) => {
+  if (event.delta.type === "created" || event.delta.type === "optionAdded") {
+    try {
+      const cached = toCachedPoll({
+        title: event.delta.title,
+        options: event.delta.options
+      });
+      cache.set(event.pollMessageGuid, cached);
+      return cached;
+    } catch (e) {
+      console.error("[spectrum-ts][imessage][poll] failed to cache poll", e);
+    }
+  }
+};
+var fetchPollInfo = async (client, cache, event) => {
+  try {
+    const info = await client.polls.get(event.pollMessageGuid);
+    cachePollInfo(cache, info);
+    return info;
+  } catch (e) {
+    console.error("[spectrum-ts][imessage][poll] failed to fetch poll", e);
+    return;
+  }
+};
+var resolvePoll = async (client, cache, event) => {
+  const pollId = event.pollMessageGuid;
+  const cached = cache.get(pollId);
+  if (cached) {
+    return cached;
+  }
+  try {
+    const info = await client.polls.get(event.pollMessageGuid);
+    return cachePollInfo(cache, info);
+  } catch (e) {
+    console.error("[spectrum-ts][imessage][poll] failed to resolve poll", e);
+    return;
+  }
+};
+var buildPollOptionMessage = (input) => {
+  const option = input.cached.optionsByIdentifier.get(input.optionId);
+  if (!option) {
+    return;
+  }
+  const action = input.selected ? "selected" : "deselected";
+  return {
+    id: `${input.event.pollMessageGuid}:${input.senderAddress}:${input.optionId}:${action}:${input.event.at.getTime()}`,
+    sender: { id: input.senderAddress },
+    space: {
+      id: input.chatGuid,
+      type: input.chatGuid.includes(";+;") ? "group" : "dm"
+    },
+    timestamp: input.event.at,
+    content: asPollOption({
+      option,
+      poll: input.cached.poll,
+      selected: input.selected
+    })
+  };
+};
+var buildPollOptionMessages = (input) => {
+  const messages5 = [];
+  for (const delta of input.deltas) {
+    const message = buildPollOptionMessage({
+      cached: input.cached,
+      chatGuid: input.chatGuid,
+      event: input.event,
+      optionId: delta.optionId,
+      selected: delta.selected,
+      senderAddress: input.senderAddress
+    });
+    if (message) {
+      messages5.push(message);
+    }
+  }
+  return messages5;
+};
+var allOptionIdsKnown = (cached, optionIds) => optionIds.every((optionId) => cached.optionsByIdentifier.has(optionId));
+var refreshPollMetadata = async (client, pollCache, event, fallbackOptionIds) => {
+  const info = await fetchPollInfo(client, pollCache, event);
+  if (!info) {
+    return;
+  }
+  const refreshed = pollCache.get(info.messageGuid);
+  if (!refreshed) {
+    return;
+  }
   return {
-    parentGuid: id.replace(PART_PREFIX, ""),
-    partIndex: Number(match[1])
+    optionIds: [...fallbackOptionIds],
+    poll: refreshed
   };
 };
-var resolveReactionTarget = async (client, cache, strippedGuid, partIndex) => {
-  let candidate = cache.get(strippedGuid);
-  if (!candidate) {
-    try {
-      const fetched = await client.messages.get(messageGuid(strippedGuid));
-      candidate = await rebuildFromAppleMessage(client, fetched);
-      cacheMessage(cache, candidate);
-    } catch {
-      return;
+var toPollVoteMessages = async (client, pollCache, event) => {
+  const senderAddress = event.actor.address;
+  if (!senderAddress) {
+    return [];
+  }
+  const pollId = event.pollMessageGuid;
+  if (pollCache.isStaleActorSelectionEvent(pollId, senderAddress, event.at)) {
+    return [];
+  }
+  const cached = await resolvePoll(client, pollCache, event);
+  if (!cached) {
+    return [];
+  }
+  const chatGuidStr = event.chatGuid;
+  let currentOptionIds = [...event.delta.optionIdentifiers];
+  let resolvedPoll = cached;
+  if (currentOptionIds.some(
+    (optionId) => !resolvedPoll.optionsByIdentifier.has(optionId)
+  )) {
+    const snapshot = await refreshPollMetadata(
+      client,
+      pollCache,
+      event,
+      currentOptionIds
+    );
+    if (snapshot) {
+      currentOptionIds = snapshot.optionIds;
+      resolvedPoll = snapshot.poll;
     }
   }
-  if (candidate.content.type === "group") {
-    const item = candidate.content.items[partIndex];
-    return item ?? candidate;
+  if (!allOptionIdsKnown(resolvedPoll, currentOptionIds)) {
+    return [];
   }
-  return candidate;
+  const deltas = pollCache.actorSelectionDeltas(
+    pollId,
+    senderAddress,
+    currentOptionIds
+  );
+  const messages5 = buildPollOptionMessages({
+    cached: resolvedPoll,
+    chatGuid: chatGuidStr,
+    deltas,
+    event,
+    senderAddress
+  });
+  pollCache.commitActorSelection(
+    pollId,
+    senderAddress,
+    currentOptionIds,
+    event.at
+  );
+  return messages5;
 };
-var toReactionMessage = async (client, cache, event, base, id, target) => {
-  const type = getAssociatedMessageType(event.message);
-  if (type && isTapbackRemoval(type)) {
+var toPollUnvoteMessages = async (client, pollCache, event) => {
+  const senderAddress = event.actor.address;
+  if (!senderAddress) {
     return [];
   }
-  const emoji = resolveReactionEmoji(
-    type,
-    event.message.associatedMessageEmoji
-  );
-  if (!emoji) {
+  const pollId = event.pollMessageGuid;
+  if (pollCache.isStaleActorSelectionEvent(pollId, senderAddress, event.at)) {
     return [];
   }
-  const { guid: strippedGuid, partIndex } = parseTapbackTarget(target);
-  const resolved = await resolveReactionTarget(
-    client,
-    cache,
-    strippedGuid,
-    partIndex
-  );
-  if (!resolved) {
+  const cached = await resolvePoll(client, pollCache, event);
+  if (!cached) {
     return [];
   }
-  return [
-    {
-      ...base,
-      id,
-      content: asReaction({ emoji, target: resolved })
-    }
-  ];
+  const chatGuidStr = event.chatGuid;
+  const deltas = pollCache.clearedActorSelectionDeltas(pollId, senderAddress);
+  const messages5 = buildPollOptionMessages({
+    cached,
+    chatGuid: chatGuidStr,
+    deltas,
+    event,
+    senderAddress
+  });
+  pollCache.commitActorSelection(pollId, senderAddress, [], event.at);
+  return messages5;
 };
-var toMessages2 = async (client, cache, event) => {
-  const base = baseShape(event.message, event.chatGuid, event.timestamp);
-  const messageGuidStr = event.message.guid;
-  const assoc = event.message.associatedMessageGuid;
-  if (assoc) {
-    return toReactionMessage(client, cache, event, base, messageGuidStr, assoc);
+var toPollDeltaMessages = async (client, pollCache, event) => {
+  if (isVotedPollEvent(event)) {
+    return toPollVoteMessages(client, pollCache, event);
   }
-  if (getBalloonBundleId(event.message) === URL_BALLOON_BUNDLE_ID) {
-    const msg2 = toRichlinkMessage(event, base, messageGuidStr);
-    cacheMessage(cache, msg2);
-    return [msg2];
+  if (isUnvotedPollEvent(event)) {
+    return toPollUnvoteMessages(client, pollCache, event);
   }
-  if (event.message.attachments.length === 1) {
-    const info = event.message.attachments[0];
-    if (!info) {
-      throw new Error("Unreachable: attachments.length === 1 but no element");
-    }
-    const msg2 = await buildAttachmentMessage(
-      client,
-      base,
-      info,
-      messageGuidStr,
-      0
-    );
-    cacheMessage(cache, msg2);
-    return [msg2];
+  return [];
+};
+
+// src/providers/imessage/remote/stream.ts
+var pollRetryDelay = (delayMs) => Math.random() * delayMs;
+var isRetryableIMessageStreamError = (error) => {
+  if (error instanceof AuthenticationError || error instanceof NotFoundError2 || error instanceof ValidationError) {
+    return false;
   }
-  if (event.message.attachments.length > 1) {
-    const items = [];
-    for (let i = 0; i < event.message.attachments.length; i++) {
-      const info = event.message.attachments[i];
-      if (!info) {
-        continue;
-      }
-      items.push(
-        await buildAttachmentMessage(
-          client,
-          base,
-          info,
-          formatChildId(i, messageGuidStr),
-          i,
-          messageGuidStr
-        )
-      );
-    }
-    const parent = {
-      ...base,
-      id: messageGuidStr,
-      content: asGroup({ items })
-    };
-    cacheMessage(cache, parent);
-    return [parent];
+  if (error instanceof IMessageError) {
+    return true;
   }
-  const text = event.message.text;
-  const msg = {
-    ...base,
-    id: messageGuidStr,
-    content: text ? asText(text) : asCustom(event.message)
-  };
-  cacheMessage(cache, msg);
-  return [msg];
+  return false;
 };
-var clientStream = (client) => {
-  const sub = client.messages.subscribe("message.received");
+var toMessageItem = async (client, event, cursor) => {
+  const id = event.message.guid;
+  if (event.message.isFromMe) {
+    return { cursor, id, values: [] };
+  }
   const cache = getMessageCache(client);
-  return stream((emit, end) => {
-    const pump = (async () => {
-      try {
-        for await (const event of sub) {
-          if (event.message.isFromMe) {
-            continue;
-          }
-          for (const message of await toMessages2(client, cache, event)) {
-            await emit(message);
-          }
-        }
-        end();
-      } catch (e) {
-        end(e);
-      }
-    })();
-    return async () => {
-      sub.close();
-      await pump;
-    };
-  });
+  const target = event.message.associatedMessageGuid;
+  const values = target ? await toReactionMessages(client, cache, event, target) : await toInboundMessages(client, cache, event);
+  return { cursor, id, values };
 };
-var sendVCardAttachment = (remote, name, vcf) => remote.attachments.upload({
-  data: Buffer.from(vcf, "utf8"),
-  fileName: name,
-  mimeType: "text/vcard"
+var messageStream = (client) => resumableOrderedStream({
+  fetchMissed: (cursor, { limit }) => client.messages.fetchMissed(cursor, { limit }),
+  isRetryableError: isRetryableIMessageStreamError,
+  processLive: (event) => toMessageItem(client, event, event.cursor),
+  processMissed: (message) => toMessageItem(client, receivedEventFromMessage(message)),
+  subscribeLive: () => client.messages.subscribe("message.received")
 });
-var vcardFileName2 = (contact) => {
-  const base = contact.name?.formatted ?? contact.user?.id ?? "contact";
-  return `${base.replace(/[^a-zA-Z0-9_\-.]/g, "_")}.vcf`;
-};
-var sendContactAttachment = async (remote, content) => {
-  const vcf = await toVCard(content);
-  const upload = await sendVCardAttachment(remote, vcardFileName2(content), vcf);
-  return upload.guid;
+var logPollStreamError = (error) => {
+  console.error("[spectrum-ts][imessage][poll] stream failed", error);
 };
-var messages2 = (clients) => mergeStreams(clients.map(clientStream));
-var startTyping = async (clients, spaceId) => {
-  const remote = clients[0];
-  if (!remote) {
+var emitPollMessages = async (client, pollCache, event, emit) => {
+  cachePollEvent(pollCache, event);
+  if (event.actor.isFromMe) {
     return;
   }
-  await remote.chats.startTyping(chatGuid(spaceId));
-};
-var stopTyping = async (clients, spaceId) => {
-  const remote = clients[0];
-  if (!remote) {
-    return;
+  const messages5 = await toPollDeltaMessages(client, pollCache, event);
+  for (const vote of messages5) {
+    await emit(vote);
   }
-  await remote.chats.stopTyping(chatGuid(spaceId));
 };
-var sendSingle = async (remote, chat, content) => {
-  switch (content.type) {
-    case "text":
-      return toSendResult(await remote.messages.send(chat, content.text));
-    case "richlink":
-      return toSendResult(
-        await remote.messages.send(chat, content.url, { richLink: true })
-      );
-    case "attachment": {
-      const attachment = await remote.attachments.upload({
-        data: await content.read(),
-        fileName: content.name,
-        mimeType: content.mimeType
-      });
-      return toSendResult(
-        await remote.messages.send(chat, "", { attachment: attachment.guid })
-      );
-    }
-    case "contact": {
-      const attachment = await sendContactAttachment(remote, content);
-      return toSendResult(await remote.messages.send(chat, "", { attachment }));
-    }
-    case "voice": {
-      const { buffer } = await ensureM4a(
-        await content.read(),
-        content.mimeType
-      );
-      const attachment = await remote.attachments.upload({
-        data: buffer,
-        fileName: content.name ?? "voice.m4a",
-        mimeType: "audio/x-m4a"
-      });
-      return toSendResult(
-        await remote.messages.send(chat, "", {
-          attachment: attachment.guid,
-          audioMessage: true
-        })
-      );
-    }
-    default:
-      throw unsupportedContent(content.type);
+var runPollSubscription = async (client, pollCache, subscription, emit, onEvent) => {
+  for await (const event of subscription) {
+    onEvent();
+    await emitPollMessages(client, pollCache, event, emit);
   }
 };
-var send2 = async (clients, spaceId, content) => {
-  const remote = clients[0];
-  if (!remote) {
-    throw new Error("No remote iMessage client available");
-  }
-  const chat = chatGuid(spaceId);
-  if (content.type === "group") {
-    for (const sub of content.items) {
-      const itemType = sub.content.type;
-      if (!GROUP_ITEM_ALLOWED.has(itemType)) {
-        throw unsupportedContent(
-          "group",
-          `"${itemType}" items are not supported inside a group`
-        );
-      }
+var pollStream = (client, pollCache) => stream((emit, end) => {
+  let active = client.polls.subscribe();
+  let closed = false;
+  let retryDelayMs = RECONNECT_INITIAL_DELAY_MS;
+  let sleepTimer;
+  let wakeSleep;
+  const sleep = async (delayMs) => {
+    if (closed) {
+      return;
     }
-    const groupMembers = [];
-    for (const sub of content.items) {
-      groupMembers.push(await sendSingle(remote, chat, sub.content));
+    await new Promise((resolve) => {
+      wakeSleep = resolve;
+      sleepTimer = setTimeout(resolve, pollRetryDelay(delayMs));
+    });
+    sleepTimer = void 0;
+    wakeSleep = void 0;
+  };
+  const cancelSleep = () => {
+    if (sleepTimer) {
+      clearTimeout(sleepTimer);
+      sleepTimer = void 0;
     }
-    const first = groupMembers[0];
-    if (!first) {
-      throw new Error("Empty group");
+    wakeSleep?.();
+    wakeSleep = void 0;
+  };
+  const pump = (async () => {
+    while (!closed) {
+      try {
+        await runPollSubscription(client, pollCache, active, emit, () => {
+          retryDelayMs = RECONNECT_INITIAL_DELAY_MS;
+        });
+      } catch (e) {
+        if (!closed) {
+          logPollStreamError(e);
+        }
+      } finally {
+        await active.close();
+      }
+      if (!closed) {
+        await sleep(retryDelayMs);
+        retryDelayMs = Math.min(retryDelayMs * 2, RECONNECT_MAX_DELAY_MS);
+        active = client.polls.subscribe();
+      }
     }
-    return { ...first, groupMembers };
-  }
-  return sendSingle(remote, chat, content);
+    end();
+  })();
+  return async () => {
+    closed = true;
+    cancelSleep();
+    await active.close();
+    await pump;
+  };
+});
+var clientStream = (client, pollCache) => {
+  return mergeStreams([messageStream(client), pollStream(client, pollCache)]);
 };
-var replyToMessage = async (clients, spaceId, msgId, content) => {
-  const remote = clients[0];
-  if (!remote) {
-    throw new Error("No remote iMessage client available");
-  }
-  const chat = chatGuid(spaceId);
-  const replyTo = messageGuid(msgId);
-  switch (content.type) {
-    case "text":
-      return toSendResult(
-        await remote.messages.send(chat, content.text, { replyTo })
-      );
-    case "richlink":
-      return toSendResult(
-        await remote.messages.send(chat, content.url, {
-          richLink: true,
-          replyTo
-        })
-      );
-    case "attachment": {
-      const attachment = await remote.attachments.upload({
-        data: await content.read(),
-        fileName: content.name,
-        mimeType: content.mimeType
-      });
-      return toSendResult(
-        await remote.messages.send(chat, "", {
-          attachment: attachment.guid,
-          replyTo
-        })
-      );
-    }
-    case "contact": {
-      const attachment = await sendContactAttachment(remote, content);
-      return toSendResult(
-        await remote.messages.send(chat, "", { attachment, replyTo })
-      );
-    }
-    case "voice": {
-      const { buffer } = await ensureM4a(
-        await content.read(),
-        content.mimeType
-      );
-      const attachment = await remote.attachments.upload({
-        data: buffer,
-        fileName: content.name ?? "voice.m4a",
-        mimeType: "audio/x-m4a"
-      });
-      return toSendResult(
-        await remote.messages.send(chat, "", {
-          attachment: attachment.guid,
-          audioMessage: true,
-          replyTo
-        })
-      );
-    }
-    default:
-      throw unsupportedContent(content.type);
-  }
+var messages3 = (clients) => {
+  const pollCache = getPollCache(clients);
+  return mergeStreams(clients.map((client) => clientStream(client, pollCache)));
 };
-var editMessage = async (clients, spaceId, msgId, content) => {
-  if (content.type !== "text") {
-    throw UnsupportedError.content(
-      content.type,
-      PLATFORM,
-      "only text content can be edited"
-    );
-  }
-  const remote = clients[0];
+
+// src/providers/imessage/remote/typing.ts
+import { chatGuid as chatGuid3 } from "@photon-ai/advanced-imessage";
+var startTyping = async (remote, spaceId) => {
+  await remote.chats.startTyping(chatGuid3(spaceId));
+};
+var stopTyping = async (remote, spaceId) => {
+  await remote.chats.stopTyping(chatGuid3(spaceId));
+};
+
+// src/providers/imessage/remote/api.ts
+var messages4 = (clients) => messages3(clients);
+var startTyping2 = async (clients, spaceId) => {
+  const remote = firstRemoteClient(clients);
   if (!remote) {
-    throw new Error("No remote iMessage client available");
+    return;
   }
-  await remote.messages.edit(
-    chatGuid(spaceId),
-    messageGuid(msgId),
-    content.text
-  );
+  await startTyping(remote, spaceId);
 };
-var reactToMessage = async (clients, spaceId, target, reaction) => {
-  const remote = clients[0];
+var stopTyping2 = async (clients, spaceId) => {
+  const remote = firstRemoteClient(clients);
   if (!remote) {
     return;
   }
-  const chat = chatGuid(spaceId);
-  const parentGuid = target.parentId ?? target.id;
-  const guid = messageGuid(parentGuid);
-  const opts = typeof target.partIndex === "number" ? { partIndex: target.partIndex } : void 0;
-  const native = EMOJI_TO_TAPBACK[reaction];
-  if (native) {
-    await remote.messages.react(chat, guid, native, opts);
-  } else {
-    await remote.messages.reactEmoji(chat, guid, reaction, opts);
-  }
+  await stopTyping(remote, spaceId);
 };
-var getMessage2 = async (clients, spaceId, msgId) => {
-  const remote = clients[0];
+var send4 = async (clients, spaceId, content) => send3(primaryRemoteClient(clients), spaceId, content);
+var replyToMessage2 = async (clients, spaceId, msgId, content) => replyToMessage(primaryRemoteClient(clients), spaceId, msgId, content);
+var editMessage2 = async (clients, spaceId, msgId, content) => editMessage(primaryRemoteClient(clients), spaceId, msgId, content);
+var reactToMessage2 = async (clients, spaceId, target, reaction) => {
+  const remote = firstRemoteClient(clients);
   if (!remote) {
     return;
   }
-  const cache = getMessageCache(remote);
-  const cached = cache.get(msgId);
-  if (cached) {
-    return cached;
-  }
-  const childRef = parseChildId(msgId);
-  if (childRef) {
-    try {
-      const fetched = await remote.messages.get(
-        messageGuid(childRef.parentGuid)
-      );
-      const parent = await rebuildFromAppleMessage(remote, fetched, spaceId);
-      cacheMessage(cache, parent);
-      if (parent.content.type !== "group") {
-        return;
-      }
-      const items = parent.content.items;
-      return items[childRef.partIndex];
-    } catch {
-      return;
-    }
-  }
-  try {
-    const fetched = await remote.messages.get(messageGuid(msgId));
-    const rebuilt = await rebuildFromAppleMessage(remote, fetched, spaceId);
-    cacheMessage(cache, rebuilt);
-    return rebuilt;
-  } catch {
+  await reactToMessage(remote, spaceId, target, reaction);
+};
+var getMessage4 = async (clients, spaceId, msgId) => {
+  const remote = firstRemoteClient(clients);
+  if (!remote) {
     return;
   }
+  return getMessage3(remote, spaceId, msgId);
 };
 
 // src/providers/imessage/types.ts
@@ -1014,6 +1707,7 @@ var messageSchema = z.object({
 });
 
 // src/providers/imessage/index.ts
+var isPollContent = (content) => content.type === "poll" || content.type === "poll_option";
 var imessage = definePlatform("iMessage", {
   config: configSchema,
   user: {
@@ -1082,55 +1776,69 @@ var imessage = definePlatform("iMessage", {
     }
   },
   events: {
-    messages: ({ client }) => isLocal(client) ? messages(client) : messages2(client)
+    messages: ({ client }) => isLocal(client) ? messages2(client) : messages4(client)
   },
   actions: {
     send: async ({ space, content, client }) => {
       if (isLocal(client)) {
-        return await send(client, space.id, content);
+        return await send2(client, space.id, content);
       }
-      return await send2(client, space.id, content);
+      return await send4(client, space.id, content);
     },
     startTyping: async ({ space, client }) => {
       if (isLocal(client)) {
         return;
       }
-      await startTyping(client, space.id);
+      await startTyping2(client, space.id);
     },
     stopTyping: async ({ space, client }) => {
       if (isLocal(client)) {
         return;
       }
-      await stopTyping(client, space.id);
+      await stopTyping2(client, space.id);
     },
     reactToMessage: async ({ space, target, reaction, client }) => {
       if (isLocal(client)) {
         throw UnsupportedError.action("react", "iMessage (local mode)");
       }
-      await reactToMessage(
+      if (isPollContent(target.content)) {
+        throw UnsupportedError.action(
+          "react",
+          "iMessage",
+          "iMessage polls do not support reactions"
+        );
+      }
+      await reactToMessage2(
         client,
         space.id,
         target,
         reaction
       );
     },
-    replyToMessage: async ({ space, messageId, content, client }) => {
+    replyToMessage: async ({ space, messageId, target, content, client }) => {
       if (isLocal(client)) {
         throw UnsupportedError.action("reply", "iMessage (local mode)");
       }
-      return await replyToMessage(client, space.id, messageId, content);
+      if (isPollContent(target.content)) {
+        throw UnsupportedError.action(
+          "reply",
+          "iMessage",
+          "iMessage polls do not support replies"
+        );
+      }
+      return await replyToMessage2(client, space.id, messageId, content);
     },
     editMessage: async ({ space, messageId, content, client }) => {
       if (isLocal(client)) {
         throw UnsupportedError.action("edit", "iMessage (local mode)");
       }
-      await editMessage(client, space.id, messageId, content);
+      await editMessage2(client, space.id, messageId, content);
     },
     getMessage: async ({ space, messageId, client }) => {
       if (isLocal(client)) {
-        return getMessage(client, messageId);
+        return getMessage2(client, messageId);
       }
-      return getMessage2(client, space.id, messageId);
+      return getMessage4(client, space.id, messageId);
     }
   }
 });