@solarpunkltd/swarm-chat-js 7.1.0 → 7.2.0

package/dist/index.js

@@ -1,7 +1,7 @@
-import { ChatMessageError as e, MAX_ENTRY_BYTES as t, MAX_MESSAGE_BYTES as n, MAX_NAME_CHARACTERS as r, MAX_TEXT_CHARACTERS as i, MAX_TOPIC_CHARACTERS as a, MESSAGE_VERSION as o, MessageType as s, chatMessageSchema as c, checkChatMessage as l, countCharacters as u, createChatMessage as d, encodeChatMessage as f, feedEntrySchema as p, hasValidSignature as m, historyFileSchema as h, historyLinkSchema as g, historyRowSchema as _, newMessageId as v, parseChatMessage as y, parseFeedEntry as b, parseHistoryFile as x, signedBytes as S } from "./message.js";
-import { Bee as C, BeeResponseError as w, Identifier as T, PrivateKey as E, Topic as D } from "@ethersphere/bee-js";
+import { ChatMessageError as e, DEFAULT_NOTE_HEARTBEAT_MS as t, DEFAULT_NOTE_SLOT_MS as n, MAX_ENTRY_BYTES as r, MAX_MESSAGE_BYTES as i, MAX_NAME_CHARACTERS as a, MAX_NOTE_BYTES as o, MAX_TEXT_CHARACTERS as s, MAX_TOPIC_CHARACTERS as c, MESSAGE_VERSION as l, MessageType as u, NOTE_VERSION as d, chatMessageSchema as f, checkChatMessage as p, countCharacters as m, createChatMessage as h, encodeChatMessage as g, encodeSlotNote as _, feedEntrySchema as v, hasValidSignature as ee, historyFileSchema as te, historyLinkSchema as y, historyRowSchema as ne, newMessageId as b, noteAddress as x, noteIdentifier as S, noteIdentifierText as C, noteSlotEnd as w, noteSlotOf as T, parseChatMessage as E, parseFeedEntry as D, parseHistoryFile as O, parseSlotNote as k, signedBytes as A, slotNoteSchema as re } from "./message.js";
+import { Bee as j, BeeResponseError as M, Identifier as N, PrivateKey as P, Topic as F } from "@ethersphere/bee-js";
 //#region src/events.ts
-var O = {
+var I = {
 	LOADING_INIT: "loadingInit",
 	LOADING_PREVIOUS_MESSAGES: "loadingPreviousMessages",
 	MESSAGE_RECEIVED: "messageReceived",
@@ -13,13 +13,13 @@ var O = {
 	MESSAGE_SKIPPED: "messageSkipped",
 	ERROR: "error"
 };
-function k(e) {
-	return j(e, -1, e.ts);
+function L(e) {
+	return z(e, -1, e.ts);
 }
-function A(e) {
-	return j(e.msg, e.seq, e.at);
+function R(e) {
+	return z(e.msg, e.seq, e.at);
 }
-function j(e, t, n) {
+function z(e, t, n) {
 	return {
 		id: e.id,
 		type: e.type,
@@ -34,7 +34,7 @@ function j(e, t, n) {
 		sentAt: e.ts
 	};
 }
-var M = class {
+var B = class {
 	constructor() {
 		this.listeners = /* @__PURE__ */ new Map(), this.on = (e, t) => {
 			this.listeners.set(e, [...this.listeners.get(e) ?? [], t]);
@@ -51,65 +51,66 @@ var M = class {
 			console.error(`a listener for ${e} threw`, t);
 		}
 	}
-}, N = class extends Error {
+}, V = class extends Error {
 	constructor(e) {
 		super("the feed head lookup did not answer in time", e), this.name = "HeadLookupTimeoutError";
 	}
-}, P = class extends Error {
+}, H = class extends Error {
 	constructor(e, t) {
 		super(`feed slot ${e} was served but could not be read`, t), this.index = e, this.name = "UnreadableSlotError";
 	}
 };
-function F(e) {
-	return e instanceof w && (e.status === 404 || e.status === 500);
+function U(e) {
+	return e instanceof M && (e.status === 404 || e.status === 500);
 }
-async function I(e, t) {
+async function W(e, t) {
 	try {
 		return await t();
 	} catch (t) {
-		if (F(t)) return null;
-		throw t instanceof w ? t : new P(e, { cause: t });
+		if (U(t)) return null;
+		throw t instanceof M ? t : new H(e, { cause: t });
 	}
 }
-function L(e, t, n, r) {
-	let i = D.fromString(n), a = (n) => e.feed.makeReader(i, t, R(n));
+function G(e, t, r, i, a = n) {
+	let o = F.fromString(r), s = (n) => e.feed.makeReader(o, t, K(n));
 	return {
-		readSlot: (e) => I(e, async () => (await a(r.slotReadMs).downloadPayload({ index: e })).payload.toUint8Array()),
+		readNote: (n) => W(n, async () => (await e.soc.makeReader(t, K(i.slotReadMs)).download(S(r, a, n))).payload.toUint8Array()),
+		readSlot: (e) => W(e, async () => (await s(i.slotReadMs).downloadPayload({ index: e })).payload.toUint8Array()),
 		async readHead() {
-			let n = R(r.feedReadMs);
+			let n = K(i.feedReadMs);
 			try {
-				let { payload: r, feedIndex: a } = await e.feed.makeReader(i, t, n).downloadPayload();
+				let { payload: r, feedIndex: i } = await e.feed.makeReader(o, t, n).downloadPayload();
 				return {
-					index: Number(a.toBigInt()),
+					index: Number(i.toBigInt()),
 					payload: r.toUint8Array()
 				};
 			} catch (e) {
-				if (F(e)) return null;
-				throw n.signal?.aborted ? new N({ cause: e }) : e;
+				if (U(e)) return null;
+				throw n.signal?.aborted ? new V({ cause: e }) : e;
 			}
 		},
 		async readFile(t) {
-			return (await e.data.download(t, void 0, R(r.feedReadMs))).toUint8Array();
+			return (await e.data.download(t, void 0, K(i.feedReadMs))).toUint8Array();
 		}
 	};
 }
-function R(e) {
+function K(e) {
 	return { signal: AbortSignal.timeout(e) };
 }
-var z = "0123456789abcdef".repeat(4);
-function B(e, t, n, r, i) {
-	let a = new E(n), o = T.fromString(r);
+var ie = "0123456789abcdef".repeat(4);
+function q(e, t, n, r, i) {
+	let a = new P(n), o = N.fromString(r);
 	return async (n) => {
-		await e.messaging.gsocSend(t, a, o, n, { deferred: !1 }, R(i.writeMs));
+		await e.messaging.gsocSend(t, a, o, n, { deferred: !1 }, K(i.writeMs));
 	};
 }
 //#endregion
 //#region src/follower.ts
-var V = {
+var J = {
 	LIVE: "live",
 	RECONNECTING: "reconnecting",
 	STALLED: "stalled"
-}, H = {
+}, Y = {
 	pollIntervalMs: 1e3,
 	maxSlotsPerPoll: 16,
 	unservedPollsBeforeProbe: 3,
@@ -128,14 +129,14 @@ var V = {
 	stallAfterMs: 8e3,
 	random: Math.random,
 	now: Date.now
-}, U = class extends Error {
+}, X = class extends Error {
 	constructor(e) {
 		super(`the gateway keeps answering feed slot ${e} with something that is not a chunk`), this.index = e, this.name = "UnreadableGatewayError";
 	}
-}, W = class {
-	constructor(e, t, n, r = {}) {
-		this.source = e, this.topic = t, this.events = n, this.next = 0, this.unservedPolls = 0, this.nextProbeAt = 0, this.unreadablePolls = 0, this.gatewayFailures = 0, this.missed = /* @__PURE__ */ new Map(), this.timer = null, this.generation = 0, this.running = !1, this.status = null, this.settings = {
-			...H,
+}, ae = class {
+	constructor(e, t, n, r = {}, i = null) {
+		this.source = e, this.topic = t, this.events = n, this.notes = i, this.next = 0, this.ceiling = null, this.nextNoteSlot = 0, this.lastNoteFoundAt = 0, this.unservedPolls = 0, this.nextProbeAt = 0, this.unreadablePolls = 0, this.gatewayFailures = 0, this.missed = /* @__PURE__ */ new Map(), this.timer = null, this.generation = 0, this.running = !1, this.status = null, this.settings = {
+			...Y,
 			...r
 		};
 	}
@@ -145,8 +146,11 @@ var V = {
 	get missedIndices() {
 		return [...this.missed.keys()];
 	}
-	start(e) {
-		this.stop(), this.next = e, this.resetRefusals(), this.unreadablePolls = 0, this.gatewayFailures = 0, this.missed.clear(), this.status = null, this.running = !0, this.schedule(0);
+	get ledByNotes() {
+		return this.ceiling !== null;
+	}
+	start(e, t = null) {
+		this.stop(), this.next = e, this.ceiling = t?.newest ?? null, this.nextNoteSlot = t?.nextNoteSlot ?? (this.notes ? this.notes.lastReadableSlot() + 1 : 0), this.lastNoteFoundAt = this.settings.now(), this.resetRefusals(), this.unreadablePolls = 0, this.gatewayFailures = 0, this.missed.clear(), this.status = null, this.running = !0, this.schedule(0);
 	}
 	stop() {
 		this.running = !1, this.generation++, this.timer &&= (clearTimeout(this.timer), null);
@@ -160,7 +164,7 @@ var V = {
 	async poll(e) {
 		let t = 0, n = !1;
 		try {
-			t = await this.walk(e), await this.readMissed(e);
+			this.notes !== null && await this.readDueNotes(this.notes, e), t = await this.walk(e), await this.readMissed(e);
 		} catch (t) {
 			n = !0, e === this.generation && this.gatewayFailed(t);
 		}
@@ -169,28 +173,49 @@ var V = {
 				this.schedule(this.backoffMs());
 				return;
 			}
-			this.gatewayAnswered(), this.schedule(t >= this.settings.maxSlotsPerPoll ? 0 : this.settings.pollIntervalMs);
+			this.gatewayAnswered(), this.schedule(t >= this.settings.maxSlotsPerPoll ? 0 : this.untilNextRead());
+		}
+	}
+	untilNextRead() {
+		return this.ceiling === null || this.notes === null ? this.settings.pollIntervalMs : Math.max(0, this.notes.readableAt(this.nextNoteSlot) - this.settings.now());
+	}
+	async readDueNotes(e, t) {
+		let n = this.settings.now(), r = e.lastReadableSlot(n);
+		if (r < this.nextNoteSlot) return;
+		let i = Math.max(this.nextNoteSlot, r - e.lookBackSlots + 1), a = await e.scan(r, i);
+		if (t === this.generation) {
+			if (this.nextNoteSlot = r + 1, a) {
+				this.lastNoteFoundAt = n, this.ceiling = Math.max(this.ceiling ?? -1, a.note.newest, this.next - 1);
+				return;
+			}
+			n - this.lastNoteFoundAt >= e.silenceMs && (this.lastNoteFoundAt = n, e.clock.distrust(), this.nextNoteSlot = Math.min(this.nextNoteSlot, e.lastReadableSlot(n) + 1));
 		}
 	}
 	async read(e) {
 		try {
 			return await this.source.readSlot(e);
 		} catch (e) {
-			if (e instanceof P) return "unreadable";
+			if (e instanceof H) return "unreadable";
 			throw e;
 		}
 	}
 	async walk(e) {
 		for (let t = 0; t < this.settings.maxSlotsPerPoll; t++) {
-			let n = this.next, r = await this.read(n);
+			let n = this.next;
+			if (this.ceiling !== null && n > this.ceiling) return t;
+			let r = await this.read(n);
 			if (e !== this.generation) return t;
+			if (this.ceiling !== null && (r === null || r === "unreadable")) {
+				this.remember(n), this.next = n + 1;
+				continue;
+			}
 			if (r === null || r === "unreadable") {
 				if (t === 0) {
 					if (this.unservedPolls++, this.unreadablePolls = r === "unreadable" ? this.unreadablePolls + 1 : 0, this.shouldProbe() && await this.probePast(n, e)) {
 						this.unreadablePolls = 0;
 						continue;
 					}
-					if (this.unreadablePolls >= this.settings.unreadablePollsBeforeFailure) throw new U(n);
+					if (this.unreadablePolls >= this.settings.unreadablePollsBeforeFailure) throw new X(n);
 				}
 				return t;
 			}
@@ -246,16 +271,16 @@ var V = {
 		}
 	}
 	accept(e, t) {
-		let n = b(t, e, this.topic);
-		n.ok ? this.events.entry(n.value) : this.events.skipped(e, n.reason, n.detail);
+		let n = D(t, e, this.topic);
+		n.ok ? (this.notes?.clock.observe(n.value.at, this.settings.now()), this.events.entry(n.value)) : this.events.skipped(e, n.reason, n.detail);
 	}
 	gatewayFailed(e) {
-		this.gatewayFailures++, this.setStatus(V.RECONNECTING), this.events.error(e);
+		this.gatewayFailures++, this.setStatus(J.RECONNECTING), this.events.error(e);
 	}
 	gatewayAnswered() {
 		this.gatewayFailures = 0;
 		let e = this.settings.now(), t = [...this.missed.values()].some((t) => e - t >= this.settings.stallAfterMs);
-		this.setStatus(t ? V.STALLED : V.LIVE);
+		this.setStatus(t ? J.STALLED : J.LIVE);
 	}
 	backoffMs() {
 		let { pollIntervalMs: e, backoffCapMs: t, random: n } = this.settings, r = Math.min(t, e * 2 ** this.gatewayFailures);
@@ -264,36 +289,52 @@ var V = {
 	setStatus(e) {
 		e !== this.status && (this.status = e, this.events.status(e));
 	}
-}, G = 16, K = class {
-	constructor(e, t, n) {
-		this.source = e, this.topic = t, this.events = n, this.older = null, this.loading = null;
+}, oe = 16, se = class {
+	constructor(e, t, n, r = null) {
+		this.source = e, this.topic = t, this.events = n, this.notes = r, this.older = null, this.loading = null;
 	}
 	async open() {
 		this.older = null;
-		let e = await this.readHead();
-		if (e === null) return {
+		let e = await this.newestNote();
+		if (e !== null) return this.openAt(e.newest, e);
+		let t = await this.readHead();
+		return t === null ? {
 			startAt: 0,
-			rows: []
+			rows: [],
+			notes: null
+		} : this.openAt(t.index, null, t.payload);
+	}
+	async newestNote() {
+		if (this.notes === null) return null;
+		let e = this.notes.lastReadableSlot(), t = await this.notes.scan(e, e - this.notes.lookBackSlots + 1);
+		return t === null ? null : {
+			newest: t.note.newest,
+			nextNoteSlot: e + 1
 		};
-		let t = await this.newestLink(e.index, e.payload);
-		if (t === null) return {
+	}
+	async openAt(e, t, n) {
+		let r = e < 0 ? null : await this.newestLink(e, n);
+		if (r === null) return {
 			startAt: 0,
-			rows: []
+			rows: [],
+			notes: t
 		};
-		let n = await this.readFile(t);
-		return n === "refused" ? {
+		let i = await this.readFile(r);
+		return i === "refused" ? {
 			startAt: 0,
-			rows: []
+			rows: [],
+			notes: t
 		} : {
-			startAt: t.toSeq + 1,
-			rows: n ?? []
+			startAt: r.toSeq + 1,
+			rows: i ?? [],
+			notes: t
 		};
 	}
 	async readHead() {
 		try {
 			return await this.source.readHead();
 		} catch (e) {
-			if (e instanceof N) return this.events.error(e), null;
+			if (e instanceof V) return this.events.error(e), null;
 			throw e;
 		}
 	}
@@ -308,27 +349,30 @@ var V = {
 	async loadOlderOnce() {
 		let e = this.older;
 		if (e === null) return [];
-		let t = await this.source.readFile(e.ref), n = x(t, this.topic, e);
+		let t = await this.source.readFile(e.ref), n = O(t, this.topic, e);
 		if (!n.ok) throw this.older = null, Error(`history file ${e.ref} refused (${n.reason}): ${n.detail}`);
 		return this.report(n.value.skipped), this.older = n.value.prev, n.value.rows;
 	}
 	async newestLink(e, t) {
-		let n = b(t, e, this.topic);
-		if (n.ok) return n.value.history;
-		for (let t = e - 1; t >= Math.max(0, e - G); t--) {
+		let n = t === void 0 ? e : e - 1;
+		if (t !== void 0) {
+			let n = D(t, e, this.topic);
+			if (n.ok) return n.value.history;
+		}
+		for (let t = n; t >= Math.max(0, e - oe); t--) {
 			let e = await this.source.readSlot(t).catch((e) => {
-				if (e instanceof P) return null;
+				if (e instanceof H) return null;
 				throw e;
 			});
 			if (e === null) continue;
-			let n = b(e, t, this.topic);
+			let n = D(e, t, this.topic);
 			if (n.ok) return n.value.history;
 		}
 		return null;
 	}
 	async readFile(e) {
 		try {
-			let t = x(await this.source.readFile(e.ref), this.topic, e);
+			let t = O(await this.source.readFile(e.ref), this.topic, e);
 			return t.ok ? (this.report(t.value.skipped), this.older = t.value.prev, t.value.rows) : (this.events.error(/* @__PURE__ */ Error(`history file ${e.ref} refused (${t.reason}): ${t.detail}`)), "refused");
 		} catch (t) {
 			return this.events.error(t), this.older = e, null;
@@ -337,20 +381,92 @@ var V = {
 	report(e) {
 		e > 0 && this.events.skipped(e);
 	}
-}, q = {
+}, ce = {
+	slotMs: n,
+	heartbeatMs: t,
+	marginMs: 1e3,
+	scanBatch: 4,
+	clockLimitMs: 3e5
+};
+function le(e) {
+	return typeof e.readNote == "function";
+}
+var ue = class {
+	constructor(e) {
+		this.limitMs = e, this.aheadAtMost = Infinity, this.trusted = !0;
+	}
+	observe(e, t) {
+		this.aheadAtMost = Math.min(this.aheadAtMost, t - e);
+	}
+	distrust() {
+		this.trusted = !1;
+	}
+	get isTrusted() {
+		return this.trusted;
+	}
+	get ms() {
+		let e = Number.isFinite(this.aheadAtMost), t = this.trusted || !e ? Math.min(0, this.aheadAtMost) : this.aheadAtMost;
+		return Math.max(-this.limitMs, Math.min(this.limitMs, t));
+	}
+}, Z = class {
+	constructor(e, t, n) {
+		this.source = e, this.now = n, this.counts = {
+			found: 0,
+			empty: 0
+		}, this.settings = {
+			...ce,
+			...t
+		}, this.clock = new ue(this.settings.clockLimitMs);
+	}
+	lastReadableSlot(e = this.now()) {
+		return T(e - this.settings.marginMs - this.clock.ms, this.settings.slotMs) - 1;
+	}
+	readableAt(e) {
+		return w(e, this.settings.slotMs) + this.settings.marginMs + this.clock.ms;
+	}
+	get lookBackSlots() {
+		return Math.ceil(this.settings.heartbeatMs / this.settings.slotMs) + 2;
+	}
+	get silenceMs() {
+		return this.settings.heartbeatMs + 2 * this.settings.slotMs + this.settings.marginMs;
+	}
+	async read(e) {
+		let t;
+		try {
+			t = await this.source.readNote(e);
+		} catch (e) {
+			if (!(e instanceof H)) throw e;
+			t = null;
+		}
+		let n = t === null ? null : k(t);
+		return n === null ? (this.counts.empty++, null) : (this.counts.found++, this.clock.observe(n.writtenAt, this.now()), n);
+	}
+	async scan(e, t) {
+		for (let n = e; n >= t; n -= this.settings.scanBatch) {
+			let e = [];
+			for (let r = n; r > n - this.settings.scanBatch && r >= t; r--) e.push(r);
+			let r = await Promise.all(e.map((e) => this.read(e))), i = r.findIndex((e) => e !== null);
+			if (i >= 0) return {
+				slot: e[i],
+				note: r[i]
+			};
+		}
+		return null;
+	}
+}, Q = {
 	resendAfterMs: 1e4,
 	maxResends: 5,
 	reactionWindowMs: 1e3,
 	isLive: () => !0
-}, J = class {
-	constructor(e, t, n, r, i = q) {
+}, de = class {
+	constructor(e, t, n, r, i = Q) {
 		this.key = e, this.name = t, this.write = n, this.events = r, this.settings = i, this.outgoing = /* @__PURE__ */ new Map(), this.reactions = /* @__PURE__ */ new Map(), this.stopped = !1;
 	}
 	get address() {
 		return this.key.publicKey().address().toHex();
 	}
 	send(e) {
-		let { message: t, bytes: n } = d(this.key, {
+		let { message: t, bytes: n } = h(this.key, {
 			...e,
 			name: this.name
 		}), r = {
@@ -378,7 +494,7 @@ var V = {
 			let i = this.reactions.get(r);
 			this.reactions.delete(r), i && i.taps % 2 == 1 && !this.stopped && this.send({
 				topic: e,
-				type: s.REACTION,
+				type: u.REACTION,
 				target: t,
 				text: n
 			});
@@ -429,49 +545,56 @@ var V = {
 	clearTimer(e) {
 		e.timer &&= (clearTimeout(e.timer), null);
 	}
-}, Y = [
+}, fe = [
 	1e3,
 	2e3,
 	4e3,
 	8e3
-], X = 3;
-function Z(e) {
+], pe = 3;
+function $(e) {
 	return (e.startsWith("0x") ? e.slice(2) : e).toLowerCase();
 }
-var Q = class {
+var me = class {
 	constructor(e, t = {}) {
-		this.emitter = new M(), this.seen = /* @__PURE__ */ new Set(), this.status = null, this.generation = 0, this.running = !1, this.starting = null, this.openTimer = null, this.wakeOpen = null;
+		this.emitter = new B(), this.seen = /* @__PURE__ */ new Set(), this.status = null, this.generation = 0, this.running = !1, this.starting = null, this.openTimer = null, this.wakeOpen = null;
 		let { user: n, infra: r } = e;
-		this.key = new E(Z(n.privateKey)), this.topic = r.chatTopic, this.nickname = n.nickname, this.openRetryMs = t.openRetryMs ?? Y, this.senderSettings = {
-			...q,
-			isLive: () => this.status === V.LIVE,
+		this.key = new P($(n.privateKey)), this.topic = r.chatTopic, this.nickname = n.nickname, this.openRetryMs = t.openRetryMs ?? fe, this.senderSettings = {
+			...Q,
+			isLive: () => this.status === J.LIVE,
 			...t.sender
 		};
 		let i = {
 			slotReadMs: r.socReadTimeout ?? 5e3,
 			feedReadMs: r.feedReadTimeout ?? 15e3,
 			writeMs: r.gsocWriteTimeout ?? 1e4
+		}, a = {
+			...r.noteSlotMs === void 0 ? {} : { slotMs: r.noteSlotMs },
+			...r.noteHeartbeatMs === void 0 ? {} : { heartbeatMs: r.noteHeartbeatMs },
+			...t.notes
 		};
-		this.source = t.source ?? L(new C(r.beeUrl), Z(r.chatAddress), r.chatTopic, i), this.write = t.write ?? B(new C(r.writeUrl ?? r.beeUrl), r.stamp ? Z(r.stamp) : z, Z(r.gsocResourceId), r.gsocTopic, i), this.follower = new W(this.source, this.topic, {
+		this.source = t.source ?? G(new j(r.beeUrl), $(r.chatAddress), r.chatTopic, i, a.slotMs), this.write = t.write ?? q(new j(r.writeUrl ?? r.beeUrl), r.stamp ? $(r.stamp) : ie, $(r.gsocResourceId), r.gsocTopic, i);
+		let o = t.follower?.now ?? (() => Date.now()), s = {
+			pollIntervalMs: r.pollingInterval ?? 1e3,
+			...t.follower,
+			now: o
+		}, c = this.source;
+		this.notes = le(c) ? new Z(c, a, o) : null, this.follower = new ae(this.source, this.topic, {
 			entry: (e) => this.show(e),
-			skipped: (e, t, n) => this.emitter.emit(O.MESSAGE_SKIPPED, {
+			skipped: (e, t, n) => this.emitter.emit(I.MESSAGE_SKIPPED, {
 				index: e,
 				reason: t,
 				detail: n
 			}),
 			status: (e) => this.setStatus(e),
-			error: (e) => this.emitter.emit(O.ERROR, e)
-		}, {
-			pollIntervalMs: r.pollingInterval ?? 1e3,
-			...t.follower
-		}), this.history = new K(this.source, this.topic, {
-			skipped: (e) => this.emitter.emit(O.MESSAGE_SKIPPED, {
+			error: (e) => this.emitter.emit(I.ERROR, e)
+		}, s, this.notes), this.history = new se(this.source, this.topic, {
+			skipped: (e) => this.emitter.emit(I.MESSAGE_SKIPPED, {
 				index: -1,
 				reason: "history-row",
 				detail: `${e} rows of a history file`
 			}),
-			error: (e) => this.emitter.emit(O.ERROR, e)
-		}), this.sender = this.makeSender();
+			error: (e) => this.emitter.emit(I.ERROR, e)
+		}, this.notes), this.sender = this.makeSender();
 	}
 	getEmitter() {
 		return this.emitter;
@@ -494,11 +617,11 @@ var Q = class {
 		this.running = !1, this.generation++, this.openTimer &&= (clearTimeout(this.openTimer), null), this.wakeOpen?.(), this.follower.stop(), this.sender.stop();
 	}
 	async sendMessage(e, t, n) {
-		if (t === s.REACTION) {
+		if (t === u.REACTION) {
 			if (!n) throw Error("a reaction names the message it reacts to");
 			return this.sender.react(this.topic, n, e), null;
 		}
-		return k(this.sender.send({
+		return L(this.sender.send({
 			topic: this.topic,
 			type: t,
 			target: n ?? "",
@@ -509,12 +632,12 @@ var Q = class {
 		return this.sender.retry(typeof e == "string" ? e : e.id);
 	}
 	async fetchPreviousMessages() {
-		this.emitter.emit(O.LOADING_PREVIOUS_MESSAGES, !0);
+		this.emitter.emit(I.LOADING_PREVIOUS_MESSAGES, !0);
 		try {
 			let e = this.generation, t = await this.history.loadOlder();
 			return e === this.generation ? this.showRows(t) : [];
 		} finally {
-			this.emitter.emit(O.LOADING_PREVIOUS_MESSAGES, !1);
+			this.emitter.emit(I.LOADING_PREVIOUS_MESSAGES, !1);
 		}
 	}
 	hasPreviousMessages() {
@@ -524,16 +647,16 @@ var Q = class {
 		return [...e].sort((e, t) => e.index >= 0 && t.index >= 0 ? e.index - t.index : e.index >= 0 || t.index >= 0 ? e.index >= 0 ? -1 : 1 : e.timestamp - t.timestamp);
 	}
 	async open(e) {
-		this.emitter.emit(O.LOADING_INIT, !0);
+		this.emitter.emit(I.LOADING_INIT, !0);
 		let t = 0;
 		for (; e === this.generation;) try {
 			let t = await this.history.open();
 			if (e !== this.generation) return;
-			this.showRows(t.rows), this.follower.start(t.startAt), this.emitter.emit(O.LOADING_INIT, !1);
+			this.showRows(t.rows), this.follower.start(t.startAt, t.notes), this.emitter.emit(I.LOADING_INIT, !1);
 			return;
 		} catch (n) {
 			if (e !== this.generation) return;
-			t++, this.emitter.emit(O.ERROR, n), this.setStatus(V.RECONNECTING), t === X && this.emitter.emit(O.CRITICAL_ERROR, n), await this.waitToOpen(this.openRetryMs[Math.min(t, this.openRetryMs.length) - 1] ?? 8e3);
+			t++, this.emitter.emit(I.ERROR, n), this.setStatus(J.RECONNECTING), t === pe && this.emitter.emit(I.CRITICAL_ERROR, n), await this.waitToOpen(this.openRetryMs[Math.min(t, this.openRetryMs.length) - 1] ?? 8e3);
 		}
 	}
 	waitToOpen(e) {
@@ -546,31 +669,31 @@ var Q = class {
 		});
 	}
 	makeSender() {
-		return new J(this.key, this.nickname, this.write, {
-			pending: (e) => this.emitter.emit(O.MESSAGE_REQUEST_INITIATED, k(e)),
-			written: (e) => this.emitter.emit(O.MESSAGE_REQUEST_UPLOADED, k(e)),
+		return new de(this.key, this.nickname, this.write, {
+			pending: (e) => this.emitter.emit(I.MESSAGE_REQUEST_INITIATED, L(e)),
+			written: (e) => this.emitter.emit(I.MESSAGE_REQUEST_UPLOADED, L(e)),
 			failed: (e, t) => {
-				this.emitter.emit(O.ERROR, t), this.emitter.emit(O.MESSAGE_REQUEST_ERROR, k(e));
+				this.emitter.emit(I.ERROR, t), this.emitter.emit(I.MESSAGE_REQUEST_ERROR, L(e));
 			},
 			confirmed: () => {}
 		}, this.senderSettings);
 	}
 	show(e) {
-		this.seen.has(e.seq) || (this.seen.add(e.seq), this.sender.confirm(e.msg), this.emitter.emit(O.MESSAGE_RECEIVED, A(e)));
+		this.seen.has(e.seq) || (this.seen.add(e.seq), this.sender.confirm(e.msg), this.emitter.emit(I.MESSAGE_RECEIVED, R(e)));
 	}
 	showRows(e) {
 		let t = [];
 		for (let n of e) {
 			if (this.seen.has(n.seq)) continue;
 			this.seen.add(n.seq), this.sender.confirm(n.msg);
-			let e = A(n);
-			t.push(e), this.emitter.emit(O.MESSAGE_RECEIVED, e);
+			let e = R(n);
+			t.push(e), this.emitter.emit(I.MESSAGE_RECEIVED, e);
 		}
 		return t;
 	}
 	setStatus(e) {
-		e !== this.status && (this.status = e, this.emitter.emit(O.STATUS, e));
+		e !== this.status && (this.status = e, this.emitter.emit(I.STATUS, e));
 	}
 };
 //#endregion
-export { M as ChatEmitter, e as ChatMessageError, O as EVENTS, V as FeedStatus, N as HeadLookupTimeoutError, t as MAX_ENTRY_BYTES, n as MAX_MESSAGE_BYTES, r as MAX_NAME_CHARACTERS, i as MAX_TEXT_CHARACTERS, a as MAX_TOPIC_CHARACTERS, o as MESSAGE_VERSION, s as MessageType, Q as SwarmChat, U as UnreadableGatewayError, P as UnreadableSlotError, c as chatMessageSchema, l as checkChatMessage, u as countCharacters, d as createChatMessage, f as encodeChatMessage, p as feedEntrySchema, m as hasValidSignature, h as historyFileSchema, g as historyLinkSchema, _ as historyRowSchema, v as newMessageId, y as parseChatMessage, b as parseFeedEntry, x as parseHistoryFile, S as signedBytes };
+export { B as ChatEmitter, e as ChatMessageError, t as DEFAULT_NOTE_HEARTBEAT_MS, n as DEFAULT_NOTE_SLOT_MS, I as EVENTS, J as FeedStatus, V as HeadLookupTimeoutError, r as MAX_ENTRY_BYTES, i as MAX_MESSAGE_BYTES, a as MAX_NAME_CHARACTERS, o as MAX_NOTE_BYTES, s as MAX_TEXT_CHARACTERS, c as MAX_TOPIC_CHARACTERS, l as MESSAGE_VERSION, u as MessageType, d as NOTE_VERSION, me as SwarmChat, X as UnreadableGatewayError, H as UnreadableSlotError, f as chatMessageSchema, p as checkChatMessage, m as countCharacters, h as createChatMessage, g as encodeChatMessage, _ as encodeSlotNote, v as feedEntrySchema, ee as hasValidSignature, te as historyFileSchema, y as historyLinkSchema, ne as historyRowSchema, b as newMessageId, x as noteAddress, S as noteIdentifier, C as noteIdentifierText, w as noteSlotEnd, T as noteSlotOf, E as parseChatMessage, D as parseFeedEntry, O as parseHistoryFile, k as parseSlotNote, A as signedBytes, re as slotNoteSchema };

package/dist/message/index.d.ts

@@ -1,2 +1,3 @@
 export * from './message.js';
 export * from './entry.js';
+export * from './note.js';

package/dist/message/note.d.ts

@@ -0,0 +1,38 @@
+import { Identifier, Reference } from '@ethersphere/bee-js';
+import { z } from 'zod';
+/**
+ * Slot notes: the chat server's announcement, after a stretch of wall-clock time in which messages landed, of the
+ * newest feed slot it has written. A reader asks for a note only once its time slot is over, and asks for a feed slot
+ * only once a note has named it, so it never asks Bee for an address that is not written yet. Bee answers a chunk it
+ * could not find by skipping every peer it asked for that address for a minute, which is what made new messages
+ * arrive about forty seconds late while readers polled the next slot.
+ *
+ * Time slot `s` covers `[s * slotMs, (s + 1) * slotMs)` in Unix milliseconds. Its note is a single owner chunk signed
+ * by the chat feed's key, at the identifier keccak256(`<topic>/note/<slotMs>/<s>`).
+ */
+export declare const NOTE_VERSION = 1;
+export declare const DEFAULT_NOTE_SLOT_MS = 2000;
+export declare const DEFAULT_NOTE_HEARTBEAT_MS = 30000;
+/** A note is far below one chunk, so it is a single owner chunk with its payload inline. */
+export declare const MAX_NOTE_BYTES = 256;
+export declare const slotNoteSchema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    newest: z.ZodNumber;
+    writtenAt: z.ZodNumber;
+}, z.core.$strict>;
+export type SlotNote = z.infer<typeof slotNoteSchema>;
+/** The time slot that holds the instant `timeMs`. */
+export declare function noteSlotOf(timeMs: number, slotMs: number): number;
+/** The instant time slot `slot` ends, which is the first instant of the next one. */
+export declare function noteSlotEnd(slot: number, slotMs: number): number;
+export declare function noteIdentifierText(topic: string, slotMs: number, slot: number): string;
+export declare function noteIdentifier(topic: string, slotMs: number, slot: number): Identifier;
+/**
+ * Where a note lives, the address `GET /chunks/<address>` reads it from: keccak256 of the identifier and the owner,
+ * the single owner chunk rule.
+ */
+export declare function noteAddress(topic: string, slotMs: number, slot: number, owner: string): Reference;
+/** The payload, with its fields in this order, so two encodings of one note are the same bytes. */
+export declare function encodeSlotNote(note: Omit<SlotNote, 'v'>): Uint8Array;
+/** A note, or null for anything that fails the strict check, which a reader treats as no note at all. */
+export declare function parseSlotNote(payload: Uint8Array): SlotNote | null;