spectrum-ts 0.5.0 → 0.6.0

package/dist/chunk-XZTTLPHE.js

@@ -0,0 +1,341 @@
+// src/content/text.ts
+import z from "zod";
+var textSchema = z.object({
+  type: z.literal("text"),
+  text: z.string().nonempty()
+});
+var asText = (text2) => textSchema.parse({ type: "text", text: text2 });
+function text(text2) {
+  return {
+    build: async () => asText(text2)
+  };
+}
+
+// src/content/resolve.ts
+var resolveContents = (items) => Promise.all(
+  items.map((c) => typeof c === "string" ? text(c).build() : c.build())
+);
+
+// src/platform/build.ts
+function buildSpace(params) {
+  const { spaceRef, extras, typingCtx, definition, client, config } = params;
+  let space;
+  async function sendImpl(...content) {
+    const resolved = await resolveContents(content);
+    const results = [];
+    for (const item of resolved) {
+      const sendResult = await definition.actions.send({
+        ...typingCtx,
+        content: item
+      });
+      if (!sendResult?.id) {
+        throw new Error(
+          `Platform "${definition.name}" send did not return a message id`
+        );
+      }
+      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"
+        })
+      );
+    }
+    return content.length === 1 && results[0] ? results[0] : results;
+  }
+  space = {
+    ...extras,
+    ...spaceRef,
+    send: sendImpl,
+    edit: async (message, newContent) => {
+      await message.edit(newContent);
+    },
+    startTyping: async () => {
+      await definition.actions.startTyping?.(typingCtx);
+    },
+    stopTyping: async () => {
+      await definition.actions.stopTyping?.(typingCtx);
+    },
+    responding: async (fn) => {
+      await definition.actions.startTyping?.(typingCtx);
+      try {
+        return await fn();
+      } finally {
+        await definition.actions.stopTyping?.(typingCtx).catch(() => {
+        });
+      }
+    }
+  };
+  return space;
+}
+function buildMessage(params) {
+  const { definition, client, config, spaceRef, space } = params;
+  const react = async (reaction) => {
+    if (!definition.actions.reactToMessage) {
+      return;
+    }
+    await definition.actions.reactToMessage({
+      space: spaceRef,
+      messageId: params.id,
+      reaction,
+      client,
+      config
+    });
+  };
+  async function reply(...content) {
+    if (!definition.actions.replyToMessage) {
+      throw new Error(
+        `Platform "${definition.name}" does not support replying to messages`
+      );
+    }
+    const resolved = await resolveContents(content);
+    const results = [];
+    for (const item of resolved) {
+      const sendResult = await definition.actions.replyToMessage({
+        space: spaceRef,
+        messageId: params.id,
+        content: item,
+        client,
+        config
+      });
+      if (!sendResult?.id) {
+        throw new Error(
+          `Platform "${definition.name}" reply did not return a message id`
+        );
+      }
+      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"
+        })
+      );
+    }
+    return content.length === 1 && results[0] ? results[0] : results;
+  }
+  const senderWithPlatform = params.sender === void 0 ? void 0 : { ...params.sender, __platform: definition.name };
+  if (params.direction === "outbound") {
+    return {
+      ...params.extras,
+      id: params.id,
+      content: params.content,
+      direction: "outbound",
+      platform: definition.name,
+      react,
+      reply,
+      edit: async (newContent) => {
+        if (!definition.actions.editMessage) {
+          throw new Error(
+            `Platform "${definition.name}" does not support editing messages`
+          );
+        }
+        const [resolved] = await resolveContents([newContent]);
+        if (!resolved) {
+          return;
+        }
+        await definition.actions.editMessage({
+          space: spaceRef,
+          messageId: params.id,
+          content: resolved,
+          client,
+          config
+        });
+      },
+      sender: senderWithPlatform,
+      space,
+      timestamp: params.timestamp
+    };
+  }
+  return {
+    ...params.extras,
+    id: params.id,
+    content: params.content,
+    direction: "inbound",
+    platform: definition.name,
+    react,
+    reply,
+    sender: senderWithPlatform,
+    space,
+    timestamp: params.timestamp
+  };
+}
+
+// src/platform/define.ts
+function createPlatformInstance(def, runtime) {
+  const isPlatformUser = (value) => {
+    return typeof value === "object" && value !== null && "__platform" in value && value.__platform === def.name;
+  };
+  const normalizeSpaceArgs = (args) => {
+    if (args.length === 0) {
+      return { users: [], params: void 0 };
+    }
+    const [first, ...rest] = args;
+    if (Array.isArray(first)) {
+      return {
+        users: first,
+        params: rest[0]
+      };
+    }
+    if (!isPlatformUser(first)) {
+      return {
+        users: [],
+        params: first
+      };
+    }
+    const last = args.at(-1);
+    if (last !== void 0 && !isPlatformUser(last)) {
+      return {
+        users: args.slice(0, -1),
+        params: last
+      };
+    }
+    return {
+      users: args,
+      params: void 0
+    };
+  };
+  const base = {
+    async user(userID) {
+      const resolved = await def.user.resolve({
+        input: { userID },
+        client: runtime.client,
+        config: runtime.config
+      });
+      return {
+        ...resolved,
+        __platform: def.name
+      };
+    },
+    async space(...args) {
+      const { users, params } = normalizeSpaceArgs(args);
+      let parsedParams = params;
+      if (params !== void 0 && def.space.params) {
+        parsedParams = def.space.params.parse(params);
+      }
+      const resolved = await def.space.resolve({
+        input: { users, params: parsedParams },
+        client: runtime.client,
+        config: runtime.config
+      });
+      const parsedSpace = def.space.schema ? def.space.schema.parse(resolved) : resolved;
+      const spaceRef = {
+        id: parsedSpace.id,
+        __platform: def.name
+      };
+      const typingCtx = {
+        space: spaceRef,
+        client: runtime.client,
+        config: runtime.config
+      };
+      return buildSpace({
+        spaceRef,
+        extras: parsedSpace,
+        typingCtx,
+        definition: def,
+        client: runtime.client,
+        config: runtime.config
+      });
+    }
+  };
+  const eventProperties = {};
+  for (const eventName of Object.keys(def.events)) {
+    if (eventName === "messages") {
+      continue;
+    }
+    const producer = def.events[eventName];
+    if (producer) {
+      eventProperties[eventName] = producer({
+        client: runtime.client,
+        config: runtime.config
+      });
+    }
+  }
+  return Object.assign(base, eventProperties);
+}
+function definePlatform(name, def) {
+  const fullDef = { name, ...def };
+  const platformCache = /* @__PURE__ */ new WeakMap();
+  const narrowSpectrum = (spectrum) => {
+    const cached = platformCache.get(spectrum);
+    if (cached) {
+      return cached;
+    }
+    const runtime = spectrum.__internal.platforms.get(name);
+    if (!runtime) {
+      throw new Error(`Platform "${name}" is not registered`);
+    }
+    const instance = createPlatformInstance(
+      fullDef,
+      runtime
+    );
+    platformCache.set(spectrum, instance);
+    return instance;
+  };
+  const narrowSpace = (input) => {
+    if (input.__platform !== name) {
+      throw new Error(
+        `Expected space from "${name}", got "${input.__platform}"`
+      );
+    }
+    return input;
+  };
+  const narrowMessage = (input) => {
+    if (input.platform !== name) {
+      throw new Error(
+        `Expected message from "${name}", got "${input.platform}"`
+      );
+    }
+    return input;
+  };
+  const narrower = ((input) => {
+    if ("__providers" in input && "__internal" in input) {
+      return narrowSpectrum(input);
+    }
+    if ("__platform" in input && "send" in input) {
+      return narrowSpace(input);
+    }
+    if ("platform" in input && "sender" in input && "space" in input) {
+      return narrowMessage(input);
+    }
+    throw new Error("Invalid input to platform narrowing function");
+  });
+  narrower.config = (config) => {
+    const resolvedConfig = config ?? {};
+    return {
+      __tag: "PlatformProviderConfig",
+      __def: void 0,
+      __name: name,
+      config: resolvedConfig,
+      __definition: fullDef
+    };
+  };
+  if (def.static) {
+    Object.assign(narrower, def.static);
+  }
+  return narrower;
+}
+
+export {
+  asText,
+  text,
+  resolveContents,
+  buildSpace,
+  buildMessage,
+  definePlatform
+};

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { C as ContentBuilder, U as User, 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, M as Message } from './types-CfiD_00g.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-CfiD_00g.js';
+import { C as ContentBuilder, U as User, 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-DZMHfgYQ.js';
+export { A as AnyPlatformDef, E as EventProducer, M as Message, h as PlatformInstance, i as PlatformMessage, j as PlatformSpace, k as PlatformUser, l as SchemaMessage } from './types-DZMHfgYQ.js';
 import vCard from 'vcf';
 import z__default from 'zod';
 export { M as ManagedStream, m as mergeStreams, s as stream } from './stream-DGy4geUK.js';
@@ -161,9 +161,11 @@ declare function definePlatform<_Name extends string, _ConfigSchema extends z__d
 }): Platform<PlatformDef<_Name, _ConfigSchema, _UserSchema, _SpaceSchema, _SpaceParamsSchema, _Client, _ResolvedUser, _ResolvedSpace, _MessageSchema, _MessageType, _Events>> & Readonly<_Static>;
 
 type SpectrumInstance<Providers extends PlatformProviderConfig[] = PlatformProviderConfig[]> = SpectrumLike<Providers> & CustomEventStreams<Providers> & {
-    readonly messages: AsyncIterable<[Space, Message]>;
+    readonly messages: AsyncIterable<[Space, InboundMessage]>;
     stop(): Promise<void>;
-    send(space: Space, ...content: [ContentInput, ...ContentInput[]]): Promise<void>;
+    send(space: Space, content: ContentInput): Promise<OutboundMessage>;
+    send(space: Space, ...content: [ContentInput, ContentInput, ...ContentInput[]]): Promise<OutboundMessage[]>;
+    edit(message: OutboundMessage, newContent: ContentInput): Promise<void>;
     responding<T>(space: Space, fn: () => T | Promise<T>): Promise<T>;
 };
 declare function Spectrum<const Providers extends PlatformProviderConfig[]>(options: {
@@ -216,4 +218,4 @@ declare const cloud: {
 declare const fromVCard: (vcf: string) => ContactInput;
 declare const toVCard: (contact: Contact) => Promise<string>;
 
-export { type CloudPlatform, type Contact, type ContactAddress, type ContactDetails, type ContactEmail, type ContactInput, type ContactName, type ContactOrg, type ContactPhone, Content, ContentBuilder, ContentInput, type DedicatedTokenData, type ImessageInfoData, Message, Platform, PlatformDef, PlatformProviderConfig, type PlatformStatus, type PlatformsData, type SharedTokenData, Space, Spectrum, SpectrumCloudError, type SpectrumInstance, type SubscriptionData, type SubscriptionStatus, type TokenData, User, type Voice, attachment, cloud, contact, custom, definePlatform, fromVCard, resolveContents, text, toVCard, voice };
+export { type CloudPlatform, type Contact, type ContactAddress, type ContactDetails, type ContactEmail, type ContactInput, type ContactName, type ContactOrg, type ContactPhone, Content, ContentBuilder, ContentInput, type DedicatedTokenData, type ImessageInfoData, Platform, PlatformDef, PlatformProviderConfig, type PlatformStatus, type PlatformsData, type SharedTokenData, Space, Spectrum, SpectrumCloudError, type SpectrumInstance, type SubscriptionData, type SubscriptionStatus, type TokenData, User, type Voice, attachment, cloud, contact, custom, definePlatform, fromVCard, resolveContents, text, toVCard, voice };

package/dist/index.js

@@ -15,10 +15,12 @@ import {
   toVCard
 } from "./chunk-UZWRB3FZ.js";
 import {
+  buildMessage,
+  buildSpace,
   definePlatform,
   resolveContents,
   text
-} from "./chunk-XEEDIGVK.js";
+} from "./chunk-XZTTLPHE.js";
 
 // src/content/voice.ts
 import { createReadStream } from "fs";
@@ -207,72 +209,27 @@ async function Spectrum(options) {
           __platform: definition.name
         };
         const typingCtx = { space: spaceRef, client, config };
-        const space = {
-          ...spaceRef,
-          send: async (...content) => {
-            const resolved = await resolveContents(content);
-            for (const item of resolved) {
-              await definition.actions.send({
-                ...typingCtx,
-                content: item
-              });
-            }
-          },
-          startTyping: async () => {
-            await definition.actions.startTyping?.(typingCtx);
-          },
-          stopTyping: async () => {
-            await definition.actions.stopTyping?.(typingCtx);
-          },
-          responding: async (fn) => {
-            await definition.actions.startTyping?.(typingCtx);
-            try {
-              return await fn();
-            } finally {
-              await definition.actions.stopTyping?.(typingCtx).catch(() => {
-              });
-            }
-          }
-        };
-        const normalizedMessage = {
-          ...parsedExtra,
+        const space = buildSpace({
+          spaceRef,
+          extras: {},
+          typingCtx,
+          definition,
+          client,
+          config
+        });
+        const normalizedMessage = buildMessage({
           id: msg.id,
           content: msg.content,
-          platform: definition.name,
-          react: async (reaction) => {
-            if (!definition.actions.reactToMessage) {
-              return;
-            }
-            await definition.actions.reactToMessage({
-              space: spaceRef,
-              messageId: msg.id,
-              reaction,
-              client,
-              config
-            });
-          },
-          reply: async (...content) => {
-            if (!definition.actions.replyToMessage) {
-              return;
-            }
-            const resolved = await resolveContents(content);
-            for (const item of resolved) {
-              await definition.actions.replyToMessage({
-                space: spaceRef,
-                messageId: msg.id,
-                content: item,
-                client,
-                config
-              });
-            }
-          },
-          sender: {
-            ...msg.sender,
-            __platform: definition.name
-          },
+          sender: msg.sender,
+          timestamp: msg.timestamp ?? /* @__PURE__ */ new Date(),
+          extras: parsedExtra,
+          spaceRef,
           space,
-          timestamp: msg.timestamp ?? /* @__PURE__ */ new Date()
-        };
+          definition,
+          client,
+          config,
+          direction: "inbound"
+        });
         yield [space, normalizedMessage];
       }
     };
@@ -383,8 +340,13 @@ async function Spectrum(options) {
     __internal: { platforms: platformStates },
     messages,
     stop: stopOnce,
-    send: async (space, ...content) => {
-      await space.send(...content);
+    send: (async (space, ...content) => {
+      return content.length === 1 ? await space.send(content[0]) : await space.send(
+        ...content
+      );
+    }),
+    edit: async (message, newContent) => {
+      await message.edit(newContent);
     },
     responding: async (space, fn) => {
       return space.responding(fn);

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

@@ -3,7 +3,7 @@ import { AdvancedIMessage } from '@photon-ai/advanced-imessage';
 import { IMessageSDK } from '@photon-ai/imessage-kit';
 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-CfiD_00g.js';
+import { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-DZMHfgYQ.js';
 import * as zod_v4_core from 'zod/v4/core';
 import 'hotscript';
 

package/dist/providers/imessage/index.js

@@ -13,7 +13,7 @@ import {
 import {
   asText,
   definePlatform
-} from "../../chunk-XEEDIGVK.js";
+} from "../../chunk-XZTTLPHE.js";
 
 // src/providers/imessage/index.ts
 import { createClient as createClient2, directChat } from "@photon-ai/advanced-imessage";
@@ -114,6 +114,14 @@ import { Readable } from "stream";
 import {
   readAttachmentBytes
 } from "@photon-ai/imessage-kit";
+var toSendResult = (result) => {
+  if (!result.message?.id) {
+    throw new Error(
+      "iMessage local send did not return a message id \u2014 track upstream in @photon-ai/imessage-kit"
+    );
+  }
+  return { id: result.message.id, timestamp: result.sentAt };
+};
 var DEFAULT_ATTACHMENT_NAME = "attachment";
 var VCARD_MIME_TYPES = /* @__PURE__ */ new Set([
   "text/vcard",
@@ -180,6 +188,9 @@ var messages = (client) => stream((emit, end) => {
   let lastPromise = Promise.resolve();
   client.startWatching({
     onMessage: (message) => {
+      if (message.isFromMe) {
+        return;
+      }
       lastPromise = lastPromise.then(() => toMessages(message)).then((ms) => {
         for (const m of ms) {
           emit(m);
@@ -199,7 +210,7 @@ var sendTempFile = async (client, spaceId, name, data) => {
   const tmp = join(dir, safeName);
   await writeFile(tmp, data);
   try {
-    await client.send(spaceId, { attachments: [tmp] });
+    return await client.send(spaceId, { attachments: [tmp] });
   } finally {
     await rm(dir, { recursive: true, force: true }).catch(() => {
     });
@@ -208,23 +219,26 @@ var sendTempFile = async (client, spaceId, name, data) => {
 var send = async (client, spaceId, content) => {
   switch (content.type) {
     case "text":
-      await client.send(spaceId, content.text);
-      break;
+      return toSendResult(await client.send(spaceId, content.text));
     case "attachment":
-      await sendTempFile(client, spaceId, content.name, await content.read());
-      break;
+      return toSendResult(
+        await sendTempFile(client, spaceId, content.name, await content.read())
+      );
     case "contact": {
       const vcf = await toVCard(content);
-      await sendTempFile(
-        client,
-        spaceId,
-        vcardFileName(content),
-        Buffer.from(vcf, "utf8")
+      return toSendResult(
+        await sendTempFile(
+          client,
+          spaceId,
+          vcardFileName(content),
+          Buffer.from(vcf, "utf8")
+        )
       );
-      break;
     }
     default:
-      break;
+      throw new Error(
+        `Unsupported iMessage local content type: ${content.type}`
+      );
   }
 };
 
@@ -359,6 +373,10 @@ var ensureM4a = async (buffer, mimeType) => {
 };
 
 // src/providers/imessage/remote.ts
+var toSendResult2 = (receipt) => ({
+  id: receipt.guid,
+  timestamp: /* @__PURE__ */ new Date()
+});
 var VCARD_MIME_TYPES2 = /* @__PURE__ */ new Set([
   "text/vcard",
   "text/x-vcard",
@@ -425,6 +443,9 @@ var clientStream = (client) => {
     (async () => {
       try {
         for await (const event of sub) {
+          if (event.message.isFromMe) {
+            continue;
+          }
           for (const message of await toMessages2(client, event)) {
             emit(message);
           }
@@ -469,27 +490,27 @@ var stopTyping = async (clients, spaceId) => {
 var send2 = async (clients, spaceId, content) => {
   const remote = clients[0];
   if (!remote) {
-    return;
+    throw new Error("No remote iMessage client available");
   }
+  const chat = chatGuid(spaceId);
   switch (content.type) {
     case "text":
-      await remote.messages.send(chatGuid(spaceId), content.text);
-      break;
+      return toSendResult2(await remote.messages.send(chat, content.text));
     case "attachment": {
       const attachment = await remote.attachments.upload({
         data: await content.read(),
         fileName: content.name,
         mimeType: content.mimeType
       });
-      await remote.messages.send(chatGuid(spaceId), "", {
-        attachment: attachment.guid
-      });
-      break;
+      return toSendResult2(
+        await remote.messages.send(chat, "", {
+          attachment: attachment.guid
+        })
+      );
     }
     case "contact": {
       const attachment = await sendContactAttachment(remote, content);
-      await remote.messages.send(chatGuid(spaceId), "", { attachment });
-      break;
+      return toSendResult2(await remote.messages.send(chat, "", { attachment }));
     }
     case "voice": {
       const { buffer } = await ensureM4a(
@@ -501,11 +522,12 @@ var send2 = async (clients, spaceId, content) => {
         fileName: content.name ?? "voice.m4a",
         mimeType: "audio/x-m4a"
       });
-      await remote.messages.send(chatGuid(spaceId), "", {
-        attachment: attachment.guid,
-        audioMessage: true
-      });
-      break;
+      return toSendResult2(
+        await remote.messages.send(chat, "", {
+          attachment: attachment.guid,
+          audioMessage: true
+        })
+      );
     }
     default:
       throw new Error(`Unsupported iMessage content type: ${content.type}`);
@@ -514,30 +536,33 @@ var send2 = async (clients, spaceId, content) => {
 var replyToMessage = async (clients, spaceId, msgId, content) => {
   const remote = clients[0];
   if (!remote) {
-    return;
+    throw new Error("No remote iMessage client available");
   }
   const chat = chatGuid(spaceId);
   const replyTo = messageGuid(msgId);
   switch (content.type) {
     case "text":
-      await remote.messages.send(chat, content.text, { replyTo });
-      break;
+      return toSendResult2(
+        await remote.messages.send(chat, content.text, { replyTo })
+      );
     case "attachment": {
       const attachment = await remote.attachments.upload({
         data: await content.read(),
         fileName: content.name,
         mimeType: content.mimeType
       });
-      await remote.messages.send(chat, "", {
-        attachment: attachment.guid,
-        replyTo
-      });
-      break;
+      return toSendResult2(
+        await remote.messages.send(chat, "", {
+          attachment: attachment.guid,
+          replyTo
+        })
+      );
     }
     case "contact": {
       const attachment = await sendContactAttachment(remote, content);
-      await remote.messages.send(chat, "", { attachment, replyTo });
-      break;
+      return toSendResult2(
+        await remote.messages.send(chat, "", { attachment, replyTo })
+      );
     }
     case "voice": {
       const { buffer } = await ensureM4a(
@@ -549,17 +574,32 @@ var replyToMessage = async (clients, spaceId, msgId, content) => {
         fileName: content.name ?? "voice.m4a",
         mimeType: "audio/x-m4a"
       });
-      await remote.messages.send(chat, "", {
-        attachment: attachment.guid,
-        audioMessage: true,
-        replyTo
-      });
-      break;
+      return toSendResult2(
+        await remote.messages.send(chat, "", {
+          attachment: attachment.guid,
+          audioMessage: true,
+          replyTo
+        })
+      );
     }
     default:
       throw new Error(`Unsupported iMessage content type: ${content.type}`);
   }
 };
+var editMessage = async (clients, spaceId, msgId, content) => {
+  if (content.type !== "text") {
+    throw new Error("iMessage only supports editing text content");
+  }
+  const remote = clients[0];
+  if (!remote) {
+    throw new Error("No remote iMessage client available");
+  }
+  await remote.messages.edit(
+    chatGuid(spaceId),
+    messageGuid(msgId),
+    content.text
+  );
+};
 var reactToMessage = async (clients, spaceId, msgId, reaction) => {
   const remote = clients[0];
   if (!remote) {
@@ -671,10 +711,9 @@ var imessage = definePlatform("iMessage", {
   actions: {
     send: async ({ space, content, client }) => {
       if (isLocal(client)) {
-        await send(client, space.id, content);
-      } else {
-        await send2(client, space.id, content);
+        return await send(client, space.id, content);
       }
+      return await send2(client, space.id, content);
     },
     startTyping: async ({ space, client }) => {
       if (isLocal(client)) {
@@ -696,9 +735,19 @@ var imessage = definePlatform("iMessage", {
     },
     replyToMessage: async ({ space, messageId, content, client }) => {
       if (isLocal(client)) {
-        return;
+        throw new Error(
+          "iMessage local mode does not support replying to messages"
+        );
+      }
+      return await replyToMessage(client, space.id, messageId, content);
+    },
+    editMessage: async ({ space, messageId, content, client }) => {
+      if (isLocal(client)) {
+        throw new Error(
+          "iMessage local mode does not support editing messages"
+        );
       }
-      await replyToMessage(client, space.id, messageId, content);
+      await editMessage(client, space.id, messageId, content);
     }
   }
 });

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

@@ -1,4 +1,4 @@
-import { d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-CfiD_00g.js';
+import { d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-DZMHfgYQ.js';
 import * as node_readline from 'node:readline';
 import z__default from 'zod';
 import 'hotscript';

package/dist/providers/terminal/index.js

@@ -1,6 +1,6 @@
 import {
   definePlatform
-} from "../../chunk-XEEDIGVK.js";
+} from "../../chunk-XZTTLPHE.js";
 
 // src/providers/terminal/index.ts
 import { createInterface } from "readline";
@@ -49,9 +49,13 @@ var terminal = definePlatform("terminal", {
   },
   actions: {
     send: async ({ content }) => {
-      if (content.type === "text") {
-        console.log(content.text);
+      if (content.type !== "text") {
+        throw new Error(
+          `Terminal provider only supports text content, got "${content.type}"`
+        );
       }
+      console.log(content.text);
+      return { id: crypto.randomUUID(), timestamp: /* @__PURE__ */ new Date() };
     }
   }
 });

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

@@ -1,7 +1,7 @@
 import { M as ManagedStream } from '../../stream-DGy4geUK.js';
 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-CfiD_00g.js';
+import { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-DZMHfgYQ.js';
 import * as zod_v4_core from 'zod/v4/core';
 import { WhatsAppClient } from '@photon-ai/whatsapp-business';
 import 'hotscript';

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

@@ -7,7 +7,7 @@ import {
 import {
   asText,
   definePlatform
-} from "../../chunk-XEEDIGVK.js";
+} from "../../chunk-XZTTLPHE.js";
 
 // src/providers/whatsapp-business/index.ts
 import {
@@ -16,6 +16,9 @@ import {
 
 // src/providers/whatsapp-business/messages.ts
 import { extension as mimeExtension } from "mime-types";
+var toSendResult = (result) => ({
+  id: result.messageId
+});
 var mapWaPhoneType = (type) => {
   if (!type) {
     return void 0;
@@ -311,8 +314,9 @@ var messages = (client) => {
 var send = async (client, spaceId, content) => {
   switch (content.type) {
     case "text":
-      await client.messages.send({ to: spaceId, text: content.text });
-      break;
+      return toSendResult(
+        await client.messages.send({ to: spaceId, text: content.text })
+      );
     case "attachment": {
       const { mediaId } = await client.media.upload({
         file: await content.read(),
@@ -321,32 +325,35 @@ var send = async (client, spaceId, content) => {
       });
       const mediaType = mimeToMediaType(content.mimeType);
       const mediaPayload = mediaType === "document" ? { id: mediaId, filename: content.name } : { id: mediaId };
-      await client.messages.send({
-        to: spaceId,
-        [mediaType]: mediaPayload
-      });
-      break;
+      return toSendResult(
+        await client.messages.send({
+          to: spaceId,
+          [mediaType]: mediaPayload
+        })
+      );
     }
     case "contact":
-      await client.messages.send({
-        to: spaceId,
-        contacts: [contactToWa(content)]
-      });
-      break;
+      return toSendResult(
+        await client.messages.send({
+          to: spaceId,
+          contacts: [contactToWa(content)]
+        })
+      );
     case "voice": {
       const { mediaId } = await client.media.upload({
         file: await content.read(),
         mimeType: content.mimeType,
         filename: voiceFilename(content)
       });
-      await client.messages.send({
-        to: spaceId,
-        audio: { id: mediaId }
-      });
-      break;
+      return toSendResult(
+        await client.messages.send({
+          to: spaceId,
+          audio: { id: mediaId }
+        })
+      );
     }
     default:
-      break;
+      throw new Error(`Unsupported WhatsApp content type: ${content.type}`);
   }
 };
 var reactToMessage = async (client, spaceId, messageId, reaction) => {
@@ -358,12 +365,13 @@ var reactToMessage = async (client, spaceId, messageId, reaction) => {
 var replyToMessage = async (client, spaceId, messageId, content) => {
   switch (content.type) {
     case "text":
-      await client.messages.send({
-        to: spaceId,
-        replyTo: messageId,
-        text: content.text
-      });
-      break;
+      return toSendResult(
+        await client.messages.send({
+          to: spaceId,
+          replyTo: messageId,
+          text: content.text
+        })
+      );
     case "attachment": {
       const { mediaId } = await client.media.upload({
         file: await content.read(),
@@ -372,35 +380,38 @@ var replyToMessage = async (client, spaceId, messageId, content) => {
       });
       const mediaType = mimeToMediaType(content.mimeType);
       const mediaPayload = mediaType === "document" ? { id: mediaId, filename: content.name } : { id: mediaId };
-      await client.messages.send({
-        to: spaceId,
-        replyTo: messageId,
-        [mediaType]: mediaPayload
-      });
-      break;
+      return toSendResult(
+        await client.messages.send({
+          to: spaceId,
+          replyTo: messageId,
+          [mediaType]: mediaPayload
+        })
+      );
     }
     case "contact":
-      await client.messages.send({
-        to: spaceId,
-        replyTo: messageId,
-        contacts: [contactToWa(content)]
-      });
-      break;
+      return toSendResult(
+        await client.messages.send({
+          to: spaceId,
+          replyTo: messageId,
+          contacts: [contactToWa(content)]
+        })
+      );
     case "voice": {
       const { mediaId } = await client.media.upload({
         file: await content.read(),
         mimeType: content.mimeType,
         filename: voiceFilename(content)
       });
-      await client.messages.send({
-        to: spaceId,
-        replyTo: messageId,
-        audio: { id: mediaId }
-      });
-      break;
+      return toSendResult(
+        await client.messages.send({
+          to: spaceId,
+          replyTo: messageId,
+          audio: { id: mediaId }
+        })
+      );
     }
     default:
-      break;
+      throw new Error(`Unsupported WhatsApp content type: ${content.type}`);
   }
 };
 
@@ -457,7 +468,7 @@ var whatsappBusiness = definePlatform("WhatsApp Business", {
   },
   actions: {
     send: async ({ space, content, client }) => {
-      await send(client, space.id, content);
+      return await send(client, space.id, content);
     },
     reactToMessage: async ({ space, messageId, reaction, client }) => {
       await reactToMessage(
@@ -468,7 +479,7 @@ var whatsappBusiness = definePlatform("WhatsApp Business", {
       );
     },
     replyToMessage: async ({ space, messageId, content, client }) => {
-      await replyToMessage(
+      return await replyToMessage(
         client,
         space.id,
         messageId,

package/dist/{types-CfiD_00g.d.ts → types-DZMHfgYQ.d.ts}

@@ -92,23 +92,35 @@ interface User {
 
 interface Space<_Def = unknown> {
     readonly __platform: string;
+    edit(message: OutboundMessage, newContent: ContentInput): Promise<void>;
     readonly id: string;
     responding<T>(fn: () => T | Promise<T>): Promise<T>;
-    send(...content: [ContentInput, ...ContentInput[]]): Promise<void>;
+    send(content: ContentInput): Promise<OutboundMessage>;
+    send(...content: [ContentInput, ContentInput, ...ContentInput[]]): Promise<OutboundMessage[]>;
     startTyping(): Promise<void>;
     stopTyping(): Promise<void>;
 }
 
-interface Message<TPlatform extends string = string, TSender extends User = User, TSpace extends Space = Space> {
+interface BaseMessage<TPlatform extends string = string, TSender extends User = User, TSpace extends Space = Space> {
     content: Content;
     readonly id: string;
     platform: TPlatform;
     react(reaction: string): Promise<void>;
-    reply(...content: [ContentInput, ...ContentInput[]]): Promise<void>;
-    sender: TSender;
+    reply(content: ContentInput): Promise<OutboundMessage<TPlatform, TSender, TSpace>>;
+    reply(...content: [ContentInput, ContentInput, ...ContentInput[]]): Promise<OutboundMessage<TPlatform, TSender, TSpace>[]>;
     space: TSpace;
     timestamp: Date;
 }
+interface InboundMessage<TPlatform extends string = string, TSender extends User = User, TSpace extends Space = Space> extends BaseMessage<TPlatform, TSender, TSpace> {
+    direction: "inbound";
+    sender: TSender;
+}
+interface OutboundMessage<TPlatform extends string = string, TSender extends User = User, TSpace extends Space = Space> extends BaseMessage<TPlatform, TSender, TSpace> {
+    direction: "outbound";
+    edit(newContent: ContentInput): Promise<void>;
+    sender: TSender | undefined;
+}
+type Message<TPlatform extends string = string, TSender extends User = User, TSpace extends Space = Space> = InboundMessage<TPlatform, TSender, TSpace> | OutboundMessage<TPlatform, TSender, TSpace>;
 
 type ResolvedSpace = Pick<Space, "id">;
 type SpaceRef = Pick<Space, "id" | "__platform">;
@@ -131,6 +143,11 @@ type ProviderMessage<TSender extends ResolvedUser = ResolvedUser, TSpace extends
     space: TSpace;
     timestamp?: Date;
 } & TExtra;
+interface SendResult<TSender extends ResolvedUser = ResolvedUser> {
+    id: string;
+    sender?: TSender;
+    timestamp?: Date;
+}
 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;
@@ -146,7 +163,7 @@ interface PlatformDef<_Name extends string = string, _ConfigSchema extends z__de
             content: Content;
             client: _Client;
             config: z__default.infer<_ConfigSchema>;
-        }) => Promise<void>;
+        }) => Promise<SendResult<_ResolvedUser>>;
         startTyping?: (_: {
             space: _ResolvedSpace & SpaceRef;
             client: _Client;
@@ -170,6 +187,13 @@ interface PlatformDef<_Name extends string = string, _ConfigSchema extends z__de
             content: Content;
             client: _Client;
             config: z__default.infer<_ConfigSchema>;
+        }) => Promise<SendResult<_ResolvedUser>>;
+        editMessage?: (_: {
+            space: _ResolvedSpace & SpaceRef;
+            messageId: string;
+            content: Content;
+            client: _Client;
+            config: z__default.infer<_ConfigSchema>;
         }) => Promise<void>;
     };
     config: _ConfigSchema;
@@ -215,11 +239,12 @@ interface PlatformDef<_Name extends string = string, _ConfigSchema extends z__de
 }
 interface AnyPlatformDef {
     actions: {
-        send: (_: any) => Promise<void>;
+        send: (_: any) => Promise<SendResult>;
         startTyping?: (_: any) => Promise<void>;
         stopTyping?: (_: any) => Promise<void>;
         reactToMessage?: (_: any) => Promise<void>;
-        replyToMessage?: (_: any) => Promise<void>;
+        replyToMessage?: (_: any) => Promise<SendResult>;
+        editMessage?: (_: any) => Promise<void>;
     };
     config: z__default.ZodType<object>;
     events: {
@@ -318,4 +343,4 @@ interface Platform<Def extends AnyPlatformDef> {
     (message: Message): PlatformMessage<Def>;
 }
 
-export type { AnyPlatformDef as A, ContentBuilder as C, EventProducer as E, Message as M, 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, 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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spectrum-ts",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/dist/chunk-XEEDIGVK.js

@@ -1,199 +0,0 @@
-// src/content/text.ts
-import z from "zod";
-var textSchema = z.object({
-  type: z.literal("text"),
-  text: z.string().nonempty()
-});
-var asText = (text2) => textSchema.parse({ type: "text", text: text2 });
-function text(text2) {
-  return {
-    build: async () => asText(text2)
-  };
-}
-
-// src/content/resolve.ts
-var resolveContents = (items) => Promise.all(
-  items.map((c) => typeof c === "string" ? text(c).build() : c.build())
-);
-
-// src/platform/define.ts
-function createPlatformInstance(def, runtime) {
-  const isPlatformUser = (value) => {
-    return typeof value === "object" && value !== null && "__platform" in value && value.__platform === def.name;
-  };
-  const normalizeSpaceArgs = (args) => {
-    if (args.length === 0) {
-      return { users: [], params: void 0 };
-    }
-    const [first, ...rest] = args;
-    if (Array.isArray(first)) {
-      return {
-        users: first,
-        params: rest[0]
-      };
-    }
-    if (!isPlatformUser(first)) {
-      return {
-        users: [],
-        params: first
-      };
-    }
-    const last = args.at(-1);
-    if (last !== void 0 && !isPlatformUser(last)) {
-      return {
-        users: args.slice(0, -1),
-        params: last
-      };
-    }
-    return {
-      users: args,
-      params: void 0
-    };
-  };
-  const base = {
-    async user(userID) {
-      const resolved = await def.user.resolve({
-        input: { userID },
-        client: runtime.client,
-        config: runtime.config
-      });
-      return {
-        ...resolved,
-        __platform: def.name
-      };
-    },
-    async space(...args) {
-      const { users, params } = normalizeSpaceArgs(args);
-      let parsedParams = params;
-      if (params !== void 0 && def.space.params) {
-        parsedParams = def.space.params.parse(params);
-      }
-      const resolved = await def.space.resolve({
-        input: { users, params: parsedParams },
-        client: runtime.client,
-        config: runtime.config
-      });
-      const parsedSpace = def.space.schema ? def.space.schema.parse(resolved) : resolved;
-      const spaceRef = {
-        id: parsedSpace.id,
-        __platform: def.name
-      };
-      const typingCtx = {
-        space: spaceRef,
-        client: runtime.client,
-        config: runtime.config
-      };
-      return {
-        ...parsedSpace,
-        ...spaceRef,
-        send: async (...content) => {
-          const built = await resolveContents(content);
-          for (const item of built) {
-            await def.actions.send({
-              ...typingCtx,
-              content: item
-            });
-          }
-        },
-        startTyping: async () => {
-          await def.actions.startTyping?.(typingCtx);
-        },
-        stopTyping: async () => {
-          await def.actions.stopTyping?.(typingCtx);
-        },
-        responding: async (fn) => {
-          await def.actions.startTyping?.(typingCtx);
-          try {
-            return await fn();
-          } finally {
-            await def.actions.stopTyping?.(typingCtx).catch(() => {
-            });
-          }
-        }
-      };
-    }
-  };
-  const eventProperties = {};
-  for (const eventName of Object.keys(def.events)) {
-    if (eventName === "messages") {
-      continue;
-    }
-    const producer = def.events[eventName];
-    if (producer) {
-      eventProperties[eventName] = producer({
-        client: runtime.client,
-        config: runtime.config
-      });
-    }
-  }
-  return Object.assign(base, eventProperties);
-}
-function definePlatform(name, def) {
-  const fullDef = { name, ...def };
-  const platformCache = /* @__PURE__ */ new WeakMap();
-  const narrowSpectrum = (spectrum) => {
-    const cached = platformCache.get(spectrum);
-    if (cached) {
-      return cached;
-    }
-    const runtime = spectrum.__internal.platforms.get(name);
-    if (!runtime) {
-      throw new Error(`Platform "${name}" is not registered`);
-    }
-    const instance = createPlatformInstance(
-      fullDef,
-      runtime
-    );
-    platformCache.set(spectrum, instance);
-    return instance;
-  };
-  const narrowSpace = (input) => {
-    if (input.__platform !== name) {
-      throw new Error(
-        `Expected space from "${name}", got "${input.__platform}"`
-      );
-    }
-    return input;
-  };
-  const narrowMessage = (input) => {
-    if (input.platform !== name) {
-      throw new Error(
-        `Expected message from "${name}", got "${input.platform}"`
-      );
-    }
-    return input;
-  };
-  const narrower = ((input) => {
-    if ("__providers" in input && "__internal" in input) {
-      return narrowSpectrum(input);
-    }
-    if ("__platform" in input && "send" in input) {
-      return narrowSpace(input);
-    }
-    if ("platform" in input && "sender" in input && "space" in input) {
-      return narrowMessage(input);
-    }
-    throw new Error("Invalid input to platform narrowing function");
-  });
-  narrower.config = (config) => {
-    const resolvedConfig = config ?? {};
-    return {
-      __tag: "PlatformProviderConfig",
-      __def: void 0,
-      __name: name,
-      config: resolvedConfig,
-      __definition: fullDef
-    };
-  };
-  if (def.static) {
-    Object.assign(narrower, def.static);
-  }
-  return narrower;
-}
-
-export {
-  asText,
-  text,
-  resolveContents,
-  definePlatform
-};