@procedures/store 0.24.0 → 0.24.1

package/dist/storage/tab-coordinator.js

@@ -25,6 +25,39 @@
  * - The leader sends the status of its sync to the followers: at each change, and in answer to a
  *   hello. `getStatus()` and `onStatus()` give the status in each tab (roadmap CLI-65).
  *
+ * A `TabGroup` runs the sync of many collections with one lock and one channel (roadmap CLI-64),
+ * for example all the collections of a tenant.
+ *
+ * - The leader of the group runs one `HybridStorage` for each collection. Each message has the
+ *   field `collection`, and each collection has its own batches, acknowledgements and status.
+ * - Each collection leads when its own queue loaded, and it tells the other tabs at once. Thus a
+ *   slow collection does not stop the batches of the other collections.
+ * - A collection whose setup fails tries again alone after its backoff, and the other collections
+ *   keep their sync. The tab sends a status with the error of the setup to the other tabs.
+ * - When no collection of the group leads or loads its queue, the tab releases the lock. It asks for
+ *   the lock again after the backoff of the group, as a `TabCoordinator` does. This is also true for
+ *   a collection that the application adds after the tab got the lock.
+ * - The lock and the channel of a group have the prefix `@procedures/store/tabs:`. A
+ *   `TabCoordinator` has the prefix `@procedures/store/tab:`. Thus a group and a coordinator never
+ *   share a lock or a channel, also with the same name.
+ * - With the option `open`, the leader makes a collection that another tab has and that this tab
+ *   does not have. Thus the tabs can open different collections.
+ *
+ * A snapshot for a new tab (roadmap CLI-66): with `copy: "tab"` and the option `snapshot`, a new
+ * tab asks the leader for the entries of its local copy.
+ *
+ * - The leader reads the entries of its copy, and it sends them in chunks of `snapshot.chunk`
+ *   entries. Each chunk has the numbers of the last batches that the copy holds, one for each tab.
+ * - The new tab keeps the batches of the other tabs until the last chunk comes. It writes the
+ *   entries to its copy, and then it writes the batches with a number after the snapshot.
+ * - The new tab keeps the values of its own writes after the snapshot.
+ * - A set in the entries can come again in a batch after the snapshot, for example a write of the
+ *   leader during its read. The second write of the set gives the same state.
+ * - When the leader changes before the last chunk, the tab asks the new leader. When no chunk comes
+ *   in the time `snapshot.timeout`, the tab reports an error and continues without the snapshot.
+ * - In the tab that holds the lock, the wait renews itself while the collection loads its queue, at
+ *   most `SNAPSHOT_RENEWALS` times. Thus the batches of the other tabs wait for a limited time.
+ *
  * The limits:
  * - When the leader stops during a push, the next leader sends the operation again: the delivery to
  *   the remote is at least once.
@@ -32,6 +65,12 @@
  *   capture. The tabs agree again after the push and the next pull.
  * - The load of the queue in a new leader writes the queued operations to the local copy again, and
  *   the observers get them again with the origin `syncOrigin`.
+ * - The leader reads all the entries of a snapshot at one time, and the new tab keeps all the chunks
+ *   until the last one. Thus a snapshot is for a local copy that fits in the memory of a tab.
+ * - `snapshot.chunk` counts the entries of a message, not its bytes: large items give large messages.
+ * - A `TabCoordinator` and a `TabGroup` of one collection do not see each other. When tabs of both
+ *   releases are open, two tabs lead the collection. Give the group a new queue store, or close
+ *   the tabs of the older release first.
  *
  * Nothing in this module reads a global value when it loads: Node can import it. The coordinator
  * reads `navigator.locks` and `BroadcastChannel` when it starts, and a test gives its own.
@@ -42,11 +81,20 @@ import { backoffDelay } from "@mark1russell7/service/backoff";
 import { HybridStorage } from "./hybrid.js";
 /**
  * The version of the messages. A tab ignores a message of another version, and a message of a type
- * that it does not know. Thus a new type of message (`status`, roadmap CLI-65) keeps the version 1:
- * a tab of an older release ignores it, and it still copies and sends the batches. A new version
- * stops the batches between the tabs of two releases, so only a change of a known message needs it.
+ * that it does not know. Thus a new type of message (`status`, roadmap CLI-65, and `snapshot`,
+ * roadmap CLI-66) keeps the version 1: a tab of an older release ignores it, and it still copies
+ * and sends the batches. A new version stops the batches between the tabs of two releases, so only
+ * a change of a known message needs it.
  */
 const PROTOCOL = 1;
+/** The prefixes of the lock and of the channel: of a `TabCoordinator`, and of a `TabGroup`. */
+const COORDINATOR_PREFIX = "@procedures/store/tab:";
+const GROUP_PREFIX = "@procedures/store/tabs:";
+/** The defaults of the snapshot (roadmap CLI-66). */
+const SNAPSHOT_CHUNK = 500;
+const SNAPSHOT_TIMEOUT = 10_000;
+/** The largest number of renewals of the wait for a snapshot in the tab that holds the lock. */
+const SNAPSHOT_RENEWALS = 5;
 /**
  * One leader tab runs the sync of a `HybridStorage`, and the other tabs copy its changes.
  *
@@ -77,31 +125,571 @@ export class TabCoordinator {
     id;
     /** The name of the lock and of the channel. */
     lockName;
+    group;
+    collection;
+    constructor(options) {
+        if (typeof options?.name !== "string" || options.name === "")
+            throw new TypeError("TabCoordinator needs a name");
+        const settings = collectionSettings(options, "TabCoordinator");
+        const hybrid = options.hybrid ?? {};
+        this.group = new GroupEngine({
+            prefix: COORDINATOR_PREFIX,
+            name: options.name,
+            single: true,
+            open: undefined,
+            backoff: retryBackoff(options.retry),
+            clock: options.clock ?? hybrid.clock ?? realClock,
+            random: options.random ?? hybrid.random ?? Math.random,
+            onError: options.onError ?? reportListenerError,
+        });
+        this.id = this.group.id;
+        this.lockName = this.group.lockName;
+        this.collection = this.group.add(options.name, options, settings);
+        this.group.start(options.locks, options.channel);
+    }
+    /** The role of this tab now. */
+    get role() {
+        return this.collection.role;
+    }
+    /** True when this tab runs the sync: the leader, or a tab in the single mode. */
+    get isLeader() {
+        return this.collection.isLeader;
+    }
+    /**
+     * The `HybridStorage` of the sync while this tab runs it, or else undefined. `getStatus()` of the
+     * coordinator gives the state of the sync in each tab. Write to the local copy, not to this
+     * storage: each tab then writes in the same way.
+     */
+    get syncStorage() {
+        return this.collection.syncStorage;
+    }
+    /**
+     * This method starts to send the change batches to an observer: the batches of the local copy of
+     * this tab, and the batches of the other tabs. Each batch comes one time, with the origin of each
+     * change. In the leader, the batches of the sync have the origin `syncOrigin` of the
+     * `HybridStorage`. A batch of another tab comes after the local copy of this tab has it. The
+     * entries of a snapshot come in one batch of sets, with the origin `syncOrigin`. A set of the
+     * snapshot can come again in a later batch, with the same value.
+     *
+     * @returns The function that stops the batches. A second use of it does nothing.
+     * @throws Error after `close()`
+     */
+    observe(observer) {
+        return this.collection.observe(observer);
+    }
+    /**
+     * This method starts to send the role of this tab to a listener at each change.
+     *
+     * @returns The function that stops the roles. A second use of it does nothing.
+     * @throws Error after `close()`
+     */
+    onRole(listener) {
+        return this.collection.onRole(listener);
+    }
+    /**
+     * The status of the sync (roadmap CLI-65), or undefined before the first status and after
+     * `close()`.
+     *
+     * - In the leader and in the single mode, it is the status of the `HybridStorage` of this tab.
+     * - In a follower, it is the last status that the leader sent. A new tab gets it in the answer to
+     *   its hello. After a change of the leader, a follower keeps the last status until the new
+     *   leader sends its status.
+     * - In a follower, `error.error` is a copy of the error of the leader: an `Error` with its `name`,
+     *   its `message` and its `code`. The copy has no `cause`.
+     */
+    getStatus() {
+        return this.collection.getStatus();
+    }
+    /**
+     * This method starts to send the status of the sync to a listener at each change (roadmap
+     * CLI-65): in the leader, each status of its `HybridStorage`, and in a follower, each status that
+     * the leader sends. The listener gets each status one time. When the tab becomes the leader, the
+     * listener gets the status of its own `HybridStorage`.
+     *
+     * @returns The function that stops the statuses. A second use of it does nothing.
+     * @throws Error after `close()`
+     */
+    onStatus(listener) {
+        return this.collection.onStatus(listener);
+    }
+    /**
+     * This method closes the coordinator.
+     *
+     * - A follower stops its lock request, or its wait before a new try. It does not become the leader.
+     * - A tab that loads its queue to become the leader closes its `HybridStorage`, and releases the lock.
+     * - The leader closes its `HybridStorage`: it sends the queue, and the queue store keeps the
+     *   operations that the remote did not take. Then the leader releases the lock, and the next
+     *   tab becomes the leader.
+     * - The coordinator closes its channel. It does not close the local copy: the application owns it.
+     * - After it, the coordinator sends and copies nothing. A second `close()` gives the promise of
+     *   the first one.
+     */
+    close() {
+        return this.group.close();
+    }
+}
+/**
+ * One leader tab runs the sync of many collections, with one lock and one channel (roadmap CLI-64).
+ * The other tabs copy the changes of each collection.
+ *
+ * @example
+ * ```typescript
+ * import { ApiStorage, IndexedDbQueueStore, TabGroup } from "@procedures/store/browser";
+ *
+ * const tenant = new TabGroup({
+ *   name: tenantId,
+ *   open: (collection) => ({
+ *     local: localCopyOf(collection),
+ *     copy: "tab",
+ *     remote: () => new ApiStorage(client, { collection }),
+ *     hybrid: { queueStore: new IndexedDbQueueStore(`${tenantId}-${collection}-queue`) },
+ *     snapshot: true,
+ *   }),
+ * });
+ *
+ * const notes = tenant.collection<Note>("notes");
+ * notes.observe((batch) => render(batch));
+ * notes.onStatus((status) => showSync("notes", status));
+ * ```
+ */
+export class TabGroup {
+    /** The id of this tab: a new random id for each group. */
+    id;
+    /** The name of the lock and of the channel. */
+    lockName;
+    group;
+    constructor(options) {
+        if (typeof options?.name !== "string" || options.name === "")
+            throw new TypeError("TabGroup needs a name");
+        if (options.open !== undefined && typeof options.open !== "function")
+            throw new TypeError("The option open of a TabGroup must be a function");
+        this.group = new GroupEngine({
+            prefix: GROUP_PREFIX,
+            name: options.name,
+            single: false,
+            open: options.open,
+            backoff: retryBackoff(options.retry),
+            clock: options.clock ?? realClock,
+            random: options.random ?? Math.random,
+            onError: options.onError ?? reportListenerError,
+        });
+        this.id = this.group.id;
+        this.lockName = this.group.lockName;
+        this.group.start(options.locks, options.channel);
+    }
+    /** The role of this tab in the group. A collection has its own role too. */
+    get role() {
+        return this.group.role;
+    }
+    /** True when this tab holds the lock of the group, or runs in the single mode. */
+    get isLeader() {
+        return this.group.role === "leader" || this.group.role === "single";
+    }
+    /** The names of the collections of the group in this tab. */
+    get collections() {
+        return [...this.group.members.keys()];
+    }
+    /**
+     * This method gives a collection of the group. It adds the collection at its first use. When the
+     * group has the collection, the method gives it and ignores `options`.
+     *
+     * @param options The options of a new collection. The default is the result of `open(name)`.
+     * @throws TypeError for a new collection without options, or with options of a wrong shape
+     * @throws Error after `close()`
+     */
+    collection(name, options) {
+        return this.group.collection(name, options);
+    }
+    /**
+     * This method starts to send the role of this tab in the group to a listener at each change.
+     *
+     * @returns The function that stops the roles. A second use of it does nothing.
+     * @throws Error after `close()`
+     */
+    onRole(listener) {
+        if (this.group.closed)
+            throw new Error("The TabGroup is closed");
+        return this.group.roleListeners.add(listener);
+    }
+    /**
+     * This method closes the group and each of its collections, as `TabCoordinator.close()` does.
+     * The leader closes each `HybridStorage`, and then it releases the lock.
+     */
+    close() {
+        return this.group.close();
+    }
+}
+/**
+ * The lock, the channel and the collections of a tab. A `TabCoordinator` is a group with one
+ * collection, whose messages have no field `collection`: thus it talks with a tab of an older release.
+ */
+class GroupEngine {
+    id;
+    lockName;
+    /** True for a `TabCoordinator` */
+    legacy;
+    backoff;
+    clock;
+    random;
+    onError;
+    roleListeners;
+    /** The collections of this tab, by name */
+    members = new Map();
+    /** An object for each time that this tab holds the lock. A collection leads only with the lease of now. */
+    lease;
+    /** True in the single mode */
+    alone = false;
+    closed = false;
+    open;
+    /** The names for which `open` gave no options */
+    refused = new Set();
+    currentRole = "follower";
+    started = false;
+    /** The lock manager, or undefined in the single mode */
+    locks;
+    channel;
+    /** The number of the failed setups of the group in a row: each setup where no collection could lead */
+    failures = 0;
+    /** The stop of the wait before the next try */
+    cancelRetry;
+    closing;
+    /** The abort of the lock request that waits */
+    abortRequest;
+    /** The release of the lock */
+    releaseLock;
+    constructor(options) {
+        this.id = randomId();
+        this.lockName = `${options.prefix}${options.name}`;
+        this.legacy = options.single;
+        this.open = options.open;
+        this.backoff = options.backoff;
+        this.clock = options.clock;
+        this.random = options.random;
+        this.onError = options.onError;
+        this.roleListeners = new StorageListeners(this.onError);
+    }
+    get role() {
+        return this.currentRole;
+    }
+    /** True while the tab has a channel. */
+    get hasChannel() {
+        return this.channel !== undefined;
+    }
+    /** The name of the coordinator or of the group, for the messages of the errors. */
+    get kind() {
+        return this.legacy ? "TabCoordinator" : "TabGroup";
+    }
+    /** This method opens the channel and asks for the lock, or starts the single mode. */
+    start(locksOption, channelOption) {
+        this.started = true;
+        const locks = locksOption === undefined ? globalLocks() : (locksOption ?? undefined);
+        const openChannel = channelOption === undefined ? globalChannelFactory() : (channelOption ?? undefined);
+        if (!locks || !openChannel) {
+            this.startSingle();
+            return;
+        }
+        try {
+            this.channel = openChannel(this.lockName);
+        }
+        catch (error) {
+            this.onError(error);
+            this.startSingle();
+            return;
+        }
+        this.locks = locks;
+        this.channel.onmessage = (event) => this.receive(event?.data);
+        for (const member of this.members.values())
+            member.begin();
+        this.elect(locks);
+    }
+    /** This method gives a collection of a `TabGroup`, and adds it at its first use. */
+    collection(name, options) {
+        if (this.closed)
+            throw new Error("The TabGroup is closed");
+        if (typeof name !== "string" || name === "")
+            throw new TypeError("A collection of a TabGroup needs a name");
+        const known = this.members.get(name);
+        if (known)
+            return known;
+        const resolved = options ?? this.open?.(name);
+        if (!resolved)
+            throw new TypeError(`The TabGroup has no options for the collection ${JSON.stringify(name)}: give options or the function open`);
+        return this.add(name, resolved, collectionSettings(resolved, "A collection of a TabGroup"));
+    }
+    /** This method adds a collection. After the start, the collection says hello, and it leads when the tab holds the lock. */
+    add(name, options, settings) {
+        const member = new CollectionSync(this, name, options, settings);
+        this.members.set(name, member);
+        this.refused.delete(name);
+        if (!this.started)
+            return member;
+        if (this.alone) {
+            member.startSingle();
+            return member;
+        }
+        member.begin();
+        if (this.lease)
+            member.startLead(this.lease, true);
+        return member;
+    }
+    /** @returns False when the message did not go out: no channel, or a value that the channel cannot clone */
+    post(collection, message) {
+        const channel = this.channel;
+        if (!channel)
+            return false;
+        try {
+            channel.postMessage(this.legacy || collection === undefined ? message : { ...message, collection });
+            return true;
+        }
+        catch (error) {
+            this.onError(error);
+            return false;
+        }
+    }
+    close() {
+        if (!this.closing)
+            this.closing = this.shutDown();
+        return this.closing;
+    }
+    async shutDown() {
+        this.closed = true;
+        this.abortRequest?.();
+        this.abortRequest = undefined;
+        this.cancelRetry?.();
+        this.cancelRetry = undefined;
+        this.lease = undefined;
+        this.setRole("closed");
+        const members = [...this.members.values()];
+        try {
+            // The leader holds the lock until each queue reached the remote or its queue store
+            await Promise.all(members.map((member) => member.shutDown()));
+        }
+        finally {
+            this.releaseLock?.();
+            this.releaseLock = undefined;
+            // The acknowledgements of the close of the storages went out before
+            try {
+                this.channel?.close();
+            }
+            catch {
+                // The channel is closed already
+            }
+            this.channel = undefined;
+            for (const member of members)
+                member.clearListeners();
+            this.roleListeners.clear();
+        }
+    }
+    //
+    // ═══ The election ═══
+    //
+    /** This method asks for the lock. The tab becomes the leader when it gets the lock. */
+    elect(locks) {
+        const Controller = globalAbortController();
+        const controller = Controller ? new Controller() : undefined;
+        this.abortRequest = controller ? () => controller.abort() : undefined;
+        const held = new Promise((resolve) => (this.releaseLock = resolve));
+        let request;
+        try {
+            request = locks.request(this.lockName, controller ? { signal: controller.signal } : {}, async () => {
+                // A lock after close(): the tab releases it at once
+                if (this.closed)
+                    return;
+                this.abortRequest = undefined;
+                if (await this.lead()) {
+                    // close() ends the hold. A group whose collections all failed after the start ends it too.
+                    await held;
+                    if (this.closed)
+                        return;
+                }
+                // A failed setup releases the lock: another tab tries, and this tab tries again after the backoff
+                this.retryLater();
+            });
+        }
+        catch (error) {
+            request = Promise.reject(error);
+        }
+        request.then(undefined, (error) => {
+            // The abort of close(), or a tab that leads already
+            if (this.closed || this.lease)
+                return;
+            // The lock manager refused the request: this tab runs the sync alone
+            this.onError(error);
+            this.stopChannel();
+            this.locks = undefined;
+            this.startSingle();
+        });
+    }
+    /**
+     * This method runs in a tab that got the lock. Each collection makes its `HybridStorage` and
+     * loads its queue, and it leads at the end of its load. When no collection can lead, the tab
+     * releases the lock. Else the collections whose setup failed try again alone after their backoff.
+     *
+     * @returns False when the tab must release the lock: no collection could lead, or `close()`
+     */
+    async lead() {
+        const lease = {};
+        this.lease = lease;
+        const members = [...this.members.values()];
+        // Each collection tells the other tabs at once when it leads: a slow collection does not stop the batches of the others
+        const results = await Promise.all(members.map((member) => member.takeLead(lease, true)));
+        if (this.lease !== lease)
+            return false;
+        // A group without collections keeps the lock: its first collection leads, or releases the lock when its setup fails
+        if (!this.canLead()) {
+            this.stepDown();
+            return false;
+        }
+        this.failures = 0;
+        this.setRole("leader");
+        // Each follower says hello for each collection that it has and that the leader did not announce: the leader makes the collections that it does not have
+        if (!this.legacy)
+            this.post(undefined, { v: PROTOCOL, type: "leader", from: this.id });
+        members.forEach((member, at) => {
+            if (!results[at])
+                member.retryInLeader();
+        });
+        return true;
+    }
+    /**
+     * This method runs after a failed setup of a collection in a tab that holds the lock, and keeps
+     * it after `lead()`. When no collection of the group leads or loads its queue, the tab releases
+     * the lock and asks for it again after the backoff of the group. Else the collection tries again
+     * alone after its own backoff.
+     */
+    afterFailedSetup(member, lease) {
+        if (this.closed || this.lease !== lease)
+            return;
+        if (this.canLead()) {
+            member.retryInLeader();
+            return;
+        }
+        this.stepDown();
+        this.setRole("follower");
+        // The lock callback then asks for the lock again after the backoff
+        const release = this.releaseLock;
+        this.releaseLock = undefined;
+        release?.();
+    }
+    /** True when the group has no collections yet, or when one of its collections leads or loads its queue. */
+    canLead() {
+        const members = [...this.members.values()];
+        return members.length === 0 || members.some((member) => member.leads || member.settingUp);
+    }
+    /** This method ends the lease of the lock. A collection that waits for its next try stops its wait: the next lease tries it. */
+    stepDown() {
+        this.lease = undefined;
+        for (const member of this.members.values())
+            member.stopRetry();
+    }
+    /** This method starts the single mode: each collection runs its sync alone. */
+    startSingle() {
+        this.alone = true;
+        this.setRole("single");
+        for (const member of [...this.members.values()])
+            member.startSingle();
+    }
+    /** This method asks for the lock again after the backoff (roadmap CLI-67). */
+    retryLater() {
+        if (this.closed)
+            return;
+        this.failures++;
+        const wait = backoffDelay(this.backoff, this.failures, this.random);
+        const cancel = this.clock.after(wait, () => {
+            this.cancelRetry = undefined;
+            if (this.closed || !this.locks)
+                return;
+            this.elect(this.locks);
+        });
+        // The wait must not keep a Node process alive
+        cancel.unref?.();
+        this.cancelRetry = cancel;
+    }
+    setRole(role) {
+        if (this.currentRole === role)
+            return;
+        this.currentRole = role;
+        this.roleListeners.emit(role);
+    }
+    stopChannel() {
+        const channel = this.channel;
+        this.channel = undefined;
+        if (!channel)
+            return;
+        channel.onmessage = null;
+        try {
+            channel.close();
+        }
+        catch {
+            // The channel is closed already
+        }
+    }
+    //
+    // ═══ The messages of the other tabs ═══
+    //
+    receive(data) {
+        if (this.closed || !isTabMessage(data) || data.from === this.id)
+            return;
+        if (this.legacy) {
+            for (const member of this.members.values())
+                member.receive(data);
+            return;
+        }
+        const name = data.collection;
+        if (name === undefined) {
+            // A new leader of the group: each collection of this tab that the leader did not announce says hello
+            if (data.type === "leader")
+                for (const member of [...this.members.values()])
+                    member.onLeader(data.from, false);
+            return;
+        }
+        const member = this.members.get(name) ?? this.adopt(name, data.type);
+        member?.receive(data);
+    }
+    /**
+     * The leader makes a collection that another tab has, with the function `open`. Thus the leader
+     * runs the sync of each collection of each tab.
+     */
+    adopt(name, type) {
+        if ((type !== "hello" && type !== "changes") || this.currentRole !== "leader" || !this.open || this.refused.has(name))
+            return undefined;
+        try {
+            const options = this.open(name);
+            if (options)
+                return this.add(name, options, collectionSettings(options, "A collection of a TabGroup"));
+        }
+        catch (error) {
+            this.onError(error);
+        }
+        this.refused.add(name);
+        return undefined;
+    }
+}
+/**
+ * The sync of one collection in a tab: the leader runs its `HybridStorage`, and a follower copies
+ * the batches of the other tabs. The group gives the lock and the channel.
+ */
+class CollectionSync {
+    name;
+    group;
     local;
     shared;
     makeRemote;
     hybridOptions;
+    settings;
     /** The origin of the `HybridStorage` and of the writes of the coordinator to the local copy. */
     tag;
     writeOptions;
-    onError;
     observers;
     roleListeners;
     statusListeners;
     /** The observers that the `HybridStorage` of the leader adds to its local copy: the capture */
     captures;
-    /** The backoff of a new try after a failed setup, its clock and its random numbers */
-    backoff;
-    clock;
-    random;
     currentRole = "follower";
-    /** The lock manager, or undefined in the single mode */
-    locks;
-    channel;
     hybrid;
     /** The storage of this tab while it loads its queue, before the tab leads */
     candidate;
-    /** The number of the failed setups in a row */
+    /** The number of the failed setups of this collection in a row, when the group leads or is single */
     failures = 0;
     /** The stop of the wait before the next try */
     cancelRetry;
@@ -122,157 +710,97 @@ export class TabCoordinator {
     outbox = [];
     /** The number of the last batch of each other tab that this tab copied */
     seen = new Map();
+    /** The number of the last batch of each other tab that the local copy of this tab holds (roadmap CLI-66) */
+    applied = new Map();
     /** In the leader: the number of the last batch of each tab that the leader captured. A tab without a hello is not here. */
     captured = new Map();
     /** The batches of the other tabs: they reach the local copy and the observers in their order */
     incoming = Promise.resolve();
     closed = false;
-    closing;
-    /** The abort of the lock request that waits */
-    abortRequest;
-    /** The release of the lock */
-    releaseLock;
-    constructor(options) {
-        if (typeof options?.name !== "string" || options.name === "")
-            throw new TypeError("TabCoordinator needs a name");
-        if (typeof options.local?.observe !== "function")
-            throw new TypeError("TabCoordinator needs a local copy with observe()");
-        if (options.copy !== "shared" && options.copy !== "tab") {
-            throw new TypeError(`Unknown copy ${JSON.stringify(options.copy)}: use shared or tab`);
-        }
-        if (typeof options.remote !== "function")
-            throw new TypeError("TabCoordinator needs the function remote");
-        this.backoff = retryBackoff(options.retry);
-        this.id = randomId();
-        this.lockName = `@procedures/store/tab:${options.name}`;
+    /** The snapshot that this tab waits for, and the number of its last request (roadmap CLI-66) */
+    snapshot;
+    requests = 0;
+    /** The batches of the other tabs that wait for the snapshot, in their order */
+    held = [];
+    /** The own writes while the snapshot waits: the number of the last own batch of each id, and of the last clear */
+    ownWrites = new Map();
+    ownClear = 0;
+    /** The stop of the wait for the next chunk */
+    cancelSnapshotWait;
+    /** The last tab that told this tab that it leads this collection: the `leader` message of its group does not start a second hello */
+    announcedBy;
+    /** The error of the last failed setup of the sync */
+    setupError;
+    constructor(group, name, options, settings) {
+        this.group = group;
+        this.name = name;
         this.local = options.local;
         this.shared = options.copy === "shared";
         this.makeRemote = options.remote;
         this.hybridOptions = options.hybrid ?? {};
-        this.tag = this.hybridOptions.origin ?? `tab-${this.id}`;
+        this.settings = settings;
+        this.tag = this.hybridOptions.origin ?? `tab-${group.id}`;
         this.writeOptions = { origin: this.tag };
-        this.onError = options.onError ?? reportListenerError;
-        this.observers = new StorageListeners(this.onError);
-        this.roleListeners = new StorageListeners(this.onError);
-        this.statusListeners = new StorageListeners(this.onError);
-        this.captures = new StorageListeners(this.onError);
-        this.clock = options.clock ?? this.hybridOptions.clock ?? realClock;
-        this.random = options.random ?? this.hybridOptions.random ?? Math.random;
+        this.observers = new StorageListeners(group.onError);
+        this.roleListeners = new StorageListeners(group.onError);
+        this.statusListeners = new StorageListeners(group.onError);
+        this.captures = new StorageListeners(group.onError);
         // The observer of a follower. A tab that leads stops it. A single tab whose setup failed keeps its batches with it.
         this.stopTap = this.local.observe((batch) => this.onFollowerBatch(batch));
-        const locks = options.locks === undefined ? globalLocks() : (options.locks ?? undefined);
-        const openChannel = options.channel === undefined ? globalChannelFactory() : (options.channel ?? undefined);
-        if (!locks || !openChannel) {
-            this.startSingle();
-            return;
-        }
-        try {
-            this.channel = openChannel(this.lockName);
-        }
-        catch (error) {
-            this.onError(error);
-            this.startSingle();
-            return;
-        }
-        this.locks = locks;
-        this.channel.onmessage = (event) => this.receive(event?.data);
-        this.hello();
-        this.elect(locks);
     }
-    /** The role of this tab now. */
     get role() {
         return this.currentRole;
     }
-    /** True when this tab runs the sync: the leader, or a tab in the single mode. */
     get isLeader() {
         return this.currentRole === "leader" || this.currentRole === "single";
     }
-    /**
-     * The `HybridStorage` of the sync while this tab runs it, or else undefined. `getStatus()` of the
-     * coordinator gives the state of the sync in each tab. Write to the local copy, not to this
-     * storage: each tab then writes in the same way.
-     */
     get syncStorage() {
         return this.hybrid;
     }
-    /**
-     * This method starts to send the change batches to an observer: the batches of the local copy of
-     * this tab, and the batches of the other tabs. Each batch comes one time, with the origin of each
-     * change. In the leader, the batches of the sync have the origin `syncOrigin` of the
-     * `HybridStorage`. A batch of another tab comes after the local copy of this tab has it.
-     *
-     * @returns The function that stops the batches. A second use of it does nothing.
-     * @throws Error after `close()`
-     */
+    /** True while the `HybridStorage` of this tab runs the sync of the collection. */
+    get leads() {
+        return this.hybrid !== undefined;
+    }
+    /** True while the `HybridStorage` of this tab loads its queue, before the collection leads. */
+    get settingUp() {
+        return this.candidate !== undefined;
+    }
     observe(observer) {
         if (this.closed)
-            throw new Error("The TabCoordinator is closed");
+            throw new Error(`The ${this.group.kind} is closed`);
         return this.observers.add(observer);
     }
-    /**
-     * This method starts to send the role of this tab to a listener at each change.
-     *
-     * @returns The function that stops the roles. A second use of it does nothing.
-     * @throws Error after `close()`
-     */
     onRole(listener) {
         if (this.closed)
-            throw new Error("The TabCoordinator is closed");
+            throw new Error(`The ${this.group.kind} is closed`);
         return this.roleListeners.add(listener);
     }
-    /**
-     * The status of the sync (roadmap CLI-65), or undefined before the first status and after
-     * `close()`.
-     *
-     * - In the leader and in the single mode, it is the status of the `HybridStorage` of this tab.
-     * - In a follower, it is the last status that the leader sent. A new tab gets it in the answer to
-     *   its hello. After a change of the leader, a follower keeps the last status until the new
-     *   leader sends its status.
-     * - In a follower, `error.error` is a copy of the error of the leader: an `Error` with its `name`,
-     *   its `message` and its `code`. The copy has no `cause`.
-     */
     getStatus() {
         return this.status;
     }
-    /**
-     * This method starts to send the status of the sync to a listener at each change (roadmap
-     * CLI-65): in the leader, each status of its `HybridStorage`, and in a follower, each status that
-     * the leader sends. The listener gets each status one time. When the tab becomes the leader, the
-     * listener gets the status of its own `HybridStorage`.
-     *
-     * @returns The function that stops the statuses. A second use of it does nothing.
-     * @throws Error after `close()`
-     */
     onStatus(listener) {
         if (this.closed)
-            throw new Error("The TabCoordinator is closed");
+            throw new Error(`The ${this.group.kind} is closed`);
         return this.statusListeners.add(listener);
     }
-    /**
-     * This method closes the coordinator.
-     *
-     * - A follower stops its lock request, or its wait before a new try. It does not become the leader.
-     * - A tab that loads its queue to become the leader closes its `HybridStorage`, and releases the lock.
-     * - The leader closes its `HybridStorage`: it sends the queue, and the queue store keeps the
-     *   operations that the remote did not take. Then the leader releases the lock, and the next
-     *   tab becomes the leader.
-     * - The coordinator closes its channel. It does not close the local copy: the application owns it.
-     * - After it, the coordinator sends and copies nothing. A second `close()` gives the promise of
-     *   the first one.
-     */
-    close() {
-        if (!this.closing)
-            this.closing = this.shutDown();
-        return this.closing;
+    /** This method starts the collection on the channel: it says hello, and it asks for a snapshot. */
+    begin() {
+        if (this.settings.snapshot.want)
+            this.snapshot = { request: 0, chunks: [], received: 0 };
+        this.hello();
+        this.requestSnapshot();
     }
+    /** This method closes the storage of the collection. The group then releases the lock and closes the channel. */
     async shutDown() {
         this.closed = true;
         this.stopTap?.();
         this.stopTap = undefined;
-        this.abortRequest?.();
-        this.abortRequest = undefined;
         this.cancelRetry?.();
         this.cancelRetry = undefined;
+        this.cancelSnapshotWait?.();
+        this.cancelSnapshotWait = undefined;
+        this.snapshot = undefined;
+        this.held = [];
         this.stopStatus?.();
         this.stopStatus = undefined;
         this.setRole("closed");
@@ -283,79 +811,61 @@ export class TabCoordinator {
         this.hybrid = undefined;
         this.status = undefined;
         try {
-            // The leader holds the lock until its queue reached the remote or its queue store
             if (hybrid)
                 await hybrid.close();
         }
         catch (error) {
-            this.onError(error);
-        }
-        finally {
-            this.releaseLock?.();
-            this.releaseLock = undefined;
-            // The acknowledgements of the close of the HybridStorage went out before
-            try {
-                this.channel?.close();
-            }
-            catch {
-                // The channel is closed already
-            }
-            this.channel = undefined;
-            this.observers.clear();
-            this.roleListeners.clear();
-            this.statusListeners.clear();
-            this.captures.clear();
+            this.group.onError(error);
         }
     }
+    clearListeners() {
+        this.observers.clear();
+        this.roleListeners.clear();
+        this.statusListeners.clear();
+        this.captures.clear();
+    }
     //
-    // ═══ The election ═══
+    // ═══ The setup of the sync ═══
     //
-    /** This method asks for the lock. The tab becomes the leader when it gets the lock. */
-    elect(locks) {
-        const Controller = globalAbortController();
-        const controller = Controller ? new Controller() : undefined;
-        this.abortRequest = controller ? () => controller.abort() : undefined;
-        const held = new Promise((resolve) => (this.releaseLock = resolve));
-        let request;
-        try {
-            request = locks.request(this.lockName, controller ? { signal: controller.signal } : {}, async () => {
-                // A lock after close(): the tab releases it at once
-                if (this.closed)
-                    return;
-                this.abortRequest = undefined;
-                if (await this.takeLead()) {
-                    await held;
-                    return;
-                }
-                // A failed setup releases the lock: another tab tries, and this tab tries again after the backoff
-                this.retryLater();
-            });
-        }
-        catch (error) {
-            request = Promise.reject(error);
-        }
-        request.then(undefined, (error) => {
-            // The abort of close(), or a tab that leads already
-            if (this.closed || this.hybrid)
-                return;
-            // The lock manager refused the request: this tab runs the sync alone
-            this.onError(error);
-            this.stopChannel();
-            this.locks = undefined;
-            this.startSingle();
+    /**
+     * This method sets up the sync in a tab that holds the lock. After a failure, the collection tries
+     * again after its backoff. When no collection of the group can lead, the tab releases the lock.
+     */
+    startLead(lease, announce) {
+        void this.takeLead(lease, announce).then((led) => {
+            if (!led && !this.closed && this.group.lease === lease)
+                this.group.afterFailedSetup(this, lease);
         });
     }
+    /** This method stops the wait before the next try of the setup. */
+    stopRetry() {
+        this.cancelRetry?.();
+        this.cancelRetry = undefined;
+    }
+    /**
+     * This method runs after a failed setup in a tab that keeps the lock. No other tab leads the
+     * collection, so no snapshot comes: the batches that waited reach the local copy now.
+     */
+    retryInLeader() {
+        this.endSnapshot();
+        this.retryLater();
+    }
     /**
      * This method makes the `HybridStorage` of a tab that got the lock, and waits for the load of its
-     * queue. Then the tab becomes the leader. Until then, the tab is a follower: its own batches go to
-     * the other tabs and to its outbox, and the capture of the storage ignores the local copy.
+     * queue. Then the collection leads. Until then, it is a follower: its own batches go to the other
+     * tabs and to its outbox, and the capture of the storage ignores the local copy.
      *
-     * @returns False when the setup failed (the error went to `onError`), or after `close()`
+     * @param announce True: the collection tells the other tabs that it leads. Else the group tells it.
+     * @returns False when the setup failed (the error went to `onError`), after `close()`, or when the tab lost the lease
      */
-    async takeLead() {
+    async takeLead(lease, announce) {
+        if (this.hybrid)
+            return true;
         const candidate = this.makeCandidate();
-        if (!candidate)
+        if (!candidate) {
+            this.reportFailure(lease);
             return false;
+        }
         this.candidate = candidate;
         let failed = false;
         let failure;
@@ -371,28 +881,55 @@ export class TabCoordinator {
         if (this.candidate !== candidate)
             return false;
         this.candidate = undefined;
-        if (!failed) {
-            this.promote(candidate, "leader");
+        if (!failed && this.group.lease === lease) {
+            this.promote(candidate, "leader", announce);
             return true;
         }
-        this.onError(failure);
+        if (failed) {
+            this.setupFailed(failure);
+            this.reportFailure(lease);
+        }
         candidate.stop();
         try {
             await candidate.hybrid.close();
         }
         catch (error) {
-            this.onError(error);
+            this.group.onError(error);
         }
         return false;
     }
-    /** This method makes the `HybridStorage` of the single mode. The tab tries again after the backoff when it fails. */
+    /** This method makes the `HybridStorage` of the single mode. The collection tries again after the backoff when it fails. */
     startSingle() {
+        if (this.closed || this.hybrid)
+            return;
+        // No other tab sends a snapshot
+        this.endSnapshot();
         const candidate = this.makeCandidate();
         if (candidate)
-            this.promote(candidate, "single");
+            this.promote(candidate, "single", false);
         else
             this.retryLater();
     }
+    /** This method tries the setup again after the backoff of the collection (roadmap CLI-67). */
+    retryLater() {
+        if (this.closed)
+            return;
+        this.cancelRetry?.();
+        this.failures++;
+        const wait = backoffDelay(this.group.backoff, this.failures, this.group.random);
+        const cancel = this.group.clock.after(wait, () => {
+            this.cancelRetry = undefined;
+            if (this.closed || this.hybrid)
+                return;
+            if (this.group.alone)
+                this.startSingle();
+            else if (this.group.lease)
+                this.startLead(this.group.lease, true);
+        });
+        // The wait must not keep a Node process alive
+        cancel.unref?.();
+        this.cancelRetry = cancel;
+    }
     /**
      * This method makes the `HybridStorage` of the sync, with its observer. Its capture ignores the
      * local copy until the tab leads.
@@ -407,7 +944,7 @@ export class TabCoordinator {
             remote = this.makeRemote();
         }
         catch (error) {
-            this.onError(error);
+            this.setupFailed(error);
             return undefined;
         }
         const gate = { open: false };
@@ -421,24 +958,57 @@ export class TabCoordinator {
             });
         }
         catch (error) {
-            this.onError(error);
+            this.setupFailed(error);
             // The remote of a storage that did not start stays open otherwise
             Promise.resolve()
                 .then(() => remote.close())
-                .catch((closeError) => this.onError(closeError));
+                .catch((closeError) => this.group.onError(closeError));
             return undefined;
         }
         // The observer starts at once: the other tabs get the changes of the load and of the first sync
         const stop = hybrid.observe((batch) => this.onLeaderBatch(batch));
         return { hybrid, gate, stop };
     }
+    /** This method gives the error of a failed setup to `onError`, and keeps it for the status of the failure. */
+    setupFailed(error) {
+        this.setupError = error;
+        this.group.onError(error);
+    }
+    /**
+     * In a group, the tab that holds the lock tells the other tabs that the setup of the collection
+     * failed (roadmap CLI-65). Its status has the error, with the operation `load`, and the other
+     * values of the last status. Thus a follower does not keep the status of an old leader. A
+     * `TabCoordinator` releases the lock after a failed setup, and sends no status.
+     */
+    reportFailure(lease) {
+        if (this.group.legacy || this.closed || this.group.lease !== lease)
+            return;
+        const last = this.status;
+        const status = {
+            connected: false,
+            pendingChanges: last?.pendingChanges ?? 0,
+            syncing: false,
+            ...(last?.endpoint !== undefined && { endpoint: last.endpoint }),
+            ...(last?.lastSync !== undefined && { lastSync: last.lastSync }),
+            ...(last?.mode !== undefined && { mode: last.mode }),
+            error: { operation: "load", error: this.setupError },
+        };
+        this.status = status;
+        // The status is the status of this tab now: its number follows the last number
+        this.statusFrom = undefined;
+        this.statusSeq++;
+        this.postStatus();
+        this.statusListeners.emit(status);
+    }
     /**
-     * This method makes this tab the leader, or the single tab, with the storage of a candidate. The
-     * capture of the storage gets the batches of this tab that no leader acknowledged.
+     * This method makes this tab the leader of the collection, or the single tab, with the storage of
+     * a candidate. The capture of the storage gets the batches of this tab that no leader acknowledged.
      */
-    promote(candidate, role) {
+    promote(candidate, role, announce) {
         const { hybrid, gate, stop } = candidate;
         this.hybrid = hybrid;
+        this.cancelRetry?.();
+        this.cancelRetry = undefined;
         this.failures = 0;
         // The capture starts and the observer of the follower stops in one step: no change of the local copy goes between them
         gate.open = true;
@@ -447,34 +1017,17 @@ export class TabCoordinator {
         stopFollower?.();
         for (const batch of this.outbox.splice(0))
             this.capture(batch.changes);
+        // The copy of this tab is now the copy that the other tabs get: a snapshot that waits ends without entries
+        this.endSnapshot();
         this.setRole(role);
-        if (role === "leader")
-            this.post({ v: PROTOCOL, type: "leader", from: this.id });
+        if (announce)
+            this.post({ v: PROTOCOL, type: "leader", from: this.group.id });
         // The status of this tab is now the status of its storage, also when it has the values of the last status of the old leader. The followers get it.
         this.status = undefined;
         this.statusFrom = undefined;
         this.stopStatus = hybrid.onStatus((status) => this.onOwnStatus(hybrid, status));
         this.onOwnStatus(hybrid, hybrid.getStatus());
     }
-    /** This method asks for the lock again, or tries the single mode again, after the backoff (roadmap CLI-67). */
-    retryLater() {
-        if (this.closed)
-            return;
-        this.failures++;
-        const wait = backoffDelay(this.backoff, this.failures, this.random);
-        const cancel = this.clock.after(wait, () => {
-            this.cancelRetry = undefined;
-            if (this.closed)
-                return;
-            if (this.locks)
-                this.elect(this.locks);
-            else
-                this.startSingle();
-        });
-        // The wait must not keep a Node process alive
-        cancel.unref?.();
-        this.cancelRetry = cancel;
-    }
     /**
      * The local copy for the `HybridStorage` of the leader. Its `observe()` gives the changes of the
      * local copy and the batches of the other tabs, so the capture queues both. It gives the changes
@@ -546,7 +1099,7 @@ export class TabCoordinator {
     postStatus() {
         if (this.status === undefined)
             return;
-        this.post({ v: PROTOCOL, type: "status", from: this.id, seq: this.statusSeq, status: portableStatus(this.status) });
+        this.post({ v: PROTOCOL, type: "status", from: this.group.id, seq: this.statusSeq, status: portableStatus(this.status) });
     }
     /** A status of the leader. A tab that runs the sync keeps its own status. */
     onLeaderStatus(from, seq, status) {
@@ -589,69 +1142,71 @@ export class TabCoordinator {
      */
     share(changes, keep) {
         const seq = ++this.seq;
+        if (this.snapshot)
+            this.noteOwn(changes, seq);
         this.observers.emit(changes);
-        const sent = this.post({ v: PROTOCOL, type: "changes", from: this.id, seq, changes });
-        if (keep && (sent || !this.channel))
+        const sent = this.post({ v: PROTOCOL, type: "changes", from: this.group.id, seq, changes });
+        if (keep && (sent || !this.group.hasChannel))
             this.outbox.push({ seq, changes });
     }
     /** This method tells the leader the batches of this tab that no leader acknowledged. */
     hello() {
-        this.post({ v: PROTOCOL, type: "hello", from: this.id, seq: this.seq, pending: this.outbox });
+        this.post({ v: PROTOCOL, type: "hello", from: this.group.id, seq: this.seq, pending: this.outbox });
     }
-    /** @returns False when the message did not go out: no channel, or a value that the channel cannot clone */
+    /** @returns False when the message did not go out */
     post(message) {
-        const channel = this.channel;
-        if (!channel)
-            return false;
-        try {
-            channel.postMessage(message);
-            return true;
-        }
-        catch (error) {
-            this.onError(error);
-            return false;
-        }
-    }
-    stopChannel() {
-        const channel = this.channel;
-        this.channel = undefined;
-        if (!channel)
-            return;
-        channel.onmessage = null;
-        try {
-            channel.close();
-        }
-        catch {
-            // The channel is closed already
-        }
+        return this.group.post(this.name, message);
     }
     //
     // ═══ The batches of the other tabs ═══
     //
+    /** A message of another tab for this collection. */
     receive(data) {
-        if (this.closed || !isTabMessage(data) || data.from === this.id)
+        if (this.closed)
             return;
-        switch (data.type) {
+        const message = data;
+        switch (message.type) {
             case "changes":
-                this.onChanges(data.from, { seq: data.seq, changes: data.changes });
+                this.onChanges(message.from, { seq: message.seq, changes: message.changes });
                 break;
             case "hello":
-                this.onHello(data.from, data.seq, data.pending);
+                this.onHello(message.from, message.seq, message.pending);
                 break;
             case "leader":
-                // The new leader gets the batches that no leader acknowledged
-                if (this.currentRole === "follower")
-                    this.hello();
+                this.onLeader(message.from, true);
                 break;
             case "ack":
-                if (data.to === this.id)
-                    this.outbox = this.outbox.filter((batch) => batch.seq > data.seq);
+                if (message.to === this.group.id)
+                    this.outbox = this.outbox.filter((batch) => batch.seq > message.seq);
                 break;
             case "status":
-                this.onLeaderStatus(data.from, data.seq, data.status);
+                this.onLeaderStatus(message.from, message.seq, message.status);
+                break;
+            case "snapshot-request":
+                this.sendSnapshot(message.from, message.request);
+                break;
+            case "snapshot":
+                this.onSnapshot(message);
                 break;
         }
     }
+    /**
+     * A new leader. A follower tells it the batches that no leader acknowledged, and asks it for the
+     * snapshot that waits.
+     *
+     * @param own True when the tab `from` leads this collection. False for the message of a group for
+     *   all its collections: a collection that the tab `from` announced already ignores it.
+     */
+    onLeader(from, own) {
+        if (this.closed || this.currentRole !== "follower")
+            return;
+        if (own)
+            this.announcedBy = from;
+        else if (this.announcedBy === from)
+            return;
+        this.hello();
+        this.requestSnapshot();
+    }
     /**
      * A batch of another tab. The leader captures it when the tab said hello to it. Each tab copies
      * it one time.
@@ -682,27 +1237,40 @@ export class TabCoordinator {
             // A new tab gets the status now. The other tabs have its number already.
             this.postStatus();
         }
+        else if (!this.group.legacy && !this.hybrid && this.group.lease && this.status !== undefined && this.statusFrom === undefined) {
+            // The status of a failed setup in the tab that holds the lock (roadmap CLI-65)
+            this.postStatus();
+        }
         for (const batch of pending)
             this.copy(from, batch);
     }
     /**
      * This method copies a batch of another tab that this tab did not see: to the local copy of a
-     * tab, and then to the observers. The batches go in their order.
+     * tab, and then to the observers. The batches go in their order. While a snapshot waits, the
+     * batch waits for it.
      */
     copy(from, batch) {
         if (batch.seq <= (this.seen.get(from) ?? 0))
             return;
         this.seen.set(from, batch.seq);
+        if (this.snapshot)
+            this.held.push({ from, batch });
+        else
+            this.apply(from, batch);
+    }
+    /** This method writes a batch of another tab to the local copy, and then gives it to the observers. */
+    apply(from, batch) {
         this.incoming = this.incoming
             .then(async () => {
             if (this.closed)
                 return;
             if (!this.shared)
                 await this.write(batch.changes);
+            this.applied.set(from, Math.max(this.applied.get(from) ?? 0, batch.seq));
             if (!this.closed)
                 this.observers.emit(batch.changes);
         })
-            .catch((error) => this.onError(error));
+            .catch((error) => this.group.onError(error));
     }
     /**
      * This method writes a batch of another tab to the local copy of this tab, with the tag of the
@@ -736,8 +1304,190 @@ export class TabCoordinator {
         const hybrid = this.hybrid;
         if (!hybrid)
             return;
-        hybrid.whenQueued().then(() => void this.post({ v: PROTOCOL, type: "ack", from: this.id, to, seq }), (error) => this.onError(error));
+        hybrid.whenQueued().then(() => void this.post({ v: PROTOCOL, type: "ack", from: this.group.id, to, seq }), (error) => this.group.onError(error));
+    }
+    //
+    // ═══ The snapshot for a new tab (roadmap CLI-66) ═══
+    //
+    /** This method asks the leader for a snapshot, while the snapshot waits. A new request replaces the last one. */
+    requestSnapshot() {
+        if (!this.snapshot)
+            return;
+        const request = ++this.requests;
+        this.snapshot = { request, chunks: [], received: 0 };
+        this.post({ v: PROTOCOL, type: "snapshot-request", from: this.group.id, request });
+        this.waitSnapshot();
+    }
+    /**
+     * This method starts the wait for the next chunk again. At its end, the tab continues without the
+     * snapshot. In the tab that holds the lock, the wait renews itself while the collection loads its
+     * queue, at most `SNAPSHOT_RENEWALS` times: a load that hangs does not hold the batches forever.
+     *
+     * @param renewals The number of the renewals of the wait in the tab that holds the lock
+     */
+    waitSnapshot(renewals = 0) {
+        this.cancelSnapshotWait?.();
+        const cancel = this.group.clock.after(this.settings.snapshot.timeout, () => {
+            this.cancelSnapshotWait = undefined;
+            if (this.closed || !this.snapshot)
+                return;
+            if (this.group.lease) {
+                // This tab holds the lock and loads its queue: the snapshot ends when the collection leads
+                if (renewals < SNAPSHOT_RENEWALS) {
+                    this.waitSnapshot(renewals + 1);
+                    return;
+                }
+                this.group.onError(new Error(`The collection ${JSON.stringify(this.name)} did not lead in time: it continues without the snapshot`));
+            }
+            else {
+                this.group.onError(new Error(`No leader sent the snapshot of the collection ${JSON.stringify(this.name)} in time`));
+            }
+            this.endSnapshot();
+        });
+        // The wait must not keep a Node process alive
+        cancel.unref?.();
+        this.cancelSnapshotWait = cancel;
+    }
+    /**
+     * The leader sends the entries of its local copy to the tab `to`, in chunks. The numbers come
+     * before the read of the entries: thus the entries hold each batch up to the numbers. A batch
+     * after them can be in the entries too, and the new tab writes it again with the same values.
+     */
+    sendSnapshot(to, request) {
+        if (!this.hybrid || this.currentRole !== "leader")
+            return;
+        const chunk = this.settings.snapshot.chunk;
+        // The batches of the other tabs that this tab got before the request reach the local copy first
+        this.incoming = this.incoming
+            .then(async () => {
+            if (this.closed || this.currentRole !== "leader")
+                return;
+            const seqs = [[this.group.id, this.seq], ...this.applied];
+            const entries = await this.local.getEntries();
+            if (this.closed)
+                return;
+            const parts = Math.max(1, Math.ceil(entries.length / chunk));
+            for (let part = 0; part < parts; part++) {
+                const slice = entries.slice(part * chunk, (part + 1) * chunk);
+                if (!this.post({ v: PROTOCOL, type: "snapshot", from: this.group.id, to, request, part, parts, seqs, entries: slice }))
+                    return;
+            }
+        })
+            .catch((error) => this.group.onError(error));
+    }
+    /** A chunk of a snapshot. The tab keeps the chunks of its last request from one leader, and applies them after the last one. */
+    onSnapshot(message) {
+        const pending = this.snapshot;
+        if (!pending || message.to !== this.group.id || message.request !== pending.request)
+            return;
+        if (pending.from === undefined) {
+            pending.from = message.from;
+            pending.parts = message.parts;
+            pending.seqs = message.seqs;
+        }
+        else if (message.from !== pending.from || message.parts !== pending.parts) {
+            return;
+        }
+        if (pending.chunks[message.part] !== undefined)
+            return;
+        pending.chunks[message.part] = message.entries;
+        pending.received++;
+        if (pending.received < message.parts)
+            this.waitSnapshot();
+        else
+            this.applySnapshot(pending);
+    }
+    /**
+     * This method writes the entries of a snapshot to the local copy, and then the batches that
+     * waited. It skips the batches that the snapshot holds, and the entries of the ids that this tab
+     * wrote after the snapshot.
+     */
+    applySnapshot(pending) {
+        this.snapshot = undefined;
+        this.cancelSnapshotWait?.();
+        this.cancelSnapshotWait = undefined;
+        const seqs = new Map(pending.seqs ?? []);
+        const mine = seqs.get(this.group.id) ?? 0;
+        const entries = [];
+        if (this.ownClear <= mine) {
+            for (const chunk of pending.chunks) {
+                for (const [id, value] of chunk ?? [])
+                    if ((this.ownWrites.get(id) ?? 0) <= mine)
+                        entries.push([id, value]);
+            }
+        }
+        this.ownWrites.clear();
+        this.ownClear = 0;
+        seqs.delete(this.group.id);
+        // A batch that the snapshot holds and that comes later is not new
+        for (const [from, seq] of seqs)
+            if (seq > (this.seen.get(from) ?? 0))
+                this.seen.set(from, seq);
+        const origin = this.hybridOptions.syncOrigin ?? "sync";
+        this.incoming = this.incoming
+            .then(async () => {
+            if (this.closed)
+                return;
+            if (entries.length > 0)
+                await this.local.setBatch(entries, this.writeOptions);
+            for (const [from, seq] of seqs)
+                this.applied.set(from, Math.max(this.applied.get(from) ?? 0, seq));
+            if (!this.closed && entries.length > 0)
+                this.observers.emit(entries.map(([id, value]) => ({ type: "set", id, value, origin })));
+        })
+            .catch((error) => this.group.onError(error));
+        for (const { from, batch } of this.held.splice(0))
+            if (batch.seq > (seqs.get(from) ?? 0))
+                this.apply(from, batch);
+    }
+    /** This method ends a snapshot that waits, without entries: the batches that waited reach the local copy. */
+    endSnapshot() {
+        if (!this.snapshot)
+            return;
+        this.snapshot = undefined;
+        this.cancelSnapshotWait?.();
+        this.cancelSnapshotWait = undefined;
+        this.ownWrites.clear();
+        this.ownClear = 0;
+        for (const { from, batch } of this.held.splice(0))
+            this.apply(from, batch);
+    }
+    /** This method records the ids of an own batch while the snapshot waits. */
+    noteOwn(changes, seq) {
+        for (const change of changes) {
+            if (change.type === "clear")
+                this.ownClear = seq;
+            else
+                this.ownWrites.set(change.id, seq);
+        }
+    }
+}
+/**
+ * The settings of the options of a collection.
+ *
+ * @throws TypeError for a local copy without `observe()`, an unknown `copy`, no `remote`, or a snapshot of a shared copy
+ * @throws RangeError for a `snapshot.chunk` that is not a whole number of 1 or more
+ */
+function collectionSettings(options, owner) {
+    if (typeof options?.local?.observe !== "function")
+        throw new TypeError(`${owner} needs a local copy with observe()`);
+    if (options.copy !== "shared" && options.copy !== "tab") {
+        throw new TypeError(`Unknown copy ${JSON.stringify(options.copy)}: use shared or tab`);
     }
+    if (typeof options.remote !== "function")
+        throw new TypeError(`${owner} needs the function remote`);
+    const snapshot = options.snapshot ?? false;
+    const want = snapshot !== false;
+    if (want && options.copy !== "tab")
+        throw new TypeError('The option snapshot needs copy: "tab": the tabs of a shared copy have the entries');
+    const details = typeof snapshot === "object" && snapshot !== null ? snapshot : {};
+    const chunk = details.chunk ?? SNAPSHOT_CHUNK;
+    if (!(Number.isSafeInteger(chunk) && chunk >= 1))
+        throw new RangeError(`snapshot.chunk must be a whole number of 1 or more, not ${chunk}`);
+    const timeout = optionalMs(details.timeout, "snapshot.timeout") ?? SNAPSHOT_TIMEOUT;
+    if (!(timeout > 0))
+        throw new RangeError(`snapshot.timeout must be a time of more than zero, not ${timeout} ms`);
+    return { snapshot: { want, chunk, timeout } };
 }
 /**
  * The backoff of the option `retry`.
@@ -891,6 +1641,10 @@ function isBatch(value) {
         return type === "delete" || (type === "set" && "value" in change);
     });
 }
+/** True when a value is a list of pairs whose first value is a string, and whose second value passes `second`. */
+function isPairs(value, second) {
+    return Array.isArray(value) && value.every((pair) => Array.isArray(pair) && pair.length === 2 && typeof pair[0] === "string" && second(pair[1]));
+}
 /**
  * True when a value is a message of the channel, of this version. A message of a type that this
  * release does not know is not a message: a tab of an older release ignores a new type.
@@ -901,6 +1655,8 @@ function isTabMessage(value) {
     const message = value;
     if (message.v !== PROTOCOL || typeof message.from !== "string")
         return false;
+    if (message.collection !== undefined && typeof message.collection !== "string")
+        return false;
     switch (message.type) {
         case "changes":
             return isSeq(message.seq) && isBatch(message.changes);
@@ -919,6 +1675,17 @@ function isTabMessage(value) {
             return typeof message.to === "string" && isSeq(message.seq);
         case "status":
             return isSeq(message.seq) && isPortableStatus(message.status);
+        case "snapshot-request":
+            return isSeq(message.request);
+        case "snapshot":
+            return (typeof message.to === "string" &&
+                isSeq(message.request) &&
+                isSeq(message.parts) &&
+                message.parts >= 1 &&
+                isSeq(message.part) &&
+                message.part < message.parts &&
+                isPairs(message.seqs, isSeq) &&
+                isPairs(message.entries, () => true));
         default:
             return false;
     }