@mh-gg/schema 0.1.1-alpha.20260613T085325975Z

package/src/types/pluginEntities.cjs

@@ -0,0 +1,83 @@
+const { builtinMicroPluginRegistry } = require('../registry.cjs');
+const { coreStateFields, hasCoreDirectMessages, hasCoreScopedAccess } = require('./coreFeatures.cjs');
+const { collectScopeTypes, pluginKeys, scopeTypeUnion, standardPluginEntityTypes } = require('./standardPluginEntityTypes.cjs');
+
+function pluginStateShape(plugin, registry = builtinMicroPluginRegistry) {
+  try {
+    const descriptor = registry.get(plugin.key || plugin.id).schema.schemas.state;
+    if (Array.isArray(descriptor.shape)) return descriptor.shape;
+    if (descriptor.state?.initial) return Object.keys(descriptor.state.initial);
+    if (descriptor.state && typeof descriptor.state === 'object' && !Array.isArray(descriptor.state)) return Object.keys(descriptor.state);
+  } catch {
+    // Unknown registries are allowed in schema files; keep generation best-effort.
+  }
+  return [];
+}
+
+function typeForPluginField(pluginRef, field) {
+  const key = pluginRef.key || '';
+  if (field === 'activity') return 'Activity[]';
+  if (key === 'mediaRooms' && field === 'rooms') return 'Record<RoomId, MediaRoom>';
+  if (key === 'presence' && field === 'members') return 'Record<MemberId, PresenceMember>';
+  if (key === 'comments' && field === 'threads') return 'Record<ThreadId, CommentThread>';
+  if (key === 'comments' && field === 'comments') return 'Record<CommentId, Comment>';
+  if (key === 'markdown' && field === 'documents') return 'Record<string, MarkdownDocument>';
+  if (key === 'embeds' && field === 'embeds') return 'Record<EmbedId, Embed>';
+  if (key === 'files' && field === 'files') return 'Record<string, FileRecord>';
+  if (key === 'reactions' && field === 'reactions') return 'Record<string, ScopedReaction>';
+  if (key === 'screenShare' && field === 'shares') return 'Record<ShareId, ScreenShare>';
+  if (key === 'attachments' && field === 'attachments') return 'Record<string, Attachment>';
+  if (key === 'labels' && field === 'labels') return 'Record<string, Label>';
+  if (key === 'labels' && field === 'assignments') return 'Record<string, string[]>';
+  if (key === 'approvals' && field === 'requests') return 'Record<string, ApprovalRequest>';
+  if (key === 'checklists' && field === 'checklists') return 'Record<string, Checklist>';
+  if (key === 'calendar' && field === 'events') return 'Record<string, CalendarEvent>';
+  if (key === 'locationPins' && (field === 'pins' || field === 'locations')) return 'Record<string, LocationPin>';
+  if (key === 'git' && field === 'version') return 'number';
+  if (key === 'git' && field === 'repos') return 'Record<string, GitRepo>';
+  return 'unknown';
+}
+
+function flatStateField(pluginRef, field) {
+  const key = pluginRef.key || '';
+  if (field === 'activity') return undefined;
+  if (key === 'mediaRooms' && field === 'rooms') return { name: 'rooms', type: 'MediaRoom[]' };
+  if (key === 'presence' && field === 'members') return { name: 'presence', type: 'Record<MemberId, PresenceMember>' };
+  if (key === 'comments' && field === 'threads') return { name: 'commentThreads', type: 'Record<ThreadId, CommentThread>' };
+  if (key === 'comments' && field === 'comments') return { name: 'comments', type: 'Record<CommentId, Comment>' };
+  if (key === 'screenShare' && field === 'shares') return { name: 'screenShares', type: 'Record<ShareId, ScreenShare>' };
+  if (key === 'markdown' && field === 'documents') return { name: 'documents', type: 'Record<string, MarkdownDocument>' };
+  if (key === 'embeds' && field === 'embeds') return { name: 'embeds', type: 'Record<EmbedId, Embed>' };
+  if (key === 'files' && field === 'files') return { name: 'files', type: 'Record<string, FileRecord>' };
+  if (key === 'reactions' && field === 'reactions') return { name: 'reactions', type: 'Record<string, ScopedReaction>' };
+  if (key === 'attachments' && field === 'attachments') return { name: 'attachments', type: 'Record<string, Attachment>' };
+  if (key === 'approvals' && field === 'requests') return { name: 'approvals', type: 'Record<string, ApprovalRequest>' };
+  if (key === 'labels' && field === 'labels') return { name: 'labels', type: 'Record<string, Label>' };
+  if (key === 'labels' && field === 'assignments') return { name: 'labelAssignments', type: 'Record<string, string[]>' };
+  if (key === 'checklists' && field === 'checklists') return { name: 'checklists', type: 'Record<string, Checklist>' };
+  if (key === 'calendar' && field === 'events') return { name: 'calendarEvents', type: 'Record<string, CalendarEvent>' };
+  if (key === 'locationPins' && (field === 'pins' || field === 'locations')) return { name: 'locationPins', type: 'Record<string, LocationPin>' };
+  if (key === 'git' && field === 'version') return { name: 'version', type: 'number' };
+  if (key === 'git' && field === 'repos') return { name: 'repos', type: 'Record<string, GitRepo>' };
+  return { name: field, type: typeForPluginField(pluginRef, field) };
+}
+
+function pluginFlatStateFields(composition, registry = builtinMicroPluginRegistry) {
+  const fields = {};
+  for (const plugin of composition.plugins || []) {
+    for (const field of pluginStateShape(plugin, registry)) {
+      const flat = flatStateField(plugin, field);
+      if (flat) fields[flat.name] = { type: flat.type, optional: false };
+    }
+  }
+  return fields;
+}
+
+module.exports = {
+  collectScopeTypes,
+  coreStateFields,
+  hasCoreDirectMessages,
+  pluginFlatStateFields,
+  scopeTypeUnion,
+  standardPluginEntityTypes
+};

package/src/types/schema.cjs

@@ -0,0 +1,148 @@
+function pascalCase(value) {
+  const text = String(value || 'Matterhorn');
+  const out = text.replace(/(^|[^a-zA-Z0-9]+)([a-zA-Z0-9])/g, (_m, _sep, char) => char.toUpperCase()).replace(/[^a-zA-Z0-9]/g, '');
+  return out || 'Matterhorn';
+}
+
+function namespaceNameForApp(schemaOrApp, fallback = 'MatterhornApp') {
+  const app = schemaOrApp?.app || schemaOrApp || {};
+  if (app.namespace) return pascalCase(app.namespace);
+  if (app.name) return pascalCase(app.name).replace(/Matterhorn|Example/g, '') || pascalCase(app.name);
+  if (app.id) return pascalCase(String(app.id).split('.').at(-1));
+  return fallback;
+}
+
+function singularize(name) {
+  const text = String(name || 'Item');
+  if (text === 'activity') return 'Activity';
+  if (text.endsWith('ies')) return `${text.slice(0, -3)}y`;
+  if (text.endsWith('Messages')) return text.slice(0, -1);
+  if (text.endsWith('sses')) return text.slice(0, -2);
+  if (text.endsWith('s') && text.length > 1) return text.slice(0, -1);
+  return text;
+}
+
+function typeNameForCollection(name) {
+  if (name === 'roleDefinitions') return 'RoleDefinition';
+  if (name === 'memberRoles') return 'MemberRole';
+  return pascalCase(singularize(name));
+}
+
+function sortedObjectEntries(value) {
+  return Object.entries(value || {}).sort(([a], [b]) => a.localeCompare(b));
+}
+
+function quoteProp(key) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+
+function union(values) {
+  const flat = [];
+  for (const value of values) {
+    for (const part of String(value || 'unknown').split(' | ')) flat.push(part.trim());
+  }
+  const unique = [...new Set(flat.filter(Boolean))];
+  if (unique.length === 0) return 'unknown';
+  if (unique.includes('unknown')) return 'unknown';
+  if (unique.includes('any')) return 'any';
+  return unique.sort().join(' | ');
+}
+
+function literalType(value) {
+  if (value === null) return 'null';
+  if (typeof value === 'string') {
+    if (/^[a-z0-9_.:-]+$/i.test(value) && value.includes('.')) return JSON.stringify(value);
+    return 'string';
+  }
+  if (typeof value === 'number') return 'number';
+  if (typeof value === 'boolean') return 'boolean';
+  if (Array.isArray(value)) return value.length ? `${union(value.map(literalType))}[]` : 'unknown[]';
+  if (value && typeof value === 'object') {
+    const entries = sortedObjectEntries(value).map(([key, child]) => `${quoteProp(key)}: ${literalType(child)}`);
+    return entries.length ? `{ ${entries.join('; ')} }` : 'Record<string, unknown>';
+  }
+  return 'unknown';
+}
+
+function addNull(type, spec) {
+  return spec?.nullable ? union([type, 'null']) : type;
+}
+
+function typeFromSchema(spec = {}) {
+  if (typeof spec === 'string') return spec === 'any' ? 'unknown' : spec;
+  if (Array.isArray(spec)) return 'string';
+  const type = spec.type || 'any';
+  if (type === 'any') return 'unknown';
+  if (type === 'string') return addNull('string', spec);
+  if (type === 'number' || type === 'integer') return addNull('number', spec);
+  if (type === 'boolean') return addNull('boolean', spec);
+  if (type === 'literal') return addNull(literalType(spec.value), spec);
+  if (type === 'enum') return addNull((spec.values || []).map((value) => JSON.stringify(value)).join(' | ') || 'string', spec);
+  if (type === 'array') return addNull(`${typeFromSchema(spec.items || { type: 'any' })}[]`, spec);
+  if (type === 'record') return addNull(`Record<string, ${typeFromSchema(spec.values || spec.items || { type: 'any' })}>`, spec);
+  if (type === 'object') return addNull(inlinePayloadType(spec), spec);
+  return addNull('unknown', spec);
+}
+
+function normalizePayloadSchema(schema = {}) {
+  if (schema.required || schema.optional) return schema;
+  return { additional: true };
+}
+
+function schemaEntries(part) {
+  if (!part) return [];
+  if (Array.isArray(part)) return part.map((name) => [name, { type: 'string' }]);
+  return Object.entries(part).map(([key, value]) => [key, typeof value === 'string' ? { type: value } : (value || { type: 'any' })]);
+}
+
+function inlinePayloadType(payloadSchema = {}) {
+  const schema = normalizePayloadSchema(payloadSchema);
+  const chunks = [];
+  for (const [name, spec] of schemaEntries(schema.required)) chunks.push(`${quoteProp(name)}: ${typeFromSchema(spec)}`);
+  for (const [name, spec] of schemaEntries(schema.optional)) chunks.push(`${quoteProp(name)}?: ${typeFromSchema(spec)}`);
+  if (schema.additional === true || (!schema.required && !schema.optional)) chunks.push('[key: string]: unknown');
+  return chunks.length ? `{ ${chunks.join('; ')} }` : 'Record<string, never>';
+}
+
+function payloadFieldInfo(payloadSchema, fieldName) {
+  const schema = normalizePayloadSchema(payloadSchema || {});
+  for (const [name, spec] of schemaEntries(schema.required)) if (name === fieldName) return { type: typeFromSchema(spec), optional: false };
+  for (const [name, spec] of schemaEntries(schema.optional)) if (name === fieldName) return { type: typeFromSchema(spec), optional: true };
+  return { type: 'unknown', optional: true };
+}
+
+function typeFromStringExpression(value, payloadSchema) {
+  const payloadMatch = /^\$payload\.([A-Za-z0-9_-]+)$/.exec(value);
+  if (payloadMatch) return payloadFieldInfo(payloadSchema, payloadMatch[1]);
+  if (value === '$createdAt') return { type: 'number', optional: false };
+  if (value.startsWith('$id:')) return { type: 'string', optional: false };
+  if (value === '$operation.id' || value === '$operation.type' || value === '$operation.ledgerId' || value === '$operation.snowflakeId') return { type: 'string', optional: false };
+  if (value.startsWith('$actor.') || value.startsWith('$app.') || value.startsWith('$room.') || value.startsWith('$profile.')) return { type: 'string', optional: false };
+  if (value.startsWith('$')) return { type: 'unknown', optional: true };
+  return { type: literalType(value), optional: false };
+}
+
+function typeFromExpression(value, payloadSchema) {
+  if (typeof value === 'string') return typeFromStringExpression(value, payloadSchema);
+  if (value && typeof value === 'object' && !Array.isArray(value) && Object.prototype.hasOwnProperty.call(value, '$expr')) {
+    const info = typeFromStringExpression(value.$expr, payloadSchema);
+    if (!Object.prototype.hasOwnProperty.call(value, 'fallback')) return info;
+    if (Array.isArray(value.fallback) && value.fallback.length === 0 && String(info.type || '').endsWith('[]')) return { type: info.type, optional: false };
+    return { type: union([info.type, literalType(value.fallback)]), optional: false };
+  }
+  return { type: literalType(value), optional: false };
+}
+
+module.exports = {
+  inlinePayloadType,
+  literalType,
+  namespaceNameForApp,
+  pascalCase,
+  quoteProp,
+  schemaEntries,
+  sortedObjectEntries,
+  typeFromExpression,
+  typeFromSchema,
+  typeNameForCollection,
+  union
+};

package/src/types/standardPluginEntityTypes.cjs

@@ -0,0 +1,135 @@
+const { hasCoreDirectMessages, hasCoreScopedAccess } = require('./coreFeatures.cjs');
+
+function pluginKeys(composition = {}) {
+  return new Set((composition.plugins || []).map((plugin) => plugin.key || plugin.id));
+}
+
+function usesScopedRole(composition = {}, keys = pluginKeys(composition)) {
+  return keys.has('approvals') || hasCoreScopedAccess(composition);
+}
+
+function addScopeTypesFromValue(types, value) {
+  if (!value || typeof value !== 'object') return;
+  if (Array.isArray(value)) {
+    for (const item of value) addScopeTypesFromValue(types, item);
+    return;
+  }
+  if (typeof value.scopeType === 'string') types.add(value.scopeType);
+  for (const item of Object.values(value)) addScopeTypesFromValue(types, item);
+}
+
+function collectScopeTypes(composition = {}) {
+  const types = new Set(['channel']);
+  for (const scope of Object.values(composition.sharedScopes || {})) {
+    if (typeof scope?.scopeType === 'string') types.add(scope.scopeType);
+    else if (typeof scope?.type === 'string') types.add(scope.type);
+  }
+  for (const action of composition.actions || []) addScopeTypesFromValue(types, action.payloadDefaults);
+  for (const plugin of composition.plugins || []) addScopeTypesFromValue(types, plugin.config);
+  return [...types].sort();
+}
+
+function scopeTypeUnion(composition = {}) {
+  const literals = collectScopeTypes(composition).map((type) => JSON.stringify(type));
+  return literals.length ? `${literals.join(' | ')} | (string & {})` : 'string & {}';
+}
+
+function standardPluginEntityTypes(composition = {}) {
+  const keys = pluginKeys(composition);
+  const lines = [`  export type ChannelId = string & { readonly __brand: "ChannelId" };
+  export type MessageId = string & { readonly __brand: "MessageId" };
+  export type RoleId = string & { readonly __brand: "RoleId" };
+  export type RoomId = string & { readonly __brand: "RoomId" };
+  export type MemberId = string & { readonly __brand: "MemberId" };
+  export type ThreadId = string & { readonly __brand: "ThreadId" };
+  export type CommentId = string & { readonly __brand: "CommentId" };
+  export type EmbedId = string & { readonly __brand: "EmbedId" };
+  export type ShareId = string & { readonly __brand: "ShareId" };
+  export type Reactions = Record<string, MemberId[]>;
+  export type ScopeType = ${scopeTypeUnion(composition)};
+  export interface ScopeRef { scopeType: ScopeType; scopeId: string; }
+  export type RoleAccessGrant = "editor" | "readonly";
+  export type RoomRoleAccess = Record<RoleId, RoleAccessGrant>;
+  export type AccessLevel = "hidden" | RoleAccessGrant;
+  export type PresenceStatus = "online" | "idle" | "dnd" | "offline" | (string & {});
+  export interface MediaFlags { audio?: boolean; video?: boolean; screen?: boolean; }
+  export interface MessageEmbed { id?: EmbedId; url: string; provider?: string; kind?: string; title?: string; thumbnailUrl?: string; renderMode?: string; }
+  export interface Member { id?: MemberId; memberId?: MemberId; name?: string; displayName?: string; role?: Role | (string & {}); status?: string; avatarUrl?: string; revokedAt?: number | null; bannedAt?: number | null; }`];
+  if (usesScopedRole(composition, keys)) lines.push(`  export type ScopedRole = "none" | "viewer" | "editor" | "moderator" | "admin" | "owner";`);
+  if (keys.has('mediaRooms')) lines.push(`  /** From the mediaRooms plugin. */
+  export interface MediaRoomParticipant { memberId: MemberId; name?: string; media?: MediaFlags; joinedAt?: number; }
+  /** From the mediaRooms plugin. */
+  export interface MediaRoom { id: RoomId; name: string; group: string | null; allowsVideo: boolean; scopeType?: ScopeType; scopeId?: string; roleAccess: RoomRoleAccess; locked: boolean; spotlightMemberId?: MemberId | null; archivedAt: number | null; participants: Record<MemberId, MediaRoomParticipant>; participantCount: number; createdBy?: MemberId; createdAt?: number; }
+`);
+  if (keys.has('presence')) lines.push(`  /** From the presence plugin. */
+  export interface PresenceMember { memberId: MemberId; name?: string; status: PresenceStatus; activity: string | null; location: string | null; updatedAt?: number; lastPingAt?: number; visible?: boolean; avatarUrl?: string; }
+`);
+  if (keys.has('comments')) lines.push(`  /** From the comments plugin. */
+  export interface CommentThread { id: ThreadId; scopeType: ScopeType; scopeId: string; title: string | null; resolved: boolean; createdAt: number; lastCommentAt?: number; archivedAt: number | null; }
+  /** From the comments plugin. */
+  export interface Comment { id: CommentId; threadId: ThreadId; scopeType?: ScopeType; scopeId?: string; parentId?: CommentId | null; body: string; authorId: MemberId; authorName?: string; createdAt: number; deletedAt: number | null; reactions: Reactions; }
+`);
+  if (keys.has('embeds')) lines.push(`  /** From the embeds plugin. */
+  export interface Embed { id: EmbedId; scopeType: ScopeType; scopeId: string; url: string; provider?: string; kind?: string; title?: string; note: string | null; addedBy?: MemberId; addedByName?: string; addedAt: number; removedAt: number | null; }
+`);
+  if (keys.has('files')) lines.push(`  /** From the files plugin. */
+  export interface NostrEvent { kind: number; created_at: number; tags: string[][]; content: string; pubkey: string; id: string; sig: string; }
+  /** From the files plugin. */
+  export interface FileRecord { id: string; scopeType: ScopeType; scopeId: string; scopeKey?: string; eventId: string; event?: NostrEvent; uploadedBy?: MemberId; uploadedByName?: string; uploadedAt: number; removedAt?: number | null; removedBy?: MemberId; }
+`);
+  if (keys.has('markdown')) lines.push(`  /** From the markdown plugin. */
+  export interface MarkdownDocument { id: string; scopeType: ScopeType; scopeId: string; scopeKey?: string; title: string; markdown: string; ast?: unknown; embeds: MessageEmbed[]; text: string; visibility?: "public" | "members" | "private" | (string & {}); tags: string[]; updatedBy?: MemberId; updatedByName?: string; updatedAt: number; createdAt: number; createdBy?: MemberId; deletedAt?: number | null; deletedBy?: MemberId; }
+`);
+  if (keys.has('approvals')) lines.push(`  /** From the approvals plugin. */
+  export interface ApprovalDecision { decision: "approved" | "rejected" | "changes-requested" | (string & {}); note?: string; decidedBy?: MemberId; decidedByName?: string; decidedAt?: number; }
+  /** From the approvals plugin. */
+  export interface ApprovalRequest { id: string; scopeType: ScopeType; scopeId: string; scopeKey?: string; title: string; description?: string | null; requiredRole?: ScopedRole; assigneeIds: MemberId[]; requestedBy?: MemberId; requestedByName?: string; requestedAt: number; status: "open" | "approved" | "rejected" | "changes-requested" | (string & {}); decisions: ApprovalDecision[]; closedAt?: number; }
+`);
+  if (hasCoreScopedAccess(composition)) lines.push(`  /** From matterhorn.core scoped access. */
+  export interface CoreScopeAccess { scopeType: string; scopeId: string; role: ScopedRole; canView: boolean; canEdit: boolean; }
+  /** From matterhorn.core scoped access. */
+  export interface CoreAccessState { version?: number; scopes: Record<string, CoreScopeAccess>; }
+`);
+  if (keys.has('reactions')) lines.push(`  /** From the reactions plugin. */
+  export interface ScopedReaction { scopeType: ScopeType; scopeId: string; reactions: Reactions; updatedAt?: number; }
+`);
+  if (keys.has('screenShare')) lines.push(`  /** From the screenShare plugin. */
+  export interface ScreenShare { id: ShareId; scopeType?: ScopeType; scopeId?: string; roomId: RoomId | null; title: string | null; presenterId: MemberId; presenterName?: string; startedAt: number; stoppedAt: number | null; stoppedBy?: MemberId; }
+`);
+  if (keys.has('attachments')) lines.push(`  /** From the attachments plugin. */
+  export interface Attachment { id: string; scopeType?: ScopeType; scopeId?: string; url?: string; title?: string; mimeType?: string | null; sizeBytes?: number | null; provider?: string | null; note?: string | null; addedAt?: number; removedAt?: number | null; }
+`);
+  if (keys.has('labels')) lines.push(`  /** From the labels plugin. */
+  export interface Label { id: string; name: string; color?: string | null; description?: string | null; archivedAt?: number | null; }
+`);
+  if (keys.has('checklists')) lines.push(`  /** From the checklists plugin. */
+  export interface Checklist { id: string; scopeType?: ScopeType; scopeId?: string; title?: string; items?: Array<{ id: string; text: string; completed?: boolean; completedAt?: number | null }>; archivedAt?: number | null; }
+`);
+  if (keys.has('calendar')) lines.push(`  /** From the calendar plugin. */
+  export interface CalendarEvent { id: string; scopeType?: ScopeType; scopeId?: string; title: string; startsAt?: number; endsAt?: number | null; location?: string | null; description?: string | null; cancelledAt?: number | null; }
+`);
+  if (keys.has('locationPins')) lines.push(`  /** From the locationPins plugin. */
+  export interface LocationPin { id: string; scopeType?: ScopeType; scopeId?: string; label?: string; address?: string; lat: number; lng: number; zoom: number; createdAt?: number; updatedAt?: number; updatedBy?: MemberId; removedAt?: number | null; }
+`);
+  if (keys.has('git')) lines.push(`  /** From the git plugin. */
+  export type GitRole = "none" | "viewer" | "editor" | "moderator" | "admin" | "owner";
+  /** From the git plugin. */
+  export interface GitRef { name: string; oid: string | null; previousOid?: string | null; updatedBy?: MemberId; updatedByName?: string; updatedAt?: number; message?: string; source?: string; }
+  /** From the git plugin. */
+  export interface GitRepoAccess { role: GitRole; canView: boolean; canEdit: boolean; canManage: boolean; canAdmin: boolean; }
+  /** From the git plugin. */
+  export interface GitRepo { id: string; name: string; description?: string; defaultBranch?: string; defaultRole?: GitRole; currentEpoch?: number; refs?: Record<string, GitRef>; roles?: Record<MemberId, GitRole>; keyEpochs?: Record<string, { epoch: number; status?: string; createdAt?: number; wrappedKeyCount?: number }>; access?: GitRepoAccess; manifestCount?: number; chunkCount?: number; updatedAt?: number; createdAt?: number; archivedAt?: number; }
+`);
+  if (hasCoreDirectMessages(composition)) lines.push(`  /** From matterhorn.core direct messages. */
+  export interface DirectThread { id: ThreadId; protocol?: string; userIds: MemberId[]; topicKey?: string; topic: string | null; createdAt: number; archivedAt: number | null; }
+  /** From matterhorn.core direct messages. */
+  export interface DirectMessage { id: MessageId; protocol?: string; threadId: ThreadId; userIds?: MemberId[]; topicKey?: string; authorId: MemberId; body: string; reactions: Reactions; embeds: MessageEmbed[]; replyToId?: MessageId | null; pinnedAt?: number | null; pinnedBy?: MemberId | null; editedAt?: number | null; deletedAt?: number | null; deletedBy?: MemberId | null; createdAt: number; encrypted?: boolean; }`);
+  return lines.join('\n');
+}
+
+module.exports = {
+  collectScopeTypes,
+  pluginKeys,
+  scopeTypeUnion,
+  standardPluginEntityTypes
+};

package/test/content-lww-contract.test.cjs

@@ -0,0 +1,104 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const { canonicalJson } = require("@mh-gg/event");
+const { sortOperations } = require("@mh-gg/host-runtime");
+const { ensureOperationIdentity, formatHlc } = require("@mh-gg/protocol");
+const { applyEffects } = require("../src/model/effects.cjs");
+
+const ACTOR = { memberId: "alice", deviceId: "dev_alice", role: "admin" };
+
+function op(type, payload, physical, nodeId = ACTOR.deviceId) {
+  return ensureOperationIdentity({
+    roomId: "room_lww",
+    appPackId: "app_lww",
+    appPackHash: "sha256-lww",
+    pluginId: "plugin_lww",
+    type,
+    actor: ACTOR,
+    seq: physical,
+    createdAt: physical,
+    hlc: formatHlc({ physical, logical: 0, nodeId }),
+    payload,
+    auth: { credentialId: "cred", signature: "sig" }
+  }, { now: physical, nodeId });
+}
+
+const EFFECTS = {
+  "record.create": [
+    { kind: "createRecord", collection: "items", storage: "map", idField: "itemId", fields: { name: "$payload.name", createdAt: "$createdAt" } }
+  ],
+  "record.rename": [
+    { kind: "updateRecord", collection: "items", storage: "map", idField: "itemId", fields: { name: "$payload.name", updatedAt: "$createdAt" } }
+  ],
+  "card.reorder": [
+    { kind: "removeIdFromRecordArray", collection: "lists", storage: "array", idField: "listId", arrayField: "cardIds", value: "$payload.cardId" },
+    { kind: "insertIdIntoRecordArray", collection: "lists", storage: "array", idField: "listId", arrayField: "cardIds", value: "$payload.cardId", position: "$payload.position" }
+  ],
+  "path.merge": [
+    { kind: "mergePath", path: "settings", fields: "$payload.fields" }
+  ],
+  "reaction.toggle": [
+    { kind: "toggleReaction", collection: "messages", storage: "map", idField: "messageId", emojiField: "emoji" }
+  ]
+};
+
+function initialState() {
+  return {
+    items: { item: { id: "item", name: "initial" } },
+    lists: [{ id: "todo", cardIds: ["a", "b", "c"] }],
+    messages: { m1: { id: "m1", reactions: {} } },
+    settings: { theme: "light", mode: "draft" },
+    activity: []
+  };
+}
+
+function reduceOperation(state, operation) {
+  return applyEffects(state, EFFECTS[operation.type], { operation, actor: operation.actor, payload: operation.payload, state });
+}
+
+function rebuild(operations) {
+  return sortOperations(operations).reduce(reduceOperation, initialState());
+}
+
+function permutations(items) {
+  if (items.length <= 1) return [items];
+  return items.flatMap((item, index) => permutations([...items.slice(0, index), ...items.slice(index + 1)]).map((rest) => [item, ...rest]));
+}
+
+test("content replay is deterministic across arrival order and same-field edits are HLC LWW", () => {
+  const operations = [
+    op("record.rename", { itemId: "item", name: "early" }, 1000),
+    op("record.rename", { itemId: "item", name: "late" }, 1002),
+    op("path.merge", { fields: { mode: "review" } }, 1001)
+  ];
+  const expected = canonicalJson(rebuild(operations));
+
+  for (const order of permutations(operations)) assert.equal(canonicalJson(rebuild(order)), expected);
+  const final = rebuild([...operations].reverse());
+  assert.equal(final.items.item.name, "late");
+  assert.equal(final.settings.mode, "review");
+});
+
+test("schema list reorders converge by total-order replay for the same list", () => {
+  const earlyMove = op("card.reorder", { listId: "todo", cardId: "b", position: 0 }, 2000);
+  const lateMove = op("card.reorder", { listId: "todo", cardId: "b", position: 2 }, 2001);
+
+  const left = rebuild([earlyMove, lateMove]);
+  const right = rebuild([lateMove, earlyMove]);
+  assert.equal(canonicalJson(left), canonicalJson(right));
+  assert.deepEqual(left.lists[0].cardIds, ["a", "c", "b"]);
+});
+
+test("createRecord add-wins for distinct ids and toggleReaction is total-order deterministic", () => {
+  const createA = op("record.create", { itemId: "a", name: "A" }, 3000);
+  const createB = op("record.create", { itemId: "b", name: "B" }, 3001);
+  const toggleOn = op("reaction.toggle", { messageId: "m1", emoji: "👍" }, 3002);
+  const toggleOff = op("reaction.toggle", { messageId: "m1", emoji: "👍" }, 3003);
+
+  const expected = canonicalJson(rebuild([createA, createB, toggleOn, toggleOff]));
+  for (const order of permutations([createA, createB, toggleOn, toggleOff])) assert.equal(canonicalJson(rebuild(order)), expected);
+  const final = rebuild([toggleOff, createB, createA, toggleOn]);
+  assert.deepEqual(Object.keys(final.items).sort(), ["a", "b", "item"]);
+  assert.deepEqual(final.messages.m1.reactions["👍"], []);
+});

package/test/partitionValidator.test.cjs

@@ -0,0 +1,92 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+const { validateModelShapes } = require("../src/model/partitionValidator.cjs");
+
+function modelWithOperations(operations, shapes = {}) {
+  return { shapes, operations };
+}
+
+test("validates operations with no chunkable shapes", () => {
+  const issues = validateModelShapes(modelWithOperations({
+    createPost: {
+      payload: {},
+      effects: [{ kind: "createRecord", collection: "posts", partition: "posts" }],
+      guards: [{ kind: "eq", left: { path: "$state.settings.title" }, right: { kind: "value.literal", value: "x" } }]
+    }
+  }, {
+    posts: { readClass: "full-fold", integrityClass: "checkpoint", partition: "posts" },
+    settings: { readClass: "full-fold", integrityClass: "checkpoint", partition: "settings" }
+  }));
+  assert.deepEqual(issues, []);
+});
+
+test("rejects cross-partition guard on window shape", () => {
+  const issues = validateModelShapes(modelWithOperations({
+    createPost: {
+      payload: {},
+      effects: [{ kind: "createRecord", collection: "posts", partition: "posts" }],
+      guards: [{ kind: "eq", left: { path: "$state.settings.allowPosts" }, right: { kind: "value.literal", value: true } }]
+    }
+  }, {
+    posts: { readClass: "window", integrityClass: "signature", partition: "posts" },
+    settings: { readClass: "head", integrityClass: "seq", partition: "settings" }
+  }));
+  assert.equal(issues.length, 1);
+  assert.equal(issues[0].type, "cross-partition-guard");
+  assert.equal(issues[0].partition, "settings");
+});
+
+test("rejects cross-partition guard on head shape", () => {
+  const issues = validateModelShapes(modelWithOperations({
+    updateSettings: {
+      payload: {},
+      effects: [{ kind: "mergePath", path: "settings.title" }],
+      guards: [{ kind: "eq", left: { path: "$state.posts.length" }, right: { kind: "value.literal", value: 0 } }]
+    }
+  }, {
+    posts: { readClass: "window", integrityClass: "signature", partition: "posts" },
+    settings: { readClass: "head", integrityClass: "seq", partition: "settings" }
+  }));
+  assert.equal(issues.length, 1);
+  assert.equal(issues[0].type, "cross-partition-guard");
+});
+
+test("allows same-partition guards", () => {
+  const issues = validateModelShapes(modelWithOperations({
+    createPost: {
+      payload: {},
+      effects: [{ kind: "createRecord", collection: "posts", partition: "posts" }],
+      guards: [{ kind: "recordOwnerOrRole", collection: "posts", roles: ["admin"] }]
+    }
+  }, {
+    posts: { readClass: "window", integrityClass: "signature", partition: "posts" }
+  }));
+  assert.deepEqual(issues, []);
+});
+
+test("rejects non-append effects on window shape", () => {
+  const issues = validateModelShapes(modelWithOperations({
+    editPost: {
+      payload: {},
+      effects: [{ kind: "updateRecord", collection: "posts", partition: "posts" }],
+      guards: []
+    }
+  }, {
+    posts: { readClass: "window", integrityClass: "signature", partition: "posts" }
+  }));
+  assert.equal(issues.length, 1);
+  assert.equal(issues[0].type, "non-crdt-window-effect");
+});
+
+test("allows append effects on window shape", () => {
+  const issues = validateModelShapes(modelWithOperations({
+    addPost: {
+      payload: {},
+      effects: [{ kind: "createRecord", collection: "posts", partition: "posts" }],
+      guards: []
+    }
+  }, {
+    posts: { readClass: "window", integrityClass: "signature", partition: "posts" }
+  }));
+  assert.deepEqual(issues, []);
+});