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

package/src/media-rooms/index.cjs

@@ -0,0 +1,244 @@
+const {
+  allow,
+  activity,
+  actorName,
+  array,
+  boolean,
+  createOperationSchemaDescriptor,
+  defineHostPlugin,
+  deny,
+  entityId,
+  object,
+  optionalString,
+  readonlyState,
+  string,
+  memberOrBetter,
+  moderatorOrBetter,
+  BASE_PLUGIN_VERSION,
+  MEDIA_ROOMS_PLUGIN_ID
+} = require("../shared/index.cjs");
+
+function parseMediaRoomsState(state) {
+  const value = object(state, "media rooms state");
+  object(value.rooms, "rooms");
+  array(value.activity, "activity");
+  return value;
+}
+function mediaRoomCreatePayload(payload) {
+  const value = object(payload, "media.room.create payload");
+  return { name: string(value.name, "name", 100), allowsVideo: value.allowsVideo !== false, group: optionalString(value.group, "group", 80), scopeType: optionalString(value.scopeType, "scopeType", 80), scopeId: optionalString(value.scopeId, "scopeId", 160), roleAccess: parseRoleAccess(value.roleAccess) };
+}
+function mediaRoomIdPayload(payload) {
+  const value = object(payload, "media room payload");
+  return { roomId: string(value.roomId, "roomId") };
+}
+function mediaRoomJoinPayload(payload) {
+  const value = object(payload, "media.room.join payload");
+  const media = value.media && typeof value.media === "object" ? value.media : {};
+  return { roomId: string(value.roomId, "roomId"), media: { audio: media.audio !== false, video: Boolean(media.video), screen: Boolean(media.screen) } };
+}
+function mediaRoomUpdatePayload(payload) {
+  const value = object(payload, "media.room.update payload");
+  return { roomId: string(value.roomId, "roomId"), locked: value.locked === undefined ? undefined : boolean(value.locked), allowsVideo: value.allowsVideo === undefined ? undefined : boolean(value.allowsVideo), spotlightMemberId: optionalString(value.spotlightMemberId, "spotlightMemberId", 120), name: optionalString(value.name, "name", 100), group: value.group === undefined ? undefined : optionalString(value.group, "group", 80), roleAccess: value.roleAccess === undefined ? undefined : parseRoleAccess(value.roleAccess) };
+}
+const mediaRoomsStateSchemaDescriptor = { plugin: MEDIA_ROOMS_PLUGIN_ID, shape: ["rooms", "activity"] };
+const roleAccessPayloadSchema = { type: "record", values: { type: "enum", values: ["editor", "readonly"] } };
+const mediaPayloadSchema = {
+  type: "object",
+  required: {},
+  optional: {
+    audio: { type: "boolean", default: true },
+    video: { type: "boolean", default: false },
+    screen: { type: "boolean", default: false }
+  },
+  additional: false
+};
+const mediaRoomsOperationSchemaDescriptor = {
+  "media.room.create": {
+    required: { name: { type: "string", max: 100 } },
+    optional: {
+      allowsVideo: { type: "boolean", default: true },
+      group: { type: "string", max: 80, nullable: true, nonEmpty: false },
+      scopeType: { type: "string", max: 80 },
+      scopeId: { type: "string", max: 160 },
+      roleAccess: roleAccessPayloadSchema
+    },
+    authorize: { roles: ["moderator"] }
+  },
+  "media.room.join": { required: { roomId: { type: "string", max: 200 } }, optional: { media: mediaPayloadSchema }, authorize: { roles: ["member"] } },
+  "media.room.leave": { required: { roomId: { type: "string", max: 200 } }, authorize: { roles: ["member"] } },
+  "media.room.update": {
+    required: { roomId: { type: "string", max: 200 } },
+    optional: { locked: { type: "boolean" }, allowsVideo: { type: "boolean" }, spotlightMemberId: { type: "string", max: 120 }, name: { type: "string", max: 100 }, group: { type: "string", max: 80, nullable: true, nonEmpty: false }, roleAccess: roleAccessPayloadSchema },
+    authorize: { roles: ["moderator"] }
+  },
+  "media.room.archive": { required: { roomId: { type: "string", max: 200 } }, authorize: { roles: ["moderator"] } }
+};
+function mediaRoomParticipantCount(room) { return Object.keys(room.participants || {}).length; }
+
+function normalizeAccessLevel(value) {
+  if (value === "editor" || value === "edit" || value === "member") return "editor";
+  if (value === "readonly" || value === "read-only" || value === "read" || value === "viewer" || value === "view") return "readonly";
+  return undefined;
+}
+
+function parseRoleAccess(value) {
+  if (value === undefined || value === null) return {};
+  const input = object(value, "roleAccess");
+  const access = {};
+  for (const [roleId, level] of Object.entries(input)) {
+    const cleanRoleId = optionalString(roleId, "roleAccess role", 80);
+    const cleanLevel = normalizeAccessLevel(level);
+    if (cleanRoleId && cleanLevel) access[cleanRoleId] = cleanLevel;
+  }
+  return access;
+}
+
+function actorRoleTags(ctx, actor = {}) {
+  const tags = new Set([actor.role].filter(Boolean));
+  for (const pluginState of Object.values(ctx.roomState?.plugins || {})) {
+    const assignment = pluginState?.memberRoles?.[actor.memberId];
+    if (!assignment || typeof assignment !== "object") continue;
+    if (typeof assignment.roleId === "string") tags.add(assignment.roleId);
+    if (Array.isArray(assignment.roleIds)) {
+      for (const roleId of assignment.roleIds) if (typeof roleId === "string" && roleId) tags.add(roleId);
+    }
+  }
+  return tags;
+}
+
+function roomAccessForActor(ctx, room, actor = {}) {
+  if (moderatorOrBetter(actor)) return "editor";
+  const access = parseRoleAccess(room.roleAccess || {});
+  const entries = Object.entries(access);
+  if (entries.length === 0) return "editor";
+  const tags = actorRoleTags(ctx, actor);
+  let level = "hidden";
+  for (const [roleId, roleLevel] of entries) {
+    if (!tags.has(roleId)) continue;
+    if (roleLevel === "editor") return "editor";
+    if (roleLevel === "readonly") level = "readonly";
+  }
+  return level;
+}
+
+function canViewRoom(ctx, room, actor) {
+  return roomAccessForActor(ctx, room, actor) !== "hidden";
+}
+
+function canJoinRoom(ctx, room, actor) {
+  return roomAccessForActor(ctx, room, actor) === "editor";
+}
+
+function configuredRoomId(value, index) {
+  if (typeof value === "string" && /^[A-Za-z0-9_-]{1,80}$/.test(value)) return value;
+  return `default_media_room_${index + 1}`;
+}
+
+function configuredString(value, fallback, max) {
+  return typeof value === "string" && value.trim() ? value.trim().slice(0, max) : fallback;
+}
+
+function resolveRoomValue(value, ctx) {
+  return value === "$room.id" ? ctx.room.id : value;
+}
+
+function defaultRoomsFromConfig(ctx) {
+  const defaults = Array.isArray(ctx.plugin.config?.defaultRooms) ? ctx.plugin.config.defaultRooms : [];
+  const rooms = {};
+  defaults.forEach((item, index) => {
+    if (!item || typeof item !== "object") return;
+    const id = configuredRoomId(item.id, index);
+    rooms[id] = {
+      id,
+      name: configuredString(item.name, "Event room", 100),
+      group: optionalString(item.group, "group", 80),
+      allowsVideo: item.allowsVideo !== false,
+      scopeType: configuredString(resolveRoomValue(item.scopeType, ctx), undefined, 80),
+      scopeId: configuredString(resolveRoomValue(item.scopeId, ctx), undefined, 160),
+      roleAccess: parseRoleAccess(item.roleAccess),
+      createdBy: "system",
+      createdAt: ctx.now,
+      locked: false,
+      participants: {}
+    };
+  });
+  return rooms;
+}
+
+const mediaRoomsHostPlugin = defineHostPlugin({
+  id: MEDIA_ROOMS_PLUGIN_ID,
+  version: BASE_PLUGIN_VERSION,
+  meta: { name: "Reusable Voice And Video Rooms" },
+  capabilities: { requires: ["room.state", "room.roles"], provides: ["media.voice", "media.video", "media.rooms"] },
+  stateSchemaDescriptor: mediaRoomsStateSchemaDescriptor,
+  operationSchemaDescriptor: createOperationSchemaDescriptor(MEDIA_ROOMS_PLUGIN_ID, BASE_PLUGIN_VERSION, mediaRoomsOperationSchemaDescriptor),
+  schemas: {
+    state: { parse: parseMediaRoomsState },
+    operations: {
+      "media.room.create": { parse: mediaRoomCreatePayload },
+      "media.room.join": { parse: mediaRoomJoinPayload },
+      "media.room.leave": { parse: mediaRoomIdPayload },
+      "media.room.update": { parse: mediaRoomUpdatePayload },
+      "media.room.archive": { parse: mediaRoomIdPayload }
+    },
+    publicView: { parse: readonlyState },
+    queries: { roomDirectory: { parse: readonlyState } }
+  },
+  async createInitialState(ctx) { return { rooms: defaultRoomsFromConfig(ctx), activity: [] }; },
+  authorize(_ctx, op) {
+    if (["media.room.join", "media.room.leave"].includes(op.type)) return memberOrBetter(op.actor) ? allow() : deny("Members only");
+    if (["media.room.create", "media.room.update", "media.room.archive"].includes(op.type)) return moderatorOrBetter(op.actor) ? allow() : deny("Moderators only");
+    return deny("Unsupported media operation");
+  },
+  async reduce(_ctx, state, op) {
+    if (op.type === "media.room.create") {
+      const room = { id: entityId("media_room", op), name: op.payload.name, group: op.payload.group, allowsVideo: op.payload.allowsVideo !== false, scopeType: op.payload.scopeType, scopeId: op.payload.scopeId, roleAccess: op.payload.roleAccess || {}, createdBy: op.actor.memberId, createdAt: op.createdAt, locked: false, participants: {} };
+      return { ...state, rooms: { ...state.rooms, [room.id]: room }, activity: activity(state, op, `${actorName(op.actor)} created ${room.name}`) };
+    }
+    const room = state.rooms[op.payload.roomId];
+    if (!room || room.archivedAt) throw new Error(`Media room ${op.payload.roomId} not found`);
+    if (op.type === "media.room.join") {
+      if (!canViewRoom(_ctx, room, op.actor)) throw new Error("Media room is not available for this role");
+      if (!canJoinRoom(_ctx, room, op.actor)) throw new Error("Media room is read-only for this role");
+      if (room.locked && !moderatorOrBetter(op.actor)) throw new Error("Media room is locked");
+      const media = { ...op.payload.media, video: Boolean(room.allowsVideo && op.payload.media?.video) };
+      const participant = { memberId: op.actor.memberId, name: actorName(op.actor), media, joinedAt: op.createdAt };
+      return { ...state, rooms: { ...state.rooms, [room.id]: { ...room, participants: { ...room.participants, [op.actor.memberId]: participant } } }, activity: activity(state, op, `${participant.name} joined ${room.name}`) };
+    }
+    if (op.type === "media.room.leave") {
+      const participants = { ...room.participants };
+      delete participants[op.actor.memberId];
+      return { ...state, rooms: { ...state.rooms, [room.id]: { ...room, participants } }, activity: activity(state, op, `${actorName(op.actor)} left ${room.name}`) };
+    }
+    if (op.type === "media.room.update") {
+      const updated = { ...room };
+      if (op.payload.locked !== undefined) updated.locked = op.payload.locked;
+      if (op.payload.allowsVideo !== undefined) updated.allowsVideo = op.payload.allowsVideo;
+      if (op.payload.spotlightMemberId !== undefined) updated.spotlightMemberId = op.payload.spotlightMemberId;
+      if (op.payload.name !== undefined) updated.name = op.payload.name;
+      if (op.payload.group !== undefined) updated.group = op.payload.group;
+      if (op.payload.roleAccess !== undefined) updated.roleAccess = op.payload.roleAccess;
+      return { ...state, rooms: { ...state.rooms, [room.id]: updated }, activity: activity(state, op, `${actorName(op.actor)} updated ${updated.name}`) };
+    }
+    if (op.type === "media.room.archive") {
+      return { ...state, rooms: { ...state.rooms, [room.id]: { ...room, archivedAt: op.createdAt, participants: {} } }, activity: activity(state, op, `${actorName(op.actor)} archived ${room.name}`) };
+    }
+    return state;
+  },
+  getPublicView(ctx, state, actor) {
+    return { rooms: Object.values(state.rooms).filter((room) => !room.archivedAt && canViewRoom(ctx, room, actor)).map((room) => ({ ...room, participantCount: mediaRoomParticipantCount(room) })) };
+  },
+  queries: {
+    roomDirectory(ctx, state, _input, actor) {
+      return Object.values(state.rooms).filter((room) => !room.archivedAt && canViewRoom(ctx, room, actor)).map((room) => ({ ...room, participantCount: mediaRoomParticipantCount(room) })).sort((a, b) => a.name.localeCompare(b.name));
+    }
+  }
+});
+
+module.exports = {
+  MEDIA_ROOMS_PLUGIN_ID,
+  mediaRoomsHostPlugin,
+  mediaRoomsOperationSchemaDescriptor,
+  mediaRoomsStateSchemaDescriptor
+};

package/src/presence/index.cjs

@@ -0,0 +1,193 @@
+const {
+  allow,
+  activity,
+  actorName,
+  array,
+  clone,
+  createOperationSchemaDescriptor,
+  defineHostPlugin,
+  deny,
+  enumValue,
+  number,
+  object,
+  readonlyState,
+  memberOrBetter,
+  moderatorOrBetter,
+  BASE_PLUGIN_VERSION,
+  PRESENCE_PLUGIN_ID,
+  PRESENCE_STATUSES
+} = require("../shared/index.cjs");
+
+const MAX_PRESENCE_MEMBERS = 500;
+const MAX_PRESENCE_ACTIVITY = 250;
+const PRESENCE_STALE_AFTER_MS = 45_000;
+const RESERVED_MEMBER_IDS = new Set(["__proto__", "prototype", "constructor"]);
+
+function presenceText(value, name, max, required = false) {
+  if (value === undefined || value === null || value === "") {
+    if (required) throw new Error(`${name} must be a non-empty string`);
+    return null;
+  }
+  if (typeof value !== "string") throw new Error(`${name} must be a string`);
+  const trimmed = value.replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim();
+  if (!trimmed) {
+    if (required) throw new Error(`${name} must be a non-empty string`);
+    return null;
+  }
+  if (trimmed.length > max) throw new Error(`${name} is too long`);
+  return trimmed;
+}
+
+function presenceMemberId(value, name) {
+  const memberId = presenceText(value, name, 120, true);
+  if (RESERVED_MEMBER_IDS.has(memberId)) throw new Error(`${name} is reserved`);
+  return memberId;
+}
+
+function parsePresenceMember(key, member) {
+  const value = object(member, `members.${key}`);
+  const memberId = presenceMemberId(value.memberId ?? key, `members.${key}.memberId`);
+  if (memberId !== key) throw new Error(`members.${key}.memberId must match its key`);
+  const updatedAt = number(value.updatedAt, `members.${key}.updatedAt`);
+  const parsed = {
+    memberId,
+    name: presenceText(value.name, `members.${key}.name`, 80) || memberId,
+    status: enumValue(value.status, `members.${key}.status`, PRESENCE_STATUSES),
+    activity: presenceText(value.activity, `members.${key}.activity`, 160),
+    location: presenceText(value.location, `members.${key}.location`, 120),
+    updatedAt
+  };
+  if (value.lastPingAt !== undefined) parsed.lastPingAt = number(value.lastPingAt, `members.${key}.lastPingAt`);
+  return parsed;
+}
+
+function parsePresenceState(state) {
+  const value = object(state, "presence state");
+  const entries = Object.entries(object(value.members, "members"));
+  if (entries.length > MAX_PRESENCE_MEMBERS) throw new Error(`members must include ${MAX_PRESENCE_MEMBERS} or fewer entries`);
+  const members = {};
+  for (const [key, member] of entries) {
+    const memberId = presenceMemberId(key, `members.${key}`);
+    members[memberId] = parsePresenceMember(memberId, member);
+  }
+  return { members, activity: array(value.activity, "activity").slice(-MAX_PRESENCE_ACTIVITY) };
+}
+function presenceUpdatePayload(payload) {
+  const value = object(payload, "presence.update payload");
+  return {
+    status: enumValue(value.status, "status", PRESENCE_STATUSES),
+    activity: presenceText(value.activity, "activity", 160),
+    location: presenceText(value.location, "location", 120)
+  };
+}
+function presenceClearPayload(payload) {
+  const value = object(payload || {}, "presence.clear payload");
+  return { memberId: value.memberId === undefined || value.memberId === null || value.memberId === "" ? null : presenceMemberId(value.memberId, "memberId") };
+}
+function presencePingPayload(payload) {
+  const value = object(payload || {}, "presence.ping payload");
+  return { status: value.status === undefined ? null : enumValue(value.status, "status", PRESENCE_STATUSES) };
+}
+function presenceActorOperation(op, memberId) {
+  return { ...op, actor: { ...op.actor, memberId } };
+}
+function presenceNow(ctx) {
+  const value = Number(ctx?.now);
+  return Number.isFinite(value) ? value : Date.now();
+}
+function canSeeInvisible(actor, memberId) {
+  return actor?.memberId === memberId || moderatorOrBetter(actor);
+}
+function effectivePresence(member, actor, now) {
+  const pingAt = Number(member.lastPingAt);
+  const stale = member.status !== "offline" && Number.isFinite(pingAt) && now - pingAt > PRESENCE_STALE_AFTER_MS;
+  const status = stale ? "offline" : member.status;
+  if (status === "invisible" && !canSeeInvisible(actor, member.memberId)) return undefined;
+  return { ...member, status, declaredStatus: member.status, stale, visible: status !== "offline" && status !== "invisible" };
+}
+function projectedPresenceMembers(state, actor, now) {
+  const members = {};
+  for (const member of Object.values(parsePresenceState(state).members)) {
+    const projected = effectivePresence(member, actor, now);
+    if (projected) members[projected.memberId] = projected;
+  }
+  return members;
+}
+const presenceStateSchemaDescriptor = { plugin: PRESENCE_PLUGIN_ID, shape: ["members", "activity"] };
+const presenceOperationSchemaDescriptor = {
+  "presence.update": { required: ["status"], optional: ["activity", "location"], authorize: { roles: ["member"] } },
+  "presence.ping": { optional: ["status"], authorize: { roles: ["member"] } },
+  "presence.clear": { optional: ["memberId"], authorize: { roles: ["member"] } }
+};
+const presenceHostPlugin = defineHostPlugin({
+  id: PRESENCE_PLUGIN_ID,
+  version: BASE_PLUGIN_VERSION,
+  meta: { name: "Reusable Presence" },
+  capabilities: { requires: ["room.state", "room.roles"], provides: ["presence.status", "presence.activity"] },
+  stateSchemaDescriptor: presenceStateSchemaDescriptor,
+  operationSchemaDescriptor: createOperationSchemaDescriptor(PRESENCE_PLUGIN_ID, BASE_PLUGIN_VERSION, presenceOperationSchemaDescriptor),
+  schemas: {
+    state: { parse: parsePresenceState },
+    operations: { "presence.update": { parse: presenceUpdatePayload }, "presence.ping": { parse: presencePingPayload }, "presence.clear": { parse: presenceClearPayload } },
+    publicView: { parse: readonlyState },
+    queries: { onlineMembers: { parse: readonlyState } }
+  },
+  async createInitialState() { return { members: {}, activity: [] }; },
+  authorize(_ctx, op) {
+    if (op.type === "presence.update" || op.type === "presence.ping") return memberOrBetter(op.actor) ? allow() : deny("Members only");
+    if (op.type === "presence.clear") {
+      const actorMemberId = presenceMemberId(op.actor.memberId, "actor.memberId");
+      return (moderatorOrBetter(op.actor) || !op.payload.memberId || op.payload.memberId === actorMemberId) ? allow() : deny("Can only clear your own presence");
+    }
+    return deny("Unsupported presence operation");
+  },
+  async reduce(_ctx, state, op) {
+    if (op.type === "presence.update") {
+      const memberId = presenceMemberId(op.actor.memberId, "actor.memberId");
+      const operation = presenceActorOperation(op, memberId);
+      const presence = { memberId, name: actorName(operation.actor), status: op.payload.status, activity: op.payload.activity, location: op.payload.location, updatedAt: op.createdAt };
+      return { ...state, members: { ...state.members, [memberId]: presence }, activity: activity(state, operation, `${presence.name} is ${presence.status}`) };
+    }
+    if (op.type === "presence.ping") {
+      const memberId = presenceMemberId(op.actor.memberId, "actor.memberId");
+      const existing = state.members[memberId];
+      const status = op.payload.status || existing?.status || "online";
+      const presence = {
+        memberId,
+        name: actorName(op.actor),
+        status,
+        activity: existing?.activity || null,
+        location: existing?.location || null,
+        updatedAt: existing && status === existing.status ? existing.updatedAt : op.createdAt,
+        lastPingAt: op.createdAt
+      };
+      return { ...state, members: { ...state.members, [memberId]: presence } };
+    }
+    if (op.type === "presence.clear") {
+      const actorMemberId = presenceMemberId(op.actor.memberId, "actor.memberId");
+      const memberId = op.payload.memberId || actorMemberId;
+      const operation = presenceActorOperation(op, actorMemberId);
+      const members = { ...state.members };
+      delete members[memberId];
+      return { ...state, members, activity: activity(state, operation, `${actorName(operation.actor)} cleared presence for ${memberId}`) };
+    }
+    return state;
+  },
+  getPublicView(ctx, state, actor = ctx?.actor) {
+    const members = projectedPresenceMembers(state, actor, presenceNow(ctx));
+    return { members, onlineCount: Object.values(members).filter((member) => member.visible).length };
+  },
+  queries: {
+    onlineMembers(ctx, state, _input, actor = ctx?.actor) {
+      return Object.values(projectedPresenceMembers(state, actor, presenceNow(ctx))).filter((member) => member.visible).sort((a, b) => a.name.localeCompare(b.name));
+    }
+  }
+});
+
+module.exports = {
+  PRESENCE_PLUGIN_ID,
+  PRESENCE_STATUSES,
+  presenceHostPlugin,
+  presenceOperationSchemaDescriptor,
+  presenceStateSchemaDescriptor
+};

package/src/reactions/index.cjs

@@ -0,0 +1,47 @@
+const { REACTIONS_PLUGIN_ID, REACTIONS_PLUGIN_KEY } = require("../shared/constants.cjs");
+const {
+  allow,
+  activity,
+  actorName,
+  array,
+  createOperationSchemaDescriptor,
+  defineHostPlugin,
+  deny,
+  entityId,
+  memberOrBetter,
+  moderatorOrBetter,
+  object,
+  readonlyState,
+  scopeKey,
+  scopePayload,
+  string,
+  BASE_PLUGIN_VERSION
+} = require("../shared/index.cjs");
+
+const reactionsHostPlugin = defineHostPlugin({
+  id: REACTIONS_PLUGIN_ID,
+  version: BASE_PLUGIN_VERSION,
+  meta: { name: "Reusable Scoped Reactions" },
+  capabilities: { requires: ["room.state", "room.roles"], provides: ["reactions.scoped", "reactions.emoji"] },
+  stateSchemaDescriptor: { plugin: REACTIONS_PLUGIN_ID, shape: ["reactions", "activity"] },
+  operationSchemaDescriptor: createOperationSchemaDescriptor(REACTIONS_PLUGIN_ID, BASE_PLUGIN_VERSION, { "reaction.toggle": { required: ["scopeType", "scopeId", "emoji"], authorize: { roles: ["member"] } } }),
+  schemas: {
+    state: { parse(value) { const state = object(value, "reactions state"); object(state.reactions, "reactions"); array(state.activity, "activity"); return state; } },
+    operations: { "reaction.toggle": { parse(payload) { const value = object(payload, "reaction.toggle payload"); return { ...scopePayload(value), emoji: string(value.emoji, "emoji", 32) }; } } },
+    publicView: { parse: readonlyState },
+    queries: { reactionsForScope: { parse: readonlyState } }
+  },
+  async createInitialState() { return { reactions: {}, activity: [] }; },
+  authorize(_ctx, op) { return op.type === "reaction.toggle" ? (memberOrBetter(op.actor) ? allow() : deny("Members only")) : deny("Unsupported reaction operation"); },
+  async reduce(_ctx, state, op) {
+    const key = scopeKey(op.payload.scopeType, op.payload.scopeId);
+    const scoped = state.reactions[key] || { scopeType: op.payload.scopeType, scopeId: op.payload.scopeId, reactions: {} };
+    const members = new Set(scoped.reactions[op.payload.emoji] || []);
+    if (members.has(op.actor.memberId)) members.delete(op.actor.memberId); else members.add(op.actor.memberId);
+    return { ...state, reactions: { ...state.reactions, [key]: { ...scoped, reactions: { ...scoped.reactions, [op.payload.emoji]: [...members].sort() }, updatedAt: op.createdAt } } };
+  },
+  getPublicView(_ctx, state) { return state; },
+  queries: { reactionsForScope(_ctx, state, input = {}) { const scoped = scopePayload(input, "reactionsForScope input"); return state.reactions[scopeKey(scoped.scopeType, scoped.scopeId)] || { ...scoped, reactions: {} }; } }
+});
+
+module.exports = { REACTIONS_PLUGIN_ID, REACTIONS_PLUGIN_KEY, reactionsHostPlugin };

package/src/screen-share/index.cjs

@@ -0,0 +1,84 @@
+const {
+  allow,
+  activity,
+  actorName,
+  array,
+  createOperationSchemaDescriptor,
+  defineHostPlugin,
+  deny,
+  entityId,
+  object,
+  optionalString,
+  readonlyState,
+  string,
+  memberOrBetter,
+  moderatorOrBetter,
+  BASE_PLUGIN_VERSION,
+  SCREEN_SHARE_PLUGIN_ID
+} = require("../shared/index.cjs");
+
+function parseScreenShareState(state) {
+  const value = object(state, "screen share state");
+  object(value.shares, "shares");
+  array(value.activity, "activity");
+  return value;
+}
+function screenShareStartPayload(payload) {
+  const value = object(payload, "screenshare.start payload");
+  return { scopeType: string(value.scopeType, "scopeType", 80), scopeId: string(value.scopeId, "scopeId", 160), roomId: optionalString(value.roomId, "roomId", 160), title: optionalString(value.title, "title", 160) };
+}
+function screenShareStopPayload(payload) {
+  const value = object(payload, "screenshare.stop payload");
+  return { shareId: string(value.shareId, "shareId") };
+}
+const screenShareStateSchemaDescriptor = { plugin: SCREEN_SHARE_PLUGIN_ID, shape: ["shares", "activity"] };
+const screenShareOperationSchemaDescriptor = {
+  "screenshare.start": { required: ["scopeType", "scopeId"], optional: ["roomId", "title"], authorize: { roles: ["member"] } },
+  "screenshare.stop": { required: ["shareId"], authorize: { roles: ["member"] } }
+};
+const screenShareHostPlugin = defineHostPlugin({
+  id: SCREEN_SHARE_PLUGIN_ID,
+  version: BASE_PLUGIN_VERSION,
+  meta: { name: "Reusable Screen Share Sessions" },
+  capabilities: { requires: ["room.state", "room.roles"], provides: ["media.screen-share", "media.presentation"] },
+  stateSchemaDescriptor: screenShareStateSchemaDescriptor,
+  operationSchemaDescriptor: createOperationSchemaDescriptor(SCREEN_SHARE_PLUGIN_ID, BASE_PLUGIN_VERSION, screenShareOperationSchemaDescriptor),
+  schemas: {
+    state: { parse: parseScreenShareState },
+    operations: { "screenshare.start": { parse: screenShareStartPayload }, "screenshare.stop": { parse: screenShareStopPayload } },
+    publicView: { parse: readonlyState },
+    queries: { activeShares: { parse: readonlyState } }
+  },
+  async createInitialState() { return { shares: {}, activity: [] }; },
+  authorize(_ctx, op) {
+    if (op.type === "screenshare.start") return memberOrBetter(op.actor) ? allow() : deny("Members only");
+    if (op.type === "screenshare.stop") return memberOrBetter(op.actor) ? allow() : deny("Members only");
+    return deny("Unsupported screen share operation");
+  },
+  async reduce(_ctx, state, op) {
+    if (op.type === "screenshare.start") {
+      const share = { id: entityId("share", op), scopeType: op.payload.scopeType, scopeId: op.payload.scopeId, roomId: op.payload.roomId, title: op.payload.title || "Screen share", presenterId: op.actor.memberId, presenterName: actorName(op.actor), startedAt: op.createdAt };
+      return { ...state, shares: { ...state.shares, [share.id]: share }, activity: activity(state, op, `${share.presenterName} started ${share.title}`) };
+    }
+    if (op.type === "screenshare.stop") {
+      const share = state.shares[op.payload.shareId];
+      if (!share || share.stoppedAt) throw new Error(`Screen share ${op.payload.shareId} not found`);
+      if (!moderatorOrBetter(op.actor) && share.presenterId !== op.actor.memberId) throw new Error("Only presenter or moderators can stop a screen share");
+      return { ...state, shares: { ...state.shares, [share.id]: { ...share, stoppedAt: op.createdAt, stoppedBy: op.actor.memberId } }, activity: activity(state, op, `${actorName(op.actor)} stopped ${share.title}`) };
+    }
+    return state;
+  },
+  getPublicView(_ctx, state) { return { shares: Object.values(state.shares).filter((share) => !share.stoppedAt) }; },
+  queries: {
+    activeShares(_ctx, state, input = {}) {
+      return Object.values(state.shares).filter((share) => !share.stoppedAt && (!input.scopeType || share.scopeType === input.scopeType) && (!input.scopeId || share.scopeId === input.scopeId));
+    }
+  }
+});
+
+module.exports = {
+  SCREEN_SHARE_PLUGIN_ID,
+  screenShareHostPlugin,
+  screenShareOperationSchemaDescriptor,
+  screenShareStateSchemaDescriptor
+};

package/src/shared/constants.cjs

@@ -0,0 +1,87 @@
+const BASE_PLUGINS_PACKAGE = "@mh-gg/base-plugins";
+const BASE_PLUGIN_VERSION = "1.0.0";
+
+const COMMENTS_PLUGIN_ID = "com.matterhorn.examples.plugins.comments";
+const PRESENCE_PLUGIN_ID = "com.matterhorn.examples.plugins.presence";
+const MEDIA_ROOMS_PLUGIN_ID = "com.matterhorn.examples.plugins.media-rooms";
+const SCREEN_SHARE_PLUGIN_ID = "com.matterhorn.examples.plugins.screen-share";
+const MARKDOWN_PLUGIN_ID = "com.matterhorn.examples.plugins.markdown";
+const EMBEDS_PLUGIN_ID = "com.matterhorn.examples.plugins.embeds";
+const ATTACHMENTS_PLUGIN_ID = "com.matterhorn.examples.plugins.attachments";
+const FILES_PLUGIN_ID = "com.matterhorn.examples.plugins.files";
+const REACTIONS_PLUGIN_ID = "com.matterhorn.examples.plugins.reactions";
+const LABELS_PLUGIN_ID = "com.matterhorn.examples.plugins.labels";
+const APPROVALS_PLUGIN_ID = "com.matterhorn.examples.plugins.approvals";
+const CHECKLISTS_PLUGIN_ID = "com.matterhorn.examples.plugins.checklists";
+const CALENDAR_PLUGIN_ID = "com.matterhorn.examples.plugins.calendar";
+const LOCATION_PINS_PLUGIN_ID = "com.matterhorn.examples.plugins.location-pins";
+const CRDT_PLUGIN_ID = "com.matterhorn.examples.plugins.crdt";
+
+const COMMENTS_PLUGIN_KEY = "comments";
+const PRESENCE_PLUGIN_KEY = "presence";
+const MEDIA_ROOMS_PLUGIN_KEY = "mediaRooms";
+const SCREEN_SHARE_PLUGIN_KEY = "screenShare";
+const MARKDOWN_PLUGIN_KEY = "markdown";
+const EMBEDS_PLUGIN_KEY = "embeds";
+const ATTACHMENTS_PLUGIN_KEY = "attachments";
+const FILES_PLUGIN_KEY = "files";
+const REACTIONS_PLUGIN_KEY = "reactions";
+const LABELS_PLUGIN_KEY = "labels";
+const APPROVALS_PLUGIN_KEY = "approvals";
+const CHECKLISTS_PLUGIN_KEY = "checklists";
+const CALENDAR_PLUGIN_KEY = "calendar";
+const LOCATION_PINS_PLUGIN_KEY = "locationPins";
+const CRDT_PLUGIN_KEY = "crdt";
+
+const PRESENCE_STATUSES = Object.freeze(["online", "away", "busy", "invisible", "offline"]);
+
+const MAX_MARKDOWN_BYTES = 64 * 1024;
+const MAX_EMBED_URL_BYTES = 4096;
+const MAX_ATTACHMENTS = 250;
+const MAX_FILES = 100;
+const MAX_FILE_EVENT_BYTES = 2 * 1024 * 1024;
+const MAX_CRDT_EVENT_BYTES = 256 * 1024;
+const MAX_CRDT_UPDATES_PER_DOCUMENT = 5000;
+
+module.exports = {
+  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,
+  MAX_ATTACHMENTS,
+  MAX_FILE_EVENT_BYTES,
+  MAX_FILES,
+  MAX_CRDT_EVENT_BYTES,
+  MAX_CRDT_UPDATES_PER_DOCUMENT,
+  MAX_EMBED_URL_BYTES,
+  MAX_MARKDOWN_BYTES,
+  MEDIA_ROOMS_PLUGIN_ID,
+  MEDIA_ROOMS_PLUGIN_KEY,
+  PRESENCE_PLUGIN_ID,
+  PRESENCE_PLUGIN_KEY,
+  PRESENCE_STATUSES,
+  REACTIONS_PLUGIN_ID,
+  REACTIONS_PLUGIN_KEY,
+  SCREEN_SHARE_PLUGIN_ID,
+  SCREEN_SHARE_PLUGIN_KEY
+};