edytor 3.0.0 → 4.0.0

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

@@ -8,7 +8,7 @@ import type { AttributionActor } from '../attribution/index.js';
 import type { BlockId, BlockSpec, InlineSpec, ProjectedBlock, SplitTail } from '../placement/model.js';
 import type { Anchor } from '../text/model.js';
 import type { ContentRun } from '../text/runs.js';
-import type { DataPatch, LeafWrite } from '../data.js';
+import type { DataPatch, DataWrite } from '../data.js';
 import type { DocPosition } from '../rangeDelete.js';
 /** Structural role of a block type (plugin-side policy, resolved per op). */
 export type BlockRole = {
@@ -180,22 +180,34 @@ export type TextRange = {
 /**
  * One planned write, named by the document operation that
  * performs it — the name a hook matches. Steps carry everything
- * their write needs (ranks, marks, offsets), decided at prepare time.
+ * their write needs (places, marks, offsets), decided at prepare time; a
+ * place is a display index among a parent's children, read against the
+ * document as the step is written (the steps before it applied).
  */
 export type PlanStep = 
-/** `index`: the destination slot at prepare time, as hooks see it. */
+/** `index`: the destination slot, as hooks see it. */
+/** `split`: the split-born block of this plan whose boundary these blocks' slots take as their sort key (a paste's lines at its split). */
 {
     op: 'insertBlocks';
     parent: BlockId | null;
     index: number;
     specs: BlockSpec[];
-    ranks: string[];
-} | {
+    split?: BlockId;
+}
+/**
+ * `side`: the move record's class among the items of its origin —
+ * absent or `0`, the blocks stand after what precedes them; `1`, before
+ * what follows them (blocks leaving a block for the gap before it).
+ */
+/** `side`: the record's class at its origin (`1`: before); `at`, `part`: the block it stands at and its order there (`moveTo`). */
+ | {
     op: 'moveBlocks';
     ids: BlockId[];
     parent: BlockId | null;
     index: number;
-    ranks: string[];
+    side?: 0 | 1;
+    part?: number;
+    at?: BlockId;
 }
 /** `marks`: the blocks that get this writer's mark; `removes`: those that leave the document. */
  | {
@@ -212,7 +224,7 @@ export type PlanStep =
     newId: BlockId;
     tail: SplitTail;
     parent: BlockId | null;
-    rank: string;
+    index: number;
 }
 /** `at`/`length`: where `from`'s display lands in `into`'s. */
  | {
@@ -229,7 +241,7 @@ export type PlanStep =
 /**
  * A data patch (`crdt/data.ts`): of block `id`, of its atom `inlineId`
  * (at display `offset`), or of the document (no `id`). `ops` as asked;
- * `leaves` the attr writes they plan.
+ * `writes` the attr and slot writes they plan.
  */
  | {
     op: 'patchData';
@@ -237,7 +249,7 @@ export type PlanStep =
     inlineId?: string;
     offset?: number;
     ops: DataPatch[];
-    leaves: LeafWrite[];
+    writes: DataWrite[];
 } | {
     op: 'insertText';
     id: BlockId;

package/dist/crdt/document.d.ts

@@ -50,10 +50,9 @@
  * bootstrap-shaped is written or broadcast, so writes made raw against a
  * pending doc produce unversioned state that `sync()` then refuses (see
  * below). `local`/`hydrated` — the full surface is legal; the only
- * difference is WHO decided the content. (One exception to "nothing
- * broadcast": the actor dictionary attach publishes this replica's
- * `c/<clientID>`/`u/<actorId>` records on ANY constructed document —
- * identity metadata, not content, and outside every admission gate.)
+ * difference is WHO decided the content. (The actor dictionary's
+ * `c/<clientID>`/`u/<actorId>` records go with the replica's first write,
+ * whatever it is: a document that is only read publishes nothing.)
  *
  * ── Admission boundary ────────────────────────────────────────────
  *
@@ -324,7 +323,7 @@ export declare class EdytorDocument {
      * replicated actor dictionary (`u/` profiles, `c/` replica bindings).
      * Ordinary edits perform no attribution
      * writes — authorship lands inside the owning op's transaction as the
-     * block-level `b/<id>` record/`l` stamp. See
+     * block-level record (`blockattr` `<id>`)/`l` stamp. See
      * `src/lib/crdt/attribution/attribution.ts` for the full contract.
      * Access after teardown throws {@link DocumentDestroyedError} — same
      * lifecycle contract as {@link history}.
@@ -488,6 +487,18 @@ export declare class EdytorDocument {
      * on pending).
      */
     clearHistory: () => void;
+    /**
+     * End this session's history: the page it was edited in left for good.
+     * Every step is dropped, and what this replica deleted is released: the
+     * text its deletes hid is deleted for good now, and the room's purge
+     * removes the blocks it deleted at its next run, without waiting for the
+     * purge horizon (one small write, sent if the connection still can). A
+     * view calls it at a `pagehide` the back/forward cache keeps nothing of;
+     * a page kept there, or one that lost its connection, keeps its history.
+     * Undo starts empty afterwards. No-op while history has not attached, and
+     * on a destroyed document.
+     */
+    endHistory: () => void;
     /**
      * Local document transaction — headless edits, one undo step per call
      * (`origin`: another origin, which the document's history tracks only

package/dist/crdt/document.js

@@ -92,7 +92,7 @@ export class EdytorDocument {
      * replicated actor dictionary (`u/` profiles, `c/` replica bindings).
      * Ordinary edits perform no attribution
      * writes — authorship lands inside the owning op's transaction as the
-     * block-level `b/<id>` record/`l` stamp. See
+     * block-level record (`blockattr` `<id>`)/`l` stamp. See
      * `src/lib/crdt/attribution/attribution.ts` for the full contract.
      * Access after teardown throws {@link DocumentDestroyedError} — same
      * lifecycle contract as {@link history}.
@@ -213,9 +213,10 @@ export class EdytorDocument {
             this.awareness.setLocalStateField('user', user);
         // Attribution service — attaches after the facade (which gates
         // foreign docs) and after the actor is fixed. Publishes this
-        // replica's actor dictionary entries (`c/`+`u/`) once; ordinary
-        // edits perform no attribution work and per-block records are
-        // written inside the owning op's transaction by the facade.
+        // replica's actor dictionary entries (`c/`+`u/`) inside its first
+        // write's transaction; ordinary edits perform no attribution work
+        // and per-block records are written inside the owning op's
+        // transaction by the facade.
         this.#attributionCtl = init.attribution.attach(asEngineDoc(this.doc), {
             actor: this.actor
         });
@@ -501,6 +502,22 @@ export class EdytorDocument {
         alive(this, 'clearHistory');
         this.#_history?.clear();
     };
+    /**
+     * End this session's history: the page it was edited in left for good.
+     * Every step is dropped, and what this replica deleted is released: the
+     * text its deletes hid is deleted for good now, and the room's purge
+     * removes the blocks it deleted at its next run, without waiting for the
+     * purge horizon (one small write, sent if the connection still can). A
+     * view calls it at a `pagehide` the back/forward cache keeps nothing of;
+     * a page kept there, or one that lost its connection, keeps its history.
+     * Undo starts empty afterwards. No-op while history has not attached, and
+     * on a destroyed document.
+     */
+    endHistory = () => {
+        if (this._destroyed)
+            return;
+        this.#_history?.end();
+    };
     /**
      * Local document transaction — headless edits, one undo step per call
      * (`origin`: another origin, which the document's history tracks only

package/dist/crdt/edytor-doc.d.ts

@@ -38,6 +38,16 @@ type Layers = {
  * The per-doc facade factory over the engine `Y` (the editor's documents
  * use it directly; {@link bindDocModel} is the public binding around it).
  */
+/**
+ * Give `doc` edytor's rule — a registry value a concurrent creation replaced
+ * keeps its subtree (fork patch YP14, `keepingReplaced`) — or refuse it
+ * loudly when it has integrated updates without it: the engine decides what
+ * a replaced value keeps when it integrates, so a document that took updates
+ * under the engine's default could lose a subtree its peers keep, forever.
+ * Create it with `createDoc()` (or `createDocument`/`loadDocument`), never
+ * `new Y.Doc()`.
+ */
+export declare const adoptRules: <D extends object>(doc: D) => D;
 export declare const docFacade: <L extends Layers>(Y: EngineApi, layers: L) => (doc: EngineDoc, config?: EdytorDocConfig) => {
     /** Every op prepared: pure, a plan of named steps + its effect, or `refused`. */
     prepare: {
@@ -104,7 +114,7 @@ export declare const docFacade: <L extends Layers>(Y: EngineApi, layers: L) => (
         keep?: boolean;
         after?: readonly import("./index.js").BlockSpec[];
     } | undefined) => OpResult;
-    placeBeside: (ids: readonly string[], target: string, side: "right" | "left", kind?: string | undefined) => OpResult;
+    placeBeside: (ids: readonly string[], target: string, side: "left" | "right", kind?: string | undefined) => OpResult;
     wrapInLayout: (ids: readonly string[], kind?: string | undefined, columns?: number | undefined) => OpResult;
     splitBlock: (id: string, offset: number, newId: string, tail?: SplitTail | undefined) => OpResult;
     mergeBlocks: (fromId: string, intoId: string) => OpResult;
@@ -265,7 +275,7 @@ export declare const docFacade: <L extends Layers>(Y: EngineApi, layers: L) => (
 export declare const bindDocModel: (Y: EngineApi) => {
     /** The schema manifest constants table. */
     SCHEMA: {
-        readonly version: 6;
+        readonly version: 10;
         readonly name: "edytor-doc";
         readonly roots: {
             readonly registry: "blocks";
@@ -276,7 +286,7 @@ export declare const bindDocModel: (Y: EngineApi) => {
             readonly schema: "schema";
         };
     };
-    SCHEMA_VERSION: 6;
+    SCHEMA_VERSION: 10;
     SCHEMA_NAME: "edytor-doc";
     META_KEY: "meta";
     /** Doc-level API (no facade needed). */
@@ -349,29 +359,30 @@ export declare const bindDocModel: (Y: EngineApi) => {
             blockNodeOf: (doc: EngineDoc, id: BlockId) => EngineNode | null;
             liveNodeOf: (doc: EngineDoc, id: BlockId) => EngineNode | null;
             isLive: (doc: EngineDoc, id: BlockId) => boolean;
-            candidatesOf: (node: EngineNode) => import("./placement/model.js").PlacementCand[];
             view: (doc: EngineDoc) => ModelView;
-            resolvePlacements: (blocks: Map<BlockId, import("./placement/model.js").BlockRec>, ownerOf?: (b: BlockId) => import("./text/model.js").Owner) => Map<BlockId, import("./placement/model.js").ResolvedPlacement>;
             childrenIndex: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./placement/model.js").DisplayOwnership) => Map<BlockId | null, import("./placement/model.js").ChildSlot[]>;
             positionInView: (v: ModelView, id: BlockId) => import("./index.js").Destination | null;
             buildInline: (atom: InlineSpec) => EngineNode;
             isSelfOrDescendant: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./text/model.js").Ownership, id: BlockId, maybeAncestor: BlockId) => boolean;
-            ranksAt: (siblings: readonly {
-                rank: string;
-            }[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
-            writePlacement: (doc: EngineDoc, node: EngineNode, p: BlockId | null, r: string) => void;
+            placeBlocks: (doc: EngineDoc, v: ModelView, parent: BlockId | null, left: BlockId | null, right: BlockId | null, slots: readonly import("./placement/slots.js").BlockSlot[] | null, moved?: readonly number[] | null, side?: number, part?: number, at?: import("./placement/slots.js").Unit | null) => void;
+            moveBlocksTo: (doc: EngineDoc, v: ModelView, ids: readonly BlockId[], parent: BlockId | null, index: number, side?: number, part?: number, at?: BlockId | null) => void;
+            insertSpecsAt: (doc: EngineDoc, v: ModelView, parent: BlockId | null, index: number, specs: readonly import("./index.js").BlockSpec[], split?: import("./placement/slots.js").Unit | null) => void;
             withdrawOnUndo: (doc: EngineDoc) => (item: import("./engine-api.js").EngineItemRef, stackItem: {
                 inserts: {
                     has(client: number, clock: number): boolean;
                 };
             }) => boolean;
-            materializeSpec: (doc: EngineDoc, sp: import("./index.js").BlockSpec, parent: BlockId | null, rank: string) => void;
             collides: (doc: EngineDoc, specs: readonly import("./index.js").BlockSpec[]) => boolean;
-            writeSplit: (doc: EngineDoc, id: BlockId, offset: number, newId: BlockId, tail: SplitTail, place: import("./placement/model.js").PlacementValue) => void;
+            writeSplit: (doc: EngineDoc, id: BlockId, offset: number, newId: BlockId, tail: SplitTail, parent: BlockId | null, index: number) => import("./placement/slots.js").Unit;
             ownText: (doc: EngineDoc, id: BlockId) => {
                 from: unknown;
                 to: number;
             };
+            recordsOf: (doc: EngineDoc, node: EngineNode, v?: ModelView) => {
+                item: import("./placement/slots.js").SeqItem;
+                stamp: import("./placement/slots.js").Stamp;
+                wins: boolean;
+            }[];
             insertBlocks: (doc: EngineDoc, dest: import("./index.js").Destination, specs: import("./index.js").BlockSpec[]) => boolean;
             insertBlock: (doc: EngineDoc, dest: import("./index.js").Destination, spec: import("./index.js").BlockSpec) => boolean;
             restoreBlocks: (doc: EngineDoc, specs: import("./index.js").BlockSpec[]) => void;
@@ -403,8 +414,8 @@ export declare const bindDocModel: (Y: EngineApi) => {
                 at: number;
                 node: EngineNode;
             } | null;
-            splitAt: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, newId: import("./text/model.js").BlockId, n: number) => import("./text/model.js").MergeClaim[];
-            claimInto: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: Pick<import("./text/model.js").Ownership, "streamOf">, from: import("./text/model.js").BlockId, into: import("./text/model.js").BlockId) => void;
+            splitAt: (doc: EngineDoc, blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, newId: import("./text/model.js").BlockId, n: number) => void;
+            claimInto: (own: Pick<import("./text/model.js").Ownership, "streamOf">, from: import("./text/model.js").BlockId, into: import("./text/model.js").BlockId) => void;
             ownText: (doc: EngineDoc, rec: import("./text/model.js").TextBlockRec) => {
                 from: unknown;
                 to: number;
@@ -424,7 +435,7 @@ export declare const bindDocModel: (Y: EngineApi) => {
             keep?: boolean;
             after?: readonly import("./index.js").BlockSpec[];
         } | undefined) => OpResult;
-        placeBeside: (ids: readonly string[], target: string, side: "right" | "left", kind?: string | undefined) => OpResult;
+        placeBeside: (ids: readonly string[], target: string, side: "left" | "right", kind?: string | undefined) => OpResult;
         wrapInLayout: (ids: readonly string[], kind?: string | undefined, columns?: number | undefined) => OpResult;
         splitBlock: (id: string, offset: number, newId: string, tail?: SplitTail | undefined) => OpResult;
         mergeBlocks: (fromId: string, intoId: string) => OpResult;
@@ -584,14 +595,6 @@ export declare const bindDocModel: (Y: EngineApi) => {
      * not have integrated anything yet.
      */
     newDoc: (opts?: ConstructorParameters<EngineApi["Doc"]>[0]) => YDoc;
-    /**
-     * Keep, on `doc`, the text a replica may have to copy again: its
-     * `gcFilter` then spares a deleted copy's content, as every facade's
-     * history does. A doc that only relays updates (the room) calls it
-     * before applying anything, so what it collects and encodes matches
-     * what an editing replica keeps.
-     */
-    keepCopies: (doc: EngineDoc) => void;
     /** The bound engine layers (same instances the facades use). */
     model: {
         REGISTRY_KEY: string;
@@ -599,29 +602,30 @@ export declare const bindDocModel: (Y: EngineApi) => {
         blockNodeOf: (doc: EngineDoc, id: BlockId) => EngineNode | null;
         liveNodeOf: (doc: EngineDoc, id: BlockId) => EngineNode | null;
         isLive: (doc: EngineDoc, id: BlockId) => boolean;
-        candidatesOf: (node: EngineNode) => import("./placement/model.js").PlacementCand[];
         view: (doc: EngineDoc) => ModelView;
-        resolvePlacements: (blocks: Map<BlockId, import("./placement/model.js").BlockRec>, ownerOf?: (b: BlockId) => import("./text/model.js").Owner) => Map<BlockId, import("./placement/model.js").ResolvedPlacement>;
         childrenIndex: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./placement/model.js").DisplayOwnership) => Map<BlockId | null, import("./placement/model.js").ChildSlot[]>;
         positionInView: (v: ModelView, id: BlockId) => import("./index.js").Destination | null;
         buildInline: (atom: InlineSpec) => EngineNode;
         isSelfOrDescendant: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./text/model.js").Ownership, id: BlockId, maybeAncestor: BlockId) => boolean;
-        ranksAt: (siblings: readonly {
-            rank: string;
-        }[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
-        writePlacement: (doc: EngineDoc, node: EngineNode, p: BlockId | null, r: string) => void;
+        placeBlocks: (doc: EngineDoc, v: ModelView, parent: BlockId | null, left: BlockId | null, right: BlockId | null, slots: readonly import("./placement/slots.js").BlockSlot[] | null, moved?: readonly number[] | null, side?: number, part?: number, at?: import("./placement/slots.js").Unit | null) => void;
+        moveBlocksTo: (doc: EngineDoc, v: ModelView, ids: readonly BlockId[], parent: BlockId | null, index: number, side?: number, part?: number, at?: BlockId | null) => void;
+        insertSpecsAt: (doc: EngineDoc, v: ModelView, parent: BlockId | null, index: number, specs: readonly import("./index.js").BlockSpec[], split?: import("./placement/slots.js").Unit | null) => void;
         withdrawOnUndo: (doc: EngineDoc) => (item: import("./engine-api.js").EngineItemRef, stackItem: {
             inserts: {
                 has(client: number, clock: number): boolean;
             };
         }) => boolean;
-        materializeSpec: (doc: EngineDoc, sp: import("./index.js").BlockSpec, parent: BlockId | null, rank: string) => void;
         collides: (doc: EngineDoc, specs: readonly import("./index.js").BlockSpec[]) => boolean;
-        writeSplit: (doc: EngineDoc, id: BlockId, offset: number, newId: BlockId, tail: SplitTail, place: import("./placement/model.js").PlacementValue) => void;
+        writeSplit: (doc: EngineDoc, id: BlockId, offset: number, newId: BlockId, tail: SplitTail, parent: BlockId | null, index: number) => import("./placement/slots.js").Unit;
         ownText: (doc: EngineDoc, id: BlockId) => {
             from: unknown;
             to: number;
         };
+        recordsOf: (doc: EngineDoc, node: EngineNode, v?: ModelView) => {
+            item: import("./placement/slots.js").SeqItem;
+            stamp: import("./placement/slots.js").Stamp;
+            wins: boolean;
+        }[];
         insertBlocks: (doc: EngineDoc, dest: import("./index.js").Destination, specs: import("./index.js").BlockSpec[]) => boolean;
         insertBlock: (doc: EngineDoc, dest: import("./index.js").Destination, spec: import("./index.js").BlockSpec) => boolean;
         restoreBlocks: (doc: EngineDoc, specs: import("./index.js").BlockSpec[]) => void;
@@ -653,8 +657,8 @@ export declare const bindDocModel: (Y: EngineApi) => {
             at: number;
             node: EngineNode;
         } | null;
-        splitAt: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, newId: import("./text/model.js").BlockId, n: number) => import("./text/model.js").MergeClaim[];
-        claimInto: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: Pick<import("./text/model.js").Ownership, "streamOf">, from: import("./text/model.js").BlockId, into: import("./text/model.js").BlockId) => void;
+        splitAt: (doc: EngineDoc, blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, newId: import("./text/model.js").BlockId, n: number) => void;
+        claimInto: (own: Pick<import("./text/model.js").Ownership, "streamOf">, from: import("./text/model.js").BlockId, into: import("./text/model.js").BlockId) => void;
         ownText: (doc: EngineDoc, rec: import("./text/model.js").TextBlockRec) => {
             from: unknown;
             to: number;
@@ -671,7 +675,7 @@ export declare const bindDocModel: (Y: EngineApi) => {
 export declare const bindEdytorDoc: (Y: EngineApi) => {
     /** The schema manifest constants table. */
     SCHEMA: {
-        readonly version: 6;
+        readonly version: 10;
         readonly name: "edytor-doc";
         readonly roots: {
             readonly registry: "blocks";
@@ -682,7 +686,7 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
             readonly schema: "schema";
         };
     };
-    SCHEMA_VERSION: 6;
+    SCHEMA_VERSION: 10;
     SCHEMA_NAME: "edytor-doc";
     META_KEY: "meta";
     /** Doc-level API (no facade needed). */
@@ -755,29 +759,30 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
             blockNodeOf: (doc: EngineDoc, id: BlockId) => EngineNode | null;
             liveNodeOf: (doc: EngineDoc, id: BlockId) => EngineNode | null;
             isLive: (doc: EngineDoc, id: BlockId) => boolean;
-            candidatesOf: (node: EngineNode) => import("./placement/model.js").PlacementCand[];
             view: (doc: EngineDoc) => ModelView;
-            resolvePlacements: (blocks: Map<BlockId, import("./placement/model.js").BlockRec>, ownerOf?: (b: BlockId) => import("./text/model.js").Owner) => Map<BlockId, import("./placement/model.js").ResolvedPlacement>;
             childrenIndex: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./placement/model.js").DisplayOwnership) => Map<BlockId | null, import("./placement/model.js").ChildSlot[]>;
             positionInView: (v: ModelView, id: BlockId) => import("./index.js").Destination | null;
             buildInline: (atom: InlineSpec) => EngineNode;
             isSelfOrDescendant: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./text/model.js").Ownership, id: BlockId, maybeAncestor: BlockId) => boolean;
-            ranksAt: (siblings: readonly {
-                rank: string;
-            }[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
-            writePlacement: (doc: EngineDoc, node: EngineNode, p: BlockId | null, r: string) => void;
+            placeBlocks: (doc: EngineDoc, v: ModelView, parent: BlockId | null, left: BlockId | null, right: BlockId | null, slots: readonly import("./placement/slots.js").BlockSlot[] | null, moved?: readonly number[] | null, side?: number, part?: number, at?: import("./placement/slots.js").Unit | null) => void;
+            moveBlocksTo: (doc: EngineDoc, v: ModelView, ids: readonly BlockId[], parent: BlockId | null, index: number, side?: number, part?: number, at?: BlockId | null) => void;
+            insertSpecsAt: (doc: EngineDoc, v: ModelView, parent: BlockId | null, index: number, specs: readonly import("./index.js").BlockSpec[], split?: import("./placement/slots.js").Unit | null) => void;
             withdrawOnUndo: (doc: EngineDoc) => (item: import("./engine-api.js").EngineItemRef, stackItem: {
                 inserts: {
                     has(client: number, clock: number): boolean;
                 };
             }) => boolean;
-            materializeSpec: (doc: EngineDoc, sp: import("./index.js").BlockSpec, parent: BlockId | null, rank: string) => void;
             collides: (doc: EngineDoc, specs: readonly import("./index.js").BlockSpec[]) => boolean;
-            writeSplit: (doc: EngineDoc, id: BlockId, offset: number, newId: BlockId, tail: SplitTail, place: import("./placement/model.js").PlacementValue) => void;
+            writeSplit: (doc: EngineDoc, id: BlockId, offset: number, newId: BlockId, tail: SplitTail, parent: BlockId | null, index: number) => import("./placement/slots.js").Unit;
             ownText: (doc: EngineDoc, id: BlockId) => {
                 from: unknown;
                 to: number;
             };
+            recordsOf: (doc: EngineDoc, node: EngineNode, v?: ModelView) => {
+                item: import("./placement/slots.js").SeqItem;
+                stamp: import("./placement/slots.js").Stamp;
+                wins: boolean;
+            }[];
             insertBlocks: (doc: EngineDoc, dest: import("./index.js").Destination, specs: import("./index.js").BlockSpec[]) => boolean;
             insertBlock: (doc: EngineDoc, dest: import("./index.js").Destination, spec: import("./index.js").BlockSpec) => boolean;
             restoreBlocks: (doc: EngineDoc, specs: import("./index.js").BlockSpec[]) => void;
@@ -809,8 +814,8 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
                 at: number;
                 node: EngineNode;
             } | null;
-            splitAt: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, newId: import("./text/model.js").BlockId, n: number) => import("./text/model.js").MergeClaim[];
-            claimInto: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: Pick<import("./text/model.js").Ownership, "streamOf">, from: import("./text/model.js").BlockId, into: import("./text/model.js").BlockId) => void;
+            splitAt: (doc: EngineDoc, blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, newId: import("./text/model.js").BlockId, n: number) => void;
+            claimInto: (own: Pick<import("./text/model.js").Ownership, "streamOf">, from: import("./text/model.js").BlockId, into: import("./text/model.js").BlockId) => void;
             ownText: (doc: EngineDoc, rec: import("./text/model.js").TextBlockRec) => {
                 from: unknown;
                 to: number;
@@ -830,7 +835,7 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
             keep?: boolean;
             after?: readonly import("./index.js").BlockSpec[];
         } | undefined) => OpResult;
-        placeBeside: (ids: readonly string[], target: string, side: "right" | "left", kind?: string | undefined) => OpResult;
+        placeBeside: (ids: readonly string[], target: string, side: "left" | "right", kind?: string | undefined) => OpResult;
         wrapInLayout: (ids: readonly string[], kind?: string | undefined, columns?: number | undefined) => OpResult;
         splitBlock: (id: string, offset: number, newId: string, tail?: SplitTail | undefined) => OpResult;
         mergeBlocks: (fromId: string, intoId: string) => OpResult;
@@ -990,14 +995,6 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
      * not have integrated anything yet.
      */
     newDoc: (opts?: ConstructorParameters<EngineApi["Doc"]>[0]) => YDoc;
-    /**
-     * Keep, on `doc`, the text a replica may have to copy again: its
-     * `gcFilter` then spares a deleted copy's content, as every facade's
-     * history does. A doc that only relays updates (the room) calls it
-     * before applying anything, so what it collects and encodes matches
-     * what an editing replica keeps.
-     */
-    keepCopies: (doc: EngineDoc) => void;
     /**
      * Purge from `doc` what was deleted before `horizon` (`room.purge.what`): real deletes, inside the caller's transaction,
      * and the horizon record every history reads (`hist.purge.horizon`).
@@ -1006,7 +1003,7 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
     purge: (doc: EngineDoc, facade: {
         model: import("./placement/model.js").PlacementModel;
         text: import("./text/model.js").TextEngine;
-    }, horizon: import("./purge.js").Horizon) => import("./purge.js").PurgeReport;
+    }, horizon: import("./purge.js").Horizon | null) => import("./purge.js").PurgeReport;
     /** The purge horizon `doc` holds, or `null`. */
     horizonOf: (doc: EngineDoc) => import("./purge.js").Horizon | null;
     /**
@@ -1020,29 +1017,30 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
         blockNodeOf: (doc: EngineDoc, id: BlockId) => EngineNode | null;
         liveNodeOf: (doc: EngineDoc, id: BlockId) => EngineNode | null;
         isLive: (doc: EngineDoc, id: BlockId) => boolean;
-        candidatesOf: (node: EngineNode) => import("./placement/model.js").PlacementCand[];
         view: (doc: EngineDoc) => ModelView;
-        resolvePlacements: (blocks: Map<BlockId, import("./placement/model.js").BlockRec>, ownerOf?: (b: BlockId) => import("./text/model.js").Owner) => Map<BlockId, import("./placement/model.js").ResolvedPlacement>;
         childrenIndex: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./placement/model.js").DisplayOwnership) => Map<BlockId | null, import("./placement/model.js").ChildSlot[]>;
         positionInView: (v: ModelView, id: BlockId) => import("./index.js").Destination | null;
         buildInline: (atom: InlineSpec) => EngineNode;
         isSelfOrDescendant: (placements: Map<BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./text/model.js").Ownership, id: BlockId, maybeAncestor: BlockId) => boolean;
-        ranksAt: (siblings: readonly {
-            rank: string;
-        }[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
-        writePlacement: (doc: EngineDoc, node: EngineNode, p: BlockId | null, r: string) => void;
+        placeBlocks: (doc: EngineDoc, v: ModelView, parent: BlockId | null, left: BlockId | null, right: BlockId | null, slots: readonly import("./placement/slots.js").BlockSlot[] | null, moved?: readonly number[] | null, side?: number, part?: number, at?: import("./placement/slots.js").Unit | null) => void;
+        moveBlocksTo: (doc: EngineDoc, v: ModelView, ids: readonly BlockId[], parent: BlockId | null, index: number, side?: number, part?: number, at?: BlockId | null) => void;
+        insertSpecsAt: (doc: EngineDoc, v: ModelView, parent: BlockId | null, index: number, specs: readonly import("./index.js").BlockSpec[], split?: import("./placement/slots.js").Unit | null) => void;
         withdrawOnUndo: (doc: EngineDoc) => (item: import("./engine-api.js").EngineItemRef, stackItem: {
             inserts: {
                 has(client: number, clock: number): boolean;
             };
         }) => boolean;
-        materializeSpec: (doc: EngineDoc, sp: import("./index.js").BlockSpec, parent: BlockId | null, rank: string) => void;
         collides: (doc: EngineDoc, specs: readonly import("./index.js").BlockSpec[]) => boolean;
-        writeSplit: (doc: EngineDoc, id: BlockId, offset: number, newId: BlockId, tail: SplitTail, place: import("./placement/model.js").PlacementValue) => void;
+        writeSplit: (doc: EngineDoc, id: BlockId, offset: number, newId: BlockId, tail: SplitTail, parent: BlockId | null, index: number) => import("./placement/slots.js").Unit;
         ownText: (doc: EngineDoc, id: BlockId) => {
             from: unknown;
             to: number;
         };
+        recordsOf: (doc: EngineDoc, node: EngineNode, v?: ModelView) => {
+            item: import("./placement/slots.js").SeqItem;
+            stamp: import("./placement/slots.js").Stamp;
+            wins: boolean;
+        }[];
         insertBlocks: (doc: EngineDoc, dest: import("./index.js").Destination, specs: import("./index.js").BlockSpec[]) => boolean;
         insertBlock: (doc: EngineDoc, dest: import("./index.js").Destination, spec: import("./index.js").BlockSpec) => boolean;
         restoreBlocks: (doc: EngineDoc, specs: import("./index.js").BlockSpec[]) => void;
@@ -1074,8 +1072,8 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
             at: number;
             node: EngineNode;
         } | null;
-        splitAt: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, newId: import("./text/model.js").BlockId, n: number) => import("./text/model.js").MergeClaim[];
-        claimInto: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: Pick<import("./text/model.js").Ownership, "streamOf">, from: import("./text/model.js").BlockId, into: import("./text/model.js").BlockId) => void;
+        splitAt: (doc: EngineDoc, blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, newId: import("./text/model.js").BlockId, n: number) => void;
+        claimInto: (own: Pick<import("./text/model.js").Ownership, "streamOf">, from: import("./text/model.js").BlockId, into: import("./text/model.js").BlockId) => void;
         ownText: (doc: EngineDoc, rec: import("./text/model.js").TextBlockRec) => {
             from: unknown;
             to: number;

package/dist/crdt/edytor-doc.js

@@ -48,10 +48,10 @@
  */
 import { setMarkEdges } from './text/marks.js';
 import { keepingReplaced } from './incarnations.js';
+import { clientsOf } from './structs.js';
 import { SCHEMA } from './schema.js';
 import { bindModel, blockText, crdtId, listBlockIds, project, resolveBlock } from './placement/model.js';
 import { bindText } from './text/model.js';
-import { bindDeletes } from './text/deletes.js';
 import { bindPurge, readHorizon } from './purge.js';
 import { restoreDocument } from './restore.js';
 import { bindRuns, indexOf } from './text/runs.js';
@@ -84,15 +84,29 @@ export { DEFAULT_HISTORY_LIMIT } from './doc/history.js';
  * The per-doc facade factory over the engine `Y` (the editor's documents
  * use it directly; {@link bindDocModel} is the public binding around it).
  */
+/**
+ * Give `doc` edytor's rule — a registry value a concurrent creation replaced
+ * keeps its subtree (fork patch YP14, `keepingReplaced`) — or refuse it
+ * loudly when it has integrated updates without it: the engine decides what
+ * a replaced value keeps when it integrates, so a document that took updates
+ * under the engine's default could lose a subtree its peers keep, forever.
+ * Create it with `createDoc()` (or `createDocument`/`loadDocument`), never
+ * `new Y.Doc()`.
+ */
+export const adoptRules = (doc) => {
+    const d = doc;
+    if (d.keepReplaced == null && clientsOf(doc).size > 0)
+        throw new TypeError("edytor: this document took updates before it carried edytor's rules (create it with createDoc(), createDocument or loadDocument, not new Y.Doc())");
+    return keepingReplaced(d);
+};
 export const docFacade = (Y, layers) => {
-    const D = bindDeletes(Y);
     // Compact per-block attribution writes (`attribution/block.ts`).
     // One bound instance per engine binding; its suppression memory is
     // per-doc (WeakMap-keyed), so facades on the same doc share it.
     const BA = bindBlockAttribution(Y);
     const { init, seed } = bindSeed(Y, BA);
     return (doc, config = {}) => {
-        keepingReplaced(doc);
+        adoptRules(doc);
         setMarkEdges(doc, config.markEdge ?? (() => undefined));
         const roleOf = config.roleOf ?? (() => undefined);
         const defaultType = config.defaultType ?? 'paragraph';
@@ -141,7 +155,7 @@ export const docFacade = (Y, layers) => {
             funnel.dispose();
             events.close();
         };
-        const { createUndoManager } = docHistory({ ...base, ...funnel, D, init });
+        const { createUndoManager } = docHistory({ ...base, ...funnel, init });
         const { anchorAt, followUndo, resolveAnchor } = docAnchors(reads);
         const steps = { ...shape, ...planSteps(shape) };
         const { plan } = steps;
@@ -361,7 +375,6 @@ export const bindDocModel = (Y) => {
     const M = bindModel(Y);
     const T = bindText(Y);
     const R = bindRuns(Y);
-    const D = bindDeletes(Y);
     const { init, seed } = bindSeed(Y, bindBlockAttribution(Y));
     const create = docFacade(Y, { model: M, text: T });
     return {
@@ -390,14 +403,6 @@ export const bindDocModel = (Y) => {
          * not have integrated anything yet.
          */
         newDoc: (opts) => keepingReplaced(new Y.Doc(opts)),
-        /**
-         * Keep, on `doc`, the text a replica may have to copy again: its
-         * `gcFilter` then spares a deleted copy's content, as every facade's
-         * history does. A doc that only relays updates (the room) calls it
-         * before applying anything, so what it collects and encodes matches
-         * what an editing replica keeps.
-         */
-        keepCopies: (doc) => void D.scope(doc),
         /** The bound engine layers (same instances the facades use). */
         model: M,
         text: T,

package/dist/crdt/engine-api.d.ts

@@ -49,6 +49,10 @@ export type EngineItemRef = {
  */
 export interface EngineTransaction {
     changed?: Map<unknown, Set<string | null>>;
+    /** The visibility changes hold records made, in order: `client, clock, ±len` per item (`> 0` shown). */
+    holds?: number[];
+    /** The units whose mover changed (the fork's move records), in order: `client, clock, len` per item. */
+    moves?: number[];
 }
 /**
  * Structural minimum of the vendored `Y.Node` (v14) used by the placement
@@ -70,7 +74,28 @@ export interface EngineNode {
     forEachAttr(f: (value: unknown, key: string, node: EngineNode) => void): void;
     attrKeys(): IterableIterator<string>;
     insert(index: number, content: unknown): void;
-    delete(index: number, length?: number): void;
+    /**
+     * Delete `length` live units at `index`. With `into` (the document's
+     * records list), they are held by one record appended there instead (a
+     * delete its writer can take back), except those `fresh` names, which are
+     * removed.
+     */
+    delete(index: number, length?: number, into?: EngineNode | null, fresh?: unknown): void;
+    /** Append one hold record of `ids` (`client, clock, len` triples) to this records list: they read as deleted while it lives. */
+    hold(ids: number[]): void;
+    /**
+     * Move the units `ids` names (`client, clock, len` triples, in order) to
+     * live index `index` of this sequence: one move record there (the fork's
+     * `ContentMove`); `side` is its class among the items of its origin (`0`
+     * after, `1` before), `at` the chain it stands at for the sort of two
+     * records at one origin — the units from the root sequence down to the
+     * unit it stands at, outermost first (`null`: the first unit it names) —
+     * and `part` its order among the records standing there.
+     */
+    move(index: number, ids: number[], side?: number, part?: number, at?: ReadonlyArray<{
+        client: number;
+        clock: number;
+    }> | null): void;
 }
 /** Structural minimum of the vendored `Y.Doc`. */
 export interface EngineDoc {
@@ -98,6 +123,13 @@ export interface EngineDoc {
      */
     on(name: 'commit', f: (transaction: never) => void): void;
     off(name: 'commit', f: (transaction: never) => void): void;
+    /**
+     * Doc-level `beforeCommit` channel (the fork's) — fires once per
+     * outermost transaction, after its function returned and while the
+     * transaction is still open: a listener's writes join it.
+     */
+    on(name: 'beforeCommit', f: (transaction: never) => void): void;
+    off(name: 'beforeCommit', f: (transaction: never) => void): void;
     /** Doc destruction event — doc-scoped state must release on destroy. */
     on(name: 'destroy', f: () => void): void;
     off(name: 'destroy', f: () => void): void;

package/dist/crdt/engine.d.ts

@@ -30,7 +30,6 @@ export type EngineSymbol =
 	| 'followRedone'
 	| 'isParentOf'
 	| 'mergeIdSets'
-	| 'ContentAny'
 	| 'createID';
 
 export declare const Y: Pick<typeof V, EngineSymbol>;