edytor 6.0.0 → 7.0.0

package/dist/components/Edytor.svelte

@@ -193,6 +193,8 @@
 		params,
 		onSyncExpired,
 		onSyncRefused,
+		rebuild,
+		adopt,
 		requireHydration,
 		snapshot,
 		actor,
@@ -208,7 +210,15 @@
 		autocapitalize = 'none',
 		inputmode,
 		enterkeyhint
-	}: EdytorProps = $props();
+	}: EdytorProps & {
+		/** The view's own rebuild (`EdytorRoot`): a new view on a new document. */
+		rebuild?: () => void;
+		/**
+		 * Hands the view to `EdytorRoot`, which a binding cannot: on the server a
+		 * bound prop renders the tree twice, and the discarded view never ends.
+		 */
+		adopt?: (view: EdytorClass) => void;
+	} = $props();
 
 	const initialEdytorOptions = untrack(() => ({
 		readonly,
@@ -227,6 +237,7 @@
 	}));
 
 	edytor = new EdytorClass(initialEdytorOptions);
+	untrack(() => adopt)?.(edytor);
 
 	// ONE attach path for owned and injected documents: `attachSync`
 	// tracks the provider on the DOCUMENT's lifetime (one provider per
@@ -276,7 +287,11 @@
 		}
 		// Subscribe first, then replay the standing refusal isolated like the
 		// later ones: a throwing callback still hears the next refusal.
-		offRefused = document.onSyncRefused((next) => onSyncRefused?.(next));
+		offRefused = document.onSyncRefused((next) => {
+			onSyncRefused?.(next);
+			// A re-seed (`4410`): a view that owns its document builds itself again on a new one.
+			if (next.code === CLOSE.reseeded && !edytorDocument) rebuild?.();
+		});
 		if (refusal) {
 			try {
 				onSyncRefused?.(refusal);
@@ -379,7 +394,7 @@
 			contenteditable="false"
 			aria-hidden="true"
 			style="display: none"
-			use:edytor.surface.anchor
+			use:edytor.surface.own
 		></span>
 	</div>
 {:else if snapshot}

package/dist/components/Edytor.svelte.d.ts

@@ -113,6 +113,15 @@ export type EdytorProps = {
 import type { JSONDoc } from '../utils/json.js';
 import type { HotKey, HotKeyCombination } from '../session/keymap.js';
 import type { EdytorSelection } from '../selection/selection.svelte.js';
-declare const Edytor: import("svelte").Component<EdytorProps, {}, "edytor">;
+type $$ComponentProps = EdytorProps & {
+    /** The view's own rebuild (`EdytorRoot`): a new view on a new document. */
+    rebuild?: () => void;
+    /**
+     * Hands the view to `EdytorRoot`, which a binding cannot: on the server a
+     * bound prop renders the tree twice, and the discarded view never ends.
+     */
+    adopt?: (view: EdytorClass) => void;
+};
+declare const Edytor: import("svelte").Component<$$ComponentProps, {}, "edytor">;
 type Edytor = ReturnType<typeof Edytor>;
 export default Edytor;

package/dist/components/EdytorRoot.svelte

@@ -0,0 +1,17 @@
+<script lang="ts">
+	// The public `<Edytor>`: the view, built again on a new document when the
+	// room re-seeds the one it owns (`room.reseed.protocol`).
+	import Edytor, { type EdytorProps } from './Edytor.svelte';
+
+	// eslint-disable-next-line no-useless-assignment -- bindable: `adopt` assigns it
+	let { edytor = $bindable(), ...props }: EdytorProps = $props();
+	let epoch = $state(0);
+</script>
+
+<!-- A view built again loads the room's document: it never seeds its value over it. -->
+{#key epoch}<Edytor
+		{...props}
+		requireHydration={epoch > 0 || props.requireHydration}
+		adopt={(view) => (edytor = view)}
+		rebuild={() => epoch++}
+	/>{/key}

package/dist/components/EdytorRoot.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type EdytorProps } from './Edytor.svelte';
+declare const EdytorRoot: import("svelte").Component<EdytorProps, {}, "edytor">;
+type EdytorRoot = ReturnType<typeof EdytorRoot>;
+export default EdytorRoot;

package/dist/components/Suggestion.svelte

@@ -31,7 +31,7 @@
 	contenteditable="false"
 	aria-label={suggestion.label ?? labelsOf(edytor, 'editor', editorEnglish).suggestion}
 	role="group"
-	use:edytor.surface.preview={suggestion.id}
+	use:edytor.surface.own={suggestion.id}
 	onmousedown={cancel}
 >
 	{#each cells as cell (cell.id)}<Block kid={cell} />{/each}

package/dist/crdt/attribution/block.d.ts

@@ -78,6 +78,9 @@ export type BlockAttribution = {
     lastChangedBy?: ActorId;
 };
 export { BLOCK_ATTR_ROOT, LAST_CHANGED_ATTR };
+/** A record's `createdBy` key, and the prefix of its contributors' (a re-seed copies them: `crdt/reseed.ts`). */
+export declare const CREATED_KEY = "c";
+export declare const CONTRIBUTOR_PREFIX = "k/";
 /** The `k/` member set on a `b/` record node. */
 export declare const contributorsOfRecord: (rec: EngineNode | null) => Set<ActorId>;
 /**

package/dist/crdt/attribution/block.js

@@ -5,8 +5,9 @@ import { attrItems, newNode as makeNode } from '../structs.js';
 // `../schema.js` leaf — re-exported so existing import sites stay.
 export { BLOCK_ATTR_ROOT, LAST_CHANGED_ATTR };
 const REC_NODE = 'brec';
-const CREATED_KEY = 'c';
-const CONTRIBUTOR_PREFIX = 'k/';
+/** A record's `createdBy` key, and the prefix of its contributors' (a re-seed copies them: `crdt/reseed.ts`). */
+export const CREATED_KEY = 'c';
+export const CONTRIBUTOR_PREFIX = 'k/';
 /** Incarnation stamp on a record: the nonce `n` of the node it belongs to. */
 const INCARNATION_KEY = 'i';
 const recordOf = (doc, id) => {

package/dist/crdt/doc/suggest.d.ts

@@ -89,8 +89,12 @@ export type SuggestContext = DocBase & DocReads & {
     create: (doc: EngineDoc, config: EdytorDocConfig) => SuggestFacade;
     /** Its changes no index fact shows: counted in the facade's `version`. */
     v: number;
-    /** The export `toJSON()` gives unless asked for the suggestions. */
-    base: (() => JSONDoc | undefined) | undefined;
+    /**
+     * The document without its pending suggestions, read by `read` (the
+     * export `toJSON()` gives unless asked for the suggestions);
+     * `undefined` while none is pending.
+     */
+    base: (<T>(read: (other: SuggestFacade) => T) => T | undefined) | undefined;
 };
 /** The facade the part is built over: its `part`, and the operations it writes through. */
 export type SuggestFacade = {

package/dist/crdt/doc/suggest.js

@@ -526,10 +526,11 @@ const docSuggest = (f) => {
         return [...map.keys()].sort(c.compare).flatMap((b) => map.get(b));
     };
     /**
-     * The document without its pending suggestions (`sugg.json.base`): on a
-     * copy, every pending one rejected; `undefined` while none is pending.
+     * The document without its pending suggestions (`sugg.json.base`), read
+     * by `read`: on a copy, every pending one rejected; `undefined` while
+     * none is pending.
      */
-    const base = () => {
+    const base = (read) => {
         if (root().attrKeys().next().done || !changes().length)
             return;
         const { Y } = c;
@@ -538,11 +539,11 @@ const docSuggest = (f) => {
         const other = c.create(copy, { ...c.config, actor: undefined });
         const all = suggestionsOf(other);
         all.run(all.decide(all.changes(), false));
-        const json = other.toJSON({ suggestions: true });
+        const out = read(other);
         all.dispose();
         other.dispose();
         copy.destroy();
-        return json;
+        return out;
     };
     c.base = base;
     return {

package/dist/crdt/edytor-doc.d.ts

@@ -1032,7 +1032,7 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
      * Make the visible document `doc` equal `json`, keeping the ids the
      * registry holds and writing only what differs (`room.history.restore`), inside the caller's transaction.
      */
-    restoreTo: <Plan>(doc: EngineDoc, facade: import("./restore.js").RestoreFacade<Plan>, json: JSONDoc) => import("./restore.js").RestoreReport;
+    restoreTo: <Plan>(doc: EngineDoc, facade: import("./restore.js").RestoreFacade<Plan>, json: JSONDoc, { rewrite, suggestions }?: import("./restore.js").RestoreOptions<Plan>) => import("./restore.js").RestoreReport;
     model: {
         REGISTRY_KEY: string;
         registryOf: (doc: EngineDoc) => EngineNode;

package/dist/crdt/edytor-doc.js

@@ -220,7 +220,7 @@ export const docFacade = (Y, layers) => {
          */
         const toJSON = (options) => {
             // A part's export first (the shared suggestions': without the pending ones, `sugg.json.base`).
-            const base = !options?.suggestions && part.base?.();
+            const base = !options?.suggestions && part.base?.((other) => other.toJSON({ suggestions: true }));
             if (base)
                 return base;
             const data = docData();

package/dist/crdt/engine-room.d.ts

@@ -0,0 +1,4 @@
+import type * as V from './vendor/yjs/dts/index.js';
+
+export declare const clipUpdate: typeof V.clipUpdate;
+export declare const diffUpdate: typeof V.diffUpdate;

package/dist/crdt/engine-room.js

@@ -0,0 +1,6 @@
+/**
+ * The engine calls only the room makes (a re-seed's cut and rebase,
+ * `crdt/reseed.ts`): apart from the engine object (`engine.js`), which every
+ * app keeps whole, so an app's bundle holds none of them.
+ */
+export { clipUpdate, diffUpdate } from './vendor/yjs/src/index.js';

package/dist/crdt/index.d.ts

@@ -360,7 +360,7 @@ export declare const bindCrdt: (Y: EngineApi) => {
             text: import("./text/model.js").TextEngine;
         }, horizon: import("./purge.js").Horizon | null) => import("./purge.js").PurgeReport;
         horizonOf: (doc: import("./engine-api.js").EngineDoc) => import("./purge.js").Horizon | null;
-        restoreTo: <Plan>(doc: import("./engine-api.js").EngineDoc, facade: import("./restore.js").RestoreFacade<Plan>, json: import("./index.js").JSONDoc) => import("./restore.js").RestoreReport;
+        restoreTo: <Plan>(doc: import("./engine-api.js").EngineDoc, facade: import("./restore.js").RestoreFacade<Plan>, json: import("./index.js").JSONDoc, { rewrite, suggestions }?: import("./restore.js").RestoreOptions<Plan>) => import("./restore.js").RestoreReport;
         model: {
             REGISTRY_KEY: string;
             registryOf: (doc: import("./engine-api.js").EngineDoc) => import("./engine-api.js").EngineNode;
@@ -551,6 +551,7 @@ export declare const bindCrdt: (Y: EngineApi) => {
                     deny(): void;
                     allow(): void;
                 };
+                _rebasing: boolean;
                 messageHandlers: Record<number, import("./providers/room.js").RoomMessageHandler</*elided*/ any>>;
                 hasSynced: boolean;
                 whenSynced: Promise<unknown>;

package/dist/crdt/protocol.d.ts

@@ -27,9 +27,9 @@
 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, GenerationMismatchError, readProtocolVersion, type GenerationRecord } from './protocols/envelope.js';
-export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, messageComments, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkError, type ChunkReader, CLOSE } from './providers/room.js';
+export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, messageComments, messageRebase, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkError, type ChunkReader, CLOSE } from './providers/room.js';
 export { messageYjsSyncStep1, messageYjsSyncStep2, messageYjsUpdate, type SyncProtocol } from './protocols/sync.js';
-export { messageAccess, messagePermissionDenied, messageReadOnly, writeAccess, writePermissionDenied, writeReadOnly } from './protocols/auth.js';
+export { messageAccess, messageEpoch, messagePermissionDenied, messageReadOnly, writeAccess, writeEpoch, 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, readAwarenessEntries, writeAwarenessEntries, type AwarenessEntry } from './protocols/awareness.js';
 export { createDecoder, readVarUint, readVarUint8Array, type Decoder } from 'lib0-v14/decoding';

package/dist/crdt/protocol.js

@@ -30,9 +30,9 @@ export { bindCrdt } from './index.js';
 export { SCHEMA_VERSION, META_KEY } from './edytor-doc.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, ChunkError, CLOSE } from './providers/room.js';
+export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, messageComments, messageRebase, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkError, CLOSE } from './providers/room.js';
 export { messageYjsSyncStep1, messageYjsSyncStep2, messageYjsUpdate } from './protocols/sync.js';
-export { messageAccess, messagePermissionDenied, messageReadOnly, writeAccess, writePermissionDenied, writeReadOnly } from './protocols/auth.js';
+export { messageAccess, messageEpoch, messagePermissionDenied, messageReadOnly, writeAccess, writeEpoch, writePermissionDenied, writeReadOnly } from './protocols/auth.js';
 export { commentsSubscribe, commentsSnapshot, commentsChange, writeCommentsSubscribe, writeCommentsSnapshot, writeCommentsChange, readCommentsMessage } from './protocols/comments.js';
 export { applyAwarenessUpdate, encodeAwarenessUpdate, readAwarenessEntries, writeAwarenessEntries } from './protocols/awareness.js';
 // Minimal wire codec for frame bodies (lib0 — the codec the frames are

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

@@ -28,6 +28,13 @@ export declare const writeReadOnly: (encoder: encoding.Encoder) => void;
  */
 export declare const messageAccess = 2;
 export declare const writeAccess: (encoder: encoding.Encoder, access: string) => void;
+/**
+ * The room's epoch (`room.reseed.protocol`), sent to a socket that dialed an
+ * older one, instead of anything else: the room asks it for its old
+ * document (`messageRebase`), then closes it `4410`.
+ */
+export declare const messageEpoch = 3;
+export declare const writeEpoch: (encoder: encoding.Encoder, epoch: number) => void;
 export type PermissionDeniedHandler = (ydoc: unknown, reason: string) => void;
 /**
  * Decode one auth payload. Returns the auth message subtype so the caller
@@ -35,4 +42,4 @@ export type PermissionDeniedHandler = (ydoc: unknown, reason: string) => void;
  * do not speak is protocol skew, and this stack's contract is that skew is
  * reported, not silently dropped (same rule as unknown sync subtypes).
  */
-export declare const readAuthMessage: (decoder: decoding.Decoder, y: unknown, permissionDeniedHandler: PermissionDeniedHandler, readOnlyHandler?: (ydoc: unknown) => void, accessHandler?: (access: string) => void) => number;
+export declare const readAuthMessage: (decoder: decoding.Decoder, y: unknown, permissionDeniedHandler: PermissionDeniedHandler, readOnlyHandler?: (ydoc: unknown) => void, accessHandler?: (access: string) => void, epochHandler?: (epoch: number) => void) => number;

package/dist/crdt/protocols/auth.js

@@ -36,13 +36,23 @@ export const writeAccess = (encoder, access) => {
     encoding.writeVarUint(encoder, messageAccess);
     encoding.writeVarString(encoder, access);
 };
+/**
+ * The room's epoch (`room.reseed.protocol`), sent to a socket that dialed an
+ * older one, instead of anything else: the room asks it for its old
+ * document (`messageRebase`), then closes it `4410`.
+ */
+export const messageEpoch = 3;
+export const writeEpoch = (encoder, epoch) => {
+    encoding.writeVarUint(encoder, messageEpoch);
+    encoding.writeVarUint(encoder, epoch);
+};
 /**
  * Decode one auth payload. Returns the auth message subtype so the caller
  * can surface unknown subtypes — a valid envelope carrying an auth type we
  * do not speak is protocol skew, and this stack's contract is that skew is
  * reported, not silently dropped (same rule as unknown sync subtypes).
  */
-export const readAuthMessage = (decoder, y, permissionDeniedHandler, readOnlyHandler, accessHandler) => {
+export const readAuthMessage = (decoder, y, permissionDeniedHandler, readOnlyHandler, accessHandler, epochHandler) => {
     const authMessageType = decoding.readVarUint(decoder);
     switch (authMessageType) {
         case messagePermissionDenied:
@@ -54,6 +64,9 @@ export const readAuthMessage = (decoder, y, permissionDeniedHandler, readOnlyHan
             break;
         case messageAccess:
             accessHandler?.(decoding.readVarString(decoder));
+            break;
+        case messageEpoch:
+            epochHandler?.(decoding.readVarUint(decoder));
     }
     return authMessageType;
 };

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

@@ -243,6 +243,7 @@ export declare const bindProviders: (Y: EngineApi) => {
                 deny(): void;
                 allow(): void;
             };
+            _rebasing: boolean;
             messageHandlers: Record<number, import("./room.js").RoomMessageHandler</*elided*/ any>>;
             hasSynced: boolean;
             whenSynced: Promise<unknown>;

package/dist/crdt/providers/index.js

@@ -1,6 +1,6 @@
 import { keepingReplaced } from '../incarnations.js';
 import { bindIndexeddbProvider } from './indexeddb.js';
-import { assertRoomId, SyncRefusedError } from './room.js';
+import { assertRoomId, CLOSE, SyncRefusedError } from './room.js';
 import { bindWebsocketProvider } from './websocket.js';
 export const bindProviders = (Y) => {
     const idb = bindIndexeddbProvider(Y);
@@ -50,7 +50,18 @@ export const bindProviders = (Y) => {
                 maxBackoffTime,
                 connectTimeout,
                 disableBc: disableBc || local !== undefined,
-                maxFrameBytes
+                maxFrameBytes,
+                // With a local copy, the dial waits for it: the epoch it names is the copy's.
+                connect: local === undefined
+            });
+            const dial = () => provider._destroyed || provider.connect();
+            // A re-seed (`room.reseed.protocol`, a `4410` refusal): the local copy goes,
+            // its deletion waiting for every tab's connection to close.
+            provider.on('refused', ({ code }) => {
+                if (code !== CLOSE.reseeded || !loaded)
+                    return;
+                void release?.();
+                void idb.clearDocument(persistName);
             });
             if (onExpired)
                 provider.on('expired', (state) => onExpired(state));
@@ -94,9 +105,17 @@ export const bindProviders = (Y) => {
                 });
             }
             let release = undefined;
+            // The store's load (or its failure) opens the dial.
+            const loaded = local &&
+                Object.assign((p) => local({
+                    ...p,
+                    synced: (x) => (p.synced(x), dial()),
+                    failed: (error, x) => (p.failed?.(error, x), dial())
+                }), local);
             try {
                 // Called directly (no `attach`), the store only persists: readiness is the socket's.
-                release = local && (attach ? attach(local) : local({ doc, awareness, synced: () => { } }));
+                release =
+                    loaded && (attach ? attach(loaded) : loaded({ doc, awareness, synced: () => { } }));
             }
             catch (error) {
                 provider.destroy();

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

@@ -61,6 +61,12 @@ export declare const messageChunk = 5;
  * room sends it only to a socket that subscribed.
  */
 export declare const messageComments = 6;
+/**
+ * Client → server, after a re-seed (`room.reseed.protocol`): the client's
+ * whole old document, its unsaved edits in it, for the room to rebase onto
+ * the current epoch. Sent only when the room asks (its epoch notice).
+ */
+export declare const messageRebase = 7;
 /** A WebSocket message limit on Cloudflare (32 MiB): a larger frame is sent as chunks. */
 export declare const MAX_FRAME_BYTES: number;
 /**
@@ -203,6 +209,15 @@ export declare const CLOSE: {
     readonly denied: 4403;
     /** The dialed replica is bound to another user. */
     readonly replicaTaken: 4409;
+    /**
+     * The room re-seeded the document (`room.reseed.protocol`; the reason is
+     * the room's epoch): a refusal of this document, once a client with
+     * unsaved edits redialed and handed them over. The new epoch is a new
+     * document's. Also the answer to a copy the room cannot rebase (an
+     * epoch past the cuts it keeps, or a later one) and to an older epoch's
+     * content on a socket of the current one.
+     */
+    readonly reseeded: 4410;
     /**
      * A room quota refused the socket's write (`quota: document`,
      * `quota: rate`, `quota: frame`): the frame was not applied, and a

package/dist/crdt/providers/room.js

@@ -63,6 +63,12 @@ export const messageChunk = 5;
  * room sends it only to a socket that subscribed.
  */
 export const messageComments = 6;
+/**
+ * Client → server, after a re-seed (`room.reseed.protocol`): the client's
+ * whole old document, its unsaved edits in it, for the room to rebase onto
+ * the current epoch. Sent only when the room asks (its epoch notice).
+ */
+export const messageRebase = 7;
 /** A WebSocket message limit on Cloudflare (32 MiB): a larger frame is sent as chunks. */
 export const MAX_FRAME_BYTES = 32 * 1024 * 1024;
 const chunkStart = 0;
@@ -334,6 +340,15 @@ export const CLOSE = {
     denied: 4403,
     /** The dialed replica is bound to another user. */
     replicaTaken: 4409,
+    /**
+     * The room re-seeded the document (`room.reseed.protocol`; the reason is
+     * the room's epoch): a refusal of this document, once a client with
+     * unsaved edits redialed and handed them over. The new epoch is a new
+     * document's. Also the answer to a copy the room cannot rebase (an
+     * epoch past the cuts it keeps, or a later one) and to an older epoch's
+     * content on a socket of the current one.
+     */
+    reseeded: 4410,
     /**
      * A room quota refused the socket's write (`quota: document`,
      * `quota: rate`, `quota: frame`): the frame was not applied, and a

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

@@ -174,6 +174,8 @@ export declare const bindWebsocketProvider: (Y: EngineApi) => {
                 /** The room asks a read-only socket for its state again: what this actor wrote is unsaved until stored. */
                 allow(): void;
             };
+            /** @internal The room re-seeded: this document's unsaved edits are being handed over (`room.reseed.protocol`). */
+            _rebasing: boolean;
             messageHandlers: Record<number, RoomMessageHandler</*elided*/ any>>;
             hasSynced: boolean;
             whenSynced: Promise<unknown>;
@@ -193,8 +195,8 @@ export declare const bindWebsocketProvider: (Y: EngineApi) => {
              * decodes it). `''`, `.`, `..`, an id over 256 characters and one with a
              * lone surrogate are refused at construction ({@link assertRoomId}). `params` are read at every dial (a refreshed token
              * reaches the next connection), with `replica` = this document's
-             * client id unless `params` names one: the room binds the socket's
-             * writes to it.
+             * client id unless `params` names one (the room binds the socket's
+             * writes to it), and `epoch`, the document's, which no param replaces.
              */
             get url(): string;
             /** Updates of this document's actor the room has not acknowledged as persisted yet. */

package/dist/crdt/providers/websocket.js

@@ -47,18 +47,19 @@
  * there (TCP never does).
  */
 import * as decoding from 'lib0-v14/decoding';
+import * as encoding from 'lib0-v14/encoding';
 import * as time from 'lib0-v14/time';
 import * as math from 'lib0-v14/math';
 import * as url from 'lib0-v14/url';
 import { Awareness, removeAwarenessStates } from '../protocols/awareness.js';
 import { IsolatedObservable } from '../protocols/observable.js';
-import { messagePermissionDenied, messageAccess, messageReadOnly, READ_ONLY_DENIAL, SUGGEST_ONLY_DENIAL, readAuthMessage } from '../protocols/auth.js';
+import { messagePermissionDenied, messageAccess, messageEpoch, messageReadOnly, READ_ONLY_DENIAL, SUGGEST_ONLY_DENIAL, readAuthMessage } from '../protocols/auth.js';
 import { bindSync } from '../protocols/sync.js';
 import { readCommentsMessage, writeCommentsSubscribe } from '../protocols/comments.js';
 import { frame } from '../protocols/envelope.js';
-import { assertRoomId, beginDestroy, bindRoomProtocol, tabs, chunkFrame, CLOSE, createChunkReader, emitFailed, fault, initLifecycle, isRefusal, unknownType, LOCAL_PRESENCE_LOSS, markSynced, messageAuth, messageChunk, messageComments, messageSaved, messageSync, MAX_FRAME_BYTES, SyncRefusedError } from './room.js';
+import { assertRoomId, beginDestroy, bindRoomProtocol, tabs, chunkFrame, CLOSE, createChunkReader, emitFailed, fault, initLifecycle, isRefusal, unknownType, LOCAL_PRESENCE_LOSS, markSynced, messageAuth, messageChunk, messageComments, messageRebase, messageSaved, messageSync, MAX_FRAME_BYTES, SyncRefusedError } from './room.js';
 import { asEngineDoc } from '../structs.js';
-import { ATTRIBUTION_ROOT } from '../schema.js';
+import { ATTRIBUTION_ROOT, EPOCH_ROOT } from '../schema.js';
 import { ATTRIBUTION_ORIGIN, writerOf } from '../attribution/attribution.js';
 // @todo - this should depend on awareness.outdatedTime
 const messageReconnectTimeout = 30000;
@@ -129,10 +130,17 @@ export const bindWebsocketProvider = (Y) => {
                 // The room's notice at the join: a state, not a refusal (no event).
                 () => provider._writes.deny(), 
                 // The room's word at the join, and at a change in place (`read`).
-                (access) => provider.emit('access', [access, provider]));
+                (access) => provider.emit('access', [access, provider]), 
+                // The room re-seeded since this document's epoch: it asks for the
+                // document, its unsaved edits in it (`room.reseed.protocol`).
+                () => {
+                    provider._rebasing = true;
+                    send(provider, frame(messageRebase, (e) => encoding.writeVarUint8Array(e, Y.encodeStateAsUpdate(provider.doc))));
+                });
                 if (authType !== messagePermissionDenied &&
                     authType !== messageReadOnly &&
-                    authType !== messageAccess) {
+                    authType !== messageAccess &&
+                    authType !== messageEpoch) {
                     // An auth type we do not speak inside a valid v14 envelope is
                     // protocol skew — reported, never dropped silently.
                     unknownType(provider, 'auth', authType);
@@ -400,6 +408,13 @@ export const bindWebsocketProvider = (Y) => {
                 provider.awareness.meta.delete(client);
             provider.emit('status', [{ status: 'disconnected' }]);
         }
+        // A re-seed (`room.reseed.protocol`): unsaved edits are handed over first,
+        // by a dial of this document's epoch, older now, which the room asks for
+        // them. Then, or with none, it is a refusal: the new epoch is a new document's.
+        if (event?.code === CLOSE.reseeded && provider.unsaved > 0 && !provider._rebasing) {
+            provider._rebasing = true;
+            return setupWS(provider);
+        }
         if (event && isRefusal(event.code)) {
             // Terminal: the next dial would be refused the same way.
             provider.shouldConnect = false;
@@ -511,6 +526,8 @@ export const bindWebsocketProvider = (Y) => {
         _chunks = createChunkReader();
         /** This actor's writes pending the room's acknowledgement. */
         _writes;
+        /** @internal The room re-seeded: this document's unsaved edits are being handed over (`room.reseed.protocol`). */
+        _rebasing = false;
         messageHandlers = room.messageHandlers;
         // The room lifecycle — installed by `initLifecycle`.
         hasSynced;
@@ -596,12 +613,22 @@ export const bindWebsocketProvider = (Y) => {
          * decodes it). `''`, `.`, `..`, an id over 256 characters and one with a
          * lone surrogate are refused at construction ({@link assertRoomId}). `params` are read at every dial (a refreshed token
          * reaches the next connection), with `replica` = this document's
-         * client id unless `params` names one: the room binds the socket's
-         * writes to it.
+         * client id unless `params` names one (the room binds the socket's
+         * writes to it), and `epoch`, the document's, which no param replaces.
          */
         get url() {
-            const query = url.encodeQueryParams({ replica: String(this.doc.clientID), ...this.params });
-            return `${this.serverUrl}/${encodeURIComponent(this.roomname)}?${query}`;
+            // The document's epoch (`new`: it holds nothing yet), which the room checks (`room.reseed.protocol`).
+            const epoch = this.doc.store.clients.size
+                ? String(asEngineDoc(this.doc).get(EPOCH_ROOT).getAttr('n') ?? 0)
+                : 'new';
+            const query = {
+                replica: String(this.doc.clientID),
+                epoch,
+                ...this.params
+            };
+            // In its place, but no param of the app's names it instead.
+            query.epoch = epoch;
+            return `${this.serverUrl}/${encodeURIComponent(this.roomname)}?${url.encodeQueryParams(query)}`;
         }
         /** Updates of this document's actor the room has not acknowledged as persisted yet. */
         get unsaved() {