edytor 1.0.0-rc.3 → 2.0.0

package/dist/crdt/doc/funnel.js

@@ -1,7 +1,15 @@
+/**
+ * The write funnel: every facade write goes through `write` (disposal and the
+ * document's writable guard), and every prepared plan through `apply` — one
+ * transaction, its result read from what the transaction wrote, and the
+ * frame's one attribution pass.
+ */
+import { blockNodeOf, buildInline, materializeSpec, ownText, view as modelView, writePlacement, writeSplit } from '../placement/model.js';
 import { ENTRY_FACET } from '../text/runs.js';
 import { AT, DEL_PREFIX, ID, LAST_CHANGED_ATTR, TYPE } from '../schema.js';
 import { writeLeaves } from '../data.js';
 import { NOOP } from './plan.js';
+import { claimInto, deleteRange, formatRangeIn, insertIntoText } from '../text/model.js';
 /**
  * Raised when a mutating facade op runs after `dispose()` — disposal is
  * terminal for writes (reads stay dead-safe: a stale handle may still be
@@ -15,21 +23,9 @@ export class EdytorDocDisposedError extends Error {
         this.name = 'EdytorDocDisposedError';
     }
 }
-/**
- * The lineage ring depth, validated — `NaN`/`Infinity`/fractional/negative
- * values would silently disable the ring's trim bound. The one check every
- * entry path (facade creation, document attach and reattach) runs.
- */
-export const lineageDepthOf = (depth) => {
-    const d = depth ?? 0;
-    if (!Number.isInteger(d) || d < 0) {
-        throw new RangeError(`lineage.depth must be a non-negative integer, got ${JSON.stringify(d)}`);
-    }
-    return d;
-};
 /** The write funnel of one facade. */
 export const writeFunnel = (c) => {
-    const { doc, M, T, runsView, dataNode, blockJSON, BA, config } = c;
+    const { doc, runsView, dataNode, BA, config } = c;
     /**
      * Terminal flag — set by `dispose()`. Mutating ops funnel through
      * `write`, so gating there covers every facade write + `transact` +
@@ -56,39 +52,14 @@ export const writeFunnel = (c) => {
     // is observed, never predicted.
     //
     // Each apply opens a frame that tracks the index's folds. When it
-    // closes, ONE pass over the facets the fold saw stamps attribution and
-    // commits lineage: a block whose registry entry was created gets
-    // its `createdBy` record; a block whose content, claims, type or data
+    // closes, ONE pass over the facets the fold saw stamps attribution: a
+    // block whose registry entry was created gets its `createdBy` record; a block whose content, claims, type or data
     // changed gets a contributor stamp; moves and delete marks stamp
     // nothing. Two intents the effects cannot name are recorded by their
     // steps: a split-born block inherits its source's contributors, and a
-    // merge survivor unions the absorbed block's. Lineage is captured
-    // before the first write for each target a step names, and committed
-    // only for targets the effects show changed, deleted or absorbed. With
-    // no configured `actor` the funnel writes no attribution at all.
+    // merge survivor unions the absorbed block's. With no configured
+    // `actor` the funnel writes no attribution at all.
     const actorOf = () => config.actor?.();
-    const lineageDepth = lineageDepthOf(config.lineageDepth);
-    /**
-     * Capture `id`'s displaced state when the current actor is NOT the `l`
-     * winner (`force`: destructive paths, where the state is lost whoever
-     * owns `l`). First capture in a frame wins — it is the pre-frame state.
-     */
-    const lineagePending = (id, force = false) => {
-        const actor = actorOf();
-        const node = M.blockNodeOf(doc, id);
-        if (lineageDepth <= 0 || actor === undefined || node === null)
-            return undefined;
-        const l = node.getAttr(LAST_CHANGED_ATTR);
-        if (!force && l === actor.id)
-            return undefined;
-        const j = blockJSON(id);
-        return { ...(typeof l === 'string' ? { a: l } : {}), by: actor.id, t: Date.now(), j };
-    };
-    const capture = (f, id, force = false) => {
-        const pending = f.lineage.has(id) ? undefined : lineagePending(id, force);
-        if (pending !== undefined)
-            f.lineage.set(id, pending);
-    };
     /** The frame's one attribution pass over the facets the fold saw it write. */
     const close = (f, folded) => {
         const actor = actorOf();
@@ -96,79 +67,72 @@ export const writeFunnel = (c) => {
             return;
         const created = new Set();
         const changed = new Set();
-        const gone = new Set(f.unions.map(([, from]) => from));
         for (const [id, facets] of folded.touched) {
-            if (facets.has(ENTRY_FACET) && M.blockNodeOf(doc, id) !== null)
+            if (facets.has(ENTRY_FACET) && blockNodeOf(doc, id) !== null)
                 created.add(id);
             else
-                for (const facet of facets) {
-                    if (facet.startsWith(DEL_PREFIX))
-                        gone.add(id);
-                    else if (![ENTRY_FACET, AT, ID, LAST_CHANGED_ATTR].includes(facet))
+                for (const facet of facets)
+                    if (!facet.startsWith(DEL_PREFIX) &&
+                        ![ENTRY_FACET, AT, ID, LAST_CHANGED_ATTR].includes(facet))
                         changed.add(id);
-                }
         }
         for (const id of created) {
-            const node = M.blockNodeOf(doc, id);
+            const node = blockNodeOf(doc, id);
             if (node !== null)
                 BA.stampCreated(doc, node, id, actor.id, f.inherit.get(id));
         }
         for (const id of changed) {
-            const node = created.has(id) ? null : M.blockNodeOf(doc, id);
+            const node = created.has(id) ? null : blockNodeOf(doc, id);
             if (node !== null)
                 BA.stampChange(doc, node, id, actor.id);
         }
         for (const [into, from] of f.unions)
             BA.unionContributors(doc, into, from);
-        for (const [id, pending] of f.lineage) {
-            if (changed.has(id) || gone.has(id))
-                BA.appendLineage(doc, id, pending, lineageDepth);
-        }
     };
     /**
      * A streamless block gets its own text before the first write that
-     * needs a stream (`M.ownText`: a writer derived from its dead
+     * needs a stream (`ownText`: a writer derived from its dead
      * incarnation); its attribution record follows the re-minted nonce.
      */
     const needStream = (id) => {
-        if ((M.view(doc).own.display(id) ?? []).length > 0)
+        if ((modelView(doc).own.display(id) ?? []).length > 0)
             return;
-        const { from, to } = M.ownText(doc, id);
+        const { from, to } = ownText(doc, id);
         BA.retarget(doc, id, from, to);
     };
     /** One planned step, written (the plan decided it; writers never refuse). */
     const writeStep = (w, f) => {
         // Structural steps need no view: delete marks and placements write one node.
         if (w.op === 'deleteBlock')
-            return w.marks.forEach((id) => M.blockNodeOf(doc, id).setAttr(DEL_PREFIX + doc.clientID, true));
+            return w.marks.forEach((id) => blockNodeOf(doc, id).setAttr(DEL_PREFIX + doc.clientID, true));
         if (w.op === 'splitBlock' || w.op === 'insertText' || w.op === 'insertInline')
             needStream(w.id);
-        const { blocks, own } = M.view(doc);
-        const node = (id) => M.blockNodeOf(doc, id);
+        const { blocks, own } = modelView(doc);
+        const node = (id) => blockNodeOf(doc, id);
         switch (w.op) {
             case 'insertBlocks':
-                return w.specs.forEach((sp, i) => M.materializeSpec(doc, sp, w.parent, w.ranks[i]));
+                return w.specs.forEach((sp, i) => materializeSpec(doc, sp, w.parent, w.ranks[i]));
             case 'moveBlocks':
-                return w.ids.forEach((id, i) => M.writePlacement(doc, node(id), w.parent, w.ranks[i]));
+                return w.ids.forEach((id, i) => writePlacement(doc, node(id), w.parent, w.ranks[i]));
             case 'splitBlock':
                 f.inherit.set(w.newId, w.id);
-                return M.writeSplit(doc, w.id, w.offset, w.newId, w.tail, { p: w.parent, r: w.rank });
+                return writeSplit(doc, w.id, w.offset, w.newId, w.tail, { p: w.parent, r: w.rank });
             case 'mergeBlocks':
                 f.unions.push([w.into, w.from]);
-                return T.claimInto(blocks, own, w.from, w.into);
+                return claimInto(blocks, own, w.from, w.into);
             case 'setBlockType':
                 return void node(w.id).setAttr(TYPE, w.type);
             case 'patchData':
                 return writeLeaves(dataNode(w.id, w.inlineId), w.leaves);
             case 'insertText':
-                return T.insertIntoText(doc, blocks, own, w.id, w.offset, w.text, w.marks);
+                return insertIntoText(doc, blocks, own, w.id, w.offset, w.text, w.marks);
             case 'insertInline':
-                return T.insertIntoText(doc, blocks, own, w.id, w.offset, M.buildInline(w.atom));
+                return insertIntoText(doc, blocks, own, w.id, w.offset, buildInline(w.atom));
             case 'deleteText':
             case 'removeInline':
-                return T.deleteRange(doc, blocks, own, w.id, w.offset, 'length' in w ? w.length : 1);
+                return deleteRange(doc, blocks, own, w.id, w.offset, 'length' in w ? w.length : 1);
             case 'formatRange':
-                return T.formatRangeIn(doc, blocks, own, w.id, w.offset, w.length, w.marks);
+                return formatRangeIn(doc, blocks, own, w.id, w.offset, w.length, w.marks);
         }
     };
     /**
@@ -185,20 +149,8 @@ export const writeFunnel = (c) => {
         }
         return write(() => doc.transact(() => {
             const frame = runsView.track();
-            const f = { lineage: new Map(), inherit: new Map(), unions: [] };
+            const f = { inherit: new Map(), unions: [] };
             try {
-                // Lineage captures every target's pre-write state before the
-                // first write; destructive steps capture whoever owns `l`.
-                for (const w of p.writes) {
-                    if (w.op === 'deleteBlock')
-                        capture(f, w.id, true);
-                    else if (w.op === 'mergeBlocks') {
-                        capture(f, w.from, true);
-                        capture(f, w.into);
-                    }
-                    else if ('id' in w && w.id !== undefined)
-                        capture(f, w.id);
-                }
                 for (const w of p.writes)
                     writeStep(w, f);
             }
@@ -215,9 +167,6 @@ export const writeFunnel = (c) => {
     return {
         write,
         apply,
-        actorOf,
-        lineageDepth,
-        lineagePending,
         /** Disposal is terminal for writes. */
         dispose: () => {
             disposed = true;

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

@@ -25,7 +25,7 @@
  * ```
  */
 import type { EngineDoc } from '../engine-api.js';
-export declare const SCHEMA_VERSION: 5;
+export declare const SCHEMA_VERSION: 6;
 export declare const SCHEMA_NAME: "edytor-doc";
 export declare const META_KEY: "meta";
 /**
@@ -87,20 +87,19 @@ export declare class SchemaMismatchError extends Error {
  */
 export declare const assertSchema: (doc: EngineDoc, docName?: string) => void;
 /**
- * Error raised by {@link assertUsableDoc} — the doc cannot host a v14 facade.
- * `kind` distinguishes a foreign engine object (a real v13 `yjs` Doc — a
- * different CRDT implementation entirely) from a v14 doc that decodes the
- * legacy v13 Edytor schema (applied v13 update rows awaiting migration).
+ * Error raised by {@link assertUsableDoc} — the doc cannot host a v14 facade:
+ * a foreign engine object (a v13 `yjs` Doc — a different CRDT implementation
+ * entirely).
  */
 export declare class UnsupportedDocError extends Error {
-    readonly kind: 'foreign' | 'legacy';
-    constructor(kind: 'foreign' | 'legacy');
+    readonly kind: 'foreign';
+    constructor(kind: 'foreign');
 }
 /**
  * Document-boundary guard run by {@link EdytorDocBinding.create} before the
  * runs view attaches. The facade only speaks the v14 unified-node surface —
  * without this gate a foreign doc dies obscurely inside `buildView`
- * (`registry.forEachAttr is not a function`), and a legacy-schema doc would be
- * silently misread. Both fail fast with an actionable error instead.
+ * (`registry.forEachAttr is not a function`); it fails fast with an
+ * actionable error instead.
  */
 export declare const assertUsableDoc: (doc: EngineDoc) => void;

package/dist/crdt/doc/gate.js

@@ -1,5 +1,4 @@
 import { isNodeLike, SCHEMA } from '../schema.js';
-import { isLegacyDoc } from '../migration/legacy-schema.js';
 export const SCHEMA_VERSION = SCHEMA.version;
 export const SCHEMA_NAME = SCHEMA.name;
 export const META_KEY = SCHEMA.roots.meta;
@@ -75,21 +74,15 @@ export const assertSchema = (doc, docName = 'doc') => {
         throw new SchemaMismatchError(docName, problem);
 };
 /**
- * Error raised by {@link assertUsableDoc} — the doc cannot host a v14 facade.
- * `kind` distinguishes a foreign engine object (a real v13 `yjs` Doc — a
- * different CRDT implementation entirely) from a v14 doc that decodes the
- * legacy v13 Edytor schema (applied v13 update rows awaiting migration).
+ * Error raised by {@link assertUsableDoc} — the doc cannot host a v14 facade:
+ * a foreign engine object (a v13 `yjs` Doc — a different CRDT implementation
+ * entirely).
  */
 export class UnsupportedDocError extends Error {
     kind;
     constructor(kind) {
-        super(kind === 'legacy'
-            ? 'Document carries the legacy v13 Edytor schema (`content` root) — ' +
-                'migrate it via `crdt.migration` before attaching an editor.'
-            : 'Document is not a v14 engine doc — the `blocks` registry is not a ' +
-                'unified Y.Node. Use `crdt.createDoc()` (or `new Y.Doc()` from ' +
-                '`edytor/crdt`); a v13 `yjs` Doc must be migrated via ' +
-                '`crdt.migration` (from its stored updates), not passed to the runtime.');
+        super('Document is not a v14 engine doc — the `blocks` registry is not a ' +
+            'unified Y.Node. Use `crdt.createDoc()` (or `new Y.Doc()` from `edytor/crdt`).');
         this.kind = kind;
         this.name = 'UnsupportedDocError';
     }
@@ -98,8 +91,8 @@ export class UnsupportedDocError extends Error {
  * Document-boundary guard run by {@link EdytorDocBinding.create} before the
  * runs view attaches. The facade only speaks the v14 unified-node surface —
  * without this gate a foreign doc dies obscurely inside `buildView`
- * (`registry.forEachAttr is not a function`), and a legacy-schema doc would be
- * silently misread. Both fail fast with an actionable error instead.
+ * (`registry.forEachAttr is not a function`); it fails fast with an
+ * actionable error instead.
  */
 export const assertUsableDoc = (doc) => {
     let registry;
@@ -112,7 +105,4 @@ export const assertUsableDoc = (doc) => {
     if (!isNodeLike(registry) || typeof registry.forEachAttr !== 'function') {
         throw new UnsupportedDocError('foreign');
     }
-    if (isLegacyDoc(doc)) {
-        throw new UnsupportedDocError('legacy');
-    }
 };

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

@@ -1,27 +1,100 @@
-/**
- * The document's history: the undo manager every view's history is (scope,
- * text delete marks, withdrawn creations, the attr repair, the step limit and
- * the purge horizon, lineage for undo and redo).
- */
-import type { EngineApi, EngineDoc, YUndoManager } from '../engine-api.js';
+import type { EngineApi, EngineDoc, EngineNode } from '../engine-api.js';
 import type { TextDeletes } from '../text/deletes.js';
-import type { BlockAttributionApi } from '../attribution/block.js';
+import { type IdSetOf, type StoreStruct } from '../structs.js';
 import { type WriteFunnel } from './funnel.js';
 import type { DocBase } from './reads.js';
 /** The undo steps a document's history keeps by default: older ones are released. */
 export declare const DEFAULT_HISTORY_LIMIT = 200;
+/** One undo or redo step: what its transactions inserted and deleted, and what the views keep on it. */
+export declare class StackItem {
+    inserts: IdSetOf;
+    deletes: IdSetOf;
+    /** Per-view metadata (`session/history.ts`: the selections around the step). */
+    readonly meta: Map<string, unknown>;
+    constructor(inserts: IdSetOf, deletes: IdSetOf);
+}
+/** A step taken into a stack: added (a new step) or updated (the open one took a transaction). */
+export type StepEvent = {
+    stackItem: StackItem;
+    origin: unknown;
+    type: 'undo' | 'redo';
+};
+export type HistoryOptions = {
+    /** The origins whose transactions are captured (by identity, or by constructor). Default `{ null }`. */
+    trackedOrigins?: Set<unknown>;
+    /** Transactions closer together than this many milliseconds merge into one step. Default 500. */
+    captureTimeout?: number;
+    /** The undo steps kept; older ones are released. Default {@link DEFAULT_HISTORY_LIMIT}. */
+    limit?: number;
+    /** Whether a tracked transaction is captured at all. Default: every one. */
+    captureTransaction?: (tr: {
+        local?: boolean;
+        origin?: unknown;
+    }) => boolean;
+};
+/** What a history is made over: the document and the rules of its replay. */
+type Rules = {
+    Y: EngineApi;
+    doc: EngineDoc;
+    scope: EngineNode[];
+    /** The text delete marks' restore and apply rules (`text/deletes.ts`). */
+    marks: {
+        restoreFilter(item: unknown): boolean;
+        onApply(tr: unknown, step: StackItem): void;
+    };
+    /** Whether an item a replay would delete is withdrawn instead (`hist.undo.withdraw`). */
+    withdraw(item: StoreStruct, step: StackItem): boolean;
+    /** Repair the attrs a replay left undefined. */
+    repair(step: StackItem): void;
+};
+/**
+ * A document's undo manager: the undo and redo stacks of the tracked local
+ * transactions in its scope. `undo()`/`redo()` replay the top step and
+ * return it (`null`: nothing changed); `stopCapturing()` closes the open
+ * step; `clear()` drops every step and releases what they kept.
+ */
+export declare class UndoManager {
+    #private;
+    undoStack: StackItem[];
+    redoStack: StackItem[];
+    /** Whether an `undo()` is replaying (its transaction is captured into the redo stack). */
+    undoing: boolean;
+    redoing: boolean;
+    /** The step a replay applies, while its transaction runs. */
+    currStackItem: StackItem | null;
+    /** When the open step last took a transaction (ms since the epoch; 0: no open step). */
+    lastChange: number;
+    captureTimeout: number;
+    readonly trackedOrigins: Set<unknown>;
+    captureTransaction: (tr: {
+        local?: boolean;
+        origin?: unknown;
+    }) => boolean;
+    readonly limit: number;
+    readonly doc: EngineDoc;
+    constructor(rules: Rules, options?: HistoryOptions);
+    /** Be told of every step taken into a stack (added, or the open one updated). Returns the unsubscribe. */
+    observe(f: (event: StepEvent, added: boolean) => void): () => void;
+    /** The next transaction starts a step of its own. */
+    stopCapturing(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    /** Replay the top undo step; the step, or `null` when nothing changed. */
+    undo(): StackItem | null;
+    /** Replay the top redo step; the step, or `null` when nothing changed. */
+    redo(): StackItem | null;
+    /** Drop every step (undo and redo) and release what they kept for their replay. */
+    clear(): void;
+    destroy: () => void;
+}
 /** What a facade's history is made over: its doc, the write funnel and the bound engine layers. */
-export type HistoryContext = DocBase & Pick<WriteFunnel, 'write' | 'disposed' | 'actorOf' | 'lineageDepth' | 'lineagePending'> & {
+export type HistoryContext = DocBase & Pick<WriteFunnel, 'write' | 'disposed'> & {
     D: TextDeletes;
-    BA: BlockAttributionApi;
-    /** Each history's release of all its steps (`releaseHistory`). */
-    releasers: WeakMap<YUndoManager, () => void>;
     /** Stamp the version record before the history attaches. */
     init: (doc: EngineDoc) => void;
 };
 /** The history factory of one facade. */
 export declare const docHistory: (c: HistoryContext) => {
-    createUndoManager: (options?: ConstructorParameters<EngineApi["UndoManager"]>[1] & {
-        limit?: number;
-    }) => YUndoManager;
+    createUndoManager: (options?: HistoryOptions) => UndoManager;
 };
+export {};