edytor 1.0.0-rc.2 → 1.0.0

package/dist/crdt/placement/rank.d.ts

@@ -69,11 +69,7 @@ export declare const encodeRank: (segs: readonly RankSeg[]) => string;
  * strictly-between key always exist (modulo the documented VMIN bound).
  */
 export declare const rankBetween: (left: string | undefined, right: string | undefined, clientId: number, rand?: () => number, compact?: boolean) => string;
-/**
- * The digit of the run marker data arrays wrote up to 0.1.0-next.21 (a run
- * of that form is the marker segment, then ranks of the client's own): still
- * read as a run, so what a client inserts there stays in it.
- */
+/** The base of the run band: a run member's digit lies just above it. */
 export declare const RANK_RUN: number;
 /**
  * A rank in `(left, right)` for an insert right after `left` — one rule for

package/dist/crdt/placement/rank.js

@@ -66,6 +66,10 @@ export class RankSpaceExhausted extends Error {
         this.name = 'RankSpaceExhausted';
     }
 }
+/** A rank this module cannot encode, a malformed rank, or bounds out of order (a caller's error). */
+const bad = (what) => {
+    throw new Error(`rank: ${what}`);
+};
 /** `n` (≥ 0) as exactly `width` base-64 places. */
 const places = (n, width) => {
     let out = '';
@@ -74,7 +78,7 @@ const places = (n, width) => {
         n = Math.floor(n / BASE);
     }
     if (n > 0)
-        throw new Error(`rank encode overflow: value exceeds ${width} places`);
+        bad('overflow');
     return out;
 };
 /** How many base-64 places `m` (≥ 1) takes. */
@@ -87,13 +91,13 @@ const width = (m) => {
 /** A signed integer as a self-delimiting, order-preserving string. */
 const encInt = (v) => {
     if (!Number.isSafeInteger(v))
-        throw new Error(`rank encode: bad digit ${v}`);
+        bad('digit');
     if (v === 0)
         return 'H';
     const m = Math.abs(v);
     const k = width(m);
     if (k > MAX_PLACES)
-        throw new Error(`rank encode overflow: ${v}`);
+        bad('overflow');
     if (v > 0)
         return String.fromCharCode(ZERO + k) + places(m, k);
     // Complemented: a greater magnitude sorts first.
@@ -102,16 +106,14 @@ const encInt = (v) => {
 /** The integer at `s[i]`, and where it ends. */
 const decInt = (s, i) => {
     const k = s.charCodeAt(i) - ZERO;
-    if (Number.isNaN(k) || Math.abs(k) > MAX_PLACES)
-        throw new Error(`rank decode: bad length at ${i}`);
     const n = Math.abs(k);
-    if (i + 1 + n > s.length)
-        throw new Error(`rank decode: truncated at ${i}`);
+    if (Number.isNaN(k) || n > MAX_PLACES || i + 1 + n > s.length)
+        bad('malformed');
     let x = 0;
     for (let j = i + 1; j <= i + n; j++) {
         const d = ALPHABET.indexOf(s[j]);
         if (d < 0)
-            throw new Error(`rank decode: bad char ${s[j]}`);
+            bad('malformed');
         x = x * BASE + d;
     }
     const v = k === 0 ? 0 : k > 0 ? x : -(BASE ** n - 1 - x);
@@ -120,7 +122,7 @@ const decInt = (s, i) => {
 /** Decode a rank string into its segment array (`t: Infinity` where a segment has no tie). */
 export const decodeRank = (rank) => {
     if (rank.length === 0)
-        throw new Error('rank decode: empty');
+        bad('malformed');
     const segs = [];
     for (let i = 0; i < rank.length;) {
         const [v, j] = decInt(rank, i);
@@ -131,7 +133,7 @@ export const decodeRank = (rank) => {
         segs.push({ v, t });
     }
     if (segs[segs.length - 1].t === Infinity)
-        throw new Error('rank decode: untied last segment');
+        bad('malformed');
     return segs;
 };
 /** Encode segments back to the persisted string form. */
@@ -139,7 +141,7 @@ export const encodeRank = (segs) => {
     let out = '';
     for (const { v, t } of segs) {
         if (v < RANK_VMIN || v > RANK_VMAX)
-            throw new Error(`rank encode overflow: digit ${v}`);
+            bad('overflow');
         out += encInt(v);
         if (t !== Infinity)
             out += TIE + encInt(t);
@@ -170,9 +172,8 @@ const APPEND_WINDOW = 2 ** 16;
 export const rankBetween = (left, right, clientId, rand = Math.random, compact = true) => {
     const L = left === undefined ? [] : decodeRank(left);
     const R = right === undefined ? [] : decodeRank(right);
-    if (left !== undefined && right !== undefined && left >= right) {
-        throw new Error(`rankBetween: left >= right (${left} !< ${right})`);
-    }
+    if (left !== undefined && right !== undefined && left >= right)
+        bad('left >= right');
     const rightOpen = right === undefined;
     const path = [];
     // `locked`: the emitted prefix already sorts below the right bound.
@@ -209,9 +210,8 @@ export const rankBetween = (left, right, clientId, rand = Math.random, compact =
             // Right bound ended while left continues: valid only when `locked`
             // already holds (an earlier copied segment was < the right's). If not,
             // right is a proper prefix of left — i.e. right < left, caller error.
-            if (!rightOpen && !locked) {
-                throw new Error(`rankBetween: right bound is a prefix of left (right < left)`);
-            }
+            if (!rightOpen && !locked)
+                bad('left >= right');
             // No right bound at this level (open, or `locked` below it): emit
             // within the bounded append window — dense growth, and one more
             // level per exhausted gap, not one per insert (SW12-crdt-2).
@@ -254,16 +254,12 @@ export const rankBetween = (left, right, clientId, rand = Math.random, compact =
         else if (c > 0 && !locked) {
             // Never locked and left's segment exceeds right's at the first
             // differing level → left > right (invalid bounds — caller error).
-            throw new Error(`rankBetween: left >= right at level ${i}`);
+            bad('left >= right');
         }
         path.push(lSeg);
     }
 };
-/**
- * The digit of the run marker data arrays wrote up to 0.1.0-next.21 (a run
- * of that form is the marker segment, then ranks of the client's own): still
- * read as a run, so what a client inserts there stays in it.
- */
+/** The base of the run band: a run member's digit lies just above it. */
 export const RANK_RUN = -(2 ** 30);
 /**
  * A run member's digit lies in `(RANK_RUN, RANK_RUN + RUN_BAND)`: below every
@@ -297,25 +293,25 @@ export const rankAfter = (left, right, client, rand = Math.random) => {
     const top = encodeRank([{ v: RANK_RUN + RUN_BAND, t: 0 }]);
     /**
      * `prefix` and a rank after `after` (`undefined`: the run opens) in the
-     * run: inside the band when `band`. Opening, it takes the band's middle,
-     * or a digit below the run's first member; at the run's end it appends as
-     * an open end does (a window, not half the band); else between the two.
+     * run, inside the band. Opening, it takes the band's middle, or a digit
+     * below the run's first member; at the run's end it appends as an open
+     * end does (a window, not half the band); else between the two.
      */
-    const own = (prefix, after, band) => {
+    const own = (prefix, after) => {
         const tail = (r) => r && r.length > prefix.length && r.startsWith(prefix) ? r.slice(prefix.length) : undefined;
         let next = tail(right);
-        if (band && next !== undefined && next > top)
+        if (next !== undefined && next > top)
             next = undefined;
         let mine;
         if (after === undefined) {
             if (next === undefined)
                 mine = encodeRank([{ v: RUN_START, t: client }]);
-            else if (band && next > bottom)
+            else if (next > bottom)
                 mine = rankBetween(bottom, next, client, rand, false);
             else
                 return plain();
         }
-        else if (next === undefined && band) {
+        else if (next === undefined) {
             const append = rankBetween(after, undefined, client, rand, false);
             mine = append < top ? append : rankBetween(after, top, client, rand, false);
         }
@@ -326,17 +322,11 @@ export const rankAfter = (left, right, client, rand = Math.random) => {
     };
     // A member of the client's run: the next member, inside the band.
     if (last.t === client && inRun(last.v))
-        return own(encodeRank(segs.slice(0, -1)), encodeRank([last]), true);
-    // A run of the earlier form (the marker, then the client's ranks): stays in it.
-    const k = segs.findLastIndex((g) => g.v === RANK_RUN);
-    if (k >= 0 && segs[k].t === client) {
-        const prefix = encodeRank(segs.slice(0, k + 1));
-        return own(prefix, left.length > prefix.length ? left.slice(prefix.length) : undefined, false);
-    }
+        return own(encodeRank(segs.slice(0, -1)), encodeRank([last]));
     // A rank the client made: its run opens right after it. The prefix keeps
     // `left`'s tie: a peer's rank of the same digit and a greater tie
     // then sorts after the whole run, never between `left` and it.
     if (last.t === client)
-        return own(left, undefined, true);
+        return own(left, undefined);
     return plain();
 };

package/dist/crdt/protocol.d.ts

@@ -16,7 +16,7 @@
  *   codec that needs no `Awareness` instance (whose sweep timer blocks
  *   hibernation);
  * - the admission gates (`assertAdmission`, `inspectAdmission`, …) that
- *   diagnostics and migration tooling read;
+ *   diagnostics read;
  * - the raw provider classes behind `createIndexeddbSync` and
  *   `createWebsocketSync` (`IndexeddbPersistence`, `WebsocketProvider`)
  *   and `storeState`.
@@ -24,15 +24,14 @@
  * `pnpm check:worker` keeps this graph Worker-safe; the site's
  * `server/protocol` page documents the contract.
  */
-export { bindCrdt, type Crdt, type EngineApi, type EngineDoc, type EngineNode, type EngineDeepEvent, type EngineTransaction, type EngineItemRef, type YNode, type YItem, type YDoc, type YUndoManager, type YTransaction } from './index.js';
+export { bindCrdt, type Crdt, type EngineApi, type EngineDoc, type EngineNode, type EngineTransaction, type EngineItemRef, type YNode, type YItem, type YDoc, type YUndoManager, type YTransaction } from './index.js';
 export { SCHEMA_VERSION, META_KEY } from './edytor-doc.js';
-export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, STORED_GENERATION_RECORD, STORAGE_FORMAT, GenerationMismatchError, readProtocolVersion, type GenerationRecord, type StorageFormat } from './protocols/envelope.js';
-export { PREVIOUS_SCHEMA, isPreviousGenerationRecord } from './migration/generation.js';
+export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, GenerationMismatchError, readProtocolVersion, type GenerationRecord } from './protocols/envelope.js';
 export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, messageComments, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkLimitError, type ChunkReader, CLOSE } from './providers/room.js';
 export { messageYjsSyncStep1, messageYjsSyncStep2, messageYjsUpdate, type SyncProtocol } from './protocols/sync.js';
 export { messagePermissionDenied, messageReadOnly, writePermissionDenied, writeReadOnly } from './protocols/auth.js';
 export { commentsSubscribe, commentsSnapshot, commentsChange, writeCommentsSubscribe, writeCommentsSnapshot, writeCommentsChange, readCommentsMessage, type CommentChange, type CommentMessage, type CommentSnapshot, type CommentThread, type ThreadComment } from './protocols/comments.js';
-export { applyAwarenessUpdate, encodeAwarenessUpdate, modifyAwarenessUpdate, readAwarenessEntries, writeAwarenessEntries, type AwarenessEntry } from './protocols/awareness.js';
+export { applyAwarenessUpdate, encodeAwarenessUpdate, readAwarenessEntries, writeAwarenessEntries, type AwarenessEntry } from './protocols/awareness.js';
 export { createDecoder, readVarUint, readVarUint8Array, type Decoder } from 'lib0-v14/decoding';
 export { writeVarUint8Array, type Encoder } from 'lib0-v14/encoding';
 export { assertAdmission, assertSchema, assertUsableDoc, checkSchema, inspectAdmission, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError, UndecodableUpdateError, UnsupportedDocError, type AdmissionResult, type AdmissionVerdict, type SchemaProblem } from './admission.js';

package/dist/crdt/protocol.js

@@ -16,7 +16,7 @@
  *   codec that needs no `Awareness` instance (whose sweep timer blocks
  *   hibernation);
  * - the admission gates (`assertAdmission`, `inspectAdmission`, …) that
- *   diagnostics and migration tooling read;
+ *   diagnostics read;
  * - the raw provider classes behind `createIndexeddbSync` and
  *   `createWebsocketSync` (`IndexeddbPersistence`, `WebsocketProvider`)
  *   and `storeState`.
@@ -28,14 +28,13 @@
 export { bindCrdt } from './index.js';
 // ── The frame contract and the generation ──────────────────────────────
 export { SCHEMA_VERSION, META_KEY } from './edytor-doc.js';
-export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, STORED_GENERATION_RECORD, STORAGE_FORMAT, GenerationMismatchError, readProtocolVersion } from './protocols/envelope.js';
-export { PREVIOUS_SCHEMA, isPreviousGenerationRecord } from './migration/generation.js';
+export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, GenerationMismatchError, readProtocolVersion } from './protocols/envelope.js';
 // ── Message types, acknowledgements and chunks ─────────────────────────
 export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, messageComments, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkLimitError, CLOSE } from './providers/room.js';
 export { messageYjsSyncStep1, messageYjsSyncStep2, messageYjsUpdate } from './protocols/sync.js';
 export { messagePermissionDenied, messageReadOnly, writePermissionDenied, writeReadOnly } from './protocols/auth.js';
 export { commentsSubscribe, commentsSnapshot, commentsChange, writeCommentsSubscribe, writeCommentsSnapshot, writeCommentsChange, readCommentsMessage } from './protocols/comments.js';
-export { applyAwarenessUpdate, encodeAwarenessUpdate, modifyAwarenessUpdate, readAwarenessEntries, writeAwarenessEntries } from './protocols/awareness.js';
+export { applyAwarenessUpdate, encodeAwarenessUpdate, readAwarenessEntries, writeAwarenessEntries } from './protocols/awareness.js';
 // Minimal wire codec for frame bodies (lib0 — the codec the frames are
 // written with): read the header/subtype/payload, write a payload into a
 // `frame` callback's encoder.

package/dist/crdt/protocols/awareness.d.ts

@@ -32,12 +32,12 @@ type AwarenessEvents = {
  * outdated, and remote states expire after {@link outdatedTimeout}.
  */
 export declare class Awareness extends IsolatedObservable<AwarenessEvents> {
+    #private;
     doc: AwarenessDoc;
     clientID: number;
     /** Maps from client id to client state */
     states: AwarenessStates;
     meta: Map<number, MetaClientState>;
-    private _checkInterval;
     /**
      * Idempotence guard — `destroy()` is reachable twice through the
      * OWNED-doc + OWNED-awareness composition: `EdytorDocument.destroy()`
@@ -59,6 +59,7 @@ export declare class Awareness extends IsolatedObservable<AwarenessEvents> {
  * peers. This change is propagated to remote clients.
  */
 export declare const removeAwarenessStates: (awareness: Awareness, clients: number[], origin: unknown) => void;
+/** The update carrying `clients`' entries of `awareness` (their states in `states`). */
 export declare const encodeAwarenessUpdate: (awareness: Awareness, clients: number[], states?: AwarenessStates) => Uint8Array;
 /** One awareness entry on the wire: a client's clock and state (`null` = removed). */
 export type AwarenessEntry = {
@@ -72,13 +73,8 @@ export type AwarenessEntry = {
  * must not hold timers (a hibernating Durable Object) can track presence.
  */
 export declare const readAwarenessEntries: (update: Uint8Array) => AwarenessEntry[];
-/** Instance-free awareness codec: encode entries as an update (the wire format of {@link encodeAwarenessUpdate}). */
+/** Instance-free awareness codec: encode entries as an update. */
 export declare const writeAwarenessEntries: (entries: readonly AwarenessEntry[]) => Uint8Array;
-/**
- * Modify the content of an awareness update before re-encoding it to an
- * awareness update — e.g. a central server preventing identity hijacking.
- */
-export declare const modifyAwarenessUpdate: (update: Uint8Array, modify: (state: Record<string, unknown> | null) => Record<string, unknown> | null) => Uint8Array;
 /**
  * Apply an encoded awareness update. `origin` is forwarded on the emitted
  * change/update events.

package/dist/crdt/protocols/awareness.js

@@ -14,11 +14,11 @@
  * wire compatibility is not peer compatibility (presence payload versioning
  * is the presence layer's concern).
  */
+import { jsonEquals } from '../../utils/json.js';
 import * as encoding from 'lib0-v14/encoding';
 import * as decoding from 'lib0-v14/decoding';
 import * as time from 'lib0-v14/time';
 import * as math from 'lib0-v14/math';
-import * as f from 'lib0-v14/function';
 import { IsolatedObservable } from './observable.js';
 export const outdatedTimeout = 30000;
 /**
@@ -33,7 +33,7 @@ export class Awareness extends IsolatedObservable {
     /** Maps from client id to client state */
     states;
     meta;
-    _checkInterval;
+    #checkInterval;
     /**
      * Idempotence guard — `destroy()` is reachable twice through the
      * OWNED-doc + OWNED-awareness composition: `EdytorDocument.destroy()`
@@ -49,7 +49,7 @@ export class Awareness extends IsolatedObservable {
         this.clientID = doc.clientID;
         this.states = new Map();
         this.meta = new Map();
-        this._checkInterval = setInterval(() => {
+        this.#checkInterval = setInterval(() => {
             const now = time.getUnixTime();
             const localMeta = this.meta.get(this.clientID);
             if (this.getLocalState() !== null &&
@@ -73,7 +73,7 @@ export class Awareness extends IsolatedObservable {
         // Node returns a `Timeout` (has `unref`), browsers a number — a stale-
         // state sweep must never be the thing keeping a node/SSR process alive
         // (a server-rendered component can't run its client teardown path).
-        this._checkInterval.unref?.();
+        this.#checkInterval.unref?.();
         doc.on('destroy', () => {
             this.destroy();
         });
@@ -87,7 +87,7 @@ export class Awareness extends IsolatedObservable {
         this.emit('destroy', [this]);
         this.setLocalState(null);
         super.destroy();
-        clearInterval(this._checkInterval);
+        clearInterval(this.#checkInterval);
     }
     getLocalState() {
         return this.states.get(this.clientID) || null;
@@ -121,7 +121,7 @@ export class Awareness extends IsolatedObservable {
         }
         else {
             updated.push(clientID);
-            if (!f.equalityDeep(prevState, state)) {
+            if (!jsonEquals(prevState, state)) {
                 filteredUpdated.push(clientID);
             }
         }
@@ -168,20 +168,12 @@ export const removeAwarenessStates = (awareness, clients, origin) => {
         awareness.emit('update', [{ added: [], updated: [], removed }, origin]);
     }
 };
-export const encodeAwarenessUpdate = (awareness, clients, states = awareness.states) => {
-    const len = clients.length;
-    const encoder = encoding.createEncoder();
-    encoding.writeVarUint(encoder, len);
-    for (let i = 0; i < len; i++) {
-        const clientID = clients[i];
-        const state = states.get(clientID) || null;
-        const clock = awareness.meta.get(clientID).clock;
-        encoding.writeVarUint(encoder, clientID);
-        encoding.writeVarUint(encoder, clock);
-        encoding.writeVarString(encoder, JSON.stringify(state));
-    }
-    return encoding.toUint8Array(encoder);
-};
+/** The update carrying `clients`' entries of `awareness` (their states in `states`). */
+export const encodeAwarenessUpdate = (awareness, clients, states = awareness.states) => writeAwarenessEntries(clients.map((clientID) => ({
+    clientID,
+    clock: awareness.meta.get(clientID).clock,
+    state: states.get(clientID) || null
+})));
 /**
  * Instance-free awareness codec: decode an update into its entries. Pure —
  * no `Awareness` (whose constructor starts an interval), so a relay that
@@ -195,7 +187,7 @@ export const readAwarenessEntries = (update) => {
         state: JSON.parse(decoding.readVarString(decoder))
     }));
 };
-/** Instance-free awareness codec: encode entries as an update (the wire format of {@link encodeAwarenessUpdate}). */
+/** Instance-free awareness codec: encode entries as an update. */
 export const writeAwarenessEntries = (entries) => encoding.encode((encoder) => {
     encoding.writeVarUint(encoder, entries.length);
     for (const { clientID, clock, state } of entries) {
@@ -204,27 +196,19 @@ export const writeAwarenessEntries = (entries) => encoding.encode((encoder) => {
         encoding.writeVarString(encoder, JSON.stringify(state));
     }
 });
-/**
- * Modify the content of an awareness update before re-encoding it to an
- * awareness update — e.g. a central server preventing identity hijacking.
- */
-export const modifyAwarenessUpdate = (update, modify) => writeAwarenessEntries(readAwarenessEntries(update).map((entry) => ({ ...entry, state: modify(entry.state) })));
 /**
  * Apply an encoded awareness update. `origin` is forwarded on the emitted
  * change/update events.
  */
 export const applyAwarenessUpdate = (awareness, update, origin) => {
-    const decoder = decoding.createDecoder(update);
     const timestamp = time.getUnixTime();
     const added = [];
     const updated = [];
     const filteredUpdated = [];
     const removed = [];
-    const len = decoding.readVarUint(decoder);
-    for (let i = 0; i < len; i++) {
-        const clientID = decoding.readVarUint(decoder);
-        let clock = decoding.readVarUint(decoder);
-        const state = JSON.parse(decoding.readVarString(decoder));
+    for (const entry of readAwarenessEntries(update)) {
+        const { clientID, state } = entry;
+        let { clock } = entry;
         const clientMeta = awareness.meta.get(clientID);
         const prevState = awareness.states.get(clientID);
         const currClock = clientMeta === undefined ? 0 : clientMeta.clock;
@@ -255,7 +239,7 @@ export const applyAwarenessUpdate = (awareness, update, origin) => {
                 removed.push(clientID);
             }
             else if (state !== null) {
-                if (!f.equalityDeep(state, prevState)) {
+                if (!jsonEquals(state, prevState)) {
                     filteredUpdated.push(clientID);
                 }
                 updated.push(clientID);

package/dist/crdt/protocols/envelope.d.ts

@@ -7,7 +7,7 @@
  *
  * ```
  *   varuint GENERATION | varuint messageType | payload
- *   GENERATION = PROTOCOL_VERSION * 1000 + SCHEMA_VERSION   (14005 at schema 5)
+ *   GENERATION = PROTOCOL_VERSION * 1000 + SCHEMA_VERSION   (14006 at schema 6)
  * ```
  *
  * The word names the whole generation — engine and wire (the protocol,
@@ -35,47 +35,27 @@ export declare const generationWord: (schema: number) => number;
 export declare const GENERATION: number;
 /**
  * Storage-generation prefix for the v14 IndexedDB databases: one database
- * per schema generation since generation 5, so a generation-4 store is
- * left as it was (rollback) beside its successor.
+ * per schema generation, so an earlier generation's store is left as it
+ * was beside its successor (and never read).
  */
-export declare const GENERATION_PREFIX = "edytor-v14-g5:";
-/** The prefix of the IndexedDB databases of schema generations 1 to 4. */
-export declare const PREVIOUS_GENERATION_PREFIX = "edytor-v14:";
+export declare const GENERATION_PREFIX: string;
 /** The IndexedDB name a v14 provider uses for logical document `name`. */
 export declare const generationDbName: (name: string) => string;
 /**
- * How a container stores its snapshots: `'v1'` (the
- * update encoding, every container before it) or `'v2'` (the columnar
- * encoding, gzip-compressed where the platform has `CompressionStream`;
- * a compressed snapshot starts with gzip's `1f 8b`, a v2 update with
- * `00`). Update rows stay v1 in both: a keystroke's update is smaller in
- * v1 (24 bytes against 28, a one-character delete 13 against 24).
+ * Record written to the `custom` store marking a DB as this generation's.
+ * Every row of a container holds an update in the engine's one encoding;
+ * a snapshot row may be gzip-compressed (`crdt/storage.ts`).
  */
-export type StorageFormat = 'v1' | 'v2';
-/** Record written to the `custom` store marking a DB as this generation's. */
 export type GenerationRecord = {
     engine: 'yjs-v14';
     protocol: number;
     schema: number;
-    /** Absent: `'v1'` (written before the v2 snapshots). */
-    storage?: StorageFormat;
 };
 export declare const GENERATION_KEY = "generation";
-/** This generation's wire and schema (the storage format aside: {@link STORED_GENERATION_RECORD}). */
+/** This generation's record. */
 export declare const GENERATION_RECORD: GenerationRecord;
-/** The storage format this build writes its snapshots in. */
-export declare const STORAGE_FORMAT: StorageFormat;
-/** The record this build stamps a container with (its generation and its storage format). */
-export declare const STORED_GENERATION_RECORD: GenerationRecord;
-/**
- * Is `v` this generation's container record? A record without `schema` was
- * written before the schema joined the generation, by builds that spoke
- * schema 1 only — it is a schema-1 record. A storage format this build
- * does not read (a later one) is another generation's.
- */
+/** Is `v` this generation's container record? Any other is refused, never read. */
 export declare const isGenerationRecord: (v: unknown) => v is GenerationRecord;
-/** The storage format of a container record ({@link isGenerationRecord} first). */
-export declare const storageOf: (record: GenerationRecord) => StorageFormat;
 export declare class GenerationMismatchError extends Error {
     readonly dbName: string;
     readonly found: unknown;

package/dist/crdt/protocols/envelope.js

@@ -7,7 +7,7 @@
  *
  * ```
  *   varuint GENERATION | varuint messageType | payload
- *   GENERATION = PROTOCOL_VERSION * 1000 + SCHEMA_VERSION   (14005 at schema 5)
+ *   GENERATION = PROTOCOL_VERSION * 1000 + SCHEMA_VERSION   (14006 at schema 6)
  * ```
  *
  * The word names the whole generation — engine and wire (the protocol,
@@ -36,47 +36,30 @@ export const generationWord = (schema) => PROTOCOL_VERSION * 1000 + schema;
 export const GENERATION = generationWord(SCHEMA_VERSION);
 /**
  * Storage-generation prefix for the v14 IndexedDB databases: one database
- * per schema generation since generation 5, so a generation-4 store is
- * left as it was (rollback) beside its successor.
+ * per schema generation, so an earlier generation's store is left as it
+ * was beside its successor (and never read).
  */
-export const GENERATION_PREFIX = 'edytor-v14-g5:';
-/** The prefix of the IndexedDB databases of schema generations 1 to 4. */
-export const PREVIOUS_GENERATION_PREFIX = 'edytor-v14:';
+export const GENERATION_PREFIX = `edytor-v14-g${SCHEMA_VERSION}:`;
 /** The IndexedDB name a v14 provider uses for logical document `name`. */
 export const generationDbName = (name) => GENERATION_PREFIX + name;
 export const GENERATION_KEY = 'generation';
-/** This generation's wire and schema (the storage format aside: {@link STORED_GENERATION_RECORD}). */
+/** This generation's record. */
 export const GENERATION_RECORD = {
     engine: 'yjs-v14',
     protocol: PROTOCOL_VERSION,
     schema: SCHEMA_VERSION
 };
-/** The storage format this build writes its snapshots in. */
-export const STORAGE_FORMAT = 'v2';
-/** The record this build stamps a container with (its generation and its storage format). */
-export const STORED_GENERATION_RECORD = {
-    ...GENERATION_RECORD,
-    storage: STORAGE_FORMAT
-};
-/**
- * Is `v` this generation's container record? A record without `schema` was
- * written before the schema joined the generation, by builds that spoke
- * schema 1 only — it is a schema-1 record. A storage format this build
- * does not read (a later one) is another generation's.
- */
+/** Is `v` this generation's container record? Any other is refused, never read. */
 export const isGenerationRecord = (v) => typeof v === 'object' &&
     v !== null &&
     v.engine === GENERATION_RECORD.engine &&
     v.protocol === GENERATION_RECORD.protocol &&
-    (v.schema ?? 1) === SCHEMA_VERSION &&
-    [undefined, 'v1', 'v2'].includes(v.storage);
-/** The storage format of a container record ({@link isGenerationRecord} first). */
-export const storageOf = (record) => record.storage ?? 'v1';
+    v.schema === SCHEMA_VERSION;
 export class GenerationMismatchError extends Error {
     dbName;
     found;
     constructor(dbName, found) {
-        super(`Stored document "${dbName}" is not a v14 document generation of this schema (found ${JSON.stringify(found)}). It is never applied — run the migration path, or re-import the document from JSON.`);
+        super(`Stored document "${dbName}" is not a v14 document generation of this schema (found ${JSON.stringify(found)}). It is never applied — re-import the document from JSON.`);
         this.dbName = dbName;
         this.found = found;
         this.name = 'GenerationMismatchError';

package/dist/crdt/protocols/sync.d.ts

@@ -7,38 +7,28 @@
  * (`applyRemote`) and are stamped with a non-null `remoteApplyOrigin` so
  * echo suppression + undo exclusion keep working.
  *
- * Wire format (y-protocols' layout; SyncStep2 in the v2 encoding since
- * schema generation 5):
+ * Wire format (y-protocols' layout; every update in the engine's one
+ * encoding, the columnar one upstream calls v2, since schema generation 6):
  *
  * ```
  *   varuint messageType | payload
  *   messageType 0 (SyncStep1):   varuint8array stateVector
- *   messageType 1 (SyncStep2):   varuint8array update (v2, columnar)
- *   messageType 2 (Update):      varuint8array update (v1)
+ *   messageType 1 (SyncStep2):   varuint8array update
+ *   messageType 2 (Update):      varuint8array update
  * ```
  *
- * A SyncStep2 carries a state — a document's or what a peer lacks — and
- * the v2 encoding is smaller on any such batch (a 1,000-block document:
- * 280,557 → 220,444 bytes, gzip 55,016 → 28,476). An Update carries one
- * transaction, and v1 is smaller for most of those (a one-character
- * delete 13 vs 24 bytes, a block move 62 vs 84, a block delete 43 vs 65),
- * so updates stay v1: what the engine emits on `doc.on('update')` is
- * relayed as it is. A receiver converts a SyncStep2 to v1
- * ({@link step2Update}) and applies it through the one inbound path. That does NOT mean v13 and v14 peers are interchangeable — the
- * provider layer (`providers/*`) wraps every message in the protocol-version
- * envelope (`protocols/envelope.ts`) so engines that do not speak v14 never
- * reach `readSyncMessage`.
+ * What the engine emits on `doc.on('update')` is relayed as it is, and a
+ * SyncStep2 is applied through the same inbound path as an Update. That
+ * does NOT mean v13 and v14 peers are interchangeable — the provider layer
+ * (`providers/*`) wraps every message in the protocol-version envelope
+ * (`protocols/envelope.ts`) so engines that do not speak v14 never reach
+ * {@link applyRemote}.
  *
- * API boundary — two tiers:
- *
- * - RAW readers (`readSyncStep1`, `readSyncStep2`, `readUpdate`,
- *   `readSyncMessage`) apply through the inbound refusal but report
- *   nothing, and `readSyncMessage` THROWS on an unknown message type. They
- *   exist for harnesses/custom transports; the shipped providers do not
- *   route room traffic through them.
- * - The path the providers use lives in `providers/room.ts`:
- *   `applyRemote` + per-type dispatch, so a refused payload never mutates
- *   the live doc and an unknown type is a reported drop, not a throw.
+ * One inbound path: every payload a client or a server receives applies
+ * through `applyRemote`, which refuses a forged schema stamp before
+ * anything integrates; the providers dispatch by message type in
+ * `providers/room.ts` (an unknown type is a reported drop), the room in
+ * `cloudflare/room/admission.ts`.
  *
  * Engine functions are injected (`bindSync(Y)`): `src/lib` never
  * runtime-imports the vendored `.js` (see `engine-api.ts`), so the caller
@@ -68,12 +58,7 @@ export declare const bindSync: (Y: EngineApi) => {
     remoteApplyOrigin: symbol;
     writeSyncStep1: (encoder: encoding.Encoder, doc: YDoc) => void;
     writeSyncStep2: (encoder: encoding.Encoder, doc: YDoc, encodedStateVector?: Uint8Array) => void;
-    step2Update: (payload: Uint8Array) => Uint8Array;
-    readSyncStep1: (decoder: decoding.Decoder, encoder: encoding.Encoder, doc: YDoc) => void;
-    readSyncStep2: (decoder: decoding.Decoder, doc: YDoc, transactionOrigin: unknown, errorHandler?: (error: Error) => unknown) => void;
     writeUpdate: (encoder: encoding.Encoder, update: Uint8Array) => void;
-    readUpdate: (decoder: decoding.Decoder, doc: YDoc, transactionOrigin: unknown, errorHandler?: (error: Error) => unknown) => void;
-    readSyncMessage: (decoder: decoding.Decoder, encoder: encoding.Encoder, doc: YDoc, transactionOrigin: unknown, errorHandler?: (error: Error) => unknown) => number;
     applyRemote: (doc: YDoc, update: Uint8Array, transactionOrigin: unknown, errorHandler?: (error: Error) => unknown) => {
         applied: boolean;
         problem: SchemaProblem | null;