spectrum-ts 4.0.0 → 4.2.0

package/dist/{attachment-CEpGtZLm.d.ts → attachment-CnivEhr6.d.ts}

@@ -1,5 +1,5 @@
 import z__default from 'zod';
-import { C as ContentBuilder } from './types-Be0T6E0e.js';
+import { C as ContentBuilder } from './types-CyfLJXgu.js';
 
 declare const attachmentSchema: z__default.ZodObject<{
     type: z__default.ZodLiteral<"attachment">;

package/dist/{authoring-CP3vRza8.d.ts → authoring-b9AhXgPI.d.ts}

@@ -1,7 +1,7 @@
-import './attachment-CEpGtZLm.js';
+import './attachment-CnivEhr6.js';
 import vCard from 'vcf';
 import z__default from 'zod';
-import { U as User, C as ContentBuilder, M as Message, e as Space, h as ContentInput } from './types-Be0T6E0e.js';
+import { U as User, C as ContentBuilder, M as Message, S as Space, h as ContentInput } from './types-CyfLJXgu.js';
 
 declare const nameSchema: z__default.ZodObject<{
     formatted: z__default.ZodOptional<z__default.ZodString>;

package/dist/authoring.d.ts

@@ -1,6 +1,6 @@
-export { c as asAttachment } from './attachment-CEpGtZLm.js';
-export { q as asContact, s as asCustom, u as asGroup, w as asPoll, x as asPollOption, y as asRichlink, z as asText, A as asVoice } from './authoring-CP3vRza8.js';
-export { d as ProviderMessageRecord, $ as asReaction } from './types-Be0T6E0e.js';
+export { c as asAttachment } from './attachment-CnivEhr6.js';
+export { q as asContact, s as asCustom, u as asGroup, w as asPoll, x as asPollOption, y as asRichlink, z as asText, A as asVoice } from './authoring-b9AhXgPI.js';
+export { e as ProviderMessageRecord, $ as asReaction } from './types-CyfLJXgu.js';
 import 'zod';
 import 'vcf';
 import 'hotscript';

package/dist/authoring.js

@@ -1,13 +1,13 @@
 import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
+import {
+  asVoice
+} from "./chunk-FAIFTUV2.js";
 import {
   asRichlink
 } from "./chunk-ZR3TKZMT.js";
 import {
   asGroup
 } from "./chunk-LZXPLXZF.js";
-import {
-  asVoice
-} from "./chunk-FAIFTUV2.js";
 import {
   asPoll,
   asPollOption

package/dist/{chunk-PV4AVMNN.js → chunk-ARL2NOBO.js}

@@ -5,17 +5,17 @@ import {
 import {
   asContact
 } from "./chunk-A37PM5N2.js";
-import {
-  stream
-} from "./chunk-5XEFJBN2.js";
 import {
   fromVCard,
   toVCard
 } from "./chunk-6UZFVXQF.js";
+import {
+  stream
+} from "./chunk-5XEFJBN2.js";
 import {
   UnsupportedError,
   definePlatform
-} from "./chunk-OGTHPDG7.js";
+} from "./chunk-B52VPQO3.js";
 import {
   asAttachment,
   asCustom,

package/dist/{chunk-OGTHPDG7.js → chunk-B52VPQO3.js}

@@ -46,10 +46,10 @@ var resolveMimeType = (input, mimeType, contentLabel) => {
     `Unable to resolve MIME type for ${contentLabel}. Pass options.mimeType explicitly.`
   );
 };
-var cachedRead = (read) => {
+var cachedRead = (read2) => {
   let cached;
   return () => {
-    cached ??= read().catch((err) => {
+    cached ??= read2().catch((err) => {
       cached = void 0;
       throw err;
     });
@@ -61,16 +61,16 @@ var buildPhotoAction = (input, options, contentLabel) => {
     return { kind: "clear" };
   }
   const mimeType = resolveMimeType(input, options?.mimeType, contentLabel);
-  let read;
+  let read2;
   if (input instanceof URL) {
-    read = cachedRead(async () => (await fetchUrlBytes(input)).data);
+    read2 = cachedRead(async () => (await fetchUrlBytes(input)).data);
   } else if (typeof input === "string") {
-    read = cachedRead(() => readFile(input));
+    read2 = cachedRead(() => readFile(input));
   } else {
     const snapshot = Buffer.from(input);
-    read = cachedRead(async () => snapshot);
+    read2 = cachedRead(async () => snapshot);
   }
-  return { kind: "set", read, mimeType };
+  return { kind: "set", read: read2, mimeType };
 };
 
 // src/content/avatar.ts
@@ -116,7 +116,7 @@ function edit(content, target) {
       if (!resolved) {
         throw new Error("edit() requires content");
       }
-      if (resolved.type === "edit" || resolved.type === "reply" || resolved.type === "reaction" || resolved.type === "group" || resolved.type === "typing" || resolved.type === "rename" || resolved.type === "avatar" || resolved.type === "unsend") {
+      if (resolved.type === "edit" || resolved.type === "reply" || resolved.type === "reaction" || resolved.type === "group" || resolved.type === "typing" || resolved.type === "rename" || resolved.type === "avatar" || resolved.type === "unsend" || resolved.type === "read") {
         throw new Error(`edit() cannot wrap "${resolved.type}" content`);
       }
       return asEdit({ content: resolved, target });
@@ -138,11 +138,34 @@ function markdown(source, options) {
   return streamTextBuilder("markdown", source, options);
 }
 
-// src/content/rename.ts
+// src/content/read.ts
 import z5 from "zod";
-var renameSchema = z5.object({
-  type: z5.literal("rename"),
-  displayName: z5.string().min(1, "rename() displayName must be non-empty")
+var isMessage2 = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
+var readSchema2 = z5.object({
+  type: z5.literal("read"),
+  target: z5.custom(isMessage2, {
+    message: "read target must be a Message"
+  })
+});
+var asRead = (input) => readSchema2.parse({ type: "read", ...input });
+function read(target) {
+  return {
+    build: async () => {
+      if (target.direction !== "inbound") {
+        throw new Error(
+          `read() target must be an inbound message (got direction "${target.direction}", message id "${target.id}")`
+        );
+      }
+      return asRead({ target });
+    }
+  };
+}
+
+// src/content/rename.ts
+import z6 from "zod";
+var renameSchema = z6.object({
+  type: z6.literal("rename"),
+  displayName: z6.string().min(1, "rename() displayName must be non-empty")
 });
 function rename(displayName) {
   return {
@@ -151,15 +174,15 @@ function rename(displayName) {
 }
 
 // src/content/reply.ts
-import z6 from "zod";
-var isMessage2 = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
+import z7 from "zod";
+var isMessage3 = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
 var isContent2 = (v) => typeof v === "object" && v !== null && "type" in v && typeof v.type === "string";
-var replySchema = z6.object({
-  type: z6.literal("reply"),
-  content: z6.custom(isContent2, {
+var replySchema = z7.object({
+  type: z7.literal("reply"),
+  content: z7.custom(isContent2, {
     message: "reply content must be a Content value"
   }),
-  target: z6.custom(isMessage2, {
+  target: z7.custom(isMessage3, {
     message: "reply target must be a Message"
   })
 });
@@ -176,7 +199,7 @@ function reply(content, target) {
       if (!resolved) {
         throw new Error("reply() requires content");
       }
-      if (resolved.type === "reply" || resolved.type === "edit" || resolved.type === "reaction" || resolved.type === "group" || resolved.type === "typing" || resolved.type === "rename" || resolved.type === "avatar" || resolved.type === "unsend") {
+      if (resolved.type === "reply" || resolved.type === "edit" || resolved.type === "reaction" || resolved.type === "group" || resolved.type === "typing" || resolved.type === "rename" || resolved.type === "avatar" || resolved.type === "unsend" || resolved.type === "read") {
         throw new Error(`reply() cannot wrap "${resolved.type}" content`);
       }
       return asReply({ content: resolved, target });
@@ -185,10 +208,10 @@ function reply(content, target) {
 }
 
 // src/content/typing.ts
-import z7 from "zod";
-var typingSchema = z7.object({
-  type: z7.literal("typing"),
-  state: z7.enum(["start", "stop"])
+import z8 from "zod";
+var typingSchema = z8.object({
+  type: z8.literal("typing"),
+  state: z8.enum(["start", "stop"])
 });
 function typing(state = "start") {
   return {
@@ -197,11 +220,11 @@ function typing(state = "start") {
 }
 
 // src/content/unsend.ts
-import z8 from "zod";
-var isMessage3 = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
-var unsendSchema = z8.object({
-  type: z8.literal("unsend"),
-  target: z8.custom(isMessage3, {
+import z9 from "zod";
+var isMessage4 = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
+var unsendSchema = z9.object({
+  type: z9.literal("unsend"),
+  target: z9.custom(isMessage4, {
     message: "unsend target must be a Message"
   })
 });
@@ -545,7 +568,8 @@ var FIRE_AND_FORGET_TYPES = /* @__PURE__ */ new Set([
   "edit",
   "rename",
   "avatar",
-  "unsend"
+  "unsend",
+  "read"
 ]);
 var isFireAndForget = (item) => FIRE_AND_FORGET_TYPES.has(item.type) || item.__fireAndForget === true;
 var RESERVED_SPACE_KEYS = /* @__PURE__ */ new Set([
@@ -554,6 +578,7 @@ var RESERVED_SPACE_KEYS = /* @__PURE__ */ new Set([
   "send",
   "edit",
   "unsend",
+  "read",
   "getMessage",
   "rename",
   "avatar",
@@ -569,6 +594,7 @@ var RESERVED_MESSAGE_KEYS = /* @__PURE__ */ new Set([
   "id",
   "platform",
   "react",
+  "read",
   "reply",
   "sender",
   "space",
@@ -938,6 +964,9 @@ function buildSpace(params) {
     unsend: async (message) => {
       await space.send(unsend(message));
     },
+    read: async (message) => {
+      await space.send(read(message));
+    },
     getMessage: getMessageImpl,
     rename: async (displayName) => {
       await space.send(rename(displayName));
@@ -1010,6 +1039,15 @@ function buildMessage(params) {
     }
     await space.send(unsend(target));
   };
+  const read2 = async () => {
+    const target = requireBuiltMessage("read");
+    if (target.direction !== "inbound") {
+      throw new Error(
+        `cannot mark message ${target.id} as read: only inbound messages can be marked read (direction: "${target.direction}")`
+      );
+    }
+    await space.send(read(target));
+  };
   const buildSenderWithPlatform = () => {
     if (params.sender === void 0) {
       return;
@@ -1046,6 +1084,7 @@ function buildMessage(params) {
     direction: params.direction,
     platform: definition.name,
     react,
+    read: read2,
     reply: reply2,
     edit: edit2,
     unsend: unsend2,
@@ -1325,6 +1364,7 @@ export {
   markdownSchema,
   asMarkdown,
   markdown,
+  read,
   rename,
   reply,
   typing,

package/dist/{chunk-5VCWWPFW.js → chunk-DMPDLSFU.js}

@@ -2,12 +2,12 @@ import { createRequire as __spectrumCreateRequire } from "node:module"; const re
 import {
   asPollOption
 } from "./chunk-2D27WW5B.js";
-import {
-  cloud
-} from "./chunk-3GEJYGZK.js";
 import {
   asContact
 } from "./chunk-A37PM5N2.js";
+import {
+  cloud
+} from "./chunk-3GEJYGZK.js";
 import {
   mergeStreams,
   stream
@@ -15,7 +15,7 @@ import {
 import {
   UnsupportedError,
   definePlatform
-} from "./chunk-OGTHPDG7.js";
+} from "./chunk-B52VPQO3.js";
 import {
   asAttachment,
   asCustom,
@@ -644,6 +644,10 @@ var send = async (clients, spaceId, content) => {
   if (content.type === "typing") {
     return;
   }
+  if (content.type === "read") {
+    await primary(clients).messages.markRead(content.target.id);
+    return;
+  }
   const client = primary(clients);
   switch (content.type) {
     case "text":

package/dist/{chunk-57NECZQZ.js → chunk-N6THJDZV.js}

@@ -2,12 +2,12 @@ import { createRequire as __spectrumCreateRequire } from "node:module"; const re
 import {
   fusor
 } from "./chunk-34FQGGD7.js";
-import {
-  asGroup
-} from "./chunk-LZXPLXZF.js";
 import {
   asVoice
 } from "./chunk-FAIFTUV2.js";
+import {
+  asGroup
+} from "./chunk-LZXPLXZF.js";
 import {
   toVCard
 } from "./chunk-6UZFVXQF.js";
@@ -16,7 +16,7 @@ import {
   asMarkdown,
   definePlatform,
   renderInlineTokens
-} from "./chunk-OGTHPDG7.js";
+} from "./chunk-B52VPQO3.js";
 import {
   asAttachment,
   asCustom,
@@ -793,6 +793,8 @@ var send = async ({
       return await sendReaction(client, space, content);
     case "typing":
       return await sendTyping(client, space, content.state);
+    case "read":
+      return;
     case "edit":
       return await sendEdit(client, space, content);
     case "group":

package/dist/{chunk-W5HNZ7YT.js → chunk-NLMQ75LH.js}

@@ -10,27 +10,27 @@ 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 {
+  cloud
+} from "./chunk-3GEJYGZK.js";
+import {
+  mergeStreams,
+  stream
+} from "./chunk-5XEFJBN2.js";
 import {
   UnsupportedError,
   buildPhotoAction,
   definePlatform,
   markdownSchema,
   photoActionSchema
-} from "./chunk-OGTHPDG7.js";
+} from "./chunk-B52VPQO3.js";
 import {
   asAttachment,
   asCustom,
@@ -172,68 +172,38 @@ function effect(input, messageEffect) {
   };
 }
 
-// src/providers/imessage/content/read.ts
-import z4 from "zod";
-var isMessage = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
-var readSchema = z4.object({
-  type: z4.literal("read"),
-  __platform: z4.literal("iMessage"),
-  __fireAndForget: z4.literal(true),
-  target: z4.custom(isMessage, {
-    message: "read target must be a Message"
-  })
-});
-var isRead = (v) => readSchema.safeParse(v).success;
-function read(target) {
-  return {
-    build: async () => {
-      if (target.direction !== "inbound") {
-        throw new Error(
-          `read() target must be an inbound message (got direction "${target.direction}", message id "${target.id}")`
-        );
-      }
-      return readSchema.parse({
-        type: "read",
-        __platform: "iMessage",
-        __fireAndForget: true,
-        target
-      });
-    }
-  };
-}
-
 // 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 z5 from "zod";
+import z4 from "zod";
 var SHARED_PHONE = "shared";
 var isLocal = (client) => client instanceof IMessageSDK;
-var clientEntry = z5.object({
-  address: z5.string(),
-  token: z5.string(),
-  phone: z5.string()
+var clientEntry = z4.object({
+  address: z4.string(),
+  token: z4.string(),
+  phone: z4.string()
 });
-var configSchema = z5.union([
-  z5.object({ local: z5.literal(true) }),
-  z5.object({
-    local: z5.literal(false).optional().default(false),
-    clients: clientEntry.or(z5.array(clientEntry)).optional()
+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 = z5.object({});
-var spaceSchema = z5.object({
-  id: z5.string(),
-  type: z5.enum(["dm", "group"]),
-  phone: z5.string()
+var userSchema = z4.object({});
+var spaceSchema = z4.object({
+  id: z4.string(),
+  type: z4.enum(["dm", "group"]),
+  phone: z4.string()
 });
-var spaceParamsSchema = z5.object({
-  phone: z5.string().optional()
+var spaceParamsSchema = z4.object({
+  phone: z4.string().optional()
 });
-var messageSchema = z5.object({
-  partIndex: z5.number().int().nonnegative().optional(),
-  parentId: z5.string().optional()
+var messageSchema = z4.object({
+  partIndex: z4.number().int().nonnegative().optional(),
+  parentId: z4.string().optional()
 });
 
 // src/providers/imessage/auth.ts
@@ -2852,23 +2822,11 @@ var imessage = definePlatform("iMessage", {
       // local-mode iMessage is identical to the canonical form.
       background: async (space, input, opts) => {
         await space.send(background(input, opts));
-      },
-      // Sugar: `space.read(message)` → `space.send(read(message))`.
-      read: async (space, message) => {
-        await space.send(read(message));
       }
     }
   },
   message: {
-    schema: messageSchema,
-    actions: {
-      // Sugar: `message.read()` → `message.space.send(read(self))`.
-      // `buildMessage` injects the message as the first argument; callers
-      // pass nothing.
-      read: async (message) => {
-        await message.space.send(read(message));
-      }
-    }
+    schema: messageSchema
   },
   messages: ({ client, projectConfig }) => isLocal(client) ? messages2(client) : messages4(client, projectConfig),
   send: async ({ space, content, client }) => {
@@ -2941,12 +2899,12 @@ var imessage = definePlatform("iMessage", {
       await handleAvatar(client, space, content);
       return;
     }
-    if (isBackground(content)) {
-      await handleBackground(client, space, content);
+    if (content.type === "read") {
+      await handleRead(client, space);
       return;
     }
-    if (isRead(content)) {
-      await handleRead(client, space);
+    if (isBackground(content)) {
+      await handleBackground(client, space, content);
       return;
     }
     if (isCustomizedMiniApp(content)) {
@@ -3018,6 +2976,5 @@ export {
   background,
   customizedMiniApp,
   effect,
-  read,
   imessage
 };

package/dist/{chunk-VEF6FUE7.js → chunk-WXLQNANA.js}

@@ -9,7 +9,7 @@ import {
 import {
   UnsupportedError,
   definePlatform
-} from "./chunk-OGTHPDG7.js";
+} from "./chunk-B52VPQO3.js";
 import {
   asAttachment,
   asCustom,
@@ -350,6 +350,9 @@ var send = async (client, space, content) => {
   if (content.type === "typing") {
     return;
   }
+  if (content.type === "read") {
+    return;
+  }
   return await sendContent(client, space, content);
 };
 var sendContent = async (client, space, content, threadTs) => {

package/dist/elysia.d.ts

@@ -0,0 +1,94 @@
+import { Elysia } from 'elysia';
+import { W as WebhookHandler } from './types-ZgFTj5hJ.js';
+export { M as Message, S as Space } from './types-CyfLJXgu.js';
+import 'hotscript';
+import 'zod';
+
+/**
+ * The minimal structural surface of a Spectrum instance the plugin needs. Kept
+ * structural (rather than importing the generic `SpectrumInstance<Providers>`)
+ * so the plugin stays decoupled from provider typing; a real instance is
+ * assignable via its Web `Request` webhook overload.
+ */
+interface WebhookReceiver {
+    webhook(request: Request, handler: WebhookHandler): Promise<Response>;
+}
+interface SpectrumPluginOptions {
+    /** The Spectrum instance returned by `await Spectrum({...})`. */
+    app: WebhookReceiver;
+    /**
+     * Invoked once per inbound message, fire-and-forget after the response — the
+     * same `(space, message)` contract as `app.webhook(request, handler)`. Covers
+     * both native Spectrum webhooks and fusor webhooks identically.
+     */
+    onMessage: WebhookHandler;
+    /**
+     * Route the webhook is mounted on.
+     *
+     * @default "/spectrum/webhook"
+     */
+    path?: string;
+}
+/**
+ * Mount a Spectrum webhook endpoint on an Elysia app.
+ *
+ * @example
+ * ```ts
+ * import { Elysia } from "elysia";
+ * import { Spectrum } from "spectrum-ts";
+ * import { spectrum } from "spectrum-ts/elysia";
+ *
+ * const app = await Spectrum({ ...,  webhookSecret: process.env.SPECTRUM_WEBHOOK_SECRET });
+ *
+ * new Elysia()
+ *   .use(spectrum({
+ *     app,
+ *     onMessage: async (space, message) => {
+ *       if (message.content.type === "text") await space.send(`echo: ${message.content.text}`);
+ *     },
+ *   }))
+ *   .listen(3000);
+ * ```
+ */
+declare function spectrum(options: SpectrumPluginOptions): Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+
+export { type SpectrumPluginOptions, WebhookHandler, spectrum };

package/dist/elysia.js

@@ -0,0 +1,15 @@
+import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
+
+// src/elysia.ts
+import { Elysia } from "elysia";
+function spectrum(options) {
+  const { app, onMessage, path = "/spectrum/webhook" } = options;
+  return new Elysia({ name: "spectrum-webhook", seed: path }).post(
+    path,
+    ({ request }) => app.webhook(request, onMessage),
+    { parse: "none" }
+  );
+}
+export {
+  spectrum
+};