edytor 4.0.0 → 5.0.0

package/dist/crdt/protocols/comments.d.ts

@@ -67,6 +67,16 @@ export type CommentRequest = {
     block?: string | null;
     /** The first comment's id (default: one the store makes). */
     comment?: string;
+    /**
+     * The text it is made on, as anchors (`DocAnchor`s, each span's
+     * ends): the room writes its anchor mark over them for a user who
+     * may only comment (`room.access.comment`); a writer's view writes
+     * it itself.
+     */
+    anchors?: {
+        start: unknown;
+        end: unknown;
+    }[];
 } | {
     op: 'reply';
     thread: string;
@@ -85,11 +95,16 @@ export type CommentRequest = {
     thread: string;
     comment?: string;
 };
-/** Who asks: a verified user, read-only or not; a moderator may delete anyone's comment. */
+/**
+ * Who asks: a verified user, read-only or not; a moderator may delete
+ * anyone's comment; `anchors`: the store writes a new thread's anchor (a
+ * user who may only comment).
+ */
 export type CommentActor = {
     user: string;
     readOnly?: boolean;
     moderator?: boolean;
+    anchors?: boolean;
 };
 /** What one request changed (the room broadcasts it, `onComment` receives it). */
 export type CommentChange = {

package/dist/crdt/protocols/comments.js

@@ -62,13 +62,21 @@ export const parseCommentRequest = (value) => {
                 return null;
             if (v.block !== undefined && v.block !== null && typeof v.block !== 'string')
                 return null;
+            if (v.anchors !== undefined &&
+                (!Array.isArray(v.anchors) ||
+                    v.anchors.length > 64 ||
+                    v.anchors.some((a) => typeof a?.start !== 'object' || typeof a?.end !== 'object')))
+                return null;
             return {
                 op: 'add',
                 thread: v.thread,
                 body: v.body,
                 ...(v.quote === undefined ? {} : { quote: v.quote }),
                 ...(v.block === undefined ? {} : { block: v.block }),
-                ...(v.comment === undefined ? {} : { comment: v.comment })
+                ...(v.comment === undefined ? {} : { comment: v.comment }),
+                ...(v.anchors === undefined
+                    ? {}
+                    : { anchors: v.anchors })
             };
         case 'reply':
             if (typeof v.body !== 'string')

package/dist/crdt/providers/index.d.ts

@@ -47,6 +47,8 @@ export type EdytorSyncPayload = {
      * websocket sync's local store. `document.attachSync` passes it.
      */
     attach?: (sync: EdytorSync) => EdytorSyncCleanup | void;
+    /** What the room says the document's user may do (`EdytorDocument.access`). */
+    access?: (access: 'write' | 'suggest' | 'comment' | 'read') => void;
 };
 export type EdytorSyncCleanup = () => void | Promise<void>;
 export type EdytorSync = ((payload: EdytorSyncPayload) => void | EdytorSyncCleanup) & {
@@ -273,11 +275,11 @@ export declare const bindProviders: (Y: EngineApi) => {
             destroy(): void;
             disconnect(): void;
             connect(): void;
-            emit<N extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: N, args: Parameters<WebsocketProviderEvents[N]>): void;
+            emit<N extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: N, args: Parameters<WebsocketProviderEvents[N]>): void;
             _observers: Map<string, Set<any>>;
-            on<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): WebsocketProviderEvents[NAME];
-            once<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
-            off<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
+            on<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): WebsocketProviderEvents[NAME];
+            once<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
+            off<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
         };
     };
     watchComments: (server: string | null, roomName: string, listener: (message: import("../protocol.js").CommentMessage) => void) => (() => void);

package/dist/crdt/providers/index.js

@@ -38,7 +38,7 @@ export const bindProviders = (Y) => {
         const room = `${serverUrl}/${roomName}`;
         const persistName = options.persist === false ? undefined : (options.persistName ?? `edytor:${room}`);
         const sync = (payload) => {
-            const { doc, awareness, synced, failed, attach, armBound, holdBound } = payload;
+            const { doc, awareness, synced, failed, attach, armBound, holdBound, access } = payload;
             const { params, WebSocketPolyfill, maxBackoffTime, connectTimeout, disableBc, onExpired, maxFrameBytes } = options;
             const local = persistName !== undefined && typeof indexedDB !== 'undefined'
                 ? localSync(persistName, { disableBc })
@@ -54,6 +54,8 @@ export const bindProviders = (Y) => {
             });
             if (onExpired)
                 provider.on('expired', (state) => onExpired(state));
+            if (access)
+                provider.on('access', access);
             provider.on('synced', (isSynced) => {
                 if (isSynced)
                     synced(provider);

package/dist/crdt/providers/websocket.d.ts

@@ -7,6 +7,8 @@ export type WebsocketProviderEvents = {
     status: (event: {
         status: 'connected' | 'disconnected' | 'connecting';
     }) => void;
+    /** What the room says this connection's user may do, as it joins (and at a change in place). */
+    access: (access: 'write' | 'suggest' | 'comment' | 'read', provider: unknown) => void;
     synced: (state: boolean) => void;
     'connection-close': (event: CloseEvent | null, provider: unknown) => void;
     'connection-error': (event: Event, provider: unknown) => void;
@@ -221,11 +223,11 @@ export declare const bindWebsocketProvider: (Y: EngineApi) => {
             destroy(): void;
             disconnect(): void;
             connect(): void;
-            emit<N extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: N, args: Parameters<WebsocketProviderEvents[N]>): void;
+            emit<N extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: N, args: Parameters<WebsocketProviderEvents[N]>): void;
             _observers: Map<string, Set<any>>;
-            on<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): WebsocketProviderEvents[NAME];
-            once<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
-            off<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
+            on<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): WebsocketProviderEvents[NAME];
+            once<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
+            off<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
         };
     };
     watchComments: (server: string | null, roomName: string, listener: (message: CommentMessage) => void) => (() => void);

package/dist/crdt/providers/websocket.js

@@ -52,7 +52,7 @@ import * as math from 'lib0-v14/math';
 import * as url from 'lib0-v14/url';
 import { Awareness, removeAwarenessStates } from '../protocols/awareness.js';
 import { IsolatedObservable } from '../protocols/observable.js';
-import { messagePermissionDenied, messageReadOnly, READ_ONLY_DENIAL, readAuthMessage } from '../protocols/auth.js';
+import { messagePermissionDenied, messageAccess, messageReadOnly, READ_ONLY_DENIAL, SUGGEST_ONLY_DENIAL, readAuthMessage } from '../protocols/auth.js';
 import { bindSync } from '../protocols/sync.js';
 import { readCommentsMessage, writeCommentsSubscribe } from '../protocols/comments.js';
 import { frame } from '../protocols/envelope.js';
@@ -122,12 +122,17 @@ export const bindWebsocketProvider = (Y) => {
                     if (readOnly)
                         provider._writes.deny();
                     provider.emit('permission-denied', [reason, provider]);
-                    if (!readOnly)
+                    // What a suggest-only socket may not write is stripped: the socket stays.
+                    if (!readOnly && reason !== SUGGEST_ONLY_DENIAL)
                         emitFailed(provider, new Error(`permission denied: ${reason}`));
                 }, 
                 // The room's notice at the join: a state, not a refusal (no event).
-                () => provider._writes.deny());
-                if (authType !== messagePermissionDenied && authType !== messageReadOnly) {
+                () => provider._writes.deny(), 
+                // The room's word at the join, and at a change in place (`read`).
+                (access) => provider.emit('access', [access, provider]));
+                if (authType !== messagePermissionDenied &&
+                    authType !== messageReadOnly &&
+                    authType !== messageAccess) {
                     // An auth type we do not speak inside a valid v14 envelope is
                     // protocol skew — reported, never dropped silently.
                     provider.emit('message-error', [

package/dist/crdt/purge.d.ts

@@ -18,6 +18,7 @@
 import type { EngineApi, EngineDoc } from './engine-api.js';
 import { type PlacementModel } from './placement/model.js';
 import { type TextEngine } from './text/model.js';
+import { type SuggestFacade } from './doc/suggest.js';
 /** The horizon: the time and encoded state vector of the room's epoch (`room.purge.timing`). */
 export type Horizon = {
     at: number;
@@ -43,6 +44,11 @@ export type PurgeReport = {
     merged: number;
     /** Release records the horizon covers (`hist.release.end`): deleted. */
     released: number;
+    /**
+     * Suggestions decided before the horizon (`sugg.purge`): nothing of them
+     * pending, their records' entries older than it: their records deleted.
+     */
+    suggestions: number;
 };
 /**
  * The ended histories a document holds (`hist.release.end`): per writer,
@@ -53,7 +59,7 @@ export declare const releasesOf: (doc: EngineDoc) => Map<number, number>;
 /** The horizon a document holds (`null`: never purged). */
 export declare const readHorizon: (doc: EngineDoc) => Horizon | null;
 export declare const bindPurge: (Y: EngineApi) => {
-    purge: (doc: EngineDoc, facade: {
+    purge: (doc: EngineDoc, facade: Partial<SuggestFacade> & {
         model: PlacementModel;
         text: TextEngine;
     }, horizon: Horizon | null) => PurgeReport;

package/dist/crdt/purge.js

@@ -1,10 +1,13 @@
 import { recordsOf, registryOf, view as modelView } from './placement/model.js';
 import { removeUnit, unitOf } from './placement/slots.js';
 import { deleteClaims, purgeStreams, scanText } from './text/model.js';
-import { BLOCK_ATTR_ROOT, DATA, DATA_LEAF_PREFIX, DEL_PREFIX, HORIZON_ATTR, HORIZON_ROOT, REGISTRY_KEY, RELEASE_ROOT, TEXT_DELETES_ROOT, WITHDRAW_PREFIX } from './schema.js';
+import { BLOCK_ATTR_ROOT, DATA, DATA_LEAF_PREFIX, DEL_PREFIX, HORIZON_ATTR, HORIZON_ROOT, REGISTRY_KEY, RELEASE_ROOT, SUGGEST_ROOT, TEXT_DELETES_ROOT, WITHDRAW_PREFIX } from './schema.js';
 import { baseIdOf, isIncarnationId } from './incarnations.js';
+import { suggestionsOf } from './doc/suggest.js';
 import { attrItems, dropSearchMarkers, engineOps, firstItem, holdsIds } from './structs.js';
 const mapOf = (node) => attrItems(node);
+/** The clock a suggestion's record opened at (its writer's clocks it owns start there). */
+const clockOf = (rec) => rec.start ?? 0;
 /**
  * The ended histories a document holds (`hist.release.end`): per writer,
  * the clock its latest live release record ended at (what it wrote below
@@ -107,7 +110,8 @@ export const bindPurge = (Y) => {
             records: 0,
             claims: 0,
             merged: 0,
-            released: 0
+            released: 0,
+            suggestions: 0
         };
         const vector = horizon === null
             ? new Map()
@@ -425,6 +429,32 @@ export const bindPurge = (Y) => {
                 report.released++;
             }
         }
+        // Suggestions decided before the horizon (`sugg.purge`): the decision
+        // trail goes with them. A writer's oldest record first, so no record's
+        // clocks pass to another.
+        const suggest = facade.part && suggestionsOf(facade);
+        const records = suggest?.records() ?? [];
+        if (records.length > 0) {
+            const pending = new Set(suggest.changes().map((c) => c.suggestion));
+            const root = doc.get(SUGGEST_ROOT);
+            const seen = new Set();
+            for (const rec of [...records].sort((a, b) => clockOf(a) - clockOf(b))) {
+                if (seen.has(rec.writer))
+                    continue;
+                seen.add(rec.writer);
+                const node = root.getAttr(rec.id);
+                const items = [node._item];
+                for (let it = firstItem(node); it; it = it.right)
+                    if (!it.deleted)
+                        items.push(it);
+                if (pending.has(rec.id) ||
+                    !items.every((it) => old(it.id.client, it.id.clock + it.length - 1)))
+                    continue;
+                root.deleteAttr(rec.id);
+                seen.delete(rec.writer);
+                report.suggestions++;
+            }
+        }
         // The horizon record, last.
         if (horizon !== null)
             doc.get(HORIZON_ROOT).setAttr(HORIZON_ATTR, { at: horizon.at, sv: horizon.sv });

package/dist/crdt/restore.d.ts

@@ -26,6 +26,7 @@
 import type { EngineDoc } from './engine-api.js';
 import { type BlockId, type ContentItem, type InlineSpec, type PlacementModel } from './placement/model.js';
 import type { DataPatch } from './data.js';
+import { type SuggestFacade } from './doc/suggest.js';
 import type { JSONDoc } from '../utils/json.js';
 /** One display unit: a character (a code point) with its marks, or an inline atom, keyed for comparison. */
 export type Unit = {
@@ -60,7 +61,7 @@ export type RestoreReport = {
     deleted: number;
 };
 /** What a restore reads and writes through: the facade over the document (structurally). */
-export type RestoreFacade<Plan> = {
+export type RestoreFacade<Plan> = Partial<SuggestFacade> & {
     model: PlacementModel;
     childSlots(parent: BlockId | null): readonly {
         id: BlockId;

package/dist/crdt/restore.js

@@ -1,4 +1,5 @@
 import { blockNodeOf, insertSpecsAt, moveBlocksTo, view as modelView } from './placement/model.js';
+import { suggestionsOf } from './doc/suggest.js';
 import { DEL_PREFIX, TYPE, WITHDRAW_PREFIX } from './schema.js';
 import { common, patchWrites, writeData } from './data.js';
 import { canonKey, deleteClaims } from './text/model.js';
@@ -196,5 +197,13 @@ export const restoreDocument = (doc, facade, json) => {
     }
     // 6 · The document's data.
     facade.apply(facade.prepare.patchData(null, [{ path: [], value: json.data ?? {} }]));
+    // 7 · Pending suggestions are dropped (`sugg.restore`): the version holds
+    // none (its document without them), so what the restore left of them —
+    // their proposals — is rejected, in the restore's step (its undo brings
+    // them back).
+    // (Built over the facade, its shared suggestions: `doc/suggest.ts`.)
+    const suggest = facade.part && suggestionsOf(facade);
+    if (suggest)
+        suggest.run(suggest.decide(suggest.changes(), false));
     return report;
 };

package/dist/crdt/schema.d.ts

@@ -49,6 +49,14 @@ export declare const HORIZON_ATTR = "h";
  * horizon covers.
  */
 export declare const RELEASE_ROOT = "released";
+/**
+ * The shared suggestions (`crdt/doc/suggest.ts`): attr `<id>` is one
+ * suggestion's record node, written by its writer (a client id bound to its
+ * author): its creation time `at`, `via` and `lbl`, and a list of id lists
+ * (fork patch YP31: its writer's proposed deletions, anyone else's settled
+ * ranges) and proposed operations. In the history's scope.
+ */
+export declare const SUGGEST_ROOT = "suggest";
 /** Named node roles (`SCHEMA.nodes`). */
 export declare const BLOCK_NODE = "block";
 export declare const CONTENT_NODE = "content";
@@ -92,7 +100,7 @@ export declare const LAST_CHANGED_ATTR = "l";
 export declare const CONTENT = "content";
 /** The schema generation stamped on the `meta` root (`v`) and its manifest name (`schema`). */
 export declare const SCHEMA: {
-    readonly version: 10;
+    readonly version: 11;
     readonly name: "edytor-doc";
     readonly roots: {
         readonly registry: "blocks";

package/dist/crdt/schema.js

@@ -42,6 +42,14 @@ export const HORIZON_ATTR = 'h';
  * horizon covers.
  */
 export const RELEASE_ROOT = 'released';
+/**
+ * The shared suggestions (`crdt/doc/suggest.ts`): attr `<id>` is one
+ * suggestion's record node, written by its writer (a client id bound to its
+ * author): its creation time `at`, `via` and `lbl`, and a list of id lists
+ * (fork patch YP31: its writer's proposed deletions, anyone else's settled
+ * ranges) and proposed operations. In the history's scope.
+ */
+export const SUGGEST_ROOT = 'suggest';
 /** Named node roles (`SCHEMA.nodes`). */
 export const BLOCK_NODE = 'block';
 export const CONTENT_NODE = 'content';
@@ -86,9 +94,11 @@ export const SCHEMA = {
     // YP21), a block has no `claims` list; 9: a block's place is its home slot
     // in its parent's sequence and a move is a move record (fork patch YP22),
     // a block has no `at` map and an array item no rank; 10: the update encoding
-    // writes each distinct string once (fork patch YP24). A container or frame
-    // of an earlier generation is refused.
-    version: 10,
+    // writes each distinct string once (fork patch YP24); 11: a hold record
+    // inside a nested node holds nothing (fork patch YP31: a suggestion's
+    // proposals and decisions). A container or frame of an earlier generation
+    // is refused.
+    version: 11,
     name: 'edytor-doc',
     roots: { registry: REGISTRY_KEY, meta: META_ROOT_KEY },
     metaAttrs: { version: 'v', schema: 'schema' }

package/dist/crdt/structs.d.ts

@@ -212,6 +212,8 @@ export declare const engineOps: (Y: EngineApi) => {
     merge: (sets: IdSetLike[]) => IdSetOf;
     /** Whether a store struct is an item (not a GC or a Skip). */
     isItem: (struct: unknown) => struct is StoreStruct;
+    /** Show again what a suggestion's deletes in `tr` proposed (fork patch YP32). */
+    unhide: (tr: unknown) => void;
     /** Whether `item` sits in `node`'s subtree. */
     inside: (node: EngineNode, item: StoreStruct) => boolean;
     /** Keep `item` (and its parents) from collection (`keepItem`). */

package/dist/crdt/structs.js

@@ -238,6 +238,8 @@ export const engineOps = (Y) => {
         merge: (sets) => Y.mergeIdSets(sets),
         /** Whether a store struct is an item (not a GC or a Skip). */
         isItem: (struct) => struct instanceof Y.Item,
+        /** Show again what a suggestion's deletes in `tr` proposed (fork patch YP32). */
+        unhide: (tr) => Y.unhide(tr),
         /** Whether `item` sits in `node`'s subtree. */
         inside: (node, item) => Y.isParentOf(asYNode(node), item),
         /** Keep `item` (and its parents) from collection (`keepItem`). */

package/dist/crdt/text/index/claims.js

@@ -1,4 +1,4 @@
-import { DEAD, claimGraph, cmpStamp } from '../model.js';
+import { DEAD, cmpStamp } from '../model.js';
 import { addTo, dropFrom } from './shared.js';
 /** The claim graph of one doc's index, over its state. */
 export const indexClaims = (ix) => {
@@ -16,7 +16,6 @@ export const indexClaims = (ix) => {
     const topInv = new Map();
     /** Claimed block → the blocks whose claims list names it (live or not). */
     const claimersOf = new Map();
-    let ownersBuilt = false;
     /** The max-stamp claim on `m` held by a live block. */
     const topClaim = (m) => {
         let best;
@@ -91,27 +90,6 @@ export const indexClaims = (ix) => {
             addTo(displaysMap, to, b);
     };
     const ensureOwners = () => {
-        if (!ownersBuilt) {
-            ownersBuilt = true;
-            ownerSeeds.clear();
-            const graph = claimGraph(blocks);
-            owners.clear();
-            for (const [b, o] of graph.owners)
-                if (blocks.has(b))
-                    owners.set(b, o);
-            topOf.clear();
-            topInv.clear();
-            claimersOf.clear();
-            for (const [holder, rec] of blocks)
-                for (const c of rec.claims)
-                    addTo(claimersOf, c.m, holder);
-            for (const m of claimersOf.keys())
-                setTop(m, topClaim(m));
-            displaysMap.clear();
-            for (const b of blocks.keys())
-                setDisplay(b, undefined, owners.get(b));
-            return;
-        }
         if (ownerSeeds.size === 0)
             return;
         // The tops a seed's claims (now, and those it dropped: noted in `claimersOf` changes) decide.

package/dist/crdt/text/index/layout.d.ts

@@ -4,20 +4,18 @@
  * they read.
  */
 import type { BlockId, ChildSlot } from '../../placement/model.js';
-import type { DisplayRoles } from '../runs.js';
+import type { KindRole } from '../runs.js';
 import type { IndexState } from './state.js';
 /** The layout rules of one doc's index, over its state. */
 export declare const indexLayout: (ix: IndexState) => {
-    role: <T>(b: BlockId, ask: (r: DisplayRoles, type: string) => T) => T | undefined;
+    kindOf: (b: BlockId) => KindRole | undefined;
     lineKind: (b: BlockId) => string | undefined;
     itemKind: (b: BlockId) => string | undefined;
     rowKind: (b: BlockId) => string | undefined;
     rowOfTable: (table: string) => [string, string] | undefined;
-    declaredRows: () => Map<string, string>;
     cellKind: (b: BlockId) => string | undefined;
     cellRank: (row: BlockId, id: BlockId) => string | undefined;
     tableFacts: (b: BlockId, data: unknown) => string;
-    declaredItems: () => Set<string>;
     dissolve: (kids: Map<BlockId | null, ChildSlot[]>) => Set<BlockId>;
     redissolve: (changed: Map<BlockId, [BlockId | null | undefined, BlockId | null | undefined]>, kinds: Iterable<BlockId>) => Set<BlockId>;
 };

package/dist/crdt/text/index/layout.js

@@ -3,33 +3,22 @@ import { listedColumns, unlistedRank } from '../../tables.js';
 /** The layout rules of one doc's index, over its state. */
 export const indexLayout = (ix) => {
     const { blocks, kindsOf } = ix;
-    /** `ask` of `b`'s stored kind; `undefined` without roles or a record. */
-    const role = (b, ask) => {
+    /** The role of `b`'s stored kind; `undefined` without roles or a record. */
+    const kindOf = (b) => {
         const type = blocks.get(b)?.type;
-        return ix.roles === null || type === undefined ? undefined : ask(ix.roles, type);
+        return ix.roles === null || type === undefined ? undefined : ix.roles.of(type);
     };
     /** The line kind of `b` when it is an island declared `lines`. */
-    const lineKind = (b) => role(b, (r, type) => r.line(type));
+    const lineKind = (b) => kindOf(b)?.line;
     /** The item kind of `b` when it is a layout. */
-    const itemKind = (b) => role(b, (r, type) => r.layout(type));
-    /** The item kinds the roles declare. */
-    const declaredItems = () => {
-        const items = new Set();
-        for (const type of ix.roles?.layoutKinds() ?? [])
-            items.add(ix.roles.layout(type));
-        return items;
-    };
+    const itemKind = (b) => kindOf(b)?.layout;
     /** The row kind of `b` when it is a table (`table.*`). */
-    const rowKind = (b) => role(b, (r, type) => r.table(type));
+    const rowKind = (b) => kindOf(b)?.table;
     /** `table`'s row kind and that row kind's cell kind, as `[row, cell]`. */
     const rowOfTable = (table) => {
-        const row = ix.roles?.table(table);
-        return row === undefined ? undefined : [row, ix.roles.defaultChild(row)];
+        const row = ix.roles?.of(table).table;
+        return row === undefined ? undefined : [row, ix.roles.of(row).child];
     };
-    /** The row kinds (with their cell kinds) the roles declare. */
-    const declaredRows = () => new Map([...(ix.roles?.tableKinds() ?? [])]
-        .flatMap((type) => rowOfTable(type) ?? [])
-        .map(([row, cell]) => [row, cell]));
     /** The cell kind of `b` when it is a row of a table kind. */
     const cellKind = (b) => ix.rowKinds.get(blocks.get(b)?.type ?? '');
     /**
@@ -255,16 +244,14 @@ export const indexLayout = (ix) => {
         return flips;
     };
     return {
-        role,
+        kindOf,
         lineKind,
         itemKind,
         rowKind,
         rowOfTable,
-        declaredRows,
         cellKind,
         cellRank,
         tableFacts,
-        declaredItems,
         dissolve,
         redissolve
     };

package/dist/crdt/text/index/placement.js

@@ -31,7 +31,7 @@ import { engineOps, firstItem } from '../../structs.js';
 import { DEAD, displayOf } from '../model.js';
 /** Placement maintenance of one doc's index, over its state, claims, streams and layout rules. */
 export const indexPlacement = (ix) => {
-    const { doc, registry, blocks, displaysMap, ownerChanged, placementsMap, following, dirtyLists, leftLists, placementSeeds, stateSeeds, kindsOf, slotsByBlock, rawOrder, edges, fallen, rejected, ensureOwners, ownerOf, top, streamOf, streamsIn, streamAt, role, lineKind, itemKind, rowKind, rowOfTable, declaredRows, cellKind, cellRank, declaredItems, dissolve, redissolve } = ix;
+    const { doc, registry, blocks, displaysMap, ownerChanged, placementsMap, following, dirtyLists, leftLists, placementSeeds, stateSeeds, kindsOf, slotsByBlock, rawOrder, edges, fallen, rejected, ensureOwners, ownerOf, top, streamOf, streamsIn, streamAt, kindOf, lineKind, itemKind, rowKind, rowOfTable, cellKind, cellRank, dissolve, redissolve } = ix;
     const kept = engineOps(Y).isKeptReplaced;
     // ── placements and the children index (maintained) ────────────
     /** The document holds a layout or an item kind: `kids0` and `kidsMap` differ. */
@@ -47,9 +47,9 @@ export const indexPlacement = (ix) => {
     const ownShim = {
         ownerOf,
         hidden: (b) => ownerOf(b) !== b || ix.dissolved.has(b),
-        childless: (b) => role(b, (r, type) => r.childless(type)) === true,
-        island: (b) => role(b, (r, type) => r.island(type)) === true,
-        container: (b) => role(b, (r, type) => r.container(type)) === true,
+        childless: (b) => kindOf(b)?.childless === true,
+        island: (b) => kindOf(b)?.island === true,
+        container: (b) => kindOf(b)?.container === true,
         lined: (b) => lineKind(b) !== undefined,
         passes: (b) => ix.dissolved.has(b),
         sheds: (owner, child) => {
@@ -500,14 +500,15 @@ export const indexPlacement = (ix) => {
         placementSeeds.clear();
         stateSeeds.clear();
         ownerChanged.clear();
-        ix.itemKinds = declaredItems();
+        const declared = ix.roles?.declared();
+        ix.itemKinds = new Set(declared?.items);
         for (const b of blocks.keys()) {
             const item = itemKind(b);
             if (item !== undefined)
                 ix.itemKinds.add(item);
         }
-        lineKinds = new Set(ix.roles?.lineKinds());
-        ix.rowKinds = declaredRows();
+        lineKinds = new Set(declared?.lines);
+        ix.rowKinds = new Map(declared?.rows);
         for (const b of blocks.keys()) {
             const type = blocks.get(b)?.type;
             const rows = type === undefined ? undefined : rowOfTable(type);
@@ -670,10 +671,8 @@ export const indexPlacement = (ix) => {
      */
     const itemOf = (under, plain) => {
         const parent = typeOf(under);
-        if (!ix.roles.container(parent))
-            return plain;
-        const item = ix.roles.defaultChild(parent);
-        return ix.roles.rendersContent(item) ? item : plain;
+        const { container, child } = ix.roles.of(parent);
+        return container && ix.roles.of(child).rendersContent ? child : plain;
     };
     /**
      * The kind `id` displays as — THE shown-kind rule, read from its slot
@@ -694,7 +693,8 @@ export const indexPlacement = (ix) => {
     const typeOf = (id) => {
         const stored = blocks.get(id)?.type ?? 'unknown';
         const slot = ix.slots.get(id);
-        if (ix.roles === null || slot === undefined)
+        const roles = ix.roles;
+        if (roles === null || slot === undefined)
             return stored;
         const { parent: under, reset } = slot;
         const line = under === null || lineKinds.size === 0 ? undefined : lineKind(under);
@@ -702,26 +702,23 @@ export const indexPlacement = (ix) => {
             return line;
         const lined = lineKinds.has(stored);
         const from = reset === undefined ? undefined : (blocks.get(reset)?.type ?? null);
-        if (!lined && (from === undefined || stored !== ix.roles.defaultChild(from)))
-            return stored === ix.roles.defaultChild(null) && under !== null
-                ? itemOf(under, stored)
-                : stored;
+        const plain = roles.of(null).child;
+        if (!lined && (from === undefined || stored !== roles.of(from).child))
+            return stored === plain && under !== null ? itemOf(under, stored) : stored;
         // Out of a removed list, inside an outer list of its kind: still an item. A
         // container whose item is the document's default kind (a column) holds no
         // items of its own: a paragraph under one is no list's item.
-        if (!lined && typeof from === 'string' && ix.roles.container(from))
+        if (!lined && typeof from === 'string' && roles.of(from).container)
             for (let u = under; u !== null; u = ix.slots.get(u)?.parent ?? null) {
-                const t = typeOf(u);
-                if (ix.roles.container(t) &&
-                    ix.roles.defaultChild(t) === stored &&
-                    stored !== ix.roles.defaultChild(null))
+                const t = roles.of(typeOf(u));
+                if (t.container && t.child === stored && stored !== plain)
                     return stored;
             }
-        const kind = ix.roles.defaultChild(under === null ? null : typeOf(under));
-        if (ix.roles.rendersContent(kind) || !ix.roles.rendersContent(stored))
+        const kind = roles.of(under === null ? null : typeOf(under)).child;
+        if (roles.of(kind).rendersContent || !roles.of(stored).rendersContent)
             return kind;
         // Never a line kind outside its island, even where the slot's kind shows nothing.
-        return lined ? ix.roles.defaultChild(null) : stored;
+        return lined ? plain : stored;
     };
     /** The document order, cached until a child list changes. */
     const order = () => (orderCache ??= documentOrder(ix.kidsMap));

package/dist/crdt/text/index/shared.js

@@ -67,20 +67,23 @@ export const EMPTY_IDS = Object.freeze([]);
  * its children.
  */
 export const sameShape = (roles, a, b) => {
-    const lines = new Set(roles.lineKinds());
-    const items = new Set([...roles.layoutKinds()].map((type) => roles.layout(type)));
-    const rows = new Set([...roles.tableKinds()].flatMap((type) => roles.table(type) ?? []));
-    const cells = new Set([...rows].map((row) => roles.defaultChild(row)));
-    return (roles.childless(a) === roles.childless(b) &&
-        roles.island(a) === roles.island(b) &&
-        roles.container(a) === roles.container(b) &&
-        roles.line(a) === roles.line(b) &&
-        lines.has(a) === lines.has(b) &&
-        roles.layout(a) === roles.layout(b) &&
-        items.has(a) === items.has(b) &&
-        roles.table(a) === roles.table(b) &&
-        rows.has(a) === rows.has(b) &&
-        cells.has(a) === cells.has(b));
+    const { lines, items, rows, cells } = roles.declared();
+    const shape = (t) => {
+        const k = roles.of(t);
+        return JSON.stringify([
+            k.childless,
+            k.island,
+            k.container,
+            k.line,
+            lines.has(t),
+            k.layout,
+            items.has(t),
+            k.table,
+            rows.has(t),
+            cells.has(t)
+        ]);
+    };
+    return shape(a) === shape(b);
 };
 /**
  * The index's self-checks, off in production: a test lane's setup installs