matrix-nodejs-homeserver 0.3.1 → 0.3.2

package/dist/api/sync.js

@@ -4,9 +4,12 @@ import { errors } from "../core/errors.js";
 import { getState } from "../core/authrules.js";
 import { loadRules } from "../core/pushrules.js";
 import { inviteDecision } from "../core/invitefilter.js";
+import { deviceListChangesQuery } from "../core/keys.js";
 import { body } from "../http/input.js";
 import { procedure } from "../http/procedure.js";
 import { matchesFilter, roomAllowed, validateSyncFilter } from "./filters.js";
+import { readBatch } from "../storage/batch.js";
+import { Semaphore } from "../core/semaphore.js";
 import { fullProfile } from "../core/profile.js";
 //#region src/api/sync.ts
 function parseSyncToken(raw) {
@@ -64,7 +67,8 @@ async function snapshotAt(hs, roomId, pos) {
 			field: "stream",
 			direction: "desc"
 		},
-		limit: 1
+		limit: 1,
+		fields: ["state_snapshot"]
 	}))[0]?.state_snapshot ?? 0;
 }
 /** Build the timeline + state section of a room. */
@@ -126,7 +130,8 @@ async function roomTimeline(hs, p, roomId, since, upTo) {
 	}
 	if (limit === 0 && events.length === 0) limited = (await hs.db.findMany("events", {
 		where,
-		limit: 1
+		limit: 1,
+		fields: ["stream"]
 	})).length > 0;
 	if (since === null) events.sort((a, b) => (a.pdu.depth ?? 0) - (b.pdu.depth ?? 0) || a.stream - b.stream);
 	else events.reverse();
@@ -144,7 +149,8 @@ async function roomTimeline(hs, p, roomId, since, upTo) {
 			operator: "lt",
 			value: events[0].stream
 		}],
-		limit: 1
+		limit: 1,
+		fields: ["stream"]
 	})).length > 0;
 	const startPos = events.length ? Math.min(...events.map((e) => e.stream)) - 1 : upTo;
 	const startState = await hs.rooms.stateAtSnapshot(await snapshotAt(hs, roomId, startPos));
@@ -196,7 +202,7 @@ async function roomTimeline(hs, p, roomId, since, upTo) {
 		timelineEvents: events
 	};
 }
-async function roomEphemeral(hs, p, roomId) {
+async function roomEphemeral(hs, p, roomId, prefetched) {
 	const since = p.since?.pos ?? null;
 	const out = [];
 	const typing = hs.typing.typingSince(roomId, since);
@@ -213,7 +219,7 @@ async function roomEphemeral(hs, p, roomId) {
 		operator: "gt",
 		value: since
 	});
-	const receipts = (await hs.db.findMany("receipts", { where })).filter((r) => r.stream <= p.to);
+	const receipts = (prefetched ?? await hs.db.findMany("receipts", { where })).filter((r) => r.stream <= p.to);
 	const content = {};
 	for (const r of receipts) {
 		if (r.receipt_type === M.READ.PRIVATE && r.user_id !== p.session.userId) continue;
@@ -231,7 +237,7 @@ async function roomEphemeral(hs, p, roomId) {
 	});
 	return out.filter((e) => matchesFilter(p.filter.room?.ephemeral, e));
 }
-async function accountData(hs, p, roomId) {
+async function accountData(hs, p, roomId, prefetched) {
 	const where = [{
 		field: "user_id",
 		value: p.session.userId
@@ -244,7 +250,7 @@ async function accountData(hs, p, roomId) {
 		operator: "gt",
 		value: p.since.pos
 	});
-	const rows = await hs.db.findMany("account_data", { where });
+	const rows = prefetched ?? await hs.db.findMany("account_data", { where });
 	const filter = roomId ? p.filter.room?.account_data : p.filter.account_data;
 	return rows.filter((r) => r.stream <= p.to && (p.since || Object.keys(r.content ?? {}).length > 0)).map((r) => ({
 		type: r.type,
@@ -271,13 +277,193 @@ async function roomSummary(hs, roomId, userId) {
 	if (!getState(state, M.ROOM.NAME)?.content?.name && !getState(state, M.ROOM.CANONICAL_ALIAS)?.content?.alias) summary[M.HEROES] = heroes.sort();
 	return summary;
 }
+/**
+* What changed for the user since the token, for all of their rooms at once: the rooms with new
+* events or newly complete state, and the new receipts and account data by room.
+*
+* https://github.com/k18k/matrix-nodejs-homeserver/issues/33: an incremental sync queried every
+* joined room (timeline, receipts, account data) and only then found that most had nothing new,
+* so a sync cost as many queries as the user had rooms, each time a long-poll woke up. These few
+* queries find the rooms that changed, and only those are built.
+*/
+/** One-time key counts by algorithm, as /sync reports them (signed_curve25519 always present). */
+function countAlgorithms(rows) {
+	const counts = { signed_curve25519: 0 };
+	for (const r of rows) counts[r.algorithm] = (counts[r.algorithm] ?? 0) + 1;
+	return counts;
+}
+async function changesSince(hs, p, memberships, since, accountRows) {
+	const joined = memberships.filter((m) => m.membership === "join").map((m) => m.room_id);
+	const anyMembership = [...new Set(memberships.map((m) => m.room_id))];
+	const range = [{
+		field: "stream",
+		operator: "gt",
+		value: since
+	}, {
+		field: "stream",
+		operator: "lte",
+		value: p.to
+	}];
+	const chunks = (list) => Array.from({ length: Math.ceil(list.length / 500) }, (_, i) => list.slice(i * 500, i * 500 + 500));
+	const inRooms = (chunk) => ({
+		field: "room_id",
+		operator: "in",
+		value: chunk
+	});
+	const queries = [];
+	for (const chunk of chunks(joined)) {
+		queries.push({
+			model: "events",
+			opts: {
+				where: [inRooms(chunk), ...range],
+				fields: ["room_id"]
+			}
+		});
+		queries.push({
+			model: "receipts",
+			opts: { where: [inRooms(chunk), ...range] }
+		});
+		queries.push({
+			model: "partial_state_rooms",
+			opts: {
+				where: [inRooms(chunk), {
+					field: "completed_stream",
+					operator: "gt",
+					value: since
+				}],
+				fields: ["room_id"]
+			}
+		});
+	}
+	for (const chunk of chunks(anyMembership)) queries.push({
+		model: "memberships",
+		opts: { where: [inRooms(chunk), {
+			field: "stream",
+			operator: "gt",
+			value: since
+		}] }
+	});
+	const results = await readBatch(hs.db, queries);
+	const touched = /* @__PURE__ */ new Set();
+	const receipts = /* @__PURE__ */ new Map();
+	const joinedChunks = Math.ceil(joined.length / 500);
+	for (let c = 0; c < joinedChunks; c++) {
+		const [events, receiptRows, completed] = results.slice(c * 3, c * 3 + 3);
+		for (const r of events) touched.add(r.room_id);
+		for (const r of receiptRows) {
+			touched.add(r.room_id);
+			receipts.set(r.room_id, [...receipts.get(r.room_id) ?? [], r]);
+		}
+		for (const r of completed) touched.add(r.room_id);
+	}
+	const memberChanges = results.slice(joinedChunks * 3).flat();
+	const accountData = /* @__PURE__ */ new Map();
+	for (const r of accountRows) {
+		if (r.room_id) touched.add(r.room_id);
+		accountData.set(r.room_id, [...accountData.get(r.room_id) ?? [], r]);
+	}
+	return {
+		touched,
+		receipts,
+		accountData,
+		memberChanges
+	};
+}
 async function buildSync(hs, p) {
 	const userId = p.session.userId;
 	const since = p.since?.pos ?? null;
-	const memberships = await hs.db.findMany("memberships", { where: [{
+	const incremental = since !== null && !p.fullState;
+	const deviceWhere = [{
 		field: "user_id",
 		value: userId
-	}] });
+	}, {
+		field: "device_id",
+		value: p.session.deviceId
+	}];
+	const acknowledged = p.since ? hs.db.delete("to_device", [...deviceWhere, {
+		field: "stream",
+		operator: "lte",
+		value: p.since.toDevice
+	}]) : Promise.resolve(0);
+	const [memberships, ignoredRows, toDeviceRows, oneTimeKeyRows, fallbackRows, accountRows = []] = await readBatch(hs.db, [
+		{
+			model: "memberships",
+			opts: { where: [{
+				field: "user_id",
+				value: userId
+			}] }
+		},
+		{
+			model: "account_data",
+			opts: { where: [
+				{
+					field: "user_id",
+					value: userId
+				},
+				{
+					field: "room_id",
+					value: ""
+				},
+				{
+					field: "type",
+					value: M.IGNORED_USER_LIST
+				}
+			] }
+		},
+		{
+			model: "to_device",
+			opts: {
+				where: [...deviceWhere, {
+					field: "stream",
+					operator: "gt",
+					value: p.since?.toDevice ?? 0
+				}],
+				sortBy: {
+					field: "stream",
+					direction: "asc"
+				},
+				limit: 100
+			}
+		},
+		{
+			model: "one_time_keys",
+			opts: {
+				where: [...deviceWhere, {
+					field: "fallback",
+					value: false
+				}],
+				fields: ["algorithm"]
+			}
+		},
+		{
+			model: "fallback_keys",
+			opts: {
+				where: [...deviceWhere, {
+					field: "used",
+					value: false
+				}],
+				fields: ["algorithm"]
+			}
+		},
+		...incremental ? [{
+			model: "account_data",
+			opts: { where: [{
+				field: "user_id",
+				value: userId
+			}, {
+				field: "stream",
+				operator: "gt",
+				value: since
+			}] }
+		}] : []
+	]);
+	p = {
+		...p,
+		ignored: new Set(Object.keys(ignoredRows[0]?.content?.ignored_users ?? {}))
+	};
+	const changes = incremental ? await changesSince(hs, p, memberships, since, accountRows) : null;
+	let memberChangesRead = changes ? Promise.resolve(changes.memberChanges) : null;
+	const memberChanges = () => memberChangesRead ??= hs.rooms.membershipChangesSince(userId, since ?? 0, memberships);
 	const join = {};
 	const invite = {};
 	const leave = {};
@@ -288,12 +474,13 @@ async function buildSync(hs, p) {
 		const roomId = m.room_id;
 		const changed = since === null || m.stream > since;
 		if (m.membership === "join") {
+			if (changes && !changed && !changes.touched.has(roomId) && hs.typing.typingSince(roomId, since) === null) continue;
 			if (!p.filter.room?.state?.lazy_load_members && await hs.partialState.isPartial(roomId)) continue;
 			const completedAt = await hs.partialState.completedAt(roomId);
 			const initial = since === null || p.fullState || m.stream > since || completedAt !== null && completedAt > since && completedAt <= p.to;
 			const { timeline, state, stateAfter, timelineEvents } = await roomTimeline(hs, p, roomId, initial ? null : since, p.to);
-			const ephemeral = await roomEphemeral(hs, p, roomId);
-			const roomAccountData = await accountData(hs, p, roomId);
+			const ephemeral = await roomEphemeral(hs, p, roomId, changes ? changes.receipts.get(roomId) ?? [] : void 0);
+			const roomAccountData = await accountData(hs, p, roomId, changes ? changes.accountData.get(roomId) ?? [] : void 0);
 			if (!initial && timelineEvents.length === 0 && state.length === 0 && stateAfter.length === 0 && ephemeral.length === 0 && roomAccountData.length === 0) continue;
 			join[roomId] = {
 				timeline,
@@ -341,68 +528,67 @@ async function buildSync(hs, p) {
 			leave[roomId] = {
 				timeline,
 				state: { events: state.map((e) => toClientEvent(e, { includeRoomId: false })) },
-				account_data: { events: await accountData(hs, p, roomId) }
+				account_data: { events: await accountData(hs, p, roomId, changes ? changes.accountData.get(roomId) ?? [] : void 0) }
 			};
 			empty = false;
 		}
 	}
-	const globalAccountData = await accountData(hs, p, "");
+	const globalAccountData = await accountData(hs, p, "", changes ? changes.accountData.get("") ?? [] : void 0);
 	if (since === null && !globalAccountData.some((e) => e.type === M.PUSH_RULES)) globalAccountData.push({
 		type: M.PUSH_RULES,
 		content: { global: await loadRules(hs, userId) }
 	});
 	if (globalAccountData.length) empty = false;
-	const deviceWhere = [{
-		field: "user_id",
-		value: userId
-	}, {
-		field: "device_id",
-		value: p.session.deviceId
-	}];
-	if (p.since) await hs.db.delete("to_device", [...deviceWhere, {
-		field: "stream",
-		operator: "lte",
-		value: p.since.toDevice
-	}]);
-	const toDevice = (await hs.db.findMany("to_device", {
-		where: [...deviceWhere, {
-			field: "stream",
-			operator: "gt",
-			value: p.since?.toDevice ?? 0
-		}],
-		sortBy: {
-			field: "stream",
-			direction: "asc"
-		},
-		limit: 100
-	})).filter((r) => r.stream <= p.to);
+	await acknowledged;
+	const toDevice = toDeviceRows.filter((r) => r.stream <= p.to);
 	const nextToDevice = toDevice.length ? toDevice[toDevice.length - 1].stream : p.since?.toDevice ?? 0;
 	if (toDevice.length) empty = false;
 	const presenceEvents = [];
-	if (!p.filter.presence?.types || p.filter.presence.types.length) {
-		const sharing = await hs.rooms.usersSharingRooms(userId);
-		const newlyShared = /* @__PURE__ */ new Set();
-		if (since !== null) {
-			const changes = await hs.db.findMany("memberships", { where: [{
+	const wantPresence = !p.filter.presence?.types || p.filter.presence.types.length > 0;
+	const sharing = await hs.rooms.usersSharingRooms(userId);
+	const joinedRooms = memberships.filter((m) => m.membership === "join").map((m) => m.room_id);
+	const newlyShared = /* @__PURE__ */ new Set();
+	if (since !== null && wantPresence) {
+		const myRooms = new Set(joinedRooms);
+		for (const c of await memberChanges()) {
+			if (c.membership !== "join" || !myRooms.has(c.room_id)) continue;
+			if (c.user_id === userId) for (const u of await hs.rooms.joinedMembers(c.room_id)) newlyShared.add(u);
+			else newlyShared.add(c.user_id);
+		}
+	}
+	const sharingList = [...sharing];
+	const [presenceRows = [], newlySharedPresence = [], deviceRows] = await readBatch(hs.db, [
+		{
+			model: "presence",
+			opts: { where: [{
+				field: "user_id",
+				operator: "in",
+				value: wantPresence ? sharingList : []
+			}, ...since !== null ? [{
 				field: "stream",
 				operator: "gt",
 				value: since
-			}] });
-			const myRooms = new Set(memberships.filter((m) => m.membership === "join").map((m) => m.room_id));
-			for (const c of changes) {
-				if (c.membership !== "join" || !myRooms.has(c.room_id)) continue;
-				if (c.user_id === userId) for (const u of await hs.rooms.joinedMembers(c.room_id)) newlyShared.add(u);
-				else newlyShared.add(c.user_id);
-			}
-		}
-		const where = [{
-			field: "user_id",
-			operator: "in",
-			value: [...sharing]
-		}];
-		for (const row of await hs.db.findMany("presence", { where })) {
+			}] : []] }
+		},
+		{
+			model: "presence",
+			opts: { where: [{
+				field: "user_id",
+				operator: "in",
+				value: [...newlyShared]
+			}] }
+		},
+		...since !== null ? [{
+			model: "device_list_changes",
+			opts: deviceListChangesQuery(sharing, since)
+		}] : []
+	]);
+	if (wantPresence) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const row of [...presenceRows, ...newlySharedPresence]) {
+			if (seen.has(row.user_id)) continue;
+			seen.add(row.user_id);
 			if (row.stream > p.to) continue;
-			if (since !== null && row.stream <= since && !newlyShared.has(row.user_id)) continue;
 			const content = {
 				presence: row.presence,
 				last_active_ago: Date.now() - row.last_active_ts
@@ -418,7 +604,7 @@ async function buildSync(hs, p) {
 		}
 	}
 	if (presenceEvents.length) empty = false;
-	const profileUpdates = await profileUpdatesFor(hs, p, memberships);
+	const profileUpdates = await profileUpdatesFor(hs, p, memberships, memberChanges);
 	if (profileUpdates) empty = false;
 	const body = {
 		next_batch: formatToken({
@@ -438,12 +624,16 @@ async function buildSync(hs, p) {
 			type: r.type,
 			content: r.content
 		})) },
-		device_one_time_keys_count: await hs.keys.oneTimeKeyCounts(userId, p.session.deviceId),
-		device_unused_fallback_key_types: await hs.keys.unusedFallbackKeyTypes(userId, p.session.deviceId)
+		device_one_time_keys_count: countAlgorithms(oneTimeKeyRows),
+		device_unused_fallback_key_types: [...new Set(fallbackRows.map((r) => r.algorithm))]
 	};
 	if (profileUpdates) body[UNSTABLE.ORG.MATRIX.MSC4429.USERS] = profileUpdates;
 	if (since !== null) {
-		const lists = await hs.keys.changesSince(userId, since, p.to);
+		const lists = await hs.keys.changesSince(userId, since, p.to, {
+			memberChanges: await memberChanges(),
+			deviceRows,
+			joinedRooms
+		});
 		body.device_lists = lists;
 		if (lists.changed.length || lists.left.length) empty = false;
 	}
@@ -453,6 +643,12 @@ async function buildSync(hs, p) {
 		nextToDevice
 	};
 }
+const slots = /* @__PURE__ */ new WeakMap();
+function syncSlots(hs) {
+	let s = slots.get(hs);
+	if (!s) slots.set(hs, s = new Semaphore(hs.config.maxConcurrentSyncs));
+	return s;
+}
 async function sync(ctx) {
 	const hs = ctx.hs;
 	const session = await ctx.auth();
@@ -465,33 +661,21 @@ async function sync(ctx) {
 	const deadline = Date.now() + timeout;
 	for (;;) {
 		const to = await hs.streams.position();
-		const ignoredRow = await hs.db.findOne("account_data", [
-			{
-				field: "user_id",
-				value: session.userId
-			},
-			{
-				field: "room_id",
-				value: ""
-			},
-			{
-				field: "type",
-				value: M.IGNORED_USER_LIST
-			}
-		]);
-		const ignored = new Set(Object.keys(ignoredRow?.content?.ignored_users ?? {}));
+		const ignored = /* @__PURE__ */ new Set();
 		const stable = ctx.query.get("use_state_after") === "true";
 		const unstable = ctx.query.get(UNSTABLE.ORG.MATRIX.MSC4222.USE_STATE_AFTER) === "true";
-		const { body, empty } = await buildSync(hs, {
+		const useStateAfter = stable || unstable;
+		const stateAfterKey = stable ? "state_after" : UNSTABLE.ORG.MATRIX.MSC4222.STATE_AFTER;
+		const { body, empty } = await syncSlots(hs).run(() => buildSync(hs, {
 			session,
 			ignored,
 			since,
 			to,
 			filter,
 			fullState,
-			useStateAfter: stable || unstable,
-			stateAfterKey: stable ? "state_after" : UNSTABLE.ORG.MATRIX.MSC4222.STATE_AFTER
-		});
+			useStateAfter,
+			stateAfterKey
+		}));
 		const remaining = deadline - Date.now();
 		if (!since || !empty || remaining <= 0 || fullState) return body;
 		if (await hs.streams.position() > to) continue;
@@ -499,6 +683,7 @@ async function sync(ctx) {
 		if (ctx.request.signal?.aborted) return body;
 	}
 }
+const LAST_ACTIVE_GRANULARITY_MS = 6e4;
 async function touchPresence(hs, userId, presence) {
 	const state = presence === "unavailable" ? "unavailable" : "online";
 	const row = await hs.db.findOne("presence", [{
@@ -506,7 +691,7 @@ async function touchPresence(hs, userId, presence) {
 		value: userId
 	}]);
 	if (row && row.presence === state) {
-		await hs.db.update("presence", [{
+		if (Date.now() - row.last_active_ts >= LAST_ACTIVE_GRANULARITY_MS) await hs.db.update("presence", [{
 			field: "user_id",
 			value: userId
 		}], { last_active_ts: Date.now() });
@@ -564,7 +749,7 @@ function registerSyncRoutes(r) {
 * MSC4429: profile changes of users sharing a room, limited to the fields the filter asks for.
 * The initial sync carries current values; users we no longer share any room with get `null`.
 */
-async function profileUpdatesFor(hs, p, memberships) {
+async function profileUpdatesFor(hs, p, memberships, memberChanges) {
 	const ids = (p.filter.profile_fields ?? p.filter[UNSTABLE.ORG.MATRIX.MSC4429.PROFILE_FIELDS])?.ids;
 	if (!Array.isArray(ids) || !ids.length) return null;
 	const wanted = new Set(ids.filter((x) => typeof x === "string"));
@@ -577,11 +762,7 @@ async function profileUpdatesFor(hs, p, memberships) {
 	const full = new Set(since === null ? sharing : []);
 	if (since !== null) {
 		const myRooms = new Set(memberships.filter((m) => m.membership === "join").map((m) => m.room_id));
-		const changes = await hs.db.findMany("memberships", { where: [{
-			field: "stream",
-			operator: "gt",
-			value: since
-		}] });
+		const changes = await memberChanges();
 		for (const c of changes) {
 			if (c.stream > p.to || c.user_id === p.session.userId) continue;
 			if (c.membership === "join" && myRooms.has(c.room_id)) {

package/dist/core/cluster.d.ts

@@ -1,8 +1,8 @@
 //#region src/core/cluster.d.ts
 /**
  * Coordination between homeserver instances sharing one database. The default
- * (`localCluster()`) keeps everything in process; use `postgresCluster()` or
- * `redisCluster()` to run several instances behind a load balancer.
+ * (`localCluster()`) keeps everything in process; use `postgresCluster()` to run several
+ * instances behind a load balancer.
  */
 export interface ClusterAdapter {
   /** Allocate the next value of a cluster-wide, strictly increasing sequence. */
@@ -44,13 +44,20 @@ export declare class StreamManager {
   private cluster;
   private instanceId;
   private inflight;
-  private published;
-  private transition;
+  /** Allocations waiting for a publish that covers them. */
+  private reserving;
+  /** Allocations whose publish is done, asking the sequence for their position now. */
+  private allocating;
+  /** The position of the last published busy state: below every position still being allocated. */
+  private lastPos;
   private heartbeat;
   private positionCache;
+  private publishing;
+  private nextPublish;
   constructor(cluster: ClusterAdapter, instanceId: string);
   private key;
-  private publishState;
+  /** Publish this writer's state as it is when the publish starts; concurrent callers share it. */
+  private flush;
   /** Allocate a position. The caller must call `done()` once its writes are committed. */
   allocate(): Promise<StreamLease>;
   /** Allocate a position, run `fn` with it, then complete it. */

package/dist/core/cluster.js

@@ -91,38 +91,64 @@ var StreamManager = class {
 	cluster;
 	instanceId;
 	inflight = /* @__PURE__ */ new Set();
-	published = {
-		busy: false,
-		pos: 0
-	};
-	transition = Promise.resolve();
+	/** Allocations waiting for a publish that covers them. */
+	reserving = 0;
+	/** Allocations whose publish is done, asking the sequence for their position now. */
+	allocating = 0;
+	/** The position of the last published busy state: below every position still being allocated. */
+	lastPos = 0;
 	heartbeat;
 	positionCache = null;
+	publishing = Promise.resolve();
+	nextPublish = null;
 	constructor(cluster, instanceId) {
 		this.cluster = cluster;
 		this.instanceId = instanceId;
-		this.heartbeat = setInterval(() => void this.publishState().catch(() => {}), WRITER_TTL_MS / 3);
+		this.heartbeat = setInterval(() => void this.flush().catch(() => {}), WRITER_TTL_MS / 3);
 		this.heartbeat.unref?.();
 	}
 	key() {
 		return `writer:${this.instanceId}`;
 	}
-	async publishState() {
-		await this.cluster.set(this.key(), this.published, WRITER_TTL_MS);
+	/** Publish this writer's state as it is when the publish starts; concurrent callers share it. */
+	flush() {
+		if (this.nextPublish) return this.nextPublish;
+		const run = async () => {
+			this.nextPublish = null;
+			const covered = this.reserving;
+			const earlier = this.allocating;
+			this.reserving = 0;
+			this.allocating += covered;
+			const bounds = [];
+			if (this.inflight.size) bounds.push(Math.min(...this.inflight) - 1);
+			if (earlier) bounds.push(this.lastPos);
+			if (covered) bounds.push(await this.cluster.currentId("stream"));
+			const state = bounds.length ? {
+				busy: true,
+				pos: Math.min(...bounds)
+			} : {
+				busy: false,
+				pos: 0
+			};
+			if (state.busy) this.lastPos = state.pos;
+			await this.cluster.set(this.key(), state, WRITER_TTL_MS);
+		};
+		const p = this.publishing.then(run, run);
+		this.nextPublish = p;
+		this.publishing = p.catch(() => {});
+		return p;
 	}
 	/** Allocate a position. The caller must call `done()` once its writes are committed. */
 	async allocate() {
-		await (this.transition = this.transition.then(async () => {
-			if (!this.published.busy) {
-				this.published = {
-					busy: true,
-					pos: await this.cluster.currentId("stream")
-				};
-				await this.publishState();
-			}
-		}));
-		const id = await this.cluster.nextId("stream");
-		this.inflight.add(id);
+		this.reserving++;
+		let id;
+		try {
+			await this.flush();
+			id = await this.cluster.nextId("stream");
+			this.inflight.add(id);
+		} finally {
+			this.allocating--;
+		}
 		let finished = false;
 		const timer = setTimeout(() => void lease.done(), 6e4);
 		timer.unref?.();
@@ -133,16 +159,7 @@ var StreamManager = class {
 				finished = true;
 				clearTimeout(timer);
 				this.inflight.delete(id);
-				await (this.transition = this.transition.then(async () => {
-					this.published = this.inflight.size ? {
-						busy: true,
-						pos: Math.min(...this.inflight) - 1
-					} : {
-						busy: false,
-						pos: await this.cluster.currentId("stream")
-					};
-					await this.publishState();
-				}));
+				await this.flush();
 				this.positionCache = null;
 			}
 		};

package/dist/core/html.js

@@ -0,0 +1,13 @@
+//#region src/core/html.ts
+/** Escape text for use in HTML content and quoted attributes. */
+function escapeHtml(s) {
+	return s.replace(/[&<>"']/g, (c) => ({
+		"&": "&amp;",
+		"<": "&lt;",
+		">": "&gt;",
+		"\"": "&quot;",
+		"'": "&#39;"
+	})[c]);
+}
+//#endregion
+export { escapeHtml };

package/dist/core/identity.js

@@ -18,7 +18,7 @@ var IdentityServers = class {
 		if (opts.signed) headers.authorization = this.hs.federation.client.authHeader(idServer, method, path, opts.body);
 		let res;
 		try {
-			res = await this.hs.fetch(`${this.base(idServer)}${path}`, {
+			res = await this.hs.publicFetch(`${this.base(idServer)}${path}`, {
 				method,
 				headers,
 				body: opts.body === void 0 ? void 0 : JSON.stringify(opts.body),