spectrum-ts 1.9.2 → 1.12.0

package/dist/{chunk-XZSBR26X.js → chunk-YDHES53X.js}

@@ -93,458 +93,79 @@ function attachment(input, options) {
   };
 }
 
-// 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;
-};
-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;
-};
-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;
-  }
-  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;
-  }
-  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;
-  }
-  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;
-  }
-  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;
+// src/content/avatar.ts
+import z4 from "zod";
+
+// src/utils/photo-content.ts
+import { readFile as readFile2 } from "fs/promises";
+import { basename as basename2 } from "path";
+import { lookup as lookupMimeType2 } from "mime-types";
+import z3 from "zod";
+var CLEAR_SENTINEL = "clear";
+var photoActionSchema = z3.discriminatedUnion("kind", [
+  z3.object({
+    kind: z3.literal("set"),
+    read: readSchema,
+    mimeType: z3.string().nonempty()
+  }),
+  z3.object({ kind: z3.literal("clear") })
+]);
+var resolveMimeType = (input, mimeType, contentLabel) => {
+  if (mimeType) {
+    return mimeType;
   }
-  const result = {};
-  if (orgStr) {
-    const [name, department] = splitStructured(orgStr);
-    if (name) {
-      result.name = name;
-    }
-    if (department) {
-      result.department = department;
+  if (typeof input === "string") {
+    const resolved = lookupMimeType2(basename2(input));
+    if (resolved) {
+      return resolved;
     }
   }
-  if (title) {
-    result.title = title;
-  }
-  return result;
-};
-var extractUrls = (card) => {
-  const props = asPropertyArray(card.data.url);
-  if (props.length === 0) {
-    return;
-  }
-  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;
-  }
-  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)
+  throw new Error(
+    `Unable to resolve MIME type for ${contentLabel}. Pass options.mimeType explicitly.`
   );
-  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;
-};
-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 cachedRead = (read) => {
+  let cached;
+  return () => {
+    cached ??= read().catch((err) => {
+      cached = void 0;
+      throw err;
+    });
+    return cached;
+  };
 };
-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();
+var buildPhotoAction = (input, options, contentLabel) => {
+  if (input === CLEAR_SENTINEL) {
+    return { kind: "clear" };
+  }
+  const mimeType = resolveMimeType(input, options?.mimeType, contentLabel);
+  let read;
+  if (typeof input === "string") {
+    read = cachedRead(() => readFile2(input));
+  } else {
+    const snapshot = Buffer.from(input);
+    read = cachedRead(async () => snapshot);
+  }
+  return { kind: "set", read, mimeType };
 };
 
-// src/content/contact.ts
-import vCard2 from "vcf";
-import z3 from "zod";
-var userRefSchema = z3.object({
-  __platform: z3.string(),
-  id: z3.string()
+// src/content/avatar.ts
+var avatarSchema = z4.object({
+  type: z4.literal("avatar"),
+  action: photoActionSchema
 });
-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) {
+function avatar(input, options) {
+  const action = buildPhotoAction(input, options, "avatar");
   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);
-    }
+    build: async () => avatarSchema.parse({ type: "avatar", action })
   };
 }
 
 // src/content/custom.ts
-import z4 from "zod";
-var customSchema = z4.object({
-  type: z4.literal("custom"),
-  raw: z4.unknown()
+import z5 from "zod";
+var customSchema = z5.object({
+  type: z5.literal("custom"),
+  raw: z5.unknown()
 });
 var asCustom = (raw) => customSchema.parse({ type: "custom", raw });
 function custom(raw) {
@@ -554,10 +175,10 @@ function custom(raw) {
 }
 
 // src/content/text.ts
-import z5 from "zod";
-var textSchema = z5.object({
-  type: z5.literal("text"),
-  text: z5.string().nonempty()
+import z6 from "zod";
+var textSchema = z6.object({
+  type: z6.literal("text"),
+  text: z6.string().nonempty()
 });
 var asText = (text2) => textSchema.parse({ type: "text", text: text2 });
 function text(text2) {
@@ -572,15 +193,15 @@ var resolveContents = (items) => Promise.all(
 );
 
 // src/content/edit.ts
-import z6 from "zod";
+import z7 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 = z6.object({
-  type: z6.literal("edit"),
-  content: z6.custom(isContent, {
+var editSchema = z7.object({
+  type: z7.literal("edit"),
+  content: z7.custom(isContent, {
     message: "edit content must be a Content value"
   }),
-  target: z6.custom(isMessage, {
+  target: z7.custom(isMessage, {
     message: "edit target must be a Message"
   })
 });
@@ -588,11 +209,16 @@ var asEdit = (input) => editSchema.parse({ type: "edit", ...input });
 function edit(content, target) {
   return {
     build: async () => {
+      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") {
+      if (resolved.type === "edit" || resolved.type === "reply" || resolved.type === "reaction" || resolved.type === "group" || resolved.type === "typing" || resolved.type === "rename" || resolved.type === "avatar") {
         throw new Error(`edit() cannot wrap "${resolved.type}" content`);
       }
       return asEdit({ content: resolved, target });
@@ -601,12 +227,12 @@ function edit(content, target) {
 }
 
 // src/content/reaction.ts
-import z7 from "zod";
+import z8 from "zod";
 var isMessage2 = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
-var reactionSchema = z7.object({
-  type: z7.literal("reaction"),
-  emoji: z7.string().min(1),
-  target: z7.custom(isMessage2, {
+var reactionSchema = z8.object({
+  type: z8.literal("reaction"),
+  emoji: z8.string().min(1),
+  target: z8.custom(isMessage2, {
     message: "reaction target must be a Message"
   })
 });
@@ -622,16 +248,28 @@ function reaction(emoji, target) {
   };
 }
 
+// src/content/rename.ts
+import z9 from "zod";
+var renameSchema = z9.object({
+  type: z9.literal("rename"),
+  displayName: z9.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 z8 from "zod";
+import z10 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 = z8.object({
-  type: z8.literal("reply"),
-  content: z8.custom(isContent2, {
+var replySchema = z10.object({
+  type: z10.literal("reply"),
+  content: z10.custom(isContent2, {
     message: "reply content must be a Content value"
   }),
-  target: z8.custom(isMessage3, {
+  target: z10.custom(isMessage3, {
     message: "reply target must be a Message"
   })
 });
@@ -643,7 +281,7 @@ function reply(content, target) {
       if (!resolved) {
         throw new Error("reply() requires content");
       }
-      if (resolved.type === "reply" || resolved.type === "edit" || resolved.type === "reaction" || resolved.type === "group" || resolved.type === "typing") {
+      if (resolved.type === "reply" || resolved.type === "edit" || resolved.type === "reaction" || resolved.type === "group" || resolved.type === "typing" || resolved.type === "rename" || resolved.type === "avatar") {
         throw new Error(`reply() cannot wrap "${resolved.type}" content`);
       }
       return asReply({ content: resolved, target });
@@ -652,10 +290,10 @@ function reply(content, target) {
 }
 
 // src/content/typing.ts
-import z9 from "zod";
-var typingSchema = z9.object({
-  type: z9.literal("typing"),
-  state: z9.enum(["start", "stop"])
+import z11 from "zod";
+var typingSchema = z11.object({
+  type: z11.literal("typing"),
+  state: z11.enum(["start", "stop"])
 });
 function typing(state = "start") {
   return {
@@ -847,7 +485,9 @@ var supportsAnsiColor = () => {
 var FIRE_AND_FORGET_TYPES = /* @__PURE__ */ new Set([
   "reaction",
   "typing",
-  "edit"
+  "edit",
+  "rename",
+  "avatar"
 ]);
 var isFireAndForget = (item) => FIRE_AND_FORGET_TYPES.has(item.type) || item.__fireAndForget === true;
 var RESERVED_SPACE_KEYS = /* @__PURE__ */ new Set([
@@ -856,12 +496,26 @@ var RESERVED_SPACE_KEYS = /* @__PURE__ */ new Set([
   "send",
   "edit",
   "getMessage",
+  "rename",
+  "avatar",
   "startTyping",
   "stopTyping",
   "responding"
 ]);
-var warnReservedAction = (name, platform) => {
-  const body = `[spectrum-ts] ${platform} declared space action "${name}" which collides with a reserved Space key; skipping.`;
+var RESERVED_MESSAGE_KEYS = /* @__PURE__ */ new Set([
+  "content",
+  "direction",
+  "edit",
+  "id",
+  "platform",
+  "react",
+  "reply",
+  "sender",
+  "space",
+  "timestamp"
+]);
+var warnReservedAction = (scope, name, platform) => {
+  const body = `[spectrum-ts] ${platform} declared ${scope} action "${name}" which collides with a reserved ${scope === "space" ? "Space" : "Message"} key; skipping.`;
   console.warn(
     supportsAnsiColor() ? `${ANSI_YELLOW}${body}${ANSI_RESET}` : body
   );
@@ -1110,10 +764,12 @@ function buildSpace(params) {
   if (declaredActions) {
     for (const [name, factory] of Object.entries(declaredActions)) {
       if (RESERVED_SPACE_KEYS.has(name)) {
-        warnReservedAction(name, definition.name);
+        warnReservedAction("space", name, definition.name);
         continue;
       }
-      platformActions[name] = (...args) => space.send(factory(...args));
+      platformActions[name] = async (...args) => {
+        await factory(space, ...args);
+      };
     }
   }
   space = {
@@ -1125,6 +781,21 @@ function buildSpace(params) {
       await space.send(edit(newContent, message));
     },
     getMessage: getMessageImpl,
+    rename: async (displayName) => {
+      await space.send(rename(displayName));
+    },
+    avatar: (async (input, options) => {
+      if (typeof input === "string") {
+        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"));
     },
@@ -1146,10 +817,6 @@ function buildSpace(params) {
 function buildMessage(params) {
   const { definition, space } = params;
   let self;
-  const react = async (emoji) => {
-    const target = requireBuiltMessage("react");
-    await space.send(reaction(emoji, target));
-  };
   const requireBuiltMessage = (action) => {
     if (!self) {
       throw new Error(
@@ -1158,46 +825,68 @@ function buildMessage(params) {
     }
     return self;
   };
+  const react = async (emoji) => {
+    const target = requireBuiltMessage("react");
+    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 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: reply2,
-      edit: async (newContent) => {
-        const target = requireBuiltMessage("edit");
-        await space.send(edit(newContent, target));
-      },
-      sender: senderWithPlatform,
-      space,
-      timestamp: params.timestamp
-    };
-    self = outbound;
-    return outbound;
+  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 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 inbound = {
+  const message = {
     ...params.extras,
+    ...messagePlatformActions,
     id: params.id,
     content: params.content,
-    direction: "inbound",
+    direction: params.direction,
     platform: definition.name,
     react,
     reply: reply2,
+    edit: edit2,
     sender: senderWithPlatform,
     space,
     timestamp: params.timestamp
   };
-  self = inbound;
-  return inbound;
+  self = message;
+  return message;
 }
 
 // src/platform/define.ts
@@ -1435,10 +1124,9 @@ export {
   attachmentSchema,
   asAttachment,
   attachment,
-  fromVCard,
-  toVCard,
-  asContact,
-  contact,
+  photoActionSchema,
+  buildPhotoAction,
+  avatar,
   asCustom,
   custom,
   textSchema,
@@ -1449,6 +1137,7 @@ export {
   reactionSchema,
   asReaction,
   reaction,
+  rename,
   reply,
   typing,
   UnsupportedError,