edytor 1.0.0-rc.3 → 2.0.0

package/dist/crdt/schema.js

@@ -43,7 +43,7 @@ export const INLINE_NODE = 'inline';
 /** Attr keys on a block node (`SCHEMA.blockAttrs`). */
 export const ID = 'id';
 export const TYPE = 'type';
-/** A block's or atom's whole data: the legacy layer, read under the leaves and exploded by the first patch. */
+/** A block's or atom's whole data, as documents before 0.1.0-next.6 stored it: no longer read; the room's purge deletes it. */
 export const DATA = 'data';
 /** A data leaf: `d/` and its path, RFC 6901 escaped (`crdt/data.ts`). */
 export const DATA_LEAF_PREFIX = 'd/';
@@ -80,10 +80,9 @@ export const AT = 'at';
 export const REC_PREFIX = 'b/';
 /** The schema generation stamped on the `meta` root (`v`) and its manifest name (`schema`). */
 export const SCHEMA = {
-    // 5 (0.1.0-next.25): paired marks, variable-length ranks, v2
-    // SyncStep2; a generation-4 container converts through its JSON
-    // (`migration/generation.ts`).
-    version: 5,
+    // 6: one update encoding (the columnar one) on the wire and in storage;
+    // a container or frame of an earlier generation is refused.
+    version: 6,
     name: 'edytor-doc',
     roots: { registry: REGISTRY_KEY, meta: META_ROOT_KEY },
     metaAttrs: { version: 'v', schema: 'schema' }

package/dist/crdt/semantics.d.ts

@@ -53,16 +53,12 @@ export type NormalizedRole = {
 };
 /** `role` as {@link NormalizedRole}: the one form two declarations compare in. */
 export declare const normalizeRole: (role: BlockRole | undefined) => NormalizedRole;
-/** `richTextPlugin`'s structural rows (its other kinds are plain). */
+/** `createRichTextPlugin()`'s structural rows (its other kinds are plain). */
 export declare const richTextKinds: {
     divider: {
         void: true;
         rendersContent: false;
     };
-    horizontalRule: {
-        void: true;
-        rendersContent: false;
-    };
     'ordered-list': {
         rendersContent: false;
         defaultChild: string;
@@ -73,7 +69,7 @@ export declare const richTextKinds: {
     };
 };
 /**
- * `richTextPlugin`'s mark edges: where a concurrent insert at each end
+ * `createRichTextPlugin()`'s mark edges: where a concurrent insert at each end
  * of a mark lands. A link grows at its start only (typing after it
  * stays out of it unless from inside the anchor); the others are inclusive.
  */
@@ -92,7 +88,7 @@ export declare const commentMarks: {
         edge: "exclusive";
     };
 };
-/** `codePlugin`'s structural rows: the code block is an island of `codeLine`s (`lines`). */
+/** `createCodePlugin()`'s structural rows: the code block is an island of `codeLine`s (`lines`). */
 export declare const codeKinds: {
     code: {
         island: true;
@@ -101,15 +97,15 @@ export declare const codeKinds: {
         defaultChild: string;
     };
 };
-/** `imagePlugin`'s structural rows: void, its only text is the caption. */
+/** `createImagePlugin()`'s structural rows: void, its only text is the caption. */
 export declare const imageKinds: {
     image: {
         void: true;
     };
 };
 /**
- * The media plugins' structural rows (`embedPlugin`, `bookmarkPlugin`,
- * `filePlugin`, `videoPlugin`, `audioPlugin`): void like the image, their
+ * The media plugins' structural rows (`createEmbedPlugin()`, `createBookmarkPlugin()`,
+ * `createFilePlugin()`, `createVideoPlugin()`, `createAudioPlugin()`): void like the image, their
  * only text is the caption.
  */
 export declare const mediaKinds: {
@@ -249,7 +245,7 @@ export declare const semanticsDigest: (config: DocumentSemanticsConfig) => Recor
  * names counts when it has facts. Anything but a digest compares nothing.
  */
 export declare const semanticsMismatch: (ours: Record<string, string>, theirs: unknown) => string[];
-/** `richTextPlugin`'s block roles and mark edges, for `createDocument({ semantics })` and the room. */
+/** `createRichTextPlugin()`'s block roles and mark edges, for `createDocument({ semantics })` and the room. */
 export declare const richTextSemantics: {
     roles: Record<string, BlockRole>;
     rendersContent: Record<string, boolean>;
@@ -259,13 +255,13 @@ export declare const richTextSemantics: {
         edge: MarkEdge;
     }>;
 };
-/** `codePlugin`'s block roles. */
+/** `createCodePlugin()`'s block roles. */
 export declare const codeSemantics: {
     roles: Record<string, BlockRole>;
     rendersContent: Record<string, boolean>;
     defaultChild: Record<string, string>;
 };
-/** `imagePlugin`'s block roles. */
+/** `createImagePlugin()`'s block roles. */
 export declare const imageSemantics: {
     roles: Record<string, BlockRole>;
     rendersContent: Record<string, boolean>;
@@ -327,8 +323,7 @@ export declare const defaultSemantics: {
 };
 /**
  * The facade configuration (`EdytorDocConfig`) a document with no view
- * reads `semantics` with — the room's, and a generation cutover's
- * (`migration/generation.ts`): roles, default children, content-less kinds
+ * reads `semantics` with — the room's: roles, default children, content-less kinds
  * and mark edges, each answered only for a kind the tables name.
  */
 export declare const facadeConfigOf: (semantics: DocumentSemanticsConfig) => {

package/dist/crdt/semantics.js

@@ -48,15 +48,14 @@ const frozen = (value) => {
     }
     return value;
 };
-/** `richTextPlugin`'s structural rows (its other kinds are plain). */
+/** `createRichTextPlugin()`'s structural rows (its other kinds are plain). */
 export const richTextKinds = frozen({
     divider: { void: true, rendersContent: false },
-    horizontalRule: { void: true, rendersContent: false },
     'ordered-list': { rendersContent: false, defaultChild: 'list-item' },
     'unordered-list': { rendersContent: false, defaultChild: 'list-item' }
 });
 /**
- * `richTextPlugin`'s mark edges: where a concurrent insert at each end
+ * `createRichTextPlugin()`'s mark edges: where a concurrent insert at each end
  * of a mark lands. A link grows at its start only (typing after it
  * stays out of it unless from inside the anchor); the others are inclusive.
  */
@@ -71,15 +70,15 @@ export const richTextMarks = frozen({
 export const commentMarks = frozen({
     comment: { edge: 'exclusive' }
 });
-/** `codePlugin`'s structural rows: the code block is an island of `codeLine`s (`lines`). */
+/** `createCodePlugin()`'s structural rows: the code block is an island of `codeLine`s (`lines`). */
 export const codeKinds = frozen({
     code: { island: true, lines: true, rendersContent: false, defaultChild: 'codeLine' }
 });
-/** `imagePlugin`'s structural rows: void, its only text is the caption. */
+/** `createImagePlugin()`'s structural rows: void, its only text is the caption. */
 export const imageKinds = frozen({ image: { void: true } });
 /**
- * The media plugins' structural rows (`embedPlugin`, `bookmarkPlugin`,
- * `filePlugin`, `videoPlugin`, `audioPlugin`): void like the image, their
+ * The media plugins' structural rows (`createEmbedPlugin()`, `createBookmarkPlugin()`,
+ * `createFilePlugin()`, `createVideoPlugin()`, `createAudioPlugin()`): void like the image, their
  * only text is the caption.
  */
 export const mediaKinds = frozen({
@@ -143,6 +142,7 @@ export const tableKinds = frozen({
  * `table`, `atomic`, `rendersContent`, `defaultChild`), and a bare snippet is a
  * plain kind. To add kinds to a bundled config, use {@link mergeSemantics}.
  */
+/* @__NO_SIDE_EFFECTS__ */
 export const semanticsOf = (...tables) => {
     const semantics = {
         roles: {},
@@ -264,25 +264,27 @@ export const semanticsMismatch = (ours, theirs) => {
         .sort();
 };
 /** `config` with a mark-edge table, frozen. */
+/* @__NO_SIDE_EFFECTS__ */
 const withMarks = (config, marks) => frozen(Object.assign({}, config, { marks }));
-/** `richTextPlugin`'s block roles and mark edges, for `createDocument({ semantics })` and the room. */
-export const richTextSemantics = withMarks(semanticsOf(richTextKinds), richTextMarks);
-/** `codePlugin`'s block roles. */
-export const codeSemantics = semanticsOf(codeKinds);
-/** `imagePlugin`'s block roles. */
-export const imageSemantics = semanticsOf(imageKinds);
+/** `createRichTextPlugin()`'s block roles and mark edges, for `createDocument({ semantics })` and the room. */
+export const richTextSemantics = /* @__PURE__ */ withMarks(
+/* @__PURE__ */ semanticsOf(richTextKinds), richTextMarks);
+/** `createCodePlugin()`'s block roles. */
+export const codeSemantics = /* @__PURE__ */ semanticsOf(codeKinds);
+/** `createImagePlugin()`'s block roles. */
+export const imageSemantics = /* @__PURE__ */ semanticsOf(imageKinds);
 /** The media plugins' block roles (embed, bookmark, file, video, audio). */
-export const mediaSemantics = semanticsOf(mediaKinds);
+export const mediaSemantics = /* @__PURE__ */ semanticsOf(mediaKinds);
 /** The columns plugin's block roles (a layout of columns). */
-export const layoutSemantics = semanticsOf(layoutKinds);
+export const layoutSemantics = /* @__PURE__ */ semanticsOf(layoutKinds);
 /** The page plugin's block role (a link to another document). */
-export const pageSemantics = semanticsOf(pageKinds);
+export const pageSemantics = /* @__PURE__ */ semanticsOf(pageKinds);
 /** The table of contents plugin's block role. */
-export const tocSemantics = semanticsOf(tocKinds);
+export const tocSemantics = /* @__PURE__ */ semanticsOf(tocKinds);
 /** The table plugin's block roles (a table of rows of cells). */
-export const tableSemantics = semanticsOf(tableKinds);
+export const tableSemantics = /* @__PURE__ */ semanticsOf(tableKinds);
 /** The equation plugin's block role. */
-export const equationSemantics = semanticsOf(equationKinds);
+export const equationSemantics = /* @__PURE__ */ semanticsOf(equationKinds);
 /**
  * The rich-text, code, image, media, columns, page, table of contents,
  * table and equation plugins' block roles together (and the rich-text and
@@ -295,8 +297,7 @@ export const equationSemantics = semanticsOf(equationKinds);
 export const defaultSemantics = withMarks(semanticsOf(richTextKinds, codeKinds, imageKinds, mediaKinds, layoutKinds, pageKinds, tocKinds, tableKinds, equationKinds), { ...richTextMarks, ...commentMarks });
 /**
  * The facade configuration (`EdytorDocConfig`) a document with no view
- * reads `semantics` with — the room's, and a generation cutover's
- * (`migration/generation.ts`): roles, default children, content-less kinds
+ * reads `semantics` with — the room's: roles, default children, content-less kinds
  * and mark edges, each answered only for a kind the tables name.
  */
 export const facadeConfigOf = (semantics) => {

package/dist/crdt/storage.d.ts

@@ -1,21 +1,15 @@
 /**
  * The storage codec — what the room's rows and the IndexedDB store
- * hold, apart from the wire (which stays v1 until the schema generation
- * that changes it). Snapshots are written in the v2 (columnar) encoding
- * and gzip-compressed where the platform has `CompressionStream`; update
- * rows stay v1 (smaller for one keystroke). A compressed record starts
- * with gzip's magic `1f 8b`, which no v2 update does (its first byte is
- * the encoder's feature flag, `00`), so a v2 container's snapshot says
- * itself whether it is compressed. Worker-safe: no timers, every
- * platform API feature-detected.
+ * hold: updates in the engine's one encoding, snapshots gzip-compressed
+ * when that makes them smaller (`CompressionStream`, in every supported
+ * browser, Node and Workers). A compressed record starts with gzip's magic
+ * `1f 8b`, which no update does (its first byte is the encoder's feature
+ * flag, `00`), so a record says itself whether it is compressed.
+ * Worker-safe: no timers.
  */
 /** Whether `bytes` are gzip (its magic `1f 8b`). */
 export declare const isGzip: (bytes: Uint8Array) => boolean;
-/** Whether this platform compresses (`CompressionStream`). */
-export declare const canCompress: () => boolean;
-/** `bytes` gzip-compressed, or `null` where the platform has no `CompressionStream`. */
-export declare const gzip: (bytes: Uint8Array) => Promise<Uint8Array | null>;
 /** `bytes` as stored: inflated when gzip, else as they are. */
 export declare const gunzip: (bytes: Uint8Array) => Promise<Uint8Array>;
-/** `bytes` compressed when that makes them smaller (and the platform can), else as they are. */
+/** `bytes` compressed when that makes them smaller, else as they are. */
 export declare const packed: (bytes: Uint8Array) => Promise<Uint8Array>;

package/dist/crdt/storage.js

@@ -1,37 +1,23 @@
 /**
  * The storage codec — what the room's rows and the IndexedDB store
- * hold, apart from the wire (which stays v1 until the schema generation
- * that changes it). Snapshots are written in the v2 (columnar) encoding
- * and gzip-compressed where the platform has `CompressionStream`; update
- * rows stay v1 (smaller for one keystroke). A compressed record starts
- * with gzip's magic `1f 8b`, which no v2 update does (its first byte is
- * the encoder's feature flag, `00`), so a v2 container's snapshot says
- * itself whether it is compressed. Worker-safe: no timers, every
- * platform API feature-detected.
+ * hold: updates in the engine's one encoding, snapshots gzip-compressed
+ * when that makes them smaller (`CompressionStream`, in every supported
+ * browser, Node and Workers). A compressed record starts with gzip's magic
+ * `1f 8b`, which no update does (its first byte is the encoder's feature
+ * flag, `00`), so a record says itself whether it is compressed.
+ * Worker-safe: no timers.
  */
 /** Whether `bytes` are gzip (its magic `1f 8b`). */
 export const isGzip = (bytes) => bytes.length >= 2 && bytes[0] === 0x1f && bytes[1] === 0x8b;
-const platform = globalThis;
 /** Run `bytes` through a (de)compression stream. */
 const through = async (bytes, transform) => {
     const stream = new Response(bytes).body.pipeThrough(transform);
     return new Uint8Array(await new Response(stream).arrayBuffer());
 };
-/** Whether this platform compresses (`CompressionStream`). */
-export const canCompress = () => typeof platform.CompressionStream === 'function';
-/** `bytes` gzip-compressed, or `null` where the platform has no `CompressionStream`. */
-export const gzip = async (bytes) => platform.CompressionStream ? through(bytes, new platform.CompressionStream('gzip')) : null;
 /** `bytes` as stored: inflated when gzip, else as they are. */
-export const gunzip = async (bytes) => {
-    if (!isGzip(bytes))
-        return bytes;
-    if (!platform.DecompressionStream) {
-        throw new Error('a compressed record needs DecompressionStream, which this platform lacks');
-    }
-    return through(bytes, new platform.DecompressionStream('gzip'));
-};
-/** `bytes` compressed when that makes them smaller (and the platform can), else as they are. */
+export const gunzip = async (bytes) => isGzip(bytes) ? through(bytes, new DecompressionStream('gzip')) : bytes;
+/** `bytes` compressed when that makes them smaller, else as they are. */
 export const packed = async (bytes) => {
-    const out = await gzip(bytes);
-    return out !== null && out.length < bytes.length ? out : bytes;
+    const out = await through(bytes, new CompressionStream('gzip'));
+    return out.length < bytes.length ? out : bytes;
 };

package/dist/crdt/structs.d.ts

@@ -1,24 +1,3 @@
-/**
- * Vendor internals — the ONE place Edytor code reaches into the engine's
- * private state (the struct store, a node's attr items and first item,
- * the doc's collection settings and transaction events) and calls the
- * engine's internal functions with Edytor's structural views of its
- * objects. Centralizing these keeps the blast radius of a vendored engine
- * upgrade in one module: when an internal is renamed or reshaped, the
- * accessors below are the lines to change, and the fail-fast checks break
- * loudly at upgrade time instead of silently disabling run invalidation or
- * history lineage (the old optional-chained reads turned a rename into a
- * silent no-op).
- *
- * The model works against structural types (`EngineDoc`, `EngineNode`,
- * `StoreStruct`, `IdSetLike`: the subset it reads) while the engine's
- * generated declarations (`vendor/yjs/dts`) type its classes; a real engine
- * object satisfies the structural view at runtime. Each accessor states
- * that correspondence once, so a call site needs no cast.
- *
- * The engine surface is injected (`Y: EngineApi`) like every other bound
- * module — this file never imports vendor `.js`.
- */
 import type { EngineApi, EngineDoc, EngineNode, YDoc, YNode, YUndoManager } from './engine-api.js';
 /**
  * Structural shape of one store struct (Item | GC | Skip) — the subset
@@ -62,9 +41,9 @@ export type IdSetLike = {
 };
 /**
  * The doc's struct store — vendor-internal (`doc.store.clients`).
- * FAIL-FAST: a missing store means the doc is not a vendored-engine doc
- * (or the vendored layout changed) — either way the only honest response
- * is a descriptive throw, never a silent fallback.
+ * FAIL-FAST in development: a missing store means the doc is not a
+ * vendored-engine doc (or the vendored layout changed) — either way the only
+ * honest response is a descriptive throw, never a silent fallback.
  */
 export declare const clientsOf: (doc: EngineDoc) => Map<number, StoreStruct[]>;
 /**
@@ -75,25 +54,17 @@ export declare const clientsOf: (doc: EngineDoc) => Map<number, StoreStruct[]>;
  */
 export declare const structAt: (Y: EngineApi, structs: readonly StoreStruct[], clock: number) => StoreStruct | null;
 /**
- * Walk every struct an IdSet covers, invoking `fn` per struct in
- * (client, clock) order. IdSet ranges are item-aligned (they record whole
- * structs), so an overlapping struct is a covered struct — the walk never
- * splits.
- *
- * `fn` returning `false` halts the walk early (caller-side short-circuit).
+ * Walk every struct an IdSet covers, in (client, clock) order: `fn(struct,
+ * from, to)` gets the struct and the clock range `[from, to)` of it the set
+ * covers (a struct can reach past a range a diff of two id sets cut). The
+ * walk never splits a struct; `fn` returning `false` halts it.
  *
  * Returns `false` when coverage was INCOMPLETE — a client's struct list
  * was missing or a range start could not be located — so the caller can
  * fall back to an all-consumers/opaque answer instead of trusting a
  * partial walk. `clientsOf` throws first when the store itself is absent.
  */
-export declare const walkIdSetStructs: (Y: EngineApi, doc: EngineDoc, idSet: IdSetLike, fn: (struct: StoreStruct) => boolean | void) => boolean;
-/**
- * {@link walkIdSetStructs}, clipped: `fn(struct, from, to)` gets the clock
- * range `[from, to)` of the struct the id set covers (a struct can reach past
- * a range a diff of two id sets cut).
- */
-export declare const walkIdSetRanges: (Y: EngineApi, doc: EngineDoc, idSet: IdSetLike, fn: (struct: StoreStruct, from: number, to: number) => void) => boolean;
+export declare const walkIdSet: (Y: EngineApi, doc: EngineDoc, idSet: IdSetLike, fn: (struct: StoreStruct, from: number, to: number) => boolean | void) => boolean;
 /**
  * The id the local `redone` chain leads `id` to: the copy an undo or redo
  * on THIS replica re-created of a deleted item (redo copies chain), or `id`
@@ -143,8 +114,8 @@ export declare const asYNode: (node: EngineNode) => YNode;
 /** A new detached node of the engine, through the structural view. */
 export declare const newNode: (Y: EngineApi, name: string) => EngineNode;
 /**
- * A renderer-free bounded read cursor on `node` (the fork's `RangeCursor`),
- * in the caller's view of a cursor.
+ * A bounded read cursor on `node` (the fork's `RangeCursor`), in the
+ * caller's view of a cursor.
  */
 export declare const rangeCursorOf: <C>(Y: EngineApi, node: EngineNode) => C;
 /**
@@ -159,11 +130,6 @@ export declare const firstItem: <I = StoreStruct>(node: EngineNode | YNode) => I
 export declare const sequenceLength: (node: EngineNode | YNode) => number;
 /** The item a node is the value of (`_item`), in the caller's view. */
 export declare const itemOf: <I = StoreStruct>(node: EngineNode) => I | null;
-/**
- * Run `f` with `node`'s renderer (vendor `_renderer`) set aside: a write
- * addresses live-content space, whatever renderer a reader installed.
- */
-export declare const withoutRenderer: <T>(node: EngineNode, f: () => T) => T;
 /** The struct store's reads edytor makes (vendor `doc.store`). */
 export type StoreLike = {
     clients: Map<number, StoreStruct[]>;
@@ -195,6 +161,14 @@ export declare const collectNow: (item: object, tr: unknown) => void;
  * `afterTransaction`), with the caller's view of a transaction.
  */
 export declare const onTransaction: <T>(doc: EngineDoc | YDoc, event: "beforeTransaction" | "afterTransaction", f: (tr: T) => void) => void;
+/**
+ * Whether a transaction changed one of `nodes` or a node under one: its
+ * `changed` types and their ancestors (what a deep observer of `nodes`
+ * would have heard; the engine has none, fork patch YP19).
+ */
+export declare const changedUnder: (tr: {
+    changed: Map<unknown, unknown>;
+}, nodes: readonly unknown[]) => boolean;
 /** The steps of a history's undo stack (or its redo stack), in the caller's view. */
 export declare const stepsOf: <S>(stack: YUndoManager["undoStack"]) => S[];
 /** An engine id set as the model reads and writes it. */
@@ -218,10 +192,31 @@ export declare const engineOps: (Y: EngineApi) => {
     /** The item starting at `client:clock`, split there, inside `tr`. */
     cleanStart: <I = StoreStruct>(tr: unknown, client: number, clock: number) => I;
     /**
-     * Re-create deleted `item` as the engine's undo does (`redoItem`): its
-     * copy, or `null` when it cannot come back.
+     * Re-create deleted `item` (`redoItem`, fork patch YP18): its copy, or
+     * `null` when it cannot come back. `items` are re-created with it (a
+     * parent among them first); an attr does not come back over a later
+     * write unless `skipped` (the step's inserts) or `deletedByHistory`
+     * holds that write.
      */
-    redo: <I = StoreStruct>(tr: unknown, item: I, items: Set<I>, um: YUndoManager) => I | null;
+    redo: <I = StoreStruct>(tr: unknown, item: I, items: Set<I>, skipped?: IdSetLike, deletedByHistory?: (id: {
+        client: number;
+        clock: number;
+    }) => boolean) => I | null;
+    /** Merge id sets into a new one. */
+    merge: (sets: IdSetLike[]) => IdSetOf;
+    /** Whether a store struct is an item (not a GC or a Skip). */
+    isItem: (struct: unknown) => struct is StoreStruct;
+    /** Whether `item` sits in `node`'s subtree. */
+    inside: (node: EngineNode, item: StoreStruct) => boolean;
+    /** Keep `item` (and its parents) from collection (`keepItem`). */
+    keep: (item: StoreStruct) => void;
+    /** The newest copy a local undo or redo made of `item` (its `redone` chain), split there, inside `tr`. */
+    latest: (tr: unknown, item: StoreStruct) => StoreStruct;
+    /** Delete `item` inside `tr`. */
+    remove: (tr: unknown, item: StoreStruct) => void;
+    /** Listen to a doc event (vendor `on`/`off`), with the caller's view of its arguments. */
+    on: (doc: EngineDoc, event: string, f: (...args: never[]) => void) => void;
+    off: (doc: EngineDoc, event: string, f: (...args: never[]) => void) => void;
     /**
      * Integrate a new item holding `content` right after `left` (its
      * origin: `left`'s last id) in `parent`, written by `client` at

package/dist/crdt/structs.js

@@ -1,12 +1,34 @@
+/**
+ * Vendor internals — the ONE place Edytor code reaches into the engine's
+ * private state (the struct store, a node's attr items and first item,
+ * the doc's collection settings and transaction events) and calls the
+ * engine's internal functions with Edytor's structural views of its
+ * objects. Centralizing these keeps the blast radius of a vendored engine
+ * upgrade in one module: when an internal is renamed or reshaped, the
+ * accessors below are the lines to change, and the fail-fast checks break
+ * loudly at upgrade time instead of silently disabling run invalidation or
+ * history lineage (the old optional-chained reads turned a rename into a
+ * silent no-op).
+ *
+ * The model works against structural types (`EngineDoc`, `EngineNode`,
+ * `StoreStruct`, `IdSetLike`: the subset it reads) while the engine's
+ * generated declarations (`vendor/yjs/dts`) type its classes; a real engine
+ * object satisfies the structural view at runtime. Each accessor states
+ * that correspondence once, so a call site needs no cast.
+ *
+ * The engine surface is injected (`Y: EngineApi`) like every other bound
+ * module — this file never imports vendor `.js`.
+ */
+import { DEV } from 'esm-env';
 /**
  * The doc's struct store — vendor-internal (`doc.store.clients`).
- * FAIL-FAST: a missing store means the doc is not a vendored-engine doc
- * (or the vendored layout changed) — either way the only honest response
- * is a descriptive throw, never a silent fallback.
+ * FAIL-FAST in development: a missing store means the doc is not a
+ * vendored-engine doc (or the vendored layout changed) — either way the only
+ * honest response is a descriptive throw, never a silent fallback.
  */
 export const clientsOf = (doc) => {
     const clients = doc.store?.clients;
-    if (clients === undefined) {
+    if (DEV && clients === undefined) {
         throw new Error('structs: doc.store.clients missing — the vendored engine layout changed (or this doc is not a vendored-engine doc)');
     }
     return clients;
@@ -28,19 +50,17 @@ export const structAt = (Y, structs, clock) => {
     }
 };
 /**
- * Walk every struct an IdSet covers, invoking `fn` per struct in
- * (client, clock) order. IdSet ranges are item-aligned (they record whole
- * structs), so an overlapping struct is a covered struct — the walk never
- * splits.
- *
- * `fn` returning `false` halts the walk early (caller-side short-circuit).
+ * Walk every struct an IdSet covers, in (client, clock) order: `fn(struct,
+ * from, to)` gets the struct and the clock range `[from, to)` of it the set
+ * covers (a struct can reach past a range a diff of two id sets cut). The
+ * walk never splits a struct; `fn` returning `false` halts it.
  *
  * Returns `false` when coverage was INCOMPLETE — a client's struct list
  * was missing or a range start could not be located — so the caller can
  * fall back to an all-consumers/opaque answer instead of trusting a
  * partial walk. `clientsOf` throws first when the store itself is absent.
  */
-export const walkIdSetStructs = (Y, doc, idSet, fn) => {
+export const walkIdSet = (Y, doc, idSet, fn) => {
     const clients = clientsOf(doc);
     let complete = true;
     let stopped = false;
@@ -66,7 +86,7 @@ export const walkIdSetStructs = (Y, doc, idSet, fn) => {
                 const s = structs[i];
                 if (s.id.clock >= end)
                     break;
-                if (fn(s) === false) {
+                if (fn(s, Math.max(r.clock, s.id.clock), Math.min(end, s.id.clock + s.length)) === false) {
                     stopped = true;
                     return;
                 }
@@ -75,40 +95,6 @@ export const walkIdSetStructs = (Y, doc, idSet, fn) => {
     });
     return complete;
 };
-/**
- * {@link walkIdSetStructs}, clipped: `fn(struct, from, to)` gets the clock
- * range `[from, to)` of the struct the id set covers (a struct can reach past
- * a range a diff of two id sets cut).
- */
-export const walkIdSetRanges = (Y, doc, idSet, fn) => {
-    const clients = clientsOf(doc);
-    let complete = true;
-    idSet.clients.forEach((ranges, client) => {
-        const structs = clients.get(client);
-        if (structs === undefined) {
-            complete = false;
-            return;
-        }
-        for (const r of ranges.getIds()) {
-            const end = r.clock + r.len;
-            let i;
-            try {
-                i = Y.findIndexSS(structs, r.clock);
-            }
-            catch {
-                complete = false;
-                continue;
-            }
-            for (; i < structs.length; i++) {
-                const s = structs[i];
-                if (s.id.clock >= end)
-                    break;
-                fn(s, Math.max(r.clock, s.id.clock), Math.min(end, s.id.clock + s.length));
-            }
-        }
-    });
-    return complete;
-};
 /**
  * The id the local `redone` chain leads `id` to: the copy an undo or redo
  * on THIS replica re-created of a deleted item (redo copies chain), or `id`
@@ -172,10 +158,10 @@ export const asYNode = (node) => node;
 /** A new detached node of the engine, through the structural view. */
 export const newNode = (Y, name) => new Y.Node(name);
 /**
- * A renderer-free bounded read cursor on `node` (the fork's `RangeCursor`),
- * in the caller's view of a cursor.
+ * A bounded read cursor on `node` (the fork's `RangeCursor`), in the
+ * caller's view of a cursor.
  */
-export const rangeCursorOf = (Y, node) => new Y.RangeCursor(asYNode(node), null);
+export const rangeCursorOf = (Y, node) => new Y.RangeCursor(asYNode(node));
 // ── node and document internals ──────────────────────────────────────────
 /**
  * A node's attr entries (vendor `_map`): per key, the item of its current
@@ -189,21 +175,6 @@ export const firstItem = (node) => node._start ?? null;
 export const sequenceLength = (node) => node._length;
 /** The item a node is the value of (`_item`), in the caller's view. */
 export const itemOf = (node) => node._item;
-/**
- * Run `f` with `node`'s renderer (vendor `_renderer`) set aside: a write
- * addresses live-content space, whatever renderer a reader installed.
- */
-export const withoutRenderer = (node, f) => {
-    const n = node;
-    const renderer = n._renderer;
-    n._renderer = null;
-    try {
-        return f();
-    }
-    finally {
-        n._renderer = renderer;
-    }
-};
 /** The doc's struct store (vendor `store`). */
 export const storeOf = (doc) => doc.store;
 /** Whether `doc` collects deleted content at all (vendor `gc`). */
@@ -230,6 +201,18 @@ export const collectNow = (item, tr) => item.gc(tr, false);
  * `afterTransaction`), with the caller's view of a transaction.
  */
 export const onTransaction = (doc, event, f) => doc.on(event, f);
+/**
+ * Whether a transaction changed one of `nodes` or a node under one: its
+ * `changed` types and their ancestors (what a deep observer of `nodes`
+ * would have heard; the engine has none, fork patch YP19).
+ */
+export const changedUnder = (tr, nodes) => {
+    for (const type of tr.changed.keys())
+        for (let t = type; t; t = t._item?.parent)
+            if (nodes.includes(t))
+                return true;
+    return false;
+};
 /** The steps of a history's undo stack (or its redo stack), in the caller's view. */
 export const stepsOf = (stack) => stack;
 /**
@@ -249,10 +232,36 @@ export const engineOps = (Y) => {
         /** The item starting at `client:clock`, split there, inside `tr`. */
         cleanStart: (tr, client, clock) => Y.getItemCleanStart(tr, Y.createID(client, clock)),
         /**
-         * Re-create deleted `item` as the engine's undo does (`redoItem`): its
-         * copy, or `null` when it cannot come back.
+         * Re-create deleted `item` (`redoItem`, fork patch YP18): its copy, or
+         * `null` when it cannot come back. `items` are re-created with it (a
+         * parent among them first); an attr does not come back over a later
+         * write unless `skipped` (the step's inserts) or `deletedByHistory`
+         * holds that write.
          */
-        redo: (tr, item, items, um) => Y.redoItem(tr, item, items, Y.createIdSet(), false, um),
+        redo: (tr, item, items, skipped = Y.createIdSet(), deletedByHistory) => Y.redoItem(tr, item, items, skipped, deletedByHistory),
+        /** Merge id sets into a new one. */
+        merge: (sets) => Y.mergeIdSets(sets),
+        /** Whether a store struct is an item (not a GC or a Skip). */
+        isItem: (struct) => struct instanceof Y.Item,
+        /** Whether `item` sits in `node`'s subtree. */
+        inside: (node, item) => Y.isParentOf(asYNode(node), item),
+        /** Keep `item` (and its parents) from collection (`keepItem`). */
+        keep: (item) => Y.keepItem(item, true),
+        /** The newest copy a local undo or redo made of `item` (its `redone` chain), split there, inside `tr`. */
+        latest: (tr, item) => {
+            if (!item.redone)
+                return item;
+            const store = tr.doc.store;
+            const { item: copy, diff } = Y.followRedone(store, item.id);
+            return (diff > 0
+                ? Y.getItemCleanStart(tr, Y.createID(copy.id.client, copy.id.clock + diff))
+                : copy);
+        },
+        /** Delete `item` inside `tr`. */
+        remove: (tr, item) => item.delete(tr),
+        /** Listen to a doc event (vendor `on`/`off`), with the caller's view of its arguments. */
+        on: (doc, event, f) => doc.on(event, f),
+        off: (doc, event, f) => doc.off(event, f),
         /**
          * Integrate a new item holding `content` right after `left` (its
          * origin: `left`'s last id) in `parent`, written by `client` at