edytor 2.0.0 → 4.0.0

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

@@ -5,7 +5,7 @@ import { bindText } from './text/model.js';
 import { type RunView } from './text/runs.js';
 import { type BlockAttribution } from './attribution/block.js';
 import type { JSONBlock, JSONDoc } from '../utils/json.js';
-import { assertSchema, assertUsableDoc, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion } from './doc/gate.js';
+import { assertSchema, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion } from './doc/gate.js';
 import type { EngineNode } from './engine-api.js';
 import type { ContentItem, InlineSpec, ModelView, SplitTail } from './placement/model.js';
 import type { Anchor } from './text/model.js';
@@ -14,10 +14,10 @@ import type { DocPosition } from './rangeDelete.js';
 import type { DataPatch } from './data.js';
 import type { AnchorAffinity, BlockRole, DataTarget, DocAnchor, DocChange, EdytorDocConfig, JsonObj, OpResult, OrderPolicy, Plan, PlanEffect, PlanStep, Prepared, TextRange } from './doc/types.js';
 export { SCHEMA };
-export { assertSchema, assertUsableDoc, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion };
-export { UnsupportedDocError, type SchemaProblem } from './doc/gate.js';
+export { assertSchema, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion };
+export type { SchemaProblem } from './doc/gate.js';
 export { SEED_ORIGIN } from './doc/seed.js';
-export { EdytorDocDisposedError } from './doc/funnel.js';
+export { DocumentDestroyedError } from './doc/funnel.js';
 export { DEFAULT_HISTORY_LIMIT } from './doc/history.js';
 export type { AnchorAffinity, BlockRole, DataTarget, DocAnchor, DocChange, EdytorDocConfig, OpResult, OrderPolicy, Plan, PlanEffect, PlanStep, Prepared, TextRange };
 export type EdytorDoc = ReturnType<EdytorDocBinding['create']>;
@@ -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,17 +48,17 @@
  */
 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';
 import { bindBlockAttribution, blockAttributionOf } from './attribution/block.js';
 import { rangeDeleteOps } from './rangeDelete.js';
 import { flowOps } from './flow.js';
-import { assertSchema, assertUsableDoc, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion } from './doc/gate.js';
+import { assertSchema, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion } from './doc/gate.js';
 import { bindSeed, restore } from './doc/seed.js';
 import { applied, ref } from './doc/plan.js';
 import { docReads } from './doc/reads.js';
@@ -76,27 +76,37 @@ import { metaOps } from './doc/meta.js';
 import { contentOps } from './doc/content.js';
 // ── schema manifest and gate (`doc/gate.ts`) ────────────────────────────
 export { SCHEMA };
-export { assertSchema, assertUsableDoc, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion };
-export { UnsupportedDocError } from './doc/gate.js';
+export { assertSchema, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion };
 export { SEED_ORIGIN } from './doc/seed.js';
-export { EdytorDocDisposedError } from './doc/funnel.js';
+export { DocumentDestroyedError } from './doc/funnel.js';
 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);
-        // Document-boundary check — foreign (v13-engine) and legacy-schema docs
-        // fail fast here rather than inside the runs view (see assertUsableDoc).
-        assertUsableDoc(doc);
+        adoptRules(doc);
         setMarkEdges(doc, config.markEdge ?? (() => undefined));
         const roleOf = config.roleOf ?? (() => undefined);
         const defaultType = config.defaultType ?? 'paragraph';
@@ -145,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;
@@ -365,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 {
@@ -394,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>;

package/dist/crdt/engine.js

@@ -37,16 +37,13 @@ export const Y = {
 	createIdSet: V.createIdSet,
 	diffIdSet: V.diffIdSet,
 	insertIntoIdSet: V.insertIntoIdSet,
-	// text delete marks (`text/deletes.ts`, fork patch YP11)
+	// the document's undo manager (`doc/history.ts`, fork patch YP18)
 	iterateStructsByIdSet: V.iterateStructsByIdSet,
 	getItemCleanStart: V.getItemCleanStart,
 	redoItem: V.redoItem,
-	// the document's undo manager (`doc/history.ts`, fork patch YP18)
 	keepItem: V.keepItem,
 	followRedone: V.followRedone,
 	isParentOf: V.isParentOf,
 	mergeIdSets: V.mergeIdSets,
-	// a folded delete record appended after the one it replaces
-	ContentAny: V.ContentAny,
 	createID: V.createID
 };

package/dist/crdt/flow.d.ts

@@ -21,7 +21,7 @@
  * - a `whole` flow (a block-selection copy) goes after the block, replacing
  *   it when empty (`flow.whole`); over selected blocks the lines take their
  *   slot (`flow.slot`), and at a slot they are placed with nothing replaced
- *   (`flow.place`: an accepted suggestion), all at plain ranks (`insertBlocks`: their order
+ *   (`flow.place`: an accepted suggestion), as plain inserts (`insertBlocks`: their order
  *   against a peer's split beside them is not claimed); a void
  *   takes one run (`flow.void`);
  * - a table's cell is never split: it takes the lines a flow shows, nested