spectrum-ts 1.4.0 → 1.5.0

package/dist/chunk-4U4RINOV.js

@@ -0,0 +1,2133 @@
+import {
+  asGroup,
+  asRichlink,
+  groupSchema
+} from "./chunk-66GJ45ZZ.js";
+import {
+  asPoll,
+  asPollOption,
+  cloud,
+  mergeStreams,
+  stream
+} from "./chunk-L6LUFBLF.js";
+import {
+  UnsupportedError,
+  asAttachment,
+  asContact,
+  asCustom,
+  asText,
+  attachmentSchema,
+  definePlatform,
+  fromVCard,
+  reactionSchema,
+  text,
+  textSchema,
+  toVCard
+} from "./chunk-LH4YEBG3.js";
+
+// src/providers/imessage/index.ts
+import { createClient as createClient2, MessageEffect as MessageEffect2 } from "@photon-ai/advanced-imessage";
+import { IMessageSDK as IMessageSDK2 } from "@photon-ai/imessage-kit";
+
+// src/providers/imessage/content/effect.ts
+import {
+  MessageEffect
+} from "@photon-ai/advanced-imessage";
+
+// src/content/effect.ts
+import z from "zod";
+var effectInnerSchema = z.discriminatedUnion("type", [
+  textSchema,
+  attachmentSchema
+]);
+var messageEffectSchema = z.object({
+  type: z.literal("effect"),
+  content: effectInnerSchema,
+  effect: z.string().nonempty()
+});
+
+// src/providers/imessage/content/effect.ts
+var SUPPORTED_EFFECTS = new Set(Object.values(MessageEffect));
+var resolveContent = (input) => typeof input === "string" ? text(input).build() : input.build();
+function effect(input, messageEffect) {
+  return {
+    build: async () => {
+      if (!SUPPORTED_EFFECTS.has(messageEffect)) {
+        throw new Error(
+          `Unsupported iMessage message effect "${messageEffect}"`
+        );
+      }
+      const inner = await resolveContent(input);
+      if (inner.type !== "text" && inner.type !== "attachment") {
+        throw new Error(
+          `imessage effect() only supports text and attachment content, got "${inner.type}"`
+        );
+      }
+      return messageEffectSchema.parse({
+        type: "effect",
+        content: inner,
+        effect: messageEffect
+      });
+    }
+  };
+}
+
+// src/providers/imessage/auth.ts
+import { createClient } from "@photon-ai/advanced-imessage";
+
+// src/providers/imessage/types.ts
+import { IMessageSDK } from "@photon-ai/imessage-kit";
+import z2 from "zod";
+var SHARED_PHONE = "shared";
+var isLocal = (client) => client instanceof IMessageSDK;
+var clientEntry = z2.object({
+  address: z2.string(),
+  token: z2.string(),
+  phone: z2.string()
+});
+var configSchema = z2.union([
+  z2.object({ local: z2.literal(true) }),
+  z2.object({
+    local: z2.literal(false).optional().default(false),
+    clients: clientEntry.or(z2.array(clientEntry)).optional()
+  })
+]);
+var userSchema = z2.object({});
+var spaceSchema = z2.object({
+  id: z2.string(),
+  type: z2.enum(["dm", "group"]),
+  phone: z2.string()
+});
+var spaceParamsSchema = z2.object({
+  phone: z2.string().optional()
+});
+var messageSchema = z2.object({
+  partIndex: z2.number().int().nonnegative().optional(),
+  parentId: z2.string().optional()
+});
+
+// src/providers/imessage/auth.ts
+var RENEWAL_RATIO = 0.8;
+var EXPIRY_BUFFER_MS = 3e4;
+var RETRY_DELAY_MS = 3e4;
+var cloudAuthState = /* @__PURE__ */ new WeakMap();
+var requirePhone = (data, instanceId) => {
+  const phone = data.numbers?.[instanceId];
+  if (!phone) {
+    throw new Error(`iMessage instance ${instanceId} has no phone assigned`);
+  }
+  return phone;
+};
+async function createCloudClients(projectId, projectSecret) {
+  let tokenData = await cloud.issueImessageTokens(projectId, projectSecret);
+  let tokenExpiresAt = Date.now() + tokenData.expiresIn * 1e3;
+  let disposed = false;
+  let renewalTimer;
+  const records = [];
+  const syncPhones = (data) => {
+    for (const { entry, instanceId } of records) {
+      entry.phone = requirePhone(data, instanceId);
+    }
+  };
+  const scheduleRenewal = () => {
+    if (disposed) {
+      return;
+    }
+    const ttlMs = tokenData.expiresIn * 1e3;
+    const renewInMs = Math.max(ttlMs * RENEWAL_RATIO, 5e3);
+    renewalTimer = setTimeout(async () => {
+      try {
+        tokenData = await cloud.issueImessageTokens(projectId, projectSecret);
+        tokenExpiresAt = Date.now() + tokenData.expiresIn * 1e3;
+        if (tokenData.type === "dedicated") {
+          syncPhones(tokenData);
+        }
+        scheduleRenewal();
+      } catch {
+        renewalTimer = setTimeout(() => scheduleRenewal(), RETRY_DELAY_MS);
+        renewalTimer?.unref?.();
+      }
+    }, renewInMs);
+    renewalTimer?.unref?.();
+  };
+  scheduleRenewal();
+  const refreshIfNeeded = async () => {
+    if (Date.now() < tokenExpiresAt - EXPIRY_BUFFER_MS) {
+      return;
+    }
+    tokenData = await cloud.issueImessageTokens(projectId, projectSecret);
+    tokenExpiresAt = Date.now() + tokenData.expiresIn * 1e3;
+    if (tokenData.type === "dedicated") {
+      syncPhones(tokenData);
+    }
+    scheduleRenewal();
+  };
+  if (tokenData.type === "shared") {
+    const address = process.env.SPECTRUM_IMESSAGE_ADDRESS ?? "imessage.spectrum.photon.codes:443";
+    const entries2 = [
+      {
+        phone: SHARED_PHONE,
+        client: createClient({
+          address,
+          tls: true,
+          token: async () => {
+            await refreshIfNeeded();
+            return tokenData.token;
+          }
+        })
+      }
+    ];
+    cloudAuthState.set(entries2, {
+      dispose: () => {
+        disposed = true;
+        if (renewalTimer !== void 0) {
+          clearTimeout(renewalTimer);
+          renewalTimer = void 0;
+        }
+      }
+    });
+    return entries2;
+  }
+  const dedicated = tokenData;
+  for (const [instanceId, token] of Object.entries(dedicated.auth)) {
+    const entry = {
+      phone: requirePhone(dedicated, instanceId),
+      client: createClient({
+        address: `${instanceId}.imsg.photon.codes:443`,
+        tls: true,
+        token: async () => {
+          await refreshIfNeeded();
+          const data = tokenData;
+          return data.auth[instanceId] ?? token;
+        }
+      })
+    };
+    records.push({ entry, instanceId });
+  }
+  const entries = records.map((r) => r.entry);
+  cloudAuthState.set(entries, {
+    dispose: () => {
+      disposed = true;
+      if (renewalTimer !== void 0) {
+        clearTimeout(renewalTimer);
+        renewalTimer = void 0;
+      }
+    }
+  });
+  return entries;
+}
+async function disposeCloudAuth(clients) {
+  const auth = cloudAuthState.get(clients);
+  if (auth) {
+    auth.dispose();
+    cloudAuthState.delete(clients);
+  }
+}
+
+// src/providers/imessage/local/inbound.ts
+import { setTimeout as sleep } from "timers/promises";
+
+// src/providers/imessage/local/attachments.ts
+import { createReadStream } from "fs";
+import { readFile } from "fs/promises";
+import { Readable } from "stream";
+
+// src/providers/imessage/shared/vcard.ts
+var VCARD_MIME_TYPES = /* @__PURE__ */ new Set([
+  "text/vcard",
+  "text/x-vcard",
+  "text/directory",
+  "application/vcard",
+  "application/x-vcard"
+]);
+var normalizeMimeType = (mimeType) => (mimeType.split(";")[0] ?? "").trim().toLowerCase();
+var isVCardAttachment = (mimeType, fileName) => {
+  if (mimeType && VCARD_MIME_TYPES.has(normalizeMimeType(mimeType))) {
+    return true;
+  }
+  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(
+      `iMessage attachment ${att.id} has no local file available on disk`
+    );
+  }
+  return readFile(att.localPath);
+};
+var toAttachmentContent = (att) => {
+  const { localPath } = att;
+  return asAttachment({
+    name: att.fileName ?? DEFAULT_ATTACHMENT_NAME,
+    mimeType: att.mimeType,
+    size: att.sizeBytes,
+    read: () => readLocalAttachment(att),
+    stream: localPath ? async () => Readable.toWeb(
+      createReadStream(localPath)
+    ) : void 0
+  });
+};
+var toVCardContent = async (att) => {
+  try {
+    const buf = await readLocalAttachment(att);
+    return asContact(fromVCard(buf.toString("utf8")));
+  } catch {
+    return toAttachmentContent(att);
+  }
+};
+var localAttachmentContent = async (att) => isVCardAttachment(att.mimeType, att.fileName) ? await toVCardContent(att) : toAttachmentContent(att);
+
+// src/providers/imessage/local/inbound.ts
+var ATTACHMENT_PLACEHOLDER = "\uFFFC";
+var ATTACHMENT_JOIN_RETRY_DELAY_MS = 250;
+var ATTACHMENT_JOIN_RETRY_LIMIT = 8;
+var ATTACHMENT_JOIN_FETCH_LIMIT = 10;
+var hasAttachmentPlaceholder = (message) => message.text?.includes(ATTACHMENT_PLACEHOLDER) ?? false;
+var isPendingAttachmentJoin = (message) => message.attachments.length === 0 && (message.hasAttachments || hasAttachmentPlaceholder(message));
+var refetchUntilAttachmentsSettle = async (client, message) => {
+  if (!message.chatId) {
+    return message;
+  }
+  for (let attempt = 0; attempt < ATTACHMENT_JOIN_RETRY_LIMIT; attempt += 1) {
+    await sleep(ATTACHMENT_JOIN_RETRY_DELAY_MS);
+    let rows;
+    try {
+      rows = await client.getMessages({
+        chatId: message.chatId,
+        limit: ATTACHMENT_JOIN_FETCH_LIMIT,
+        since: message.createdAt
+      });
+    } catch {
+      continue;
+    }
+    const refreshed = rows.find((row) => row.id === message.id);
+    if (refreshed && !isPendingAttachmentJoin(refreshed)) {
+      return refreshed;
+    }
+  }
+  return message;
+};
+var toMessages = async (message) => {
+  const { chatId, chatKind } = message;
+  if (!chatId || chatKind === "unknown") {
+    return [];
+  }
+  if (message.reaction !== null || message.kind !== "text" || message.retractedAt !== null) {
+    return [];
+  }
+  if (isPendingAttachmentJoin(message)) {
+    return [];
+  }
+  const base = {
+    sender: { id: message.participant ?? "" },
+    // Local mode has no concept of "which-of-my-phones"; phone is empty.
+    space: {
+      id: chatId,
+      type: chatKind === "group" ? "group" : "dm",
+      phone: ""
+    },
+    timestamp: message.createdAt
+  };
+  if (message.attachments.length > 0) {
+    return Promise.all(
+      message.attachments.map(async (att) => ({
+        ...base,
+        id: `${message.id}:${att.id}`,
+        content: await localAttachmentContent(att)
+      }))
+    );
+  }
+  return [
+    {
+      ...base,
+      id: message.id,
+      content: { type: "text", text: message.text ?? "" }
+    }
+  ];
+};
+var messages = (client) => stream((emit, end) => {
+  let lastPromise = Promise.resolve();
+  const handleIncoming = async (message) => {
+    const stableMessage = isPendingAttachmentJoin(message) ? await refetchUntilAttachmentsSettle(client, message) : message;
+    const ms = await toMessages(stableMessage);
+    for (const m of ms) {
+      await emit(m);
+    }
+  };
+  const startPromise = client.startWatching({
+    onIncomingMessage: (message) => {
+      lastPromise = lastPromise.then(() => handleIncoming(message)).catch(end);
+    },
+    onError: end
+  }).catch(end);
+  return async () => {
+    await startPromise.catch(() => {
+    });
+    await client.stopWatching();
+    await lastPromise.catch(() => {
+    });
+  };
+});
+
+// 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, detail) => UnsupportedError.content(type, LOCAL_IMESSAGE_PLATFORM, detail);
+
+// src/providers/imessage/local/send.ts
+var synthRecord = (spaceId, content) => ({
+  id: crypto.randomUUID(),
+  content,
+  space: { id: spaceId },
+  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-"));
+  const tmp = join(dir, safeName);
+  await writeFile(tmp, data);
+  try {
+    await client.send({ to: spaceId, attachments: [tmp] });
+  } finally {
+    await rm(dir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+};
+var send = async (client, spaceId, content) => {
+  switch (content.type) {
+    case "text":
+      await client.send({ to: spaceId, text: content.text });
+      return synthRecord(spaceId, content);
+    case "attachment":
+      await sendTempFile(client, spaceId, content.name, await content.read());
+      return synthRecord(spaceId, content);
+    case "contact": {
+      const vcf = await toVCard(content);
+      await sendTempFile(
+        client,
+        spaceId,
+        vcardFileName(content),
+        Buffer.from(vcf, "utf8")
+      );
+      return synthRecord(spaceId, content);
+    }
+    case "effect":
+      throw unsupportedLocalContent(
+        "effect",
+        "message effects require remote iMessage"
+      );
+    case "poll":
+      throw unsupportedLocalContent("poll");
+    default:
+      throw unsupportedLocalContent(content.type);
+  }
+};
+var getMessage = async (_client, _id) => void 0;
+
+// 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/inbound.ts
+import {
+  NotFoundError
+} from "@photon-ai/advanced-imessage";
+
+// src/providers/imessage/cache.ts
+var DEFAULT_MAX = 1e3;
+var MessageCache = class {
+  map = /* @__PURE__ */ new Map();
+  max;
+  constructor(max = DEFAULT_MAX) {
+    this.max = max;
+  }
+  get(id) {
+    return this.map.get(id);
+  }
+  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);
+      }
+    }
+  }
+  clear() {
+    this.map.clear();
+  }
+};
+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, poll) {
+    if (this.map.has(id)) {
+      this.map.delete(id);
+    }
+    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 messageCaches = /* @__PURE__ */ new WeakMap();
+var pollCaches = /* @__PURE__ */ new WeakMap();
+var getMessageCache = (owner) => {
+  let cache = messageCaches.get(owner);
+  if (!cache) {
+    cache = new MessageCache();
+    messageCaches.set(owner, cache);
+  }
+  return cache;
+};
+var getPollCache = (owner) => {
+  let cache = pollCaches.get(owner);
+  if (!cache) {
+    cache = new PollCache();
+    pollCaches.set(owner, cache);
+  }
+  return cache;
+};
+
+// src/providers/imessage/remote/ids.ts
+var PART_PREFIX = /^p:(\d+)\//;
+var dmChatGuid = (address) => `any;-;${address}`;
+var toChatGuid = (value) => value;
+var toMessageGuid = (value) => value;
+var formatChildId = (partIndex, parentGuid) => `p:${partIndex}/${parentGuid}`;
+var parseChildId = (id) => {
+  const match = id.match(PART_PREFIX);
+  if (!match) {
+    return null;
+  }
+  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) => message.content.balloonBundleId;
+var messageAttachments = (message) => message.content.attachments;
+var resolveChatGuid = (message, hint) => {
+  if (hint) {
+    return hint;
+  }
+  const first = message.chatGuids?.[0];
+  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, phone) => {
+  const chat = resolveChatGuid(message, chatGuidHint);
+  return {
+    sender: { id: resolveSenderId(message) },
+    space: {
+      id: chat,
+      type: chat.includes(";+;") ? "group" : "dm",
+      phone
+    },
+    timestamp
+  };
+};
+var toAttachmentContent2 = (client, info) => asAttachment({
+  name: info.fileName,
+  mimeType: info.mimeType,
+  size: info.totalBytes,
+  read: async () => await downloadPrimaryAttachment(client, info.guid),
+  stream: async () => downloadPrimaryAttachmentStream(client, info.guid)
+});
+var downloadPrimaryAttachmentStream = (client, attachmentGuid) => {
+  const frames = client.attachments.downloadStream(attachmentGuid);
+  const iterator = frames[Symbol.asyncIterator]();
+  let closed = false;
+  const closeFrames = async () => {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    try {
+      await iterator.return?.();
+    } finally {
+      await frames.close();
+    }
+  };
+  return new ReadableStream({
+    async cancel() {
+      await closeFrames();
+    },
+    async pull(controller) {
+      try {
+        while (true) {
+          const result = await iterator.next();
+          if (result.done) {
+            controller.close();
+            await closeFrames();
+            return;
+          }
+          if (result.value.type === "primaryChunk") {
+            controller.enqueue(result.value.data);
+            return;
+          }
+        }
+      } catch (error) {
+        await closeFrames();
+        throw error;
+      }
+    }
+  });
+};
+var downloadPrimaryAttachment = async (client, attachmentGuid) => {
+  const chunks = [];
+  const frames = client.attachments.downloadStream(attachmentGuid);
+  try {
+    for await (const frame of frames) {
+      if (frame.type === "primaryChunk") {
+        chunks.push(Buffer.from(frame.data));
+      }
+    }
+  } finally {
+    await frames.close();
+  }
+  return Buffer.concat(chunks);
+};
+var toVCardContent2 = async (client, info) => {
+  try {
+    const buf = await downloadPrimaryAttachment(client, info.guid);
+    return asContact(fromVCard(buf.toString("utf8")));
+  } 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) => 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 };
+  if (parentId !== void 0) {
+    msg.parentId = parentId;
+  }
+  return msg;
+};
+var toRichlinkMessage = (message, base, id) => {
+  const url = message.content.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, phone, chatGuidHint) => {
+  const messageGuidStr = message.guid;
+  const timestamp = message.dateCreated ?? /* @__PURE__ */ new Date();
+  const base = buildMessageBase(message, chatGuidHint, timestamp, phone);
+  const attachments = messageAttachments(message);
+  if (attachments.length === 1) {
+    const info = attachments[0];
+    if (!info) {
+      throw new Error("Unreachable: attachments.length === 1 but no element");
+    }
+    return buildAttachmentMessage(client, base, info, messageGuidStr, 0);
+  }
+  if (attachments.length > 1) {
+    const items = [];
+    for (let i = 0; i < attachments.length; i++) {
+      const info = attachments[i];
+      if (!info) {
+        continue;
+      }
+      items.push(
+        await buildAttachmentMessage(
+          client,
+          base,
+          info,
+          formatChildId(i, messageGuidStr),
+          i,
+          messageGuidStr
+        )
+      );
+    }
+    return {
+      ...base,
+      id: messageGuidStr,
+      content: asProviderGroup(items)
+    };
+  }
+  if (getBalloonBundleId(message) === URL_BALLOON_BUNDLE_ID) {
+    return toRichlinkMessage(message, base, messageGuidStr);
+  }
+  const text2 = message.content.text;
+  return {
+    ...base,
+    id: messageGuidStr,
+    content: text2 ? asText(text2) : asCustom(message)
+  };
+};
+var cacheMessage = (cache, message) => {
+  cache.set(message.id, message);
+  if (message.content.type === "group") {
+    for (const item of message.content.items) {
+      if (isIMessageMessage(item)) {
+        cache.set(item.id, item);
+      }
+    }
+  }
+};
+var toInboundMessages = async (client, cache, event, phone) => {
+  const base = buildMessageBase(
+    event.message,
+    event.chatGuid,
+    event.occurredAt,
+    phone
+  );
+  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];
+  }
+  const attachments = messageAttachments(event.message);
+  if (attachments.length === 1) {
+    const info = 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 (attachments.length > 1) {
+    const items = [];
+    for (let i = 0; i < attachments.length; i++) {
+      const info = attachments[i];
+      if (!info) {
+        continue;
+      }
+      items.push(
+        await buildAttachmentMessage(
+          client,
+          base,
+          info,
+          formatChildId(i, messageGuidStr),
+          i,
+          messageGuidStr
+        )
+      );
+    }
+    const parent = {
+      ...base,
+      id: messageGuidStr,
+      content: asProviderGroup(items)
+    };
+    cacheMessage(cache, parent);
+    return [parent];
+  }
+  const text2 = event.message.content.text;
+  const msg = {
+    ...base,
+    id: messageGuidStr,
+    content: text2 ? asText(text2) : asCustom(event.message)
+  };
+  cacheMessage(cache, msg);
+  return [msg];
+};
+var getMessage3 = async (remote, spaceId, msgId, phone) => {
+  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(
+        toChatGuid(spaceId),
+        toMessageGuid(childRef.parentGuid)
+      );
+      const parent = await rebuildFromAppleMessage(
+        remote,
+        fetched,
+        phone,
+        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(
+      toChatGuid(spaceId),
+      toMessageGuid(msgId)
+    );
+    const rebuilt = await rebuildFromAppleMessage(
+      remote,
+      fetched,
+      phone,
+      spaceId
+    );
+    cacheMessage(cache, rebuilt);
+    return rebuilt;
+  } catch (err) {
+    if (err instanceof NotFoundError) {
+      return;
+    }
+    throw err;
+  }
+};
+
+// src/providers/imessage/remote/reactions.ts
+var EMOJI_TO_TAPBACK = {
+  "\u2764\uFE0F": "love",
+  "\u{1F44D}": "like",
+  "\u{1F44E}": "dislike",
+  "\u{1F602}": "laugh",
+  "\u203C\uFE0F": "emphasize",
+  "\u2753": "question"
+};
+var TAPBACK_TO_EMOJI = Object.fromEntries(
+  Object.entries(EMOJI_TO_TAPBACK).map(([emoji, kind]) => [kind, emoji])
+);
+var reactionEmoji = (reaction) => reaction.kind === "emoji" ? reaction.emoji : TAPBACK_TO_EMOJI[reaction.kind];
+var asProviderReaction = (emoji, target) => reactionSchema.parse({
+  emoji,
+  target,
+  type: "reaction"
+});
+var resolveReactionTarget = async (client, cache, chat, targetGuid, partIndex, phone) => {
+  let candidate = cache.get(targetGuid);
+  if (!candidate) {
+    try {
+      const fetched = await client.messages.get(
+        toChatGuid(chat),
+        toMessageGuid(targetGuid)
+      );
+      candidate = await rebuildFromAppleMessage(client, fetched, phone, chat);
+      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 ?? 0];
+    return isIMessageMessage(item) ? item : candidate;
+  }
+  return candidate;
+};
+var toReactionMessages = async (client, cache, event, phone) => {
+  const emoji = reactionEmoji(event.reaction);
+  if (!emoji) {
+    return [];
+  }
+  const senderAddress = event.actor?.address;
+  if (!senderAddress) {
+    return [];
+  }
+  const resolved = await resolveReactionTarget(
+    client,
+    cache,
+    event.chatGuid,
+    event.messageGuid,
+    event.targetPartIndex,
+    phone
+  );
+  if (!resolved) {
+    return [];
+  }
+  const partSuffix = typeof event.targetPartIndex === "number" ? `:${event.targetPartIndex}` : "";
+  return [
+    {
+      sender: { id: senderAddress },
+      space: {
+        id: event.chatGuid,
+        type: event.chatGuid.includes(";+;") ? "group" : "dm",
+        phone
+      },
+      timestamp: event.occurredAt,
+      id: `${event.messageGuid}:reaction:${event.sequence}${partSuffix}`,
+      content: asProviderReaction(emoji, resolved)
+    }
+  ];
+};
+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
+    );
+  }
+};
+
+// 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, text2]) => ({
+    code,
+    stderr: text2
+  }));
+};
+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([
+  "text",
+  "attachment",
+  "contact",
+  "voice"
+]);
+var MAX_GROUP_TEXT_ITEMS = 1;
+var outboundRecord = (spaceId, id, content, timestamp, extras) => ({
+  id,
+  content,
+  space: { id: spaceId },
+  timestamp,
+  ...extras
+});
+var outboundGroupItem = (spaceId, id, content, timestamp, partIndex, parentId) => outboundRecord(spaceId, id, content, timestamp, {
+  partIndex,
+  parentId
+});
+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 replyTargetFromId = (messageId) => {
+  const childRef = parseChildId(messageId);
+  if (childRef) {
+    return {
+      guid: toMessageGuid(childRef.parentGuid),
+      partIndex: childRef.partIndex
+    };
+  }
+  return toMessageGuid(messageId);
+};
+var outboundMessage = (spaceId, message, content) => outboundRecord(spaceId, message.guid, content, message.dateCreated);
+var outboundPoll = (spaceId, poll, content) => outboundRecord(spaceId, poll.pollMessageGuid, content, /* @__PURE__ */ new Date());
+var sendVCardAttachment = (remote, name, vcf) => remote.attachments.upload({
+  data: Buffer.from(vcf, "utf8"),
+  fileName: name
+});
+var sendContactAttachment = async (remote, content) => {
+  const vcf = await toVCard(content);
+  const name = vcardFileName(content);
+  const upload = await sendVCardAttachment(remote, name, vcf);
+  return { guid: upload.attachment.guid, name };
+};
+var uploadAttachment = async (remote, content) => {
+  const attachment = await remote.attachments.upload({
+    data: await content.read(),
+    fileName: content.name
+  });
+  return { guid: attachment.attachment.guid, name: content.name };
+};
+var uploadVoice = async (remote, content) => {
+  const { buffer } = await ensureM4a(await content.read(), content.mimeType);
+  const name = content.name ?? "voice.m4a";
+  const attachment = await remote.attachments.upload({
+    data: buffer,
+    fileName: name
+  });
+  return { guid: attachment.attachment.guid, name };
+};
+var sendContent = async (remote, spaceId, chat, content, replyTo, effect2) => {
+  switch (content.type) {
+    case "effect":
+      return sendContent(
+        remote,
+        spaceId,
+        chat,
+        content.content,
+        replyTo,
+        content.effect
+      );
+    case "text": {
+      const message = await remote.messages.sendText(
+        chat,
+        content.text,
+        withReply(effectOption(effect2), replyTo)
+      );
+      return outboundMessage(spaceId, message, content);
+    }
+    case "richlink": {
+      const message = await remote.messages.sendText(
+        chat,
+        content.url,
+        withReply({ enableLinkPreview: true }, replyTo)
+      );
+      return outboundMessage(spaceId, message, content);
+    }
+    case "attachment": {
+      const { guid } = await uploadAttachment(remote, content);
+      const message = await remote.messages.sendAttachment(
+        chat,
+        guid,
+        withReply(effectOption(effect2), replyTo)
+      );
+      return outboundMessage(spaceId, message, content);
+    }
+    case "contact": {
+      const { guid } = await sendContactAttachment(remote, content);
+      const message = await remote.messages.sendAttachment(
+        chat,
+        guid,
+        replyOptions(replyTo)
+      );
+      return outboundMessage(spaceId, message, content);
+    }
+    case "voice": {
+      const { guid } = await uploadVoice(remote, content);
+      const message = await remote.messages.sendAttachment(chat, guid, {
+        isAudioMessage: true,
+        ...replyOptions(replyTo)
+      });
+      return outboundMessage(spaceId, message, content);
+    }
+    case "poll":
+      if (replyTo) {
+        throw unsupportedRemoteContent(
+          "poll",
+          "polls cannot be sent as replies"
+        );
+      }
+      return outboundPoll(
+        spaceId,
+        await remote.polls.create(
+          chat,
+          content.title,
+          content.options.map((option) => option.title)
+        ),
+        content
+      );
+    default:
+      throw unsupportedRemoteContent(content.type);
+  }
+};
+var validateGroupContent = (content) => {
+  let textCount = 0;
+  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`
+      );
+    }
+    if (itemType === "text" && ++textCount > MAX_GROUP_TEXT_ITEMS) {
+      throw unsupportedRemoteContent(
+        "group",
+        `groups can contain at most ${MAX_GROUP_TEXT_ITEMS} text item`
+      );
+    }
+  }
+};
+var resolvePart = async (remote, content) => {
+  switch (content.type) {
+    case "text":
+      return { text: content.text };
+    case "attachment": {
+      const { guid, name } = await uploadAttachment(remote, content);
+      return { attachmentGuid: guid, attachmentName: name };
+    }
+    case "contact": {
+      const { guid, name } = await sendContactAttachment(remote, content);
+      return { attachmentGuid: guid, attachmentName: name };
+    }
+    case "voice": {
+      const { guid, name } = await uploadVoice(remote, content);
+      return { attachmentGuid: guid, attachmentName: name };
+    }
+    default:
+      throw unsupportedRemoteContent(content.type);
+  }
+};
+var send3 = async (remote, spaceId, content) => {
+  const chat = toChatGuid(spaceId);
+  if (content.type === "group") {
+    validateGroupContent(content);
+    const resolved = await Promise.all(
+      content.items.map((sub) => resolvePart(remote, sub.content))
+    );
+    const message = await remote.messages.sendMultipart(
+      chat,
+      resolved.map((part, idx) => ({ ...part, bubbleIndex: idx }))
+    );
+    const parentGuid = message.guid;
+    const timestamp = message.dateCreated;
+    const items = content.items.map(
+      (sub, idx) => outboundGroupItem(
+        spaceId,
+        formatChildId(idx, parentGuid),
+        sub.content,
+        timestamp,
+        idx,
+        parentGuid
+      )
+    );
+    return outboundRecord(spaceId, parentGuid, providerGroup(items), timestamp);
+  }
+  return sendContent(remote, spaceId, chat, content);
+};
+var replyToMessage = async (remote, spaceId, msgId, content) => {
+  const chat = toChatGuid(spaceId);
+  return sendContent(remote, spaceId, chat, content, replyTargetFromId(msgId));
+};
+var editMessage = async (remote, spaceId, msgId, content) => {
+  if (content.type !== "text") {
+    throw unsupportedRemoteContent(
+      content.type,
+      "only text content can be edited"
+    );
+  }
+  const childRef = parseChildId(msgId);
+  await remote.messages.edit(
+    toChatGuid(spaceId),
+    toMessageGuid(childRef?.parentGuid ?? msgId),
+    content.text,
+    childRef ? { partIndex: childRef.partIndex } : void 0
+  );
+};
+
+// 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 ignoreCleanupError = () => void 0;
+var jitterDelay = (delayMs) => Math.random() * delayMs;
+var numericCursor = (cursor) => {
+  if (!cursor) {
+    return;
+  }
+  const value = Number(cursor);
+  return Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+};
+var isCursorRegression = (next, current) => {
+  const nextValue = numericCursor(next);
+  const currentValue = numericCursor(current);
+  return nextValue !== void 0 && currentValue !== void 0 && nextValue < currentValue;
+};
+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 || isCursorRegression(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 sleep2 = 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(lastCursor);
+    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(cursor);
+    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);
+      void livePump.pump.catch(ignoreCleanupError);
+    }
+  };
+  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 sleep2(nextRetryDelay());
+      }
+    }
+    end();
+  };
+  const pump = run().catch((error) => {
+    if (!closed) {
+      end(error);
+    }
+  });
+  return async () => {
+    closed = true;
+    cancelSleep();
+    await closeIterable(activeLive);
+    void pump.catch(ignoreCleanupError);
+  };
+});
+
+// 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.pollMessageGuid, 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";
+  const eventTime = input.event.occurredAt.getTime();
+  return {
+    id: `${input.event.pollMessageGuid}:${input.senderAddress}:${input.optionId}:${action}:${eventTime}`,
+    sender: { id: input.senderAddress },
+    space: {
+      id: input.chatGuid,
+      type: input.chatGuid.includes(";+;") ? "group" : "dm",
+      phone: input.phone
+    },
+    timestamp: input.event.occurredAt,
+    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,
+      phone: input.phone,
+      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) => {
+  const info = await fetchPollInfo(client, pollCache, event);
+  if (!info) {
+    return;
+  }
+  return pollCache.get(info.pollMessageGuid);
+};
+var toPollVoteMessages = async (client, pollCache, event, phone) => {
+  const senderAddress = event.actor?.address;
+  if (!senderAddress) {
+    return [];
+  }
+  const pollId = event.pollMessageGuid;
+  if (pollCache.isStaleActorSelectionEvent(
+    pollId,
+    senderAddress,
+    event.occurredAt
+  )) {
+    return [];
+  }
+  const cached = await resolvePoll(client, pollCache, event);
+  if (!cached) {
+    return [];
+  }
+  const chatGuidStr = event.chatGuid;
+  const currentOptionIds = [event.delta.optionIdentifier];
+  let resolvedPoll = cached;
+  if (currentOptionIds.some(
+    (optionId) => !resolvedPoll.optionsByIdentifier.has(optionId)
+  )) {
+    const snapshot = await refreshPollMetadata(client, pollCache, event);
+    if (snapshot) {
+      resolvedPoll = snapshot;
+    }
+  }
+  if (!allOptionIdsKnown(resolvedPoll, currentOptionIds)) {
+    return [];
+  }
+  const deltas = pollCache.actorSelectionDeltas(
+    pollId,
+    senderAddress,
+    currentOptionIds
+  );
+  const messages5 = buildPollOptionMessages({
+    cached: resolvedPoll,
+    chatGuid: chatGuidStr,
+    deltas,
+    event,
+    phone,
+    senderAddress
+  });
+  pollCache.commitActorSelection(
+    pollId,
+    senderAddress,
+    currentOptionIds,
+    event.occurredAt
+  );
+  return messages5;
+};
+var toPollUnvoteMessages = async (client, pollCache, event, phone) => {
+  const senderAddress = event.actor?.address;
+  if (!senderAddress) {
+    return [];
+  }
+  const pollId = event.pollMessageGuid;
+  if (pollCache.isStaleActorSelectionEvent(
+    pollId,
+    senderAddress,
+    event.occurredAt
+  )) {
+    return [];
+  }
+  const cached = await resolvePoll(client, pollCache, event);
+  if (!cached) {
+    return [];
+  }
+  const chatGuidStr = event.chatGuid;
+  const deltas = pollCache.clearedActorSelectionDeltas(pollId, senderAddress);
+  const messages5 = buildPollOptionMessages({
+    cached,
+    chatGuid: chatGuidStr,
+    deltas,
+    event,
+    phone,
+    senderAddress
+  });
+  pollCache.commitActorSelection(pollId, senderAddress, [], event.occurredAt);
+  return messages5;
+};
+var toPollDeltaMessages = async (client, pollCache, event, phone) => {
+  if (isVotedPollEvent(event)) {
+    return toPollVoteMessages(client, pollCache, event, phone);
+  }
+  if (isUnvotedPollEvent(event)) {
+    return toPollUnvoteMessages(client, pollCache, event, phone);
+  }
+  return [];
+};
+
+// src/providers/imessage/remote/stream.ts
+var isRetryableIMessageStreamError = (error) => {
+  if (error instanceof AuthenticationError || error instanceof NotFoundError2 || error instanceof ValidationError) {
+    return false;
+  }
+  if (error instanceof IMessageError) {
+    return true;
+  }
+  return false;
+};
+var isEventFromCurrentAccount = (event, phone) => phone !== SHARED_PHONE && event.actor?.address !== void 0 && event.actor.address === phone;
+var toMessageItem = async (client, event, phone, cursor) => {
+  if (event.type === "message.received") {
+    if (event.message.isFromMe) {
+      return { cursor, id: event.message.guid, values: [] };
+    }
+    const cache = getMessageCache(client);
+    return {
+      cursor,
+      id: event.message.guid,
+      values: await toInboundMessages(client, cache, event, phone)
+    };
+  }
+  if (event.type === "message.reactionAdded") {
+    if (isEventFromCurrentAccount(event, phone)) {
+      return {
+        cursor,
+        id: `${event.messageGuid}:reaction:${event.sequence}`,
+        values: []
+      };
+    }
+    const cache = getMessageCache(client);
+    return {
+      cursor,
+      id: `${event.messageGuid}:reaction:${event.sequence}`,
+      values: await toReactionMessages(client, cache, event, phone)
+    };
+  }
+  return {
+    cursor,
+    id: `${event.type}:${"messageGuid" in event ? event.messageGuid : "unknown"}:${event.sequence}`,
+    values: []
+  };
+};
+var toPollItem = async (client, pollCache, event, phone, cursor) => {
+  cachePollEvent(pollCache, event);
+  if (isEventFromCurrentAccount(event, phone)) {
+    return {
+      cursor,
+      id: `${event.pollMessageGuid}:poll:${event.sequence}`,
+      values: []
+    };
+  }
+  return {
+    cursor,
+    id: `${event.pollMessageGuid}:poll:${event.sequence}`,
+    values: await toPollDeltaMessages(client, pollCache, event, phone)
+  };
+};
+var toCatchUpCompleteItem = (event) => ({
+  cursor: String(event.headSequence),
+  id: `${event.type}:${event.headSequence}`,
+  values: []
+});
+var isMessageEvent = (event) => event.type.startsWith("message.");
+var isPollEvent = (event) => event.type === "poll.changed";
+async function* catchUpEvents(client, cursor, isWanted) {
+  const since = toResumeAfter(cursor);
+  if (since === void 0) {
+    return;
+  }
+  for await (const event of client.events.catchUp(since)) {
+    if (event.type === "catchup.complete") {
+      yield event;
+      return;
+    }
+    if (isWanted(event)) {
+      yield event;
+    }
+  }
+}
+var toResumeAfter = (cursor) => {
+  if (!cursor) {
+    return void 0;
+  }
+  const sequence = Number(cursor);
+  return Number.isSafeInteger(sequence) && sequence >= 0 ? sequence : void 0;
+};
+async function* afterCursor(stream2, cursor) {
+  const resumeAfter = toResumeAfter(cursor);
+  try {
+    for await (const event of stream2) {
+      if (resumeAfter !== void 0 && event.sequence <= resumeAfter) {
+        continue;
+      }
+      yield event;
+    }
+  } finally {
+    await stream2.close?.();
+  }
+}
+var withClose = (source, cursor) => Object.assign(afterCursor(source, cursor), {
+  close: async () => {
+    await source.close?.();
+  }
+});
+var messageStream = (client, phone) => resumableOrderedStream({
+  fetchMissed: (cursor) => catchUpEvents(client, cursor, isMessageEvent),
+  isRetryableError: isRetryableIMessageStreamError,
+  processLive: (event) => toMessageItem(client, event, phone, String(event.sequence)),
+  processMissed: (event) => event.type === "catchup.complete" ? Promise.resolve(toCatchUpCompleteItem(event)) : toMessageItem(client, event, phone, String(event.sequence)),
+  subscribeLive: (cursor) => withClose(client.messages.subscribeEvents(), cursor)
+});
+var pollStream = (client, pollCache, phone) => resumableOrderedStream({
+  fetchMissed: (cursor) => catchUpEvents(client, cursor, isPollEvent),
+  isRetryableError: isRetryableIMessageStreamError,
+  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)
+});
+var clientStream = (client, pollCache, phone) => mergeStreams([
+  messageStream(client, phone),
+  pollStream(client, pollCache, phone)
+]);
+var messages3 = (clients) => {
+  const pollCache = getPollCache(clients);
+  return mergeStreams(
+    clients.map((entry) => clientStream(entry.client, pollCache, entry.phone))
+  );
+};
+
+// src/providers/imessage/remote/typing.ts
+var startTyping = async (remote, spaceId) => {
+  await remote.chats.setTyping(toChatGuid(spaceId), true);
+};
+var stopTyping = async (remote, spaceId) => {
+  await remote.chats.setTyping(toChatGuid(spaceId), false);
+};
+
+// src/providers/imessage/remote/api.ts
+var messages4 = (clients) => messages3(clients);
+var startTyping2 = async (remote, spaceId) => {
+  await startTyping(remote, spaceId);
+};
+var stopTyping2 = async (remote, spaceId) => {
+  await stopTyping(remote, spaceId);
+};
+var send4 = async (remote, spaceId, content) => send3(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 getMessage4 = async (remote, spaceId, msgId, phone) => getMessage3(remote, spaceId, msgId, phone);
+
+// src/providers/imessage/remote/client.ts
+var isSharedMode = (clients) => clients.length === 1 && clients[0]?.phone === SHARED_PHONE;
+var availablePhones = (clients) => clients.map((c) => c.phone);
+var clientForPhone = (clients, phone) => {
+  if (isSharedMode(clients)) {
+    const entry2 = clients[0];
+    if (!entry2) {
+      throw new Error("No iMessage clients configured");
+    }
+    return entry2.client;
+  }
+  const entry = clients.find((c) => c.phone === phone);
+  if (!entry) {
+    const list = availablePhones(clients).join(", ") || "<none>";
+    throw new Error(
+      `No iMessage client serves phone ${phone}. Available: ${list}`
+    );
+  }
+  return entry.client;
+};
+var randomPhone = (clients) => {
+  if (clients.length === 0) {
+    throw new Error("No iMessage phones configured for this account");
+  }
+  if (isSharedMode(clients)) {
+    return SHARED_PHONE;
+  }
+  const entry = clients[Math.floor(Math.random() * clients.length)];
+  if (!entry) {
+    throw new Error("No iMessage phones configured for this account");
+  }
+  return entry.phone;
+};
+
+// src/providers/imessage/index.ts
+var isPollContent = (content) => content.type === "poll" || content.type === "poll_option";
+var imessage = definePlatform("iMessage", {
+  config: configSchema,
+  static: {
+    effect: {
+      message: MessageEffect2
+    }
+  },
+  lifecycle: {
+    createClient: async ({
+      config,
+      projectId,
+      projectSecret
+    }) => {
+      if (config.local) {
+        return new IMessageSDK2();
+      }
+      if (config.clients) {
+        const entries = Array.isArray(config.clients) ? config.clients : [config.clients];
+        return entries.map((e) => ({
+          phone: e.phone,
+          client: createClient2({
+            address: e.address,
+            tls: true,
+            token: e.token
+          })
+        }));
+      }
+      if (!(projectId && projectSecret)) {
+        throw new Error(
+          "iMessage requires projectId and projectSecret. Either pass credentials to Spectrum(), use local mode: imessage.config({ local: true }), or provide explicit client config: imessage.config({ clients: [...] })"
+        );
+      }
+      return await createCloudClients(projectId, projectSecret);
+    },
+    destroyClient: async ({ client }) => {
+      if (isLocal(client)) {
+        await client.close();
+        return;
+      }
+      await disposeCloudAuth(client);
+      await Promise.all(client.map((entry) => entry.client.close()));
+    }
+  },
+  user: {
+    resolve: async ({ input }) => ({ id: input.userID })
+  },
+  space: {
+    schema: spaceSchema,
+    params: spaceParamsSchema,
+    resolve: async ({ input, client }) => {
+      if (isLocal(client)) {
+        throw UnsupportedError.action(
+          "createSpace",
+          "iMessage (local mode)",
+          "local mode only supports replying to existing messages"
+        );
+      }
+      if (input.users.length === 0) {
+        throw new Error("iMessage space creation requires at least one user");
+      }
+      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) {
+        return {
+          id: dmChatGuid(addresses[0] ?? ""),
+          type: "dm",
+          phone
+        };
+      }
+      const { chat } = await remote.chats.create(addresses);
+      return { id: chat.guid, type: "group", phone };
+    }
+  },
+  message: {
+    schema: messageSchema
+  },
+  events: {
+    messages: ({ client }) => isLocal(client) ? messages2(client) : messages4(client)
+  },
+  actions: {
+    send: async ({ space, content, client }) => {
+      if (isLocal(client)) {
+        return await send2(client, space.id, content);
+      }
+      const remote = clientForPhone(client, space.phone);
+      return await send4(remote, space.id, content);
+    },
+    startTyping: async ({ space, client }) => {
+      if (isLocal(client)) {
+        return;
+      }
+      const remote = clientForPhone(client, space.phone);
+      await startTyping2(remote, space.id);
+    },
+    stopTyping: async ({ space, client }) => {
+      if (isLocal(client)) {
+        return;
+      }
+      const remote = clientForPhone(client, space.phone);
+      await stopTyping2(remote, space.id);
+    },
+    reactToMessage: async ({ space, target, reaction, client }) => {
+      if (isLocal(client)) {
+        throw UnsupportedError.action("react", "iMessage (local mode)");
+      }
+      if (isPollContent(target.content)) {
+        throw UnsupportedError.action(
+          "react",
+          "iMessage",
+          "iMessage polls do not support reactions"
+        );
+      }
+      const remote = clientForPhone(client, space.phone);
+      await reactToMessage2(
+        remote,
+        space.id,
+        target,
+        reaction
+      );
+    },
+    replyToMessage: async ({ space, messageId, target, content, client }) => {
+      if (isLocal(client)) {
+        throw UnsupportedError.action("reply", "iMessage (local mode)");
+      }
+      if (isPollContent(target.content)) {
+        throw UnsupportedError.action(
+          "reply",
+          "iMessage",
+          "iMessage polls do not support replies"
+        );
+      }
+      const remote = clientForPhone(client, space.phone);
+      return await replyToMessage2(remote, space.id, messageId, content);
+    },
+    editMessage: async ({ space, messageId, content, client }) => {
+      if (isLocal(client)) {
+        throw UnsupportedError.action("edit", "iMessage (local mode)");
+      }
+      const remote = clientForPhone(client, space.phone);
+      await editMessage2(remote, space.id, messageId, content);
+    },
+    getMessage: async ({ space, messageId, client }) => {
+      if (isLocal(client)) {
+        return getMessage2(client, messageId);
+      }
+      const remote = clientForPhone(client, space.phone);
+      return getMessage4(remote, space.id, messageId, space.phone);
+    }
+  }
+});
+
+export {
+  effect,
+  imessage
+};