spectrum-ts 4.2.0 → 5.0.0

package/dist/chunk-B52VPQO3.js

@@ -1,1379 +0,0 @@
-import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
-import {
-  StreamConsumedError,
-  asText,
-  drainStreamText,
-  fetchUrlBytes,
-  reaction,
-  readSchema,
-  resolveContents,
-  streamTextBuilder
-} from "./chunk-UXAKIXVM.js";
-
-// src/content/avatar.ts
-import z2 from "zod";
-
-// src/utils/photo-content.ts
-import { readFile } from "fs/promises";
-import { basename } from "path";
-import { lookup as lookupMimeType } from "mime-types";
-import z from "zod";
-var CLEAR_SENTINEL = "clear";
-var photoActionSchema = z.discriminatedUnion("kind", [
-  z.object({
-    kind: z.literal("set"),
-    read: readSchema,
-    mimeType: z.string().nonempty()
-  }),
-  z.object({ kind: z.literal("clear") })
-]);
-var resolveMimeType = (input, mimeType, contentLabel) => {
-  if (mimeType) {
-    return mimeType;
-  }
-  if (input instanceof URL) {
-    const resolved = lookupMimeType(basename(input.pathname));
-    if (resolved) {
-      return resolved;
-    }
-  } else if (typeof input === "string") {
-    const resolved = lookupMimeType(basename(input));
-    if (resolved) {
-      return resolved;
-    }
-  }
-  throw new Error(
-    `Unable to resolve MIME type for ${contentLabel}. Pass options.mimeType explicitly.`
-  );
-};
-var cachedRead = (read2) => {
-  let cached;
-  return () => {
-    cached ??= read2().catch((err) => {
-      cached = void 0;
-      throw err;
-    });
-    return cached;
-  };
-};
-var buildPhotoAction = (input, options, contentLabel) => {
-  if (input === CLEAR_SENTINEL) {
-    return { kind: "clear" };
-  }
-  const mimeType = resolveMimeType(input, options?.mimeType, contentLabel);
-  let read2;
-  if (input instanceof URL) {
-    read2 = cachedRead(async () => (await fetchUrlBytes(input)).data);
-  } else if (typeof input === "string") {
-    read2 = cachedRead(() => readFile(input));
-  } else {
-    const snapshot = Buffer.from(input);
-    read2 = cachedRead(async () => snapshot);
-  }
-  return { kind: "set", read: read2, mimeType };
-};
-
-// src/content/avatar.ts
-var avatarSchema = z2.object({
-  type: z2.literal("avatar"),
-  action: photoActionSchema
-});
-function avatar(input, options) {
-  const action = buildPhotoAction(input, options, "avatar");
-  return {
-    build: async () => avatarSchema.parse({ type: "avatar", action })
-  };
-}
-
-// src/content/edit.ts
-import z3 from "zod";
-var isMessage = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
-var isContent = (v) => typeof v === "object" && v !== null && "type" in v && typeof v.type === "string";
-var editSchema = z3.object({
-  type: z3.literal("edit"),
-  content: z3.custom(isContent, {
-    message: "edit content must be a Content value"
-  }),
-  target: z3.custom(isMessage, {
-    message: "edit target must be a Message"
-  })
-});
-var asEdit = (input) => editSchema.parse({ type: "edit", ...input });
-function edit(content, target) {
-  return {
-    build: async () => {
-      if (!target) {
-        throw new Error(
-          "edit() target is undefined \u2014 the targeted message was never sent (space.send resolves undefined when a platform skips unsupported content)"
-        );
-      }
-      if (target.direction !== "outbound") {
-        throw new Error(
-          `edit() target must be an outbound message (got direction "${target.direction}", message id "${target.id}")`
-        );
-      }
-      const [resolved] = await resolveContents([content]);
-      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" || resolved.type === "read") {
-        throw new Error(`edit() cannot wrap "${resolved.type}" content`);
-      }
-      return asEdit({ content: resolved, target });
-    }
-  };
-}
-
-// src/content/markdown.ts
-import z4 from "zod";
-var markdownSchema = z4.object({
-  type: z4.literal("markdown"),
-  markdown: z4.string().nonempty()
-});
-var asMarkdown = (markdown2) => markdownSchema.parse({ type: "markdown", markdown: markdown2 });
-function markdown(source, options) {
-  if (typeof source === "string") {
-    return { build: async () => asMarkdown(source) };
-  }
-  return streamTextBuilder("markdown", source, options);
-}
-
-// src/content/read.ts
-import z5 from "zod";
-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 {
-    build: async () => renameSchema.parse({ type: "rename", displayName })
-  };
-}
-
-// src/content/reply.ts
-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 = z7.object({
-  type: z7.literal("reply"),
-  content: z7.custom(isContent2, {
-    message: "reply content must be a Content value"
-  }),
-  target: z7.custom(isMessage3, {
-    message: "reply target must be a Message"
-  })
-});
-var asReply = (input) => replySchema.parse({ type: "reply", ...input });
-function reply(content, target) {
-  return {
-    build: async () => {
-      if (!target) {
-        throw new Error(
-          "reply() target is undefined \u2014 the targeted message was never sent (space.send resolves undefined when a platform skips unsupported content)"
-        );
-      }
-      const [resolved] = await resolveContents([content]);
-      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" || resolved.type === "read") {
-        throw new Error(`reply() cannot wrap "${resolved.type}" content`);
-      }
-      return asReply({ content: resolved, target });
-    }
-  };
-}
-
-// src/content/typing.ts
-import z8 from "zod";
-var typingSchema = z8.object({
-  type: z8.literal("typing"),
-  state: z8.enum(["start", "stop"])
-});
-function typing(state = "start") {
-  return {
-    build: async () => typingSchema.parse({ type: "typing", state })
-  };
-}
-
-// src/content/unsend.ts
-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"
-  })
-});
-var asUnsend = (input) => unsendSchema.parse({ type: "unsend", ...input });
-function unsend(target) {
-  return {
-    build: async () => {
-      if (!target) {
-        throw new Error(
-          "unsend() target is undefined \u2014 the targeted message was never sent (space.send resolves undefined when a platform skips unsupported content)"
-        );
-      }
-      if (target.direction !== "outbound") {
-        throw new Error(
-          `unsend() target must be an outbound message (got direction "${target.direction}", message id "${target.id}")`
-        );
-      }
-      return asUnsend({ 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/define.ts
-import { createLogger as createLogger2, withSpan as withSpan2 } from "@photon-ai/otel";
-
-// src/utils/identifier.ts
-import { sanitizeEmail, sanitizePhone } from "@photon-ai/otel";
-var PHONE_LIKE = /^\+?[\d\s()\-.]{7,}$/;
-var EMAIL_LIKE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-function classifyIdentifier(s) {
-  if (EMAIL_LIKE.test(s)) {
-    return { kind: "email", identifier: sanitizeEmail(s) };
-  }
-  if (PHONE_LIKE.test(s) && s.replace(/\D/g, "").length >= 7) {
-    return { kind: "phone", identifier: sanitizePhone(s) };
-  }
-  return { kind: "unknown", identifier: s };
-}
-
-// src/platform/build.ts
-import { createLogger, withSpan } from "@photon-ai/otel";
-
-// src/utils/markdown.ts
-import { Marked } from "marked";
-var markdownLexer = new Marked();
-var BULLET = "\u2022 ";
-var HR_LINE = "\u2014\u2014\u2014";
-var NESTED_LIST_INDENT = "  ";
-var BLOCK_SEPARATOR = "\n\n";
-var TABLE_CELL_SEPARATOR = " | ";
-var DEFAULT_LIST_START = 1;
-var asMarkedToken = (token) => token;
-var checkboxPrefix = (item) => {
-  if (!item.task) {
-    return "";
-  }
-  return item.checked ? "[x] " : "[ ] ";
-};
-var listMarker = (list, index) => {
-  if (!list.ordered) {
-    return BULLET;
-  }
-  const start = list.start === "" ? DEFAULT_LIST_START : list.start;
-  return `${start + index}. `;
-};
-var renderLink = (token) => {
-  if (token.text === token.href) {
-    return token.href;
-  }
-  return `${renderInlineTokens(token.tokens)} (${token.href})`;
-};
-var renderImage = (token) => token.text ? `${token.text} (${token.href})` : token.href;
-var renderInlineToken = (token) => {
-  switch (token.type) {
-    case "strong":
-    case "em":
-    case "del":
-      return renderInlineTokens(token.tokens);
-    case "codespan":
-      return token.text;
-    case "br":
-      return "\n";
-    case "link":
-      return renderLink(token);
-    case "image":
-      return renderImage(token);
-    case "escape":
-      return token.text;
-    case "text":
-      return token.tokens ? renderInlineTokens(token.tokens) : token.text;
-    // Raw HTML in markdown source stays literal — plain text has no markup.
-    case "html":
-      return token.text;
-    // Task-item checkboxes are rendered from `ListItem.task`/`checked`.
-    case "checkbox":
-      return "";
-    default:
-      return "raw" in token ? String(token.raw) : "";
-  }
-};
-var renderInlineTokens = (tokens) => {
-  let out = "";
-  for (const token of tokens) {
-    out += renderInlineToken(asMarkedToken(token));
-  }
-  return out;
-};
-var renderBlockquote = (quote) => renderBlockTokens(quote.tokens).split("\n").map((line) => line ? `> ${line}` : ">").join("\n");
-var renderList = (list) => {
-  const lines = [];
-  for (const [index, item] of list.items.entries()) {
-    const prefix = `${listMarker(list, index)}${checkboxPrefix(item)}`;
-    const blocks = [];
-    for (const token of item.tokens) {
-      const rendered = renderBlockToken(asMarkedToken(token));
-      if (rendered) {
-        blocks.push(rendered);
-      }
-    }
-    const [first = "", ...rest] = blocks.join("\n").split("\n");
-    lines.push(`${prefix}${first}`);
-    for (const line of rest) {
-      lines.push(`${NESTED_LIST_INDENT}${line}`);
-    }
-  }
-  return lines.join("\n");
-};
-var renderTable = (table) => {
-  const renderRow = (cells) => cells.map((cell) => renderInlineTokens(cell.tokens)).join(TABLE_CELL_SEPARATOR);
-  const lines = [renderRow(table.header)];
-  for (const row of table.rows) {
-    lines.push(renderRow(row));
-  }
-  return lines.join("\n");
-};
-var renderBlockToken = (token) => {
-  switch (token.type) {
-    case "heading":
-    case "paragraph":
-      return renderInlineTokens(token.tokens);
-    case "code":
-      return token.text;
-    case "blockquote":
-      return renderBlockquote(token);
-    case "list":
-      return renderList(token);
-    case "table":
-      return renderTable(token);
-    case "hr":
-      return HR_LINE;
-    case "space":
-    case "def":
-      return "";
-    default:
-      return renderInlineToken(token);
-  }
-};
-var renderBlockTokens = (tokens) => {
-  const blocks = [];
-  for (const token of tokens) {
-    const rendered = renderBlockToken(asMarkedToken(token));
-    if (rendered) {
-      blocks.push(rendered);
-    }
-  }
-  return blocks.join(BLOCK_SEPARATOR);
-};
-var markdownToPlainText = (markdown2) => renderBlockTokens(markdownLexer.lexer(markdown2)).trim();
-
-// src/utils/telemetry.ts
-var targetId = (target) => {
-  const id = target?.id;
-  return typeof id === "string" ? id : void 0;
-};
-var targetType = (target) => {
-  const type = target?.content?.type;
-  return typeof type === "string" ? type : void 0;
-};
-var replyOrEditAttrs = (content) => {
-  const target = content.target;
-  const inner = content.content;
-  const innerType = inner?.type;
-  return {
-    "spectrum.message.content.target.id": targetId(target),
-    "spectrum.message.content.target.type": targetType(target),
-    "spectrum.message.content.inner.type": typeof innerType === "string" ? innerType : void 0
-  };
-};
-var unsendAttrs = (content) => {
-  const target = content.target;
-  return {
-    "spectrum.message.content.target.id": targetId(target),
-    "spectrum.message.content.target.type": targetType(target)
-  };
-};
-var reactionAttrs = (content) => {
-  const target = content.target;
-  const emoji = content.emoji;
-  return {
-    "spectrum.message.content.target.id": targetId(target),
-    "spectrum.message.content.reaction.emoji": typeof emoji === "string" ? emoji : void 0
-  };
-};
-var groupAttrs = (content) => {
-  const items = content.items;
-  if (!Array.isArray(items)) {
-    return {};
-  }
-  const types = items.map((item) => {
-    const itemType = item?.content?.type;
-    return typeof itemType === "string" ? itemType : void 0;
-  }).filter((t) => t !== void 0);
-  return {
-    "spectrum.message.content.items.count": items.length,
-    "spectrum.message.content.items.types": types.length > 0 ? types.join(",") : void 0
-  };
-};
-var typingAttrs = (content) => {
-  const state = content.state;
-  return {
-    "spectrum.message.content.typing.state": typeof state === "string" ? state : void 0
-  };
-};
-var attachmentAttrs = (content) => {
-  const mime = content.mimeType;
-  const size = content.size;
-  return {
-    "spectrum.message.content.attachment.mime": typeof mime === "string" ? mime : void 0,
-    "spectrum.message.content.attachment.size": typeof size === "number" ? size : void 0
-  };
-};
-var voiceAttrs = (content) => {
-  const mime = content.mimeType;
-  const duration = content.duration;
-  const size = content.size;
-  return {
-    "spectrum.message.content.voice.mime": typeof mime === "string" ? mime : void 0,
-    "spectrum.message.content.voice.duration": typeof duration === "number" ? duration : void 0,
-    "spectrum.message.content.voice.size": typeof size === "number" ? size : void 0
-  };
-};
-var CONTENT_ATTR_HANDLERS = {
-  reply: replyOrEditAttrs,
-  edit: replyOrEditAttrs,
-  unsend: unsendAttrs,
-  reaction: reactionAttrs,
-  group: groupAttrs,
-  typing: typingAttrs,
-  attachment: attachmentAttrs,
-  voice: voiceAttrs
-};
-function contentAttrs(content) {
-  const type = content?.type;
-  if (!(content && type)) {
-    return { "spectrum.message.content.type": void 0 };
-  }
-  const handler = CONTENT_ATTR_HANDLERS[type];
-  return {
-    "spectrum.message.content.type": type,
-    ...handler ? handler(content) : {}
-  };
-}
-function senderAttrs(sender) {
-  const id = sender?.id;
-  if (typeof id !== "string" || id.length === 0) {
-    return {};
-  }
-  const { kind, identifier } = classifyIdentifier(id);
-  return {
-    "spectrum.message.sender.id": identifier,
-    "spectrum.message.sender.kind": kind
-  };
-}
-
-// src/platform/build.ts
-var platformLog = createLogger("spectrum.platform");
-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 FIRE_AND_FORGET_TYPES = /* @__PURE__ */ new Set([
-  "typing",
-  "edit",
-  "rename",
-  "avatar",
-  "unsend",
-  "read"
-]);
-var isFireAndForget = (item) => FIRE_AND_FORGET_TYPES.has(item.type) || item.__fireAndForget === true;
-var RESERVED_SPACE_KEYS = /* @__PURE__ */ new Set([
-  "__platform",
-  "id",
-  "send",
-  "edit",
-  "unsend",
-  "read",
-  "getMessage",
-  "rename",
-  "avatar",
-  "startTyping",
-  "stopTyping",
-  "responding"
-]);
-var PLATFORM_WISE_ACTION_KEYS = /* @__PURE__ */ new Set(["getMessage"]);
-var RESERVED_MESSAGE_KEYS = /* @__PURE__ */ new Set([
-  "content",
-  "direction",
-  "edit",
-  "id",
-  "platform",
-  "react",
-  "read",
-  "reply",
-  "sender",
-  "space",
-  "timestamp",
-  "unsend"
-]);
-var scopeLabel = (scope) => {
-  if (scope === "space") {
-    return "Space";
-  }
-  if (scope === "message") {
-    return "Message";
-  }
-  return "PlatformInstance";
-};
-var warnReservedAction = (scope, name, platform) => {
-  const body = `[spectrum-ts] ${platform} declared ${scope} action "${name}" which collides with a reserved ${scopeLabel(scope)} key; skipping.`;
-  console.warn(
-    supportsAnsiColor() ? `${ANSI_YELLOW}${body}${ANSI_RESET}` : body
-  );
-};
-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}` : "";
-  platformLog.warn(
-    `${platform} does not support ${subject}${detail}; skipping.`,
-    {
-      "spectrum.provider": platform,
-      "spectrum.unsupported.kind": err.kind,
-      "spectrum.unsupported.content_type": err.contentType,
-      "spectrum.unsupported.action": err.action
-    }
-  );
-};
-var contentPlatform = (content) => {
-  const platform = content.__platform;
-  return typeof platform === "string" ? platform : void 0;
-};
-var findUnsupportedPlatformContent = (content, platform) => {
-  const scopedPlatform = contentPlatform(content);
-  if (scopedPlatform && scopedPlatform !== platform) {
-    return scopedPlatform;
-  }
-  if (content.type === "reply" || content.type === "edit") {
-    return findUnsupportedPlatformContent(content.content, platform);
-  }
-  if (content.type !== "group") {
-    return;
-  }
-  for (const item of content.items) {
-    const nested = item.content;
-    if (typeof nested !== "object" || nested === null || !("type" in nested)) {
-      continue;
-    }
-    const unsupported = findUnsupportedPlatformContent(
-      nested,
-      platform
-    );
-    if (unsupported) {
-      return unsupported;
-    }
-  }
-};
-var unsupportedPlatformContentError = (content, platform) => {
-  const requiredPlatform = findUnsupportedPlatformContent(content, platform);
-  if (!requiredPlatform) {
-    return;
-  }
-  return UnsupportedError.content(
-    content.type,
-    platform,
-    `requires ${requiredPlatform}`
-  );
-};
-var findStreamText = (item) => {
-  if (item.type === "streamText") {
-    return item;
-  }
-  if ((item.type === "reply" || item.type === "edit") && item.content.type === "streamText") {
-    return item.content;
-  }
-  return;
-};
-var replaceStreamText = (item, source, full) => {
-  const inner = source.format === "markdown" ? asMarkdown(full) : asText(full);
-  if (item.type === "reply" || item.type === "edit") {
-    return { ...item, content: inner };
-  }
-  return inner;
-};
-var downgradeMarkdown = (md) => {
-  const plain = markdownToPlainText(md.markdown);
-  return plain ? asText(plain) : void 0;
-};
-var replaceMarkdown = (item) => {
-  if (item.type === "markdown") {
-    return downgradeMarkdown(item) ?? item;
-  }
-  if ((item.type === "reply" || item.type === "edit") && item.content.type === "markdown") {
-    const downgraded = downgradeMarkdown(item.content);
-    return downgraded ? { ...item, content: downgraded } : item;
-  }
-  if (item.type === "group") {
-    let changed = false;
-    const items = item.items.map((member) => {
-      if (member.content.type !== "markdown") {
-        return member;
-      }
-      const downgraded = downgradeMarkdown(member.content);
-      if (!downgraded) {
-        return member;
-      }
-      changed = true;
-      return { ...member, content: downgraded };
-    });
-    return changed ? { ...item, items } : item;
-  }
-  return item;
-};
-async function resendDrainedStream(send, item, source, platform, unsupported) {
-  platformLog.info(
-    `${platform} does not support streaming text; waiting for the stream to finish to send the full text as one message.`,
-    {
-      "spectrum.provider": platform,
-      "spectrum.stream_text.fallback": true
-    }
-  );
-  let full;
-  try {
-    full = await drainStreamText(source);
-  } catch (drainErr) {
-    if (drainErr instanceof StreamConsumedError) {
-      throw unsupported;
-    }
-    throw drainErr;
-  }
-  if (!full) {
-    throw unsupported;
-  }
-  return await sendWithFallbacks(
-    send,
-    replaceStreamText(item, source, full),
-    platform
-  );
-}
-async function sendWithFallbacks(send, item, platform) {
-  try {
-    return await send(item);
-  } catch (err) {
-    if (!(err instanceof UnsupportedError)) {
-      throw err;
-    }
-    const source = findStreamText(item);
-    if (source) {
-      return await resendDrainedStream(send, item, source, platform, err);
-    }
-    const downgraded = replaceMarkdown(item);
-    if (downgraded === item) {
-      throw err;
-    }
-    platformLog.info(
-      `${platform} does not support markdown; sending the content as plain text instead.`,
-      {
-        "spectrum.provider": platform,
-        "spectrum.markdown.fallback": true
-      }
-    );
-    return await send(downgraded);
-  }
-}
-var providerMessageCoreKeys = /* @__PURE__ */ new Set([
-  "content",
-  "direction",
-  "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;
-};
-var rawDirection = (raw) => raw.direction === "inbound" || raw.direction === "outbound" ? raw.direction : void 0;
-function wrapProviderMessage(raw, ctx, direction) {
-  const effectiveDirection = rawDirection(raw) ?? direction;
-  const wrappedContent = wrapNestedContent(
-    raw.content,
-    ctx,
-    effectiveDirection
-  );
-  const base = {
-    id: raw.id,
-    content: wrappedContent,
-    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,
-    store: ctx.store
-  };
-  if (effectiveDirection === "inbound") {
-    return buildMessage({ ...base, sender: raw.sender, direction: "inbound" });
-  }
-  return buildMessage({ ...base, sender: raw.sender, direction: "outbound" });
-}
-var wrapNestedContent = (content, ctx, direction) => {
-  if (content.type === "reaction") {
-    const target = content.target;
-    if (isRawProviderRecord(target)) {
-      return {
-        ...content,
-        target: wrapProviderMessage(target, ctx, "inbound")
-      };
-    }
-    return content;
-  }
-  if (content.type === "edit") {
-    const target = content.target;
-    if (isRawProviderRecord(target)) {
-      return {
-        ...content,
-        target: wrapProviderMessage(target, ctx, "outbound")
-      };
-    }
-    return content;
-  }
-  if (content.type === "group") {
-    const items = content.items.map((item) => {
-      const raw = item;
-      if (!isRawProviderRecord(raw)) {
-        return item;
-      }
-      return direction === "inbound" ? wrapProviderMessage(raw, ctx, "inbound") : wrapProviderMessage(raw, ctx, "outbound");
-    });
-    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, actionCtx, definition, client, config, store } = params;
-  let space;
-  async function dispatchSend(item) {
-    return withSpan(
-      "spectrum.message.send",
-      {
-        "spectrum.provider": definition.name,
-        "spectrum.space.id": spaceRef.id,
-        "spectrum.message.fire_and_forget": isFireAndForget(item),
-        ...contentAttrs(item)
-      },
-      async () => {
-        const platformError = unsupportedPlatformContentError(
-          item,
-          definition.name
-        );
-        if (platformError) {
-          warnUnsupported(platformError, definition.name);
-          return;
-        }
-        const providerSend = async (content) => await definition.send({
-          ...actionCtx,
-          content
-        });
-        let raw;
-        try {
-          raw = await sendWithFallbacks(providerSend, item, definition.name);
-        } catch (err) {
-          if (err instanceof UnsupportedError) {
-            warnUnsupported(err, definition.name);
-            return;
-          }
-          throw err;
-        }
-        if (!raw?.id) {
-          if (isFireAndForget(item)) {
-            return;
-          }
-          throw new Error(
-            `Platform "${definition.name}" send did not return a message id`
-          );
-        }
-        return wrapProviderMessage(
-          raw,
-          { client, config, definition, space, spaceRef, store },
-          "outbound"
-        );
-      }
-    );
-  }
-  async function sendImpl(...content) {
-    const resolved = await resolveContents(content);
-    const results = [];
-    for (const item of resolved) {
-      const sent = await dispatchSend(item);
-      if (sent) {
-        results.push(sent);
-      }
-    }
-    if (content.length === 1) {
-      return results[0];
-    }
-    return results;
-  }
-  async function getMessageImpl(id) {
-    const getMessage = definition.actions?.getMessage;
-    if (!getMessage) {
-      throw UnsupportedError.action("getMessage", definition.name);
-    }
-    return withSpan(
-      "spectrum.message.get",
-      {
-        "spectrum.provider": definition.name,
-        "spectrum.space.id": spaceRef.id,
-        "spectrum.message.id": id
-      },
-      async () => {
-        const raw = await getMessage(
-          { client, config, store },
-          spaceRef,
-          id
-        );
-        if (!raw) {
-          return;
-        }
-        return wrapProviderMessage(
-          raw,
-          { client, config, definition, space, spaceRef, store },
-          "inbound"
-        );
-      }
-    );
-  }
-  const platformActions = {};
-  const declaredActions = definition.space.actions;
-  if (declaredActions) {
-    for (const [name, factory] of Object.entries(declaredActions)) {
-      if (RESERVED_SPACE_KEYS.has(name)) {
-        warnReservedAction("space", name, definition.name);
-        continue;
-      }
-      platformActions[name] = async (...args) => {
-        await factory(space, ...args);
-      };
-    }
-  }
-  space = {
-    ...extras,
-    ...spaceRef,
-    ...platformActions,
-    send: sendImpl,
-    edit: async (message, newContent) => {
-      await space.send(edit(newContent, message));
-    },
-    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));
-    },
-    avatar: (async (input, options) => {
-      if (typeof input === "string" || input instanceof URL) {
-        await space.send(avatar(input, options));
-        return;
-      }
-      if (!options?.mimeType) {
-        throw new Error(
-          "space.avatar(Buffer) requires options.mimeType \u2014 pass { mimeType: '...' }"
-        );
-      }
-      await space.send(avatar(input, { mimeType: options.mimeType }));
-    }),
-    startTyping: async () => {
-      await space.send(typing("start"));
-    },
-    stopTyping: async () => {
-      await space.send(typing("stop"));
-    },
-    responding: async (fn) => {
-      await space.send(typing("start"));
-      try {
-        return await fn();
-      } finally {
-        await space.send(typing("stop")).catch(() => {
-        });
-      }
-    }
-  };
-  return space;
-}
-function buildMessage(params) {
-  const { definition, space } = params;
-  let self;
-  const requireBuiltMessage = (action) => {
-    if (!self) {
-      throw new Error(
-        `${action}() called before message construction completed (internal bug)`
-      );
-    }
-    return self;
-  };
-  const react = async (emoji) => {
-    const target = requireBuiltMessage("react");
-    return await space.send(reaction(emoji, target));
-  };
-  async function reply2(...content) {
-    const target = requireBuiltMessage("reply");
-    const wrapped = content.map((c) => reply(c, target));
-    return space.send(...wrapped);
-  }
-  const edit2 = async (newContent) => {
-    const target = requireBuiltMessage("edit");
-    if (target.direction !== "outbound") {
-      throw new Error(
-        `cannot edit message ${target.id}: only outbound messages can be edited (direction: "${target.direction}")`
-      );
-    }
-    await space.send(edit(newContent, target));
-  };
-  const unsend2 = async () => {
-    const target = requireBuiltMessage("unsend");
-    if (target.direction !== "outbound") {
-      throw new Error(
-        `cannot unsend message ${target.id}: only outbound messages can be unsent (direction: "${target.direction}")`
-      );
-    }
-    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;
-    }
-    if (params.direction === "outbound") {
-      return {
-        ...params.sender,
-        __platform: definition.name,
-        kind: "agent"
-      };
-    }
-    return { ...params.sender, __platform: definition.name };
-  };
-  const senderWithPlatform = buildSenderWithPlatform();
-  const messagePlatformActions = {};
-  const declaredMessageActions = definition.message?.actions;
-  if (declaredMessageActions) {
-    for (const [name, factory] of Object.entries(declaredMessageActions)) {
-      if (RESERVED_MESSAGE_KEYS.has(name)) {
-        warnReservedAction("message", name, definition.name);
-        continue;
-      }
-      messagePlatformActions[name] = async (...args) => {
-        const target = requireBuiltMessage(name);
-        await factory(target, ...args);
-      };
-    }
-  }
-  const message = {
-    ...params.extras,
-    ...messagePlatformActions,
-    id: params.id,
-    content: params.content,
-    direction: params.direction,
-    platform: definition.name,
-    react,
-    read: read2,
-    reply: reply2,
-    edit: edit2,
-    unsend: unsend2,
-    sender: senderWithPlatform,
-    space,
-    timestamp: params.timestamp
-  };
-  self = message;
-  return message;
-}
-
-// src/platform/define.ts
-var platformLog2 = createLogger2("spectrum.platform");
-function buildInstanceActions(platformName, declared, reservedKeys, buildCtx) {
-  const out = {};
-  for (const key of PLATFORM_WISE_ACTION_KEYS) {
-    const override = declared?.[key];
-    if (override && typeof override === "function") {
-      out[key] = (...args) => override(buildCtx(), ...args);
-    } else {
-      out[key] = () => {
-        throw UnsupportedError.action(key, platformName);
-      };
-    }
-  }
-  if (!declared) {
-    return out;
-  }
-  for (const [name, factory] of Object.entries(declared)) {
-    if (PLATFORM_WISE_ACTION_KEYS.has(name)) {
-      continue;
-    }
-    if (reservedKeys.has(name)) {
-      warnReservedAction("instance", name, platformName);
-      continue;
-    }
-    if (typeof factory !== "function") {
-      continue;
-    }
-    out[name] = (...args) => factory(buildCtx(), ...args);
-  }
-  return out;
-}
-function createPlatformInstance(def, runtime) {
-  const resolveUserID = async (userID) => {
-    const resolved = await def.user.resolve({
-      input: { userID },
-      client: runtime.client,
-      config: runtime.config,
-      store: runtime.store
-    });
-    return {
-      ...resolved,
-      __platform: def.name
-    };
-  };
-  const providerCtx = () => ({
-    client: runtime.client,
-    config: runtime.config,
-    store: runtime.store
-  });
-  const parseSpaceParams = (params) => params !== void 0 && def.space.params ? def.space.params.parse(params) : params;
-  const finalizeSpace = (resolved) => {
-    const parsedSpace = def.space.schema ? def.space.schema.parse(resolved) : resolved;
-    const spaceRef = {
-      ...parsedSpace,
-      id: parsedSpace.id,
-      __platform: def.name
-    };
-    const actionCtx = {
-      space: spaceRef,
-      ...providerCtx()
-    };
-    return buildSpace({
-      spaceRef,
-      extras: parsedSpace,
-      actionCtx,
-      definition: def,
-      client: runtime.client,
-      config: runtime.config,
-      store: runtime.store
-    });
-  };
-  const base = {
-    async user(userID) {
-      return await resolveUserID(userID);
-    },
-    space: {
-      create: async (users, params) => {
-        const userList = Array.isArray(users) ? users : [users];
-        const first = userList.length === 1 ? userList[0] : void 0;
-        const single = typeof first === "string" ? classifyIdentifier(first) : void 0;
-        const kind = userList.length > 1 ? "group" : single?.kind ?? "unknown";
-        return await withSpan2(
-          "spectrum.space.create",
-          {
-            "spectrum.provider": def.name,
-            "spectrum.space.user_count": userList.length,
-            "spectrum.space.identifier_kind": kind,
-            "spectrum.space.identifier": kind === "unknown" ? void 0 : single?.identifier
-          },
-          async () => {
-            const resolvedUsers = await Promise.all(
-              userList.map(
-                (u) => typeof u === "string" ? resolveUserID(u) : u
-              )
-            );
-            const resolved = await def.space.create({
-              input: { users: resolvedUsers, params: parseSpaceParams(params) },
-              ...providerCtx()
-            });
-            return finalizeSpace(resolved);
-          }
-        );
-      },
-      get: async (id, params) => await withSpan2(
-        "spectrum.space.get",
-        {
-          "spectrum.provider": def.name,
-          "spectrum.space.id": id
-        },
-        async () => {
-          const parsedParams = parseSpaceParams(params);
-          if (def.space.get) {
-            const resolved = await def.space.get({
-              input: { id, params: parsedParams },
-              ...providerCtx()
-            });
-            return finalizeSpace(resolved);
-          }
-          const candidate = { id };
-          if (def.space.schema) {
-            const parsed = def.space.schema.safeParse(candidate);
-            if (!parsed.success) {
-              throw new Error(
-                `Platform "${def.name}" cannot construct a space from an id alone \u2014 its space schema requires more fields. Implement \`space.get\` in the "${def.name}" provider definition.`,
-                { cause: parsed.error }
-              );
-            }
-          }
-          return finalizeSpace(candidate);
-        }
-      )
-    }
-  };
-  const eventProperties = {};
-  const customEvents = def.events ?? {};
-  for (const eventName of Object.keys(customEvents)) {
-    const declared = customEvents[eventName];
-    if (typeof declared === "function") {
-      const producer = declared;
-      eventProperties[eventName] = producer({
-        client: runtime.client,
-        config: runtime.config,
-        projectConfig: runtime.projectConfig,
-        store: runtime.store
-      });
-      continue;
-    }
-    const fusorEvents = runtime.subscribeEvent?.(eventName);
-    if (fusorEvents) {
-      eventProperties[eventName] = fusorEvents;
-    }
-  }
-  let messagesIterable;
-  Object.defineProperty(base, "messages", {
-    enumerable: true,
-    get() {
-      messagesIterable ??= runtime.subscribeMessages();
-      return messagesIterable;
-    }
-  });
-  const instanceActions = buildInstanceActions(
-    def.name,
-    def.actions,
-    /* @__PURE__ */ new Set([
-      "user",
-      "space",
-      "messages",
-      ...Object.keys(customEvents)
-    ]),
-    () => ({
-      client: runtime.client,
-      config: runtime.config,
-      store: runtime.store
-    })
-  );
-  return Object.assign(
-    base,
-    instanceActions,
-    eventProperties
-  );
-}
-function definePlatform(name, rawDef) {
-  const def = rawDef;
-  const fullDef = { ...def, name };
-  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) {
-      platformLog2.warn("space platform mismatch; narrowing skipped", {
-        expected: name,
-        actual: input.__platform
-      });
-    }
-    return input;
-  };
-  const narrowMessage = (input) => {
-    if (input.platform !== name) {
-      platformLog2.warn("message platform mismatch; narrowing skipped", {
-        expected: name,
-        actual: 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
-    };
-  };
-  narrower.is = ((input) => {
-    if (typeof input !== "object" || input === null) {
-      return false;
-    }
-    if ("__platform" in input) {
-      return input.__platform === name;
-    }
-    if ("platform" in input) {
-      return input.platform === name;
-    }
-    return false;
-  });
-  if (def.static) {
-    Object.assign(narrower, def.static);
-  }
-  return narrower;
-}
-
-export {
-  photoActionSchema,
-  buildPhotoAction,
-  avatar,
-  edit,
-  markdownSchema,
-  asMarkdown,
-  markdown,
-  read,
-  rename,
-  reply,
-  typing,
-  unsend,
-  UnsupportedError,
-  renderInlineTokens,
-  contentAttrs,
-  senderAttrs,
-  wrapProviderMessage,
-  buildSpace,
-  definePlatform
-};