@earendil-works/chord 1.4.0 → 1.5.1

package/dist/sync/client.js

@@ -0,0 +1,438 @@
+// Session sync over a Chord store's outbox: upload the commits after the last sequence a copy shares with a remote
+// into a slot the remote creates once, pull a copy forward with `applyBatch`, restore from an archive, fold history
+// into snapshots, and decide when to upload. The remote and the host's sync state are interfaces (`remote.ts`).
+//
+// Bounded memory: bodies are streams (`batch.ts`). An upload reads the outbox a page at a time and stops a batch at
+// `BATCH_BYTES`; a pull applies a batch in chunks of at most `APPLY_BYTES`; a snapshot is exported and imported as it
+// streams. Nothing holds a whole batch, snapshot or store, so a Durable Object's isolate (128 MB) can run it.
+import { applyBatch } from "../store/apply-batch.js";
+import { importStore } from "../store/import.js";
+import { openStore } from "../store/store.js";
+import { decodeBatchLines, decodeSnapshot, encodeBatch, encodeSnapshot } from "./batch.js";
+import { HistoryUnavailableError, LOG_START, remoteHead, remoteHistory, } from "./remote.js";
+/** Commits read from the outbox per page at most. */
+const OUTBOX_PAGE = 100;
+/** About how much one outbox page holds: the count of the next page follows the size of the commits read. */
+const PAGE_BYTES = 1024 * 1024;
+/**
+ * Where an upload ends a batch: once its lines (before compression) reach this size. One commit larger than this is
+ * a batch of its own.
+ */
+export const BATCH_BYTES = 8 * 1024 * 1024;
+/** How much of a batch a pull holds before it applies it: commits are applied in chunks of about this size. */
+export const APPLY_BYTES = 4 * 1024 * 1024;
+/** The last sequence a copy shares with the remote, counting commits an interrupted pull applied. */
+function sharedHead(state, local) {
+    if (state?.pulling !== undefined && local <= state.pulling)
+        return local;
+    return state?.syncedHead ?? LOG_START;
+}
+/** A store's head as a sequence: `lastSeq`, 0 for a store without commits. */
+export function storeHead(store) {
+    return store.lastSeq;
+}
+/** The store keeps no outbox, or its outbox no longer holds the commits a sync needs. */
+export class OutboxUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "OutboxUnavailableError";
+    }
+}
+function outboxOf(store) {
+    if (store.outbox === undefined) {
+        throw new OutboxUnavailableError("The session's store has no outbox: open it with { outbox: true } to sync it");
+    }
+    return store.outbox;
+}
+/** The outbox commits after `after`, a page of at most `limit`. */
+export async function readOutbox(store, after, limit, context) {
+    const outbox = outboxOf(store);
+    if (after < outbox.floor) {
+        throw new OutboxUnavailableError(`The outbox starts after ${outbox.floor}, past the synced head ${after}`);
+    }
+    return outbox.read(after, limit, context);
+}
+/**
+ * Upload what this copy committed since it last shared the remote's history, from the store's outbox, and trim the
+ * outbox through what the remote acknowledged. Every device continues a session as its own; whichever creates the slot
+ * first continues the session, so an upload that is acknowledged stays.
+ *
+ * A session the remote does not have yet, whose outbox does not reach back to its first commit (turned on later, or
+ * trimmed, as for a copy renamed after it diverged), starts with an archive slot: the store's `export()` at its head.
+ *
+ * A slot this device created already is an upload whose response was lost: the remote has the history up to its end,
+ * and the upload goes on from there.
+ */
+export async function uploadSession(options) {
+    const { sessionId, device, source, store, state, epoch, context } = options;
+    const outbox = outboxOf(source);
+    let synced = sharedHead(await state.get(sessionId, context), storeHead(source));
+    let uploaded;
+    while (true) {
+        // Read again on every pass: a slot this device already holds may end past what the copy still has.
+        const head = storeHead(source);
+        if (head < synced)
+            return { type: "behind", head, syncedHead: synced };
+        let to;
+        let body;
+        let archive = false;
+        let close;
+        if (synced === LOG_START && outbox.floor > 0) {
+            const snapshot = await exportSnapshot(source, context);
+            to = snapshot.to;
+            body = snapshot.body;
+            close = snapshot.close;
+            archive = true;
+        }
+        else {
+            const range = await outboxRange(source, synced, context);
+            if (range === undefined)
+                return uploaded === undefined ? { type: "idle" } : { type: "uploaded", head: uploaded };
+            to = range.to;
+            body = encodeBatch(outboxCommits(source, synced, to, context));
+        }
+        const after = synced;
+        let result;
+        try {
+            result = await store.putBatch(sessionId, after, to, device, body, context, {
+                ...(archive ? { archive } : {}),
+                ...(epoch === undefined ? {} : { epoch }),
+            });
+        }
+        finally {
+            // A remote that answered without reading the archive leaves the export holding the commit queue.
+            await close?.();
+        }
+        // A history that does not end at `after` is another one too: the remote never held this copy's past `after`.
+        if (result.type === "stale_epoch")
+            return { type: "stale_epoch", at: after, epoch: result.epoch };
+        if (result.type === "not_head")
+            return { type: "diverged", at: after };
+        if (result.type === "exists" && result.device !== device)
+            return { type: "diverged", at: after };
+        synced = result.type === "created" ? to : result.to;
+        await state.set(sessionId, { syncedHead: synced }, context);
+        const trimmable = Math.min(synced, source.lastSeq);
+        if (trimmable > outbox.floor)
+            await outbox.trim(trimmable, context);
+        if (result.type === "created")
+            uploaded = to;
+    }
+}
+/**
+ * Where the next batch after `after` ends: the outbox read a page at a time, holding one page, until the lines reach
+ * `BATCH_BYTES` (one commit at least). Undefined when the outbox has nothing after `after`.
+ */
+async function outboxRange(store, after, context) {
+    let to;
+    let bytes = 0;
+    const pages = new OutboxPages(store, after, context);
+    for (let page = await pages.next(); page.length > 0; page = await pages.next()) {
+        for (const commit of page) {
+            if (to !== undefined && bytes + encodedSize(commit) > BATCH_BYTES)
+                return { to };
+            bytes += encodedSize(commit);
+            to = commit.seq;
+        }
+        if (bytes >= BATCH_BYTES)
+            break;
+    }
+    return to === undefined ? undefined : { to };
+}
+/** The outbox commits after `after` through `to`, a page at a time, as the body is read. */
+async function* outboxCommits(store, after, to, context) {
+    const pages = new OutboxPages(store, after, context);
+    let at = after;
+    while (at < to) {
+        const page = await pages.next();
+        if (page.length === 0)
+            throw new OutboxUnavailableError(`The outbox ends at ${at}, before ${to}`);
+        for (const commit of page) {
+            if (commit.seq > to)
+                return;
+            yield commit;
+            at = commit.seq;
+        }
+    }
+}
+/**
+ * Pages of the outbox after a sequence, each about `PAGE_BYTES`: the outbox reads by count, so the next page's count
+ * follows the commits read so far (`OUTBOX_PAGE` to start, one commit at least). A run of large commits reads one at a
+ * time instead of `OUTBOX_PAGE` of them at once.
+ */
+class OutboxPages {
+    #store;
+    #context;
+    #after;
+    #limit = OUTBOX_PAGE;
+    #done = false;
+    constructor(store, after, context) {
+        this.#store = store;
+        this.#after = after;
+        this.#context = context;
+    }
+    async next() {
+        if (this.#done)
+            return [];
+        const page = await readOutbox(this.#store, this.#after, this.#limit, this.#context);
+        if (page.length < this.#limit)
+            this.#done = true;
+        if (page.length === 0)
+            return page;
+        this.#after = page.at(-1).seq;
+        const average = page.reduce((size, commit) => size + encodedSize(commit), 0) / page.length;
+        this.#limit = Math.max(1, Math.min(OUTBOX_PAGE, Math.floor(PAGE_BYTES / average)));
+        return page;
+    }
+}
+/** A commit's line size before compression, as `BATCH_BYTES` counts it. */
+function encodedSize(commit) {
+    return JSON.stringify(commit.writes).length + 64;
+}
+/**
+ * The store's state as a streamed snapshot body. The export holds the store's commit queue from its first part until
+ * the body is read to the end or `close()` is called, so `to` (its manifest's `lastSeq`) is exactly what it holds.
+ */
+async function exportSnapshot(store, context) {
+    const parts = store.export(context);
+    const first = await parts.next();
+    if (first.done || first.value.kind !== "manifest") {
+        await parts.return?.(undefined);
+        throw new Error("A store export does not start with its manifest");
+    }
+    const manifest = first.value;
+    return {
+        to: manifest.lastSeq,
+        body: encodeSnapshot((async function* () {
+            yield manifest;
+            yield* parts;
+        })()),
+        close: async () => {
+            await parts.return?.(undefined);
+        },
+    };
+}
+/**
+ * Apply a batch body to `store` as it streams, in chunks of about `APPLY_BYTES`, skipping the commits the store has
+ * (a pull resuming inside a batch). Each chunk is one `applyBatch()` transaction; a pull stopped between chunks
+ * resumes after the last applied one.
+ */
+async function applyBody(store, body, context) {
+    let chunk = [];
+    let bytes = 0;
+    for await (const line of decodeBatchLines(body)) {
+        if (line.commit.seq <= store.lastSeq)
+            continue;
+        chunk.push(line.commit);
+        bytes += line.bytes;
+        if (bytes >= APPLY_BYTES) {
+            await applyBatch(store, chunk, context);
+            chunk = [];
+            bytes = 0;
+        }
+    }
+    if (chunk.length > 0)
+        await applyBatch(store, chunk, context);
+}
+/** This copy has commits it has not uploaded: upload them first, which may find that the copy diverged. */
+export class UnsyncedCommitsError extends Error {
+    constructor(sessionId, localHead, syncedHead) {
+        super(`This copy of session ${sessionId} is at ${localHead}, past what it shares with the remote (${syncedHead})`);
+        this.name = "UnsyncedCommitsError";
+    }
+}
+/**
+ * Apply what the remote has after the local head; into an empty backend, that restores the session (from an archive
+ * when the history starts with one) and opens its store with an outbox. Resolves with the store, which the caller
+ * owns and closes. Nothing may hold the store's claims (no `StoreStorage`, no Harness): `applyBatch()` refuses then.
+ *
+ * A copy with commits it has not uploaded rejects with `UnsyncedCommitsError` instead of getting the remote's commits
+ * spliced onto its own. A copy whose history folding removed rejects with `HistoryUnavailableError` and restores into
+ * a fresh backend.
+ */
+export async function pullSession(options) {
+    const { sessionId, store: remote, local, state, context } = options;
+    const listing = await remote.list(sessionId, context);
+    let target = local.kind === "store" ? local.store : undefined;
+    const at = () => (target === undefined ? LOG_START : storeHead(target));
+    const synced = sharedHead(await state.get(sessionId, context), at());
+    if (at() > synced)
+        throw new UnsyncedCommitsError(sessionId, at(), synced);
+    const history = remoteHistory(listing, at());
+    try {
+        const bodies = [];
+        if (history.snapshot !== undefined) {
+            const snapshot = history.snapshot;
+            bodies.push({ to: snapshot, archive: true, read: () => remote.getSnapshot(sessionId, snapshot, context) });
+        }
+        for (const batch of history.batches) {
+            bodies.push({
+                to: batch.to,
+                archive: batch.archive === true,
+                read: () => remote.getBatch(sessionId, batch.after, context),
+            });
+        }
+        for (const body of bodies) {
+            if (body.to <= at())
+                continue;
+            const bytes = await body.read();
+            if (bytes === undefined)
+                throw new HistoryUnavailableError(at());
+            await state.set(sessionId, { syncedHead: at(), pulling: body.to }, context);
+            if (body.archive) {
+                // An archive restores a whole store: only into an empty backend.
+                if (target !== undefined || local.kind !== "empty")
+                    throw new HistoryUnavailableError(at());
+                target = await importStore(local.backend, decodeSnapshot(bytes), context, { outbox: true });
+            }
+            else {
+                if (target === undefined) {
+                    if (local.kind !== "empty")
+                        throw new Error("unreachable: a store copy always has a target");
+                    target = await openStore(local.backend, context, { outbox: true });
+                }
+                await applyBody(target, bytes, context);
+            }
+            await state.set(sessionId, { syncedHead: at() }, context);
+        }
+        if (target === undefined) {
+            if (local.kind !== "empty")
+                throw new Error("unreachable: a store copy always has a target");
+            target = await openStore(local.backend, context, { outbox: true });
+        }
+        const head = at();
+        if (head < remoteHead(listing))
+            throw new HistoryUnavailableError(head);
+        await state.set(sessionId, { syncedHead: head }, context);
+        // What the remote holds needs no upload: the outbox keeps only this copy's own commits.
+        const outbox = target.outbox;
+        if (outbox !== undefined && head > outbox.floor)
+            await outbox.trim(head, context);
+        return { store: target, head };
+    }
+    catch (error) {
+        // A store this pull opened is the caller's only on success.
+        if (local.kind === "empty" && target !== undefined)
+            await target.close(context).catch(() => { });
+        throw error;
+    }
+}
+/**
+ * Fold a session's history into one snapshot: restore it into `scratch` (an empty backend; a file or a Durable Object's
+ * SQLite storage, not `:memory:`, so the restored store is not held in memory), upload its `export()` as a snapshot, drop the commits of the batches it covers, keeping their
+ * slots taken, and delete older snapshots. The remote runs this, not clients.
+ */
+export async function foldSession(options) {
+    const { sessionId, store, scratch, context } = options;
+    const listing = await store.list(sessionId, context);
+    const history = remoteHistory(listing);
+    if (history.batches.length + (history.snapshot === undefined ? 0 : 1) < 2)
+        return undefined;
+    const restored = await pullSession({
+        sessionId,
+        store,
+        local: { kind: "empty", backend: scratch },
+        state: new ScratchState(),
+        context,
+    });
+    try {
+        const snapshot = await exportSnapshot(restored.store, context);
+        try {
+            await store.putSnapshot(sessionId, snapshot.to, snapshot.body, context);
+        }
+        finally {
+            await snapshot.close();
+        }
+        await store.foldBatches(sessionId, history.batches.filter((batch) => batch.to <= snapshot.to).map((batch) => batch.after), context);
+        await store.deleteSnapshots(sessionId, listing.snapshots.filter((at) => at < snapshot.to), context);
+        return snapshot.to;
+    }
+    finally {
+        await restored.store.close(context);
+    }
+}
+/** Sync state for a restore nobody continues. */
+class ScratchState {
+    #state;
+    async get() {
+        return this.#state;
+    }
+    async set(_sessionId, state) {
+        this.#state = state;
+    }
+}
+/**
+ * Decides when to flush: some time after a commit, sooner after an urgent one, one flush at a time. Commits that arrive
+ * during a flush keep their urgency and schedule the next one when it ends. A failed flush is retried with backoff
+ * until one succeeds, so the last commits of a turn do not wait for the next commit.
+ */
+export class FlushScheduler {
+    #options;
+    #due;
+    #disarm;
+    #running;
+    /** When the commits that arrived during a flush want the next one. */
+    #pendingDue;
+    #failures = 0;
+    #closed = false;
+    constructor(options) {
+        this.#options = options;
+    }
+    /** A commit landed. */
+    notify(urgent) {
+        if (this.#closed)
+            return;
+        const due = this.#options.now() + (urgent ? (this.#options.urgentMs ?? 200) : (this.#options.intervalMs ?? 5000));
+        if (this.#running !== undefined) {
+            this.#pendingDue = Math.min(this.#pendingDue ?? due, due);
+            return;
+        }
+        this.#arm(due);
+    }
+    /** Flush now, after a flush underway, and stop scheduling. A failure rejects. */
+    async close() {
+        this.#closed = true;
+        this.#disarm?.();
+        this.#disarm = undefined;
+        this.#due = undefined;
+        await this.#running;
+        await this.#options.flush();
+    }
+    #arm(due) {
+        if (this.#due !== undefined && this.#due <= due)
+            return;
+        this.#disarm?.();
+        this.#due = due;
+        this.#disarm = this.#options.setTimer(() => void this.#run(), Math.max(0, due - this.#options.now()));
+    }
+    #run() {
+        this.#disarm = undefined;
+        this.#due = undefined;
+        this.#running = (async () => {
+            let retry;
+            try {
+                await this.#options.flush();
+                this.#failures = 0;
+            }
+            catch (error) {
+                this.#options.onError(error);
+                const delay = (this.#options.retryMs ?? 1000) * 2 ** this.#failures;
+                this.#failures++;
+                retry = this.#options.now() + Math.min(delay, this.#options.maxRetryMs ?? 60_000);
+            }
+            finally {
+                this.#running = undefined;
+            }
+            if (this.#closed)
+                return;
+            const pending = this.#pendingDue;
+            this.#pendingDue = undefined;
+            // A retry waits for its backoff even when commits arrived: they flush with it.
+            const due = retry ?? pending;
+            if (due !== undefined)
+                this.#arm(due);
+        })();
+        return this.#running;
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/sync/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/sync/client.ts"],"names":[],"mappings":"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","sourcesContent":["// Session sync over a Chord store's outbox: upload the commits after the last sequence a copy shares with a remote\n// into a slot the remote creates once, pull a copy forward with `applyBatch`, restore from an archive, fold history\n// into snapshots, and decide when to upload. The remote and the host's sync state are interfaces (`remote.ts`).\n//\n// Bounded memory: bodies are streams (`batch.ts`). An upload reads the outbox a page at a time and stops a batch at\n// `BATCH_BYTES`; a pull applies a batch in chunks of at most `APPLY_BYTES`; a snapshot is exported and imported as it\n// streams. Nothing holds a whole batch, snapshot or store, so a Durable Object's isolate (128 MB) can run it.\n\nimport type { Context } from \"../context/index.ts\";\nimport { applyBatch } from \"../store/apply-batch.ts\";\nimport type { Backend } from \"../store/backend.ts\";\nimport { importStore } from \"../store/import.ts\";\nimport type { OutboxCommit } from \"../store/outbox.ts\";\nimport { type ChordStore, openStore, type Store } from \"../store/store.ts\";\nimport { decodeBatchLines, decodeSnapshot, encodeBatch, encodeSnapshot, type SyncBody } from \"./batch.ts\";\nimport {\n\ttype BatchInfo,\n\tHistoryUnavailableError,\n\tLOG_START,\n\ttype PutBatchResult,\n\tremoteHead,\n\tremoteHistory,\n\ttype Seq,\n\ttype SessionSyncMaintenance,\n\ttype SessionSyncStore,\n} from \"./remote.ts\";\n\n/** Commits read from the outbox per page at most. */\nconst OUTBOX_PAGE = 100;\n/** About how much one outbox page holds: the count of the next page follows the size of the commits read. */\nconst PAGE_BYTES = 1024 * 1024;\n/**\n * Where an upload ends a batch: once its lines (before compression) reach this size. One commit larger than this is\n * a batch of its own.\n */\nexport const BATCH_BYTES = 8 * 1024 * 1024;\n/** How much of a batch a pull holds before it applies it: commits are applied in chunks of about this size. */\nexport const APPLY_BYTES = 4 * 1024 * 1024;\n\n/**\n * What a host keeps for each copy of a session it syncs: the last sequence the copy shares with the remote. Commits\n * after it are the copy's own and not uploaded yet. When this is lost, a copy without commits of its own takes the\n * remote's head; one with commits finds out by uploading.\n */\nexport type SyncState = {\n\treadonly syncedHead: Seq | undefined;\n\t/**\n\t * Set while a pull applies a batch or snapshot ending here: a local head up to it holds the remote's commits, not\n\t * the copy's own, even when the pull stopped partway.\n\t */\n\treadonly pulling?: Seq;\n};\n\n/** The last sequence a copy shares with the remote, counting commits an interrupted pull applied. */\nfunction sharedHead(state: SyncState | undefined, local: Seq): Seq {\n\tif (state?.pulling !== undefined && local <= state.pulling) return local;\n\treturn state?.syncedHead ?? LOG_START;\n}\n\nexport interface SyncStateStore {\n\tget(sessionId: string, context: Context): Promise<SyncState | undefined>;\n\tset(sessionId: string, state: SyncState, context: Context): Promise<void>;\n}\n\n/** A store's head as a sequence: `lastSeq`, 0 for a store without commits. */\nexport function storeHead(store: Store): Seq {\n\treturn store.lastSeq;\n}\n\n/** The store keeps no outbox, or its outbox no longer holds the commits a sync needs. */\nexport class OutboxUnavailableError extends Error {\n\tconstructor(message: string) {\n\t\tsuper(message);\n\t\tthis.name = \"OutboxUnavailableError\";\n\t}\n}\n\nfunction outboxOf(store: Store) {\n\tif (store.outbox === undefined) {\n\t\tthrow new OutboxUnavailableError(\"The session's store has no outbox: open it with { outbox: true } to sync it\");\n\t}\n\treturn store.outbox;\n}\n\n/** The outbox commits after `after`, a page of at most `limit`. */\nexport async function readOutbox(store: Store, after: Seq, limit: number, context: Context): Promise<OutboxCommit[]> {\n\tconst outbox = outboxOf(store);\n\tif (after < outbox.floor) {\n\t\tthrow new OutboxUnavailableError(`The outbox starts after ${outbox.floor}, past the synced head ${after}`);\n\t}\n\treturn outbox.read(after, limit, context);\n}\n\nexport type UploadResult =\n\t| { readonly type: \"uploaded\"; readonly head: Seq }\n\t/** Nothing was committed since the last upload. */\n\t| { readonly type: \"idle\" }\n\t/**\n\t * Another device continued the session from `at` first. This copy's commits after `at` are a different history:\n\t * the host renames the copy to a new session (forked from this one at `at`) and uploads it there, and the session\n\t * itself restores into a fresh store.\n\t */\n\t| { readonly type: \"diverged\"; readonly at: Seq }\n\t/**\n\t * The copy lost commits it had uploaded, for example to a power loss: its head is below `syncedHead`. Its next\n\t * commits would reuse their sequences, so nothing is uploaded. Pull what it lost before the copy commits again; a pull\n\t * applies from the local head.\n\t */\n\t| { readonly type: \"behind\"; readonly head: Seq; readonly syncedHead: Seq }\n\t/**\n\t * The remote refused this device's epoch: another device holds the right to write the session now. Like\n\t * `diverged`, the copy's commits after `at` are a different history, so the host forks the copy (S7).\n\t */\n\t| { readonly type: \"stale_epoch\"; readonly at: Seq; readonly epoch: number };\n\n/**\n * Upload what this copy committed since it last shared the remote's history, from the store's outbox, and trim the\n * outbox through what the remote acknowledged. Every device continues a session as its own; whichever creates the slot\n * first continues the session, so an upload that is acknowledged stays.\n *\n * A session the remote does not have yet, whose outbox does not reach back to its first commit (turned on later, or\n * trimmed, as for a copy renamed after it diverged), starts with an archive slot: the store's `export()` at its head.\n *\n * A slot this device created already is an upload whose response was lost: the remote has the history up to its end,\n * and the upload goes on from there.\n */\nexport async function uploadSession(options: {\n\treadonly sessionId: string;\n\treadonly device: string;\n\treadonly source: Store;\n\treadonly store: SessionSyncStore;\n\treadonly state: SyncStateStore;\n\t/** The writer's epoch, from whatever grants it (the remote, Radius); sent with every slot. */\n\treadonly epoch?: number;\n\treadonly context: Context;\n}): Promise<UploadResult> {\n\tconst { sessionId, device, source, store, state, epoch, context } = options;\n\tconst outbox = outboxOf(source);\n\tlet synced = sharedHead(await state.get(sessionId, context), storeHead(source));\n\tlet uploaded: Seq | undefined;\n\twhile (true) {\n\t\t// Read again on every pass: a slot this device already holds may end past what the copy still has.\n\t\tconst head = storeHead(source);\n\t\tif (head < synced) return { type: \"behind\", head, syncedHead: synced };\n\t\tlet to: Seq;\n\t\tlet body: SyncBody;\n\t\tlet archive = false;\n\t\tlet close: (() => Promise<void>) | undefined;\n\t\tif (synced === LOG_START && outbox.floor > 0) {\n\t\t\tconst snapshot = await exportSnapshot(source, context);\n\t\t\tto = snapshot.to;\n\t\t\tbody = snapshot.body;\n\t\t\tclose = snapshot.close;\n\t\t\tarchive = true;\n\t\t} else {\n\t\t\tconst range = await outboxRange(source, synced, context);\n\t\t\tif (range === undefined)\n\t\t\t\treturn uploaded === undefined ? { type: \"idle\" } : { type: \"uploaded\", head: uploaded };\n\t\t\tto = range.to;\n\t\t\tbody = encodeBatch(outboxCommits(source, synced, to, context));\n\t\t}\n\t\tconst after = synced;\n\t\tlet result: PutBatchResult;\n\t\ttry {\n\t\t\tresult = await store.putBatch(sessionId, after, to, device, body, context, {\n\t\t\t\t...(archive ? { archive } : {}),\n\t\t\t\t...(epoch === undefined ? {} : { epoch }),\n\t\t\t});\n\t\t} finally {\n\t\t\t// A remote that answered without reading the archive leaves the export holding the commit queue.\n\t\t\tawait close?.();\n\t\t}\n\t\t// A history that does not end at `after` is another one too: the remote never held this copy's past `after`.\n\t\tif (result.type === \"stale_epoch\") return { type: \"stale_epoch\", at: after, epoch: result.epoch };\n\t\tif (result.type === \"not_head\") return { type: \"diverged\", at: after };\n\t\tif (result.type === \"exists\" && result.device !== device) return { type: \"diverged\", at: after };\n\t\tsynced = result.type === \"created\" ? to : result.to;\n\t\tawait state.set(sessionId, { syncedHead: synced }, context);\n\t\tconst trimmable = Math.min(synced, source.lastSeq);\n\t\tif (trimmable > outbox.floor) await outbox.trim(trimmable, context);\n\t\tif (result.type === \"created\") uploaded = to;\n\t}\n}\n\n/**\n * Where the next batch after `after` ends: the outbox read a page at a time, holding one page, until the lines reach\n * `BATCH_BYTES` (one commit at least). Undefined when the outbox has nothing after `after`.\n */\nasync function outboxRange(store: Store, after: Seq, context: Context): Promise<{ readonly to: Seq } | undefined> {\n\tlet to: Seq | undefined;\n\tlet bytes = 0;\n\tconst pages = new OutboxPages(store, after, context);\n\tfor (let page = await pages.next(); page.length > 0; page = await pages.next()) {\n\t\tfor (const commit of page) {\n\t\t\tif (to !== undefined && bytes + encodedSize(commit) > BATCH_BYTES) return { to };\n\t\t\tbytes += encodedSize(commit);\n\t\t\tto = commit.seq;\n\t\t}\n\t\tif (bytes >= BATCH_BYTES) break;\n\t}\n\treturn to === undefined ? undefined : { to };\n}\n\n/** The outbox commits after `after` through `to`, a page at a time, as the body is read. */\nasync function* outboxCommits(store: Store, after: Seq, to: Seq, context: Context): AsyncGenerator<OutboxCommit> {\n\tconst pages = new OutboxPages(store, after, context);\n\tlet at = after;\n\twhile (at < to) {\n\t\tconst page = await pages.next();\n\t\tif (page.length === 0) throw new OutboxUnavailableError(`The outbox ends at ${at}, before ${to}`);\n\t\tfor (const commit of page) {\n\t\t\tif (commit.seq > to) return;\n\t\t\tyield commit;\n\t\t\tat = commit.seq;\n\t\t}\n\t}\n}\n\n/**\n * Pages of the outbox after a sequence, each about `PAGE_BYTES`: the outbox reads by count, so the next page's count\n * follows the commits read so far (`OUTBOX_PAGE` to start, one commit at least). A run of large commits reads one at a\n * time instead of `OUTBOX_PAGE` of them at once.\n */\nclass OutboxPages {\n\treadonly #store: Store;\n\treadonly #context: Context;\n\t#after: Seq;\n\t#limit = OUTBOX_PAGE;\n\t#done = false;\n\n\tconstructor(store: Store, after: Seq, context: Context) {\n\t\tthis.#store = store;\n\t\tthis.#after = after;\n\t\tthis.#context = context;\n\t}\n\n\tasync next(): Promise<OutboxCommit[]> {\n\t\tif (this.#done) return [];\n\t\tconst page = await readOutbox(this.#store, this.#after, this.#limit, this.#context);\n\t\tif (page.length < this.#limit) this.#done = true;\n\t\tif (page.length === 0) return page;\n\t\tthis.#after = page.at(-1)!.seq;\n\t\tconst average = page.reduce((size, commit) => size + encodedSize(commit), 0) / page.length;\n\t\tthis.#limit = Math.max(1, Math.min(OUTBOX_PAGE, Math.floor(PAGE_BYTES / average)));\n\t\treturn page;\n\t}\n}\n\n/** A commit's line size before compression, as `BATCH_BYTES` counts it. */\nfunction encodedSize(commit: OutboxCommit): number {\n\treturn JSON.stringify(commit.writes).length + 64;\n}\n\n/** A snapshot of a store being exported: where it ends, its body, and `close()` for when the body is not read to the end. */\ntype ExportedSnapshot = { readonly to: Seq; readonly body: SyncBody; close(): Promise<void> };\n\n/**\n * The store's state as a streamed snapshot body. The export holds the store's commit queue from its first part until\n * the body is read to the end or `close()` is called, so `to` (its manifest's `lastSeq`) is exactly what it holds.\n */\nasync function exportSnapshot(store: Store, context: Context): Promise<ExportedSnapshot> {\n\tconst parts = store.export(context);\n\tconst first = await parts.next();\n\tif (first.done || first.value.kind !== \"manifest\") {\n\t\tawait parts.return?.(undefined);\n\t\tthrow new Error(\"A store export does not start with its manifest\");\n\t}\n\tconst manifest = first.value;\n\treturn {\n\t\tto: manifest.lastSeq,\n\t\tbody: encodeSnapshot(\n\t\t\t(async function* () {\n\t\t\t\tyield manifest;\n\t\t\t\tyield* parts;\n\t\t\t})(),\n\t\t),\n\t\tclose: async () => {\n\t\t\tawait parts.return?.(undefined);\n\t\t},\n\t};\n}\n\n/**\n * Apply a batch body to `store` as it streams, in chunks of about `APPLY_BYTES`, skipping the commits the store has\n * (a pull resuming inside a batch). Each chunk is one `applyBatch()` transaction; a pull stopped between chunks\n * resumes after the last applied one.\n */\nasync function applyBody(store: ChordStore, body: SyncBody, context: Context): Promise<void> {\n\tlet chunk: OutboxCommit[] = [];\n\tlet bytes = 0;\n\tfor await (const line of decodeBatchLines(body)) {\n\t\tif (line.commit.seq <= store.lastSeq) continue;\n\t\tchunk.push(line.commit);\n\t\tbytes += line.bytes;\n\t\tif (bytes >= APPLY_BYTES) {\n\t\t\tawait applyBatch(store, chunk, context);\n\t\t\tchunk = [];\n\t\t\tbytes = 0;\n\t\t}\n\t}\n\tif (chunk.length > 0) await applyBatch(store, chunk, context);\n}\n\n/** This copy has commits it has not uploaded: upload them first, which may find that the copy diverged. */\nexport class UnsyncedCommitsError extends Error {\n\tconstructor(sessionId: string, localHead: Seq, syncedHead: Seq) {\n\t\tsuper(\n\t\t\t`This copy of session ${sessionId} is at ${localHead}, past what it shares with the remote (${syncedHead})`,\n\t\t);\n\t\tthis.name = \"UnsyncedCommitsError\";\n\t}\n}\n\n/** The copy a pull applies to: an open store, or an empty backend to restore the session into. */\nexport type LocalCopy =\n\t| { readonly kind: \"store\"; readonly store: Store }\n\t| { readonly kind: \"empty\"; readonly backend: Backend };\n\n/**\n * Apply what the remote has after the local head; into an empty backend, that restores the session (from an archive\n * when the history starts with one) and opens its store with an outbox. Resolves with the store, which the caller\n * owns and closes. Nothing may hold the store's claims (no `StoreStorage`, no Harness): `applyBatch()` refuses then.\n *\n * A copy with commits it has not uploaded rejects with `UnsyncedCommitsError` instead of getting the remote's commits\n * spliced onto its own. A copy whose history folding removed rejects with `HistoryUnavailableError` and restores into\n * a fresh backend.\n */\nexport async function pullSession(options: {\n\treadonly sessionId: string;\n\treadonly store: SessionSyncStore;\n\treadonly local: LocalCopy;\n\treadonly state: SyncStateStore;\n\treadonly context: Context;\n}): Promise<{ readonly store: Store; readonly head: Seq }> {\n\tconst { sessionId, store: remote, local, state, context } = options;\n\tconst listing = await remote.list(sessionId, context);\n\tlet target: Store | undefined = local.kind === \"store\" ? local.store : undefined;\n\tconst at = () => (target === undefined ? LOG_START : storeHead(target));\n\tconst synced = sharedHead(await state.get(sessionId, context), at());\n\tif (at() > synced) throw new UnsyncedCommitsError(sessionId, at(), synced);\n\tconst history = remoteHistory(listing, at());\n\ttry {\n\t\tconst bodies: { readonly to: Seq; readonly archive: boolean; read(): Promise<SyncBody | undefined> }[] = [];\n\t\tif (history.snapshot !== undefined) {\n\t\t\tconst snapshot = history.snapshot;\n\t\t\tbodies.push({ to: snapshot, archive: true, read: () => remote.getSnapshot(sessionId, snapshot, context) });\n\t\t}\n\t\tfor (const batch of history.batches) {\n\t\t\tbodies.push({\n\t\t\t\tto: batch.to,\n\t\t\t\tarchive: batch.archive === true,\n\t\t\t\tread: () => remote.getBatch(sessionId, batch.after, context),\n\t\t\t});\n\t\t}\n\t\tfor (const body of bodies) {\n\t\t\tif (body.to <= at()) continue;\n\t\t\tconst bytes = await body.read();\n\t\t\tif (bytes === undefined) throw new HistoryUnavailableError(at());\n\t\t\tawait state.set(sessionId, { syncedHead: at(), pulling: body.to }, context);\n\t\t\tif (body.archive) {\n\t\t\t\t// An archive restores a whole store: only into an empty backend.\n\t\t\t\tif (target !== undefined || local.kind !== \"empty\") throw new HistoryUnavailableError(at());\n\t\t\t\ttarget = await importStore(local.backend, decodeSnapshot(bytes), context, { outbox: true });\n\t\t\t} else {\n\t\t\t\tif (target === undefined) {\n\t\t\t\t\tif (local.kind !== \"empty\") throw new Error(\"unreachable: a store copy always has a target\");\n\t\t\t\t\ttarget = await openStore(local.backend, context, { outbox: true });\n\t\t\t\t}\n\t\t\t\tawait applyBody(target as ChordStore, bytes, context);\n\t\t\t}\n\t\t\tawait state.set(sessionId, { syncedHead: at() }, context);\n\t\t}\n\t\tif (target === undefined) {\n\t\t\tif (local.kind !== \"empty\") throw new Error(\"unreachable: a store copy always has a target\");\n\t\t\ttarget = await openStore(local.backend, context, { outbox: true });\n\t\t}\n\t\tconst head = at();\n\t\tif (head < remoteHead(listing)) throw new HistoryUnavailableError(head);\n\t\tawait state.set(sessionId, { syncedHead: head }, context);\n\t\t// What the remote holds needs no upload: the outbox keeps only this copy's own commits.\n\t\tconst outbox = target.outbox;\n\t\tif (outbox !== undefined && head > outbox.floor) await outbox.trim(head, context);\n\t\treturn { store: target, head };\n\t} catch (error) {\n\t\t// A store this pull opened is the caller's only on success.\n\t\tif (local.kind === \"empty\" && target !== undefined) await target.close(context).catch(() => {});\n\t\tthrow error;\n\t}\n}\n\n/**\n * Fold a session's history into one snapshot: restore it into `scratch` (an empty backend; a file or a Durable Object's\n * SQLite storage, not `:memory:`, so the restored store is not held in memory), upload its `export()` as a snapshot, drop the commits of the batches it covers, keeping their\n * slots taken, and delete older snapshots. The remote runs this, not clients.\n */\nexport async function foldSession(options: {\n\treadonly sessionId: string;\n\treadonly store: SessionSyncMaintenance;\n\treadonly scratch: Backend;\n\treadonly context: Context;\n}): Promise<Seq | undefined> {\n\tconst { sessionId, store, scratch, context } = options;\n\tconst listing = await store.list(sessionId, context);\n\tconst history = remoteHistory(listing);\n\tif (history.batches.length + (history.snapshot === undefined ? 0 : 1) < 2) return undefined;\n\tconst restored = await pullSession({\n\t\tsessionId,\n\t\tstore,\n\t\tlocal: { kind: \"empty\", backend: scratch },\n\t\tstate: new ScratchState(),\n\t\tcontext,\n\t});\n\ttry {\n\t\tconst snapshot = await exportSnapshot(restored.store, context);\n\t\ttry {\n\t\t\tawait store.putSnapshot(sessionId, snapshot.to, snapshot.body, context);\n\t\t} finally {\n\t\t\tawait snapshot.close();\n\t\t}\n\t\tawait store.foldBatches(\n\t\t\tsessionId,\n\t\t\thistory.batches.filter((batch: BatchInfo) => batch.to <= snapshot.to).map((batch) => batch.after),\n\t\t\tcontext,\n\t\t);\n\t\tawait store.deleteSnapshots(\n\t\t\tsessionId,\n\t\t\tlisting.snapshots.filter((at) => at < snapshot.to),\n\t\t\tcontext,\n\t\t);\n\t\treturn snapshot.to;\n\t} finally {\n\t\tawait restored.store.close(context);\n\t}\n}\n\n/** Sync state for a restore nobody continues. */\nclass ScratchState implements SyncStateStore {\n\t#state: SyncState | undefined;\n\tasync get(): Promise<SyncState | undefined> {\n\t\treturn this.#state;\n\t}\n\tasync set(_sessionId: string, state: SyncState): Promise<void> {\n\t\tthis.#state = state;\n\t}\n}\n\nexport type FlushSchedulerOptions = {\n\treadonly flush: () => Promise<unknown>;\n\t/** Arms a timer and returns its disarm. */\n\treadonly setTimer: (callback: () => void, delayMs: number) => () => void;\n\treadonly now: () => number;\n\t/** A failed flush; the scheduler retries it with backoff. */\n\treadonly onError: (error: unknown) => void;\n\t/** Delay of an ordinary flush after a commit. Default 5 seconds. */\n\treadonly intervalMs?: number;\n\t/** Delay of a flush after an urgent commit. Default 200 milliseconds. */\n\treadonly urgentMs?: number;\n\t/** First retry delay after a failed flush, doubling up to `maxRetryMs`. Default 1 second. */\n\treadonly retryMs?: number;\n\t/** Default 1 minute. */\n\treadonly maxRetryMs?: number;\n};\n\n/**\n * Decides when to flush: some time after a commit, sooner after an urgent one, one flush at a time. Commits that arrive\n * during a flush keep their urgency and schedule the next one when it ends. A failed flush is retried with backoff\n * until one succeeds, so the last commits of a turn do not wait for the next commit.\n */\nexport class FlushScheduler {\n\treadonly #options: FlushSchedulerOptions;\n\t#due: number | undefined;\n\t#disarm: (() => void) | undefined;\n\t#running: Promise<void> | undefined;\n\t/** When the commits that arrived during a flush want the next one. */\n\t#pendingDue: number | undefined;\n\t#failures = 0;\n\t#closed = false;\n\n\tconstructor(options: FlushSchedulerOptions) {\n\t\tthis.#options = options;\n\t}\n\n\t/** A commit landed. */\n\tnotify(urgent: boolean): void {\n\t\tif (this.#closed) return;\n\t\tconst due = this.#options.now() + (urgent ? (this.#options.urgentMs ?? 200) : (this.#options.intervalMs ?? 5000));\n\t\tif (this.#running !== undefined) {\n\t\t\tthis.#pendingDue = Math.min(this.#pendingDue ?? due, due);\n\t\t\treturn;\n\t\t}\n\t\tthis.#arm(due);\n\t}\n\n\t/** Flush now, after a flush underway, and stop scheduling. A failure rejects. */\n\tasync close(): Promise<void> {\n\t\tthis.#closed = true;\n\t\tthis.#disarm?.();\n\t\tthis.#disarm = undefined;\n\t\tthis.#due = undefined;\n\t\tawait this.#running;\n\t\tawait this.#options.flush();\n\t}\n\n\t#arm(due: number): void {\n\t\tif (this.#due !== undefined && this.#due <= due) return;\n\t\tthis.#disarm?.();\n\t\tthis.#due = due;\n\t\tthis.#disarm = this.#options.setTimer(() => void this.#run(), Math.max(0, due - this.#options.now()));\n\t}\n\n\t#run(): Promise<void> {\n\t\tthis.#disarm = undefined;\n\t\tthis.#due = undefined;\n\t\tthis.#running = (async () => {\n\t\t\tlet retry: number | undefined;\n\t\t\ttry {\n\t\t\t\tawait this.#options.flush();\n\t\t\t\tthis.#failures = 0;\n\t\t\t} catch (error) {\n\t\t\t\tthis.#options.onError(error);\n\t\t\t\tconst delay = (this.#options.retryMs ?? 1000) * 2 ** this.#failures;\n\t\t\t\tthis.#failures++;\n\t\t\t\tretry = this.#options.now() + Math.min(delay, this.#options.maxRetryMs ?? 60_000);\n\t\t\t} finally {\n\t\t\t\tthis.#running = undefined;\n\t\t\t}\n\t\t\tif (this.#closed) return;\n\t\t\tconst pending = this.#pendingDue;\n\t\t\tthis.#pendingDue = undefined;\n\t\t\t// A retry waits for its backoff even when commits arrived: they flush with it.\n\t\t\tconst due = retry ?? pending;\n\t\t\tif (due !== undefined) this.#arm(due);\n\t\t})();\n\t\treturn this.#running;\n\t}\n}\n"]}

package/dist/sync/files.d.ts

@@ -0,0 +1,46 @@
+import type { Context } from "../context/index.ts";
+/** An operation's outcome: its value, or the error it failed with. */
+export type FileResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: Error;
+};
+/** A directory entry. */
+export type SyncFileInfo = {
+    readonly name: string;
+    readonly kind: "file" | "directory" | "symlink";
+};
+/** A file opened for reads at offsets: what streaming a body back needs. */
+export interface SyncFileReader {
+    /** Up to `length` bytes at `offset`; fewer only at end of file. */
+    read(offset: number, length: number, context: Context): Promise<FileResult<Uint8Array>>;
+    close(context: Context): Promise<void>;
+}
+/** File operations for the directory-backed sync pieces. A missing file or directory fails with `code: "not_found"`. */
+export interface SyncFileSystem {
+    joinPath(parts: string[], context: Context): Promise<FileResult<string>>;
+    readTextFile(path: string, context: Context): Promise<FileResult<string>>;
+    readBinaryFile(path: string, context: Context): Promise<FileResult<Uint8Array>>;
+    /** Open a file for bounded reads, so a body streams back without being read whole. */
+    openBinaryReader(path: string, options: {
+        noFollow?: boolean;
+    } | undefined, context: Context): Promise<FileResult<SyncFileReader>>;
+    writeFile(path: string, content: string | Uint8Array, context: Context): Promise<FileResult<void>>;
+    /** Append to a file, creating it: a body is written chunk by chunk as it streams. */
+    appendFile(path: string, content: string | Uint8Array, context: Context): Promise<FileResult<void>>;
+    renameFile(sourcePath: string, destinationPath: string, context: Context): Promise<FileResult<void>>;
+    listDir(path: string, context: Context): Promise<FileResult<SyncFileInfo[]>>;
+    createDir(path: string, options: {
+        recursive?: boolean;
+    } | undefined, context: Context): Promise<FileResult<void>>;
+    remove(path: string, options: {
+        recursive?: boolean;
+        force?: boolean;
+    } | undefined, context: Context): Promise<FileResult<void>>;
+}
+/** Whether `result` failed because the file or directory is missing. */
+export declare function isNotFound(result: FileResult<unknown>): boolean;
+export declare function unwrap<T>(result: FileResult<T>): T;
+//# sourceMappingURL=files.d.ts.map

package/dist/sync/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../src/sync/files.ts"],"names":[],"mappings":"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"}

package/dist/sync/files.js

@@ -0,0 +1,13 @@
+// The file operations the directory-backed sync pieces need, as an interface: any environment that has them (Node,
+// a container, a remote host) can back a sync remote or the host's sync state. Shaped as Pi Durable's `FileSystem`
+// (`@earendil-works/pi-durable/env`), so its environments pass as they are.
+/** Whether `result` failed because the file or directory is missing. */
+export function isNotFound(result) {
+    return !result.ok && result.error.code === "not_found";
+}
+export function unwrap(result) {
+    if (!result.ok)
+        throw result.error;
+    return result.value;
+}
+//# sourceMappingURL=files.js.map

package/dist/sync/files.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.js","sourceRoot":"","sources":["../../src/sync/files.ts"],"names":[],"mappings":"AAAA,mHAAmH;AACnH,mHAAmH;AACnH,4EAA4E;AAyC5E,wEAAwE;AACxE,MAAM,UAAU,UAAU,CAAC,MAA2B;IACrD,OAAO,CAAC,MAAM,CAAC,EAAE,IAAK,MAAM,CAAC,KAAqC,CAAC,IAAI,KAAK,WAAW,CAAC;AACzF,CAAC;AAED,MAAM,UAAU,MAAM,CAAI,MAAqB;IAC9C,IAAI,CAAC,MAAM,CAAC,EAAE;QAAE,MAAM,MAAM,CAAC,KAAK,CAAC;IACnC,OAAO,MAAM,CAAC,KAAK,CAAC;AACrB,CAAC","sourcesContent":["// The file operations the directory-backed sync pieces need, as an interface: any environment that has them (Node,\n// a container, a remote host) can back a sync remote or the host's sync state. Shaped as Pi Durable's `FileSystem`\n// (`@earendil-works/pi-durable/env`), so its environments pass as they are.\n\nimport type { Context } from \"../context/index.ts\";\n\n/** An operation's outcome: its value, or the error it failed with. */\nexport type FileResult<T> = { readonly ok: true; readonly value: T } | { readonly ok: false; readonly error: Error };\n\n/** A directory entry. */\nexport type SyncFileInfo = { readonly name: string; readonly kind: \"file\" | \"directory\" | \"symlink\" };\n\n/** A file opened for reads at offsets: what streaming a body back needs. */\nexport interface SyncFileReader {\n\t/** Up to `length` bytes at `offset`; fewer only at end of file. */\n\tread(offset: number, length: number, context: Context): Promise<FileResult<Uint8Array>>;\n\tclose(context: Context): Promise<void>;\n}\n\n/** File operations for the directory-backed sync pieces. A missing file or directory fails with `code: \"not_found\"`. */\nexport interface SyncFileSystem {\n\tjoinPath(parts: string[], context: Context): Promise<FileResult<string>>;\n\treadTextFile(path: string, context: Context): Promise<FileResult<string>>;\n\treadBinaryFile(path: string, context: Context): Promise<FileResult<Uint8Array>>;\n\t/** Open a file for bounded reads, so a body streams back without being read whole. */\n\topenBinaryReader(\n\t\tpath: string,\n\t\toptions: { noFollow?: boolean } | undefined,\n\t\tcontext: Context,\n\t): Promise<FileResult<SyncFileReader>>;\n\twriteFile(path: string, content: string | Uint8Array, context: Context): Promise<FileResult<void>>;\n\t/** Append to a file, creating it: a body is written chunk by chunk as it streams. */\n\tappendFile(path: string, content: string | Uint8Array, context: Context): Promise<FileResult<void>>;\n\trenameFile(sourcePath: string, destinationPath: string, context: Context): Promise<FileResult<void>>;\n\tlistDir(path: string, context: Context): Promise<FileResult<SyncFileInfo[]>>;\n\tcreateDir(path: string, options: { recursive?: boolean } | undefined, context: Context): Promise<FileResult<void>>;\n\tremove(\n\t\tpath: string,\n\t\toptions: { recursive?: boolean; force?: boolean } | undefined,\n\t\tcontext: Context,\n\t): Promise<FileResult<void>>;\n}\n\n/** Whether `result` failed because the file or directory is missing. */\nexport function isNotFound(result: FileResult<unknown>): boolean {\n\treturn !result.ok && (result.error as { readonly code?: unknown }).code === \"not_found\";\n}\n\nexport function unwrap<T>(result: FileResult<T>): T {\n\tif (!result.ok) throw result.error;\n\treturn result.value;\n}\n"]}

package/dist/sync/filesystem.d.ts

@@ -0,0 +1,37 @@
+import type { Context } from "../context/index.ts";
+import type { SyncBody } from "./batch.ts";
+import { type SyncFileSystem } from "./files.ts";
+import { type JsonObject, type PutBatchResult, type RemoteListing, type Seq, type SessionChanges, type SessionSyncMaintenance } from "./remote.ts";
+/** A session ID names a file or directory: refuse anything that could leave the root. */
+export declare function checkSessionId(sessionId: string): string;
+/**
+ * A remote store in a directory, laid out as the real remote is: per session, one slot per batch start, holding where
+ * the batch ends and which device created it, and snapshots named by their end. As the real remote, it creates a slot
+ * only where the history ends. Creating a slot is check-then-write,
+ * without the atomicity of the real remote across processes: for development and tests, with one process writing.
+ *
+ * ```text
+ * {root}/{session}/slots/{after}.json     { after, to, device, archive?, folded? }, written once
+ * {root}/{session}/batches/{after}.batch  the commits (or an archive), until folded
+ * {root}/{session}/snapshots/{to}.batch   a store archive
+ * {root}/{session}/meta.json             the host's description, last write wins
+ * ```
+ */
+export declare class FileSystemSyncRemote implements SessionSyncMaintenance {
+    #private;
+    constructor(fs: SyncFileSystem, root: string);
+    putBatch(sessionId: string, after: Seq, to: Seq, device: string, body: SyncBody, context: Context, options?: {
+        readonly archive?: boolean;
+    }): Promise<PutBatchResult>;
+    getBatch(sessionId: string, after: Seq, context: Context): Promise<SyncBody | undefined>;
+    getSnapshot(sessionId: string, to: Seq, context: Context): Promise<SyncBody | undefined>;
+    putSnapshot(sessionId: string, to: Seq, body: SyncBody, context: Context): Promise<void>;
+    foldBatches(sessionId: string, afters: readonly Seq[], context: Context): Promise<void>;
+    deleteSnapshots(sessionId: string, snapshots: readonly Seq[], context: Context): Promise<void>;
+    list(sessionId: string, context: Context): Promise<RemoteListing>;
+    /** Every session, every time: a directory keeps no change order. */
+    sessions(_cursor: string | undefined, context: Context): Promise<SessionChanges>;
+    putMeta(sessionId: string, meta: JsonObject, context: Context): Promise<void>;
+    getMeta(sessionId: string, context: Context): Promise<JsonObject | undefined>;
+}
+//# sourceMappingURL=filesystem.d.ts.map

package/dist/sync/filesystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../src/sync/filesystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAc,KAAK,cAAc,EAAU,MAAM,YAAY,CAAC;AACrE,OAAO,EAEN,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,aAAa,EAElB,KAAK,GAAG,EACR,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,MAAM,aAAa,CAAC;AAcrB,yFAAyF;AACzF,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAGxD;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,oBAAqB,YAAW,sBAAsB;;IAIlE,YAAY,EAAE,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,EAG3C;IAEK,QAAQ,CACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,GAAG,EACV,EAAE,EAAE,GAAG,EACP,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE;QAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAO,GAC1C,OAAO,CAAC,cAAc,CAAC,CAgBzB;IAEK,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAI7F;IAED,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAEvF;IAEK,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAE7F;IAEK,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,EAAE,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAe5F;IAEK,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,GAAG,EAAE,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAKnG;IAEK,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CActE;IAED,oEAAoE;IAC9D,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC,CAiBrF;IAEK,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAElF;IAEK,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAGlF;CAuED"}