spectrum-ts 4.1.0 → 5.0.0

package/dist/chunk-DMT6BFJV.js

@@ -1,2980 +0,0 @@
-import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
-import {
-  asRichlink
-} from "./chunk-ZR3TKZMT.js";
-import {
-  asGroup,
-  groupSchema
-} from "./chunk-LZXPLXZF.js";
-import {
-  asPoll,
-  asPollOption
-} from "./chunk-2D27WW5B.js";
-import {
-  cloud
-} from "./chunk-3GEJYGZK.js";
-import {
-  asContact
-} from "./chunk-A37PM5N2.js";
-import {
-  mergeStreams,
-  stream
-} from "./chunk-5XEFJBN2.js";
-import {
-  fromVCard,
-  toVCard
-} from "./chunk-6UZFVXQF.js";
-import {
-  UnsupportedError,
-  buildPhotoAction,
-  definePlatform,
-  markdownSchema,
-  photoActionSchema
-} from "./chunk-B52VPQO3.js";
-import {
-  asAttachment,
-  asCustom,
-  asText,
-  attachmentSchema,
-  reactionSchema,
-  text,
-  textSchema
-} from "./chunk-UXAKIXVM.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";
-import { withSpan } from "@photon-ai/otel";
-
-// src/providers/imessage/content/background.ts
-import z from "zod";
-var backgroundSchema = z.object({
-  type: z.literal("background"),
-  __platform: z.literal("iMessage"),
-  __fireAndForget: z.literal(true),
-  action: photoActionSchema
-});
-var isBackground = (v) => backgroundSchema.safeParse(v).success;
-function background(input, options) {
-  const action = buildPhotoAction(input, options, "background");
-  return {
-    build: async () => backgroundSchema.parse({
-      type: "background",
-      __platform: "iMessage",
-      __fireAndForget: true,
-      action
-    })
-  };
-}
-
-// src/providers/imessage/content/customized-mini-app.ts
-import z2 from "zod";
-var layoutSchema = z2.object({
-  caption: z2.string().nonempty().optional(),
-  subcaption: z2.string().nonempty().optional(),
-  trailingCaption: z2.string().nonempty().optional(),
-  trailingSubcaption: z2.string().nonempty().optional(),
-  image: z2.instanceof(Uint8Array).optional(),
-  imageTitle: z2.string().nonempty().optional(),
-  imageSubtitle: z2.string().nonempty().optional(),
-  summary: z2.string().nonempty().optional()
-}).refine(
-  (layout) => layout.caption !== void 0 || layout.subcaption !== void 0 || layout.trailingCaption !== void 0 || layout.trailingSubcaption !== void 0 || layout.image !== void 0,
-  {
-    message: "layout must set at least one of caption, subcaption, trailingCaption, trailingSubcaption, image"
-  }
-).refine(
-  (layout) => layout.image === void 0 === (layout.imageTitle === void 0),
-  {
-    message: "layout.image and layout.imageTitle must be set together",
-    path: ["imageTitle"]
-  }
-).refine(
-  (layout) => layout.imageSubtitle === void 0 || layout.image !== void 0,
-  {
-    message: "layout.imageSubtitle requires layout.image",
-    path: ["imageSubtitle"]
-  }
-);
-var customizedMiniAppSchema = z2.object({
-  type: z2.literal("customized-mini-app"),
-  __platform: z2.literal("iMessage"),
-  // Display name of the owning app, shown by Messages fallback UI.
-  appName: z2.string().nonempty(),
-  // Apple App Store numeric id of the owning app. Positive when set; omit to
-  // send a card whose extension is not published on the App Store.
-  appStoreId: z2.number().int().positive().optional(),
-  // Bundle identifier of the iMessage extension target.
-  extensionBundleId: z2.string().nonempty(),
-  // Visible card layout.
-  layout: layoutSchema,
-  // 10-character uppercase alphanumeric Apple Team ID.
-  teamId: z2.string(),
-  // Absolute URL delivered to the installed extension on tap.
-  url: z2.url()
-});
-var isCustomizedMiniApp = (v) => customizedMiniAppSchema.safeParse(v).success;
-var asCustomizedMiniApp = (input) => customizedMiniAppSchema.parse({
-  type: "customized-mini-app",
-  __platform: "iMessage",
-  ...input
-});
-function customizedMiniApp(input) {
-  return {
-    build: async () => asCustomizedMiniApp(input)
-  };
-}
-
-// src/providers/imessage/content/effect.ts
-import {
-  MessageEffect
-} from "@photon-ai/advanced-imessage";
-
-// src/content/effect.ts
-import z3 from "zod";
-var effectInnerSchema = z3.discriminatedUnion("type", [
-  textSchema,
-  markdownSchema,
-  attachmentSchema
-]);
-var messageEffectSchema = z3.object({
-  type: z3.literal("effect"),
-  content: effectInnerSchema,
-  effect: z3.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 !== "markdown" && inner.type !== "attachment") {
-        throw new Error(
-          `imessage effect() only supports text, markdown, 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 z4 from "zod";
-var SHARED_PHONE = "shared";
-var isLocal = (client) => client instanceof IMessageSDK;
-var clientEntry = z4.object({
-  address: z4.string(),
-  token: z4.string(),
-  phone: z4.string()
-});
-var configSchema = z4.union([
-  z4.object({ local: z4.literal(true) }),
-  z4.object({
-    local: z4.literal(false).optional().default(false),
-    clients: clientEntry.or(z4.array(clientEntry)).optional()
-  })
-]);
-var userSchema = z4.object({});
-var spaceSchema = z4.object({
-  id: z4.string(),
-  type: z4.enum(["dm", "group"]),
-  phone: z4.string()
-});
-var spaceParamsSchema = z4.object({
-  phone: z4.string().optional()
-});
-var messageSchema = z4.object({
-  partIndex: z4.number().int().nonnegative().optional(),
-  parentId: z4.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/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;
-  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);
-      }
-    }
-  }
-  clear() {
-    this.map.clear();
-  }
-};
-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/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({
-    id: att.id,
-    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/ids.ts
-var PART_PREFIX = /^p:(\d+)\//;
-var dmChatGuid = (address) => `any;-;${address}`;
-var chatTypeFromGuid = (guid) => guid.includes(";+;") ? "group" : "dm";
-var toChatGuid = (value) => value;
-var toMessageGuid = (value) => value;
-var formatChildId = (partIndex, parentGuid) => `p:${partIndex}/${parentGuid}`;
-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/avatar.ts
-var setIcon = async (remote, spaceId, content) => {
-  const chat = toChatGuid(spaceId);
-  if (content.action.kind === "clear") {
-    await remote.groups.removeIcon(chat);
-    return;
-  }
-  const buffer = await content.action.read();
-  await remote.groups.setIcon(
-    chat,
-    new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)
-  );
-};
-
-// src/providers/imessage/remote/background.ts
-var setBackground = async (remote, spaceId, content) => {
-  const chat = toChatGuid(spaceId);
-  if (content.action.kind === "clear") {
-    await remote.chats.removeBackground(chat);
-    return;
-  }
-  const buffer = await content.action.read();
-  await remote.chats.setBackground(
-    chat,
-    new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)
-  );
-};
-
-// src/providers/imessage/remote/customized-mini-app.ts
-var sendCustomizedMiniApp = async (remote, spaceId, content) => {
-  const chat = toChatGuid(spaceId);
-  const message = await remote.messages.sendCustomizedMiniApp(chat, content);
-  return {
-    id: message.guid,
-    content,
-    direction: "outbound",
-    space: { id: spaceId },
-    timestamp: message.dateCreated
-  };
-};
-
-// src/providers/imessage/remote/inbound.ts
-import {
-  NotFoundError as NotFoundError2
-} from "@photon-ai/advanced-imessage";
-
-// src/providers/imessage/remote/attachments.ts
-import {
-  NotFoundError
-} from "@photon-ai/advanced-imessage";
-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 getRemoteAttachment = async (client, guid) => {
-  let info;
-  try {
-    info = await client.attachments.get(guid);
-  } catch (err) {
-    if (err instanceof NotFoundError) {
-      return;
-    }
-    throw err;
-  }
-  return asAttachment({
-    id: info.guid,
-    name: info.fileName,
-    mimeType: info.mimeType,
-    size: info.totalBytes,
-    read: () => downloadPrimaryAttachment(client, info.guid),
-    stream: async () => downloadPrimaryAttachmentStream(client, info.guid)
-  });
-};
-
-// 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.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 {
-    direction: message.isFromMe ? "outbound" : "inbound",
-    sender: { id: resolveSenderId(message) },
-    space: {
-      id: chat,
-      type: chatTypeFromGuid(chat),
-      phone
-    },
-    timestamp
-  };
-};
-var toAttachmentContent2 = (client, info) => asAttachment({
-  id: info.guid,
-  name: info.fileName,
-  mimeType: info.mimeType,
-  size: info.totalBytes,
-  read: async () => await downloadPrimaryAttachment(client, info.guid),
-  stream: async () => downloadPrimaryAttachmentStream(client, info.guid)
-});
-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(
-        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 NotFoundError2) {
-        return;
-      }
-      throw err;
-    }
-  }
-  try {
-    const fetched = await remote.messages.get(toMessageGuid(msgId));
-    const rebuilt = await rebuildFromAppleMessage(
-      remote,
-      fetched,
-      phone,
-      spaceId
-    );
-    cacheMessage(cache, rebuilt);
-    return rebuilt;
-  } catch (err) {
-    if (err instanceof NotFoundError2) {
-      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(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: chatTypeFromGuid(event.chatGuid),
-        phone
-      },
-      timestamp: event.occurredAt,
-      id: `${event.messageGuid}:reaction:${event.sequence}${partSuffix}`,
-      content: asProviderReaction(emoji, resolved)
-    }
-  ];
-};
-var toSettableReaction = (emoji) => {
-  const native = EMOJI_TO_TAPBACK[emoji];
-  return native ? { kind: native } : { kind: "emoji", emoji };
-};
-var tapbackTarget = (target) => ({
-  guid: toMessageGuid(target.parentId ?? target.id),
-  opts: typeof target.partIndex === "number" ? { partIndex: target.partIndex } : void 0
-});
-var reactToMessage = async (remote, spaceId, target, reaction) => {
-  const { guid, opts } = tapbackTarget(target);
-  const sent = await remote.messages.setReaction(
-    toChatGuid(spaceId),
-    guid,
-    toSettableReaction(reaction),
-    true,
-    opts
-  );
-  return {
-    id: sent.guid,
-    content: asProviderReaction(reaction, target),
-    direction: "outbound",
-    space: { id: spaceId },
-    timestamp: sent.dateCreated
-  };
-};
-var unsendReaction = async (remote, spaceId, target, reaction) => {
-  const { guid, opts } = tapbackTarget(target);
-  await remote.messages.setReaction(
-    toChatGuid(spaceId),
-    guid,
-    toSettableReaction(reaction),
-    false,
-    opts
-  );
-};
-
-// src/providers/imessage/remote/read.ts
-var markRead = async (remote, spaceId) => {
-  await remote.chats.markRead(toChatGuid(spaceId));
-};
-
-// src/providers/imessage/remote/rename.ts
-var setDisplayName = async (remote, spaceId, content) => {
-  await remote.groups.setDisplayName(toChatGuid(spaceId), content.displayName);
-};
-
-// 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;
-  }
-};
-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;
-  }
-  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/markdown.ts
-import { Marked } from "marked";
-var markdownLexer = new Marked();
-var BULLET = "\u2022 ";
-var HR_LINE = "\u2014\u2014\u2014";
-var NESTED_LIST_INDENT = "  ";
-var BLOCK_SEPARATOR = "\n\n";
-var TABLE_CELL_SEPARATOR = " | ";
-var DEFAULT_LIST_START = 1;
-var LEADING_WHITESPACE = /^\s+/;
-var TRAILING_WHITESPACE = /\s+$/;
-var MONOSPACE_UPPER_A = 120432;
-var MONOSPACE_LOWER_A = 120458;
-var MONOSPACE_DIGIT_ZERO = 120822;
-var UPPER_A = 65;
-var UPPER_Z = 90;
-var LOWER_A = 97;
-var LOWER_Z = 122;
-var DIGIT_ZERO = 48;
-var DIGIT_NINE = 57;
-var monospaceCodePoint = (codePoint) => {
-  if (codePoint >= UPPER_A && codePoint <= UPPER_Z) {
-    return MONOSPACE_UPPER_A + (codePoint - UPPER_A);
-  }
-  if (codePoint >= LOWER_A && codePoint <= LOWER_Z) {
-    return MONOSPACE_LOWER_A + (codePoint - LOWER_A);
-  }
-  if (codePoint >= DIGIT_ZERO && codePoint <= DIGIT_NINE) {
-    return MONOSPACE_DIGIT_ZERO + (codePoint - DIGIT_ZERO);
-  }
-  return codePoint;
-};
-var toMonospace = (text2) => {
-  let out = "";
-  for (const char of text2) {
-    const codePoint = char.codePointAt(0);
-    out += codePoint === void 0 ? char : String.fromCodePoint(monospaceCodePoint(codePoint));
-  }
-  return out;
-};
-var STYLE_ORDER = ["bold", "italic", "strikethrough"];
-var plain = (text2) => ({ text: text2, styles: [] });
-var withStyle = (spans, style) => spans.map(
-  (span) => span.styles.includes(style) ? span : { ...span, styles: [...span.styles, style] }
-);
-var asLink = (spans) => spans.map((span) => ({ ...span, link: true }));
-var spanText = (spans) => {
-  let out = "";
-  for (const span of spans) {
-    out += span.text;
-  }
-  return out;
-};
-var joinSpans = (blocks, separator) => {
-  const out = [];
-  for (const [index, block] of blocks.entries()) {
-    if (index > 0) {
-      out.push(plain(separator));
-    }
-    out.push(...block);
-  }
-  return out;
-};
-var splitSpanLines = (spans) => {
-  let current = [];
-  const lines = [current];
-  for (const span of spans) {
-    const parts = span.text.split("\n");
-    for (const [index, part] of parts.entries()) {
-      if (index > 0) {
-        current = [];
-        lines.push(current);
-      }
-      if (part) {
-        current.push({ ...span, text: part });
-      }
-    }
-  }
-  return lines;
-};
-var asMarkedToken = (token) => token;
-var checkboxPrefix = (item) => {
-  if (!item.task) {
-    return "";
-  }
-  return item.checked ? "[x] " : "[ ] ";
-};
-var listMarker = (list, index) => {
-  if (!list.ordered) {
-    return BULLET;
-  }
-  const start = list.start === "" ? DEFAULT_LIST_START : list.start;
-  return `${start + index}. `;
-};
-var renderLink = (token) => {
-  if (token.text === token.href) {
-    return [{ text: token.href, styles: [], link: true }];
-  }
-  return [
-    ...asLink(renderInlineTokens(token.tokens)),
-    { text: ` (${token.href})`, styles: [], link: true }
-  ];
-};
-var renderImage = (token) => [
-  {
-    text: token.text ? `${token.text} (${token.href})` : token.href,
-    styles: [],
-    link: true
-  }
-];
-var renderInlineToken = (token) => {
-  switch (token.type) {
-    case "strong":
-      return withStyle(renderInlineTokens(token.tokens), "bold");
-    case "em":
-      return withStyle(renderInlineTokens(token.tokens), "italic");
-    case "del":
-      return withStyle(renderInlineTokens(token.tokens), "strikethrough");
-    case "codespan":
-      return [plain(toMonospace(token.text))];
-    case "br":
-      return [plain("\n")];
-    case "link":
-      return renderLink(token);
-    case "image":
-      return renderImage(token);
-    case "escape":
-      return [plain(token.text)];
-    case "text":
-      return token.tokens ? renderInlineTokens(token.tokens) : [plain(token.text)];
-    // Raw HTML in markdown source stays literal — styled text has no markup.
-    case "html":
-      return [plain(token.text)];
-    // Task-item checkboxes are rendered from `ListItem.task`/`checked`.
-    case "checkbox":
-      return [];
-    default:
-      return "raw" in token ? [plain(String(token.raw))] : [];
-  }
-};
-var renderInlineTokens = (tokens) => {
-  const out = [];
-  for (const token of tokens) {
-    out.push(...renderInlineToken(asMarkedToken(token)));
-  }
-  return out;
-};
-var renderBlockquote = (quote) => {
-  const lines = splitSpanLines(renderBlockTokens(quote.tokens));
-  const out = [];
-  for (const [index, line] of lines.entries()) {
-    if (index > 0) {
-      out.push(plain("\n"));
-    }
-    out.push(plain(line.length > 0 ? "> " : ">"), ...line);
-  }
-  return out;
-};
-var renderList = (list) => {
-  const out = [];
-  for (const [index, item] of list.items.entries()) {
-    const prefix = `${listMarker(list, index)}${checkboxPrefix(item)}`;
-    const blocks = [];
-    for (const token of item.tokens) {
-      const rendered = renderBlockToken(asMarkedToken(token));
-      if (spanText(rendered)) {
-        blocks.push(rendered);
-      }
-    }
-    const [first = [], ...rest] = splitSpanLines(joinSpans(blocks, "\n"));
-    if (out.length > 0) {
-      out.push(plain("\n"));
-    }
-    out.push(plain(prefix), ...first);
-    for (const line of rest) {
-      out.push(plain(`
-${NESTED_LIST_INDENT}`), ...line);
-    }
-  }
-  return out;
-};
-var renderTable = (table) => {
-  const out = [];
-  const pushRow = (cells, rowIndex) => {
-    if (rowIndex > 0) {
-      out.push(plain("\n"));
-    }
-    for (const [cellIndex, cell] of cells.entries()) {
-      if (cellIndex > 0) {
-        out.push(plain(TABLE_CELL_SEPARATOR));
-      }
-      out.push(...renderInlineTokens(cell.tokens));
-    }
-  };
-  pushRow(table.header, 0);
-  for (const [index, row] of table.rows.entries()) {
-    pushRow(row, index + 1);
-  }
-  return out;
-};
-var renderBlockToken = (token) => {
-  switch (token.type) {
-    // iMessage formatting has no heading sizes; bold is the conventional
-    // stand-in (Telegram precedent).
-    case "heading":
-      return withStyle(renderInlineTokens(token.tokens), "bold");
-    case "paragraph":
-      return renderInlineTokens(token.tokens);
-    case "code":
-      return [plain(toMonospace(token.text))];
-    case "blockquote":
-      return renderBlockquote(token);
-    case "list":
-      return renderList(token);
-    case "table":
-      return renderTable(token);
-    case "hr":
-      return [plain(HR_LINE)];
-    case "space":
-    case "def":
-      return [];
-    default:
-      return renderInlineToken(token);
-  }
-};
-var renderBlockTokens = (tokens) => {
-  const blocks = [];
-  for (const token of tokens) {
-    const rendered = renderBlockToken(asMarkedToken(token));
-    if (spanText(rendered)) {
-      blocks.push(rendered);
-    }
-  }
-  return joinSpans(blocks, BLOCK_SEPARATOR);
-};
-var trimSpans = (spans) => {
-  const trimmed = [...spans];
-  while (trimmed.length > 0) {
-    const first = trimmed.at(0);
-    const text2 = first?.text.replace(LEADING_WHITESPACE, "");
-    if (first && text2) {
-      trimmed[0] = { ...first, text: text2 };
-      break;
-    }
-    trimmed.shift();
-  }
-  while (trimmed.length > 0) {
-    const last = trimmed.at(-1);
-    const text2 = last?.text.replace(TRAILING_WHITESPACE, "");
-    if (last && text2) {
-      trimmed[trimmed.length - 1] = { ...last, text: text2 };
-      break;
-    }
-    trimmed.pop();
-  }
-  return trimmed;
-};
-var finalize = (spans) => {
-  let text2 = "";
-  let hasLinks = false;
-  const open = /* @__PURE__ */ new Map();
-  const ranges = [];
-  const close = (style, end) => {
-    const start = open.get(style);
-    open.delete(style);
-    if (start !== void 0 && end > start) {
-      ranges.push({ type: style, start, length: end - start });
-    }
-  };
-  for (const span of spans) {
-    if (!span.text) {
-      continue;
-    }
-    hasLinks ||= span.link === true;
-    const offset = text2.length;
-    for (const style of STYLE_ORDER) {
-      if (span.styles.includes(style)) {
-        if (!open.has(style)) {
-          open.set(style, offset);
-        }
-      } else {
-        close(style, offset);
-      }
-    }
-    text2 += span.text;
-  }
-  for (const style of STYLE_ORDER) {
-    close(style, text2.length);
-  }
-  ranges.sort(
-    (a, b) => a.start - b.start || STYLE_ORDER.indexOf(a.type) - STYLE_ORDER.indexOf(b.type)
-  );
-  return { text: text2, formatting: ranges, hasLinks };
-};
-var markdownToIMessageText = (markdown) => finalize(trimSpans(renderBlockTokens(markdownLexer.lexer(markdown))));
-
-// src/providers/imessage/remote/send.ts
-var GROUP_ITEM_ALLOWED = /* @__PURE__ */ new Set([
-  "text",
-  "markdown",
-  "attachment",
-  "contact",
-  "voice"
-]);
-var GROUP_TEXT_TYPES = /* @__PURE__ */ new Set([
-  "text",
-  "markdown"
-]);
-var MAX_GROUP_TEXT_ITEMS = 1;
-var outboundRecord = (spaceId, id, content, timestamp, extras) => ({
-  id,
-  content,
-  direction: "outbound",
-  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 formattingOption = (formatting) => formatting.length > 0 ? { formatting } : {};
-var dataDetectionOption = (hasLinks) => hasLinks ? { enableDataDetection: true } : {};
-var renderMarkdown = (markdown) => {
-  const rendered = markdownToIMessageText(markdown);
-  if (!rendered.text) {
-    throw unsupportedRemoteContent(
-      "markdown",
-      "renders to empty text \u2014 nothing to send"
-    );
-  }
-  return rendered;
-};
-var replyTargetFromId = (messageId) => {
-  const childRef = parseChildId(messageId);
-  if (childRef) {
-    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 "markdown": {
-      const rendered = renderMarkdown(content.markdown);
-      const message = await remote.messages.sendText(
-        chat,
-        rendered.text,
-        withReply(
-          {
-            ...effectOption(effect2),
-            ...formattingOption(rendered.formatting),
-            ...dataDetectionOption(rendered.hasLinks)
-          },
-          replyTo
-        )
-      );
-      return outboundMessage(spaceId, message, content);
-    }
-    case "richlink": {
-      const message = await remote.messages.sendText(
-        chat,
-        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 (GROUP_TEXT_TYPES.has(itemType) && ++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 "markdown": {
-      const rendered = renderMarkdown(content.markdown);
-      return { text: rendered.text, ...formattingOption(rendered.formatting) };
-    }
-    case "attachment": {
-      const { guid, name } = await uploadAttachment(remote, content);
-      return { attachmentGuid: guid, attachmentName: name };
-    }
-    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
-  );
-};
-var unsendMessage = async (remote, spaceId, msgId) => {
-  const childRef = parseChildId(msgId);
-  await remote.messages.unsend(
-    toChatGuid(spaceId),
-    toMessageGuid(childRef?.parentGuid ?? msgId),
-    childRef ? { partIndex: childRef.partIndex } : void 0
-  );
-};
-
-// src/providers/imessage/remote/stream.ts
-import {
-  ValidationError
-} from "@photon-ai/advanced-imessage";
-import { sanitizePhone } from "@photon-ai/otel";
-
-// src/utils/resumable-stream.ts
-import { createLogger } from "@photon-ai/otel";
-var CATCH_UP_PAGE_SIZE = 100;
-var MAX_BUFFERED_LIVE_EVENTS = 1e3;
-var RECONNECT_INITIAL_DELAY_MS = 500;
-var RECONNECT_MAX_DELAY_MS = 3e4;
-var PERSISTENT_FAILURE_ERROR_THRESHOLD = 5;
-var log = createLogger("spectrum.stream");
-var RetryableStreamError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "RetryableStreamError";
-  }
-};
-var LiveBufferOverflowError = class extends RetryableStreamError {
-  constructor(limit) {
-    super(`Live stream buffer exceeded ${limit} events during catch-up`);
-    this.name = "LiveBufferOverflowError";
-  }
-};
-var CursorRejectedError = class extends Error {
-  constructor(cause) {
-    super("Server rejected resume cursor", { cause });
-    this.name = "CursorRejectedError";
-  }
-};
-var closeIterable = async (iterable) => {
-  if (!iterable) {
-    return;
-  }
-  await iterable.close?.();
-};
-var ignoreCleanupError = () => void 0;
-var jitterDelay = (delayMs) => delayMs * (0.5 + Math.random() * 0.5);
-var errorMessage = (error) => error instanceof Error ? error.message : String(error);
-async function* throwOnCursorRejection(source, isCursorRejected) {
-  try {
-    yield* source;
-  } catch (error) {
-    throw isCursorRejected(error) ? new CursorRejectedError(error) : error;
-  }
-}
-var numericCursor = (cursor) => {
-  if (!cursor) {
-    return;
-  }
-  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;
-  const jitter = options.jitter ?? jitterDelay;
-  const label = options.label;
-  let activeLive;
-  let closed = false;
-  let failedAttempts = 0;
-  let lastCursor;
-  let retryDelayMs = initialRetryDelayMs;
-  let sleepTimer;
-  let wakeSleep;
-  const deliveredSinceCursor = /* @__PURE__ */ new Set();
-  const noteRecovery = () => {
-    retryDelayMs = initialRetryDelayMs;
-    if (failedAttempts === 0) {
-      return;
-    }
-    log.info("stream recovered", { attempts: failedAttempts, label });
-    failedAttempts = 0;
-  };
-  const advanceCursor = (cursor, clearDelivered) => {
-    if (!cursor || cursor === lastCursor || isCursorRegression(cursor, lastCursor)) {
-      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) {
-      noteRecovery();
-    }
-  };
-  const isCursorRejected = (error) => options.isCursorRejectedError?.(error) === true;
-  const sleep2 = async (delayMs) => {
-    if (delayMs <= 0 || closed) {
-      return;
-    }
-    await new Promise((resolve) => {
-      wakeSleep = resolve;
-      sleepTimer = setTimeout(resolve, jitter(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 handleFailure = (error) => {
-    failedAttempts += 1;
-    const delayMs = nextRetryDelay();
-    if (error instanceof CursorRejectedError) {
-      lastCursor = void 0;
-      deliveredSinceCursor.clear();
-      log.warn(
-        "resume cursor rejected; accepting event gap and resuming live",
-        {
-          attempt: failedAttempts,
-          delayMs,
-          error: errorMessage(error.cause),
-          label
-        }
-      );
-      return delayMs;
-    }
-    const attrs = {
-      attempt: failedAttempts,
-      delayMs,
-      error: errorMessage(error),
-      hasCursor: lastCursor !== void 0,
-      label
-    };
-    if (failedAttempts >= PERSISTENT_FAILURE_ERROR_THRESHOLD) {
-      log.error("stream persistently failing; still retrying", attrs, error);
-      return delayMs;
-    }
-    log.warn("stream interrupted; reconnecting", attrs);
-    return delayMs;
-  };
-  const consumeLive = async () => {
-    const live = options.subscribeLive(lastCursor);
-    activeLive = live;
-    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) => {
-    const missed = throwOnCursorRejection(
-      options.fetchMissed(cursor, { limit: catchUpPageSize }),
-      isCursorRejected
-    );
-    for await (const event of missed) {
-      throwLiveError(getLiveError());
-      await deliverItem(await options.processMissed(event), false, false);
-    }
-    throwLiveError(getLiveError());
-  };
-  const flushLiveBuffer = async (liveBuffer, getLiveError, stopBuffering) => {
-    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());
-    compactDeliveredIds(lastFlushedId);
-    stopBuffering();
-  };
-  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);
-      await flushLiveBuffer(liveBuffer, livePump.getError, () => {
-        buffering = false;
-      });
-      noteRecovery();
-      await livePump.pump;
-      throwLiveError(livePump.getError());
-    } finally {
-      buffering = false;
-      if (activeLive === live) {
-        activeLive = void 0;
-      }
-      await closeIterable(live);
-      await livePump.pump.catch(ignoreCleanupError);
-    }
-  };
-  const run = async () => {
-    while (!closed) {
-      try {
-        if (lastCursor) {
-          await catchUpThenConsumeLive(lastCursor);
-        } else {
-          await consumeLive();
-        }
-      } catch (error) {
-        await closeIterable(activeLive).catch(ignoreCleanupError);
-        activeLive = void 0;
-        if (closed) {
-          break;
-        }
-        await sleep2(handleFailure(error));
-      }
-    }
-    end();
-  };
-  const pump = run().catch((error) => {
-    log.error("resumable stream loop crashed", { label }, error);
-    if (!closed) {
-      end(error);
-    }
-  });
-  return async () => {
-    closed = true;
-    cancelSleep();
-    await closeIterable(activeLive);
-    await pump.catch(ignoreCleanupError);
-  };
-});
-
-// src/providers/imessage/remote/contact-share.ts
-import { sanitizeErrorMessage } from "@photon-ai/otel";
-import { LRUCache } from "lru-cache";
-var SHARE_TTL_MS = 24 * 60 * 60 * 1e3;
-var MAX_TRACKED_CHATS = 1e4;
-var ContactShareTracker = class {
-  cache = new LRUCache({
-    max: MAX_TRACKED_CHATS,
-    ttl: SHARE_TTL_MS,
-    ttlAutopurge: false
-  });
-  /**
-   * Best-effort share. The cache is set eagerly so that a burst of inbound
-   * messages for the same chat coalesces to a single API call. On failure the
-   * entry is evicted so the next inbound retries — transient errors don't
-   * permanently mute the feature for a chat. Never awaits and never throws:
-   * the receive stream must not crash on share failures.
-   */
-  maybeShare(client, chatGuid) {
-    if (this.cache.has(chatGuid)) {
-      return;
-    }
-    this.cache.set(chatGuid, true);
-    const safeChatGuid = sanitizeErrorMessage(chatGuid);
-    client.chats.shareContactInfo(chatGuid).then(() => {
-      console.info(
-        `[spectrum-ts][imessage][contact-share] shared contact info to ${safeChatGuid}`
-      );
-    }).catch((error) => {
-      this.cache.delete(chatGuid);
-      console.warn(
-        `[spectrum-ts][imessage][contact-share] failed to share contact info to ${safeChatGuid}`,
-        error
-      );
-    });
-  }
-};
-var trackers = /* @__PURE__ */ new WeakMap();
-var getContactShareTracker = (owner) => {
-  let tracker = trackers.get(owner);
-  if (!tracker) {
-    tracker = new ContactShareTracker();
-    trackers.set(owner, tracker);
-  }
-  return tracker;
-};
-
-// 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 cached = cache.get(event.pollMessageGuid);
-  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: chatTypeFromGuid(input.chatGuid),
-      phone: input.phone
-    },
-    timestamp: input.event.occurredAt,
-    content: asPollOption({
-      option,
-      poll: input.cached.poll,
-      selected: input.selected
-    })
-  };
-};
-var refreshPollMetadata = async (client, pollCache, event) => {
-  const info = await fetchPollInfo(client, pollCache, event);
-  if (!info) {
-    return;
-  }
-  return pollCache.get(info.pollMessageGuid);
-};
-var toPollOptionMessage = async (client, pollCache, event, phone) => {
-  const senderAddress = event.actor?.address;
-  const optionId = event.delta.optionIdentifier;
-  if (!(senderAddress && optionId)) {
-    return [];
-  }
-  let cached = await resolvePoll(client, pollCache, event);
-  if (!cached) {
-    return [];
-  }
-  if (!cached.optionsByIdentifier.has(optionId)) {
-    const refreshed = await refreshPollMetadata(client, pollCache, event);
-    if (refreshed) {
-      cached = refreshed;
-    }
-  }
-  const message = buildPollOptionMessage({
-    cached,
-    chatGuid: event.chatGuid,
-    event,
-    optionId,
-    phone,
-    selected: event.delta.type === "voted",
-    senderAddress
-  });
-  return message ? [message] : [];
-};
-var toPollDeltaMessages = async (client, pollCache, event, phone) => {
-  if (isVotedPollEvent(event)) {
-    return toPollOptionMessage(client, pollCache, event, phone);
-  }
-  if (isUnvotedPollEvent(event)) {
-    return toPollOptionMessage(client, pollCache, event, phone);
-  }
-  return [];
-};
-
-// src/providers/imessage/remote/stream.ts
-var isCursorRejectedIMessageError = (error) => error instanceof ValidationError;
-var streamLabel = (kind, phone) => `imessage.${kind}:${phone === SHARED_PHONE ? phone : sanitizePhone(phone)}`;
-var isEventFromCurrentAccount = (event, phone) => event.isFromMe || phone !== SHARED_PHONE && event.actor?.address !== void 0 && event.actor.address === phone;
-var toMessageItem = async (client, event, phone, cursor, onInbound) => {
-  if (event.type === "message.received") {
-    if (event.message.isFromMe) {
-      return { cursor, id: event.message.guid, values: [] };
-    }
-    const inboundChatGuid = event.message.chatGuids?.[0];
-    if (inboundChatGuid) {
-      onInbound?.(inboundChatGuid);
-    }
-    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;
-  }
-  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, onInbound) => resumableOrderedStream({
-  fetchMissed: (cursor) => catchUpEvents(client, cursor, isMessageEvent),
-  isCursorRejectedError: isCursorRejectedIMessageError,
-  label: streamLabel("messages", phone),
-  processLive: (event) => toMessageItem(client, event, phone, String(event.sequence), onInbound),
-  processMissed: (event) => event.type === "catchup.complete" ? Promise.resolve(toCatchUpCompleteItem(event)) : toMessageItem(
-    client,
-    event,
-    phone,
-    String(event.sequence),
-    onInbound
-  ),
-  subscribeLive: (cursor) => withClose(client.messages.subscribeEvents(), cursor)
-});
-var pollStream = (client, pollCache, phone) => resumableOrderedStream({
-  fetchMissed: (cursor) => catchUpEvents(client, cursor, isPollEvent),
-  isCursorRejectedError: isCursorRejectedIMessageError,
-  label: streamLabel("polls", phone),
-  processLive: (event) => toPollItem(client, pollCache, event, phone, String(event.sequence)),
-  processMissed: (event) => event.type === "catchup.complete" ? Promise.resolve(toCatchUpCompleteItem(event)) : toPollItem(client, pollCache, event, phone, String(event.sequence)),
-  subscribeLive: (cursor) => withClose(client.polls.subscribeEvents(), cursor)
-});
-var clientStream = (client, pollCache, phone, onInbound) => mergeStreams([
-  messageStream(client, phone, onInbound),
-  pollStream(client, pollCache, phone)
-]);
-var messages3 = (clients, projectConfig) => {
-  const pollCache = getPollCache(clients);
-  const shareEnabled = projectConfig?.profile?.imessageSynced === true;
-  const tracker = shareEnabled ? getContactShareTracker(clients) : void 0;
-  return mergeStreams(
-    clients.map(
-      (entry) => clientStream(
-        entry.client,
-        pollCache,
-        entry.phone,
-        tracker ? (chatGuid) => tracker.maybeShare(entry.client, chatGuid) : void 0
-      )
-    )
-  );
-};
-
-// src/providers/imessage/remote/stream-text.ts
-var INITIAL_THROTTLE_MS = 1e3;
-var BACKOFF_FACTOR = 2;
-var MAX_EDITS = 5;
-var sendStreamText = async (remote, spaceId, content) => {
-  if (content.format === "markdown") {
-    throw unsupportedRemoteContent(
-      "streamText",
-      "markdown-formatted streams have no native iMessage delivery"
-    );
-  }
-  const chat = toChatGuid(spaceId);
-  let sent;
-  let full = "";
-  let lastSentText = "";
-  let lastEditAt = 0;
-  let editCount = 0;
-  const flushEdit = async (text2) => {
-    if (!sent || text2 === lastSentText) {
-      return;
-    }
-    await remote.messages.edit(chat, toMessageGuid(sent.guid), text2);
-    lastSentText = text2;
-    lastEditAt = Date.now();
-    editCount += 1;
-  };
-  for await (const delta of content.stream()) {
-    full += delta;
-    if (!sent) {
-      sent = await remote.messages.sendText(chat, full);
-      lastSentText = full;
-      lastEditAt = Date.now();
-      continue;
-    }
-    const hasBudgetForInterimEdit = editCount < MAX_EDITS - 1;
-    const requiredGap = INITIAL_THROTTLE_MS * BACKOFF_FACTOR ** editCount;
-    if (hasBudgetForInterimEdit && Date.now() - lastEditAt >= requiredGap) {
-      await flushEdit(full);
-    }
-  }
-  if (!sent) {
-    throw unsupportedRemoteContent(
-      "streamText",
-      "stream produced no text \u2014 nothing to send"
-    );
-  }
-  await flushEdit(full);
-  return {
-    id: sent.guid,
-    content: asText(full),
-    direction: "outbound",
-    space: { id: spaceId },
-    timestamp: sent.dateCreated
-  };
-};
-
-// 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, projectConfig) => messages3(clients, projectConfig);
-var setBackground2 = async (remote, spaceId, content) => setBackground(remote, spaceId, content);
-var sendCustomizedMiniApp2 = async (remote, spaceId, content) => sendCustomizedMiniApp(remote, spaceId, content);
-var setDisplayName2 = async (remote, spaceId, content) => setDisplayName(remote, spaceId, content);
-var setIcon2 = async (remote, spaceId, content) => setIcon(remote, spaceId, content);
-var markRead2 = async (remote, spaceId) => {
-  await markRead(remote, spaceId);
-};
-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 sendStreamText2 = async (remote, spaceId, content) => sendStreamText(remote, spaceId, content);
-var replyToMessage2 = async (remote, spaceId, msgId, content) => replyToMessage(remote, spaceId, msgId, content);
-var editMessage2 = async (remote, spaceId, msgId, content) => editMessage(remote, spaceId, msgId, content);
-var reactToMessage2 = async (remote, spaceId, target, reaction) => reactToMessage(remote, spaceId, target, reaction);
-var unsendMessage2 = async (remote, spaceId, msgId) => unsendMessage(remote, spaceId, msgId);
-var unsendReaction2 = async (remote, spaceId, target, reaction) => unsendReaction(remote, spaceId, target, reaction);
-var getMessage4 = async (remote, spaceId, msgId, phone) => getMessage3(remote, spaceId, msgId, phone);
-
-// src/providers/imessage/remote/client.ts
-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 cacheRemoteOutbound = (remote, space, record) => {
-  if (!record) {
-    return record;
-  }
-  cacheMessage(getMessageCache(remote), {
-    ...record,
-    direction: record.direction ?? "outbound",
-    space: {
-      ...record.space,
-      id: record.space.id,
-      phone: space.phone,
-      type: space.type
-    }
-  });
-  return record;
-};
-var handleEdit = async (client, space, content) => {
-  if (isLocal(client)) {
-    throw UnsupportedError.action("edit", "iMessage (local mode)");
-  }
-  if (content.content.type !== "text") {
-    throw UnsupportedError.content(
-      "edit",
-      "iMessage",
-      `only text content can be edited (got "${content.content.type}")`
-    );
-  }
-  const remote = clientForPhone(client, space.phone);
-  await editMessage2(remote, space.id, content.target.id, content.content);
-};
-var handleUnsend = async (client, space, content) => {
-  if (isLocal(client)) {
-    throw UnsupportedError.action("unsend", "iMessage (local mode)");
-  }
-  if (isPollContent(content.target.content)) {
-    throw UnsupportedError.action(
-      "unsend",
-      "iMessage",
-      "iMessage polls cannot be unsent"
-    );
-  }
-  const remote = clientForPhone(client, space.phone);
-  const targetContent = content.target.content;
-  if (targetContent.type === "reaction") {
-    await unsendReaction2(
-      remote,
-      space.id,
-      targetContent.target,
-      targetContent.emoji
-    );
-    return;
-  }
-  await unsendMessage2(remote, space.id, content.target.id);
-};
-var handleStreamText = async (client, space, content) => {
-  if (isLocal(client)) {
-    throw UnsupportedError.action(
-      "streamText",
-      "iMessage (local mode)",
-      "streaming text responses require remote iMessage"
-    );
-  }
-  const remote = clientForPhone(client, space.phone);
-  return cacheRemoteOutbound(
-    remote,
-    space,
-    await sendStreamText2(remote, space.id, content)
-  );
-};
-var handleBackground = async (client, space, content) => {
-  if (isLocal(client)) {
-    throw UnsupportedError.action(
-      "background",
-      "iMessage (local mode)",
-      "chat backgrounds require remote iMessage"
-    );
-  }
-  const remote = clientForPhone(client, space.phone);
-  await setBackground2(remote, space.id, content);
-};
-var handleCustomizedMiniApp = async (client, space, content) => {
-  if (isLocal(client)) {
-    throw UnsupportedError.action(
-      "customized-mini-app",
-      "iMessage (local mode)",
-      "mini app cards require remote iMessage"
-    );
-  }
-  const remote = clientForPhone(client, space.phone);
-  return cacheRemoteOutbound(
-    remote,
-    space,
-    await sendCustomizedMiniApp2(remote, space.id, content)
-  );
-};
-var handleRead = async (client, space) => {
-  if (isLocal(client)) {
-    throw UnsupportedError.action(
-      "read",
-      "iMessage (local mode)",
-      "marking chats as read requires remote iMessage"
-    );
-  }
-  const remote = clientForPhone(client, space.phone);
-  await markRead2(remote, space.id);
-};
-var handleTyping = async (client, space, state) => {
-  if (isLocal(client)) {
-    return;
-  }
-  const remote = clientForPhone(client, space.phone);
-  if (state === "start") {
-    await startTyping2(remote, space.id);
-  } else {
-    await stopTyping2(remote, space.id);
-  }
-};
-var handleRename = async (client, space, content) => {
-  if (isLocal(client)) {
-    throw UnsupportedError.action(
-      "rename",
-      "iMessage (local mode)",
-      "renaming chats requires remote iMessage"
-    );
-  }
-  if (space.type !== "group") {
-    throw UnsupportedError.action(
-      "rename",
-      "iMessage",
-      "only group chats can be renamed (this space is a DM)"
-    );
-  }
-  const remote = clientForPhone(client, space.phone);
-  await setDisplayName2(remote, space.id, content);
-};
-var handleAvatar = async (client, space, content) => {
-  if (isLocal(client)) {
-    throw UnsupportedError.action(
-      "avatar",
-      "iMessage (local mode)",
-      "setting group avatars requires remote iMessage"
-    );
-  }
-  if (space.type !== "group") {
-    throw UnsupportedError.action(
-      "avatar",
-      "iMessage",
-      "only group chats have avatars (this space is a DM)"
-    );
-  }
-  const remote = clientForPhone(client, space.phone);
-  await setIcon2(remote, space.id, content);
-};
-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,
-    create: async ({ input, client }) => {
-      if (isLocal(client)) {
-        throw UnsupportedError.action(
-          "space.create",
-          "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 addresses = input.users.map((u) => u.id);
-      if (isSharedMode(client)) {
-        if (addresses.length > 1) {
-          throw UnsupportedError.action(
-            "space.create",
-            "iMessage (shared mode)",
-            "shared mode cannot create group chats \u2014 use a dedicated number, or space.get(chatGuid) for an existing group"
-          );
-        }
-        return {
-          id: dmChatGuid(addresses[0] ?? ""),
-          type: "dm",
-          phone: SHARED_PHONE
-        };
-      }
-      const phone = input.params?.phone ?? randomPhone(client);
-      const remote = clientForPhone(client, phone);
-      const { chat } = await remote.chats.create(addresses);
-      return {
-        id: chat.guid,
-        type: chat.isGroup ? "group" : "dm",
-        phone
-      };
-    },
-    get: async ({ input, client }) => {
-      if (isLocal(client)) {
-        throw UnsupportedError.action(
-          "space.get",
-          "iMessage (local mode)",
-          "local mode only supports replying to existing messages"
-        );
-      }
-      if (client.length === 0) {
-        throw new Error("No iMessage clients configured");
-      }
-      const phone = isSharedMode(client) ? SHARED_PHONE : input.params?.phone ?? (client.length === 1 ? client[0]?.phone : void 0);
-      if (!phone) {
-        throw new Error(
-          `iMessage space.get requires params.phone when multiple clients are configured. Available: ${availablePhones(client).join(", ")}`
-        );
-      }
-      return {
-        id: input.id,
-        type: chatTypeFromGuid(input.id),
-        phone
-      };
-    },
-    actions: {
-      // Sugar: `space.background(input, opts?)` →
-      // `space.send(background(input, opts?))`. Routed through the universal
-      // send pipeline so the unsupported-content + warn-and-skip path on
-      // local-mode iMessage is identical to the canonical form.
-      background: async (space, input, opts) => {
-        await space.send(background(input, opts));
-      }
-    }
-  },
-  message: {
-    schema: messageSchema
-  },
-  messages: ({ client, projectConfig }) => isLocal(client) ? messages2(client) : messages4(client, projectConfig),
-  send: async ({ space, content, client }) => {
-    if (content.type === "reply") {
-      if (isLocal(client)) {
-        throw UnsupportedError.action("reply", "iMessage (local mode)");
-      }
-      if (isPollContent(content.target.content)) {
-        throw UnsupportedError.action(
-          "reply",
-          "iMessage",
-          "iMessage polls do not support replies"
-        );
-      }
-      const remote2 = clientForPhone(client, space.phone);
-      return cacheRemoteOutbound(
-        remote2,
-        space,
-        await replyToMessage2(
-          remote2,
-          space.id,
-          content.target.id,
-          content.content
-        )
-      );
-    }
-    if (content.type === "reaction") {
-      if (isLocal(client)) {
-        throw UnsupportedError.action("react", "iMessage (local mode)");
-      }
-      if (isPollContent(content.target.content)) {
-        throw UnsupportedError.action(
-          "react",
-          "iMessage",
-          "iMessage polls do not support reactions"
-        );
-      }
-      const remote2 = clientForPhone(client, space.phone);
-      return cacheRemoteOutbound(
-        remote2,
-        space,
-        await reactToMessage2(
-          remote2,
-          space.id,
-          content.target,
-          content.emoji
-        )
-      );
-    }
-    if (content.type === "typing") {
-      await handleTyping(client, space, content.state);
-      return;
-    }
-    if (content.type === "edit") {
-      await handleEdit(client, space, content);
-      return;
-    }
-    if (content.type === "unsend") {
-      await handleUnsend(client, space, content);
-      return;
-    }
-    if (content.type === "streamText") {
-      return await handleStreamText(client, space, content);
-    }
-    if (content.type === "rename") {
-      await handleRename(client, space, content);
-      return;
-    }
-    if (content.type === "avatar") {
-      await handleAvatar(client, space, content);
-      return;
-    }
-    if (content.type === "read") {
-      await handleRead(client, space);
-      return;
-    }
-    if (isBackground(content)) {
-      await handleBackground(client, space, content);
-      return;
-    }
-    if (isCustomizedMiniApp(content)) {
-      return await handleCustomizedMiniApp(client, space, content);
-    }
-    if (isLocal(client)) {
-      return await send2(client, space.id, content);
-    }
-    const remote = clientForPhone(client, space.phone);
-    return cacheRemoteOutbound(
-      remote,
-      space,
-      await send4(remote, space.id, content)
-    );
-  },
-  actions: {
-    getMessage: async ({ client }, space, messageId) => {
-      if (isLocal(client)) {
-        return getMessage2(client, messageId);
-      }
-      const remote = clientForPhone(client, space.phone);
-      return getMessage4(remote, space.id, messageId, space.phone);
-    },
-    // Fetch an attachment by GUID. Returns a spectrum `Attachment` whose
-    // `.read()` / `.stream()` lazily download the bytes — calling both
-    // issues two independent gRPC downloads, so cache `.read()` if you
-    // need the bytes more than once. Returns `undefined` for unknown
-    // GUIDs. Local-mode iMessage is not supported.
-    getAttachment: async ({ client }, guid, phone) => {
-      if (isLocal(client)) {
-        throw UnsupportedError.action(
-          "getAttachment",
-          "iMessage (local mode)",
-          "fetching attachments by GUID requires remote iMessage"
-        );
-      }
-      if (client.length === 0) {
-        throw new Error("No iMessage clients configured");
-      }
-      const routedPhone = (() => {
-        if (isSharedMode(client)) {
-          return SHARED_PHONE;
-        }
-        if (phone) {
-          return phone;
-        }
-        if (client.length === 1) {
-          return client[0].phone;
-        }
-        throw new Error(
-          `imessage.getAttachment requires a phone in multi-phone mode. Available: ${availablePhones(client).join(", ")}`
-        );
-      })();
-      const remote = clientForPhone(client, routedPhone);
-      return withSpan(
-        "spectrum.imessage.getAttachment",
-        {
-          "spectrum.provider": "iMessage",
-          "spectrum.imessage.attachment.guid": guid,
-          "spectrum.imessage.phone": routedPhone
-        },
-        () => getRemoteAttachment(remote, guid)
-      );
-    }
-  }
-});
-
-export {
-  background,
-  customizedMiniApp,
-  effect,
-  imessage
-};