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

package/src/comments/reducer.cjs

@@ -0,0 +1,81 @@
+const { activity, actorName, entityId, moderatorOrBetter } = require("../shared/index.cjs");
+const { createThread, ensureThread, findComment, findThreadByScope } = require("./threads.cjs");
+
+function createThreadOperation(state, op) {
+  const duplicate = findThreadByScope(state, op.payload.scopeType, op.payload.scopeId);
+  if (duplicate) return state;
+  const thread = createThread(op, op.payload);
+  return { ...state, threads: { ...state.threads, [thread.id]: thread }, activity: activity(state, op, `${actorName(op.actor)} opened ${thread.title}`) };
+}
+
+function addCommentOperation(state, op) {
+  const ensured = ensureThread(state, op, op.payload);
+  const comment = {
+    id: entityId("comment", op),
+    threadId: ensured.thread.id,
+    parentId: op.payload.parentId || null,
+    authorId: op.actor.memberId,
+    authorName: actorName(op.actor),
+    body: op.payload.body,
+    reactions: {},
+    createdAt: op.createdAt,
+    updatedAt: op.createdAt
+  };
+  return {
+    ...ensured.state,
+    threads: { ...ensured.state.threads, [ensured.thread.id]: { ...ensured.thread, lastCommentAt: op.createdAt, resolved: false } },
+    comments: { ...ensured.state.comments, [comment.id]: comment },
+    activity: activity(ensured.state, op, `${comment.authorName} commented on ${ensured.thread.title}`)
+  };
+}
+
+function assertAuthorOrModerator(op, comment, action) {
+  if (!moderatorOrBetter(op.actor) && comment.authorId !== op.actor.memberId) throw new Error(`Only authors or moderators can ${action} comments`);
+}
+
+function editCommentOperation(state, op) {
+  const comment = findComment(state, op.payload.commentId);
+  assertAuthorOrModerator(op, comment, "edit");
+  return { ...state, comments: { ...state.comments, [comment.id]: { ...comment, body: op.payload.body, editedAt: op.createdAt, updatedAt: op.createdAt } }, activity: activity(state, op, `${actorName(op.actor)} edited a comment`) };
+}
+
+function reactToCommentOperation(state, op) {
+  const comment = findComment(state, op.payload.commentId);
+  const current = new Set(comment.reactions?.[op.payload.emoji] || []);
+  if (current.has(op.actor.memberId)) current.delete(op.actor.memberId); else current.add(op.actor.memberId);
+  return { ...state, comments: { ...state.comments, [comment.id]: { ...comment, reactions: { ...(comment.reactions || {}), [op.payload.emoji]: [...current].sort() } } } };
+}
+
+function deleteCommentOperation(state, op) {
+  const comment = findComment(state, op.payload.commentId);
+  assertAuthorOrModerator(op, comment, "delete");
+  return { ...state, comments: { ...state.comments, [comment.id]: { ...comment, body: "", deletedAt: op.createdAt, deleteReason: op.payload.reason } }, activity: activity(state, op, `${actorName(op.actor)} deleted a comment`) };
+}
+
+function resolveThreadOperation(state, op) {
+  const thread = state.threads[op.payload.threadId];
+  if (!thread || thread.deletedAt) throw new Error(`Thread ${op.payload.threadId} not found`);
+  return { ...state, threads: { ...state.threads, [thread.id]: { ...thread, resolved: op.payload.resolved, resolvedAt: op.payload.resolved ? op.createdAt : undefined, resolvedBy: op.payload.resolved ? op.actor.memberId : undefined } }, activity: activity(state, op, `${actorName(op.actor)} ${op.payload.resolved ? "resolved" : "reopened"} ${thread.title}`) };
+}
+
+async function reduceCommentsState(_ctx, state, op) {
+  switch (op.type) {
+    case "comments.thread.create": return createThreadOperation(state, op);
+    case "comments.add": return addCommentOperation(state, op);
+    case "comments.edit": return editCommentOperation(state, op);
+    case "comments.react": return reactToCommentOperation(state, op);
+    case "comments.delete": return deleteCommentOperation(state, op);
+    case "comments.resolve": return resolveThreadOperation(state, op);
+    default: return state;
+  }
+}
+
+module.exports = {
+  addCommentOperation,
+  createThreadOperation,
+  deleteCommentOperation,
+  editCommentOperation,
+  reactToCommentOperation,
+  reduceCommentsState,
+  resolveThreadOperation
+};

package/src/comments/schemas.cjs

@@ -0,0 +1,60 @@
+const { boolean, enumValue, object, optionalString, scopePayload, string } = require("../shared/index.cjs");
+
+const commentsOperationSchemaDescriptor = Object.freeze({
+  "comments.thread.create": { required: ["scopeType", "scopeId"], optional: ["title", "visibility"], authorize: { roles: ["member"] } },
+  "comments.add": { required: ["body"], optional: ["threadId", "scopeType", "scopeId", "parentId"], authorize: { roles: ["member"] } },
+  "comments.edit": { required: ["commentId", "body"], authorize: { roles: ["member"] } },
+  "comments.react": { required: ["commentId", "emoji"], authorize: { roles: ["member"] } },
+  "comments.delete": { required: ["commentId"], optional: ["reason"], authorize: { roles: ["member"] } },
+  "comments.resolve": { required: ["threadId"], optional: ["resolved"], authorize: { roles: ["moderator"] } }
+});
+
+function commentsThreadPayload(payload) {
+  const value = object(payload, "comments.thread.create payload");
+  return {
+    ...scopePayload(value),
+    title: optionalString(value.title, "title", 160),
+    visibility: value.visibility ? enumValue(value.visibility, "visibility", ["members", "moderators", "private"]) : "members"
+  };
+}
+
+function commentsAddPayload(payload) {
+  const value = object(payload, "comments.add payload");
+  const threadId = optionalString(value.threadId, "threadId", 160);
+  return {
+    threadId,
+    ...(threadId ? {} : scopePayload(value, "comments.add scope")),
+    parentId: optionalString(value.parentId, "parentId", 160),
+    body: string(value.body, "body", 4000)
+  };
+}
+
+function commentsEditPayload(payload) {
+  const value = object(payload, "comments.edit payload");
+  return { commentId: string(value.commentId, "commentId"), body: string(value.body, "body", 4000) };
+}
+
+function commentsReactPayload(payload) {
+  const value = object(payload, "comments.react payload");
+  return { commentId: string(value.commentId, "commentId"), emoji: string(value.emoji, "emoji", 32) };
+}
+
+function commentsDeletePayload(payload) {
+  const value = object(payload, "comments.delete payload");
+  return { commentId: string(value.commentId, "commentId"), reason: optionalString(value.reason, "reason", 240) };
+}
+
+function commentsResolvePayload(payload) {
+  const value = object(payload, "comments.resolve payload");
+  return { threadId: string(value.threadId, "threadId"), resolved: value.resolved === undefined ? true : boolean(value.resolved) };
+}
+
+module.exports = {
+  commentsAddPayload,
+  commentsDeletePayload,
+  commentsEditPayload,
+  commentsOperationSchemaDescriptor,
+  commentsReactPayload,
+  commentsResolvePayload,
+  commentsThreadPayload
+};

package/src/comments/state.cjs

@@ -0,0 +1,17 @@
+const { array, object, COMMENTS_PLUGIN_ID } = require("../shared/index.cjs");
+
+const commentsStateSchemaDescriptor = Object.freeze({ plugin: COMMENTS_PLUGIN_ID, shape: ["threads", "comments", "activity"] });
+
+function createInitialCommentsState() {
+  return { threads: {}, comments: {}, activity: [] };
+}
+
+function parseCommentsState(state) {
+  const value = object(state, "comments state");
+  object(value.threads, "threads");
+  object(value.comments, "comments");
+  array(value.activity, "activity");
+  return value;
+}
+
+module.exports = { commentsStateSchemaDescriptor, createInitialCommentsState, parseCommentsState };

package/src/comments/threads.cjs

@@ -0,0 +1,44 @@
+const { actorName, entityId } = require("../shared/index.cjs");
+
+function threadKey(scopeType, scopeId) {
+  return `${encodeURIComponent(scopeType)}:${encodeURIComponent(scopeId)}`;
+}
+
+function findThreadByScope(state, scopeType, scopeId) {
+  return Object.values(state.threads).find((thread) => thread.scopeType === scopeType && thread.scopeId === scopeId && !thread.deletedAt);
+}
+
+function createThread(op, payload) {
+  return {
+    id: entityId("thread", op),
+    scopeType: payload.scopeType,
+    scopeId: payload.scopeId,
+    scopeKey: threadKey(payload.scopeType, payload.scopeId),
+    title: payload.title || `${payload.scopeType} discussion`,
+    visibility: payload.visibility || "members",
+    createdBy: op.actor.memberId,
+    createdByName: actorName(op.actor),
+    createdAt: op.createdAt,
+    resolved: false
+  };
+}
+
+function ensureThread(state, op, payload) {
+  if (payload.threadId) {
+    const thread = state.threads[payload.threadId];
+    if (!thread || thread.deletedAt) throw new Error(`Thread ${payload.threadId} not found`);
+    return { state, thread };
+  }
+  const existing = findThreadByScope(state, payload.scopeType, payload.scopeId);
+  if (existing) return { state, thread: existing };
+  const thread = createThread(op, payload);
+  return { state: { ...state, threads: { ...state.threads, [thread.id]: thread } }, thread };
+}
+
+function findComment(state, commentId) {
+  const comment = state.comments[commentId];
+  if (!comment || comment.deletedAt) throw new Error(`Comment ${commentId} not found`);
+  return comment;
+}
+
+module.exports = { createThread, ensureThread, findComment, findThreadByScope, threadKey };

package/src/comments/views.cjs

@@ -0,0 +1,27 @@
+const { scopePayload } = require("../shared/index.cjs");
+
+function publicCommentsView(_ctx, state) {
+  const visibleThreads = Object.fromEntries(Object.entries(state.threads).filter(([, thread]) => !thread.deletedAt && _ctx.access.canView(thread.scopeType, thread.scopeId)));
+  const visibleThreadIds = new Set(Object.keys(visibleThreads));
+  const comments = Object.fromEntries(Object.entries(state.comments).filter(([, comment]) => !comment.deletedAt && visibleThreadIds.has(comment.threadId)));
+  return { ...state, threads: visibleThreads, comments };
+}
+
+function commentsForScope(_ctx, state, input = {}) {
+  const scoped = scopePayload(input, "commentsForScope input");
+  if (!_ctx.access.canView(scoped.scopeType, scoped.scopeId)) return { threads: [], comments: [] };
+  const threads = Object.values(state.threads).filter((thread) => thread.scopeType === scoped.scopeType && thread.scopeId === scoped.scopeId && !thread.deletedAt);
+  const threadIds = new Set(threads.map((thread) => thread.id));
+  const comments = Object.values(state.comments).filter((comment) => threadIds.has(comment.threadId) && !comment.deletedAt).sort((a, b) => a.createdAt - b.createdAt);
+  return { threads, comments };
+}
+
+function unresolvedThreads(_ctx, state) {
+  return Object.values(state.threads).filter((thread) => !thread.deletedAt && !thread.resolved && _ctx.access.canView(thread.scopeType, thread.scopeId)).sort((a, b) => (b.lastCommentAt || b.createdAt) - (a.lastCommentAt || a.createdAt));
+}
+
+function countForScope(ctx, input = {}) {
+  return commentsForScope(ctx, ctx.state, input).comments.length;
+}
+
+module.exports = { commentsForScope, countForScope, publicCommentsView, unresolvedThreads };

package/src/composer/capabilities.cjs

@@ -0,0 +1,19 @@
+const { unique, freezeArray } = require("./registry.cjs");
+
+function summarizeCapabilities(plugins) {
+  const required = [];
+  const provides = [];
+  for (const plugin of plugins) {
+    required.push(...(plugin.capabilities?.requires || []));
+    provides.push(...(plugin.capabilities?.provides || []));
+  }
+  return Object.freeze({ required: freezeArray(unique(required).sort()), provides: freezeArray(unique(provides).sort()) });
+}
+
+function appCapabilitySet({ required = ["room.state", "room.roles", "relay.route"], optional = ["relay.event-cache"], suites = [] } = {}) {
+  const allSuites = Array.isArray(suites) ? suites : [suites];
+  const suiteCapabilities = allSuites.flatMap((suite) => (suite?.capabilities?.provides || []));
+  return Object.freeze({ required: freezeArray(unique(required).sort()), optional: freezeArray(unique([...optional, ...suiteCapabilities]).sort()) });
+}
+
+module.exports = { appCapabilitySet, summarizeCapabilities };

package/src/composer/compose.cjs

@@ -0,0 +1,37 @@
+const { freezeArray } = require("./registry.cjs");
+const { getReusablePluginEntry } = require("./selection.cjs");
+
+function normalizeCompositionItem(item) {
+  if (!item) return [];
+  if (Array.isArray(item)) return item.flatMap(normalizeCompositionItem);
+  if (item.kind === "matterhorn.example-plugin-suite") return item.entries.slice();
+  if (item.entries && Array.isArray(item.entries)) return item.entries.flatMap(normalizeCompositionItem);
+  if (item.plugin) return [item];
+  if (item.id && item.version) return [{ plugin: item }];
+  if (typeof item === "string") return [getReusablePluginEntry(item)];
+  throw new Error("Composition items must be plugins, plugin entries, suites, selections, or arrays");
+}
+
+function composeHostPluginEntries(...items) {
+  const seen = new Map();
+  const composed = [];
+  for (const entry of items.flatMap(normalizeCompositionItem)) {
+    const plugin = entry.plugin;
+    if (!plugin?.id) throw new Error("Plugin entry is missing plugin.id");
+    const existing = seen.get(plugin.id);
+    if (existing) {
+      if (existing.plugin.version !== plugin.version) throw new Error(`Conflicting versions for plugin ${plugin.id}`);
+      continue;
+    }
+    const frozen = Object.freeze({ ...entry });
+    seen.set(plugin.id, frozen);
+    composed.push(frozen);
+  }
+  return freezeArray(composed);
+}
+
+function composeHostPlugins(...items) {
+  return freezeArray(composeHostPluginEntries(...items).map((entry) => entry.plugin));
+}
+
+module.exports = { composeHostPluginEntries, composeHostPlugins, normalizeCompositionItem };

package/src/composer/index.cjs

@@ -0,0 +1,15 @@
+const registry = require("./registry.cjs");
+const capabilities = require("./capabilities.cjs");
+const compose = require("./compose.cjs");
+const operations = require("./operations.cjs");
+const selection = require("./selection.cjs");
+const suite = require("./suite.cjs");
+
+module.exports = {
+  ...registry,
+  ...capabilities,
+  ...compose,
+  ...operations,
+  ...selection,
+  ...suite
+};

package/src/composer/operations.cjs

@@ -0,0 +1,42 @@
+const { manifestHash } = require("@mh-gg/base");
+const { ensureOperationIdentity } = require("@mh-gg/protocol");
+const { commentsHostPlugin } = require("./registry.cjs");
+const { getReusablePlugin } = require("./selection.cjs");
+
+function defaultActor() {
+  return {
+    memberId: "admin",
+    role: "admin",
+    displayName: "Admin",
+    deviceId: "admin"
+  };
+}
+
+function reusablePluginOperationFactory({ appPack, roomId, actor, startSeq = 1, startTime = 1000 } = {}) {
+  if (!appPack) throw new Error("appPack is required");
+  let seq = startSeq - 1;
+  return function makePluginOperation(plugin, type, payload, overrides = {}) {
+    seq += 1;
+    const opSeq = overrides.seq ?? seq;
+    const resolvedPlugin = typeof plugin === "string" ? getReusablePlugin(plugin) : plugin;
+    const opActor = overrides.actor || actor || defaultActor();
+    const createdAt = overrides.createdAt ?? (startTime + opSeq);
+    const operation = {
+      clientOperationId: overrides.id || `demo_${opSeq}`,
+      roomId: overrides.roomId || roomId,
+      appPackId: appPack.id,
+      appPackHash: manifestHash(appPack),
+      pluginId: resolvedPlugin.id || commentsHostPlugin.id,
+      type,
+      actor: opActor,
+      seq: opSeq,
+      createdAt,
+      payload,
+      hlc: overrides.hlc,
+      auth: overrides.auth || { credentialId: `cred_${opActor.memberId}`, signature: "sig" }
+    };
+    return ensureOperationIdentity(operation, { now: createdAt, nodeId: opActor.deviceId || opActor.memberId || "matterhorn-sdk" });
+  };
+}
+
+module.exports = { reusablePluginOperationFactory };

package/src/composer/registry.cjs

@@ -0,0 +1,155 @@
+const {
+  APPROVALS_PLUGIN_ID,
+  APPROVALS_PLUGIN_KEY,
+  ATTACHMENTS_PLUGIN_ID,
+  ATTACHMENTS_PLUGIN_KEY,
+  CALENDAR_PLUGIN_ID,
+  CALENDAR_PLUGIN_KEY,
+  CHECKLISTS_PLUGIN_ID,
+  CHECKLISTS_PLUGIN_KEY,
+  COMMENTS_PLUGIN_ID,
+  COMMENTS_PLUGIN_KEY,
+  CRDT_PLUGIN_ID,
+  CRDT_PLUGIN_KEY,
+  EMBEDS_PLUGIN_ID,
+  EMBEDS_PLUGIN_KEY,
+  FILES_PLUGIN_ID,
+  FILES_PLUGIN_KEY,
+  BASE_PLUGIN_VERSION,
+  BASE_PLUGINS_PACKAGE,
+  LABELS_PLUGIN_ID,
+  LABELS_PLUGIN_KEY,
+  LOCATION_PINS_PLUGIN_ID,
+  LOCATION_PINS_PLUGIN_KEY,
+  MARKDOWN_PLUGIN_ID,
+  MARKDOWN_PLUGIN_KEY,
+  MEDIA_ROOMS_PLUGIN_ID,
+  MEDIA_ROOMS_PLUGIN_KEY,
+  PRESENCE_PLUGIN_ID,
+  PRESENCE_PLUGIN_KEY,
+  REACTIONS_PLUGIN_ID,
+  REACTIONS_PLUGIN_KEY,
+  SCREEN_SHARE_PLUGIN_ID,
+  SCREEN_SHARE_PLUGIN_KEY
+} = require("../shared/constants.cjs");
+const { commentsHostPlugin } = require("../comments/index.cjs");
+const { presenceHostPlugin } = require("../presence/index.cjs");
+const { mediaRoomsHostPlugin } = require("../media-rooms/index.cjs");
+const { screenShareHostPlugin } = require("../screen-share/index.cjs");
+const { markdownHostPlugin } = require("../markdown/documents/index.cjs");
+const { embedsHostPlugin } = require("../embeds/index.cjs");
+const { attachmentsHostPlugin } = require("../attachments/index.cjs");
+const { filesHostPlugin } = require("../files/index.cjs");
+const { reactionsHostPlugin } = require("../reactions/index.cjs");
+const { labelsHostPlugin } = require("../labels/index.cjs");
+const { approvalsHostPlugin } = require("../approvals/index.cjs");
+const { checklistsHostPlugin } = require("../checklists/index.cjs");
+const { calendarHostPlugin } = require("../calendar/index.cjs");
+const { locationPinsHostPlugin } = require("../location-pins/index.cjs");
+const { crdtHostPlugin } = require("../crdt/index.cjs");
+
+const DEFAULT_PLUGIN_ORDER = Object.freeze([
+  COMMENTS_PLUGIN_KEY,
+  PRESENCE_PLUGIN_KEY,
+  MEDIA_ROOMS_PLUGIN_KEY,
+  SCREEN_SHARE_PLUGIN_KEY,
+  MARKDOWN_PLUGIN_KEY,
+  EMBEDS_PLUGIN_KEY,
+  ATTACHMENTS_PLUGIN_KEY,
+  FILES_PLUGIN_KEY,
+  REACTIONS_PLUGIN_KEY,
+  LABELS_PLUGIN_KEY,
+  APPROVALS_PLUGIN_KEY,
+  CHECKLISTS_PLUGIN_KEY,
+  CALENDAR_PLUGIN_KEY,
+  LOCATION_PINS_PLUGIN_KEY
+]);
+
+function record({ key, id, plugin, exportName, aliases }) {
+  return Object.freeze({ key, id, plugin, packageName: BASE_PLUGINS_PACKAGE, exportName, aliases: Object.freeze([key, id, ...(aliases || [])]) });
+}
+
+const PLUGIN_REGISTRY = Object.freeze({
+  [COMMENTS_PLUGIN_KEY]: record({ key: COMMENTS_PLUGIN_KEY, id: COMMENTS_PLUGIN_ID, plugin: commentsHostPlugin, exportName: "commentsHostPlugin", aliases: ["comment", "thread", "threads", "discussion", "discussions"] }),
+  [PRESENCE_PLUGIN_KEY]: record({ key: PRESENCE_PLUGIN_KEY, id: PRESENCE_PLUGIN_ID, plugin: presenceHostPlugin, exportName: "presenceHostPlugin", aliases: ["status", "online"] }),
+  [MEDIA_ROOMS_PLUGIN_KEY]: record({ key: MEDIA_ROOMS_PLUGIN_KEY, id: MEDIA_ROOMS_PLUGIN_ID, plugin: mediaRoomsHostPlugin, exportName: "mediaRoomsHostPlugin", aliases: ["media", "voice", "video", "rooms", "calls"] }),
+  [SCREEN_SHARE_PLUGIN_KEY]: record({ key: SCREEN_SHARE_PLUGIN_KEY, id: SCREEN_SHARE_PLUGIN_ID, plugin: screenShareHostPlugin, exportName: "screenShareHostPlugin", aliases: ["screenshare", "screen", "share", "presentation"] }),
+  [MARKDOWN_PLUGIN_KEY]: record({ key: MARKDOWN_PLUGIN_KEY, id: MARKDOWN_PLUGIN_ID, plugin: markdownHostPlugin, exportName: "markdownHostPlugin", aliases: ["md", "content", "richText", "rich-text"] }),
+  [EMBEDS_PLUGIN_KEY]: record({ key: EMBEDS_PLUGIN_KEY, id: EMBEDS_PLUGIN_ID, plugin: embedsHostPlugin, exportName: "embedsHostPlugin", aliases: ["embed", "links", "youtube", "spotify", "dropbox", "drive", "gdrive", "gphotos", "google-photos", "mediaLinks"] }),
+  [ATTACHMENTS_PLUGIN_KEY]: record({ key: ATTACHMENTS_PLUGIN_KEY, id: ATTACHMENTS_PLUGIN_ID, plugin: attachmentsHostPlugin, exportName: "attachmentsHostPlugin", aliases: ["attachment", "externalFiles", "cloudFiles", "cloud-files"] }),
+  [FILES_PLUGIN_KEY]: record({ key: FILES_PLUGIN_KEY, id: FILES_PLUGIN_ID, plugin: filesHostPlugin, exportName: "filesHostPlugin", aliases: ["file", "uploads", "upload", "nostrFiles", "nostr-files"] }),
+  [REACTIONS_PLUGIN_KEY]: record({ key: REACTIONS_PLUGIN_KEY, id: REACTIONS_PLUGIN_ID, plugin: reactionsHostPlugin, exportName: "reactionsHostPlugin", aliases: ["reaction", "emoji", "votes-light"] }),
+  [LABELS_PLUGIN_KEY]: record({ key: LABELS_PLUGIN_KEY, id: LABELS_PLUGIN_ID, plugin: labelsHostPlugin, exportName: "labelsHostPlugin", aliases: ["label", "tags", "tag", "taxonomy"] }),
+  [APPROVALS_PLUGIN_KEY]: record({ key: APPROVALS_PLUGIN_KEY, id: APPROVALS_PLUGIN_ID, plugin: approvalsHostPlugin, exportName: "approvalsHostPlugin", aliases: ["approval", "review", "reviews"] }),
+  [CHECKLISTS_PLUGIN_KEY]: record({ key: CHECKLISTS_PLUGIN_KEY, id: CHECKLISTS_PLUGIN_ID, plugin: checklistsHostPlugin, exportName: "checklistsHostPlugin", aliases: ["checklist", "todos", "todo", "check-items"] }),
+  [CALENDAR_PLUGIN_KEY]: record({ key: CALENDAR_PLUGIN_KEY, id: CALENDAR_PLUGIN_ID, plugin: calendarHostPlugin, exportName: "calendarHostPlugin", aliases: ["schedule", "timeline", "events"] }),
+  [LOCATION_PINS_PLUGIN_KEY]: record({ key: LOCATION_PINS_PLUGIN_KEY, id: LOCATION_PINS_PLUGIN_ID, plugin: locationPinsHostPlugin, exportName: "locationPinsHostPlugin", aliases: ["location", "map", "maps", "pin", "geo"] }),
+  [CRDT_PLUGIN_KEY]: record({ key: CRDT_PLUGIN_KEY, id: CRDT_PLUGIN_ID, plugin: crdtHostPlugin, exportName: "crdtHostPlugin", aliases: ["sharedDoc", "shared-doc", "collaborative-text"] })
+});
+
+const PRESETS = Object.freeze({
+  none: Object.freeze([]),
+  comments: Object.freeze([COMMENTS_PLUGIN_KEY]),
+  discussion: Object.freeze([COMMENTS_PLUGIN_KEY, REACTIONS_PLUGIN_KEY]),
+  presence: Object.freeze([PRESENCE_PLUGIN_KEY]),
+  media: Object.freeze([MEDIA_ROOMS_PLUGIN_KEY, SCREEN_SHARE_PLUGIN_KEY]),
+  calls: Object.freeze([MEDIA_ROOMS_PLUGIN_KEY, SCREEN_SHARE_PLUGIN_KEY]),
+  content: Object.freeze([MARKDOWN_PLUGIN_KEY, EMBEDS_PLUGIN_KEY, FILES_PLUGIN_KEY]),
+  docs: Object.freeze([MARKDOWN_PLUGIN_KEY, EMBEDS_PLUGIN_KEY, FILES_PLUGIN_KEY, COMMENTS_PLUGIN_KEY, LABELS_PLUGIN_KEY]),
+  workflow: Object.freeze([CHECKLISTS_PLUGIN_KEY, APPROVALS_PLUGIN_KEY, CALENDAR_PLUGIN_KEY, LABELS_PLUGIN_KEY]),
+  collaboration: Object.freeze([COMMENTS_PLUGIN_KEY, PRESENCE_PLUGIN_KEY]),
+  project: Object.freeze([COMMENTS_PLUGIN_KEY, PRESENCE_PLUGIN_KEY, CHECKLISTS_PLUGIN_KEY, APPROVALS_PLUGIN_KEY, LABELS_PLUGIN_KEY]),
+  community: Object.freeze([COMMENTS_PLUGIN_KEY, PRESENCE_PLUGIN_KEY, MEDIA_ROOMS_PLUGIN_KEY, SCREEN_SHARE_PLUGIN_KEY, MARKDOWN_PLUGIN_KEY, EMBEDS_PLUGIN_KEY, REACTIONS_PLUGIN_KEY]),
+  all: DEFAULT_PLUGIN_ORDER
+});
+
+function freezeArray(values) { return Object.freeze(values.slice()); }
+function unique(values) { return [...new Set(values.filter((value) => value !== undefined && value !== null))]; }
+function registryRecords() { return Object.keys(PLUGIN_REGISTRY).map((key) => PLUGIN_REGISTRY[key]); }
+
+function pluginKeyFor(value) {
+  if (!value) throw new Error("Plugin selection is required");
+  if (typeof value === "string") {
+    if (PLUGIN_REGISTRY[value]) return value;
+    if (PRESETS[value]) return PRESETS[value].slice();
+    const found = registryRecords().find((entry) => entry.aliases.includes(value));
+    if (found) return found.key;
+    throw new Error(`Unknown reusable plugin selection ${value}`);
+  }
+  const plugin = value.plugin || value;
+  if (plugin?.id) {
+    const found = registryRecords().find((entry) => entry.id === plugin.id);
+    if (found) return found.key;
+  }
+  throw new Error(`Unknown reusable plugin ${plugin?.id || typeof value}`);
+}
+
+module.exports = {
+  APPROVALS_PLUGIN_KEY,
+  ATTACHMENTS_PLUGIN_KEY,
+  CALENDAR_PLUGIN_KEY,
+  CHECKLISTS_PLUGIN_KEY,
+  COMMENTS_PLUGIN_KEY,
+  CRDT_PLUGIN_KEY,
+  DEFAULT_PLUGIN_ORDER,
+  EMBEDS_PLUGIN_KEY,
+  FILES_PLUGIN_KEY,
+  BASE_PLUGIN_VERSION,
+  LABELS_PLUGIN_KEY,
+  LOCATION_PINS_PLUGIN_KEY,
+  MARKDOWN_PLUGIN_KEY,
+  MEDIA_ROOMS_PLUGIN_KEY,
+  PLUGIN_REGISTRY,
+  PRESENCE_PLUGIN_KEY,
+  PRESETS,
+  REACTIONS_PLUGIN_KEY,
+  SCREEN_SHARE_PLUGIN_KEY,
+  commentsHostPlugin,
+  crdtHostPlugin,
+  freezeArray,
+  filesHostPlugin,
+  locationPinsHostPlugin,
+  pluginKeyFor,
+  registryRecords,
+  unique
+};

package/src/composer/selection.cjs

@@ -0,0 +1,39 @@
+const { DEFAULT_PLUGIN_ORDER, PLUGIN_REGISTRY, pluginKeyFor } = require("./registry.cjs");
+
+function normalizeSelection(selection = "all") {
+  const raw = Array.isArray(selection) ? selection : [selection];
+  const keys = [];
+  for (const item of raw) {
+    if (item === undefined || item === null || item === false) continue;
+    const normalized = pluginKeyFor(item);
+    if (Array.isArray(normalized)) keys.push(...normalized); else keys.push(normalized);
+  }
+  const requested = new Set(keys);
+  const ordered = DEFAULT_PLUGIN_ORDER.filter((key) => requested.has(key));
+  for (const key of keys) {
+    if (!ordered.includes(key)) ordered.push(key);
+  }
+  return ordered;
+}
+
+function getReusablePlugin(selection) {
+  const key = pluginKeyFor(selection);
+  if (Array.isArray(key)) throw new Error(`${selection} resolves to multiple plugins; use createCollaborationPluginSuite instead`);
+  return PLUGIN_REGISTRY[key].plugin;
+}
+
+function getReusablePluginEntry(selection, overrides = {}) {
+  const key = pluginKeyFor(selection);
+  if (Array.isArray(key)) throw new Error(`${selection} resolves to multiple plugins; use createCollaborationPluginSuite instead`);
+  const entry = PLUGIN_REGISTRY[key];
+  return Object.freeze({
+    plugin: entry.plugin,
+    packageName: overrides.packageName || entry.packageName,
+    exportName: overrides.exportName || entry.exportName,
+    source: overrides.source,
+    dependsOn: overrides.dependsOn,
+    conflictsWith: overrides.conflictsWith
+  });
+}
+
+module.exports = { getReusablePlugin, getReusablePluginEntry, normalizeSelection };

package/src/composer/suite.cjs

@@ -0,0 +1,32 @@
+const { DEFAULT_PLUGIN_ORDER, BASE_PLUGIN_VERSION, freezeArray, pluginKeyFor } = require("./registry.cjs");
+const { summarizeCapabilities } = require("./capabilities.cjs");
+const { getReusablePluginEntry, normalizeSelection } = require("./selection.cjs");
+
+function createCollaborationPluginSuite(selection = "all", options = {}) {
+  const keys = normalizeSelection(selection);
+  const entries = keys.map((key) => getReusablePluginEntry(key));
+  const plugins = entries.map((entry) => entry.plugin);
+  const capabilities = summarizeCapabilities(plugins);
+  return Object.freeze({
+    kind: "matterhorn.example-plugin-suite",
+    id: options.id || `com.matterhorn.examples.plugins.suite.${keys.length ? keys.join("-") : "none"}`,
+    version: options.version || BASE_PLUGIN_VERSION,
+    selection: freezeArray(keys),
+    entries: freezeArray(entries),
+    plugins: freezeArray(plugins),
+    pluginIds: freezeArray(plugins.map((plugin) => plugin.id)),
+    capabilities,
+    hasPlugin(pluginOrKey) {
+      const key = pluginKeyFor(pluginOrKey);
+      if (Array.isArray(key)) return key.every((item) => keys.includes(item));
+      return keys.includes(key);
+    },
+    hasCapability(capability) { return capabilities.provides.includes(capability) || capabilities.required.includes(capability); }
+  });
+}
+
+const collaborationPluginSuite = createCollaborationPluginSuite(DEFAULT_PLUGIN_ORDER);
+const reusableHostPluginEntries = collaborationPluginSuite.entries;
+const reusableHostPlugins = collaborationPluginSuite.plugins;
+
+module.exports = { collaborationPluginSuite, createCollaborationPluginSuite, reusableHostPluginEntries, reusableHostPlugins };