edytor 1.0.0-rc.2 → 1.0.0

package/dist/components/Text.svelte

@@ -1,9 +1,10 @@
 <script lang="ts">
 	import { getContext } from 'svelte';
 	import type { Edytor } from '../edytor.svelte.js';
-	import type { RenderDelta } from '../surface/cells.js';
+	import { rendersMark, type RenderDelta } from '../surface/cells.js';
 	import { Text } from '../text/text.svelte.js';
-	import Mark from './Mark.svelte';
+	import Mark, { customAt } from './Mark.svelte';
+	import CustomMark from './CustomMark.svelte';
 
 	/**
 	 * One segment of a cell: its render deltas, the empty filler, the
@@ -53,11 +54,39 @@
 		`${index}:${JSON.stringify(delta.marks)}`;
 	/**
 	 * An empty text renders the filler as its first unmarked delta: the same
-	 * keyed item, so the first character typed or composed into an empty
+	 * text node, so the first character typed or composed into an empty
 	 * block lands in the node the browser (and the IME) already holds.
 	 */
 	const FILLER: readonly RenderDelta[] = [{ text: '\u200B', marks: [] }];
 
+	/** A delta's marks this view renders (an unknown mark renders its text only). */
+	const rendered = (delta: RenderDelta): RenderDelta => {
+		const known = delta.marks.filter(([name]) => rendersMark(edytor.marks, name));
+		return known.length === delta.marks.length ? delta : { text: delta.text, marks: known };
+	};
+	const shown = $derived(empty ? FILLER : deltas);
+	/**
+	 * The first delta's text when it is unmarked: the element's own first
+	 * text node, never re-created while the text starts unmarked (a plain
+	 * text is this node and two anchors: none per delta, `render.markers`).
+	 * A text that starts marked has no such node: an empty text node before
+	 * its first mark would be a caret position of its own, outside the mark
+	 * (a DOM caret there survives a render that re-creates the mark).
+	 */
+	const head = $derived(shown[0] && !shown[0].marks.length ? shown[0].text : null);
+	/**
+	 * The deltas after it, keyed by position and marks, then the trailing
+	 * newline's marker (`delta: null`): one keyed list.
+	 */
+	const tail = $derived.by(() => {
+		const from = head === null ? 0 : 1;
+		const items: { key: string; delta: RenderDelta | null }[] = [];
+		for (let index = from; index < shown.length; index++)
+			items.push({ key: getDeltaKey(shown[index]!, index), delta: rendered(shown[index]!) });
+		if (newline) items.push({ key: 'newline', delta: null });
+		return items;
+	});
+
 	/** A plain click (no drag, no Shift, a single press) places the caret at the pointer. */
 	const restoreTextSelectionFromClick = (node: HTMLElement) => {
 		let pointerStart: { clientX: number; clientY: number } | null = null;
@@ -93,24 +122,29 @@
 	data-placeholder={placeholder ?? undefined}
 	data-edytor-composition-rest={rest || undefined}
 	style:white-space="break-spaces"
-	><!--
-	-->{#each empty ? FILLER : deltas as delta, index (getDeltaKey(delta, index))}<!--
--->{#if delta.marks.length}<!--
+	>{#if head !== null}{head}{/if}<!--
+	-->{#each tail as item (item.key)}<!--
+-->{#if item.delta === null}<!--
+--><span
+				class="newline"
+				data-edytor-trailing-newline>&#8203;</span
+			><!--
+-->{:else if customAt(edytor, item.delta, 0)}<!--
+--><CustomMark
+				delta={item.delta}
+				index={0}
+				{text}
+			/><!--
+-->{:else if item.delta.marks.length}<!--
 --><Mark
-				{delta}
+				delta={item.delta}
 				index={0}
 				{text}
 			/><!--
 -->{:else}<!--
--->{delta.text}<!--
+-->{item.delta.text}<!--
 -->{/if}<!--
 -->{/each}<!--
--->{#if newline}<!--
---><span
-			class="newline"
-			data-edytor-trailing-newline>&#8203;</span
-		><!--
--->{/if}<!--
 --></span
 >
 

package/dist/components/Text.svelte.d.ts

@@ -1,4 +1,4 @@
-import type { RenderDelta } from '../surface/cells.js';
+import { type RenderDelta } from '../surface/cells.js';
 import { Text } from '../text/text.svelte.js';
 type $$ComponentProps = {
     text: Text | undefined;

package/dist/crdt/admission.d.ts

@@ -5,8 +5,7 @@
  * gate here, in the same order, with the same refusal semantics:
  *
  *   1. **`assertUsableDoc`** — is this a v14 engine doc at all
- *      ({@link UnsupportedDocError} `'foreign'`), and is it a v13-era
- *      layout that must be migrated rather than adopted (`'legacy'`)?
+ *      ({@link UnsupportedDocError} `'foreign'`)?
  *   2. **`assertSchema`** — does the committed schema manifest allow
  *      this build to own the doc ({@link SchemaMismatchError}:
  *      `'unversioned'` content with no version stamp, `'unsupported'`
@@ -43,8 +42,6 @@
  *                             from the engine's pending store         pending store discarded; a
  *                                                                      stamp that got in anyway (raw
  *                                                                      apply) makes the doc read-only
- *   v13 migration             `bindLegacyReader` gate → rebuild via    legacy DB byte-identical; no
- *                             document-level `init` → `loadDocument`   v14 generation activated
  *
  * TWO LAYERS. The transport layer (`providers/*`, `protocols/*`) proves
  * the generation of every frame and container and refuses updates that
@@ -108,8 +105,6 @@ export declare class UndecodableUpdateError extends Error {
  * - {@link UnsupportedDocError} `'foreign'` — not a v14 engine doc
  *   (foreign roots/engines may still attach *content* later; this is
  *   about doc shape);
- * - {@link UnsupportedDocError} `'legacy'` — v13-era layout present;
- *   route through `crdt/migration` instead of attaching;
  * - {@link SchemaMismatchError} `'unversioned' | 'unsupported' |
  *   'foreign'` — a schema claim this build cannot own.
  *
@@ -137,9 +132,7 @@ export declare const bindAdmission: (Y: EngineApi) => {
      * Throws {@link UndecodableUpdateError} for payloads that fail to
      * decode/integrate at all, then the usual typed refusals.
      */
-    admitUpdate: (update: Uint8Array | ReadonlyArray<Uint8Array | {
-        v2: Uint8Array;
-    }>, docName?: string, options?: {
+    admitUpdate: (update: Uint8Array | ReadonlyArray<Uint8Array>, docName?: string, options?: {
         /** Prepare the scratch doc before anything is applied (e.g. its `gcFilter`). */
         prepare?: (doc: YDoc) => void;
     }) => YDoc;

package/dist/crdt/admission.js

@@ -5,8 +5,7 @@
  * gate here, in the same order, with the same refusal semantics:
  *
  *   1. **`assertUsableDoc`** — is this a v14 engine doc at all
- *      ({@link UnsupportedDocError} `'foreign'`), and is it a v13-era
- *      layout that must be migrated rather than adopted (`'legacy'`)?
+ *      ({@link UnsupportedDocError} `'foreign'`)?
  *   2. **`assertSchema`** — does the committed schema manifest allow
  *      this build to own the doc ({@link SchemaMismatchError}:
  *      `'unversioned'` content with no version stamp, `'unsupported'`
@@ -43,8 +42,6 @@
  *                             from the engine's pending store         pending store discarded; a
  *                                                                      stamp that got in anyway (raw
  *                                                                      apply) makes the doc read-only
- *   v13 migration             `bindLegacyReader` gate → rebuild via    legacy DB byte-identical; no
- *                             document-level `init` → `loadDocument`   v14 generation activated
  *
  * TWO LAYERS. The transport layer (`providers/*`, `protocols/*`) proves
  * the generation of every frame and container and refuses updates that
@@ -92,8 +89,6 @@ export class UndecodableUpdateError extends Error {
  * - {@link UnsupportedDocError} `'foreign'` — not a v14 engine doc
  *   (foreign roots/engines may still attach *content* later; this is
  *   about doc shape);
- * - {@link UnsupportedDocError} `'legacy'` — v13-era layout present;
- *   route through `crdt/migration` instead of attaching;
  * - {@link SchemaMismatchError} `'unversioned' | 'unsupported' |
  *   'foreign'` — a schema claim this build cannot own.
  *
@@ -138,10 +133,9 @@ export const bindAdmission = (Y) => ({
     admitUpdate: (update, docName = 'loaded document', options = {}) => {
         const doc = keepingReplaced(new Y.Doc());
         options.prepare?.(doc);
-        const apply = (part) => part instanceof Uint8Array ? Y.applyUpdate(doc, part) : Y.applyUpdateV2(doc, part.v2);
+        const apply = (part) => Y.applyUpdate(doc, part);
         try {
-            // Several updates (`{ v2 }`: in the v2 encoding) are applied in one
-            // transaction, with no merge pass.
+            // Several updates are applied in one transaction, with no merge pass.
             if (update instanceof Uint8Array)
                 apply(update);
             else

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

@@ -1,6 +1,5 @@
 /**
- * Legacy attribution surface: actor dictionary + inert reads over
- * pre-existing per-edit records.
+ * Attribution surface: the actor dictionary and the per-block records.
  *
  * The per-edit capture pipeline of earlier builds (immutable `a/<nonce>/<seq>` ContentMap records
  * written in a follow-up transaction per committed edit, projected onto
@@ -23,25 +22,15 @@
  *   also travel inside `encode()` output, so `loadDocument` restores the
  *   dictionary without republishing.
  *
- *   LEGACY RECORDS — documents saved by pre-U2 builds carry `a/` records
- *   under the same root. They are plain replicated state: preserved
- *   verbatim by `encode()`/sync and readable through `legacy()`, which
- *   decodes and merges them with the native `decodeContentMap` codecs.
- *   This build never writes new `a/` records; old replicas that still do
- *   simply append more keys — reads stay total and convergence is the
- *   ordinary attribute-record merge.
- *
- *   RETENTION — `a/` state is retained as long as it exists in the
- *   document (no GC of the records themselves); `live()`/renderer
- *   projections are gone, and the engine no longer ships concrete
- *   renderers (fork patch YP8, UPSTREAM.md) — consumers that need a rendered view over
- *   legacy records implement the engine's `AbstractRenderer` over the
- *   `ContentMap` `legacy()` returns and pass it to `toDelta({renderer})`.
+ *   LEGACY RECORDS — documents saved by early builds carry `a/` per-edit
+ *   records under the same root. They are plain replicated state, preserved
+ *   verbatim by `encode()`/sync (no GC of the records themselves); nothing
+ *   reads them. This build never writes new `a/` records; old replicas that
+ *   still do simply append more keys — convergence is the ordinary
+ *   attribute-record merge.
  */
 import type { EngineApi, EngineDoc } from '../engine-api.js';
-import type * as Engine from '../vendor/yjs/dts/index.js';
 import { ATTRIBUTION_ROOT } from '../schema.js';
-import { type JSONBlock } from '../../utils/json.js';
 import { type BlockAttribution } from './block.js';
 /** Reserved replicated root for all attribution metadata (`SCHEMA.roots.attribution`). */
 export { ATTRIBUTION_ROOT };
@@ -63,7 +52,7 @@ export type ActorProfile = {
     color?: string;
 };
 /**
- * The document-level attribution surface. `actors`/`actorOf`/`legacy`
+ * The document-level attribution surface. `actors`/`actorOf`/`block`
  * read replicated doc state directly — they resolve remote-applied
  * records identically and stay correct as old replicas append records.
  */
@@ -78,16 +67,6 @@ export type DocumentAttribution = {
      * actor id; only the resolvable profile changes.
      */
     setProfile(profile: ActorProfile): void;
-    /**
-     * Merged read over the pre-existing `a/` records written by the
-     * retired per-edit capture pipeline: `{inserts, deletes}` IdMaps in
-     * the native ContentMap shape, decoded fresh per call. Returns `null`
-     * when the document carries no legacy records. For a rendered history
-     * view, implement the engine's `AbstractRenderer` over it (the engine
-     * ships no concrete renderer); the ordinary
-     * runs/projection surface does not consult it.
-     */
-    legacy(): Engine.ContentMap | null;
     /**
      * Compact per-block attribution for `blockId`
      * (`{createdBy, contributors, lastChangedBy}` — durable actor ids,
@@ -103,48 +82,6 @@ export type DocumentAttribution = {
      * present it as "written by" for visible text.
      */
     block(blockId: string): BlockAttribution | undefined;
-    /**
-     * Opt-in bounded lineage ring for `blockId` — the block's subtree
-     * snapshots captured just BEFORE displacing events: another actor's
-     * first write (an `l` handoff), a delete, or an undo/redo touching the
-     * block. Oldest → newest, capped at the document's configured
-     * `lineage.depth`; `undefined` when the block carries no record (and
-     * empty when the feature is off or nothing has been displaced yet).
-     *
-     * The cap is enforced HERE, at read: concurrent appends under
-     * partition can transiently store `depth + n` entries (the
-     * append-side trim only sees the writer's own ring) until the
-     * replicated watermark trim converges the stored ring — this view
-     * never returns more than `depth`. A replica configured `depth: 0`
-     * (writes off) instead sees the ring's own retention bound — the
-     * deepest depth any surviving entry's writer used.
-     *
-     * Each entry's `block` is a deep-copied `JSONBlock` — restoring an
-     * entry is an ordinary `setBlock`-class edit (which itself lands a
-     * new entry, displacing the state it overwrote). Entries on a dead
-     * block stay readable here — the record survives deletion — but a
-     * reincarnated block id starts a FRESH ring: old history never
-     * contaminates the new incarnation.
-     */
-    history(blockId: string): BlockLineageEntry[] | undefined;
-};
-/** A public lineage entry — the expanded form of the compact wire record. */
-export type BlockLineageEntry = {
-    /** The displaced owner (absent when the block was unattributed at capture). */
-    actor?: string;
-    /** The actor whose edit displaced the state (or whose undo/redo touched the block). */
-    by: string;
-    /**
-     * Ring position at append — a display aid only. It can REPEAT (a trim
-     * rewinds the position counter, and concurrent replicas assign the
-     * same position independently): never an entry id — array order is
-     * the truth.
-     */
-    seq: number;
-    /** Wall-clock capture time — display only, never ordering. */
-    time?: number;
-    /** The displaced subtree snapshot (deep-copied — safe to keep/mutate). */
-    block: JSONBlock;
 };
 export type AttributionController = {
     /** The public read surface handed to `EdytorDocument.attribution`. */
@@ -157,13 +94,15 @@ export type AttributionController = {
 type AttachOptions = {
     actor: AttributionActor;
 };
+/** The display profile of `actor`: its name and color, those it has. */
+export declare const profileOf: (actor: AttributionActor) => ActorProfile;
 /**
  * Bind the attribution service to a concrete engine — same injection
  * pattern as `bindEdytorDoc`/`bindDocument`. Lifecycle is owned by the
  * calling document: one controller per `EdytorDocument`, attached in the
  * constructor, released on destroy.
  */
-export declare const bindAttribution: (Y: EngineApi) => {
+export declare const bindAttribution: (_Y: EngineApi) => {
     attach: (doc: EngineDoc, opts: AttachOptions) => AttributionController;
 };
 export type AttributionBinding = ReturnType<typeof bindAttribution>;

package/dist/crdt/attribution/attribution.js

@@ -1,6 +1,5 @@
 import { ATTRIBUTION_ROOT } from '../schema.js';
-import { cloneJson } from '../../utils/json.js';
-import { blockAttributionOf, lineageOf, lineageWatermarkOf } from './block.js';
+import { blockAttributionOf } from './block.js';
 /** Reserved replicated root for all attribution metadata (`SCHEMA.roots.attribution`). */
 export { ATTRIBUTION_ROOT };
 /**
@@ -9,7 +8,6 @@ export { ATTRIBUTION_ROOT };
  * out of undo capture; tooling classifies it as bookkeeping.
  */
 export const ATTRIBUTION_ORIGIN = Symbol('edytor.attribution');
-const RECORD_PREFIX = 'a/'; // legacy immutable per-transaction ContentMap records
 const ACTOR_PREFIX = 'u/'; // actorId → profile records
 const CLIENT_PREFIX = 'c/'; // replica clientID → actorId records
 const sanitizeProfile = (value) => {
@@ -21,7 +19,8 @@ const sanitizeProfile = (value) => {
         out.color = v.color;
     return out;
 };
-const profileOf = (actor) => ({
+/** The display profile of `actor`: its name and color, those it has. */
+export const profileOf = (actor) => ({
     ...(actor.name !== undefined ? { name: actor.name } : {}),
     ...(actor.color !== undefined ? { color: actor.color } : {})
 });
@@ -31,7 +30,7 @@ const profileOf = (actor) => ({
  * calling document: one controller per `EdytorDocument`, attached in the
  * constructor, released on destroy.
  */
-export const bindAttribution = (Y) => {
+export const bindAttribution = (_Y) => {
     /**
      * Attach the actor dictionary to `doc`: publishes this replica's
      * `c/`+`u/` records and returns the read-through view. No listeners —
@@ -74,55 +73,9 @@ export const bindAttribution = (Y) => {
                 return typeof value === 'string' && value.length > 0 ? value : undefined;
             },
             setProfile,
-            legacy: () => {
-                const inserts = Y.createIdMap();
-                const deletes = Y.createIdMap();
-                let found = false;
-                for (const key of root.attrKeys()) {
-                    if (!key.startsWith(RECORD_PREFIX))
-                        continue;
-                    const value = root.getAttr(key);
-                    if (!(value instanceof Uint8Array))
-                        continue;
-                    let change;
-                    try {
-                        change = Y.decodeContentMap(value);
-                    }
-                    catch {
-                        continue; // malformed record — skip, never poison the merged map
-                    }
-                    Y.insertIntoIdMap(inserts, change.inserts);
-                    Y.insertIntoIdMap(deletes, change.deletes);
-                    found = true;
-                }
-                return found ? Y.createContentMap(inserts, deletes) : null;
-            },
             // `b/<id>` records live on the `blockattr` root and `l` on
             // the block node — plain replicated reads, no observer needed.
-            block: (blockId) => blockAttributionOf(doc, blockId),
-            // Opt-in ring (`lineage.depth`): read the record's list items
-            // capped at the ring's watermark — the max depth of surviving
-            // entries, identical to the bound appends and the receive-side
-            // trim enforce, so every replica reads the SAME ring for the
-            // same stored state regardless of its own `lineage.depth`.
-            // (Concurrent appends can store a transient excess until the
-            // trim converges it.) Deep-copy each entry — the stored `j`
-            // snapshot is shared replicated state and must not be mutable
-            // through this view.
-            history: (blockId) => {
-                const entries = lineageOf(doc, blockId);
-                if (entries === undefined)
-                    return undefined;
-                const cap = lineageWatermarkOf(entries);
-                const visible = entries.length > cap ? entries.slice(entries.length - cap) : entries;
-                return visible.map((e) => ({
-                    ...(e.a !== undefined ? { actor: e.a } : {}),
-                    by: e.by,
-                    seq: e.s,
-                    ...(e.t !== undefined ? { time: e.t } : {}),
-                    block: cloneJson(e.j)
-                }));
-            }
+            block: (blockId) => blockAttributionOf(doc, blockId)
         };
         return {
             view,

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

@@ -77,51 +77,6 @@ export type BlockAttribution = {
     /** The actor whose state change currently wins the LWW resolution. */
     lastChangedBy?: ActorId;
 };
-/**
- * One bounded-lineage checkpoint on a block's `brec` record — the block's
- * subtree JSON captured JUST BEFORE a displacing edit: an `l` handoff
- * (another actor's first write), a delete, or an undo/redo touching the
- * block. Entries live as list items on the record node itself, appended
- * and ring-trimmed to the document's configured depth inside the owning
- * op's transaction — they die with the record on reincarnation. Compact
- * wire keys keep the replicated payload small; the public surface
- * (`attribution.history`) re-expands them.
- */
-export type LineageEntry = {
-    /** The displaced owner — the `l` winner when captured (absent when unattributed). */
-    a?: ActorId;
-    /** The actor whose edit displaced the state (or whose undo/redo touched the block). */
-    by: ActorId;
-    /**
-     * Ring position at append — a display aid only. It can REPEAT (after a
-     * trim the position counter rewinds, and concurrent replicas assign
-     * the same position independently): never an entry id — list order is
-     * the truth.
-     */
-    s: number;
-    /** Wall-clock capture time — display only, never ordering. */
-    t?: number;
-    /** The displaced subtree snapshot (a `JSONBlock`). */
-    j: unknown;
-    /**
-     * The appending writer's configured ring depth. THE retention bound is
-     * the MAX of surviving entries' `d` — enforced identically by
-     * `appendLineage` (same-tx trim), `attachRingTrim` (receive-side
-     * repair), and `history()` (read view), so a shallow replica can never
-     * evict a deeper writer's surviving history on ANY path. Entries
-     * written before `d` existed leave it absent → the ring is exempt from
-     * trimming entirely (the writers' bound is unknowable — evict
-     * nothing).
-     */
-    d?: number;
-};
-/**
- * The ring's retention bound — the deepest `lineage.depth` any surviving
- * entry's writer was configured with. `POSITIVE_INFINITY` when ANY entry
- * lacks `d` (pre-watermark data): without knowing every writer's bound,
- * no entry may be evicted on their behalf.
- */
-export declare const lineageWatermarkOf: (entries: LineageEntry[]) => number;
 export { BLOCK_ATTR_ROOT, LAST_CHANGED_ATTR };
 /** The `k/` member set on a `b/` record node. */
 export declare const contributorsOfRecord: (rec: EngineNode | null) => Set<ActorId>;
@@ -131,12 +86,6 @@ export declare const contributorsOfRecord: (rec: EngineNode | null) => Set<Actor
  * carries no attribution at all (system/foreign content stays unlabeled).
  */
 export declare const blockAttributionOf: (doc: EngineDoc, id: BlockId) => BlockAttribution | undefined;
-/**
- * Read one block's lineage ring, oldest → newest — or `undefined` when
- * the block carries no record. Entries are the stored content values;
- * callers deep-copy before exposing them publicly.
- */
-export declare const lineageOf: (doc: EngineDoc, id: BlockId) => LineageEntry[] | undefined;
 /**
  * Bound write helpers. `stampChange`/`stampCreated`/`unionContributors`
  * must be called INSIDE the operation's `doc.transact` — they perform
@@ -169,32 +118,5 @@ export declare const bindBlockAttribution: (Y: EngineApi) => {
      * The merger itself lands via `stampChange` on the survivor.
      */
     unionContributors: (doc: EngineDoc, intoId: BlockId, fromId: BlockId) => void;
-    /**
-     * Append a displaced-state checkpoint to the block's ring and trim
-     * to the ring's watermark — `max` of surviving entries' `d`,
-     * including the fresh one. The caller captures `entry.j` BEFORE its
-     * model write (see `lineagePending` in `edytor-doc.ts`) and calls
-     * this only after the write proves out, so a refused write appends
-     * nothing. The watermark is THE retention policy — identical on
-     * append, on receive (`attachRingTrim`), and on read — so a shallow
-     * replica never evicts a deeper writer's surviving history, and the
-     * bound shrinks only once the deepest entries have themselves
-     * aged out. Concurrent appends under partition can still merge a
-     * ring past the watermark — neither side saw the other's entry —
-     * which the receive-side repair converges back.
-     */
-    appendLineage: (doc: EngineDoc, id: BlockId, entry: Omit<LineageEntry, "s" | "d">, depth: number) => void;
-    /**
-     * The block's lineage ring, oldest → newest — or `undefined` when
-     * the block has no record at all. Entries are the stored content
-     * values; the public surface copies them before handing them out.
-     */
-    lineageOf: (doc: EngineDoc, id: BlockId) => LineageEntry[] | undefined;
-    /**
-     * Attach the doc's shared ring-watermark repair — once per doc for
-     * the doc's lifetime (module-level dedupe). See the module-level comment
-     * below.
-     */
-    attachRingTrim: (doc: EngineDoc) => void;
 };
 export type BlockAttributionApi = ReturnType<typeof bindBlockAttribution>;

package/dist/crdt/attribution/block.js

@@ -1,22 +1,6 @@
 import { REGISTRY_KEY } from '../placement/model.js';
 import { BLOCK_ATTR_ROOT, isNodeLike, LAST_CHANGED_ATTR, NONCE, REC_PREFIX } from '../schema.js';
-import { attrItems, newNode as makeNode, onTransaction } from '../structs.js';
-/**
- * The ring's retention bound — the deepest `lineage.depth` any surviving
- * entry's writer was configured with. `POSITIVE_INFINITY` when ANY entry
- * lacks `d` (pre-watermark data): without knowing every writer's bound,
- * no entry may be evicted on their behalf.
- */
-export const lineageWatermarkOf = (entries) => {
-    let wm = 0;
-    for (const e of entries) {
-        if (typeof e.d !== 'number' || !Number.isFinite(e.d))
-            return Number.POSITIVE_INFINITY;
-        if (e.d > wm)
-            wm = e.d;
-    }
-    return wm;
-};
+import { attrItems, newNode as makeNode } from '../structs.js';
 // `BLOCK_ATTR_ROOT`/`LAST_CHANGED_ATTR`/`REC_PREFIX` live in the shared
 // `../schema.js` leaf — re-exported so existing import sites stay.
 export { BLOCK_ATTR_ROOT, LAST_CHANGED_ATTR };
@@ -82,15 +66,6 @@ export const blockAttributionOf = (doc, id) => {
         lastChangedBy: typeof l === 'string' ? l : undefined
     };
 };
-/**
- * Read one block's lineage ring, oldest → newest — or `undefined` when
- * the block carries no record. Entries are the stored content values;
- * callers deep-copy before exposing them publicly.
- */
-export const lineageOf = (doc, id) => {
-    const rec = recordOf(doc, id);
-    return rec === null ? undefined : rec.toArray();
-};
 /**
  * Bound write helpers. `stampChange`/`stampCreated`/`unionContributors`
  * must be called INSIDE the operation's `doc.transact` — they perform
@@ -205,124 +180,6 @@ export const bindBlockAttribution = (Y) => {
             const into = ensureRecord(doc, intoId, blockNodeOf(doc, intoId));
             for (const a of contributorsOfRecord(from))
                 addContributor(into, a);
-        },
-        /**
-         * Append a displaced-state checkpoint to the block's ring and trim
-         * to the ring's watermark — `max` of surviving entries' `d`,
-         * including the fresh one. The caller captures `entry.j` BEFORE its
-         * model write (see `lineagePending` in `edytor-doc.ts`) and calls
-         * this only after the write proves out, so a refused write appends
-         * nothing. The watermark is THE retention policy — identical on
-         * append, on receive (`attachRingTrim`), and on read — so a shallow
-         * replica never evicts a deeper writer's surviving history, and the
-         * bound shrinks only once the deepest entries have themselves
-         * aged out. Concurrent appends under partition can still merge a
-         * ring past the watermark — neither side saw the other's entry —
-         * which the receive-side repair converges back.
-         */
-        appendLineage: (doc, id, entry, depth) => {
-            const rec = ensureRecord(doc, id);
-            rec.insert(rec.length, [{ ...entry, s: rec.length, d: depth }]);
-            const wm = lineageWatermarkOf(rec.toArray());
-            if (rec.length > wm)
-                rec.delete(0, rec.length - wm);
-        },
-        /**
-         * The block's lineage ring, oldest → newest — or `undefined` when
-         * the block has no record at all. Entries are the stored content
-         * values; the public surface copies them before handing them out.
-         */
-        lineageOf,
-        /**
-         * Attach the doc's shared ring-watermark repair — once per doc for
-         * the doc's lifetime (module-level dedupe). See the module-level comment
-         * below.
-         */
-        attachRingTrim: (doc) => {
-            if (ringTrimAttached.has(doc))
-                return;
-            ringTrimAttached.set(doc, true);
-            const trimToWatermark = (rec) => {
-                const wm = lineageWatermarkOf(rec.toArray());
-                if (rec.length > wm)
-                    rec.delete(0, rec.length - wm);
-            };
-            onTransaction(doc, 'afterTransaction', (transaction) => {
-                try {
-                    const changed = transaction?.changed;
-                    if (changed === undefined)
-                        return;
-                    let over;
-                    for (const type of changed.keys()) {
-                        const rec = type;
-                        if (rec?.name === REC_NODE &&
-                            rec.length > lineageWatermarkOf(rec.toArray())) {
-                            (over ??= []).push(rec);
-                        }
-                    }
-                    if (over === undefined)
-                        return;
-                    // A follow-up transaction in the same cleanup sweep — the
-                    // trim deletes exactly the items the next append would
-                    // evict, so concurrent trims (each replica runs this on
-                    // the same merged state) delete the SAME items and stay
-                    // convergent. The watermark never goes below a surviving
-                    // entry's own configured depth.
-                    doc.transact(() => {
-                        for (const rec of over)
-                            trimToWatermark(rec);
-                    }, LINEAGE_TRIM_ORIGIN);
-                }
-                catch (err) {
-                    // A failure here must never propagate — throwing inside
-                    // `afterTransaction` would break the host transaction's
-                    // cleanup sweep. An untrimmed ring still converges.
-                    console.error('[edytor-doc] lineage ring trim failed; leaving over-cap state', err);
-                }
-            });
-            // Install-time sweep: a doc that arrived over-cap BEFORE this
-            // listener existed — `loadDocument`/`attachDocument` integrate
-            // the payload before the facade composes — never fires the
-            // hook above for that data. One O(records) pass converges it.
-            try {
-                const root = doc.get(BLOCK_ATTR_ROOT);
-                let over;
-                for (const key of root.attrKeys()) {
-                    if (!key.startsWith(REC_PREFIX))
-                        continue;
-                    const rec = root.getAttr(key);
-                    if (isNodeLike(rec) &&
-                        rec.name === REC_NODE &&
-                        rec.length > lineageWatermarkOf(rec.toArray())) {
-                        (over ??= []).push(rec);
-                    }
-                }
-                if (over !== undefined) {
-                    doc.transact(() => {
-                        for (const rec of over)
-                            trimToWatermark(rec);
-                    }, LINEAGE_TRIM_ORIGIN);
-                }
-            }
-            catch (err) {
-                console.error('[edytor-doc] lineage ring sweep failed; leaving over-cap state', err);
-            }
         }
     };
 };
-/**
- * Per-doc attach table for the shared ring-trim listener — module level
- * (not binding- or facade-scoped) so the listener is installed ONCE per
- * doc across every binding's facade `create()`, and never detached: a
- * ring pushed over its watermark by concurrent appends is converged even
- * after the last facade disposes. The `WeakMap` entry and the doc-held
- * listener die with the doc — no leak.
- */
-const ringTrimAttached = new WeakMap();
-/**
- * Origin of the ring-trim's delete writes — an origin no UndoManager
- * tracks, so trims never enter an undo stack and never recurse (the trim
- * only deletes ring items: the follow-up `afterTransaction` pass finds
- * the ring at exactly the watermark and stops).
- */
-const LINEAGE_TRIM_ORIGIN = Symbol('edytor.lineage-trim');