spectrum-ts 1.1.0 → 1.1.2

package/dist/{chunk-XMAI2AAN.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,
@@ -903,8 +881,46 @@ function buildMessage(params) {
       throw err;
     }
   };
+  const requireBuiltMessage = (action) => {
+    if (!self) {
+      throw new Error(
+        `${action}() called before message construction completed (internal bug)`
+      );
+    }
+    return self;
+  };
+  const dispatchReplyItem = async (item, target, replyToMessage) => {
+    let raw;
+    try {
+      raw = await replyToMessage({
+        space: spaceRef,
+        messageId: params.id,
+        target,
+        content: item,
+        client,
+        config
+      });
+    } catch (err) {
+      if (err instanceof UnsupportedError) {
+        warnUnsupported(err, definition.name);
+        return;
+      }
+      throw err;
+    }
+    if (!raw?.id) {
+      throw new Error(
+        `Platform "${definition.name}" reply did not return a message id`
+      );
+    }
+    return wrapProviderMessage(
+      raw,
+      { client, config, definition, space, spaceRef },
+      "outbound"
+    );
+  };
   async function reply(...content) {
-    if (!definition.actions.replyToMessage) {
+    const replyToMessage = definition.actions.replyToMessage;
+    if (!replyToMessage) {
       warnUnsupported(
         UnsupportedError.action("reply", definition.name),
         definition.name
@@ -912,44 +928,13 @@ function buildMessage(params) {
       return content.length === 1 ? void 0 : [];
     }
     const resolved = await resolveContents(content);
+    const target = requireBuiltMessage("reply");
     const results = [];
     for (const item of resolved) {
-      let sendResult;
-      try {
-        sendResult = await definition.actions.replyToMessage({
-          space: spaceRef,
-          messageId: params.id,
-          content: item,
-          client,
-          config
-        });
-      } catch (err) {
-        if (err instanceof UnsupportedError) {
-          warnUnsupported(err, definition.name);
-          continue;
-        }
-        throw err;
-      }
-      if (!sendResult?.id) {
-        throw new Error(
-          `Platform "${definition.name}" reply did not return a message id`
-        );
+      const sent = await dispatchReplyItem(item, target, replyToMessage);
+      if (sent) {
+        results.push(sent);
       }
-      results.push(
-        buildMessage({
-          id: sendResult.id,
-          content: item,
-          sender: sendResult.sender,
-          timestamp: sendResult.timestamp ?? /* @__PURE__ */ new Date(),
-          extras: {},
-          spaceRef,
-          space,
-          definition,
-          client,
-          config,
-          direction: "outbound"
-        })
-      );
     }
     if (content.length === 1) {
       return results[0];
@@ -1131,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-7Q7KJKGL.js → chunk-QZ5DJ7VR.js}

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

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

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

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-DJQLFwWW.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-DJQLFwWW.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-LAGNM6I7.js";
+} from "./chunk-UWUPCIB4.js";
 import {
   voice
-} from "./chunk-7Q7KJKGL.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-XMAI2AAN.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-DJQLFwWW.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';