edytor 0.1.0-next.21 → 0.1.0-next.23

package/dist/crdt/index.d.ts

@@ -57,7 +57,7 @@ export { type BlockId, type Destination, type ContentItem, type BlockSpec, type
 export { type DocBlock } from './nodes.js';
 export { type ContentRun } from './text/runs.js';
 export type { YDoc, YUndoManager, YTransaction } from './engine-api.js';
-export { type EdytorSync, type EdytorSyncPayload, type EdytorSyncCleanup, type IndexeddbSyncOptions, type WebsocketSync, type WebsocketSyncOptions, type ProviderStack } from './providers/index.js';
+export { type EdytorSync, type EdytorSyncPayload, type EdytorSyncCleanup, type IndexeddbSyncOptions, type WebsocketSync, type WebsocketSyncOptions, type ProviderStack, type PrefetchOptions, type PrefetchResult, type LastUpdatedOptions } from './providers/index.js';
 export { type IndexeddbPersistenceApi, type IndexeddbPersistenceOptions, type ProtocolMismatch, type SchemaMismatchDetail } from './providers/indexeddb.js';
 export { type WebsocketProviderOptions, type WebsocketProviderEvents, type WebsocketPolyfill } from './providers/websocket.js';
 export { SyncRefusedError } from './providers/room.js';
@@ -168,7 +168,7 @@ export declare const bindCrdt: (Y: EngineApi) => {
                 isSelfOrDescendant: (placements: Map<import("./index.js").BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./text/model.js").Ownership, id: import("./index.js").BlockId, maybeAncestor: import("./index.js").BlockId) => boolean;
                 ranksAt: (siblings: readonly {
                     rank: string;
-                }[], index: number, count: number, clientId: number, rand?: () => number) => string[];
+                }[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
                 writePlacement: (doc: import("./engine-api.js").EngineDoc, node: import("./engine-api.js").EngineNode, p: import("./index.js").BlockId | null, r: string) => void;
                 withdrawOnUndo: (doc: import("./engine-api.js").EngineDoc) => (item: import("./engine-api.js").EngineItemRef, stackItem: {
                     inserts: {
@@ -277,7 +277,10 @@ export declare const bindCrdt: (Y: EngineApi) => {
             checkSchema: () => import("./edytor-doc.js").SchemaProblem | null;
             assertSchema: () => void;
             dispose: () => void;
-            createUndoManager: (opts?: ConstructorParameters<EngineApi["UndoManager"]>[1]) => import("./engine-api.js").YUndoManager;
+            createUndoManager: (options?: ConstructorParameters<EngineApi["UndoManager"]>[1] & {
+                limit?: number;
+            }) => import("./engine-api.js").YUndoManager;
+            releaseHistory: (um: import("./engine-api.js").YUndoManager) => void;
             project: () => import("./index.js").ProjectedDoc;
             toJSON: () => import("./index.js").JSONDoc;
             blockJSON: (id: string) => import("./index.js").JSONBlock;
@@ -345,6 +348,7 @@ export declare const bindCrdt: (Y: EngineApi) => {
             })[];
             onChange: (cb: (change: import("./edytor-doc.js").DocChange) => void) => (() => void);
         };
+        keepCopies: (doc: import("./engine-api.js").EngineDoc) => void;
         model: {
             REGISTRY_KEY: string;
             registryOf: (doc: import("./engine-api.js").EngineDoc) => import("./engine-api.js").EngineNode;
@@ -360,7 +364,7 @@ export declare const bindCrdt: (Y: EngineApi) => {
             isSelfOrDescendant: (placements: Map<import("./index.js").BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./text/model.js").Ownership, id: import("./index.js").BlockId, maybeAncestor: import("./index.js").BlockId) => boolean;
             ranksAt: (siblings: readonly {
                 rank: string;
-            }[], index: number, count: number, clientId: number, rand?: () => number) => string[];
+            }[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
             writePlacement: (doc: import("./engine-api.js").EngineDoc, node: import("./engine-api.js").EngineNode, p: import("./index.js").BlockId | null, r: string) => void;
             withdrawOnUndo: (doc: import("./engine-api.js").EngineDoc) => (item: import("./engine-api.js").EngineItemRef, stackItem: {
                 inserts: {
@@ -416,6 +420,8 @@ export declare const bindCrdt: (Y: EngineApi) => {
         };
     };
     providers: {
+        prefetch: (options: import("./index.js").PrefetchOptions) => Promise<import("./index.js").PrefetchResult>;
+        lastUpdated: (options: import("./index.js").LastUpdatedOptions) => Promise<number | null>;
         IndexeddbPersistence: {
             new (name: string, doc: YDoc, options?: import("./index.js").IndexeddbPersistenceOptions): {
                 doc: YDoc;
@@ -495,7 +501,7 @@ export declare const bindCrdt: (Y: EngineApi) => {
             };
         };
         WebsocketProvider: {
-            new (serverUrl: string, roomname: string, doc: YDoc, { connect, awareness, params, WebSocketPolyfill, resyncInterval, maxBackoffTime, connectTimeout, disableBc }?: import("./index.js").WebsocketProviderOptions): {
+            new (serverUrl: string, roomname: string, doc: YDoc, { connect, awareness, params, WebSocketPolyfill, resyncInterval, maxBackoffTime, connectTimeout, disableBc, maxFrameBytes }?: import("./index.js").WebsocketProviderOptions): {
                 serverUrl: string;
                 roomname: string;
                 doc: YDoc;
@@ -503,6 +509,7 @@ export declare const bindCrdt: (Y: EngineApi) => {
                 params: Record<string, string>;
                 maxBackoffTime: number;
                 connectTimeout: number;
+                maxFrameBytes: number;
                 _WS: import("./index.js").WebsocketPolyfill;
                 shouldConnect: boolean;
                 ws: WebSocket | null;
@@ -616,7 +623,11 @@ export declare const bindCrdt: (Y: EngineApi) => {
     };
     /** U8 — the document-admission boundary (`admitUpdate` staged restore + the shared gate vocabulary). */
     admission: {
-        admitUpdate: (update: Uint8Array, docName?: string) => YDoc;
+        admitUpdate: (update: Uint8Array | ReadonlyArray<Uint8Array | {
+            v2: Uint8Array;
+        }>, docName?: string, options?: {
+            prepare?: (doc: YDoc) => void;
+        }) => YDoc;
     };
     /** Bind the attribution service to this engine — actor dictionary + legacy `a/` reads + block attribution (documents attach it automatically). */
     attribution: {
@@ -627,9 +638,9 @@ export declare const bindCrdt: (Y: EngineApi) => {
 };
 export type Crdt = ReturnType<typeof bindCrdt>;
 export type { EngineApi, EngineDoc, EngineNode, EngineDeepEvent, EngineTransaction, EngineItemRef, YNode, YItem } from './engine-api.js';
-export { SCHEMA_VERSION, META_KEY, EdytorDocDisposedError } from './edytor-doc.js';
-export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, GenerationMismatchError, readProtocolVersion, type GenerationRecord } from './protocols/envelope.js';
-export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, MAX_FRAME_BYTES, chunkFrame, createChunkReader } from './providers/room.js';
+export { SCHEMA_VERSION, META_KEY, EdytorDocDisposedError, DEFAULT_HISTORY_LIMIT } 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 { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkLimitError, 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 { applyAwarenessUpdate, encodeAwarenessUpdate, modifyAwarenessUpdate, readAwarenessEntries, writeAwarenessEntries, type AwarenessEntry } from './protocols/awareness.js';

package/dist/crdt/index.js

@@ -155,9 +155,9 @@ export const bindCrdt = (Y) => {
 // hibernation), the store-before-ack frame (`messageSaved`) and the bounded
 // catch-up codec (`chunkFrame`/`createChunkReader`, `messageChunk`).
 // `pnpm check:worker` keeps this graph Worker-safe.
-export { SCHEMA_VERSION, META_KEY, EdytorDocDisposedError } from './edytor-doc.js';
-export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, GenerationMismatchError, readProtocolVersion } from './protocols/envelope.js';
-export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, MAX_FRAME_BYTES, chunkFrame, createChunkReader } from './providers/room.js';
+export { SCHEMA_VERSION, META_KEY, EdytorDocDisposedError, DEFAULT_HISTORY_LIMIT } from './edytor-doc.js';
+export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, STORED_GENERATION_RECORD, STORAGE_FORMAT, GenerationMismatchError, readProtocolVersion } from './protocols/envelope.js';
+export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, 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 { applyAwarenessUpdate, encodeAwarenessUpdate, modifyAwarenessUpdate, readAwarenessEntries, writeAwarenessEntries } from './protocols/awareness.js';

package/dist/crdt/migration/migrate.js

@@ -33,7 +33,7 @@ import * as f from 'lib0-v14/function';
 import { bindEdytorDoc } from '../edytor-doc.js';
 import { bindLegacyReader } from './legacy-schema.js';
 import { generationDbName } from '../protocols/envelope.js';
-import { CUSTOM, decodeRow, encodeRow, openContainer, openIfExists, UPDATES, verifyOrStamp } from '../providers/container.js';
+import { CUSTOM, decodeRow, encodeRow, readRow, openContainer, openIfExists, UPDATES, verifyOrStamp } from '../providers/container.js';
 import { jsonBlockToSpec, sanitizeWireJson } from '../../utils/json.js';
 const MIGRATION_KEY = 'migration';
 /** The name of the migration lock of logical document `name`. */
@@ -170,8 +170,14 @@ export const bindMigration = (Y) => {
             if (force) {
                 const [updates, custom] = idb.transact(db, [UPDATES, CUSTOM]);
                 await verifyOrStamp(name, updates, custom);
-                for (const row of await idb.getAll(updates))
-                    Y.applyUpdate(doc, decodeRow(row));
+                // Rows first (one transaction), then inflate: a snapshot row is v2, maybe gzip (P5).
+                for (const row of await idb.getAll(updates)) {
+                    const update = await readRow(row);
+                    if (update instanceof Uint8Array)
+                        Y.applyUpdate(doc, update);
+                    else
+                        Y.applyUpdateV2(doc, update.v2);
+                }
             }
             const base = Y.encodeStateVector(doc);
             edytorDoc.restore(doc, json.children.map((b) => jsonBlockToSpec(b)));

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

@@ -342,6 +342,14 @@ export declare const displayParentOf: (own: DisplayOwnership, pl: ResolvedPlacem
  * promoted one ({@link displaySlotOf}).
  */
 export declare const childrenIndex: (placements: Map<BlockId, ResolvedPlacement>, own: DisplayOwnership) => Map<BlockId | null, ChildSlot[]>;
+/** The order of a children list: by rank, ties by id. */
+export declare const bySlot: (a: {
+    id: BlockId;
+    rank: string;
+}, b: {
+    id: BlockId;
+    rank: string;
+}) => number;
 /**
  * Document order (O7): ONE pre-order over the visible blocks of a children
  * index — `ids` in reading order, `at` the position of each id. Every
@@ -376,7 +384,7 @@ export declare const bindModel: (Y: EngineApi) => {
     isSelfOrDescendant: (placements: Map<BlockId, ResolvedPlacement>, own: Ownership, id: BlockId, maybeAncestor: BlockId) => boolean;
     ranksAt: (siblings: readonly {
         rank: string;
-    }[], index: number, count: number, clientId: number, rand?: () => number) => string[];
+    }[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
     writePlacement: (doc: EngineDoc, node: EngineNode, p: BlockId | null, r: string) => void;
     withdrawOnUndo: (doc: EngineDoc) => (item: EngineItemRef, stackItem: {
         inserts: {

package/dist/crdt/placement/model.js

@@ -1,4 +1,4 @@
-import { decodeRank, encodeRank, rankBetween, RANK_VMIN } from './rank.js';
+import { decodeRank, encodeRank, rankAfter, rankBetween, RANK_VMIN } from './rank.js';
 import { AT, AT_NODE, BLOCK_NODE, CONTENT, CONTENT_NODE, DEL_PREFIX, hasDeleteMark, ID, CLAIMS, CLAIMS_NODE, INLINE_NODE, isNodeLike, NONCE, REGISTRY_KEY, TYPE, WITHDRAW_PREFIX } from '../schema.js';
 import { nonceOf, randOf } from '../rand.js';
 import { bindRuns } from '../text/runs.js';
@@ -409,11 +409,12 @@ export const childrenIndex = (placements, own) => {
         else
             index.set(parent, [slot]);
     }
-    for (const bucket of index.values()) {
-        bucket.sort((a, b) => a.rank === b.rank ? a.id.localeCompare(b.id) : a.rank < b.rank ? -1 : 1);
-    }
+    for (const bucket of index.values())
+        bucket.sort(bySlot);
     return index;
 };
+/** The order of a children list: by rank, ties by id. */
+export const bySlot = (a, b) => (a.rank === b.rank ? a.id.localeCompare(b.id) : a.rank < b.rank ? -1 : 1);
 export const documentOrder = (kids) => {
     const ids = [];
     const at = new Map();
@@ -559,9 +560,10 @@ export const bindModel = (Y) => {
      * so each new member takes `left` verbatim: it JOINS the tie and the
      * `(rank, id)` display sort orders the whole group deterministically.
      * On a valid seam the emitted chain is `rankBetween(left, right)` then
-     * `rankBetween(prev, right)`.
+     * `rankBetween(prev, right)` — with `run`, `rankAfter` (an insert: after a
+     * block this client ranked, in its run there, H1).
      */
-    const ranksAt = (siblings, index, count, clientId, rand) => {
+    const ranksAt = (siblings, index, count, clientId, rand, run = false) => {
         let left = siblings[index - 1]?.rank;
         const right = siblings[index]?.rank;
         if (left !== undefined && right !== undefined && left >= right) {
@@ -569,7 +571,10 @@ export const bindModel = (Y) => {
         }
         const out = [];
         for (let i = 0; i < count; i++) {
-            const r = rankBetween(left, right, clientId, rand);
+            // An insert extends this client's run after a block it ranked (H1).
+            const r = run
+                ? rankAfter(left, right, clientId, rand)
+                : rankBetween(left, right, clientId, rand);
             out.push(r);
             left = r;
         }
@@ -749,12 +754,26 @@ export const bindModel = (Y) => {
      * slot ({@link displaySlotOf}). Content is each block's display (R2).
      */
     const project = (doc) => ({ children: R.attach(doc).project() });
-    /** `positionOf` in a view: the display parent and the index among its visible children. */
+    /**
+     * `positionOf` in a view: the display parent and the index among its
+     * visible children — a binary search by the block's display rank (the
+     * list's own order), not a scan of its siblings.
+     */
     const positionInView = (v, id) => {
         if (!isLiveIn(v, id))
             return null;
-        const dp = displayParentOf(v.own, v.placements.get(id), v.placements, id);
-        const index = (v.kids.get(dp) ?? []).findIndex((s) => s.id === id);
+        const slot = displaySlotOf(v.own, v.placements, v.placements.get(id), id);
+        const dp = slot.parent;
+        const list = v.kids.get(dp) ?? [];
+        let [lo, hi] = [0, list.length];
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (bySlot(list[mid], { id, rank: slot.rank }) < 0)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        const index = list[lo]?.id === id ? lo : list.findIndex((s) => s.id === id);
         return index < 0 ? null : { parent: dp, index };
     };
     /**

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

@@ -55,3 +55,23 @@ export declare const decodeRank: (rank: string) => RankSeg[];
 /** Encode segments back to the persisted string form. */
 export declare const encodeRank: (segs: readonly RankSeg[]) => string;
 export declare const rankBetween: (left: string | undefined, right: string | undefined, clientId: number, rand?: () => number) => 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.
+ */
+export declare const RANK_RUN: number;
+/**
+ * A rank in `(left, right)` for an insert right after `left` — one rule for
+ * array items (`crdt/data.ts`) and inserted blocks (H1, `order.insert.run`).
+ * When `client` made `left`, the rank is in the client's run after it: `left`
+ * itself as the prefix, then one segment of the run band — or, when `left`
+ * is already a member of the client's run, that run's prefix and a member
+ * between `left` and the next one. So what one client inserts after its own
+ * items stays together whatever a peer inserts in that gap meanwhile: a
+ * peer's rank there is either no extension of the run's prefix (it sorts
+ * after the whole run) or one whose next digit is above the band (YATA's
+ * origin rule, as `Y.Array` keeps an insert after its origin). Elsewhere, or
+ * when the run rank would not sort below `right`, a plain {@link rankBetween}.
+ */
+export declare const rankAfter: (left: string | undefined, right: string | undefined, client: number, rand?: () => number) => string;

package/dist/crdt/placement/rank.js

@@ -207,3 +207,82 @@ export const rankBetween = (left, right, clientId, rand = Math.random) => {
         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.
+ */
+export const RANK_RUN = -(2 ** 39);
+/**
+ * A run member's digit lies in `(RANK_RUN, RANK_RUN + RUN_BAND)`: below every
+ * digit a plain rank extends a prefix with (`0`, an append's), far above the
+ * digit minimum. A run opens at {@link RUN_START}, the middle of the band, so
+ * its members can be inserted before and after one another.
+ */
+const RUN_BAND = 2 ** 38;
+const RUN_START = RANK_RUN + 2 ** 37;
+const inRun = (v) => v > RANK_RUN && v < RANK_RUN + RUN_BAND;
+/**
+ * A rank in `(left, right)` for an insert right after `left` — one rule for
+ * array items (`crdt/data.ts`) and inserted blocks (H1, `order.insert.run`).
+ * When `client` made `left`, the rank is in the client's run after it: `left`
+ * itself as the prefix, then one segment of the run band — or, when `left`
+ * is already a member of the client's run, that run's prefix and a member
+ * between `left` and the next one. So what one client inserts after its own
+ * items stays together whatever a peer inserts in that gap meanwhile: a
+ * peer's rank there is either no extension of the run's prefix (it sorts
+ * after the whole run) or one whose next digit is above the band (YATA's
+ * origin rule, as `Y.Array` keeps an insert after its origin). Elsewhere, or
+ * when the run rank would not sort below `right`, a plain {@link rankBetween}.
+ */
+export const rankAfter = (left, right, client, rand = Math.random) => {
+    const plain = () => rankBetween(left, right, client, rand);
+    if (left === undefined)
+        return plain();
+    const segs = decodeRank(left);
+    const last = segs.at(-1);
+    const bottom = encodeRank([{ v: RANK_RUN, t: 0 }]);
+    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.
+     */
+    const own = (prefix, after, band) => {
+        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)
+            next = undefined;
+        let mine;
+        if (after === undefined) {
+            if (next === undefined)
+                mine = encodeRank([{ v: RUN_START, t: client }]);
+            else if (band && next > bottom)
+                mine = rankBetween(bottom, next, client, rand);
+            else
+                return plain();
+        }
+        else if (next === undefined && band) {
+            const append = rankBetween(after, undefined, client, rand);
+            mine = append < top ? append : rankBetween(after, top, client, rand);
+        }
+        else
+            mine = rankBetween(after, next, client, rand);
+        const rank = prefix + mine;
+        return right === undefined || rank < right ? rank : plain();
+    };
+    // 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);
+    }
+    // A rank the client made: its run opens right after it.
+    if (last.t === client)
+        return own(left, undefined, true);
+    return plain();
+};

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

@@ -37,20 +37,39 @@ export declare const GENERATION: number;
 export declare const GENERATION_PREFIX = "edytor-v14:";
 /** The IndexedDB name a v14 provider uses for logical document `name`. */
 export declare const generationDbName: (name: string) => string;
+/**
+ * How a container stores its snapshots (P5, 0.1.0-next.23): `'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).
+ */
+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 0.1.0-next.23). */
+    storage?: StorageFormat;
 };
 export declare const GENERATION_KEY = "generation";
+/** This generation's wire and schema (the storage format aside: {@link STORED_GENERATION_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.
+ * schema 1 only — it is a schema-1 record. A storage format this build
+ * does not read (a later one) is another generation's.
  */
 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

@@ -39,21 +39,33 @@ export const GENERATION_PREFIX = 'edytor-v14:';
 /** 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}). */
 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.
+ * schema 1 only — it is a schema-1 record. A storage format this build
+ * does not read (a later one) is another generation's.
  */
 export const isGenerationRecord = (v) => typeof v === 'object' &&
     v !== null &&
     v.engine === GENERATION_RECORD.engine &&
     v.protocol === GENERATION_RECORD.protocol &&
-    (v.schema ?? 1) === SCHEMA_VERSION;
+    (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';
 export class GenerationMismatchError extends Error {
     dbName;
     found;

package/dist/crdt/providers/container.d.ts

@@ -5,6 +5,21 @@ export declare const openContainer: (dbName: string) => Promise<IDBDatabase>;
 /** A row is the update's bytes in a buffer of their own. */
 export declare const encodeRow: (update: Uint8Array) => ArrayBuffer;
 export declare const decodeRow: (row: unknown) => Uint8Array;
+/**
+ * A snapshot row (P5, storage `'v2'`): the document in the v2 encoding,
+ * gzip-compressed where the platform has `CompressionStream` (and that
+ * makes it smaller). Update rows stay v1 `ArrayBuffer`s. A build before
+ * 0.1.0-next.23 reads such a row as no update at all (`decodeRow` throws),
+ * so it fails to load the store instead of misreading it.
+ */
+export type SnapshotRow = {
+    v2: ArrayBuffer;
+};
+export declare const snapshotRow: (updateV2: Uint8Array) => Promise<SnapshotRow>;
+/** A stored row as the update to apply: `{ v2 }` for a snapshot row (inflated). */
+export declare const readRow: (row: unknown) => Promise<Uint8Array | {
+    v2: Uint8Array;
+}>;
 /**
  * The one verify-or-stamp rule: a container carrying this generation's
  * record passes; an EMPTY container without a record is stamped; anything

package/dist/crdt/providers/container.js

@@ -1,12 +1,13 @@
 /**
  * The v14 IndexedDB container (L58) — one owner for the store names, the row
- * codec, the open, the non-creating probe and the ONE verify-or-stamp rule,
+ * codec (v1 update rows, v2 snapshot rows: P5), the open, the non-creating probe and the ONE verify-or-stamp rule,
  * shared by the provider and the migrator. Rows are append-only for every
  * writer (a provider's compaction appends its snapshot before deleting the
  * rows it subsumes).
  */
 import * as idb from 'lib0-v14/indexeddb';
-import { GENERATION_KEY, GENERATION_RECORD, GenerationMismatchError, isGenerationRecord } from '../protocols/envelope.js';
+import { GENERATION_KEY, GenerationMismatchError, isGenerationRecord, STORED_GENERATION_RECORD } from '../protocols/envelope.js';
+import { gunzip, packed } from '../storage.js';
 export const UPDATES = 'updates';
 export const CUSTOM = 'custom';
 /** Open (creating when absent) a container with its two stores. */
@@ -20,6 +21,19 @@ export const decodeRow = (row) => {
         return row;
     throw new TypeError('Stored Yjs update is not binary data');
 };
+export const snapshotRow = async (updateV2) => ({
+    v2: (await packed(updateV2)).slice().buffer
+});
+/** A stored row as the update to apply: `{ v2 }` for a snapshot row (inflated). */
+export const readRow = async (row) => {
+    if (typeof row === 'object' && row !== null && 'v2' in row) {
+        const bytes = row.v2;
+        if (!(bytes instanceof ArrayBuffer))
+            throw new TypeError('Stored snapshot is not binary data');
+        return { v2: await gunzip(new Uint8Array(bytes)) };
+    }
+    return decodeRow(row);
+};
 /**
  * The one verify-or-stamp rule: a container carrying this generation's
  * record passes; an EMPTY container without a record is stamped; anything
@@ -29,7 +43,7 @@ export const decodeRow = (row) => {
 export const verifyOrStamp = async (name, updates, custom) => {
     const found = await idb.get(custom, GENERATION_KEY);
     if (found === undefined && (await idb.count(updates)) === 0) {
-        await idb.rtop(custom.put({ ...GENERATION_RECORD }, GENERATION_KEY));
+        await idb.rtop(custom.put({ ...STORED_GENERATION_RECORD }, GENERATION_KEY));
     }
     else if (!isGenerationRecord(found)) {
         throw new GenerationMismatchError(name, found);

package/dist/crdt/providers/index.d.ts

@@ -99,6 +99,8 @@ export type WebsocketSyncOptions = WebsocketTarget & {
     onExpired?: (state: Parameters<WebsocketProviderEvents['expired']>[0]) => void;
     /** Opt out of cross-tab sync over the BroadcastChannel (on by default). */
     disableBc?: boolean;
+    /** Largest frame sent whole (default 32 MiB); larger ones are chunked (H6). */
+    maxFrameBytes?: number;
     /**
      * Keep a local copy in IndexedDB (default `true`; skipped where there is
      * no `indexedDB`). Edits survive offline reloads and reach the server on
@@ -112,8 +114,25 @@ export type WebsocketSyncOptions = WebsocketTarget & {
 export type WebsocketSync = EdytorSync & {
     persistName?: string;
 };
+/** What {@link bindProviders}' `prefetch` takes: a websocket sync's target and options. */
+export type PrefetchOptions = (WebsocketSyncOptions extends infer O ? O extends unknown ? Omit<O, 'onExpired' | 'persist' | 'disableBc'> : never : never) & {
+    /** ms before it gives up (default 30 000). */
+    timeout?: number;
+};
+/** What `prefetch` found: whether the room sent the store anything it lacked. */
+export type PrefetchResult = {
+    updated: boolean;
+};
+/** What `lastUpdated` takes: the room it asks, and the `params` (a token) its dial would carry. */
+export type LastUpdatedOptions = WebsocketTarget & {
+    params?: Record<string, string>;
+    /** The fetch to use (default the global one). */
+    fetch?: typeof fetch;
+};
 export type ProviderStack = ReturnType<typeof bindProviders>;
 export declare const bindProviders: (Y: EngineApi) => {
+    prefetch: (options: PrefetchOptions) => Promise<PrefetchResult>;
+    lastUpdated: (options: LastUpdatedOptions) => Promise<number | null>;
     IndexeddbPersistence: {
         new (name: string, doc: YDoc, options?: import("./indexeddb.js").IndexeddbPersistenceOptions): {
             doc: YDoc;
@@ -193,7 +212,7 @@ export declare const bindProviders: (Y: EngineApi) => {
         };
     };
     WebsocketProvider: {
-        new (serverUrl: string, roomname: string, doc: YDoc, { connect, awareness, params, WebSocketPolyfill, resyncInterval, maxBackoffTime, connectTimeout, disableBc }?: import("./websocket.js").WebsocketProviderOptions): {
+        new (serverUrl: string, roomname: string, doc: YDoc, { connect, awareness, params, WebSocketPolyfill, resyncInterval, maxBackoffTime, connectTimeout, disableBc, maxFrameBytes }?: import("./websocket.js").WebsocketProviderOptions): {
             serverUrl: string;
             roomname: string;
             doc: YDoc;
@@ -201,6 +220,7 @@ export declare const bindProviders: (Y: EngineApi) => {
             params: Record<string, string>;
             maxBackoffTime: number;
             connectTimeout: number;
+            maxFrameBytes: number;
             _WS: import("./websocket.js").WebsocketPolyfill;
             shouldConnect: boolean;
             ws: WebSocket | null;