edytor 1.0.0-rc.3 → 2.0.0

package/dist/components/Ranges.svelte

@@ -0,0 +1,96 @@
+<script lang="ts" module>
+	import type { PresencePoint } from '../collaboration/awarenessSelection.js';
+	import type { Edytor } from '../edytor.svelte.js';
+
+	/** A run of text the overlay marks: its ends, and whether it is the current one (`data-current`). */
+	export type MarkedRange = { start: PresencePoint; end: PresencePoint; current?: boolean };
+
+	/** The run of `length` at block offset `offset` of block `id` (none where it is not shown). */
+	export const runOf = (
+		edytor: Edytor,
+		id: string,
+		offset: number,
+		length: number,
+		current?: boolean
+	): MarkedRange[] => {
+		const block = edytor.idToBlock.get(id);
+		const [start, end] = [block?.textAtOffset(offset), block?.textAtOffset(offset + length)];
+		return start && end ? [{ start, end, current }] : [];
+	};
+</script>
+
+<script lang="ts">
+	import { onMount } from 'svelte';
+	import { rangeRects, type RemoteSelectionRect } from '../collaboration/remoteSelection.js';
+
+	/**
+	 * Runs of text marked in the overlay (never inside the host), one
+	 * rectangle per line box, measured once per frame: the find matches, the
+	 * text a `replace` suggestion removes, the comment being written. Each
+	 * rectangle carries `data-edytor-<name>` (`data-current` on the current
+	 * run's); the layer is `z`.
+	 */
+	let {
+		edytor,
+		name,
+		z,
+		ranges
+	}: { edytor: Edytor; name: string; z: number; ranges: () => MarkedRange[] } = $props();
+
+	let rects: (RemoteSelectionRect & { current?: boolean })[] = $state([]);
+
+	onMount(() =>
+		edytor.overlay.add((origin) => {
+			const next = ranges().flatMap(({ start, end, current }) =>
+				rangeRects(edytor, start, end, origin).map((rect) => ({ ...rect, current }))
+			);
+			if (next.length || rects.length) return () => (rects = next);
+		})
+	);
+	// What the runs read changed: the overlay measures again.
+	$effect(() => {
+		void ranges();
+		edytor.overlay.invalidate();
+	});
+</script>
+
+<div data-edytor-ranges={name} contenteditable="false" aria-hidden="true" style:z-index={z}>
+	{#each rects as rect, index (index)}
+		<span
+			{...{ [`data-edytor-${name}`]: '' }}
+			data-current={rect.current || undefined}
+			style:left={`${rect.left}px`}
+			style:top={`${rect.top}px`}
+			style:width={`${rect.width}px`}
+			style:height={`${rect.height}px`}
+		></span>
+	{/each}
+</div>
+
+<style>
+	[data-edytor-ranges] {
+		position: absolute;
+		left: 0;
+		top: 0;
+		pointer-events: none;
+	}
+	[data-edytor-ranges] > span {
+		position: absolute;
+	}
+	:global([data-edytor-find-match]) {
+		border-radius: 2px;
+		background: var(--edytor-find-match, rgb(255 212 0 / 0.3));
+		mix-blend-mode: multiply;
+	}
+	:global([data-edytor-find-match][data-current]) {
+		background: var(--edytor-find-current, rgb(255 166 0 / 0.55));
+	}
+	:global([data-edytor-suggestion-range]) {
+		background: var(--edytor-suggestion-removed, rgb(235 87 87 / 0.18));
+		border-bottom: 1px solid var(--edytor-suggestion-removed-line, rgb(235 87 87 / 0.6));
+	}
+	:global([data-edytor-comment-draft]) {
+		background: var(--edytor-comment-active, rgb(255 212 0 / 0.42));
+		mix-blend-mode: multiply;
+	}
+</style>

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

@@ -0,0 +1,19 @@
+import type { PresencePoint } from '../collaboration/awarenessSelection.js';
+import type { Edytor } from '../edytor.svelte.js';
+/** A run of text the overlay marks: its ends, and whether it is the current one (`data-current`). */
+export type MarkedRange = {
+    start: PresencePoint;
+    end: PresencePoint;
+    current?: boolean;
+};
+/** The run of `length` at block offset `offset` of block `id` (none where it is not shown). */
+export declare const runOf: (edytor: Edytor, id: string, offset: number, length: number, current?: boolean) => MarkedRange[];
+type $$ComponentProps = {
+    edytor: Edytor;
+    name: string;
+    z: number;
+    ranges: () => MarkedRange[];
+};
+declare const Ranges: import("svelte").Component<$$ComponentProps, {}, "">;
+type Ranges = ReturnType<typeof Ranges>;
+export default Ranges;

package/dist/components/Suggestion.svelte

@@ -3,6 +3,7 @@
 	import type { Edytor } from '../edytor.svelte.js';
 	import type { Suggestion } from '../session/suggestions.svelte.js';
 	import { previewCells } from '../surface/cells.js';
+	import { editorEnglish, labelsOf } from '../labels.js';
 	import Block from './Block.svelte';
 
 	/**
@@ -28,12 +29,12 @@
 	data-edytor-suggestion={suggestion.id}
 	data-status={suggestion.status}
 	contenteditable="false"
-	aria-label={suggestion.label ?? edytor.labels.suggestion}
+	aria-label={suggestion.label ?? labelsOf(edytor, 'editor', editorEnglish).suggestion}
 	role="group"
 	use:edytor.surface.preview={suggestion.id}
 	onmousedown={cancel}
 >
-	{#each cells as cell (cell.id)}<Block id={cell.id} preview={cell} />{/each}
+	{#each cells as cell (cell.id)}<Block kid={cell} />{/each}
 </div>
 
 <style>

package/dist/components/Text.svelte

@@ -1,7 +1,7 @@
 <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, { customAt } from './Mark.svelte';
 	import CustomMark from './CustomMark.svelte';
@@ -61,10 +61,7 @@
 
 	/** 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]) => {
-			const definition = edytor.marks.get(name);
-			return Boolean(definition?.snippet || definition?.tag);
-		});
+		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);

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>;