spectrum-ts 1.1.1 → 1.1.2

package/dist/{chunk-7D6FHYKT.js → chunk-5GQ2OMFY.js}

@@ -672,29 +672,36 @@ var extractExtras = (raw, definition) => {
   const extra = Object.fromEntries(entries);
   return definition.message?.schema ? definition.message.schema.parse(extra) : extra;
 };
-function wrapProviderMessage(raw, ctx) {
-  const wrappedContent = wrapNestedContent(raw.content, ctx);
-  return buildMessage({
+function wrapProviderMessage(raw, ctx, direction) {
+  const wrappedContent = wrapNestedContent(raw.content, ctx, direction);
+  const base = {
     id: raw.id,
     content: wrappedContent,
-    sender: raw.sender,
     timestamp: raw.timestamp ?? /* @__PURE__ */ new Date(),
     extras: extractExtras(raw, ctx.definition),
     spaceRef: ctx.spaceRef,
     space: ctx.space,
     definition: ctx.definition,
     client: ctx.client,
-    config: ctx.config,
-    direction: "inbound"
-  });
+    config: ctx.config
+  };
+  if (direction === "inbound") {
+    if (!raw.sender) {
+      throw new Error(
+        `Inbound provider message missing sender (platform "${ctx.definition.name}", id "${raw.id}")`
+      );
+    }
+    return buildMessage({ ...base, sender: raw.sender, direction: "inbound" });
+  }
+  return buildMessage({ ...base, sender: raw.sender, direction: "outbound" });
 }
-var wrapNestedContent = (content, ctx) => {
+var wrapNestedContent = (content, ctx, direction) => {
   if (content.type === "reaction") {
     const target = content.target;
     if (isRawProviderRecord(target)) {
       return {
         ...content,
-        target: wrapProviderMessage(target, ctx)
+        target: wrapProviderMessage(target, ctx, "inbound")
       };
     }
     return content;
@@ -702,7 +709,10 @@ var wrapNestedContent = (content, ctx) => {
   if (content.type === "group") {
     const items = content.items.map((item) => {
       const raw = item;
-      return isRawProviderRecord(raw) ? wrapProviderMessage(raw, ctx) : item;
+      if (!isRawProviderRecord(raw)) {
+        return item;
+      }
+      return direction === "inbound" ? wrapProviderMessage(raw, ctx, "inbound") : wrapProviderMessage(raw, ctx, "outbound");
     });
     return { ...content, items };
   }
@@ -739,9 +749,9 @@ function buildSpace(params) {
     }
   }
   async function dispatchSend(item) {
-    let sendResult;
+    let raw;
     try {
-      sendResult = await definition.actions.send({
+      raw = await definition.actions.send({
         ...typingCtx,
         content: item
       });
@@ -752,46 +762,16 @@ function buildSpace(params) {
       }
       throw err;
     }
-    if (!sendResult?.id) {
+    if (!raw?.id) {
       throw new Error(
         `Platform "${definition.name}" send did not return a message id`
       );
     }
-    const outboundContent = item.type === "group" && sendResult.groupMembers ? {
-      ...item,
-      items: item.items.map((stub, idx) => {
-        const member = sendResult?.groupMembers?.[idx];
-        if (!member?.id) {
-          return stub;
-        }
-        return buildMessage({
-          id: member.id,
-          content: stub.content,
-          sender: member.sender,
-          timestamp: member.timestamp ?? /* @__PURE__ */ new Date(),
-          extras: {},
-          spaceRef,
-          space,
-          definition,
-          client,
-          config,
-          direction: "outbound"
-        });
-      })
-    } : item;
-    return buildMessage({
-      id: sendResult.id,
-      content: outboundContent,
-      sender: sendResult.sender,
-      timestamp: sendResult.timestamp ?? /* @__PURE__ */ new Date(),
-      extras: {},
-      spaceRef,
-      space,
-      definition,
-      client,
-      config,
-      direction: "outbound"
-    });
+    return wrapProviderMessage(
+      raw,
+      { client, config, definition, space, spaceRef },
+      "outbound"
+    );
   }
   async function sendImpl(...content) {
     const resolved = await resolveContents(content);
@@ -837,13 +817,11 @@ function buildSpace(params) {
     if (!raw) {
       return;
     }
-    return wrapProviderMessage(raw, {
-      client,
-      config,
-      definition,
-      space,
-      spaceRef
-    });
+    return wrapProviderMessage(
+      raw,
+      { client, config, definition, space, spaceRef },
+      "inbound"
+    );
   }
   space = {
     ...extras,
@@ -912,9 +890,9 @@ function buildMessage(params) {
     return self;
   };
   const dispatchReplyItem = async (item, target, replyToMessage) => {
-    let sendResult;
+    let raw;
     try {
-      sendResult = await replyToMessage({
+      raw = await replyToMessage({
         space: spaceRef,
         messageId: params.id,
         target,
@@ -929,24 +907,16 @@ function buildMessage(params) {
       }
       throw err;
     }
-    if (!sendResult?.id) {
+    if (!raw?.id) {
       throw new Error(
         `Platform "${definition.name}" reply did not return a message id`
       );
     }
-    return buildMessage({
-      id: sendResult.id,
-      content: item,
-      sender: sendResult.sender,
-      timestamp: sendResult.timestamp ?? /* @__PURE__ */ new Date(),
-      extras: {},
-      spaceRef,
-      space,
-      definition,
-      client,
-      config,
-      direction: "outbound"
-    });
+    return wrapProviderMessage(
+      raw,
+      { client, config, definition, space, spaceRef },
+      "outbound"
+    );
   };
   async function reply(...content) {
     const replyToMessage = definition.actions.replyToMessage;
@@ -1146,6 +1116,14 @@ function createPlatformInstance(def, runtime) {
       });
     }
   }
+  let messagesIterable;
+  Object.defineProperty(base, "messages", {
+    enumerable: true,
+    get() {
+      messagesIterable ??= runtime.subscribeMessages();
+      return messagesIterable;
+    }
+  });
   return Object.assign(base, eventProperties);
 }
 function definePlatform(name, def) {

package/dist/{chunk-PXX7ISZ6.js → chunk-FF2R4EP3.js}

@@ -108,6 +108,87 @@ function mergeStreams(streams) {
     };
   });
 }
+function broadcast(source) {
+  const consumers = /* @__PURE__ */ new Set();
+  let pumping = false;
+  let terminated = false;
+  let terminalError;
+  let pumpPromise;
+  let closed = false;
+  const startPump = () => {
+    if (pumping || terminated) {
+      return;
+    }
+    pumping = true;
+    pumpPromise = (async () => {
+      try {
+        for await (const value of source) {
+          for (const consumer of consumers) {
+            consumer.deliveries = consumer.deliveries.then(
+              () => consumer.emit(value).catch(() => {
+              })
+            );
+          }
+        }
+        terminated = true;
+        await Promise.allSettled(
+          Array.from(consumers, (consumer) => consumer.deliveries)
+        );
+        for (const consumer of consumers) {
+          consumer.end();
+        }
+        consumers.clear();
+      } catch (error) {
+        terminated = true;
+        terminalError = error;
+        for (const consumer of consumers) {
+          consumer.end(error);
+        }
+        consumers.clear();
+      }
+    })();
+  };
+  return {
+    subscribe() {
+      return stream((emit, end) => {
+        if (terminated) {
+          end(terminalError);
+          return;
+        }
+        const consumer = {
+          emit,
+          end,
+          deliveries: Promise.resolve()
+        };
+        consumers.add(consumer);
+        startPump();
+        return () => {
+          consumers.delete(consumer);
+        };
+      });
+    },
+    async close() {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      try {
+        await source.close();
+        if (pumpPromise) {
+          await pumpPromise;
+        }
+      } finally {
+        if (!terminated) {
+          terminated = true;
+          for (const consumer of consumers) {
+            consumer.end();
+          }
+          consumers.clear();
+        }
+      }
+    }
+  };
+}
 
 // src/utils/cloud.ts
 var SPECTRUM_CLOUD_URL = `https://${process.env.SPECTRUM_CLOUD_URL ?? "spectrum.photon.codes"}`;
@@ -183,6 +264,7 @@ export {
   poll,
   stream,
   mergeStreams,
+  broadcast,
   SpectrumCloudError,
   cloud
 };

package/dist/{chunk-7VSE6V3Q.js → chunk-QZ5DJ7VR.js}

@@ -2,7 +2,7 @@ import {
   bufferToStream,
   readSchema,
   streamSchema
-} from "./chunk-7D6FHYKT.js";
+} from "./chunk-5GQ2OMFY.js";
 
 // src/content/voice.ts
 import { createReadStream } from "fs";

package/dist/{chunk-TY3RT4OB.js → chunk-UWUPCIB4.js}

@@ -3,7 +3,7 @@ import {
   readSchema,
   resolveContents,
   streamSchema
-} from "./chunk-7D6FHYKT.js";
+} from "./chunk-5GQ2OMFY.js";
 
 // src/content/group.ts
 import z from "zod";
@@ -163,6 +163,7 @@ function richlink(url) {
 
 export {
   groupSchema,
+  asGroup,
   group,
   asRichlink,
   richlink

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-import { C as ContentBuilder, U as User, M as Message, a as ContentInput, b as Content, P as ProviderMessage, c as PlatformDef, d as Platform, e as PlatformProviderConfig, S as SpectrumLike, f as CustomEventStreams, g as Space, I as InboundMessage, O as OutboundMessage } from './types-BZhWdyLk.js';
-export { A as AnyPlatformDef, E as EventProducer, h as PlatformInstance, i as PlatformMessage, j as PlatformSpace, k as PlatformUser, l as SchemaMessage } from './types-BZhWdyLk.js';
+import { C as ContentBuilder, U as User, M as Message, a as ContentInput, b as Content, P as ProviderMessage, c as PlatformDef, d as Platform, e as PlatformProviderConfig, S as SpectrumLike, f as CustomEventStreams, g as Space, I as InboundMessage, O as OutboundMessage } from './types-GhOtIIqj.js';
+export { A as AnyPlatformDef, B as Broadcaster, E as EventProducer, h as InboundPlatformMessage, i as ManagedStream, j as PlatformInstance, k as PlatformMessage, l as PlatformRuntime, m as PlatformSpace, n as PlatformUser, o as SchemaMessage, p as broadcast, q as mergeStreams, s as stream } from './types-GhOtIIqj.js';
 import vCard from 'vcf';
 import z__default from 'zod';
-export { M as ManagedStream, m as mergeStreams, s as stream } from './stream-B55k7W8-.js';
 import 'hotscript';
 
 declare function attachment(input: string | Buffer, options?: {

package/dist/index.js

@@ -1,18 +1,19 @@
 import {
   group,
   richlink
-} from "./chunk-TY3RT4OB.js";
+} from "./chunk-UWUPCIB4.js";
 import {
   voice
-} from "./chunk-7VSE6V3Q.js";
+} from "./chunk-QZ5DJ7VR.js";
 import {
   SpectrumCloudError,
+  broadcast,
   cloud,
   mergeStreams,
   option,
   poll,
   stream
-} from "./chunk-PXX7ISZ6.js";
+} from "./chunk-FF2R4EP3.js";
 import {
   UnsupportedError,
   attachment,
@@ -26,7 +27,7 @@ import {
   text,
   toVCard,
   wrapProviderMessage
-} from "./chunk-7D6FHYKT.js";
+} from "./chunk-5GQ2OMFY.js";
 
 // src/emoji/generated.ts
 var GeneratedEmoji = {
@@ -1986,23 +1987,9 @@ async function Spectrum(options) {
   } = options;
   const flattenGroups = runtimeOptions?.flattenGroups ?? false;
   const platformStates = /* @__PURE__ */ new Map();
+  const messageBroadcasters = /* @__PURE__ */ new Map();
   const customEventStreams = /* @__PURE__ */ new Map();
   let stopped = false;
-  for (const provider of providers) {
-    const providerConfig = provider;
-    const def = providerConfig.__definition;
-    const userConfig = def.config.parse(providerConfig.config);
-    const client = await def.lifecycle.createClient({
-      config: userConfig,
-      projectId,
-      projectSecret
-    });
-    platformStates.set(def.name, {
-      client,
-      config: userConfig,
-      definition: def
-    });
-  }
   const adaptIterable = (iterable) => {
     return stream((emit, end) => {
       const iterator = iterable[Symbol.asyncIterator]();
@@ -2045,13 +2032,17 @@ async function Spectrum(options) {
           client,
           config
         });
-        const normalizedMessage = wrapProviderMessage(msg, {
-          client,
-          config,
-          definition,
-          space,
-          spaceRef
-        });
+        const normalizedMessage = wrapProviderMessage(
+          msg,
+          {
+            client,
+            config,
+            definition,
+            space,
+            spaceRef
+          },
+          "inbound"
+        );
         if (flattenGroups && normalizedMessage.content.type === "group") {
           for (const item of normalizedMessage.content.items) {
             yield [space, item];
@@ -2063,10 +2054,46 @@ async function Spectrum(options) {
     };
     return adaptIterable(bindSend());
   };
+  const getOrCreateMessageBroadcast = (state) => {
+    if (stopped) {
+      throw new Error(
+        `Spectrum instance has been stopped; cannot subscribe to "${state.definition.name}" messages`
+      );
+    }
+    const name = state.definition.name;
+    let broadcaster = messageBroadcasters.get(name);
+    if (!broadcaster) {
+      broadcaster = broadcast(createProviderMessagesStream(state));
+      messageBroadcasters.set(name, broadcaster);
+    }
+    return broadcaster;
+  };
+  for (const provider of providers) {
+    const providerConfig = provider;
+    const def = providerConfig.__definition;
+    const userConfig = def.config.parse(providerConfig.config);
+    const client = await def.lifecycle.createClient({
+      config: userConfig,
+      projectId,
+      projectSecret
+    });
+    const state = {
+      client,
+      config: userConfig,
+      definition: def
+    };
+    platformStates.set(def.name, {
+      ...state,
+      subscribeMessages: () => getOrCreateMessageBroadcast(state).subscribe()
+    });
+  }
   const createMessagesStream = () => {
     return stream((emit, end) => {
       const merged = mergeStreams(
-        Array.from(platformStates.values(), createProviderMessagesStream)
+        Array.from(
+          platformStates.values(),
+          (runtime) => runtime.subscribeMessages()
+        )
       );
       const pump = (async () => {
         try {
@@ -2130,6 +2157,10 @@ async function Spectrum(options) {
       ...Array.from(
         customEventStreams.values(),
         (eventStream) => eventStream.close()
+      ),
+      ...Array.from(
+        messageBroadcasters.values(),
+        (broadcaster) => broadcaster.close()
       )
     ];
     process.off("SIGINT", handleSignal);
@@ -2143,6 +2174,7 @@ async function Spectrum(options) {
     );
     await Promise.allSettled(clientShutdowns);
     customEventStreams.clear();
+    messageBroadcasters.clear();
     platformStates.clear();
   };
   const handleSignal = () => {
@@ -2200,6 +2232,7 @@ export {
   SpectrumCloudError,
   UnsupportedError,
   attachment,
+  broadcast,
   cloud,
   contact,
   custom,

package/dist/providers/imessage/index.d.ts

@@ -1,5 +1,4 @@
-import { M as ManagedStream } from '../../stream-B55k7W8-.js';
-import { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-BZhWdyLk.js';
+import { o as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage, i as ManagedStream } from '../../types-GhOtIIqj.js';
 import * as zod_v4_core from 'zod/v4/core';
 import * as z from 'zod';
 import z__default from 'zod';

package/dist/providers/imessage/index.js

@@ -1,14 +1,15 @@
 import {
+  asGroup,
   asRichlink,
   groupSchema
-} from "../../chunk-TY3RT4OB.js";
+} from "../../chunk-UWUPCIB4.js";
 import {
   asPoll,
   asPollOption,
   cloud,
   mergeStreams,
   stream
-} from "../../chunk-PXX7ISZ6.js";
+} from "../../chunk-FF2R4EP3.js";
 import {
   UnsupportedError,
   asAttachment,
@@ -19,7 +20,7 @@ import {
   fromVCard,
   reactionSchema,
   toVCard
-} from "../../chunk-7D6FHYKT.js";
+} from "../../chunk-5GQ2OMFY.js";
 
 // src/providers/imessage/index.ts
 import { createClient as createClient2, directChat } from "@photon-ai/advanced-imessage";
@@ -232,8 +233,10 @@ var unsupportedRemoteContent = (type, detail) => UnsupportedError.content(type,
 var unsupportedLocalContent = (type) => UnsupportedError.content(type, LOCAL_IMESSAGE_PLATFORM);
 
 // src/providers/imessage/local/send.ts
-var synthSendResult = () => ({
+var synthRecord = (spaceId, content) => ({
   id: crypto.randomUUID(),
+  content,
+  space: { id: spaceId },
   timestamp: /* @__PURE__ */ new Date()
 });
 var sendTempFile = async (client, spaceId, name, data) => {
@@ -252,10 +255,10 @@ var send = async (client, spaceId, content) => {
   switch (content.type) {
     case "text":
       await client.send({ to: spaceId, text: content.text });
-      return synthSendResult();
+      return synthRecord(spaceId, content);
     case "attachment":
       await sendTempFile(client, spaceId, content.name, await content.read());
-      return synthSendResult();
+      return synthRecord(spaceId, content);
     case "contact": {
       const vcf = await toVCard(content);
       await sendTempFile(
@@ -264,7 +267,7 @@ var send = async (client, spaceId, content) => {
         vcardFileName(content),
         Buffer.from(vcf, "utf8")
       );
-      return synthSendResult();
+      return synthRecord(spaceId, content);
     }
     case "poll":
       throw unsupportedLocalContent("poll");
@@ -927,20 +930,12 @@ var ensureM4a = async (buffer, mimeType) => {
 
 // src/providers/imessage/remote/send.ts
 var GROUP_ITEM_ALLOWED = /* @__PURE__ */ new Set([
+  "text",
   "attachment",
   "contact",
   "voice"
 ]);
-var PartialGroupSendError = class extends Error {
-  cause;
-  groupMembers;
-  constructor(groupMembers, cause) {
-    super("iMessage group send failed after one or more items were sent");
-    this.name = "PartialGroupSendError";
-    this.cause = cause;
-    this.groupMembers = groupMembers;
-  }
-};
+var MAX_GROUP_TEXT_ITEMS = 1;
 var toDate = (value) => {
   if (value instanceof Date) {
     return value;
@@ -951,15 +946,19 @@ var toDate = (value) => {
   }
 };
 var receiptTimestamp = (receipt) => toDate(receipt.timestamp) ?? toDate(receipt.date) ?? toDate(receipt.dateCreated) ?? /* @__PURE__ */ new Date();
-var toSendResult = (receipt) => {
+var receiptGuid = (receipt) => {
   if (typeof receipt.guid !== "string" || receipt.guid.length === 0) {
     throw new Error("iMessage send receipt is missing a message guid");
   }
-  return {
-    id: receipt.guid,
-    timestamp: receiptTimestamp(receipt)
-  };
+  return receipt.guid;
 };
+var outboundRecord = (spaceId, id, content, timestamp, extras) => ({
+  id,
+  content,
+  space: { id: spaceId },
+  timestamp,
+  ...extras
+});
 var withReply = (options, replyTo) => replyTo ? { ...options, replyTo } : options;
 var replyOptions = (replyTo) => replyTo ? { replyTo } : void 0;
 var sendVCardAttachment = (remote, name, vcf) => remote.attachments.upload({
@@ -969,8 +968,9 @@ var sendVCardAttachment = (remote, name, vcf) => remote.attachments.upload({
 });
 var sendContactAttachment = async (remote, content) => {
   const vcf = await toVCard(content);
-  const upload = await sendVCardAttachment(remote, vcardFileName(content), vcf);
-  return upload.guid;
+  const name = vcardFileName(content);
+  const upload = await sendVCardAttachment(remote, name, vcf);
+  return { guid: upload.guid, name };
 };
 var uploadAttachment = async (remote, content) => {
   const attachment = await remote.attachments.upload({
@@ -978,53 +978,86 @@ var uploadAttachment = async (remote, content) => {
     fileName: content.name,
     mimeType: content.mimeType
   });
-  return attachment.guid;
+  return { guid: attachment.guid, name: content.name };
 };
 var uploadVoice = async (remote, content) => {
   const { buffer } = await ensureM4a(await content.read(), content.mimeType);
+  const name = content.name ?? "voice.m4a";
   const attachment = await remote.attachments.upload({
     data: buffer,
-    fileName: content.name ?? "voice.m4a",
+    fileName: name,
     mimeType: "audio/x-m4a"
   });
-  return attachment.guid;
+  return { guid: attachment.guid, name };
 };
-var sendContent = async (remote, chat, content, replyTo) => {
+var sendContent = async (remote, spaceId, chat, content, replyTo) => {
   switch (content.type) {
-    case "text":
-      return toSendResult(
-        await remote.messages.send(chat, content.text, withReply({}, replyTo))
+    case "text": {
+      const receipt = await remote.messages.send(
+        chat,
+        content.text,
+        withReply({}, replyTo)
       );
-    case "richlink":
-      return toSendResult(
-        await remote.messages.send(
-          chat,
-          content.url,
-          withReply({ richLink: true }, replyTo)
-        )
+      return outboundRecord(
+        spaceId,
+        receiptGuid(receipt),
+        content,
+        receiptTimestamp(receipt)
       );
-    case "attachment":
-      return toSendResult(
-        await remote.messages.send(chat, "", {
-          attachment: await uploadAttachment(remote, content),
-          ...replyOptions(replyTo)
-        })
+    }
+    case "richlink": {
+      const receipt = await remote.messages.send(
+        chat,
+        content.url,
+        withReply({ richLink: true }, replyTo)
       );
-    case "contact":
-      return toSendResult(
-        await remote.messages.send(chat, "", {
-          attachment: await sendContactAttachment(remote, content),
-          ...replyOptions(replyTo)
-        })
+      return outboundRecord(
+        spaceId,
+        receiptGuid(receipt),
+        content,
+        receiptTimestamp(receipt)
       );
-    case "voice":
-      return toSendResult(
-        await remote.messages.send(chat, "", {
-          attachment: await uploadVoice(remote, content),
-          audioMessage: true,
-          ...replyOptions(replyTo)
-        })
+    }
+    case "attachment": {
+      const { guid } = await uploadAttachment(remote, content);
+      const receipt = await remote.messages.send(chat, "", {
+        attachment: guid,
+        ...replyOptions(replyTo)
+      });
+      return outboundRecord(
+        spaceId,
+        receiptGuid(receipt),
+        content,
+        receiptTimestamp(receipt)
       );
+    }
+    case "contact": {
+      const { guid } = await sendContactAttachment(remote, content);
+      const receipt = await remote.messages.send(chat, "", {
+        attachment: guid,
+        ...replyOptions(replyTo)
+      });
+      return outboundRecord(
+        spaceId,
+        receiptGuid(receipt),
+        content,
+        receiptTimestamp(receipt)
+      );
+    }
+    case "voice": {
+      const { guid } = await uploadVoice(remote, content);
+      const receipt = await remote.messages.send(chat, "", {
+        attachment: guid,
+        audioMessage: true,
+        ...replyOptions(replyTo)
+      });
+      return outboundRecord(
+        spaceId,
+        receiptGuid(receipt),
+        content,
+        receiptTimestamp(receipt)
+      );
+    }
     case "poll":
       if (replyTo) {
         throw unsupportedRemoteContent(
@@ -1032,18 +1065,24 @@ var sendContent = async (remote, chat, content, replyTo) => {
           "polls cannot be sent as replies"
         );
       }
-      return toSendResult(
-        await remote.polls.create(
-          chat,
-          content.title,
-          content.options.map((option) => option.title)
-        )
+      return outboundRecord(
+        spaceId,
+        receiptGuid(
+          await remote.polls.create(
+            chat,
+            content.title,
+            content.options.map((option) => option.title)
+          )
+        ),
+        content,
+        /* @__PURE__ */ new Date()
       );
     default:
       throw unsupportedRemoteContent(content.type);
   }
 };
 var validateGroupContent = (content) => {
+  let textCount = 0;
   for (const sub of content.items) {
     const itemType = sub.content.type;
     if (!GROUP_ITEM_ALLOWED.has(itemType)) {
@@ -1052,32 +1091,69 @@ var validateGroupContent = (content) => {
         `"${itemType}" items are not supported inside a group`
       );
     }
+    if (itemType === "text" && ++textCount > MAX_GROUP_TEXT_ITEMS) {
+      throw unsupportedRemoteContent(
+        "group",
+        `groups can contain at most ${MAX_GROUP_TEXT_ITEMS} text item`
+      );
+    }
+  }
+};
+var resolvePart = async (remote, content) => {
+  switch (content.type) {
+    case "text":
+      return { text: content.text };
+    case "attachment": {
+      const { guid, name } = await uploadAttachment(remote, content);
+      return { attachmentGuid: guid, attachmentName: name };
+    }
+    case "contact": {
+      const { guid, name } = await sendContactAttachment(remote, content);
+      return { attachmentGuid: guid, attachmentName: name };
+    }
+    case "voice": {
+      const { guid, name } = await uploadVoice(remote, content);
+      return { attachmentGuid: guid, attachmentName: name };
+    }
+    default:
+      throw unsupportedRemoteContent(content.type);
   }
 };
 var send3 = async (remote, spaceId, content) => {
   const chat = chatGuid2(spaceId);
   if (content.type === "group") {
     validateGroupContent(content);
-    const groupMembers = [];
-    try {
-      for (const sub of content.items) {
-        groupMembers.push(await sendContent(remote, chat, sub.content));
-      }
-    } catch (err) {
-      throw new PartialGroupSendError(groupMembers, err);
-    }
-    const first = groupMembers[0];
-    if (!first) {
-      throw new Error("Empty group");
-    }
-    return { ...first, groupMembers };
+    const resolved = await Promise.all(
+      content.items.map((sub) => resolvePart(remote, sub.content))
+    );
+    const receipt = await remote.messages.sendMultipart(
+      chat,
+      resolved.map((part, idx) => ({ ...part, partIndex: idx }))
+    );
+    const parentGuid = receiptGuid(receipt);
+    const timestamp = receiptTimestamp(receipt);
+    const items = content.items.map(
+      (sub, idx) => outboundRecord(
+        spaceId,
+        formatChildId(idx, parentGuid),
+        sub.content,
+        timestamp,
+        { partIndex: idx, parentId: parentGuid }
+      )
+    );
+    return outboundRecord(
+      spaceId,
+      parentGuid,
+      asGroup({ items }),
+      timestamp
+    );
   }
-  return sendContent(remote, chat, content);
+  return sendContent(remote, spaceId, chat, content);
 };
 var replyToMessage = async (remote, spaceId, msgId, content) => {
   const chat = chatGuid2(spaceId);
   const replyTo = messageGuid3(msgId);
-  return sendContent(remote, chat, content, replyTo);
+  return sendContent(remote, spaceId, chat, content, replyTo);
 };
 var editMessage = async (remote, spaceId, msgId, content) => {
   if (content.type !== "text") {

package/dist/providers/terminal/index.d.ts

@@ -1,4 +1,4 @@
-import { d as Platform, c as PlatformDef, P as ProviderMessage, M as Message } from '../../types-BZhWdyLk.js';
+import { d as Platform, c as PlatformDef, P as ProviderMessage, M as Message } from '../../types-GhOtIIqj.js';
 import z__default from 'zod';
 import 'hotscript';
 

package/dist/providers/terminal/index.js

@@ -1,6 +1,6 @@
 import {
   asVoice
-} from "../../chunk-7VSE6V3Q.js";
+} from "../../chunk-QZ5DJ7VR.js";
 import {
   UnsupportedError,
   asAttachment,
@@ -10,7 +10,7 @@ import {
   fromVCard,
   reactionSchema,
   toVCard
-} from "../../chunk-7D6FHYKT.js";
+} from "../../chunk-5GQ2OMFY.js";
 
 // src/providers/terminal/index.ts
 import { spawn } from "child_process";
@@ -601,6 +601,14 @@ function parseTimestamp(s) {
   const t = Date.parse(s);
   return Number.isNaN(t) ? /* @__PURE__ */ new Date() : new Date(t);
 }
+function buildOutboundRecord(result, content, spaceId) {
+  return {
+    id: result.id,
+    content,
+    space: { id: spaceId },
+    timestamp: parseTimestamp(result.timestamp)
+  };
+}
 function reactionTargetFromProtocol(reaction) {
   const target = {
     id: reaction.messageId,
@@ -810,7 +818,7 @@ var terminal = definePlatform("terminal", {
         "send",
         { spaceId: space.id, content: proto }
       );
-      return { id: result.id, timestamp: parseTimestamp(result.timestamp) };
+      return buildOutboundRecord(result, content, space.id);
     },
     startTyping: async ({ client, space }) => {
       const c = client;
@@ -835,7 +843,7 @@ var terminal = definePlatform("terminal", {
         "replyToMessage",
         { spaceId: space.id, messageId, content: proto }
       );
-      return { id: result.id, timestamp: parseTimestamp(result.timestamp) };
+      return buildOutboundRecord(result, content, space.id);
     }
   }
 });

package/dist/providers/whatsapp-business/index.d.ts

@@ -1,8 +1,7 @@
-import { M as ManagedStream } from '../../stream-B55k7W8-.js';
+import { o as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage, i as ManagedStream } from '../../types-GhOtIIqj.js';
 import { WhatsAppClient } from '@photon-ai/whatsapp-business';
 import * as z from 'zod';
 import z__default from 'zod';
-import { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-BZhWdyLk.js';
 import * as zod_v4_core from 'zod/v4/core';
 import 'hotscript';
 

package/dist/providers/whatsapp-business/index.js

@@ -3,7 +3,7 @@ import {
   cloud,
   mergeStreams,
   stream
-} from "../../chunk-PXX7ISZ6.js";
+} from "../../chunk-FF2R4EP3.js";
 import {
   UnsupportedError,
   asAttachment,
@@ -12,7 +12,7 @@ import {
   asReaction,
   asText,
   definePlatform
-} from "../../chunk-7D6FHYKT.js";
+} from "../../chunk-5GQ2OMFY.js";
 
 // src/providers/whatsapp-business/index.ts
 import { createClient as createClient2 } from "@photon-ai/whatsapp-business";
@@ -266,8 +266,11 @@ var primary = (clients) => {
   }
   return client;
 };
-var toSendResult = (result) => ({
-  id: result.messageId
+var toRecord = (result, spaceId, content) => ({
+  id: result.messageId,
+  content,
+  space: { id: spaceId },
+  timestamp: /* @__PURE__ */ new Date()
 });
 var MAX_POLL_CACHE_SIZE = 1e3;
 var OPTION_ID_PREFIX = "opt_";
@@ -622,8 +625,10 @@ var send = async (clients, spaceId, content) => {
   const client = primary(clients);
   switch (content.type) {
     case "text":
-      return toSendResult(
-        await client.messages.send({ to: spaceId, text: content.text })
+      return toRecord(
+        await client.messages.send({ to: spaceId, text: content.text }),
+        spaceId,
+        content
       );
     case "attachment": {
       const { mediaId } = await client.media.upload({
@@ -633,19 +638,23 @@ var send = async (clients, spaceId, content) => {
       });
       const mediaType = mimeToMediaType(content.mimeType);
       const mediaPayload = mediaType === "document" ? { id: mediaId, filename: content.name } : { id: mediaId };
-      return toSendResult(
+      return toRecord(
         await client.messages.send({
           to: spaceId,
           [mediaType]: mediaPayload
-        })
+        }),
+        spaceId,
+        content
       );
     }
     case "contact":
-      return toSendResult(
+      return toRecord(
         await client.messages.send({
           to: spaceId,
           contacts: [contactToWa(content)]
-        })
+        }),
+        spaceId,
+        content
       );
     case "voice": {
       const { mediaId } = await client.media.upload({
@@ -653,11 +662,13 @@ var send = async (clients, spaceId, content) => {
         mimeType: content.mimeType,
         filename: voiceFilename(content)
       });
-      return toSendResult(
+      return toRecord(
         await client.messages.send({
           to: spaceId,
           audio: { id: mediaId }
-        })
+        }),
+        spaceId,
+        content
       );
     }
     case "poll": {
@@ -666,7 +677,7 @@ var send = async (clients, spaceId, content) => {
         interactive: pollToInteractive(content)
       });
       cachePoll(client, result.messageId, content);
-      return toSendResult(result);
+      return toRecord(result, spaceId, content);
     }
     default:
       throw UnsupportedError.content(content.type);
@@ -682,12 +693,14 @@ var replyToMessage = async (clients, spaceId, messageId, content) => {
   const client = primary(clients);
   switch (content.type) {
     case "text":
-      return toSendResult(
+      return toRecord(
         await client.messages.send({
           to: spaceId,
           replyTo: messageId,
           text: content.text
-        })
+        }),
+        spaceId,
+        content
       );
     case "attachment": {
       const { mediaId } = await client.media.upload({
@@ -697,21 +710,25 @@ var replyToMessage = async (clients, spaceId, messageId, content) => {
       });
       const mediaType = mimeToMediaType(content.mimeType);
       const mediaPayload = mediaType === "document" ? { id: mediaId, filename: content.name } : { id: mediaId };
-      return toSendResult(
+      return toRecord(
         await client.messages.send({
           to: spaceId,
           replyTo: messageId,
           [mediaType]: mediaPayload
-        })
+        }),
+        spaceId,
+        content
       );
     }
     case "contact":
-      return toSendResult(
+      return toRecord(
         await client.messages.send({
           to: spaceId,
           replyTo: messageId,
           contacts: [contactToWa(content)]
-        })
+        }),
+        spaceId,
+        content
       );
     case "voice": {
       const { mediaId } = await client.media.upload({
@@ -719,12 +736,14 @@ var replyToMessage = async (clients, spaceId, messageId, content) => {
         mimeType: content.mimeType,
         filename: voiceFilename(content)
       });
-      return toSendResult(
+      return toRecord(
         await client.messages.send({
           to: spaceId,
           replyTo: messageId,
           audio: { id: mediaId }
-        })
+        }),
+        spaceId,
+        content
       );
     }
     case "poll": {
@@ -734,7 +753,7 @@ var replyToMessage = async (clients, spaceId, messageId, content) => {
         interactive: pollToInteractive(content)
       });
       cachePoll(client, result.messageId, content);
-      return toSendResult(result);
+      return toRecord(result, spaceId, content);
     }
     default:
       throw UnsupportedError.content(content.type);

package/dist/{types-BZhWdyLk.d.ts → types-GhOtIIqj.d.ts}

@@ -166,6 +166,18 @@ interface OutboundMessage<TPlatform extends string = string, TSender extends Use
 }
 type Message<TPlatform extends string = string, TSender extends User = User, TSpace extends Space = Space> = InboundMessage<TPlatform, TSender, TSpace> | OutboundMessage<TPlatform, TSender, TSpace>;
 
+interface ManagedStream<T> extends AsyncIterable<T> {
+    close(): Promise<void>;
+}
+type StreamCleanup = void | (() => void | Promise<void>);
+declare function stream<T>(setup: (emit: (value: T) => Promise<void>, end: (error?: unknown) => void) => StreamCleanup | Promise<StreamCleanup>): ManagedStream<T>;
+declare function mergeStreams<T>(streams: readonly ManagedStream<T>[]): ManagedStream<T>;
+interface Broadcaster<T> {
+    close(): Promise<void>;
+    subscribe(): ManagedStream<T>;
+}
+declare function broadcast<T>(source: ManagedStream<T>): Broadcaster<T>;
+
 type ResolvedSpace = Pick<Space, "id">;
 type SpaceRef = Pick<Space, "id" | "__platform">;
 type ResolvedUser = Pick<User, "id">;
@@ -187,19 +199,28 @@ type ProviderMessage<TSender extends ResolvedUser = ResolvedUser, TSpace extends
     space: TSpace;
     timestamp?: Date;
 } & TExtra;
-interface SendResult<TSender extends ResolvedUser = ResolvedUser> {
-    /**
-     * Per-item send receipts returned when the dispatched content was a
-     * `group`. Providers that iterate native sends to emulate a group
-     * (e.g. iMessage) populate this so the platform build layer can
-     * replace the outbound group's placeholder items with real Messages
-     * that carry each item's own id.
-     */
-    groupMembers?: SendResult<TSender>[];
+/**
+ * A message a provider produced — used for both inbound (`events.messages`,
+ * `getMessage`) and outbound (`send`, `replyToMessage`) flows. Providers
+ * return their native record shape (including platform extras like
+ * `partIndex`/`parentId` for iMessage) and the platform `wrapProviderMessage`
+ * pipeline turns it into a fully-built Message.
+ *
+ * `sender` is optional because outbound sends often can't synthesize one
+ * (the SDK doesn't surface the bot's own handle); inbound providers are
+ * expected to populate it.
+ */
+type ProviderMessageRecord = {
     id: string;
-    sender?: TSender;
+    content: Content;
+    sender?: {
+        id: string;
+    } & Record<string, unknown>;
+    space: {
+        id: string;
+    } & Record<string, unknown>;
     timestamp?: Date;
-}
+} & Record<string, unknown>;
 type MergeSchema<TSchema extends z__default.ZodType | undefined, TBase extends object> = TSchema extends z__default.ZodType ? string extends keyof z__default.infer<TSchema> ? TBase : Omit<z__default.infer<TSchema>, keyof TBase> & TBase : TBase;
 type SchemaMessage<TUserSchema extends z__default.ZodType | undefined = undefined, TSpaceSchema extends z__default.ZodType | undefined = undefined> = ProviderMessage<MergeSchema<TUserSchema, ResolvedUser>, MergeSchema<TSpaceSchema, ResolvedSpace>>;
 type InferEventPayload<T> = T extends (ctx: never) => AsyncIterable<infer P> ? P : never;
@@ -215,7 +236,7 @@ interface PlatformDef<_Name extends string = string, _ConfigSchema extends z__de
             content: Content;
             client: _Client;
             config: z__default.infer<_ConfigSchema>;
-        }) => Promise<SendResult<_ResolvedUser>>;
+        }) => Promise<ProviderMessageRecord>;
         startTyping?: (_: {
             space: _ResolvedSpace & SpaceRef;
             client: _Client;
@@ -240,7 +261,7 @@ interface PlatformDef<_Name extends string = string, _ConfigSchema extends z__de
             content: Content;
             client: _Client;
             config: z__default.infer<_ConfigSchema>;
-        }) => Promise<SendResult<_ResolvedUser>>;
+        }) => Promise<ProviderMessageRecord>;
         editMessage?: (_: {
             space: _ResolvedSpace & SpaceRef;
             messageId: string;
@@ -298,11 +319,11 @@ interface PlatformDef<_Name extends string = string, _ConfigSchema extends z__de
 }
 interface AnyPlatformDef {
     actions: {
-        send: (_: any) => Promise<SendResult>;
+        send: (_: any) => Promise<ProviderMessageRecord>;
         startTyping?: (_: any) => Promise<void>;
         stopTyping?: (_: any) => Promise<void>;
         reactToMessage?: (_: any) => Promise<void>;
-        replyToMessage?: (_: any) => Promise<SendResult>;
+        replyToMessage?: (_: any) => Promise<ProviderMessageRecord>;
         editMessage?: (_: any) => Promise<void>;
         getMessage?: (_: any) => Promise<any>;
     };
@@ -380,20 +401,27 @@ type SpaceVarargArgs<Def extends AnyPlatformDef> = [
 type SpaceArgs<Def extends AnyPlatformDef> = SpaceArrayArgs<Def> | SpaceVarargArgs<Def>;
 type PlatformSpace<Def extends AnyPlatformDef> = Omit<SpaceShapeOf<Def>, keyof Space> & Space;
 type PlatformMessage<Def extends AnyPlatformDef> = Omit<SchemaInfer<Def["message"]>, keyof Message> & Message<Def["name"], PlatformUser<Def>, PlatformSpace<Def>>;
+type InboundPlatformMessage<Def extends AnyPlatformDef> = Omit<SchemaInfer<Def["message"]>, keyof InboundMessage> & InboundMessage<Def["name"], PlatformUser<Def>, PlatformSpace<Def>>;
 type PlatformUser<Def extends AnyPlatformDef> = Omit<ResolvedUserOf<Def>, keyof User> & User;
 type PlatformInstance<Def extends AnyPlatformDef> = {
+    readonly messages: AsyncIterable<[
+        PlatformSpace<Def>,
+        InboundPlatformMessage<Def>
+    ]>;
     space(...args: SpaceArgs<Def>): Promise<PlatformSpace<Def>>;
     user(userID: string): Promise<PlatformUser<Def>>;
 } & {
     [K in Exclude<keyof Def["events"], "messages" | symbol | number> as K extends ReservedNames ? never : K]: AsyncIterable<InferEventPayload<Def["events"][K]>>;
 };
+interface PlatformRuntime {
+    client: unknown;
+    config: unknown;
+    definition: AnyPlatformDef;
+    subscribeMessages: () => ManagedStream<[Space, InboundMessage]>;
+}
 interface SpectrumLike<Providers extends PlatformProviderConfig[] = PlatformProviderConfig[]> {
     readonly __internal: {
-        platforms: Map<string, {
-            client: unknown;
-            config: unknown;
-            definition: AnyPlatformDef;
-        }>;
+        platforms: Map<string, PlatformRuntime>;
     };
     readonly __providers: Providers;
 }
@@ -404,4 +432,4 @@ interface Platform<Def extends AnyPlatformDef> {
     (message: Message): PlatformMessage<Def>;
 }
 
-export type { AnyPlatformDef as A, ContentBuilder as C, EventProducer as E, InboundMessage as I, Message as M, OutboundMessage as O, ProviderMessage as P, SpectrumLike as S, User as U, ContentInput as a, Content as b, PlatformDef as c, Platform as d, PlatformProviderConfig as e, CustomEventStreams as f, Space as g, PlatformInstance as h, PlatformMessage as i, PlatformSpace as j, PlatformUser as k, SchemaMessage as l };
+export { type AnyPlatformDef as A, type Broadcaster as B, type ContentBuilder as C, type EventProducer as E, type InboundMessage as I, type Message as M, type OutboundMessage as O, type ProviderMessage as P, type SpectrumLike as S, type User as U, type ContentInput as a, type Content as b, type PlatformDef as c, type Platform as d, type PlatformProviderConfig as e, type CustomEventStreams as f, type Space as g, type InboundPlatformMessage as h, type ManagedStream as i, type PlatformInstance as j, type PlatformMessage as k, type PlatformRuntime as l, type PlatformSpace as m, type PlatformUser as n, type SchemaMessage as o, broadcast as p, mergeStreams as q, stream as s };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spectrum-ts",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -19,7 +19,7 @@
     }
   },
   "dependencies": {
-    "@photon-ai/advanced-imessage": "^0.5.1",
+    "@photon-ai/advanced-imessage": "^0.6.0",
     "@photon-ai/imessage-kit": "^3.0.0",
     "@photon-ai/whatsapp-business": "^0.1.1",
     "@repeaterjs/repeater": "^3.0.6",

package/dist/stream-B55k7W8-.d.ts

@@ -1,8 +0,0 @@
-interface ManagedStream<T> extends AsyncIterable<T> {
-    close(): Promise<void>;
-}
-type StreamCleanup = void | (() => void | Promise<void>);
-declare function stream<T>(setup: (emit: (value: T) => Promise<void>, end: (error?: unknown) => void) => StreamCleanup | Promise<StreamCleanup>): ManagedStream<T>;
-declare function mergeStreams<T>(streams: readonly ManagedStream<T>[]): ManagedStream<T>;
-
-export { type ManagedStream as M, mergeStreams as m, stream as s };