edytor 1.0.0-rc.3 → 2.0.0

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;

package/dist/crdt/protocols/sync.js

@@ -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
@@ -55,7 +45,7 @@ import { asEngineDoc, attrItems } from '../structs.js';
  * is optional). Remote integration MUST always arrive under a non-null,
  * non-tracked origin:
  *
- * - history capture (`document.history` / `Y.UndoManager`) keeps
+ * - history capture (`document.history`, edytor's undo manager) keeps
  *   untracked, non-local transactions out of the local undo stack — a
  *   `null` origin is ambiguous (it is also the untyped-local marker), so
  *   an explicit marker documents intent for `doc.on('update')`
@@ -73,6 +63,12 @@ const defaultRemoteApplyOrigin = () => Symbol('edytor-remote-apply');
 export const messageYjsSyncStep1 = 0;
 export const messageYjsSyncStep2 = 1;
 export const messageYjsUpdate = 2;
+/** An inbound update that could not be read or applied: its handler hears it, the console shows it. */
+const reportUpdateError = (error, errorHandler) => {
+    if (errorHandler != null)
+        errorHandler(error);
+    console.error('Caught error while handling a Yjs update', error);
+};
 /**
  * Bind the sync protocol to a concrete engine module (the vendored v14 `Y`).
  */
@@ -85,29 +81,7 @@ export const bindSync = (Y) => {
     };
     const writeSyncStep2 = (encoder, doc, encodedStateVector) => {
         encoding.writeVarUint(encoder, messageYjsSyncStep2);
-        encoding.writeVarUint8Array(encoder, Y.encodeStateAsUpdateV2(doc, encodedStateVector));
-    };
-    /** A SyncStep2 payload (v2) as the v1 update every inbound path applies. */
-    const step2Update = (payload) => Y.convertUpdateFormatV2ToV1(payload);
-    /** Read SyncStep1 message and reply with SyncStep2. */
-    const readSyncStep1 = (decoder, encoder, doc) => writeSyncStep2(encoder, doc, decoding.readVarUint8Array(decoder));
-    /**
-     * Read and apply structs + delete set to a doc — through the same
-     * inbound refusal as the providers ({@link applyRemote}), which report
-     * a refused stamp; this raw reader reports only decode/apply errors.
-     */
-    const readSyncStep2 = (decoder, doc, transactionOrigin, errorHandler) => {
-        let update;
-        try {
-            update = step2Update(decoding.readVarUint8Array(decoder));
-        }
-        catch (error) {
-            if (errorHandler != null)
-                errorHandler(error);
-            console.error('Caught error while handling a Yjs update', error);
-            return;
-        }
-        applyRemote(doc, update, transactionOrigin, errorHandler);
+        encoding.writeVarUint8Array(encoder, Y.encodeStateAsUpdate(doc, encodedStateVector));
     };
     /**
      * The state-vector coverage test of the join rule: does the encoded
@@ -125,10 +99,6 @@ export const bindSync = (Y) => {
         encoding.writeVarUint(encoder, messageYjsUpdate);
         encoding.writeVarUint8Array(encoder, update);
     };
-    /** Read and apply an Update (v1) through the inbound refusal. */
-    const readUpdate = (decoder, doc, transactionOrigin, errorHandler) => {
-        applyRemote(doc, decoding.readVarUint8Array(decoder), transactionOrigin, errorHandler);
-    };
     /**
      * Inbound refusal: the schema problem `parts` (decoded updates,
      * judged together) would write, or `null`. The frame already proved its
@@ -193,7 +163,7 @@ export const bindSync = (Y) => {
     /** What the engine holds pending on `doc` (structs and deletes waiting for a dependency). */
     const held = (doc) => {
         const pending = [doc.store.pendingStructs?.update, doc.store.pendingDs];
-        return pending.flatMap((bytes) => (bytes ? [Y.decodeUpdateV2(bytes)] : []));
+        return pending.flatMap((bytes) => (bytes ? [Y.decodeUpdate(bytes)] : []));
     };
     /**
      * Apply one inbound update (SyncStep2 / Update payload) to the live doc
@@ -230,9 +200,7 @@ export const bindSync = (Y) => {
                 : { applied: true, problem: null, discarded };
         }
         catch (error) {
-            if (errorHandler != null)
-                errorHandler(error);
-            console.error('Caught error while handling a Yjs update', error);
+            reportUpdateError(error, errorHandler);
             return { applied: false, problem: null };
         }
     };
@@ -248,12 +216,12 @@ export const bindSync = (Y) => {
      * vector alone ignores the second field; a body without it acknowledges
      * no deletes.
      */
-    const writeSaved = (encoder, doc, deletes, unstored = doc.store.pendingDs && Y.decodeUpdateV2(doc.store.pendingDs).ds) => {
+    const writeSaved = (encoder, doc, deletes, unstored = doc.store.pendingDs && Y.decodeUpdate(doc.store.pendingDs).ds) => {
         encoding.writeVarUint8Array(encoder, Y.encodeStateVector(doc));
         const held = deletes && unstored ? Y.diffIdSet(deletes, unstored) : deletes;
         if (!held || held.isEmpty())
             return;
-        const body = new Y.UpdateEncoderV1();
+        const body = new Y.UpdateEncoder();
         encoding.writeVarUint(body.restEncoder, 0); // no structs
         Y.writeIdSet(body, held);
         encoding.writeVarUint8Array(encoder, body.toUint8Array());
@@ -265,31 +233,6 @@ export const bindSync = (Y) => {
             ? Y.decodeUpdate(decoding.readVarUint8Array(decoder)).ds
             : null
     });
-    /**
-     * Read a sync message from `decoder`; writes any reply (SyncStep2) into
-     * `encoder`. Returns the decoded message type. Callers MUST gate the
-     * protocol-version envelope before invoking this (see `envelope.ts`).
-     * RAW: payloads apply through the inbound refusal (unreported) and an
-     * unknown message type THROWS — the shipped providers dispatch through
-     * `providers/room.ts` (`applyRemote` + reported drops) instead.
-     */
-    const readSyncMessage = (decoder, encoder, doc, transactionOrigin, errorHandler) => {
-        const messageType = decoding.readVarUint(decoder);
-        switch (messageType) {
-            case messageYjsSyncStep1:
-                readSyncStep1(decoder, encoder, doc);
-                break;
-            case messageYjsSyncStep2:
-                readSyncStep2(decoder, doc, transactionOrigin, errorHandler);
-                break;
-            case messageYjsUpdate:
-                readUpdate(decoder, doc, transactionOrigin, errorHandler);
-                break;
-            default:
-                throw new Error('Unknown message type');
-        }
-        return messageType;
-    };
     return {
         messageYjsSyncStep1,
         messageYjsSyncStep2,
@@ -297,12 +240,7 @@ export const bindSync = (Y) => {
         remoteApplyOrigin,
         writeSyncStep1,
         writeSyncStep2,
-        step2Update,
-        readSyncStep1,
-        readSyncStep2,
         writeUpdate,
-        readUpdate,
-        readSyncMessage,
         applyRemote,
         lacks,
         writeSaved,

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

@@ -1,2 +1,4 @@
-import { type ProviderStack } from './index.js';
+import { type PrefetchOptions, type ProviderStack } from './index.js';
 export declare const providers: ProviderStack;
+/** {@link prefetchWith} over the one stack. */
+export declare const prefetch: (options: PrefetchOptions) => Promise<import("./index.js").PrefetchResult>;

package/dist/crdt/providers/bound.js

@@ -5,5 +5,7 @@
  * `instanceof` holds whichever entry point a consumer imported it from.
  */
 import { Y } from '../engine.js';
-import { bindProviders } from './index.js';
+import { bindProviders, prefetchWith } from './index.js';
 export const providers = bindProviders(Y);
+/** {@link prefetchWith} over the one stack. */
+export const prefetch = (options) => prefetchWith(Y, providers, options);

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

@@ -1,25 +1,19 @@
 export declare const UPDATES = "updates";
 export declare const CUSTOM = "custom";
-/** Open (creating when absent) a container with its two stores. */
+/** A request's result, as a promise (its failure as an `Error`). */
+export declare const rtop: <T>(request: IDBRequest<T>) => Promise<T>;
+/** The stores `names` of one read-write transaction on `db`. */
+export declare const storesOf: (db: IDBDatabase, names: string[]) => IDBObjectStore[];
+/** The greatest key of `store` (`null` when it is empty). */
+export declare const lastKey: (store: IDBObjectStore) => Promise<IDBValidKey | null>;
+/** Open (creating when absent) a container with its two stores; it closes when another version opens. */
 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 (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 from
- * before the v2 snapshots 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;
-}>;
+/** A snapshot row: the document's state, gzip-compressed where that makes it smaller. */
+export declare const snapshotRow: (update: Uint8Array) => Promise<ArrayBuffer>;
+/** A stored row as the update to apply (a compressed snapshot inflated). */
+export declare const readRow: (row: unknown) => Promise<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,38 +1,50 @@
 /**
  * The v14 IndexedDB container — one owner for the store names, the row
- * codec (v1 update rows, v2 snapshot rows: `room.store.v2`), 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
+ * codec (every row an update in the engine's one encoding, a snapshot
+ * gzip-compressed where that makes it smaller), the open, the non-creating
+ * probe and the ONE verify-or-stamp rule. 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, GenerationMismatchError, isGenerationRecord, STORED_GENERATION_RECORD } from '../protocols/envelope.js';
+import { GENERATION_KEY, GenerationMismatchError, GENERATION_RECORD, isGenerationRecord } 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. */
-export const openContainer = (dbName) => idb.openDB(dbName, (db) => idb.createStores(db, [[UPDATES, { autoIncrement: true }], [CUSTOM]]));
-/** A row is the update's bytes in a buffer of their own. */
-export const encodeRow = (update) => update.slice().buffer;
-export const decodeRow = (row) => {
-    if (row instanceof ArrayBuffer)
-        return new Uint8Array(row);
-    if (row instanceof Uint8Array)
-        return row;
-    throw new TypeError('Stored Yjs update is not binary data');
+/** A request's result, as a promise (its failure as an `Error`). */
+export const rtop = (request) => new Promise((resolve, reject) => {
+    request.onerror = () => reject(new Error(String(request.error)));
+    request.onsuccess = () => resolve(request.result);
+});
+/** The stores `names` of one read-write transaction on `db`. */
+export const storesOf = (db, names) => {
+    const transaction = db.transaction(names, 'readwrite');
+    return names.map((name) => transaction.objectStore(name));
 };
-export const snapshotRow = async (updateV2) => ({
-    v2: (await packed(updateV2)).slice().buffer
+/** The greatest key of `store` (`null` when it is empty). */
+export const lastKey = (store) => rtop(store.openKeyCursor(null, 'prev')).then((cursor) => cursor?.key ?? null);
+/** Open (creating when absent) a container with its two stores; it closes when another version opens. */
+export const openContainer = (dbName) => new Promise((resolve, reject) => {
+    const request = indexedDB.open(dbName);
+    request.onupgradeneeded = () => {
+        request.result.createObjectStore(UPDATES, { autoIncrement: true });
+        request.result.createObjectStore(CUSTOM);
+    };
+    request.onerror = () => reject(request.error);
+    request.onsuccess = () => {
+        const db = request.result;
+        db.onversionchange = () => db.close();
+        resolve(db);
+    };
 });
-/** A stored row as the update to apply: `{ v2 }` for a snapshot row (inflated). */
+/** A row is the update's bytes in a buffer of their own. */
+export const encodeRow = (update) => update.slice().buffer;
+/** A snapshot row: the document's state, gzip-compressed where that makes it smaller. */
+export const snapshotRow = async (update) => encodeRow(await packed(update));
+/** A stored row as the update to apply (a compressed snapshot 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);
+    if (!(row instanceof ArrayBuffer))
+        throw new TypeError('Stored Yjs update is not binary data');
+    return gunzip(new Uint8Array(row));
 };
 /**
  * The one verify-or-stamp rule: a container carrying this generation's
@@ -41,9 +53,9 @@ export const readRow = async (row) => {
  * {@link GenerationMismatchError} — nothing inside a row is inspected.
  */
 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({ ...STORED_GENERATION_RECORD }, GENERATION_KEY));
+    const found = await rtop(custom.get(GENERATION_KEY));
+    if (found === undefined && (await rtop(updates.count())) === 0) {
+        await rtop(custom.put({ ...GENERATION_RECORD }, GENERATION_KEY));
     }
     else if (!isGenerationRecord(found)) {
         throw new GenerationMismatchError(name, found);

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

@@ -127,9 +127,6 @@ export type LastUpdatedOptions = WebsocketTarget & {
 };
 export type ProviderStack = ReturnType<typeof bindProviders>;
 export declare const bindProviders: (Y: EngineApi) => {
-    prefetch: (options: PrefetchOptions) => Promise<PrefetchResult>;
-    lastUpdated: (options: LastUpdatedOptions) => Promise<number | null>;
-    documentSnapshot: (options: LastUpdatedOptions) => Promise<JSONDoc | null>;
     IndexeddbPersistence: {
         new (name: string, doc: YDoc, options?: import("./indexeddb.js").IndexeddbPersistenceOptions): {
             doc: YDoc;
@@ -153,7 +150,7 @@ export declare const bindProviders: (Y: EngineApi) => {
             bcconnected: boolean;
             disableBc: boolean;
             _ownsAwareness: boolean;
-            _bcSubscriber: (data: ArrayBuffer, origin: unknown) => void;
+            _bcSubscriber: (data: ArrayBuffer | Uint8Array, origin: unknown) => void;
             _awarenessUpdateHandler: (updates: {
                 added: number[];
                 updated: number[];
@@ -225,7 +222,7 @@ export declare const bindProviders: (Y: EngineApi) => {
             bcChannel: string;
             bcconnected: boolean;
             disableBc: boolean;
-            _bcSubscriber: (data: ArrayBuffer, origin: unknown) => void;
+            _bcSubscriber: (data: ArrayBuffer | Uint8Array, origin: unknown) => void;
             _fromTab: {};
             wsUnsuccessfulReconnects: number;
             wsLastMessageReceived: number;
@@ -292,9 +289,40 @@ export declare const bindProviders: (Y: EngineApi) => {
         _dbsize: number;
         _destroyed: boolean;
     }, forceStore?: boolean) => Promise<undefined>;
-    clearDocument: (name: string) => Promise<any>;
+    clearDocument: (name: string) => Promise<void>;
     PREFERRED_TRIM_SIZE: number;
     createIndexeddbSync: (name: string) => EdytorSync;
     createWebsocketSync: (options: WebsocketSyncOptions) => WebsocketSync;
 };
 export type { IndexeddbProvider };
+/**
+ * `[serverUrl (no trailing slash), room]` of a target, the room id checked.
+ * The target is `{ server, room }`; the names before them are refused, in
+ * a message that names the `caller` it was passed to.
+ */
+export declare const targetOf: (caller: string, options: WebsocketTarget) => [string, string];
+/**
+ * Keep a document fresh without opening it: load its local store
+ * (the one `createWebsocketSync` keeps, `edytor:<server>/<room>` unless
+ * `persistName` names another), dial the room once, take what it lacks
+ * and hand it what the store holds that the room lacks, wait until the
+ * room stored it, then close. Resolves with whether the room sent
+ * anything new; rejects with the room's refusal (`SyncRefusedError`),
+ * after `timeout`, or where there is no IndexedDB. Over the provider
+ * classes of `stack` (bound to `Y`).
+ */
+export declare const prefetchWith: (Y: EngineApi, stack: ProviderStack, options: PrefetchOptions) => Promise<PrefetchResult>;
+/**
+ * When the room last stored a change (ms since the epoch), or `null`:
+ * `?lastUpdated`, answered without opening the document. Compare it with
+ * when a document was last fetched to decide whether to `prefetch` it.
+ * Throws on an HTTP error (`403` refused, `401` expired).
+ */
+export declare const lastUpdated: (options: LastUpdatedOptions) => Promise<number | null>;
+/**
+ * The room's document as JSON, or `null` when it stores nothing yet:
+ * `?snapshot`, answered from the room's live document. Show it while a
+ * view's own copy hydrates: `<Edytor snapshot>`. Throws on an HTTP error
+ * (`403` refused, `401` expired).
+ */
+export declare const documentSnapshot: (options: LastUpdatedOptions) => Promise<JSONDoc | null>;