spectrum-ts 0.9.0 → 1.0.1

package/dist/chunk-XMAI2AAN.js

@@ -0,0 +1,1221 @@
+// src/content/attachment.ts
+import { createReadStream } from "fs";
+import { readFile, stat } from "fs/promises";
+import { basename } from "path";
+import { Readable } from "stream";
+import { lookup as lookupMimeType } from "mime-types";
+import z2 from "zod";
+
+// src/utils/io.ts
+import z from "zod";
+var readSchema = z.function({
+  input: [],
+  output: z.promise(z.instanceof(Buffer))
+});
+var streamSchema = z.function({
+  input: [],
+  output: z.promise(z.instanceof(ReadableStream))
+});
+var bufferToStream = (buf) => new ReadableStream({
+  start(controller) {
+    controller.enqueue(buf);
+    controller.close();
+  }
+});
+
+// src/content/attachment.ts
+var DEFAULT_ATTACHMENT_NAME = "attachment";
+var attachmentSchema = z2.object({
+  type: z2.literal("attachment"),
+  name: z2.string().nonempty(),
+  mimeType: z2.string().nonempty(),
+  size: z2.number().int().nonnegative().optional(),
+  read: readSchema,
+  stream: streamSchema
+});
+var resolveAttachmentName = (input, name) => name || (typeof input === "string" ? basename(input) : DEFAULT_ATTACHMENT_NAME);
+var resolveAttachmentMimeType = (name, mimeType) => {
+  if (mimeType) {
+    return mimeType;
+  }
+  const resolvedMimeType = lookupMimeType(name);
+  if (!resolvedMimeType) {
+    throw new Error(
+      `Unable to resolve MIME type for attachment "${name}". Pass options.mimeType explicitly.`
+    );
+  }
+  return resolvedMimeType;
+};
+var asAttachment = (input) => {
+  let cached;
+  const read = () => {
+    cached ??= input.read().catch((err) => {
+      cached = void 0;
+      throw err;
+    });
+    return cached;
+  };
+  const stream = input.stream ?? (async () => bufferToStream(await read()));
+  return attachmentSchema.parse({
+    type: "attachment",
+    name: input.name,
+    mimeType: input.mimeType,
+    size: input.size,
+    read,
+    stream
+  });
+};
+function attachment(input, options) {
+  return {
+    build: async () => {
+      const name = resolveAttachmentName(input, options?.name);
+      const mimeType = resolveAttachmentMimeType(name, options?.mimeType);
+      if (typeof input === "string") {
+        const stats = await stat(input);
+        return asAttachment({
+          name,
+          mimeType,
+          size: stats.size,
+          read: () => readFile(input),
+          stream: async () => Readable.toWeb(
+            createReadStream(input)
+          )
+        });
+      }
+      return asAttachment({
+        name,
+        mimeType,
+        size: input.byteLength,
+        read: async () => input,
+        stream: async () => bufferToStream(input)
+      });
+    }
+  };
+}
+
+// src/utils/vcard.ts
+import vCard from "vcf";
+var asPropertyArray = (prop) => {
+  if (!prop) {
+    return [];
+  }
+  const arr = Array.isArray(prop) ? prop : [prop];
+  return arr;
+};
+var propString = (prop) => {
+  const [first] = asPropertyArray(prop);
+  const value = first?.valueOf().trim();
+  return value ? value : void 0;
+};
+var paramTypes = (prop) => {
+  const { type } = prop;
+  if (!type) {
+    return [];
+  }
+  return (Array.isArray(type) ? type : [type]).map((t) => t.toLowerCase());
+};
+var mapPhoneType = (prop) => {
+  const types = paramTypes(prop);
+  if (types.some((t) => t === "cell" || t === "mobile" || t === "iphone")) {
+    return "mobile";
+  }
+  if (types.includes("home")) {
+    return "home";
+  }
+  if (types.includes("work")) {
+    return "work";
+  }
+  if (types.length > 0) {
+    return "other";
+  }
+  return void 0;
+};
+var mapSimpleType = (prop) => {
+  const types = paramTypes(prop);
+  if (types.includes("home")) {
+    return "home";
+  }
+  if (types.includes("work")) {
+    return "work";
+  }
+  if (types.length > 0) {
+    return "other";
+  }
+  return void 0;
+};
+var splitStructured = (value) => value.split(";").map((part) => part.trim());
+var extractName = (card) => {
+  const fn = propString(card.data.fn);
+  const n = propString(card.data.n);
+  if (!(fn || n)) {
+    return void 0;
+  }
+  const result = {};
+  if (fn) {
+    result.formatted = fn;
+  }
+  if (n) {
+    const [last, first, middle, prefix, suffix] = splitStructured(n);
+    if (first) {
+      result.first = first;
+    }
+    if (last) {
+      result.last = last;
+    }
+    if (middle) {
+      result.middle = middle;
+    }
+    if (prefix) {
+      result.prefix = prefix;
+    }
+    if (suffix) {
+      result.suffix = suffix;
+    }
+  }
+  return result;
+};
+var extractPhones = (card) => {
+  const props = asPropertyArray(card.data.tel);
+  if (props.length === 0) {
+    return void 0;
+  }
+  return props.map((p) => {
+    const entry = { value: p.valueOf().trim() };
+    const type = mapPhoneType(p);
+    if (type) {
+      entry.type = type;
+    }
+    return entry;
+  });
+};
+var extractEmails = (card) => {
+  const props = asPropertyArray(card.data.email);
+  if (props.length === 0) {
+    return void 0;
+  }
+  return props.map((p) => {
+    const entry = { value: p.valueOf().trim() };
+    const type = mapSimpleType(p);
+    if (type) {
+      entry.type = type;
+    }
+    return entry;
+  });
+};
+var extractAddresses = (card) => {
+  const props = asPropertyArray(card.data.adr);
+  if (props.length === 0) {
+    return void 0;
+  }
+  return props.map((p) => {
+    const [, , street, city, region, postalCode, country] = splitStructured(
+      p.valueOf()
+    );
+    const entry = {};
+    if (street) {
+      entry.street = street;
+    }
+    if (city) {
+      entry.city = city;
+    }
+    if (region) {
+      entry.region = region;
+    }
+    if (postalCode) {
+      entry.postalCode = postalCode;
+    }
+    if (country) {
+      entry.country = country;
+    }
+    const type = mapSimpleType(p);
+    if (type) {
+      entry.type = type;
+    }
+    return entry;
+  });
+};
+var extractOrg = (card) => {
+  const orgStr = propString(card.data.org);
+  const title = propString(card.data.title);
+  if (!(orgStr || title)) {
+    return void 0;
+  }
+  const result = {};
+  if (orgStr) {
+    const [name, department] = splitStructured(orgStr);
+    if (name) {
+      result.name = name;
+    }
+    if (department) {
+      result.department = department;
+    }
+  }
+  if (title) {
+    result.title = title;
+  }
+  return result;
+};
+var extractUrls = (card) => {
+  const props = asPropertyArray(card.data.url);
+  if (props.length === 0) {
+    return void 0;
+  }
+  return props.map((p) => p.valueOf().trim());
+};
+var photoMimeFromType = (type) => {
+  if (!type) {
+    return "image/jpeg";
+  }
+  const lower = type.toLowerCase();
+  if (lower.startsWith("image/")) {
+    return lower;
+  }
+  return `image/${lower}`;
+};
+var DATA_URI_PATTERN = /^data:([^;,]+);base64,(.*)$/i;
+var extractPhoto = (card) => {
+  const [prop] = asPropertyArray(card.data.photo);
+  if (!prop) {
+    return void 0;
+  }
+  const value = prop.valueOf();
+  const dataUriMatch = DATA_URI_PATTERN.exec(value);
+  if (dataUriMatch) {
+    const [, mimeType, base64] = dataUriMatch;
+    const buf2 = Buffer.from(base64 ?? "", "base64");
+    return {
+      mimeType: mimeType ?? "image/jpeg",
+      read: async () => buf2
+    };
+  }
+  const type = Array.isArray(prop.type) ? prop.type[0] : prop.type;
+  const buf = Buffer.from(value, "base64");
+  return {
+    mimeType: photoMimeFromType(type),
+    read: async () => buf
+  };
+};
+var normalizeVCardInput = (vcf) => {
+  const withoutBom = vcf.charCodeAt(0) === 65279 ? vcf.slice(1) : vcf;
+  return withoutBom.replace(/\r\n|\r|\n/g, "\r\n");
+};
+var fromVCard = (vcf) => {
+  const [card] = vCard.parse(normalizeVCardInput(vcf));
+  if (!card) {
+    throw new Error("Invalid vCard: no cards parsed");
+  }
+  const input = { raw: vcf };
+  const name = extractName(card);
+  if (name) {
+    input.name = name;
+  }
+  const phones = extractPhones(card);
+  if (phones) {
+    input.phones = phones;
+  }
+  const emails = extractEmails(card);
+  if (emails) {
+    input.emails = emails;
+  }
+  const addresses = extractAddresses(card);
+  if (addresses) {
+    input.addresses = addresses;
+  }
+  const org = extractOrg(card);
+  if (org) {
+    input.org = org;
+  }
+  const urls = extractUrls(card);
+  if (urls) {
+    input.urls = urls;
+  }
+  const birthday = propString(card.data.bday);
+  if (birthday) {
+    input.birthday = birthday;
+  }
+  const note = propString(card.data.note);
+  if (note) {
+    input.note = note;
+  }
+  const photo = extractPhoto(card);
+  if (photo) {
+    input.photo = photo;
+  }
+  return input;
+};
+var formattedNameFor = (name) => {
+  if (name?.formatted) {
+    return name.formatted;
+  }
+  const parts = [name?.first, name?.middle, name?.last].filter(
+    (p) => Boolean(p)
+  );
+  if (parts.length > 0) {
+    return parts.join(" ");
+  }
+  return "Unknown";
+};
+var phoneTypeParam = (type) => {
+  if (type === "mobile") {
+    return "CELL";
+  }
+  if (type === "home" || type === "work" || type === "other") {
+    return type.toUpperCase();
+  }
+  return void 0;
+};
+var simpleTypeParam = (type) => type ? type.toUpperCase() : void 0;
+var photoTypeParam = (mimeType) => {
+  const sub = mimeType.split("/")[1] ?? "jpeg";
+  return sub.toUpperCase();
+};
+var writeName = (card, name) => {
+  card.set("fn", formattedNameFor(name));
+  if (!name) {
+    return;
+  }
+  if (name.first || name.last || name.middle || name.prefix || name.suffix) {
+    card.set(
+      "n",
+      [
+        name.last ?? "",
+        name.first ?? "",
+        name.middle ?? "",
+        name.prefix ?? "",
+        name.suffix ?? ""
+      ].join(";")
+    );
+  }
+};
+var writePhones = (card, phones) => {
+  for (const phone of phones ?? []) {
+    const type = phoneTypeParam(phone.type);
+    card.add("tel", phone.value, type ? { type } : void 0);
+  }
+};
+var writeEmails = (card, emails) => {
+  for (const email of emails ?? []) {
+    const type = simpleTypeParam(email.type);
+    card.add("email", email.value, type ? { type } : void 0);
+  }
+};
+var writeAddresses = (card, addresses) => {
+  for (const addr of addresses ?? []) {
+    const value = [
+      "",
+      "",
+      addr.street ?? "",
+      addr.city ?? "",
+      addr.region ?? "",
+      addr.postalCode ?? "",
+      addr.country ?? ""
+    ].join(";");
+    const type = simpleTypeParam(addr.type);
+    card.add("adr", value, type ? { type } : void 0);
+  }
+};
+var writeOrg = (card, org) => {
+  if (!org) {
+    return;
+  }
+  if (org.name || org.department) {
+    card.set("org", [org.name ?? "", org.department ?? ""].join(";"));
+  }
+  if (org.title) {
+    card.set("title", org.title);
+  }
+};
+var writeUrls = (card, urls) => {
+  for (const url of urls ?? []) {
+    card.add("url", url);
+  }
+};
+var writePhoto = async (card, photo) => {
+  if (!photo) {
+    return;
+  }
+  const buf = await photo.read();
+  card.set("photo", buf.toString("base64"), {
+    encoding: "b",
+    type: photoTypeParam(photo.mimeType)
+  });
+};
+var toVCard = async (contact2) => {
+  if (typeof contact2.raw === "string" && contact2.raw.startsWith("BEGIN:VCARD")) {
+    return contact2.raw;
+  }
+  const card = new vCard();
+  writeName(card, contact2.name);
+  writePhones(card, contact2.phones);
+  writeEmails(card, contact2.emails);
+  writeAddresses(card, contact2.addresses);
+  writeOrg(card, contact2.org);
+  writeUrls(card, contact2.urls);
+  if (contact2.birthday) {
+    card.set("bday", contact2.birthday);
+  }
+  if (contact2.note) {
+    card.set("note", contact2.note);
+  }
+  await writePhoto(card, contact2.photo);
+  return card.toString();
+};
+
+// src/content/contact.ts
+import vCard2 from "vcf";
+import z3 from "zod";
+var userRefSchema = z3.object({
+  __platform: z3.string(),
+  id: z3.string()
+});
+var nameSchema = z3.object({
+  formatted: z3.string().optional(),
+  first: z3.string().optional(),
+  last: z3.string().optional(),
+  middle: z3.string().optional(),
+  prefix: z3.string().optional(),
+  suffix: z3.string().optional()
+});
+var phoneTypeSchema = z3.enum(["mobile", "home", "work", "other"]);
+var emailTypeSchema = z3.enum(["home", "work", "other"]);
+var addressTypeSchema = z3.enum(["home", "work", "other"]);
+var phoneSchema = z3.object({
+  value: z3.string(),
+  type: phoneTypeSchema.optional()
+});
+var emailSchema = z3.object({
+  value: z3.string(),
+  type: emailTypeSchema.optional()
+});
+var addressSchema = z3.object({
+  street: z3.string().optional(),
+  city: z3.string().optional(),
+  region: z3.string().optional(),
+  postalCode: z3.string().optional(),
+  country: z3.string().optional(),
+  type: addressTypeSchema.optional()
+});
+var orgSchema = z3.object({
+  name: z3.string().optional(),
+  title: z3.string().optional(),
+  department: z3.string().optional()
+});
+var photoSchema = z3.object({
+  mimeType: z3.string(),
+  read: readSchema
+});
+var contactSchema = z3.object({
+  type: z3.literal("contact"),
+  user: userRefSchema.optional(),
+  name: nameSchema.optional(),
+  phones: z3.array(phoneSchema).optional(),
+  emails: z3.array(emailSchema).optional(),
+  addresses: z3.array(addressSchema).optional(),
+  org: orgSchema.optional(),
+  urls: z3.array(z3.string()).optional(),
+  birthday: z3.string().optional(),
+  note: z3.string().optional(),
+  photo: photoSchema.optional(),
+  raw: z3.unknown().optional()
+});
+var asContact = (input) => contactSchema.parse({ type: "contact", ...input });
+var isUser = (value) => typeof value === "object" && value !== null && "__platform" in value && "id" in value && typeof value.__platform === "string" && typeof value.id === "string";
+function contact(input, details) {
+  return {
+    build: async () => {
+      if (typeof input === "string") {
+        return asContact(fromVCard(input));
+      }
+      if (input instanceof vCard2) {
+        return asContact(fromVCard(input.toString()));
+      }
+      if (isUser(input)) {
+        return asContact({
+          user: { __platform: input.__platform, id: input.id },
+          ...details
+        });
+      }
+      return asContact(input);
+    }
+  };
+}
+
+// src/content/custom.ts
+import z4 from "zod";
+var customSchema = z4.object({
+  type: z4.literal("custom"),
+  raw: z4.unknown()
+});
+var asCustom = (raw) => customSchema.parse({ type: "custom", raw });
+function custom(raw) {
+  return {
+    build: async () => asCustom(raw)
+  };
+}
+
+// src/content/text.ts
+import z5 from "zod";
+var textSchema = z5.object({
+  type: z5.literal("text"),
+  text: z5.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/content/reaction.ts
+import z6 from "zod";
+var isMessage = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
+var reactionSchema = z6.object({
+  type: z6.literal("reaction"),
+  emoji: z6.string().min(1),
+  target: z6.custom(isMessage, {
+    message: "reaction target must be a Message"
+  })
+});
+var asReaction = (input) => reactionSchema.parse({ type: "reaction", ...input });
+function reaction(emoji, target) {
+  return { build: async () => asReaction({ emoji, target }) };
+}
+
+// src/utils/errors.ts
+var composeMessage = (opts) => {
+  const platform = opts.platform ?? "platform";
+  const subject = opts.kind === "content" ? `content type "${opts.contentType ?? "unknown"}"` : `action "${opts.action ?? "unknown"}"`;
+  const detail = opts.detail ? `: ${opts.detail}` : "";
+  return `${platform} does not support ${subject}${detail}`;
+};
+var UnsupportedError = class _UnsupportedError extends Error {
+  kind;
+  platform;
+  contentType;
+  action;
+  detail;
+  constructor(opts) {
+    super(composeMessage(opts));
+    this.name = "UnsupportedError";
+    this.kind = opts.kind;
+    this.platform = opts.platform;
+    this.contentType = opts.contentType;
+    this.action = opts.action;
+    this.detail = opts.detail;
+  }
+  static content(contentType, platform, detail) {
+    return new _UnsupportedError({
+      kind: "content",
+      contentType,
+      platform,
+      detail
+    });
+  }
+  static action(action, platform, detail) {
+    return new _UnsupportedError({ kind: "action", action, platform, detail });
+  }
+  withPlatform(platform) {
+    if (this.platform) {
+      return this;
+    }
+    return new _UnsupportedError({
+      kind: this.kind,
+      platform,
+      contentType: this.contentType,
+      action: this.action,
+      detail: this.detail
+    });
+  }
+};
+
+// src/platform/build.ts
+var ANSI_YELLOW = "\x1B[33m";
+var ANSI_RESET = "\x1B[0m";
+var supportsAnsiColor = () => {
+  if (typeof process === "undefined") {
+    return false;
+  }
+  if (process.env.NO_COLOR) {
+    return false;
+  }
+  const force = process.env.FORCE_COLOR;
+  if (force !== void 0) {
+    return force !== "" && force !== "0" && force !== "false";
+  }
+  return Boolean(process.stderr?.isTTY);
+};
+var warnUnsupported = (err, fallbackPlatform) => {
+  const platform = err.platform ?? fallbackPlatform;
+  const subject = err.kind === "content" ? `content type "${err.contentType ?? "unknown"}"` : `action "${err.action ?? "unknown"}"`;
+  const detail = err.detail ? `: ${err.detail}` : "";
+  const body = `[spectrum-ts] ${platform} does not support ${subject}${detail}; skipping.`;
+  console.warn(
+    supportsAnsiColor() ? `${ANSI_YELLOW}${body}${ANSI_RESET}` : body
+  );
+};
+var providerMessageCoreKeys = /* @__PURE__ */ new Set([
+  "content",
+  "id",
+  "sender",
+  "space",
+  "timestamp"
+]);
+var extractExtras = (raw, definition) => {
+  const entries = Object.entries(raw).filter(
+    ([key]) => !providerMessageCoreKeys.has(key)
+  );
+  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({
+    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"
+  });
+}
+var wrapNestedContent = (content, ctx) => {
+  if (content.type === "reaction") {
+    const target = content.target;
+    if (isRawProviderRecord(target)) {
+      return {
+        ...content,
+        target: wrapProviderMessage(target, ctx)
+      };
+    }
+    return content;
+  }
+  if (content.type === "group") {
+    const items = content.items.map((item) => {
+      const raw = item;
+      return isRawProviderRecord(raw) ? wrapProviderMessage(raw, ctx) : item;
+    });
+    return { ...content, items };
+  }
+  return content;
+};
+var isRawProviderRecord = (v) => {
+  if (typeof v !== "object" || v === null) {
+    return false;
+  }
+  const record = v;
+  return "id" in record && "content" in record && typeof record.react !== "function" && typeof record.reply !== "function";
+};
+function buildSpace(params) {
+  const { spaceRef, extras, typingCtx, definition, client, config } = params;
+  let space;
+  async function dispatchReaction(item) {
+    try {
+      if (!definition.actions.reactToMessage) {
+        throw UnsupportedError.action("react", definition.name);
+      }
+      await definition.actions.reactToMessage({
+        space: spaceRef,
+        target: item.target,
+        reaction: item.emoji,
+        client,
+        config
+      });
+    } catch (err) {
+      if (err instanceof UnsupportedError) {
+        warnUnsupported(err, definition.name);
+        return;
+      }
+      throw err;
+    }
+  }
+  async function dispatchSend(item) {
+    let sendResult;
+    try {
+      sendResult = await definition.actions.send({
+        ...typingCtx,
+        content: item
+      });
+    } catch (err) {
+      if (err instanceof UnsupportedError) {
+        warnUnsupported(err, definition.name);
+        return;
+      }
+      throw err;
+    }
+    if (!sendResult?.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"
+    });
+  }
+  async function sendImpl(...content) {
+    const resolved = await resolveContents(content);
+    const results = [];
+    for (const item of resolved) {
+      if (item.type === "reaction") {
+        await dispatchReaction(item);
+        continue;
+      }
+      const sent = await dispatchSend(item);
+      if (sent) {
+        results.push(sent);
+      }
+    }
+    if (content.length === 1) {
+      return results[0];
+    }
+    return results;
+  }
+  async function getMessageImpl(id) {
+    if (!definition.actions.getMessage) {
+      warnUnsupported(
+        UnsupportedError.action("getMessage", definition.name),
+        definition.name
+      );
+      return;
+    }
+    let raw;
+    try {
+      raw = await definition.actions.getMessage({
+        space: spaceRef,
+        messageId: id,
+        client,
+        config
+      });
+    } catch (err) {
+      if (err instanceof UnsupportedError) {
+        warnUnsupported(err, definition.name);
+        return;
+      }
+      throw err;
+    }
+    if (!raw) {
+      return;
+    }
+    return wrapProviderMessage(raw, {
+      client,
+      config,
+      definition,
+      space,
+      spaceRef
+    });
+  }
+  space = {
+    ...extras,
+    ...spaceRef,
+    send: sendImpl,
+    edit: async (message, newContent) => {
+      await message.edit(newContent);
+    },
+    getMessage: getMessageImpl,
+    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;
+  let self;
+  const react = async (reaction2) => {
+    if (!definition.actions.reactToMessage) {
+      warnUnsupported(
+        UnsupportedError.action("react", definition.name),
+        definition.name
+      );
+      return;
+    }
+    if (!self) {
+      throw new Error(
+        "react() called before message construction completed (internal bug)"
+      );
+    }
+    try {
+      await definition.actions.reactToMessage({
+        space: spaceRef,
+        target: self,
+        reaction: reaction2,
+        client,
+        config
+      });
+    } catch (err) {
+      if (err instanceof UnsupportedError) {
+        warnUnsupported(err, definition.name);
+        return;
+      }
+      throw err;
+    }
+  };
+  async function reply(...content) {
+    if (!definition.actions.replyToMessage) {
+      warnUnsupported(
+        UnsupportedError.action("reply", definition.name),
+        definition.name
+      );
+      return content.length === 1 ? void 0 : [];
+    }
+    const resolved = await resolveContents(content);
+    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`
+        );
+      }
+      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];
+    }
+    return results;
+  }
+  const senderWithPlatform = params.sender === void 0 ? void 0 : { ...params.sender, __platform: definition.name };
+  if (params.direction === "outbound") {
+    const outbound = {
+      ...params.extras,
+      id: params.id,
+      content: params.content,
+      direction: "outbound",
+      platform: definition.name,
+      react,
+      reply,
+      edit: async (newContent) => {
+        if (!definition.actions.editMessage) {
+          warnUnsupported(
+            UnsupportedError.action("edit", definition.name),
+            definition.name
+          );
+          return;
+        }
+        const [resolved] = await resolveContents([newContent]);
+        if (!resolved) {
+          return;
+        }
+        try {
+          await definition.actions.editMessage({
+            space: spaceRef,
+            messageId: params.id,
+            content: resolved,
+            client,
+            config
+          });
+        } catch (err) {
+          if (err instanceof UnsupportedError) {
+            warnUnsupported(err, definition.name);
+            return;
+          }
+          throw err;
+        }
+      },
+      sender: senderWithPlatform,
+      space,
+      timestamp: params.timestamp
+    };
+    self = outbound;
+    return outbound;
+  }
+  const inbound = {
+    ...params.extras,
+    id: params.id,
+    content: params.content,
+    direction: "inbound",
+    platform: definition.name,
+    react,
+    reply,
+    sender: senderWithPlatform,
+    space,
+    timestamp: params.timestamp
+  };
+  self = inbound;
+  return inbound;
+}
+
+// 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 resolveUserID = async (userID) => {
+    const resolved = await def.user.resolve({
+      input: { userID },
+      client: runtime.client,
+      config: runtime.config
+    });
+    return {
+      ...resolved,
+      __platform: def.name
+    };
+  };
+  const resolveStringUsers = async (args) => {
+    const convertArg = async (arg) => {
+      if (typeof arg === "string") {
+        return await resolveUserID(arg);
+      }
+      if (Array.isArray(arg)) {
+        return await Promise.all(arg.map(convertArg));
+      }
+      return arg;
+    };
+    return await Promise.all(args.map(convertArg));
+  };
+  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 convertedArgs = await resolveStringUsers(args);
+      const { users, params } = normalizeSpaceArgs(convertedArgs);
+      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 {
+  readSchema,
+  streamSchema,
+  bufferToStream,
+  asAttachment,
+  attachment,
+  fromVCard,
+  toVCard,
+  asContact,
+  contact,
+  asCustom,
+  custom,
+  asText,
+  text,
+  resolveContents,
+  reactionSchema,
+  asReaction,
+  reaction,
+  UnsupportedError,
+  wrapProviderMessage,
+  buildSpace,
+  definePlatform
+};