@mh-gg/base-plugins 0.1.1-alpha.20260613T085325975Z

package/src/index.cjs

@@ -0,0 +1,19 @@
+module.exports = {
+  ...require("./shared/constants.cjs"),
+  ...require("./comments/index.cjs"),
+  ...require("./presence/index.cjs"),
+  ...require("./media-rooms/index.cjs"),
+  ...require("./screen-share/index.cjs"),
+  ...require("./markdown/index.cjs"),
+  ...require("./embeds/index.cjs"),
+  ...require("./attachments/index.cjs"),
+  ...require("./files/index.cjs"),
+  ...require("./reactions/index.cjs"),
+  ...require("./labels/index.cjs"),
+  ...require("./approvals/index.cjs"),
+  ...require("./checklists/index.cjs"),
+  ...require("./calendar/index.cjs"),
+  ...require("./location-pins/index.cjs"),
+  ...require("./crdt/index.cjs"),
+  ...require("./composer/index.cjs")
+};

package/src/labels/index.cjs

@@ -0,0 +1,46 @@
+const { LABELS_PLUGIN_ID, LABELS_PLUGIN_KEY } = require("../shared/constants.cjs");
+const {
+  allow,
+  activity,
+  actorName,
+  array,
+  createOperationSchemaDescriptor,
+  defineHostPlugin,
+  deny,
+  entityId,
+  enumValue,
+  memberOrBetter,
+  moderatorOrBetter,
+  object,
+  optionalString,
+  readonlyState,
+  scopeKey,
+  scopePayload,
+  string,
+  BASE_PLUGIN_VERSION
+} = require("../shared/index.cjs");
+
+function labelPayload(payload) { const value = object(payload, "label payload"); return { name: string(value.name, "name", 80), color: optionalString(value.color, "color", 40) || "neutral", description: optionalString(value.description, "description", 240) }; }
+function labelApplyPayload(payload) { const value = object(payload, "label apply payload"); return { ...scopePayload(value), labelId: string(value.labelId, "labelId") }; }
+const labelsHostPlugin = defineHostPlugin({
+  id: LABELS_PLUGIN_ID,
+  version: BASE_PLUGIN_VERSION,
+  meta: { name: "Reusable Labels And Tags" },
+  capabilities: { requires: ["room.state", "room.roles"], provides: ["taxonomy.labels", "taxonomy.scoped-tags"] },
+  stateSchemaDescriptor: { plugin: LABELS_PLUGIN_ID, shape: ["labels", "assignments", "activity"] },
+  operationSchemaDescriptor: createOperationSchemaDescriptor(LABELS_PLUGIN_ID, BASE_PLUGIN_VERSION, { "label.create": { required: ["name"], optional: ["color", "description"], authorize: { roles: ["moderator"] } }, "label.apply": { required: ["scopeType", "scopeId", "labelId"], authorize: { roles: ["member"] } }, "label.remove": { required: ["scopeType", "scopeId", "labelId"], authorize: { roles: ["member"] } } }),
+  schemas: { state: { parse(value) { const state = object(value, "labels state"); object(state.labels, "labels"); object(state.assignments, "assignments"); array(state.activity, "activity"); return state; } }, operations: { "label.create": { parse: labelPayload }, "label.apply": { parse: labelApplyPayload }, "label.remove": { parse: labelApplyPayload } }, publicView: { parse: readonlyState }, queries: { labelsForScope: { parse: readonlyState }, labelDirectory: { parse: readonlyState } } },
+  async createInitialState() { return { labels: {}, assignments: {}, activity: [] }; },
+  authorize(_ctx, op) { if (op.type === "label.create") return moderatorOrBetter(op.actor) ? allow() : deny("Moderators only"); if (["label.apply", "label.remove"].includes(op.type)) return memberOrBetter(op.actor) ? allow() : deny("Members only"); return deny("Unsupported label operation"); },
+  async reduce(_ctx, state, op) {
+    if (op.type === "label.create") { const label = { id: entityId("label", op), ...op.payload, createdBy: op.actor.memberId, createdAt: op.createdAt }; return { ...state, labels: { ...state.labels, [label.id]: label }, activity: activity(state, op, `${actorName(op.actor)} created label ${label.name}`) }; }
+    const label = state.labels[op.payload.labelId]; if (!label) throw new Error(`Label ${op.payload.labelId} not found`);
+    const key = scopeKey(op.payload.scopeType, op.payload.scopeId); const current = new Set(state.assignments[key] || []);
+    if (op.type === "label.apply") current.add(label.id); else current.delete(label.id);
+    return { ...state, assignments: { ...state.assignments, [key]: [...current].sort() }, activity: activity(state, op, `${actorName(op.actor)} ${op.type === "label.apply" ? "applied" : "removed"} ${label.name}`) };
+  },
+  getPublicView(_ctx, state) { return state; },
+  queries: { labelDirectory(_ctx, state) { return Object.values(state.labels).sort((a, b) => a.name.localeCompare(b.name)); }, labelsForScope(_ctx, state, input = {}) { const scoped = scopePayload(input, "labelsForScope input"); const ids = state.assignments[scopeKey(scoped.scopeType, scoped.scopeId)] || []; return ids.map((id) => state.labels[id]).filter(Boolean); } }
+});
+
+module.exports = { LABELS_PLUGIN_ID, LABELS_PLUGIN_KEY, labelsHostPlugin };

package/src/location-pins/index.cjs

@@ -0,0 +1,142 @@
+const { LOCATION_PINS_PLUGIN_ID, LOCATION_PINS_PLUGIN_KEY } = require("../shared/constants.cjs");
+const {
+  BASE_PLUGIN_VERSION,
+  activity,
+  actorName,
+  adminOrOwner,
+  allow,
+  array,
+  createOperationSchemaDescriptor,
+  defineHostPlugin,
+  deny,
+  memberOrBetter,
+  number,
+  object,
+  optionalString,
+  readonlyState,
+  scopeKey,
+  scopePayload,
+  string
+} = require("../shared/index.cjs");
+
+function clampNumber(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+function wrapLongitude(value) {
+  return ((((value + 180) % 360) + 360) % 360) - 180;
+}
+
+function normalizePin(value) {
+  const lat = number(value.lat, "lat");
+  const lng = number(value.lng, "lng");
+  const zoom = value.zoom === undefined ? 13 : number(value.zoom, "zoom");
+  return {
+    lat: clampNumber(lat, -85.05112878, 85.05112878),
+    lng: wrapLongitude(lng),
+    zoom: Math.round(clampNumber(zoom, 2, 18))
+  };
+}
+
+function locationPinSetPayload(payload) {
+  const value = object(payload, "location.pin.set payload");
+  return {
+    ...scopePayload(value),
+    ...normalizePin(value),
+    label: optionalString(value.label, "label", 180),
+    address: optionalString(value.address, "address", 300)
+  };
+}
+
+function locationPinClearPayload(payload) {
+  const value = object(payload, "location.pin.clear payload");
+  return scopePayload(value);
+}
+
+function locationPinsForScope(_ctx, state, input = {}) {
+  const scoped = scopePayload(input, "locationPinsForScope input");
+  return Object.values(state.pins)
+    .filter((pin) => !pin.removedAt && pin.scopeType === scoped.scopeType && pin.scopeId === scoped.scopeId)
+    .sort((left, right) => right.updatedAt - left.updatedAt);
+}
+
+function pinId(payload) {
+  return `pin_${scopeKey(payload.scopeType, payload.scopeId).replace(/[^A-Za-z0-9_-]/g, "_")}`;
+}
+
+const locationPinsHostPlugin = defineHostPlugin({
+  id: LOCATION_PINS_PLUGIN_ID,
+  version: BASE_PLUGIN_VERSION,
+  meta: { name: "Reusable Location Pins" },
+  capabilities: { requires: ["room.state", "room.roles"], provides: ["location.pins", "location.coordinates"] },
+  stateSchemaDescriptor: { plugin: LOCATION_PINS_PLUGIN_ID, shape: ["pins", "activity"] },
+  operationSchemaDescriptor: createOperationSchemaDescriptor(LOCATION_PINS_PLUGIN_ID, BASE_PLUGIN_VERSION, {
+    "location.pin.set": {
+      required: { scopeType: { type: "string" }, scopeId: { type: "string" }, lat: { type: "number" }, lng: { type: "number" } },
+      optional: { zoom: { type: "number" }, label: { type: "string" }, address: { type: "string" } },
+      authorize: { roles: ["member"] }
+    },
+    "location.pin.clear": { required: { scopeType: { type: "string" }, scopeId: { type: "string" } }, authorize: { roles: ["admin"] } }
+  }),
+  schemas: {
+    state: { parse(value) { const state = object(value, "location pins state"); object(state.pins, "pins"); array(state.activity, "activity"); return state; } },
+    operations: {
+      "location.pin.set": { parse: locationPinSetPayload },
+      "location.pin.clear": { parse: locationPinClearPayload }
+    },
+    publicView: { parse: readonlyState },
+    queries: { locationPinsForScope: { parse: readonlyState } }
+  },
+  async createInitialState() { return { pins: {}, activity: [] }; },
+  authorize(ctx, op) {
+    if (op.type === "location.pin.set") {
+      if (!memberOrBetter(op.actor)) return deny("Members only");
+      return ctx.access.canEdit(op.payload.scopeType, op.payload.scopeId) ? allow() : deny("Scoped edit access required");
+    }
+    if (op.type === "location.pin.clear") return adminOrOwner(op.actor) ? allow() : deny("Admins only");
+    return deny("Unsupported location pin operation");
+  },
+  async reduce(_ctx, state, op) {
+    const id = pinId(op.payload);
+    if (op.type === "location.pin.clear") {
+      const existing = state.pins[id];
+      if (!existing || existing.removedAt) return state;
+      const nextPin = { ...existing, removedAt: op.createdAt, removedBy: op.actor.memberId };
+      return {
+        ...state,
+        pins: { ...state.pins, [id]: nextPin },
+        activity: activity(state, op, `${actorName(op.actor)} cleared ${existing.label || "a location pin"}`)
+      };
+    }
+    const pin = {
+      id,
+      scopeType: op.payload.scopeType,
+      scopeId: op.payload.scopeId,
+      scopeKey: scopeKey(op.payload.scopeType, op.payload.scopeId),
+      lat: op.payload.lat,
+      lng: op.payload.lng,
+      zoom: op.payload.zoom,
+      label: op.payload.label,
+      address: op.payload.address,
+      updatedBy: op.actor.memberId,
+      updatedByName: actorName(op.actor),
+      updatedAt: op.createdAt
+    };
+    return {
+      ...state,
+      pins: { ...state.pins, [pin.id]: pin },
+      activity: activity(state, op, `${actorName(op.actor)} pinned ${pin.label || pin.scopeId}`)
+    };
+  },
+  getPublicView(ctx, state) {
+    return { ...state, pins: Object.fromEntries(Object.entries(state.pins).filter(([, pin]) => !pin.removedAt && ctx.access.canView(pin.scopeType, pin.scopeId))) };
+  },
+  queries: { locationPinsForScope }
+});
+
+module.exports = {
+  LOCATION_PINS_PLUGIN_ID,
+  LOCATION_PINS_PLUGIN_KEY,
+  locationPinsHostPlugin,
+  normalizePin
+};

package/src/markdown/documents/index.cjs

@@ -0,0 +1,128 @@
+const {
+  allow,
+  activity,
+  actorName,
+  array,
+  createOperationSchemaDescriptor,
+  defineHostPlugin,
+  deny,
+  entityId,
+  enumValue,
+  object,
+  parseMaybeJsonList,
+  readonlyState,
+  scopeKey,
+  scopePayload,
+  string,
+  memberOrBetter,
+  moderatorOrBetter,
+  BASE_PLUGIN_VERSION,
+  MARKDOWN_PLUGIN_ID,
+  MAX_MARKDOWN_BYTES
+} = require("../../shared/index.cjs");
+const { parseMarkdown } = require("../parser/index.cjs");
+
+function parseMarkdownDocumentState(state) {
+  const value = object(state, "markdown state");
+  object(value.documents, "documents");
+  array(value.activity, "activity");
+  return value;
+}
+function markdownUpsertPayload(payload) {
+  const value = object(payload, "markdown.document.upsert payload");
+  return {
+    ...scopePayload(value, "markdown scope"),
+    title: string(value.title, "title", 180),
+    markdown: string(value.markdown, "markdown", MAX_MARKDOWN_BYTES),
+    visibility: enumValue(value.visibility || "members", "visibility", ["public", "members", "private"]),
+    tags: parseMaybeJsonList(value.tags, "tags")
+  };
+}
+function markdownDeletePayload(payload) {
+  const value = object(payload, "markdown.document.delete payload");
+  return { documentId: string(value.documentId, "documentId") };
+}
+const markdownStateSchemaDescriptor = { plugin: MARKDOWN_PLUGIN_ID, shape: ["documents", "activity"] };
+const markdownOperationSchemaDescriptor = {
+  "markdown.document.upsert": { required: ["scopeType", "scopeId", "title", "markdown"], optional: ["visibility", "tags"], authorize: { roles: ["member"] } },
+  "markdown.document.delete": { required: ["documentId"], authorize: { roles: ["moderator"] } }
+};
+const markdownHostPlugin = defineHostPlugin({
+  id: MARKDOWN_PLUGIN_ID,
+  version: BASE_PLUGIN_VERSION,
+  meta: { name: "Reusable Markdown Documents" },
+  capabilities: { requires: ["room.state", "room.roles"], provides: ["content.markdown", "content.markdown.embeds", "content.sanitized-ast"] },
+  stateSchemaDescriptor: markdownStateSchemaDescriptor,
+  operationSchemaDescriptor: createOperationSchemaDescriptor(MARKDOWN_PLUGIN_ID, BASE_PLUGIN_VERSION, markdownOperationSchemaDescriptor),
+  schemas: {
+    state: { parse: parseMarkdownDocumentState },
+    operations: { "markdown.document.upsert": { parse: markdownUpsertPayload }, "markdown.document.delete": { parse: markdownDeletePayload } },
+    publicView: { parse: readonlyState },
+    queries: { documentForScope: { parse: readonlyState }, searchDocuments: { parse: readonlyState } }
+  },
+  async createInitialState() { return { documents: {}, activity: [] }; },
+  authorize(_ctx, op) {
+    if (op.type === "markdown.document.upsert") return memberOrBetter(op.actor) ? allow() : deny("Members only");
+    if (op.type === "markdown.document.delete") return moderatorOrBetter(op.actor) ? allow() : deny("Moderators only");
+    return deny("Unsupported markdown operation");
+  },
+  async reduce(_ctx, state, op) {
+    if (op.type === "markdown.document.upsert") {
+      const existing = Object.values(state.documents).find((doc) => doc.scopeType === op.payload.scopeType && doc.scopeId === op.payload.scopeId && !doc.deletedAt);
+      const id = existing?.id || entityId("md", op);
+      const parsed = parseMarkdown(op.payload.markdown);
+      const doc = {
+        id,
+        scopeType: op.payload.scopeType,
+        scopeId: op.payload.scopeId,
+        scopeKey: scopeKey(op.payload.scopeType, op.payload.scopeId),
+        title: op.payload.title,
+        markdown: op.payload.markdown,
+        ast: parsed,
+        embeds: parsed.embeds,
+        text: parsed.text,
+        visibility: op.payload.visibility,
+        tags: op.payload.tags,
+        updatedBy: op.actor.memberId,
+        updatedByName: actorName(op.actor),
+        updatedAt: op.createdAt,
+        createdAt: existing?.createdAt || op.createdAt,
+        createdBy: existing?.createdBy || op.actor.memberId
+      };
+      return { ...state, documents: { ...state.documents, [id]: doc }, activity: activity(state, op, `${actorName(op.actor)} updated ${doc.title}`, { documentId: id }) };
+    }
+    if (op.type === "markdown.document.delete") {
+      const doc = state.documents[op.payload.documentId];
+      if (!doc || doc.deletedAt) throw new Error(`Document ${op.payload.documentId} not found`);
+      return { ...state, documents: { ...state.documents, [doc.id]: { ...doc, deletedAt: op.createdAt, deletedBy: op.actor.memberId } }, activity: activity(state, op, `${actorName(op.actor)} deleted ${doc.title}`) };
+    }
+    return state;
+  },
+  getPublicView(_ctx, state) {
+    return { ...state, documents: Object.fromEntries(Object.entries(state.documents).filter(([, doc]) => !doc.deletedAt && doc.visibility !== "private")) };
+  },
+  queries: {
+    documentForScope(_ctx, state, input = {}) {
+      const scoped = scopePayload(input, "documentForScope input");
+      return Object.values(state.documents).find((doc) => doc.scopeType === scoped.scopeType && doc.scopeId === scoped.scopeId && !doc.deletedAt) || null;
+    },
+    searchDocuments(_ctx, state, input = {}) {
+      const q = String(input.query || "").toLowerCase().trim();
+      return Object.values(state.documents)
+        .filter((doc) => !doc.deletedAt && (!q || doc.title.toLowerCase().includes(q) || doc.text.toLowerCase().includes(q) || doc.tags.some((tag) => tag.toLowerCase().includes(q))))
+        .sort((a, b) => b.updatedAt - a.updatedAt)
+        .slice(0, 25)
+        .map((doc) => ({ id: doc.id, title: doc.title, scopeType: doc.scopeType, scopeId: doc.scopeId, tags: doc.tags, updatedAt: doc.updatedAt, embedCount: doc.embeds.length }));
+    }
+  },
+  methods: {
+    parse(_ctx, input = {}) { return parseMarkdown(string(object(input, "parse input").markdown, "markdown", MAX_MARKDOWN_BYTES)); }
+  }
+});
+
+module.exports = {
+  MARKDOWN_PLUGIN_ID,
+  markdownHostPlugin,
+  markdownOperationSchemaDescriptor,
+  markdownStateSchemaDescriptor
+};

package/src/markdown/index.cjs

@@ -0,0 +1,8 @@
+module.exports = {
+  defineMarkdownPlugin: require("../shared/index.cjs").defineMarkdownPlugin,
+  createEmbedRecord: require("../shared/index.cjs").createEmbedRecord,
+  ...require("./providers/index.cjs"),
+  ...require("./resolve.cjs"),
+  ...require("./parser/index.cjs"),
+  ...require("./documents/index.cjs")
+};

package/src/markdown/parser/index.cjs

@@ -0,0 +1,127 @@
+const { MAX_MARKDOWN_BYTES, normalizeUrl } = require("../../shared/index.cjs");
+const { DEFAULT_MARKDOWN_PLUGINS } = require("../providers/index.cjs");
+const { cleanUrlToken, pluginForDirective, resolveEmbed } = require("../resolve.cjs");
+
+function tokeniseInline(text, options = {}) {
+  const tokens = [];
+  const embeds = [];
+  const pattern = /\[([^\]\n]+)\]\((https?:\/\/[^\s)]+)\)|(https?:\/\/[^\s<>)]+)/g;
+  let cursor = 0;
+  for (const match of text.matchAll(pattern)) {
+    if (match.index > cursor) tokens.push({ type: "text", value: text.slice(cursor, match.index) });
+    const label = match[1] || match[3];
+    const url = cleanUrlToken(match[2] || match[3]);
+    let embed = null;
+    try {
+      embed = resolveEmbed(url, { ...options, title: label });
+      embeds.push(embed);
+    } catch {
+      // Links remain valid text links even when embed resolution fails.
+    }
+    tokens.push({ type: "link", text: label, url: normalizeUrl(url), ...(embed ? { embed } : {}) });
+    cursor = match.index + match[0].length;
+  }
+  if (cursor < text.length) tokens.push({ type: "text", value: text.slice(cursor) });
+  return { tokens, embeds };
+}
+
+function parseMarkdown(markdown, options = {}) {
+  if (typeof markdown !== "string") throw new Error("markdown must be a string");
+  if (new TextEncoder().encode(markdown).length > (options.maxBytes || MAX_MARKDOWN_BYTES)) throw new Error("markdown is too large");
+  const lines = markdown.replace(/\r\n/g, "\n").split("\n");
+  const nodes = [];
+  const embeds = [];
+  let index = 0;
+  function pushInlineNode(type, text, extra = {}) {
+    const inline = tokeniseInline(text, options);
+    embeds.push(...inline.embeds);
+    nodes.push({ type, text, children: inline.tokens, ...extra });
+  }
+  while (index < lines.length) {
+    const line = lines[index];
+    if (!line.trim()) { index += 1; continue; }
+    const fence = line.match(/^```\s*([A-Za-z0-9_-]+)?\s*$/);
+    if (fence) {
+      const language = fence[1] || "text";
+      index += 1;
+      const code = [];
+      while (index < lines.length && !/^```\s*$/.test(lines[index])) { code.push(lines[index]); index += 1; }
+      if (index < lines.length) index += 1;
+      nodes.push({ type: "code", language, value: code.join("\n") });
+      continue;
+    }
+    const directive = line.match(/^::([A-Za-z0-9_-]+)(?:\[([^\]]*)\])?\((https?:\/\/[^\s)]+)\)\s*$/);
+    if (directive) {
+      const [, provider, title, url] = directive;
+      const plugin = pluginForDirective(provider, options.plugins || DEFAULT_MARKDOWN_PLUGINS);
+      if (!plugin) throw new Error(`Unknown markdown directive ${provider}`);
+      const embed = { ...plugin.toEmbed(normalizeUrl(url), { title: title || undefined, directive: provider }), pluginId: plugin.id };
+      embeds.push(embed);
+      nodes.push({ type: "embed", provider: embed.provider, title: embed.title, url: embed.url, embed });
+      index += 1;
+      continue;
+    }
+    const heading = line.match(/^(#{1,6})\s+(.+)$/);
+    if (heading) {
+      pushInlineNode("heading", heading[2].trim(), { depth: heading[1].length });
+      index += 1;
+      continue;
+    }
+    const quote = line.match(/^>\s?(.*)$/);
+    if (quote) {
+      const quoteLines = [quote[1]];
+      index += 1;
+      while (index < lines.length) {
+        const next = lines[index].match(/^>\s?(.*)$/);
+        if (!next) break;
+        quoteLines.push(next[1]);
+        index += 1;
+      }
+      pushInlineNode("blockquote", quoteLines.join("\n"));
+      continue;
+    }
+    if (/^[-*]\s+/.test(line)) {
+      const items = [];
+      while (index < lines.length && /^[-*]\s+/.test(lines[index])) {
+        const text = lines[index].replace(/^[-*]\s+/, "").trim();
+        const inline = tokeniseInline(text, options);
+        embeds.push(...inline.embeds);
+        items.push({ text, children: inline.tokens });
+        index += 1;
+      }
+      nodes.push({ type: "list", ordered: false, items });
+      continue;
+    }
+    const paragraph = [line.trim()];
+    index += 1;
+    while (index < lines.length && lines[index].trim() && !/^(#{1,6})\s+/.test(lines[index]) && !/^::[A-Za-z0-9_-]+/.test(lines[index]) && !/^[-*]\s+/.test(lines[index]) && !/^>/.test(lines[index]) && !/^```/.test(lines[index])) {
+      paragraph.push(lines[index].trim());
+      index += 1;
+    }
+    pushInlineNode("paragraph", paragraph.join(" "));
+  }
+  return {
+    kind: "matterhorn.markdown-document",
+    version: 1,
+    nodes,
+    embeds,
+    text: renderMarkdownToPlainText({ nodes }),
+    embedCount: embeds.length
+  };
+}
+
+function renderMarkdownToPlainText(parsed) {
+  const nodes = parsed?.nodes || [];
+  return nodes.map((node) => {
+    if (node.type === "code") return node.value;
+    if (node.type === "list") return node.items.map((item) => `- ${item.text}`).join("\n");
+    if (node.type === "embed") return `[${node.provider}] ${node.title || node.url}`;
+    return node.text || "";
+  }).filter(Boolean).join("\n").trim();
+}
+
+module.exports = {
+  parseMarkdown,
+  renderMarkdownToPlainText,
+  tokeniseInline
+};

package/src/markdown/providers/audio.cjs

@@ -0,0 +1,77 @@
+const {
+  cleanId,
+  createEmbedRecord,
+  defineMarkdownPlugin,
+  directRenderMode,
+  firstMatch,
+  hostEndsWith,
+  hostIs,
+  mediaKindFromPath,
+  normalizeUrl,
+  pathParts,
+  safeHostname,
+  simpleProvider
+} = require("../../shared/index.cjs");
+
+const spotifyMarkdownPlugin = defineMarkdownPlugin({
+  id: "markdown.embed.spotify",
+  provider: "spotify",
+  aliases: ["spotify"],
+  matchUrl(url) { return safeHostname(url) === "open.spotify.com"; },
+  toEmbed(url, ctx = {}) {
+    const parsed = new URL(url);
+    const parts = parsed.pathname.split("/").filter(Boolean);
+    const type = parts[0];
+    const id = parts[1];
+    const allowed = ["album", "artist", "episode", "playlist", "show", "track"];
+    if (!allowed.includes(type) || !id) throw new Error("Spotify URL must point to an album, artist, episode, playlist, show, or track");
+    return createEmbedRecord({
+      provider: "spotify",
+      kind: type === "episode" || type === "show" ? "audio-show" : "audio",
+      title: ctx.title || `Spotify ${type}`,
+      url,
+      embedUrl: `https://open.spotify.com/embed/${type}/${encodeURIComponent(id)}`,
+      renderMode: "iframe",
+      metadata: { spotifyType: type, spotifyId: id }
+    });
+  }
+});
+
+const soundcloudMarkdownPlugin = defineMarkdownPlugin({
+  id: "markdown.embed.soundcloud",
+  provider: "soundcloud",
+  aliases: ["soundcloud"],
+  matchUrl(url) { return hostIs(url, ["soundcloud.com"]); },
+  toEmbed(url, ctx = {}) { return createEmbedRecord({ provider: "soundcloud", kind: "audio", title: ctx.title || "SoundCloud track", url, embedUrl: `https://w.soundcloud.com/player/?url=${encodeURIComponent(normalizeUrl(url))}`, renderMode: "iframe", metadata: { host: safeHostname(url) } }); }
+});
+
+const bandcampMarkdownPlugin = simpleProvider({
+  id: "markdown.embed.bandcamp",
+  provider: "bandcamp",
+  aliases: ["bandcamp"],
+  hostSuffixes: ["bandcamp.com"],
+  kind: "audio",
+  title: "Bandcamp item",
+  renderMode: "external-link",
+  metadata: (parsed) => ({ artistHost: parsed.hostname.toLowerCase() })
+});
+
+const appleMusicMarkdownPlugin = simpleProvider({
+  id: "markdown.embed.apple-music",
+  provider: "apple-music",
+  aliases: ["apple-music", "music"],
+  hosts: ["music.apple.com"],
+  kind: "audio",
+  title: "Apple Music item",
+  renderMode: "external-link"
+});
+
+const clypMarkdownPlugin = simpleProvider({ id: "markdown.embed.clyp", provider: "clyp", aliases: ["clyp"], hostSuffixes: ["clyp.it"], kind: "audio", title: "Clyp audio", renderMode: "external-link" });
+
+module.exports = {
+  appleMusicMarkdownPlugin,
+  bandcampMarkdownPlugin,
+  clypMarkdownPlugin,
+  soundcloudMarkdownPlugin,
+  spotifyMarkdownPlugin
+};

package/src/markdown/providers/cloud.cjs

@@ -0,0 +1,72 @@
+const {
+  cleanId,
+  createEmbedRecord,
+  defineMarkdownPlugin,
+  directRenderMode,
+  firstMatch,
+  hostEndsWith,
+  hostIs,
+  mediaKindFromPath,
+  normalizeUrl,
+  pathParts,
+  safeHostname,
+  simpleProvider
+} = require("../../shared/index.cjs");
+
+const googleDriveMarkdownPlugin = defineMarkdownPlugin({
+  id: "markdown.embed.google-drive",
+  provider: "google-drive",
+  aliases: ["drive", "gdrive", "google-drive", "docs", "sheets", "slides"],
+  matchUrl(url) { const host = safeHostname(url); return host === "drive.google.com" || host === "docs.google.com"; },
+  toEmbed(url, ctx = {}) {
+    const parsed = new URL(url);
+    const host = parsed.hostname.toLowerCase().replace(/^www\./, "");
+    const fileId = firstMatch([/\/file\/d\/([^/]+)/, /[?&]id=([^&]+)/], `${parsed.pathname}${parsed.search}`)?.[1];
+    const documentId = firstMatch([/\/document\/d\/([^/]+)/, /\/spreadsheets\/d\/([^/]+)/, /\/presentation\/d\/([^/]+)/], parsed.pathname)?.[1];
+    const docKind = parsed.pathname.includes("/spreadsheets/") ? "spreadsheet" : parsed.pathname.includes("/presentation/") ? "presentation" : "document";
+    const embedUrl = fileId
+      ? `https://drive.google.com/file/d/${encodeURIComponent(fileId)}/preview`
+      : documentId
+        ? `https://${host}${parsed.pathname.replace(/\/(edit|view).*$/, "/preview")}`
+        : undefined;
+    return createEmbedRecord({
+      provider: "google-drive",
+      kind: fileId ? "file" : docKind,
+      title: ctx.title || "Google Drive item",
+      url,
+      ...(embedUrl ? { embedUrl } : {}),
+      renderMode: embedUrl ? "iframe" : "external-link",
+      metadata: { fileId: fileId || null, documentId: documentId || null, docKind }
+    });
+  }
+});
+
+const googlePhotosMarkdownPlugin = defineMarkdownPlugin({
+  id: "markdown.embed.google-photos",
+  provider: "google-photos",
+  aliases: ["gphotos", "google-photos", "photos"],
+  matchUrl(url) { const host = safeHostname(url); return host === "photos.app.goo.gl" || host === "photos.google.com"; },
+  toEmbed(url, ctx = {}) { return createEmbedRecord({ provider: "google-photos", kind: "photo-album", title: ctx.title || "Google Photos album", url, renderMode: "external-link", metadata: { host: safeHostname(url) } }); }
+});
+
+const dropboxMarkdownPlugin = defineMarkdownPlugin({
+  id: "markdown.embed.dropbox",
+  provider: "dropbox",
+  aliases: ["dropbox", "dbx"],
+  matchUrl(url) { const host = safeHostname(url); return host === "dropbox.com" || host === "dl.dropboxusercontent.com"; },
+  toEmbed(url, ctx = {}) {
+    const parsed = new URL(url);
+    parsed.searchParams.delete("dl");
+    parsed.searchParams.set("raw", "1");
+    return createEmbedRecord({ provider: "dropbox", kind: mediaKindFromPath(parsed.pathname), title: ctx.title || "Dropbox file", url, externalUrl: url, embedUrl: parsed.toString(), renderMode: "file-preview", metadata: { host: safeHostname(url) } });
+  }
+});
+
+const onedriveMarkdownPlugin = simpleProvider({ id: "markdown.embed.onedrive", provider: "onedrive", aliases: ["onedrive", "1drv"], hosts: ["onedrive.live.com", "1drv.ms"], kind: "file", title: "OneDrive item", renderMode: "external-link" });
+
+module.exports = {
+  dropboxMarkdownPlugin,
+  googleDriveMarkdownPlugin,
+  googlePhotosMarkdownPlugin,
+  onedriveMarkdownPlugin
+};

package/src/markdown/providers/developer.cjs

@@ -0,0 +1,45 @@
+const {
+  cleanId,
+  createEmbedRecord,
+  defineMarkdownPlugin,
+  directRenderMode,
+  firstMatch,
+  hostEndsWith,
+  hostIs,
+  mediaKindFromPath,
+  normalizeUrl,
+  pathParts,
+  safeHostname,
+  simpleProvider
+} = require("../../shared/index.cjs");
+
+const codepenMarkdownPlugin = defineMarkdownPlugin({
+  id: "markdown.embed.codepen",
+  provider: "codepen",
+  aliases: ["codepen", "pen"],
+  matchUrl(url) { return hostIs(url, ["codepen.io"]) && pathParts(url)[1] === "pen"; },
+  toEmbed(url, ctx = {}) { const parts = pathParts(url); return createEmbedRecord({ provider: "codepen", kind: "code-demo", title: ctx.title || "CodePen", url, embedUrl: `https://codepen.io/${encodeURIComponent(parts[0])}/embed/${encodeURIComponent(parts[2])}`, renderMode: "iframe", metadata: { user: parts[0], penId: parts[2] } }); }
+});
+const jsfiddleMarkdownPlugin = defineMarkdownPlugin({
+  id: "markdown.embed.jsfiddle",
+  provider: "jsfiddle",
+  aliases: ["jsfiddle", "fiddle"],
+  matchUrl(url) { return hostIs(url, ["jsfiddle.net"]); },
+  toEmbed(url, ctx = {}) { const parsed = new URL(url); const embedPath = parsed.pathname.replace(/\/$/, "") + "/embedded/"; return createEmbedRecord({ provider: "jsfiddle", kind: "code-demo", title: ctx.title || "JSFiddle", url, embedUrl: `https://jsfiddle.net${embedPath}`, renderMode: "iframe", metadata: { path: parsed.pathname } }); }
+});
+const githubMarkdownPlugin = simpleProvider({ id: "markdown.embed.github", provider: "github", aliases: ["github", "gh"], hosts: ["github.com"], kind: (parsed) => parsed.pathname.includes("/pull/") ? "pull-request" : parsed.pathname.includes("/issues/") ? "issue" : parsed.pathname.includes("/blob/") ? "code-file" : "repository", title: "GitHub link", renderMode: "external-link" });
+const gistMarkdownPlugin = simpleProvider({ id: "markdown.embed.gist", provider: "gist", aliases: ["gist"], hosts: ["gist.github.com"], kind: "code-snippet", title: "GitHub Gist", renderMode: "external-link" });
+const pastebinMarkdownPlugin = defineMarkdownPlugin({ id: "markdown.embed.pastebin", provider: "pastebin", aliases: ["pastebin"], matchUrl(url) { return hostIs(url, ["pastebin.com"]) && pathParts(url)[0]; }, toEmbed(url, ctx = {}) { const id = pathParts(url)[0]; return createEmbedRecord({ provider: "pastebin", kind: "code-snippet", title: ctx.title || "Pastebin", url, embedUrl: `https://pastebin.com/embed_iframe/${cleanId(id)}`, renderMode: "iframe", metadata: { pasteId: id } }); } });
+const hastebinMarkdownPlugin = simpleProvider({ id: "markdown.embed.hastebin", provider: "hastebin", aliases: ["hastebin"], hostSuffixes: ["hastebin.com", "hastebin.app"], kind: "code-snippet", title: "Hastebin", renderMode: "external-link" });
+
+const wikipediaMarkdownPlugin = simpleProvider({ id: "markdown.embed.wikipedia", provider: "wikipedia", aliases: ["wikipedia", "wiki"], hostSuffixes: ["wikipedia.org", "wikimedia.org"], kind: "article", title: (parsed) => pathParts(parsed.toString()).at(-1)?.replace(/_/g, " ") || "Wikipedia article", renderMode: "external-link" });
+
+module.exports = {
+  codepenMarkdownPlugin,
+  gistMarkdownPlugin,
+  githubMarkdownPlugin,
+  hastebinMarkdownPlugin,
+  jsfiddleMarkdownPlugin,
+  pastebinMarkdownPlugin,
+  wikipediaMarkdownPlugin
+};