spectrum-ts 1.1.1 → 1.2.0

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-I7EKZS5C.js}

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

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

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

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

@@ -658,6 +658,43 @@ var warnUnsupported = (err, fallbackPlatform) => {
     supportsAnsiColor() ? `${ANSI_YELLOW}${body}${ANSI_RESET}` : body
   );
 };
+var contentPlatform = (content) => {
+  const platform = content.__platform;
+  return typeof platform === "string" ? platform : void 0;
+};
+var findUnsupportedPlatformContent = (content, platform) => {
+  const scopedPlatform = contentPlatform(content);
+  if (scopedPlatform && scopedPlatform !== platform) {
+    return scopedPlatform;
+  }
+  if (content.type !== "group") {
+    return;
+  }
+  for (const item of content.items) {
+    const nested = item.content;
+    if (typeof nested !== "object" || nested === null || !("type" in nested)) {
+      continue;
+    }
+    const unsupported = findUnsupportedPlatformContent(
+      nested,
+      platform
+    );
+    if (unsupported) {
+      return unsupported;
+    }
+  }
+};
+var unsupportedPlatformContentError = (content, platform) => {
+  const requiredPlatform = findUnsupportedPlatformContent(content, platform);
+  if (!requiredPlatform) {
+    return;
+  }
+  return UnsupportedError.content(
+    content.type,
+    platform,
+    `requires ${requiredPlatform}`
+  );
+};
 var providerMessageCoreKeys = /* @__PURE__ */ new Set([
   "content",
   "id",
@@ -672,29 +709,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 +746,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 +786,16 @@ function buildSpace(params) {
     }
   }
   async function dispatchSend(item) {
-    let sendResult;
+    let raw;
     try {
-      sendResult = await definition.actions.send({
+      const platformError = unsupportedPlatformContentError(
+        item,
+        definition.name
+      );
+      if (platformError) {
+        throw platformError;
+      }
+      raw = await definition.actions.send({
         ...typingCtx,
         content: item
       });
@@ -752,46 +806,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 +861,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 +934,16 @@ function buildMessage(params) {
     return self;
   };
   const dispatchReplyItem = async (item, target, replyToMessage) => {
-    let sendResult;
+    let raw;
     try {
-      sendResult = await replyToMessage({
+      const platformError = unsupportedPlatformContentError(
+        item,
+        definition.name
+      );
+      if (platformError) {
+        throw platformError;
+      }
+      raw = await replyToMessage({
         space: spaceRef,
         messageId: params.id,
         target,
@@ -929,24 +958,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;
@@ -993,6 +1014,14 @@ function buildMessage(params) {
         if (!resolved) {
           return;
         }
+        const platformError = unsupportedPlatformContentError(
+          resolved,
+          definition.name
+        );
+        if (platformError) {
+          warnUnsupported(platformError, definition.name);
+          return;
+        }
         try {
           await definition.actions.editMessage({
             space: spaceRef,
@@ -1146,6 +1175,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) {
@@ -1205,6 +1242,18 @@ function definePlatform(name, def) {
       __definition: fullDef
     };
   };
+  narrower.is = ((input) => {
+    if (typeof input !== "object" || input === null) {
+      return false;
+    }
+    if ("__platform" in input) {
+      return input.__platform === name;
+    }
+    if ("platform" in input) {
+      return input.platform === name;
+    }
+    return false;
+  });
   if (def.static) {
     Object.assign(narrower, def.static);
   }
@@ -1215,6 +1264,7 @@ export {
   readSchema,
   streamSchema,
   bufferToStream,
+  attachmentSchema,
   asAttachment,
   attachment,
   fromVCard,
@@ -1223,6 +1273,7 @@ export {
   contact,
   asCustom,
   custom,
+  textSchema,
   asText,
   text,
   resolveContents,

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-Dvp0I86h.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-Dvp0I86h.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-K3CTEGCZ.js";
 import {
   voice
-} from "./chunk-7VSE6V3Q.js";
+} from "./chunk-I7EKZS5C.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-UQPIWAHH.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,12 +1,14 @@
-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 { a as ContentInput, C as ContentBuilder, o as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage, i as ManagedStream } from '../../types-Dvp0I86h.js';
 import * as zod_v4_core from 'zod/v4/core';
 import * as z from 'zod';
 import z__default from 'zod';
-import { AdvancedIMessage } from '@photon-ai/advanced-imessage';
+import { MessageEffect, AdvancedIMessage } from '@photon-ai/advanced-imessage';
 import { IMessageSDK } from '@photon-ai/imessage-kit';
 import 'hotscript';
 
+type IMessageMessageEffect = MessageEffect;
+declare function effect(input: ContentInput, messageEffect: IMessageMessageEffect): ContentBuilder;
+
 type IMessageClient = IMessageSDK | AdvancedIMessage[];
 declare const userSchema: z__default.ZodObject<{}, z__default.core.$strip>;
 declare const spaceSchema: z__default.ZodObject<{
@@ -76,6 +78,24 @@ declare const imessage: Platform<PlatformDef<"iMessage", z.ZodUnion<readonly [z.
             }[] | undefined;
         };
     }) => ManagedStream<IMessageMessage>;
-}>> & Readonly<Record<never, never>>;
+}>> & Readonly<{
+    effect: {
+        message: {
+            readonly slam: "com.apple.MobileSMS.expressivesend.impact";
+            readonly loud: "com.apple.MobileSMS.expressivesend.loud";
+            readonly gentle: "com.apple.MobileSMS.expressivesend.gentle";
+            readonly invisible: "com.apple.MobileSMS.expressivesend.invisibleink";
+            readonly confetti: "com.apple.messages.effect.CKConfettiEffect";
+            readonly fireworks: "com.apple.messages.effect.CKFireworksEffect";
+            readonly balloons: "com.apple.messages.effect.CKBalloonEffect";
+            readonly heart: "com.apple.messages.effect.CKHeartEffect";
+            readonly lasers: "com.apple.messages.effect.CKLasersEffect";
+            readonly celebration: "com.apple.messages.effect.CKHappyBirthdayEffect";
+            readonly sparkles: "com.apple.messages.effect.CKSparklesEffect";
+            readonly spotlight: "com.apple.messages.effect.CKSpotlightEffect";
+            readonly echo: "com.apple.messages.effect.CKEchoEffect";
+        };
+    };
+}>;
 
-export { imessage };
+export { type IMessageMessageEffect, effect, imessage };