wire-mesh-core 1.30.0 → 1.30.1

package/dist/adapters/node-fs-storage.cjs

@@ -0,0 +1,81 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+//#region src/adapters/node-fs-storage.ts
+/** A Node filesystem-backed KeyValueStorage -- the durable Node-side counterpart to indexeddb-storage.ts's browser one, and memory-storage.ts's in-process one, satisfying the identical contract. Every key is treated directly as a relative path under the given directory (creating nested directories as needed), which every key this codebase constructs is already suited to: internally generated, ASCII, path-shaped by design (e.g. "data/<peer-hex>/entry/<seq>") rather than arbitrary untrusted input, matching the same assumption indexeddb-storage.ts's own comment already states for its key range bounds. */
+function isEnoent(error) {
+	if (!(error instanceof Error)) return false;
+	if (!("code" in error)) return false;
+	return error.code === "ENOENT";
+}
+function keyToFilePath(baseDir, key) {
+	return node_path.join(baseDir, key);
+}
+/** Every regular file under baseDir, as a relative path using "/" separators regardless of the host OS -- so a caller's own "/"-joined key strings compare correctly against what this returns, the same key shape set()/get() already use. */
+async function listAllRelativePaths(baseDir) {
+	let entries;
+	try {
+		entries = await node_fs_promises.readdir(baseDir, { recursive: true });
+	} catch (error) {
+		if (isEnoent(error)) return [];
+		throw error;
+	}
+	const files = [];
+	for (const entry of entries) if ((await node_fs_promises.stat(node_path.join(baseDir, entry)).catch(() => null))?.isFile() === true) files.push(entry.split(node_path.sep).join("/"));
+	return files;
+}
+function createNodeFsStorage(options) {
+	const baseDir = options.dir;
+	return {
+		async get(key) {
+			try {
+				const contents = await node_fs_promises.readFile(keyToFilePath(baseDir, key));
+				return new Uint8Array(contents);
+			} catch (error) {
+				if (isEnoent(error)) return void 0;
+				throw error;
+			}
+		},
+		async set(key, value) {
+			const filePath = keyToFilePath(baseDir, key);
+			await node_fs_promises.mkdir(node_path.dirname(filePath), { recursive: true });
+			await node_fs_promises.writeFile(filePath, value);
+		},
+		async delete(key) {
+			try {
+				await node_fs_promises.unlink(keyToFilePath(baseDir, key));
+			} catch (error) {
+				if (!isEnoent(error)) throw error;
+			}
+		},
+		async keys(prefix) {
+			return (await listAllRelativePaths(baseDir)).filter((key) => key.startsWith(prefix));
+		}
+	};
+}
+//#endregion
+exports.createNodeFsStorage = createNodeFsStorage;

package/dist/adapters/node-fs-storage.d.cts

@@ -0,0 +1,8 @@
+import { KeyValueStorage } from "../ports/storage.cjs";
+//#region src/adapters/node-fs-storage.d.ts
+export interface NodeFsStorageOptions {
+  /** Directory to store entries under. Created on first write if it doesn't already exist. */
+  dir: string;
+}
+export declare function createNodeFsStorage(options: Readonly<NodeFsStorageOptions>): KeyValueStorage;
+//#endregion

package/dist/adapters/node-fs-storage.d.mts

@@ -0,0 +1,8 @@
+import { KeyValueStorage } from "../ports/storage.mjs";
+//#region src/adapters/node-fs-storage.d.ts
+export interface NodeFsStorageOptions {
+  /** Directory to store entries under. Created on first write if it doesn't already exist. */
+  dir: string;
+}
+export declare function createNodeFsStorage(options: Readonly<NodeFsStorageOptions>): KeyValueStorage;
+//#endregion

package/dist/adapters/node-fs-storage.mjs

@@ -0,0 +1,56 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+//#region src/adapters/node-fs-storage.ts
+/** A Node filesystem-backed KeyValueStorage -- the durable Node-side counterpart to indexeddb-storage.ts's browser one, and memory-storage.ts's in-process one, satisfying the identical contract. Every key is treated directly as a relative path under the given directory (creating nested directories as needed), which every key this codebase constructs is already suited to: internally generated, ASCII, path-shaped by design (e.g. "data/<peer-hex>/entry/<seq>") rather than arbitrary untrusted input, matching the same assumption indexeddb-storage.ts's own comment already states for its key range bounds. */
+function isEnoent(error) {
+	if (!(error instanceof Error)) return false;
+	if (!("code" in error)) return false;
+	return error.code === "ENOENT";
+}
+function keyToFilePath(baseDir, key) {
+	return path.join(baseDir, key);
+}
+/** Every regular file under baseDir, as a relative path using "/" separators regardless of the host OS -- so a caller's own "/"-joined key strings compare correctly against what this returns, the same key shape set()/get() already use. */
+async function listAllRelativePaths(baseDir) {
+	let entries;
+	try {
+		entries = await fs.readdir(baseDir, { recursive: true });
+	} catch (error) {
+		if (isEnoent(error)) return [];
+		throw error;
+	}
+	const files = [];
+	for (const entry of entries) if ((await fs.stat(path.join(baseDir, entry)).catch(() => null))?.isFile() === true) files.push(entry.split(path.sep).join("/"));
+	return files;
+}
+function createNodeFsStorage(options) {
+	const baseDir = options.dir;
+	return {
+		async get(key) {
+			try {
+				const contents = await fs.readFile(keyToFilePath(baseDir, key));
+				return new Uint8Array(contents);
+			} catch (error) {
+				if (isEnoent(error)) return void 0;
+				throw error;
+			}
+		},
+		async set(key, value) {
+			const filePath = keyToFilePath(baseDir, key);
+			await fs.mkdir(path.dirname(filePath), { recursive: true });
+			await fs.writeFile(filePath, value);
+		},
+		async delete(key) {
+			try {
+				await fs.unlink(keyToFilePath(baseDir, key));
+			} catch (error) {
+				if (!isEnoent(error)) throw error;
+			}
+		},
+		async keys(prefix) {
+			return (await listAllRelativePaths(baseDir)).filter((key) => key.startsWith(prefix));
+		}
+	};
+}
+//#endregion
+export { createNodeFsStorage };

package/dist/domain/data-sync.cjs

@@ -0,0 +1,109 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_domain_device_id = require("./device-id.cjs");
+//#region src/domain/data-sync.ts
+function headKey(peer) {
+	return `data/${require_domain_device_id.deviceIdToHex(peer)}/head`;
+}
+function entryKey(peer, seq) {
+	return `data/${require_domain_device_id.deviceIdToHex(peer)}/entry/${String(seq)}`;
+}
+async function readHeadSeq(storage, peer) {
+	const raw = await storage.get(headKey(peer));
+	if (raw === void 0) return 0;
+	return Number(new TextDecoder().decode(raw));
+}
+async function writeHeadSeq(storage, peer, seq) {
+	await storage.set(headKey(peer), new TextEncoder().encode(String(seq)));
+}
+/**
+* The current head-seq this store holds for `peer`'s log -- own log if peer is this device's own identity, a replicated peer's log otherwise (any store may hold and answer for a peer's log, per data-domain.cddl's own fan-out rule; nothing here distinguishes "my own log" from "a replica I'm holding"). 0 means nothing is held yet.
+*/
+async function headSeqFor(storage, peer) {
+	return readHeadSeq(storage, peer);
+}
+/**
+* Appends one entry to this identity's own oplog and returns both the new sequence and the data-have frame announcing it. Only manages the local append and head-seq bookkeeping -- the caller decides when and to which peers to actually send the returned frame (proactively on every append, batched, on a timer, or not at all), the same "primitive vs. policy" split sendDirectManageRequest already draws for the manage-request path.
+*/
+async function appendOwnEntry(options, entry) {
+	const seq = await readHeadSeq(options.storage, options.identity.deviceId) + 1;
+	await options.storage.set(entryKey(options.identity.deviceId, seq), entry);
+	await writeHeadSeq(options.storage, options.identity.deviceId, seq);
+	return {
+		seq,
+		haveFrame: {
+			type: "data-have",
+			peer: options.identity.deviceId,
+			"head-seq": seq
+		}
+	};
+}
+/**
+* Handles an incoming data-have: null if this store already holds `frame.peer`'s log up to or past the announced head-seq (nothing to do), otherwise the data-request that would catch it up from its own current head. Whether to actually send that request -- whether this store tracks `frame.peer`'s log at all -- is the caller's own policy; this function only ever answers "would catching up mean anything right now", never "do I want to".
+*/
+async function handleDataHave(storage, frame) {
+	const ourHead = await readHeadSeq(storage, frame.peer);
+	if (ourHead >= frame["head-seq"]) return null;
+	return {
+		type: "data-request",
+		peer: frame.peer,
+		"from-seq": ourHead
+	};
+}
+/**
+* Handles an incoming data-request: the entries this store actually holds for `frame.peer` after `frame["from-seq"]`, capped at `limit`, or null if it holds none past that point. The responder need not be `frame.peer` itself -- any peer holding a replica may answer on the original author's behalf, per data-domain.cddl's own fan-out rule; this function makes no distinction.
+*/
+async function handleDataRequest(storage, frame, limit) {
+	const ourHead = await readHeadSeq(storage, frame.peer);
+	if (ourHead <= frame["from-seq"]) return null;
+	const lastSeq = Math.min(ourHead, frame["from-seq"] + limit);
+	const entries = [];
+	for (let seq = frame["from-seq"] + 1; seq <= lastSeq; seq += 1) {
+		const entry = await storage.get(entryKey(frame.peer, seq));
+		if (entry === void 0) break;
+		entries.push(entry);
+	}
+	if (entries.length === 0) return null;
+	return {
+		type: "data-entries",
+		peer: frame.peer,
+		"from-seq": frame["from-seq"],
+		entries
+	};
+}
+/**
+* Handles an incoming data-entries: persists the given entries starting right after from-seq, but ONLY when from-seq exactly matches this store's own current head for `frame.peer` -- data-domain.cddl's own gap-rejection obligation. A mismatch covers both directions: from-seq ahead of our head is a real gap (we're missing something in between); from-seq behind our head is a stale or replayed response we've already applied. Either way the caller's own retry path is the same -- re-issue a data-request from this store's own current headSeqFor(peer), which handleDataHave already computes correctly on the next data-have it sees.
+*/
+async function handleDataEntries(storage, frame) {
+	const ourHead = await readHeadSeq(storage, frame.peer);
+	if (frame["from-seq"] !== ourHead) return {
+		ok: false,
+		reason: "gap"
+	};
+	let seq = frame["from-seq"];
+	for (const entry of frame.entries) {
+		seq += 1;
+		await storage.set(entryKey(frame.peer, seq), entry);
+	}
+	await writeHeadSeq(storage, frame.peer, seq);
+	return { ok: true };
+}
+/**
+* Entries this store holds for `peer` after `fromSeqExclusive`, in sequence order -- the local read-side counterpart to appendOwnEntry/handleDataEntries, for a caller replaying a log directly (e.g. an application rendering history) rather than syncing it over the wire.
+*/
+async function readEntries(storage, peer, fromSeqExclusive) {
+	const head = await readHeadSeq(storage, peer);
+	const entries = [];
+	for (let seq = fromSeqExclusive + 1; seq <= head; seq += 1) {
+		const entry = await storage.get(entryKey(peer, seq));
+		if (entry === void 0) break;
+		entries.push(entry);
+	}
+	return entries;
+}
+//#endregion
+exports.appendOwnEntry = appendOwnEntry;
+exports.handleDataEntries = handleDataEntries;
+exports.handleDataHave = handleDataHave;
+exports.handleDataRequest = handleDataRequest;
+exports.headSeqFor = headSeqFor;
+exports.readEntries = readEntries;

package/dist/domain/data-sync.d.cts

@@ -0,0 +1,42 @@
+import { D as DeviceId, E as DataRequestFrame, T as DataHaveFrame, w as DataEntriesFrame } from "../protocol-sW8d6Og-.cjs";
+import { KeyValueStorage } from "../ports/storage.cjs";
+import { t as IdentityPort } from "../identity-DJ06jn4k.cjs";
+//#region src/domain/data-sync.d.ts
+export interface DataSyncOptions {
+  identity: IdentityPort;
+  storage: KeyValueStorage;
+}
+/**
+ * The current head-seq this store holds for `peer`'s log -- own log if peer is this device's own identity, a replicated peer's log otherwise (any store may hold and answer for a peer's log, per data-domain.cddl's own fan-out rule; nothing here distinguishes "my own log" from "a replica I'm holding"). 0 means nothing is held yet.
+ */
+export declare function headSeqFor(storage: Readonly<KeyValueStorage>, peer: DeviceId): Promise<number>;
+/**
+ * Appends one entry to this identity's own oplog and returns both the new sequence and the data-have frame announcing it. Only manages the local append and head-seq bookkeeping -- the caller decides when and to which peers to actually send the returned frame (proactively on every append, batched, on a timer, or not at all), the same "primitive vs. policy" split sendDirectManageRequest already draws for the manage-request path.
+ */
+export declare function appendOwnEntry(options: Readonly<DataSyncOptions>, entry: Uint8Array<ArrayBuffer>): Promise<{
+  seq: number;
+  haveFrame: DataHaveFrame;
+}>;
+/**
+ * Handles an incoming data-have: null if this store already holds `frame.peer`'s log up to or past the announced head-seq (nothing to do), otherwise the data-request that would catch it up from its own current head. Whether to actually send that request -- whether this store tracks `frame.peer`'s log at all -- is the caller's own policy; this function only ever answers "would catching up mean anything right now", never "do I want to".
+ */
+export declare function handleDataHave(storage: Readonly<KeyValueStorage>, frame: Readonly<DataHaveFrame>): Promise<DataRequestFrame | null>;
+/**
+ * Handles an incoming data-request: the entries this store actually holds for `frame.peer` after `frame["from-seq"]`, capped at `limit`, or null if it holds none past that point. The responder need not be `frame.peer` itself -- any peer holding a replica may answer on the original author's behalf, per data-domain.cddl's own fan-out rule; this function makes no distinction.
+ */
+export declare function handleDataRequest(storage: Readonly<KeyValueStorage>, frame: Readonly<DataRequestFrame>, limit: number): Promise<DataEntriesFrame | null>;
+export type HandleDataEntriesResult = {
+  ok: true;
+} | {
+  ok: false;
+  reason: "gap";
+};
+/**
+ * Handles an incoming data-entries: persists the given entries starting right after from-seq, but ONLY when from-seq exactly matches this store's own current head for `frame.peer` -- data-domain.cddl's own gap-rejection obligation. A mismatch covers both directions: from-seq ahead of our head is a real gap (we're missing something in between); from-seq behind our head is a stale or replayed response we've already applied. Either way the caller's own retry path is the same -- re-issue a data-request from this store's own current headSeqFor(peer), which handleDataHave already computes correctly on the next data-have it sees.
+ */
+export declare function handleDataEntries(storage: Readonly<KeyValueStorage>, frame: Readonly<DataEntriesFrame>): Promise<HandleDataEntriesResult>;
+/**
+ * Entries this store holds for `peer` after `fromSeqExclusive`, in sequence order -- the local read-side counterpart to appendOwnEntry/handleDataEntries, for a caller replaying a log directly (e.g. an application rendering history) rather than syncing it over the wire.
+ */
+export declare function readEntries(storage: Readonly<KeyValueStorage>, peer: DeviceId, fromSeqExclusive: number): Promise<Uint8Array[]>;
+//#endregion

package/dist/domain/data-sync.d.mts

@@ -0,0 +1,42 @@
+import { D as DeviceId, E as DataRequestFrame, T as DataHaveFrame, w as DataEntriesFrame } from "../protocol-sW8d6Og-.mjs";
+import { KeyValueStorage } from "../ports/storage.mjs";
+import { t as IdentityPort } from "../identity-C5N86BPz.mjs";
+//#region src/domain/data-sync.d.ts
+export interface DataSyncOptions {
+  identity: IdentityPort;
+  storage: KeyValueStorage;
+}
+/**
+ * The current head-seq this store holds for `peer`'s log -- own log if peer is this device's own identity, a replicated peer's log otherwise (any store may hold and answer for a peer's log, per data-domain.cddl's own fan-out rule; nothing here distinguishes "my own log" from "a replica I'm holding"). 0 means nothing is held yet.
+ */
+export declare function headSeqFor(storage: Readonly<KeyValueStorage>, peer: DeviceId): Promise<number>;
+/**
+ * Appends one entry to this identity's own oplog and returns both the new sequence and the data-have frame announcing it. Only manages the local append and head-seq bookkeeping -- the caller decides when and to which peers to actually send the returned frame (proactively on every append, batched, on a timer, or not at all), the same "primitive vs. policy" split sendDirectManageRequest already draws for the manage-request path.
+ */
+export declare function appendOwnEntry(options: Readonly<DataSyncOptions>, entry: Uint8Array<ArrayBuffer>): Promise<{
+  seq: number;
+  haveFrame: DataHaveFrame;
+}>;
+/**
+ * Handles an incoming data-have: null if this store already holds `frame.peer`'s log up to or past the announced head-seq (nothing to do), otherwise the data-request that would catch it up from its own current head. Whether to actually send that request -- whether this store tracks `frame.peer`'s log at all -- is the caller's own policy; this function only ever answers "would catching up mean anything right now", never "do I want to".
+ */
+export declare function handleDataHave(storage: Readonly<KeyValueStorage>, frame: Readonly<DataHaveFrame>): Promise<DataRequestFrame | null>;
+/**
+ * Handles an incoming data-request: the entries this store actually holds for `frame.peer` after `frame["from-seq"]`, capped at `limit`, or null if it holds none past that point. The responder need not be `frame.peer` itself -- any peer holding a replica may answer on the original author's behalf, per data-domain.cddl's own fan-out rule; this function makes no distinction.
+ */
+export declare function handleDataRequest(storage: Readonly<KeyValueStorage>, frame: Readonly<DataRequestFrame>, limit: number): Promise<DataEntriesFrame | null>;
+export type HandleDataEntriesResult = {
+  ok: true;
+} | {
+  ok: false;
+  reason: "gap";
+};
+/**
+ * Handles an incoming data-entries: persists the given entries starting right after from-seq, but ONLY when from-seq exactly matches this store's own current head for `frame.peer` -- data-domain.cddl's own gap-rejection obligation. A mismatch covers both directions: from-seq ahead of our head is a real gap (we're missing something in between); from-seq behind our head is a stale or replayed response we've already applied. Either way the caller's own retry path is the same -- re-issue a data-request from this store's own current headSeqFor(peer), which handleDataHave already computes correctly on the next data-have it sees.
+ */
+export declare function handleDataEntries(storage: Readonly<KeyValueStorage>, frame: Readonly<DataEntriesFrame>): Promise<HandleDataEntriesResult>;
+/**
+ * Entries this store holds for `peer` after `fromSeqExclusive`, in sequence order -- the local read-side counterpart to appendOwnEntry/handleDataEntries, for a caller replaying a log directly (e.g. an application rendering history) rather than syncing it over the wire.
+ */
+export declare function readEntries(storage: Readonly<KeyValueStorage>, peer: DeviceId, fromSeqExclusive: number): Promise<Uint8Array[]>;
+//#endregion

package/dist/domain/data-sync.mjs

@@ -0,0 +1,103 @@
+import { deviceIdToHex } from "./device-id.mjs";
+//#region src/domain/data-sync.ts
+function headKey(peer) {
+	return `data/${deviceIdToHex(peer)}/head`;
+}
+function entryKey(peer, seq) {
+	return `data/${deviceIdToHex(peer)}/entry/${String(seq)}`;
+}
+async function readHeadSeq(storage, peer) {
+	const raw = await storage.get(headKey(peer));
+	if (raw === void 0) return 0;
+	return Number(new TextDecoder().decode(raw));
+}
+async function writeHeadSeq(storage, peer, seq) {
+	await storage.set(headKey(peer), new TextEncoder().encode(String(seq)));
+}
+/**
+* The current head-seq this store holds for `peer`'s log -- own log if peer is this device's own identity, a replicated peer's log otherwise (any store may hold and answer for a peer's log, per data-domain.cddl's own fan-out rule; nothing here distinguishes "my own log" from "a replica I'm holding"). 0 means nothing is held yet.
+*/
+async function headSeqFor(storage, peer) {
+	return readHeadSeq(storage, peer);
+}
+/**
+* Appends one entry to this identity's own oplog and returns both the new sequence and the data-have frame announcing it. Only manages the local append and head-seq bookkeeping -- the caller decides when and to which peers to actually send the returned frame (proactively on every append, batched, on a timer, or not at all), the same "primitive vs. policy" split sendDirectManageRequest already draws for the manage-request path.
+*/
+async function appendOwnEntry(options, entry) {
+	const seq = await readHeadSeq(options.storage, options.identity.deviceId) + 1;
+	await options.storage.set(entryKey(options.identity.deviceId, seq), entry);
+	await writeHeadSeq(options.storage, options.identity.deviceId, seq);
+	return {
+		seq,
+		haveFrame: {
+			type: "data-have",
+			peer: options.identity.deviceId,
+			"head-seq": seq
+		}
+	};
+}
+/**
+* Handles an incoming data-have: null if this store already holds `frame.peer`'s log up to or past the announced head-seq (nothing to do), otherwise the data-request that would catch it up from its own current head. Whether to actually send that request -- whether this store tracks `frame.peer`'s log at all -- is the caller's own policy; this function only ever answers "would catching up mean anything right now", never "do I want to".
+*/
+async function handleDataHave(storage, frame) {
+	const ourHead = await readHeadSeq(storage, frame.peer);
+	if (ourHead >= frame["head-seq"]) return null;
+	return {
+		type: "data-request",
+		peer: frame.peer,
+		"from-seq": ourHead
+	};
+}
+/**
+* Handles an incoming data-request: the entries this store actually holds for `frame.peer` after `frame["from-seq"]`, capped at `limit`, or null if it holds none past that point. The responder need not be `frame.peer` itself -- any peer holding a replica may answer on the original author's behalf, per data-domain.cddl's own fan-out rule; this function makes no distinction.
+*/
+async function handleDataRequest(storage, frame, limit) {
+	const ourHead = await readHeadSeq(storage, frame.peer);
+	if (ourHead <= frame["from-seq"]) return null;
+	const lastSeq = Math.min(ourHead, frame["from-seq"] + limit);
+	const entries = [];
+	for (let seq = frame["from-seq"] + 1; seq <= lastSeq; seq += 1) {
+		const entry = await storage.get(entryKey(frame.peer, seq));
+		if (entry === void 0) break;
+		entries.push(entry);
+	}
+	if (entries.length === 0) return null;
+	return {
+		type: "data-entries",
+		peer: frame.peer,
+		"from-seq": frame["from-seq"],
+		entries
+	};
+}
+/**
+* Handles an incoming data-entries: persists the given entries starting right after from-seq, but ONLY when from-seq exactly matches this store's own current head for `frame.peer` -- data-domain.cddl's own gap-rejection obligation. A mismatch covers both directions: from-seq ahead of our head is a real gap (we're missing something in between); from-seq behind our head is a stale or replayed response we've already applied. Either way the caller's own retry path is the same -- re-issue a data-request from this store's own current headSeqFor(peer), which handleDataHave already computes correctly on the next data-have it sees.
+*/
+async function handleDataEntries(storage, frame) {
+	const ourHead = await readHeadSeq(storage, frame.peer);
+	if (frame["from-seq"] !== ourHead) return {
+		ok: false,
+		reason: "gap"
+	};
+	let seq = frame["from-seq"];
+	for (const entry of frame.entries) {
+		seq += 1;
+		await storage.set(entryKey(frame.peer, seq), entry);
+	}
+	await writeHeadSeq(storage, frame.peer, seq);
+	return { ok: true };
+}
+/**
+* Entries this store holds for `peer` after `fromSeqExclusive`, in sequence order -- the local read-side counterpart to appendOwnEntry/handleDataEntries, for a caller replaying a log directly (e.g. an application rendering history) rather than syncing it over the wire.
+*/
+async function readEntries(storage, peer, fromSeqExclusive) {
+	const head = await readHeadSeq(storage, peer);
+	const entries = [];
+	for (let seq = fromSeqExclusive + 1; seq <= head; seq += 1) {
+		const entry = await storage.get(entryKey(peer, seq));
+		if (entry === void 0) break;
+		entries.push(entry);
+	}
+	return entries;
+}
+//#endregion
+export { appendOwnEntry, handleDataEntries, handleDataHave, handleDataRequest, headSeqFor, readEntries };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wire-mesh-core",
-  "version": "1.30.0",
+  "version": "1.30.1",
   "type": "module",
   "packageManager": "pnpm@12.4.1+sha512.2e81e399d73fe8390dab25e06aa788ab7a5908248d2f5a370f82b481147a6a7a367bf8048f9a6fdb6460f21a66f0542dedb8b94ca2c8723596741920b1656d4c",
   "repository": {
@@ -70,6 +70,10 @@
       "import": "./dist/adapters/memory-storage.mjs",
       "require": "./dist/adapters/memory-storage.cjs"
     },
+    "./adapters/node-fs-storage": {
+      "import": "./dist/adapters/node-fs-storage.mjs",
+      "require": "./dist/adapters/node-fs-storage.cjs"
+    },
     "./adapters/node-identity": {
       "import": "./dist/adapters/node-identity.mjs",
       "require": "./dist/adapters/node-identity.cjs"
@@ -98,6 +102,10 @@
       "import": "./dist/domain/capability-request.mjs",
       "require": "./dist/domain/capability-request.cjs"
     },
+    "./domain/data-sync": {
+      "import": "./dist/domain/data-sync.mjs",
+      "require": "./dist/domain/data-sync.cjs"
+    },
     "./domain/device-id": {
       "import": "./dist/domain/device-id.mjs",
       "require": "./dist/domain/device-id.cjs"