@daasboard/doc 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,47 @@
1
+ import { LoroPageDoc, type LoroPageDocOptions } from "../LoroPageDoc.js";
2
+ import type { PresenceOptions, RoomPresence } from "../presence/RoomPresence.js";
3
+ import { type SnapshotFetch, type SnapshotFetchOptions } from "./snapshot.js";
4
+ import { type RoomToken } from "./token.js";
5
+ import { WsTransport, type TransportEvents, type TransportStats, type TransportStatus } from "./WsTransport.js";
6
+ export type ConnectRoomErrorCode = "unreachable" | "replay-stalled" | "partial-log" | "claim-conflict" | "token-refused" | "forbidden" | "token-expired" | "invalid-room" | "aborted" | "transport-failed" | "token-provider-failed";
7
+ export declare class ConnectRoomError extends Error {
8
+ readonly code: ConnectRoomErrorCode;
9
+ readonly closeCode?: number | undefined;
10
+ readonly name = "ConnectRoomError";
11
+ constructor(code: ConnectRoomErrorCode, message: string, closeCode?: number | undefined, options?: ErrorOptions);
12
+ }
13
+ export type RoomConnectionStatus = TransportStatus | "fetching-snapshot" | "waiting-for-editor";
14
+ export interface RoomConnectionState {
15
+ readonly status: RoomConnectionStatus;
16
+ readonly role: "read" | "write" | null;
17
+ readonly stats: Readonly<TransportStats> | null;
18
+ readonly error: ConnectRoomError | null;
19
+ }
20
+ export interface ConnectRoomOptions {
21
+ url: string;
22
+ room: string;
23
+ token?: RoomToken;
24
+ presence?: PresenceOptions;
25
+ page?: Pick<LoroPageDocOptions, "onFatal" | "now">;
26
+ stallTimeoutMs?: number;
27
+ signal?: AbortSignal;
28
+ events?: TransportEvents;
29
+ onSnapshotRetry?: SnapshotFetchOptions["onRetry"];
30
+ onSnapshot?(result: SnapshotFetch): void;
31
+ onClaimConflict?(): void;
32
+ onState?(state: RoomConnectionState): void;
33
+ onFailure?(error: ConnectRoomError): void;
34
+ }
35
+ export interface RoomConnection {
36
+ readonly page: LoroPageDoc;
37
+ readonly created: boolean;
38
+ readonly role: "read" | "write" | null;
39
+ readonly status: RoomConnectionStatus;
40
+ readonly stats: Readonly<TransportStats>;
41
+ readonly error: ConnectRoomError | null;
42
+ readonly presence: RoomPresence;
43
+ readonly transport: WsTransport;
44
+ subscribe(listener: (state: RoomConnectionState) => void): () => void;
45
+ dispose(): void;
46
+ }
47
+ export declare function connectRoom(options: ConnectRoomOptions): Promise<RoomConnection>;
@@ -0,0 +1,303 @@
1
+ import { LoroPageDoc } from "../LoroPageDoc.js";
2
+ import { fetchSnapshot } from "./snapshot.js";
3
+ import { resolveRoomToken } from "./token.js";
4
+ import { WsTransport } from "./WsTransport.js";
5
+ export class ConnectRoomError extends Error {
6
+ code;
7
+ closeCode;
8
+ name = "ConnectRoomError";
9
+ constructor(code, message, closeCode, options) {
10
+ super(message, options);
11
+ this.code = code;
12
+ this.closeCode = closeCode;
13
+ }
14
+ }
15
+ function notify(callback, ...args) {
16
+ try {
17
+ callback?.(...args);
18
+ }
19
+ catch (cause) {
20
+ try {
21
+ console.error("connectRoom host callback failed", cause);
22
+ }
23
+ catch { }
24
+ }
25
+ }
26
+ function transportError(failure) {
27
+ if (failure.code === "token-invalid")
28
+ return new ConnectRoomError("token-refused", failure.message);
29
+ const codes = {
30
+ 4400: "invalid-room", 4401: "token-refused", 4403: "forbidden", 4408: "token-expired",
31
+ };
32
+ return new ConnectRoomError(failure.closeCode === undefined ? "transport-failed" : (codes[failure.closeCode] ?? "transport-failed"), failure.message, failure.closeCode);
33
+ }
34
+ export async function connectRoom(options) {
35
+ const url = new URL(options.url);
36
+ if (!["http:", "https:", "ws:", "wss:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
37
+ throw new TypeError("expected an http(s) or ws(s) relay base URL without credentials, query or fragment");
38
+ }
39
+ const socketUrl = options.url.replace(/^http(s?):/i, "ws$1:");
40
+ const timeoutMs = options.stallTimeoutMs ?? 15_000;
41
+ if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
42
+ throw new RangeError("stallTimeoutMs must be finite and positive");
43
+ const events = options.events;
44
+ const listeners = new Set();
45
+ let transport;
46
+ let status = "fetching-snapshot";
47
+ let error = null;
48
+ let waitingForEditor = false;
49
+ let firstLive = false;
50
+ let role = null;
51
+ let pendingStats;
52
+ let published;
53
+ let disposed = false;
54
+ let timer;
55
+ let sawFrame = false;
56
+ let wake;
57
+ const fetchAbort = new AbortController();
58
+ let rejectFailure;
59
+ const failure = new Promise((_, reject) => { rejectFailure = reject; });
60
+ void failure.catch(() => { });
61
+ const token = options.token;
62
+ let providerFailed = false;
63
+ let providerPending = false;
64
+ let providerRequest = 0;
65
+ let providerError;
66
+ const roomToken = typeof token === "function" ? async (room) => {
67
+ const request = ++providerRequest;
68
+ providerPending = true;
69
+ try {
70
+ const credential = await Promise.race([resolveRoomToken(token, room), failure]);
71
+ if (request === providerRequest) {
72
+ providerFailed = false;
73
+ providerError = undefined;
74
+ }
75
+ return credential;
76
+ }
77
+ catch (cause) {
78
+ if (request === providerRequest) {
79
+ providerFailed = true;
80
+ providerError = cause;
81
+ }
82
+ throw cause;
83
+ }
84
+ finally {
85
+ if (request === providerRequest)
86
+ providerPending = false;
87
+ }
88
+ } : token;
89
+ const state = () => ({
90
+ status, role, stats: transport ? { ...transport.stats } : null, error,
91
+ });
92
+ const emit = () => {
93
+ const current = state();
94
+ published = { status, role, error };
95
+ notify(options.onState, current);
96
+ for (const listener of listeners)
97
+ notify(listener, current);
98
+ };
99
+ const publish = (statsOnly = false) => {
100
+ wake?.();
101
+ wake = undefined;
102
+ const unchanged = published?.status === status && published.role === role && published.error === error;
103
+ if (statsOnly && status === "catching-up" && unchanged) {
104
+ if (!pendingStats) {
105
+ const batch = pendingStats = {};
106
+ queueMicrotask(() => {
107
+ if (pendingStats !== batch)
108
+ return;
109
+ pendingStats = undefined;
110
+ if (!disposed)
111
+ emit();
112
+ });
113
+ }
114
+ return;
115
+ }
116
+ pendingStats = undefined;
117
+ emit();
118
+ };
119
+ const clearTimer = () => { clearTimeout(timer); timer = undefined; };
120
+ const detachAbort = () => options.signal?.removeEventListener("abort", aborted);
121
+ const fail = (reason) => {
122
+ if (error || disposed)
123
+ return;
124
+ error = reason;
125
+ clearTimer();
126
+ detachAbort();
127
+ fetchAbort.abort(reason);
128
+ rejectFailure(reason);
129
+ transport?.close();
130
+ status = "failed";
131
+ publish();
132
+ notify(options.onFailure, reason);
133
+ };
134
+ const aborted = () => fail(new ConnectRoomError("aborted", "room connection aborted by the caller", undefined, { cause: options.signal?.reason }));
135
+ const arm = () => {
136
+ clearTimer();
137
+ if (error || disposed || firstLive)
138
+ return;
139
+ timer = setTimeout(() => {
140
+ if (providerFailed || providerPending) {
141
+ fail(new ConnectRoomError("token-provider-failed", "the room token provider failed or did not finish before the connect deadline", undefined, { cause: providerError }));
142
+ return;
143
+ }
144
+ const seconds = (timeoutMs / 1000).toFixed(0);
145
+ fail(new ConnectRoomError(sawFrame ? "replay-stalled" : "unreachable", sawFrame
146
+ ? `server ${options.url}: ${transport?.stats.received ?? 0} entries so far, but nothing arrived for ${seconds} s; the replay stalled or the connection is half-open`
147
+ : `server ${options.url} unreachable for ${seconds} s (${transport?.stats.reconnects ?? 0} reconnect attempts)`));
148
+ }, timeoutMs);
149
+ };
150
+ const update = (statsOnly = false) => {
151
+ if (error) {
152
+ status = "failed";
153
+ clearTimer();
154
+ }
155
+ else if (transport) {
156
+ status = waitingForEditor && transport.currentStatus === "live" ? "waiting-for-editor" : transport.currentStatus;
157
+ if (transport.currentStatus === "live")
158
+ firstLive = true;
159
+ if (firstLive)
160
+ clearTimer();
161
+ else {
162
+ if (transport.currentStatus === "closed")
163
+ clearTimer();
164
+ else if (timer === undefined && !disposed) {
165
+ sawFrame = false;
166
+ arm();
167
+ }
168
+ }
169
+ }
170
+ publish(statsOnly);
171
+ };
172
+ const nextChange = () => Promise.race([new Promise((resolve) => { wake = resolve; }), failure]);
173
+ if (options.signal?.aborted)
174
+ aborted();
175
+ else
176
+ options.signal?.addEventListener("abort", aborted, { once: true });
177
+ try {
178
+ if (error)
179
+ throw error;
180
+ attempts: for (let attempt = 0; attempt < 2; attempt++) {
181
+ transport = undefined;
182
+ waitingForEditor = false;
183
+ firstLive = false;
184
+ sawFrame = false;
185
+ status = "fetching-snapshot";
186
+ publish();
187
+ if (error)
188
+ throw error;
189
+ const snapshot = fetchSnapshot(options.url, options.room, {
190
+ ...(roomToken === undefined ? {} : { token: roomToken }),
191
+ signal: fetchAbort.signal,
192
+ inactivityMs: timeoutMs,
193
+ onRetry: (retry) => notify(options.onSnapshotRetry, retry),
194
+ });
195
+ void snapshot.then((boot) => { if (error)
196
+ boot.snapshot?.doc.free(); }, () => { });
197
+ const boot = await Promise.race([snapshot, failure]);
198
+ if (error)
199
+ throw error;
200
+ let transferred = false;
201
+ const page = LoroPageDoc.empty({
202
+ ...(options.page?.now ? { now: options.page.now } : {}),
203
+ ...(options.page?.onFatal ? { onFatal: (cause) => notify(options.page?.onFatal, cause) } : {}),
204
+ });
205
+ try {
206
+ notify(options.onSnapshot, boot);
207
+ if (error)
208
+ throw error;
209
+ transport = new WsTransport(page, socketUrl, options.room, {
210
+ onStatus: (s) => { update(); notify(events?.onStatus, s); },
211
+ onStats: (stats) => { update(true); notify(events?.onStats, stats); },
212
+ onGrant: (grant) => { role = grant.role; update(); notify(events?.onGrant, grant); },
213
+ onFrame: () => { sawFrame = true; arm(); notify(events?.onFrame); },
214
+ onFailure: (detail) => { fail(transportError(detail)); notify(events?.onFailure, detail); },
215
+ onError: (message) => notify(events?.onError, message),
216
+ onBootstrap: (outcome) => notify(events?.onBootstrap, outcome),
217
+ onLogReset: (reset) => notify(events?.onLogReset, reset),
218
+ }, {
219
+ ...(roomToken === undefined ? {} : { token: roomToken }),
220
+ ...(options.presence === undefined ? {} : { presence: options.presence }),
221
+ ...(boot.snapshot ? { bootstrap: boot.snapshot } : {}),
222
+ });
223
+ transferred = true;
224
+ if (roomToken === undefined)
225
+ role = "write";
226
+ }
227
+ finally {
228
+ if (!transferred)
229
+ boot.snapshot?.doc.free();
230
+ }
231
+ update();
232
+ await Promise.race([transport.ready(), failure]);
233
+ let created = false;
234
+ for (;;) {
235
+ if (error)
236
+ throw error;
237
+ if (transport.currentStatus !== "live") {
238
+ await Promise.race([transport.ready(), failure]);
239
+ continue;
240
+ }
241
+ if (page.isInitialized())
242
+ break;
243
+ if (transport.stats.received > 0) {
244
+ throw new ConnectRoomError("partial-log", `room log is partial: ${transport.stats.received} entries replayed but none holds the page's init; refusing to create a second page`);
245
+ }
246
+ if (transport.stats.role !== "write") {
247
+ waitingForEditor = true;
248
+ update();
249
+ if (error)
250
+ throw error;
251
+ await nextChange();
252
+ continue;
253
+ }
254
+ waitingForEditor = false;
255
+ update();
256
+ if (error)
257
+ throw error;
258
+ const claim = await Promise.race([transport.claimEmpty(() => page.init()), failure]);
259
+ if (claim === "created") {
260
+ created = true;
261
+ break;
262
+ }
263
+ transport.close();
264
+ if (attempt === 1)
265
+ throw new ConnectRoomError("claim-conflict", "another client created the room first, twice in a row; reconnect to try again");
266
+ notify(options.onClaimConflict);
267
+ continue attempts;
268
+ }
269
+ waitingForEditor = false;
270
+ update();
271
+ if (error)
272
+ throw error;
273
+ detachAbort();
274
+ const connected = transport;
275
+ return {
276
+ page, created,
277
+ get role() { return role; },
278
+ get status() { return status; },
279
+ get stats() { return { ...connected.stats }; },
280
+ get error() { return error; },
281
+ presence: connected.presence,
282
+ transport: connected,
283
+ subscribe(listener) { listeners.add(listener); return () => { listeners.delete(listener); }; },
284
+ dispose() {
285
+ if (disposed)
286
+ return;
287
+ disposed = true;
288
+ pendingStats = undefined;
289
+ clearTimer();
290
+ detachAbort();
291
+ connected.close();
292
+ listeners.clear();
293
+ },
294
+ };
295
+ }
296
+ throw new ConnectRoomError("claim-conflict", "could not join the winning room claim");
297
+ }
298
+ catch (cause) {
299
+ const reason = error ?? (cause instanceof ConnectRoomError ? cause : new ConnectRoomError("transport-failed", cause instanceof Error ? cause.message : String(cause), undefined, { cause }));
300
+ fail(reason);
301
+ throw reason;
302
+ }
303
+ }
@@ -0,0 +1,4 @@
1
+ export declare function roomBytes(room: string): Uint8Array;
2
+ export declare function extendPrefixHash(room: Uint8Array, seq: number, previous: Uint8Array, payload: Uint8Array): Uint8Array;
3
+ export declare function emptyPrefixHash(room: Uint8Array): Uint8Array;
4
+ export declare function sameBytes(a: Uint8Array, b: Uint8Array): boolean;
@@ -0,0 +1,27 @@
1
+ import { sha256 } from "@noble/hashes/sha2.js";
2
+ const DOMAIN = new TextEncoder().encode("room-server/log-prefix/v1\0");
3
+ function u64(n) {
4
+ const b = new Uint8Array(8);
5
+ new DataView(b.buffer).setBigUint64(0, BigInt(n));
6
+ return b;
7
+ }
8
+ export function roomBytes(room) {
9
+ return new TextEncoder().encode(room);
10
+ }
11
+ export function extendPrefixHash(room, seq, previous, payload) {
12
+ return sha256.create()
13
+ .update(DOMAIN)
14
+ .update(u64(room.byteLength))
15
+ .update(room)
16
+ .update(u64(seq))
17
+ .update(u64(payload.byteLength))
18
+ .update(previous)
19
+ .update(payload)
20
+ .digest();
21
+ }
22
+ export function emptyPrefixHash(room) {
23
+ return extendPrefixHash(room, 0, new Uint8Array(32), new Uint8Array(0));
24
+ }
25
+ export function sameBytes(a, b) {
26
+ return a.byteLength === b.byteLength && a.every((x, i) => x === b[i]);
27
+ }
@@ -0,0 +1,9 @@
1
+ import { type LoroDoc } from "loro-crdt";
2
+ export interface SliceOptions {
3
+ treeName?: string;
4
+ safeEnds?: ReadonlyMap<string, readonly number[]>;
5
+ from?: ReadonlyMap<string, number>;
6
+ until?: ReadonlyMap<string, number>;
7
+ firstSliceBytes?: number;
8
+ }
9
+ export declare function exportInSlices(doc: LoroDoc, maxBytes: number, { treeName, safeEnds, from, until, firstSliceBytes }?: SliceOptions): Uint8Array[];
@@ -0,0 +1,151 @@
1
+ import { VersionVector } from "loro-crdt";
2
+ function safeStarts(doc, peer, start, end) {
3
+ const json = doc.exportJsonUpdates(new VersionVector(new Map([[peer, start]])), new VersionVector(new Map([[peer, end]])), false);
4
+ const starts = [];
5
+ let groupStart = -1;
6
+ const written = new Set();
7
+ for (const change of json.changes) {
8
+ for (const op of change.ops) {
9
+ const content = op.content;
10
+ const cid = /^cid:(\d+)@(\d+):/.exec(op.container);
11
+ const key = typeof content.key === "string" ? `${op.container}\0${content.key}` : null;
12
+ const opens = (content.type === "create" && op.container.endsWith(":Tree")) || (typeof content.value === "string" && content.value.startsWith("\u{1F99C}:cid:"));
13
+ const continues = groupStart >= 0 && cid !== null && cid[2] === peer && Number(cid[1]) >= groupStart && (key === null || !written.has(key));
14
+ if (continues) {
15
+ if (key)
16
+ written.add(key);
17
+ continue;
18
+ }
19
+ if (op.counter > start && content.type !== "mark_end")
20
+ starts.push(op.counter);
21
+ written.clear();
22
+ groupStart = opens ? op.counter : -1;
23
+ if (opens && key)
24
+ written.add(key);
25
+ }
26
+ }
27
+ return starts;
28
+ }
29
+ export function exportInSlices(doc, maxBytes, { treeName = "tree", safeEnds, from, until, firstSliceBytes } = {}) {
30
+ const out = [];
31
+ const ends = doc.version().toJSON();
32
+ if (ends.size === 0)
33
+ return out;
34
+ const firstLimit = firstSliceBytes === undefined ? maxBytes : Math.min(maxBytes, firstSliceBytes);
35
+ const limitNow = () => (out.length === 0 ? firstLimit : maxBytes);
36
+ const cuts = new Map();
37
+ for (const node of doc.getTree(treeName).nodes()) {
38
+ const at = node.id.indexOf("@");
39
+ if (at < 0)
40
+ continue;
41
+ const peer = node.id.slice(at + 1);
42
+ const counter = Number(node.id.slice(0, at));
43
+ let set = cuts.get(peer);
44
+ if (!set)
45
+ cuts.set(peer, (set = new Set()));
46
+ set.add(counter);
47
+ }
48
+ const changes = doc.getAllChanges();
49
+ const lamportOf = (peer, counter) => {
50
+ const list = changes.get(peer) ?? [];
51
+ let lo = 0;
52
+ let hi = list.length - 1;
53
+ while (lo <= hi) {
54
+ const mid = (lo + hi) >> 1;
55
+ const c = list[mid];
56
+ if (counter < c.counter)
57
+ hi = mid - 1;
58
+ else if (counter >= c.counter + c.length)
59
+ lo = mid + 1;
60
+ else
61
+ return c.lamport + (counter - c.counter);
62
+ }
63
+ return 0;
64
+ };
65
+ const segments = [];
66
+ for (const [peer, version] of ends) {
67
+ let start = from?.get(peer) ?? 0;
68
+ const end = Math.min(version, until?.get(peer) ?? version);
69
+ if (start >= end)
70
+ continue;
71
+ const points = [...(cuts.get(peer) ?? [])].filter((c) => c > start && c < end).sort((a, b) => a - b);
72
+ for (const p of [...points, end]) {
73
+ if (p > start)
74
+ segments.push({ peer, counter: start, len: p - start, lamport: lamportOf(peer, start) });
75
+ start = p;
76
+ }
77
+ }
78
+ segments.sort((a, b) => a.lamport - b.lamport || (a.peer < b.peer ? -1 : a.peer > b.peer ? 1 : 0) || a.counter - b.counter);
79
+ let density = 32;
80
+ const exportSegments = (segs) => {
81
+ const spans = new Map();
82
+ for (const s of segs) {
83
+ const span = spans.get(s.peer);
84
+ if (!span)
85
+ spans.set(s.peer, { counter: s.counter, end: s.counter + s.len });
86
+ else {
87
+ span.counter = Math.min(span.counter, s.counter);
88
+ span.end = Math.max(span.end, s.counter + s.len);
89
+ }
90
+ }
91
+ return doc.export({ mode: "updates-in-range", spans: [...spans].map(([peer, s]) => ({ id: { peer, counter: s.counter }, len: s.end - s.counter })) });
92
+ };
93
+ const cutInside = (s) => {
94
+ const end = s.counter + s.len;
95
+ const starts = new Set(safeStarts(doc, s.peer, s.counter, end));
96
+ for (const c of safeEnds?.get(s.peer) ?? [])
97
+ if (c > s.counter && c < end)
98
+ starts.add(c);
99
+ const parts = [];
100
+ let from = s.counter;
101
+ for (const to of [...[...starts].sort((a, b) => a - b), end]) {
102
+ if (to > from)
103
+ parts.push({ peer: s.peer, counter: from, len: to - from, lamport: lamportOf(s.peer, from), atomic: true });
104
+ from = to;
105
+ }
106
+ return parts;
107
+ };
108
+ const emit = (segs) => {
109
+ const ops = segs.reduce((n, s) => n + s.len, 0);
110
+ const bytes = exportSegments(segs);
111
+ density = Math.max(1, bytes.byteLength / ops);
112
+ if (bytes.byteLength <= limitNow()) {
113
+ out.push(bytes);
114
+ return;
115
+ }
116
+ if (segs.length === 1) {
117
+ if (bytes.byteLength <= maxBytes) {
118
+ out.push(bytes);
119
+ return;
120
+ }
121
+ const parts = segs[0].atomic ? [] : cutInside(segs[0]);
122
+ if (parts.length < 2) {
123
+ out.push(bytes);
124
+ return;
125
+ }
126
+ segs = parts;
127
+ }
128
+ const half = Math.max(1, Math.floor(ops / 2));
129
+ let n = 0;
130
+ let cut = 0;
131
+ while (cut < segs.length - 1 && n + segs[cut].len <= half)
132
+ n += segs[cut++].len;
133
+ if (cut === 0)
134
+ cut = 1;
135
+ emit(segs.slice(0, cut));
136
+ emit(segs.slice(cut));
137
+ };
138
+ let i = 0;
139
+ while (i < segments.length) {
140
+ const aim = limitNow() / 2;
141
+ let ops = segments[i].len;
142
+ let j = i + 1;
143
+ while (j < segments.length && (ops + segments[j].len) * density <= aim) {
144
+ ops += segments[j].len;
145
+ j++;
146
+ }
147
+ emit(segments.slice(i, j));
148
+ i = j;
149
+ }
150
+ return out;
151
+ }
@@ -0,0 +1,46 @@
1
+ import { LoroDoc } from "loro-crdt";
2
+ import { type RoomToken } from "./token.js";
3
+ export interface StagedSnapshot {
4
+ readonly doc: LoroDoc;
5
+ readonly epoch: bigint;
6
+ readonly seq: number;
7
+ readonly prefix: Uint8Array;
8
+ readonly frontier: string;
9
+ readonly location: string | null;
10
+ readonly size: number;
11
+ }
12
+ export interface SnapshotFetch {
13
+ snapshot: StagedSnapshot | null;
14
+ reason: string | null;
15
+ retryable: boolean;
16
+ retryAfterMs: number;
17
+ attempts: number;
18
+ waitedMs: number;
19
+ fetchMs: number;
20
+ stageMs: number;
21
+ }
22
+ export interface SnapshotFetchOptions {
23
+ token?: RoomToken;
24
+ fetch?: typeof fetch;
25
+ cache?: RequestCache;
26
+ signal?: AbortSignal;
27
+ maxRetries?: number;
28
+ maxWaitMs?: number;
29
+ inactivityMs?: number;
30
+ minBytesPerSecond?: number;
31
+ maxBytes?: number;
32
+ random?: () => number;
33
+ onRetry?(info: {
34
+ attempt: number;
35
+ status: number;
36
+ retryAfterMs: number;
37
+ delayMs: number;
38
+ }): void;
39
+ }
40
+ export declare function snapshotUrl(base: string, room: string): string;
41
+ export declare function retryAfterMs(value: string | null, now?: number): number;
42
+ export declare function frontierText(frontiers: readonly {
43
+ peer: string;
44
+ counter: number;
45
+ }[]): string;
46
+ export declare function fetchSnapshot(base: string, room: string, opts?: SnapshotFetchOptions): Promise<SnapshotFetch>;