edytor 4.0.0 → 5.0.0

package/dist/cloudflare/room/suggest.js

@@ -0,0 +1,143 @@
+/**
+ * The suggest-only rule (`room.access.suggest`, `sugg.room.suggest`): what a
+ * frame of a socket whose user may only suggest may write. Every struct must
+ * be a suggestion's, under a client id of that user that is not the socket's
+ * own replica (its writes are suggestion writers'):
+ *
+ * - a suggestion record (an attr of the root `suggest`), and what a record
+ *   of its user holds (its attrs, its writer's id lists and operations);
+ * - its own binding and profile (the attribution root: the trust rules
+ *   check them);
+ * - text in a block's backing text (an insertion; a split's boundary; a
+ *   merge's claim of a block its user made; a mark next to its user's own
+ *   text), and an atom's attrs of an atom its user made;
+ * - a block its user made (its registry entry, attrs, children's slots) and
+ *   a home slot naming such a block in any block's sequence;
+ * - a hold record naming only its user's units (deleting its own text).
+ *
+ * Anything else strips the client from the frame, as a forged mark does, and
+ * a delete of an item another user wrote is dropped. Residuals: a mark both of
+ * whose ends touch its user's text covers what lies between them, and its user
+ * may delete its own accepted text directly (the room reads no record's
+ * decisions). Pure reads of the room document and the frame.
+ */
+import { Y } from '../../crdt/engine.js';
+import { ATTRIBUTION_ROOT, BLOCK_NODE, CONTENT_NODE, INLINE_NODE, REGISTRY_KEY, SUGGEST_ROOT, TEXT_DELETES_ROOT } from '../../crdt/schema.js';
+import { isId } from './forged.js';
+import { heldClock, runsOf, storedStruct, structAt } from './updates.js';
+/** What a frame of a suggest-only socket may not write: the clients to strip, the deletes to drop. */
+export const suggestOnly = (doc, { structs, ds }, skip, owns, replica) => {
+    const frame = runsOf(structs);
+    const strip = new Set();
+    /** The struct at `id`, the room's or the frame's. */
+    const at = (id) => (storedStruct(doc, id.client, id.clock) ?? structAt(frame.get(id.client) ?? [], id.clock));
+    /**
+     * Where the item at `id` sits: its map key (`null` in a sequence) and its
+     * parent, read from the item or, for an encoded one that names neither,
+     * from an origin of it (left, else right: one sequence, or one key).
+     */
+    const placeIn = (id) => {
+        const seen = new Set();
+        for (let next = id; next !== null;) {
+            const held = storedStruct(doc, next.client, next.clock);
+            if (held)
+                return held instanceof Y.Item ? { key: held.parentSub, parent: held.parent } : null;
+            const item = structAt(frame.get(next.client) ?? [], next.clock);
+            if (!(item instanceof Y.Item) || seen.has(item))
+                return null;
+            seen.add(item);
+            if (item.parent !== null || item.parentSub !== null)
+                return { key: item.parentSub, parent: item.parent };
+            next = item.origin ?? item.rightOrigin;
+        }
+        return null;
+    };
+    /** The node (and its item) a place's parent names: a root's name, or a nested node's. */
+    const nodeOf = (parent) => {
+        if (typeof parent === 'string')
+            return { root: parent };
+        if (isId(parent)) {
+            const item = at(parent);
+            return { name: item?.content?.type?.name, item: item?.id };
+        }
+        const node = parent;
+        if (!node)
+            return {};
+        if (!node._item) {
+            const root = [...doc.share].find(([, type]) => type === parent)?.[0];
+            return { root };
+        }
+        return { name: node.name, item: node._item.id };
+    };
+    const registry = () => doc.share.get(REGISTRY_KEY)?._map;
+    /** A block `id` whose node a client of this user made (in the room or the frame). */
+    const ownBlock = (id) => {
+        if (typeof id !== 'string')
+            return false;
+        const stored = registry()?.get(id);
+        if (stored)
+            return owns(stored.id.client);
+        return structs.some((s) => s instanceof Y.Item &&
+            owns(s.id.client) &&
+            placeIn(s.id)?.key === id &&
+            nodeOf(placeIn(s.id)?.parent).root === REGISTRY_KEY);
+    };
+    const allowed = (s) => {
+        const place = placeIn(s.id);
+        if (place === null)
+            return false;
+        const parent = nodeOf(place.parent);
+        const value = s.content.getContent?.()[0];
+        if (parent.root === SUGGEST_ROOT || parent.root === ATTRIBUTION_ROOT)
+            return true;
+        if (parent.name === 'suggestion')
+            return !!parent.item && owns(parent.item.client);
+        if (parent.root === TEXT_DELETES_ROOT) {
+            const ids = s.content.ids ?? [];
+            return ids.every((v, i) => i % 3 !== 0 || owns(v));
+        }
+        if (parent.name === CONTENT_NODE) {
+            // A mark (a format item: its key and value).
+            if (s.content.key !== undefined) {
+                const { origin, rightOrigin } = s;
+                const near = [origin, rightOrigin];
+                return near.some((id) => isId(id) && owns(id.client));
+            }
+            return value?.m === undefined || ownBlock(value.m);
+        }
+        if (parent.name === INLINE_NODE)
+            return !!parent.item && owns(parent.item.client);
+        if (parent.root === REGISTRY_KEY) {
+            // A top-level home slot of its own block, or its own block's entry (never another's).
+            if (place.key === null)
+                return ownBlock(value?.b);
+            const stored = registry()?.get(place.key);
+            return !stored || owns(stored.id.client);
+        }
+        if (parent.name === BLOCK_NODE) {
+            if (s.content.priority !== undefined)
+                return false;
+            if (place.key === null && value?.b !== undefined)
+                return ownBlock(value.b);
+            return !!parent.item && owns(parent.item.client);
+        }
+        return false;
+    };
+    for (const s of structs) {
+        const { client, clock } = s.id;
+        if (!(s instanceof Y.Item) || skip.has(client) || strip.has(client))
+            continue;
+        if (storedStruct(doc, client, clock) !== null)
+            continue;
+        if (client === replica || !owns(client) || !allowed(s))
+            strip.add(client);
+    }
+    // Deletes of what another user wrote are dropped.
+    const deletes = Y.createIdSet();
+    for (const [client, ranges] of ds.clients)
+        if (!owns(client))
+            for (const { clock, len } of ranges.getIds())
+                if (clock < heldClock(doc, client))
+                    deletes.add(client, clock, len);
+    return { strip, deletes };
+};

package/dist/cloudflare/routeDocumentSocket.d.ts

@@ -4,15 +4,24 @@ export type DocumentNamespace = {
         fetch(request: Request): Promise<Response>;
     };
 };
+/**
+ * What a user may do in a document: `read`; `comment` (read, and comment:
+ * the room writes a thread's anchor); `suggest` (read, comment, and write
+ * suggestions, which a writer accepts or rejects); `write` (everything,
+ * deciding suggestions included).
+ */
+export type DocumentAccessLevel = 'read' | 'comment' | 'suggest' | 'write';
 /**
  * What the host verified. `userId` owns every Yjs client id the socket
  * writes under; `replica` is the client's `doc.clientID` (read it from a
  * query parameter with {@link requestedReplica}; omitted, the socket's
- * first presence entry binds it); `readOnly` refuses every write.
+ * first presence entry binds it); `access` what the user may do (default
+ * `write`; `readOnly: true` is `access: 'read'`).
  */
 export type DocumentIdentity = {
     userId: string;
     replica?: number | null;
+    access?: DocumentAccessLevel;
     readOnly?: boolean;
     /**
      * When the credential expires, ms since the epoch (a token's `exp` ×

package/dist/cloudflare/routeDocumentSocket.js

@@ -119,13 +119,15 @@ const authorized = async (request, documentId, authorize, refuse, options) => {
         return refuse(CLOSE.expired, 'expired');
     return identity;
 };
+/** What `identity` may do: its `access`, else `read` for `readOnly`, else `write`. */
+const accessOf = (identity) => identity.access ?? (identity.readOnly ? 'read' : 'write');
 /** A refusal as an HTTP status (a probe, a history request). */
 const statusOf = (code, reason) => new Response(reason, { status: PROBE_STATUS[code] ?? 403 });
 /** The verified identity as the headers the room trusts. */
 const identityHeaders = (identity) => {
     const headers = new Headers({
         [IDENTITY_HEADERS.user]: encodeURIComponent(identity.userId),
-        [IDENTITY_HEADERS.access]: identity.readOnly ? 'read' : 'write'
+        [IDENTITY_HEADERS.access]: accessOf(identity)
     });
     const replica = identity.replica ?? null;
     if (replica !== null)
@@ -173,7 +175,7 @@ async function routeHistory(request, rooms, documentId, authorize, options) {
     const identity = await authorized(request, documentId, authorize, statusOf, options);
     if (identity instanceof Response)
         return identity;
-    if ((op === 'restore' || op === 'undo') && identity.readOnly) {
+    if ((op === 'restore' || op === 'undo') && accessOf(identity) !== 'write') {
         return new Response('read-only', { status: 403 });
     }
     const headers = identityHeaders(identity);
@@ -247,7 +249,7 @@ async function routeComments(request, rooms, documentId, authorize, options) {
     const identity = await authorized(request, documentId, authorize, statusOf, options);
     if (identity instanceof Response)
         return identity;
-    if (op === 'post' && identity.readOnly)
+    if (op === 'post' && accessOf(identity) === 'read')
         return new Response('read-only', { status: 403 });
     let body = null;
     if (op === 'post') {

package/dist/components/Content.svelte

@@ -43,7 +43,15 @@
 	const placeholder = $derived(edytor.placeholderAt(id));
 
 	/** An empty content's one text (`partsOf`: a content starts with a text). */
-	const EMPTY: Segment = { kind: 'text', key: START, text: '', runs: [] };
+	const EMPTY: Segment = {
+		kind: 'text',
+		key: START,
+		text: '',
+		runs: [],
+		segOrd: 0,
+		start: 0,
+		end: 0
+	};
 
 	/** Whether this view renders an atom of `part`'s kind (its record has a snippet). */
 	const rendersAtom = (part: AtomPart) => Boolean(edytor.inlineBlocks.get(part.type)?.snippet);

package/dist/crdt/anchors.js

@@ -1,5 +1,6 @@
-/** The children index order (`childrenIndex`): rank, then id. */
-const before = (a, b) => (a.rank === b.rank ? a.id < b.id : a.rank < b.rank);
+import { bySlot } from './placement/display.js';
+/** The children list's own order (`bySlot`): rank, then id. */
+const before = (a, b) => bySlot(a, b) < 0;
 /**
  * Where an endpoint whose block `dead` vanished lands: a displayable stop next
  * to the slot `dead` (or its topmost dead ancestor) occupied. `dead === null`

package/dist/crdt/attribution/attribution.d.ts

@@ -44,6 +44,8 @@ export { ATTRIBUTION_ROOT };
  * it as bookkeeping.
  */
 export declare const ATTRIBUTION_ORIGIN: unique symbol;
+export declare const ACTOR_PREFIX = "u/";
+export declare const CLIENT_PREFIX = "c/";
 /** The stable application-level author identity (mirrors `DocumentActor`). */
 export type AttributionActor = {
     id: string;
@@ -113,6 +115,7 @@ type AttachOptions = {
  * attached with (`undefined`: a raw doc). The provider's `saved` reads it.
  */
 export declare const writerOf: (doc: EngineDoc) => string | undefined;
+export declare const sanitizeProfile: (value: unknown) => ActorProfile;
 /** The display profile of `actor`: its name and color, those it has. */
 export declare const profileOf: (actor: AttributionActor) => ActorProfile;
 /**

package/dist/crdt/attribution/attribution.js

@@ -9,8 +9,8 @@ export { ATTRIBUTION_ROOT };
  * it as bookkeeping.
  */
 export const ATTRIBUTION_ORIGIN = Symbol('edytor.attribution');
-const ACTOR_PREFIX = 'u/'; // actorId → profile records
-const CLIENT_PREFIX = 'c/'; // replica clientID → actorId records
+export const ACTOR_PREFIX = 'u/'; // actorId → profile records
+export const CLIENT_PREFIX = 'c/'; // replica clientID → actorId records
 /** The actor each attached document's replica writes for (its attribution controller's). */
 const localActors = new WeakMap();
 /**
@@ -25,7 +25,7 @@ export const writerOf = (doc) => {
         : undefined;
     return typeof bound === 'string' && bound.length > 0 ? bound : localActors.get(doc);
 };
-const sanitizeProfile = (value) => {
+export const sanitizeProfile = (value) => {
     const v = (value ?? undefined);
     const out = {};
     if (typeof v?.name === 'string')

package/dist/crdt/doc/capability.js

@@ -40,7 +40,7 @@
 import { isLiveIn } from '../placement/model.js';
 /** The capability of the facade over its reads. */
 export const docCapability = (c) => {
-    const { roles, rendersContentOf, view, blockTypeOf, childrenIds, positionOf, ancestorsOf, isVoid, isIsland, islandOf, insideIsland, holdsLayout, insideItem, isRowKind, isCellKind, displayLength } = c;
+    const { roles, view, blockTypeOf, childrenIds, positionOf, ancestorsOf, isVoid, isIsland, islandOf, insideIsland, holdsLayout, insideItem, isRowKind, isCellKind, displayLength } = c;
     // ── structural capability: one answer in advance and at execution ──
     /**
      * May `ids` be placed under `parent` (`null` = the root)? Every id is
@@ -87,7 +87,7 @@ export const docCapability = (c) => {
      * A container: a block that shows only its children — no content of
      * its own, neither void nor an island (a list, a table row, a column).
      */
-    const isContainer = (id) => !rendersContent(id) && !isVoid(id) && !isIsland(id);
+    const isContainer = (id) => roles.of(blockTypeOf(id) ?? '').container;
     /**
      * THE container rule: may a block of `kind` sit directly
      * under `parent` (`null` = the root)? A container whose default child is
@@ -109,15 +109,11 @@ export const docCapability = (c) => {
     const fits = (parent, kind) => parent === null || fitsIn(blockTypeOf(parent) ?? '', kind);
     /** `fits`, by the parent's kind (a block not written yet: `placeBeside`'s new item). */
     const fitsIn = (parentType, kind) => {
-        if (!roles.container(parentType))
+        const { container, child: item } = roles.of(parentType);
+        if (!container || item === defaultChild(null) || kind === item)
             return true;
-        const item = roles.defaultChild(parentType);
-        if (item === defaultChild(null) || kind === item)
-            return true;
-        return (kind !== undefined &&
-            roles.container(kind) &&
-            roles.defaultChild(kind) === item &&
-            rendersContentOf(item));
+        const k = kind === undefined ? undefined : roles.of(kind);
+        return k?.container === true && k.child === item && roles.of(item).rendersContent;
     };
     /**
      * `kind`, or — where a plain block (the document's default kind, or
@@ -135,7 +131,7 @@ export const docCapability = (c) => {
         if (fits(parent, kind) || (kind !== undefined && kind !== defaultChild(null)))
             return kind;
         const item = defaultChild(parent);
-        return rendersContentOf(item) ? item : kind;
+        return roles.of(item).rendersContent ? item : kind;
     };
     /** A container that goes once it loses every child: it holds no text of its own (a peer's retype can leave some, hidden: it renders none). */
     const emptiable = (id) => isContainer(id) && displayLength(id) === 0;
@@ -184,9 +180,9 @@ export const docCapability = (c) => {
         return islandFrom === islandOf(intoId, v) && !isIsland(intoId);
     };
     /** `id`'s shown kind renders its content. */
-    const rendersContent = (id) => rendersContentOf(blockTypeOf(id) ?? '');
+    const rendersContent = (id) => roles.of(blockTypeOf(id) ?? '').rendersContent;
     /** The adopted default child type under `parent` (`null` = the root). */
-    const defaultChild = (parent) => roles.defaultChild(parent === null ? null : (blockTypeOf(parent) ?? null));
+    const defaultChild = (parent) => roles.of(parent === null ? null : (blockTypeOf(parent) ?? null)).child;
     /**
      * The kind a new block copies from `id` (a split tail, a flow's tail,
      * a duplicate and each of its descendants). A type a peer's retype is

package/dist/crdt/doc/funnel.d.ts

@@ -20,7 +20,7 @@ export type FunnelContext = DocBase & DocReads & {
 /** The write funnel of one facade. */
 export declare const writeFunnel: (c: FunnelContext) => {
     write: <R>(fn: () => R) => R;
-    apply: (p: Prepared) => OpResult;
+    apply: (p: Prepared, quiet?: boolean) => OpResult;
     /** Disposal is terminal for writes. */
     dispose: () => void;
     disposed: () => boolean;

package/dist/crdt/doc/funnel.js

@@ -146,8 +146,10 @@ export const writeFunnel = (c) => {
      * and fold the result from what that transaction did. A refusal writes
      * nothing. A plan is valid only at the version it was prepared against,
      * in the same synchronous turn: applying it anywhere else throws.
+     * `quiet`: it stamps no attribution (a suggestion's writer: its content
+     * is not the block's until accepted).
      */
-    const apply = (p) => {
+    const apply = (p, quiet) => {
         if (!('writes' in p))
             return write(() => p);
         if (p.version !== runsView.version()) {
@@ -166,7 +168,8 @@ export const writeFunnel = (c) => {
                 throw error;
             }
             const folded = frame.end();
-            close(f, folded);
+            if (!quiet)
+                close(f, folded);
             return folded.wrote ? { status: 'applied', ids: p.ids } : NOOP;
         }));
     };

package/dist/crdt/doc/gate.d.ts

@@ -25,7 +25,7 @@
  * ```
  */
 import type { EngineDoc } from '../engine-api.js';
-export declare const SCHEMA_VERSION: 10;
+export declare const SCHEMA_VERSION: 11;
 export declare const SCHEMA_NAME: "edytor-doc";
 export declare const META_KEY: "meta";
 /**

package/dist/crdt/doc/history.d.ts

@@ -10,6 +10,12 @@ export declare class StackItem {
     deletes: IdSetOf;
     /** Per-view metadata (`session/history.ts`: the selections around the step). */
     readonly meta: Map<string, unknown>;
+    /**
+     * The client it was written under when that is not the replica's own (a
+     * suggestion's writer: its transaction's `writer`): it replays under it,
+     * and its records release with the history's.
+     */
+    writer?: number;
     constructor(inserts: IdSetOf, deletes: IdSetOf);
 }
 /** A step taken into a stack: added (a new step) or updated (the open one took a transaction). */

package/dist/crdt/doc/history.js

@@ -15,7 +15,7 @@
 import { getUnixTime } from 'lib0-v14/time';
 import { openSteps, ownTextIds } from '../text/model.js';
 import { readHorizon } from '../purge.js';
-import { BLOCK_NODE, CONTENT_NODE, DATA_LEAF_PREFIX, DEL_PREFIX, DOC_DATA_ROOT, HORIZON_ROOT, INLINE_NODE, LAST_CHANGED_ATTR, RELEASE_ROOT, TEXT_DELETES_ROOT, TYPE, WITHDRAW_PREFIX } from '../schema.js';
+import { BLOCK_NODE, CONTENT_NODE, DATA_LEAF_PREFIX, DEL_PREFIX, DOC_DATA_ROOT, HORIZON_ROOT, INLINE_NODE, LAST_CHANGED_ATTR, RELEASE_ROOT, SUGGEST_ROOT, TEXT_DELETES_ROOT, TYPE, WITHDRAW_PREFIX } from '../schema.js';
 import { changedUnder, collectable, collectNow, collects, dropSearchMarkers, engineOps, walkIdSet } from '../structs.js';
 import { isInitialized } from './gate.js';
 import { DocumentDestroyedError } from './funnel.js';
@@ -30,6 +30,12 @@ export class StackItem {
     deletes;
     /** Per-view metadata (`session/history.ts`: the selections around the step). */
     meta = new Map();
+    /**
+     * The client it was written under when that is not the replica's own (a
+     * suggestion's writer: its transaction's `writer`): it replays under it,
+     * and its records release with the history's.
+     */
+    writer;
     constructor(inserts, deletes) {
         this.inserts = inserts;
         this.deletes = deletes;
@@ -235,6 +241,8 @@ export class UndoManager {
                 ops.keep(item);
         });
         const step = stack.at(-1);
+        if (tr.writer)
+            step.writer = tr.writer;
         // A streamless block's own text is shared by every replica that
         // typed into it first: no step captures it, so undoing the first
         // typing removes the typing and keeps the text (and nonce).
@@ -264,60 +272,71 @@ export class UndoManager {
         const ops = this.#ops;
         const { records, withdraw, repair } = this.#rules;
         const deletedByHistory = (id) => [this.undoStack, this.redoStack].some((s) => s.some((step) => step.deletes.has(id.client, id.clock)));
-        this.doc.transact((transaction) => {
-            const tr = transaction;
-            while (stack.length > 0 && this.currStackItem === null) {
-                const step = stack.pop();
-                const restore = new Set();
-                const remove = [];
-                const held = [];
-                let changed = false;
-                ops.iterate(tr, step.inserts, (struct) => {
-                    if (!ops.isItem(struct))
-                        return;
-                    const item = ops.latest(tr, struct);
-                    // An atom the step inserted is held whole: its attrs stay with it.
-                    const atom = item.parent?._item;
-                    if (atom?.id &&
-                        isUnit(atom) &&
-                        step.inserts.has(atom.id.client, atom.id.clock))
-                        return;
-                    if (!item.deleted && this.#inScope(item))
-                        remove.push(item);
-                });
-                ops.iterate(tr, step.deletes, (struct) => {
-                    if (!ops.isItem(struct) || !this.#inScope(struct))
-                        return;
-                    // Created and deleted within the step: nothing to bring back.
-                    if (step.inserts.has(struct.id.client, struct.id.clock))
-                        return;
-                    // Text a record holds stays hidden: the record decides (removed with its node).
-                    if ((struct.holds ?? 0) > 0)
-                        return;
-                    restore.add(struct);
-                });
-                for (const item of restore)
-                    changed = ops.redo(tr, item, restore, step.inserts, deletedByHistory) !== null || changed;
-                // Children before parents: more is known when an item is judged.
-                for (let i = remove.length - 1; i >= 0; i--) {
-                    const item = remove[i];
-                    // Text the step wrote is held, never removed: a redo shows it again where it was.
-                    if (isUnit(item))
-                        held.push(item.id.client, item.id.clock, item.length);
-                    else if (!withdraw(item, step))
-                        ops.remove(tr, item);
-                    changed = true;
+        // A step written under another client replays under it, and so does its replay's step.
+        const local = this.doc.clientID;
+        const writer = stack.at(-1)?.writer;
+        this.doc.clientID = writer ?? local;
+        try {
+            this.doc.transact((transaction) => {
+                const tr = transaction;
+                tr.writer = writer;
+                while (stack.length > 0 && this.currStackItem === null) {
+                    const step = stack.pop();
+                    const restore = new Set();
+                    const remove = [];
+                    const held = [];
+                    let changed = false;
+                    ops.iterate(tr, step.inserts, (struct) => {
+                        if (!ops.isItem(struct))
+                            return;
+                        const item = ops.latest(tr, struct);
+                        // An atom the step inserted is held whole: its attrs stay with it.
+                        const atom = item.parent?._item;
+                        if (atom?.id &&
+                            isUnit(atom) &&
+                            step.inserts.has(atom.id.client, atom.id.clock))
+                            return;
+                        if (!item.deleted && this.#inScope(item))
+                            remove.push(item);
+                    });
+                    ops.iterate(tr, step.deletes, (struct) => {
+                        if (!ops.isItem(struct) || !this.#inScope(struct))
+                            return;
+                        // Created and deleted within the step: nothing to bring back.
+                        if (step.inserts.has(struct.id.client, struct.id.clock))
+                            return;
+                        // Text a record holds stays hidden: the record decides (removed with its node).
+                        if ((struct.holds ?? 0) > 0)
+                            return;
+                        restore.add(struct);
+                    });
+                    for (const item of restore)
+                        changed =
+                            ops.redo(tr, item, restore, step.inserts, deletedByHistory) !== null || changed;
+                    // Children before parents: more is known when an item is judged.
+                    for (let i = remove.length - 1; i >= 0; i--) {
+                        const item = remove[i];
+                        // Text the step wrote is held, never removed: a redo shows it again where it was.
+                        if (isUnit(item))
+                            held.push(item.id.client, item.id.clock, item.length);
+                        else if (!withdraw(item, step))
+                            ops.remove(tr, item);
+                        changed = true;
+                    }
+                    records.hold(held);
+                    this.currStackItem = changed ? step : null;
+                    if (changed)
+                        repair(step);
                 }
-                records.hold(held);
-                this.currStackItem = changed ? step : null;
-                if (changed)
-                    repair(step);
-            }
-            tr.changed.forEach((keys, node) => {
-                if (keys.has(null))
-                    dropSearchMarkers(node);
-            });
-        }, this);
+                tr.changed.forEach((keys, node) => {
+                    if (keys.has(null))
+                        dropSearchMarkers(node);
+                });
+            }, this);
+        }
+        finally {
+            this.doc.clientID = local;
+        }
         const step = this.currStackItem;
         this.currStackItem = null;
         return step;
@@ -364,7 +383,9 @@ export class UndoManager {
             const own = ops.idSet();
             for (const step of dropped)
                 walkIdSet(Y, doc, step.inserts, (st, from, to) => {
-                    if (st.parent === records && !st.deleted && st.id.client === doc.clientID)
+                    if (st.parent === records &&
+                        !st.deleted &&
+                        (st.id.client === doc.clientID || st.id.client === step.writer))
                         own.add(st.id.client, from, to - from);
                 });
             const held = ops.idSet();
@@ -464,7 +485,7 @@ export const historyRules = (Y, doc) => {
     return {
         Y,
         doc,
-        scope: [registryOf(doc), records, doc.get(DOC_DATA_ROOT)],
+        scope: [registryOf(doc), records, doc.get(DOC_DATA_ROOT), doc.get(SUGGEST_ROOT)],
         records,
         withdraw: withdrawOnUndo(doc),
         repair: repairAttrs

package/dist/crdt/doc/layout.js

@@ -12,8 +12,8 @@ export const layoutOps = (c) => {
     /** The layout kind a new layout takes: `kind` when it is one, else the only one the roles declare. */
     const layoutKind = (kind) => {
         if (kind !== undefined)
-            return roles.layout(kind) === undefined ? undefined : kind;
-        const kinds = [...roles.layoutKinds()];
+            return roles.of(kind).layout === undefined ? undefined : kind;
+        const kinds = roles.declared().layouts;
         return kinds.length === 1 ? kinds[0] : undefined;
     };
     /** A fresh empty block of `type`. */
@@ -90,7 +90,7 @@ export const layoutOps = (c) => {
             }
         }
         const wrap = layout === null ? layoutKind(kind && ref(kind)) : blockTypeOf(layout);
-        const item = wrap === undefined ? undefined : roles.layout(wrap);
+        const item = wrap === undefined ? undefined : roles.of(wrap).layout;
         if (wrap === undefined || item === undefined)
             return REFUSED;
         if (moved.some((id) => !fitsIn(item, blockTypeOf(id))))
@@ -145,14 +145,14 @@ export const layoutOps = (c) => {
         if (blocks.some((id) => isLayoutItem(id) || holdsLayout(id)))
             return REFUSED;
         const wrap = layoutKind(kind && ref(kind));
-        const item = wrap === undefined ? undefined : roles.layout(wrap);
+        const item = wrap === undefined ? undefined : roles.of(wrap).layout;
         if (wrap === undefined || item === undefined || !fits(parent, wrap))
             return REFUSED;
         if (parent !== null && (insideItem(parent, v) || isIsland(parent) || insideIsland(parent, v)))
             return REFUSED;
         if (blocks.some((id) => !fitsIn(item, blockTypeOf(id))))
             return REFUSED;
-        const fill = roles.defaultChild(item);
+        const fill = roles.of(item).child;
         if (columns > blocks.length && !fitsIn(item, fill))
             return REFUSED;
         const ordered = blocks.toSorted((a, b) => positionOf(a).index - positionOf(b).index);

package/dist/crdt/doc/meta.js

@@ -11,7 +11,7 @@ import { collides } from '../placement/model.js';
 import { ref, refused, sanitizeItem } from './plan.js';
 /** The meta ops of one facade, prepared. */
 export const metaOps = (c) => {
-    const { doc, roles, roleOf, dataNode, view, blockTypeOf, blockDataOf, childrenIds, positionOf, is, isVoid, displayLength, live, contentTarget, REFUSED, plan, attr, leavingIsland, settle, remove, atomOf, writeContent } = c;
+    const { doc, roles, roleOf, dataNode, view, blockTypeOf, blockDataOf, childrenIds, positionOf, isLines, isVoid, displayLength, live, contentTarget, REFUSED, plan, attr, leavingIsland, settle, remove, atomOf, writeContent } = c;
     /**
      * The data step of `patches` (sanitized) on a block, one of its atoms or
      * the document (`crdt/data.ts`): none when it changes nothing, `null`
@@ -80,18 +80,17 @@ export const metaOps = (c) => {
         const moved = kids.get(id) ?? [];
         // A code block retyped to an ordinary kind keeps its lines as that kind's children
         // (`leavingIsland`: never a kind that hides their text).
-        const lined = is(id, (t) => roles.line(t) !== undefined);
-        if (lined && !roles.island(type) && !roles.childless(type)) {
-            const to = roles.defaultChild(type);
+        const to = roles.of(type);
+        if (isLines(id) && !to.island && !to.childless) {
             return [
                 ...steps,
                 ...moved.flatMap((k) => {
-                    const kind = leavingIsland(id, blockTypeOf(k.id), to);
+                    const kind = leavingIsland(id, blockTypeOf(k.id), to.child);
                     return kind === undefined ? [] : attr(k.id, TYPE, kind);
                 })
             ];
         }
-        if (!roles.childless(type) || moved.length === 0 || pos === null)
+        if (!to.childless || moved.length === 0 || pos === null)
             return steps;
         // The children keep their home slots: the read shows them in the void's
         // slot (`conc.void-children`), settled for its parent.
@@ -159,7 +158,7 @@ export const metaOps = (c) => {
         if (!live(id) || (content !== undefined && !contentTarget(id)))
             return REFUSED;
         const type = value.type === undefined ? undefined : ref(value.type);
-        const toVoid = type === undefined ? isVoid(id) : roles.childless(type);
+        const toVoid = type === undefined ? isVoid(id) : roles.of(type).childless;
         if (children?.length && toVoid)
             return REFUSED;
         if (children !== undefined && collides(doc, children))