edytor 1.0.0-rc.2 → 1.0.0

package/dist/crdt/rangeDelete.d.ts

@@ -40,52 +40,14 @@
  *   (`table.range`);
  * - the plan's `at` is where the caret lands (`del.range.caret`).
  */
-import type { BlockId, Destination } from './placement/model.js';
-import type { Plan, PlanStep, Prepared } from './edytor-doc.js';
+import type { BlockId } from './placement/model.js';
+import type { Prepared } from './edytor-doc.js';
+import type { OpsContext } from './doc/steps.js';
 /** A position in one document version: a block and a display offset. */
 export type DocPosition = {
     block: BlockId;
     offset: number;
 };
-/** What range deletion reads from the document and the step writers it composes. */
-export type RangeDeleteContext = {
-    ref: (id: BlockId) => BlockId;
-    refused: Prepared;
-    plan: (ids: readonly BlockId[], writes: PlanStep[]) => Plan;
-    order: () => {
-        ids: readonly BlockId[];
-        at: ReadonlyMap<BlockId, number>;
-    };
-    positionOf: (id: BlockId) => Destination | null;
-    /** Display ancestors, nearest first (the root excluded). */
-    ancestorsOf: (id: BlockId) => BlockId[];
-    childrenIds: (parent: BlockId | null) => BlockId[];
-    displayLength: (id: BlockId) => number;
-    /** Live, with its own content node. */
-    contentTarget: (id: BlockId) => boolean;
-    rendersContent: (id: BlockId) => boolean;
-    canMerge: (from: BlockId, into: BlockId) => boolean;
-    isIsland: (id: BlockId) => boolean;
-    /** An island declared `lines` (a code block): it holds only lines. */
-    isLines: (id: BlockId) => boolean;
-    move: (ids: BlockId[], parent: BlockId | null, index: number) => PlanStep[];
-    /** A block that shows only its children: a list, a table row, a column. */
-    isContainer: (id: BlockId) => boolean;
-    /** A container that goes once it loses every child (it holds no text of its own). */
-    emptiable: (id: BlockId) => boolean;
-    /** The kind steps for `from`'s children `kids` landing under `parent` (island and container rules). */
-    settle: (from: BlockId | null, kids: readonly BlockId[], parent: BlockId | null) => PlanStep[];
-    remove: (id: BlockId, kept: readonly BlockId[]) => PlanStep;
-    /**
-     * The steps that dissolve each layout the plan leaves with one item or
-     * none (`layout.dissolving`): `gone` it removes, `leaving` it moves.
-     */
-    dissolving: (gone: readonly BlockId[], leaving: readonly BlockId[], writes: readonly PlanStep[]) => PlanStep[];
-    /** The table `id` is, or whose row or cell it is; `null` for any other block (`table.*`). */
-    tableOf: (id: BlockId) => BlockId | null;
-    /** `id` is a table's cell. */
-    isTableCell: (id: BlockId) => boolean;
-};
 /**
  * What the view knows of a range (view state the document does not hold):
  * whether it hides a block, and, given `removed`, whether the block stays
@@ -95,7 +57,7 @@ export type RangeView = {
     hidden?: (id: BlockId, removed?: ReadonlySet<BlockId>) => boolean;
 };
 /** `deleteRange` and `replaceRange` (the head kept), prepared. */
-export declare const rangeDeleteOps: (c: RangeDeleteContext) => {
+export declare const rangeDeleteOps: (c: OpsContext) => {
     deleteRange: (from: DocPosition, to: DocPosition, view?: RangeView) => Prepared;
     replaceRange: (from: DocPosition, to: DocPosition, view?: RangeView) => Prepared;
 };

package/dist/crdt/rangeDelete.js

@@ -1,3 +1,4 @@
+import { ref } from './doc/plan.js';
 /** `deleteRange` and `replaceRange` (the head kept), prepared. */
 export const rangeDeleteOps = (c) => {
     // `headSpent`: a whole-doc retry keeps the head, but what it hid goes as if it went.
@@ -5,14 +6,14 @@ export const rangeDeleteOps = (c) => {
         // A position names shown text: a live block that renders its own content.
         const holds = (id) => c.contentTarget(id) && c.rendersContent(id);
         const pos = (p) => {
-            const block = c.ref(p.block);
+            const block = ref(p.block);
             const len = holds(block) ? c.displayLength(block) : -1;
             return { block, offset: Math.max(0, Math.min(p.offset, len)) };
         };
         let [s, e] = [pos(from), pos(to)];
         if (!holds(s.block) || !holds(e.block))
-            return c.refused;
-        const { ids, at } = c.order();
+            return c.REFUSED;
+        const { ids, at } = c.view().order;
         if (at.get(s.block) > at.get(e.block) || (s.block === e.block && s.offset > e.offset))
             [s, e] = [e, s];
         const S = s.block;
@@ -104,7 +105,7 @@ export const rangeDeleteOps = (c) => {
             if (!doomed.has(parent(id)))
                 writes.push(c.remove(id, kept));
         // A layout the range leaves with one column dissolves (`layout.dissolving`).
-        writes.push(...c.dissolving([...doomed, ...(merges ? [E] : [])], rescued, writes));
+        writes.push(...c.dissolving(new Set([...doomed, ...(merges ? [E] : [])]), rescued, writes));
         const caret = (() => {
             if (!doomed.has(S))
                 return s;
@@ -135,7 +136,7 @@ export const rangeDeleteOps = (c) => {
      * come after the start in reading order); the caret lands at the start.
      */
     const inTables = (s, e, view) => {
-        const { ids, at } = c.order();
+        const { ids, at } = c.view().order;
         const [S, E] = [s.block, e.block];
         const kept = new Set(c.ancestorsOf(E));
         const between = ids.slice(at.get(S) + 1, at.get(E)).filter((id) => !view.hidden?.(id));
@@ -161,7 +162,7 @@ export const rangeDeleteOps = (c) => {
         const roots = [...doomed].filter((id) => !doomed.has(parentOf(id)));
         for (const id of roots)
             writes.push(c.remove(id, []));
-        writes.push(...c.dissolving(roots, [], writes));
+        writes.push(...c.dissolving(new Set(roots), [], writes));
         return { ...c.plan([S], writes), at: s };
     };
     return { deleteRange: prepare(false), replaceRange: prepare(true) };

package/dist/crdt/restore.d.ts

@@ -24,9 +24,29 @@
  * 6. the document's data, patched to the snapshot's.
  */
 import type { EngineDoc } from './engine-api.js';
-import type { BlockId, ContentItem, InlineSpec, PlacementModel } from './placement/model.js';
+import { type BlockId, type ContentItem, type InlineSpec, type PlacementModel } from './placement/model.js';
 import type { DataPatch } from './data.js';
 import type { JSONDoc } from '../utils/json.js';
+/** One display unit: a character (a code point) with its marks, or an inline atom, keyed for comparison. */
+export type Unit = {
+    key: string;
+    item: ContentItem;
+};
+/** `items` one unit each (a character with its marks, or an atom), keyed for comparison. */
+export declare const unitsOf: (items: readonly ContentItem[]) => Unit[];
+/** The one changed stretch from `x` to `y`: `x[p, e)` became `mid`. */
+export declare const hunk: (x: readonly Unit[], y: readonly Unit[]) => {
+    p: number;
+    e: number;
+    mid: Unit[];
+};
+/**
+ * Make block `id`'s content, `have` (its units now), read `want`: the one
+ * changed stretch between their common prefix and suffix is deleted and
+ * written again through the facade (an atom without an id gets a fresh
+ * one). Whether it wrote anything.
+ */
+export declare const rewriteContent: <Plan>(facade: Pick<RestoreFacade<Plan>, "apply" | "prepare">, id: BlockId, have: readonly Unit[], want: readonly Unit[]) => boolean;
 export type RestoreReport = {
     /** Blocks revived (their delete or withdraw marks removed). */
     revived: number;

package/dist/crdt/restore.js

@@ -1,10 +1,11 @@
+import { blockNodeOf, materializeSpec, ranksAt, view as modelView, writePlacement } from './placement/model.js';
 import { DEL_PREFIX, TYPE, WITHDRAW_PREFIX } from './schema.js';
-import { patchWrites, writeLeaves } from './data.js';
+import { common, patchWrites, writeLeaves } from './data.js';
 import { canonKey } from './text/model.js';
 import { randOf } from './rand.js';
 import { toBlockSpec } from '../utils/json.js';
 /** `items` one unit each (a character with its marks, or an atom), keyed for comparison. */
-const unitsOf = (items) => {
+export const unitsOf = (items) => {
     const out = [];
     for (const item of items) {
         if (item.kind === 'inline') {
@@ -42,6 +43,47 @@ const runsOf = (units) => {
     }
     return out;
 };
+/** The one changed stretch from `x` to `y`: `x[p, e)` became `mid`. */
+export const hunk = (x, y) => {
+    let p = 0;
+    while (p < x.length && p < y.length && x[p].key === y[p].key)
+        p++;
+    let q = 0;
+    while (q < x.length - p &&
+        q < y.length - p &&
+        x[x.length - 1 - q].key === y[y.length - 1 - q].key)
+        q++;
+    return { p, e: x.length - q, mid: y.slice(p, y.length - q) };
+};
+/** A unit's width in the block's offsets (a character's UTF-16 length; an atom counts 1). */
+const width = (u) => (u.item.kind === 'text' ? u.item.text.length : 1);
+/**
+ * Make block `id`'s content, `have` (its units now), read `want`: the one
+ * changed stretch between their common prefix and suffix is deleted and
+ * written again through the facade (an atom without an id gets a fresh
+ * one). Whether it wrote anything.
+ */
+export const rewriteContent = (facade, id, have, want) => {
+    const { p, e, mid } = hunk(have, want);
+    if (p === e && mid.length === 0)
+        return false;
+    let at = have.slice(0, p).reduce((n, u) => n + width(u), 0);
+    const gone = have.slice(p, e).reduce((n, u) => n + width(u), 0);
+    if (gone > 0)
+        facade.apply(facade.prepare.deleteText(id, at, gone));
+    for (const item of runsOf(mid)) {
+        if (item.kind === 'text') {
+            facade.apply(facade.prepare.insertText(id, at, item.text, item.marks ?? {}));
+            at += item.text.length;
+        }
+        else {
+            const atom = { id: item.id || crypto.randomUUID(), type: item.type, data: item.data };
+            facade.apply(facade.prepare.insertInline(id, at, atom));
+            at += 1;
+        }
+    }
+    return true;
+};
 /** Visible-tree order of `specs` with each block's snapshot parent. */
 const walk = (specs, parent, into) => {
     for (const spec of specs) {
@@ -50,43 +92,16 @@ const walk = (specs, parent, into) => {
     }
     return into;
 };
-/** The ids of `list` (positions in another order, `-1` absent) on its longest increasing run. */
-const longestRun = (positions) => {
-    const tails = [];
-    const tailAt = [];
-    const links = new Array(positions.length).fill(-1);
-    positions.forEach((position, i) => {
-        if (position < 0)
-            return;
-        let lo = 0;
-        let hi = tails.length;
-        while (lo < hi) {
-            const mid = (lo + hi) >> 1;
-            if (tails[mid] < position)
-                lo = mid + 1;
-            else
-                hi = mid;
-        }
-        tails[lo] = position;
-        tailAt[lo] = i;
-        links[i] = lo > 0 ? tailAt[lo - 1] : -1;
-    });
-    const kept = new Set();
-    for (let i = tails.length ? tailAt[tails.length - 1] : -1; i !== -1; i = links[i])
-        kept.add(i);
-    return kept;
-};
 /**
  * Make the visible document `doc` (through `facade`, the facade over it)
  * equal `json`. Runs inside the caller's transaction; the writer is
  * `doc.clientID`. See the module comment for what it writes.
  */
 export const restoreDocument = (doc, facade, json) => {
-    const M = facade.model;
     const report = { revived: 0, moved: 0, rewritten: 0, created: 0, deleted: 0 };
     const specs = json.children.map((block) => toBlockSpec(block));
     const all = walk(specs, null, new Map());
-    const node = (id) => M.blockNodeOf(doc, id);
+    const node = (id) => blockNodeOf(doc, id);
     // 1 · Revive, and free every snapshot block from the claims on it.
     for (const id of all.keys()) {
         const n = node(id);
@@ -99,7 +114,7 @@ export const restoreDocument = (doc, facade, json) => {
             report.revived++;
     }
     {
-        const { blocks } = M.view(doc);
+        const { blocks } = modelView(doc);
         for (const rec of blocks.values()) {
             // A deleted holder's claims are void (and stay so): only the others.
             if (rec.deleted || rec.claimsNode === undefined)
@@ -131,7 +146,8 @@ export const restoreDocument = (doc, facade, json) => {
             continue;
         const slots = facade.childSlots(parent);
         const index = new Map(slots.map((slot, i) => [slot.id, i]));
-        const kept = longestRun(list.map((spec) => index.get(spec.id) ?? -1));
+        // What a longest common run of the two orders keeps stays where it is.
+        const kept = new Set(common(slots.map((slot) => slot.id), list.map((spec) => spec.id)).map(([, j]) => j));
         let prev;
         list.forEach((spec, i) => {
             if (kept.has(i)) {
@@ -148,14 +164,14 @@ export const restoreDocument = (doc, facade, json) => {
                 ...(prev === undefined ? [] : [{ rank: prev }]),
                 ...(next === undefined ? [] : [{ rank: next }])
             ];
-            const [rank] = M.ranksAt(bounds, prev === undefined ? 0 : 1, 1, doc.clientID, randOf(doc));
+            const [rank] = ranksAt(bounds, prev === undefined ? 0 : 1, 1, doc.clientID, randOf(doc));
             const n = node(spec.id);
             if (n === null) {
-                M.materializeSpec(doc, { ...spec, children: [] }, parent, rank);
+                materializeSpec(doc, { ...spec, children: [] }, parent, rank);
                 report.created++;
             }
             else {
-                M.writePlacement(doc, n, parent, rank);
+                writePlacement(doc, n, parent, rank);
                 report.moved++;
             }
             prev = rank;
@@ -167,39 +183,18 @@ export const restoreDocument = (doc, facade, json) => {
         let have = unitsOf(facade.contentItems(id));
         if (have.length === want.length && have.every((u, i) => u.key === want[i].key))
             continue;
-        const rec = M.view(doc).blocks.get(id);
+        const rec = modelView(doc).blocks.get(id);
         const claims = rec?.claimsNode;
         if (claims !== undefined && claims.length > 0) {
             claims.delete(0, claims.length);
             have = unitsOf(facade.contentItems(id));
         }
-        let head = 0;
-        while (head < have.length && head < want.length && have[head].key === want[head].key)
-            head++;
-        let tail = 0;
-        while (tail < have.length - head &&
-            tail < want.length - head &&
-            have[have.length - 1 - tail].key === want[want.length - 1 - tail].key)
-            tail++;
-        const removed = have.length - head - tail;
-        if (removed > 0)
-            facade.apply(facade.prepare.deleteText(id, head, removed));
-        let at = head;
-        for (const item of runsOf(want.slice(head, want.length - tail))) {
-            if (item.kind === 'text') {
-                facade.apply(facade.prepare.insertText(id, at, item.text, item.marks ?? {}));
-                at += item.text.length;
-            }
-            else {
-                facade.apply(facade.prepare.insertInline(id, at, { id: item.id, type: item.type, data: item.data }));
-                at += 1;
-            }
-        }
+        rewriteContent(facade, id, have, want);
         report.rewritten++;
     }
     // 5 · Every visible block outside the snapshot is deleted, with what it displays.
     for (let round = 0; round < 8; round++) {
-        const view = M.view(doc);
+        const view = modelView(doc);
         const extra = view.order.ids.filter((id) => !all.has(id));
         if (extra.length === 0)
             break;

package/dist/crdt/schema.d.ts

@@ -50,7 +50,7 @@ export declare const INLINE_NODE = "inline";
 /** Attr keys on a block node (`SCHEMA.blockAttrs`). */
 export declare const ID = "id";
 export declare 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 declare const DATA = "data";
 /** A data leaf: `d/` and its path, RFC 6901 escaped (`crdt/data.ts`). */
 export declare const DATA_LEAF_PREFIX = "d/";
@@ -91,7 +91,7 @@ export declare const AT = "at";
 export declare const REC_PREFIX = "b/";
 /** The schema generation stamped on the `meta` root (`v`) and its manifest name (`schema`). */
 export declare const SCHEMA: {
-    readonly version: 5;
+    readonly version: 6;
     readonly name: "edytor-doc";
     readonly roots: {
         readonly registry: "blocks";

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