spectrum-ts 1.3.0 → 1.5.0

package/dist/providers/imessage/index.js

@@ -1,2078 +1,10 @@
 import {
-  asGroup,
-  asRichlink,
-  groupSchema
-} from "../../chunk-66GJ45ZZ.js";
-import {
-  asPoll,
-  asPollOption,
-  cloud,
-  mergeStreams,
-  stream
-} from "../../chunk-FF2R4EP3.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,
-  directChat,
-  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";
-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;
-  if (tokenData.type === "shared") {
-    throw UnsupportedError.action(
-      "multi-phone",
-      "iMessage shared mode",
-      "use dedicated-token cloud mode"
-    );
-  }
-  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);
-        if (tokenData.type === "shared") {
-          throw UnsupportedError.action(
-            "multi-phone",
-            "iMessage shared mode",
-            "use dedicated-token cloud mode"
-          );
-        }
-        tokenExpiresAt = Date.now() + tokenData.expiresIn * 1e3;
-        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);
-    if (tokenData.type === "shared") {
-      throw UnsupportedError.action(
-        "multi-phone",
-        "iMessage shared mode",
-        "use dedicated-token cloud mode"
-      );
-    }
-    tokenExpiresAt = Date.now() + tokenData.expiresIn * 1e3;
-    syncPhones(tokenData);
-    scheduleRenewal();
-  };
-  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/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 toMessages = async (message) => {
-  const { chatId, chatKind } = message;
-  if (!chatId || chatKind === "unknown") {
-    return [];
-  }
-  if (message.reaction !== null || message.kind !== "text" || message.retractedAt !== null) {
-    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 startPromise = client.startWatching({
-    onIncomingMessage: (message) => {
-      lastPromise = lastPromise.then(() => toMessages(message)).then(async (ms) => {
-        for (const m of ms) {
-          await emit(m);
-        }
-      }).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 {
-  messageGuid,
-  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 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 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) => {
-  const raw = message._raw;
-  const id = raw?.balloonBundleId;
-  return typeof id === "string" ? id : void 0;
-};
-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 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,
-  size: info.totalBytes,
-  read: async () => Buffer.from(await client.attachments.downloadBuffer(info.guid)),
-  stream: async () => client.attachments.download(info.guid).stream
-});
-var toVCardContent2 = async (client, info) => {
-  try {
-    const buf = Buffer.from(await client.attachments.downloadBuffer(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.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);
-  if (message.attachments.length === 1) {
-    const info = message.attachments[0];
-    if (!info) {
-      throw new Error("Unreachable: attachments.length === 1 but no element");
-    }
-    return buildAttachmentMessage(client, base, info, messageGuidStr, 0);
-  }
-  if (message.attachments.length > 1) {
-    const items = [];
-    for (let i = 0; i < message.attachments.length; i++) {
-      const info = message.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.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.timestamp,
-    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];
-  }
-  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: messageGuidStr,
-      content: asProviderGroup(items)
-    };
-    cacheMessage(cache, parent);
-    return [parent];
-  }
-  const text2 = event.message.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(
-        messageGuid(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(messageGuid(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
-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, phone) => {
-  let candidate = cache.get(strippedGuid);
-  if (!candidate) {
-    try {
-      const fetched = await client.messages.get(messageGuid2(strippedGuid));
-      candidate = await rebuildFromAppleMessage(client, fetched, phone);
-      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, phone) => {
-  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,
-    phone
-  );
-  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,
-    phone
-  );
-  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, 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 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 receiptGuid = (receipt) => {
-  if (typeof receipt.guid !== "string" || receipt.guid.length === 0) {
-    throw new Error("iMessage send receipt is missing a message guid");
-  }
-  return receipt.guid;
-};
-var outboundRecord = (spaceId, id, content, timestamp, extras) => ({
-  id,
-  content,
-  space: { id: spaceId },
-  timestamp,
-  ...extras
-});
-var withReply = (options, replyTo) => replyTo ? { ...options, replyTo } : options;
-var replyOptions = (replyTo) => replyTo ? { replyTo } : void 0;
-var effectOption = (effect2) => effect2 ? { effect: effect2 } : {};
-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 name = vcardFileName(content);
-  const upload = await sendVCardAttachment(remote, name, vcf);
-  return { guid: upload.guid, name };
-};
-var uploadAttachment = async (remote, content) => {
-  const attachment = await remote.attachments.upload({
-    data: await content.read(),
-    fileName: content.name,
-    mimeType: content.mimeType
-  });
-  return { guid: 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,
-    mimeType: "audio/x-m4a"
-  });
-  return { guid: 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 receipt = await remote.messages.send(
-        chat,
-        content.text,
-        withReply(effectOption(effect2), replyTo)
-      );
-      return outboundRecord(
-        spaceId,
-        receiptGuid(receipt),
-        content,
-        receiptTimestamp(receipt)
-      );
-    }
-    case "richlink": {
-      const receipt = await remote.messages.send(
-        chat,
-        content.url,
-        withReply({ richLink: true }, replyTo)
-      );
-      return outboundRecord(
-        spaceId,
-        receiptGuid(receipt),
-        content,
-        receiptTimestamp(receipt)
-      );
-    }
-    case "attachment": {
-      const { guid } = await uploadAttachment(remote, content);
-      const receipt = await remote.messages.send(chat, "", {
-        attachment: guid,
-        ...effectOption(effect2),
-        ...replyOptions(replyTo)
-      });
-      return outboundRecord(
-        spaceId,
-        receiptGuid(receipt),
-        content,
-        receiptTimestamp(receipt)
-      );
-    }
-    case "contact": {
-      const { guid } = await sendContactAttachment(remote, content);
-      const receipt = await remote.messages.send(chat, "", {
-        attachment: guid,
-        ...replyOptions(replyTo)
-      });
-      return outboundRecord(
-        spaceId,
-        receiptGuid(receipt),
-        content,
-        receiptTimestamp(receipt)
-      );
-    }
-    case "voice": {
-      const { guid } = await uploadVoice(remote, content);
-      const receipt = await remote.messages.send(chat, "", {
-        attachment: guid,
-        audioMessage: true,
-        ...replyOptions(replyTo)
-      });
-      return outboundRecord(
-        spaceId,
-        receiptGuid(receipt),
-        content,
-        receiptTimestamp(receipt)
-      );
-    }
-    case "poll":
-      if (replyTo) {
-        throw unsupportedRemoteContent(
-          "poll",
-          "polls cannot be sent as replies"
-        );
-      }
-      return outboundRecord(
-        spaceId,
-        receiptGuid(
-          await remote.polls.create(
-            chat,
-            content.title,
-            content.options.map((option) => option.title)
-          )
-        ),
-        content,
-        /* @__PURE__ */ new Date()
-      );
-    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 = chatGuid2(spaceId);
-  if (content.type === "group") {
-    validateGroupContent(content);
-    const resolved = await Promise.all(
-      content.items.map((sub) => resolvePart(remote, sub.content))
-    );
-    const receipt = await remote.messages.sendMultipart(
-      chat,
-      resolved.map((part, idx) => ({ ...part, partIndex: idx }))
-    );
-    const parentGuid = receiptGuid(receipt);
-    const timestamp = receiptTimestamp(receipt);
-    const items = content.items.map(
-      (sub, idx) => outboundRecord(
-        spaceId,
-        formatChildId(idx, parentGuid),
-        sub.content,
-        timestamp,
-        { partIndex: idx, parentId: parentGuid }
-      )
-    );
-    return outboundRecord(
-      spaceId,
-      parentGuid,
-      asGroup({ items }),
-      timestamp
-    );
-  }
-  return sendContent(remote, spaceId, chat, content);
-};
-var replyToMessage = async (remote, spaceId, msgId, content) => {
-  const chat = chatGuid2(spaceId);
-  const replyTo = messageGuid3(msgId);
-  return sendContent(remote, spaceId, 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",
-      phone: input.phone
-    },
-    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,
-      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, fallbackOptionIds) => {
-  const info = await fetchPollInfo(client, pollCache, event);
-  if (!info) {
-    return;
-  }
-  const refreshed = pollCache.get(info.messageGuid);
-  if (!refreshed) {
-    return;
-  }
-  return {
-    optionIds: [...fallbackOptionIds],
-    poll: refreshed
-  };
-};
-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.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 (!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.at
-  );
-  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.at)) {
-    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.at);
-  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 pollRetryDelay = (delayMs) => Math.random() * delayMs;
-var isRetryableIMessageStreamError = (error) => {
-  if (error instanceof AuthenticationError || error instanceof NotFoundError2 || error instanceof ValidationError) {
-    return false;
-  }
-  if (error instanceof IMessageError) {
-    return true;
-  }
-  return false;
-};
-var toMessageItem = async (client, event, phone, cursor) => {
-  const id = event.message.guid;
-  if (event.message.isFromMe) {
-    return { cursor, id, values: [] };
-  }
-  const cache = getMessageCache(client);
-  const target = event.message.associatedMessageGuid;
-  const values = target ? await toReactionMessages(client, cache, event, target, phone) : await toInboundMessages(client, cache, event, phone);
-  return { cursor, id, values };
-};
-var messageStream = (client, phone) => resumableOrderedStream({
-  fetchMissed: (cursor, { limit }) => client.messages.fetchMissed(cursor, { limit }),
-  isRetryableError: isRetryableIMessageStreamError,
-  processLive: (event) => toMessageItem(client, event, phone, event.cursor),
-  processMissed: (message) => toMessageItem(client, receivedEventFromMessage(message), phone),
-  subscribeLive: () => client.messages.subscribe("message.received")
-});
-var logPollStreamError = (error) => {
-  console.error("[spectrum-ts][imessage][poll] stream failed", error);
-};
-var emitPollMessages = async (client, pollCache, event, phone, emit) => {
-  cachePollEvent(pollCache, event);
-  if (event.actor.isFromMe) {
-    return;
-  }
-  const messages5 = await toPollDeltaMessages(client, pollCache, event, phone);
-  for (const vote of messages5) {
-    await emit(vote);
-  }
-};
-var runPollSubscription = async (client, pollCache, subscription, phone, emit, onEvent) => {
-  for await (const event of subscription) {
-    onEvent();
-    await emitPollMessages(client, pollCache, event, phone, emit);
-  }
-};
-var pollStream = (client, pollCache, phone) => 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;
-    }
-    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;
-    }
-    wakeSleep?.();
-    wakeSleep = void 0;
-  };
-  const pump = (async () => {
-    while (!closed) {
-      try {
-        await runPollSubscription(
-          client,
-          pollCache,
-          active,
-          phone,
-          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();
-      }
-    }
-    end();
-  })();
-  return async () => {
-    closed = true;
-    cancelSleep();
-    await active.close();
-    await pump;
-  };
-});
-var clientStream = (client, pollCache, phone) => {
-  return 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
-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 (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 availablePhones = (clients) => clients.map((c) => c.phone);
-var clientForPhone = (clients, phone) => {
-  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");
-  }
-  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/types.ts
-import { IMessageSDK } from "@photon-ai/imessage-kit";
-import z2 from "zod";
-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/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 = 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: directChat(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);
-    }
-  }
-});
+  effect,
+  imessage
+} from "../../chunk-4U4RINOV.js";
+import "../../chunk-66GJ45ZZ.js";
+import "../../chunk-L6LUFBLF.js";
+import "../../chunk-LH4YEBG3.js";
 export {
   effect,
   imessage