@protobase/server 0.59.3 → 0.60.0

package/dist/calls/admission.d.ts

@@ -0,0 +1,4 @@
+//#region src/calls/admission.d.ts
+/** Why a member is not let into a call: removed from it, the call is full, or the call they resume has ended. */
+export type Refusal = 'removed' | 'full' | 'ended';
+//#endregion

package/dist/calls/admission.js

@@ -0,0 +1,12 @@
+//#region src/calls/admission.ts
+/**
+* Whether a member may come into a call they did not resume from an ended one: never once removed; a member already
+* in it takes their place over, as from another tab; anyone else while the call has room.
+*/
+const admission = ({ removed, present, member, maxMembers }) => {
+	if (removed) return "removed";
+	if (present.includes(member)) return;
+	if (present.length >= maxMembers) return "full";
+};
+//#endregion
+export { admission };

package/dist/calls/call-hub.js

@@ -0,0 +1,170 @@
+import { fixedWindow } from "../realtime/fixed-window.js";
+import { randomUUID } from "node:crypto";
+//#region src/calls/call-hub.ts
+/** Signals a member may pass in a second at most; more are dropped. */
+const signalsPerSecond = 100;
+/** How often the signals for this process are read, with several processes. */
+const signalsEveryMs = 100;
+const rosterOf = (members) => members.map(({ member, joined_at }) => ({
+	member,
+	joined_at
+}));
+/**
+* The members this process serves, in their calls, whose records the `calls` schema keeps. A member is in only while
+* the call's record says so, with this process serving them: a removal, the call's end or another process taking
+* them over closes their socket at the next read, a second at most. A signal goes from a member in a call to another
+* member of the same call only, straight to their socket here, or through the `calls` schema to the process that
+* serves them.
+*/
+const callHub = ({ store, manyProcesses, report }) => {
+	const process = randomUUID();
+	const locals = /* @__PURE__ */ new Map();
+	const known = /* @__PURE__ */ new Map();
+	let signalTimer;
+	const ofCall = (call) => [...locals.values()].filter((local) => local.call === call);
+	const drop = (local, reason) => {
+		locals.delete(local.row);
+		local.link.send({
+			type: "left",
+			reason
+		});
+		local.link.close(reason === "ended" ? 1e3 : 1008, reason);
+	};
+	const apply = (call, found) => {
+		const members = found && !found.ended ? found.members : [];
+		if (members.length === 0) known.delete(call);
+		else known.set(call, members);
+		for (const local of ofCall(call)) {
+			if (!members.some((member) => member.row === local.row && member.process === process)) {
+				drop(local, !found || found.ended ? "ended" : "removed");
+				continue;
+			}
+			if (!local.listener) continue;
+			const body = JSON.stringify(members);
+			if (local.sent === body) continue;
+			local.sent = body;
+			local.link.send({
+				type: "members",
+				members: rosterOf(members)
+			});
+			local.listener?.(members);
+		}
+	};
+	/** Reads who is in these calls and tells their members here. */
+	const refresh = async (calls) => {
+		const found = await store.rosters(calls);
+		for (const call of calls) apply(call, found.get(call));
+	};
+	const deliver = (call, to, from, body) => {
+		ofCall(call).find((local) => local.member === to)?.link.send({
+			type: "signal",
+			from,
+			...body.description && { description: body.description },
+			...body.candidate && { candidate: body.candidate }
+		});
+	};
+	const inCall = async (call, member) => {
+		const find = () => known.get(call)?.find((present) => present.member === member);
+		if (find()) return find();
+		await refresh([call]);
+		return find();
+	};
+	const readSignals = async () => {
+		for (const signal of await store.takeSignals(process, 500)) {
+			if (!await inCall(signal.call, signal.from)) continue;
+			deliver(signal.call, signal.to, signal.from, signal.body);
+		}
+	};
+	const followSignals = () => {
+		if (!manyProcesses || signalTimer || locals.size === 0) return;
+		const tick = () => {
+			if (locals.size === 0) {
+				signalTimer = void 0;
+				return;
+			}
+			readSignals().catch(report).finally(() => {
+				signalTimer = setTimeout(tick, signalsEveryMs);
+				signalTimer.unref?.();
+			});
+		};
+		signalTimer = setTimeout(tick, signalsEveryMs);
+		signalTimer.unref?.();
+	};
+	const signal = async (self, to, body) => {
+		if (locals.get(self.row) !== self || !self.signals()) return;
+		if (!await inCall(self.call, self.member)) return;
+		const target = await inCall(self.call, to);
+		if (!target || target.member === self.member) return;
+		if (target.process === process) return deliver(self.call, to, self.member, body);
+		if (manyProcesses) await store.writeSignal({
+			process: target.process,
+			call: self.call,
+			to,
+			from: self.member,
+			body
+		});
+	};
+	return {
+		process,
+		/** How many members this process serves. */
+		get size() {
+			return locals.size;
+		},
+		/**
+		* Lets the member in, or says why not. Once in, `listen` gets who is in the call; `leave` ends their time in it,
+		* `detach` only stops this process hearing of them, as when their socket was lost: they are out `graceSeconds`
+		* later unless their browser resumes.
+		*/
+		admit: async (input, link) => {
+			const admitted = await store.admit({
+				...input,
+				process
+			});
+			if ("refused" in admitted) return admitted;
+			const local = {
+				call: admitted.call,
+				member: input.member,
+				row: admitted.row,
+				link,
+				signals: fixedWindow(signalsPerSecond, 1e3)
+			};
+			for (const before of ofCall(admitted.call)) if (before.member === input.member && before.row === admitted.row) drop(before, "removed");
+			locals.set(local.row, local);
+			followSignals();
+			const room = {
+				call: admitted.call,
+				tracks: async (tracks) => {
+					if (locals.get(local.row) !== local) return;
+					await store.setTracks(local.row, process, tracks);
+					await refresh([local.call]);
+				},
+				signal: (to, body) => signal(local, to, body)
+			};
+			return {
+				call: admitted.call,
+				room,
+				listen: async (listener) => {
+					local.listener = listener;
+					await refresh([local.call]);
+				},
+				leave: async () => {
+					if (locals.get(local.row) !== local) return;
+					locals.delete(local.row);
+					await store.leave(local.row, process);
+					await refresh([local.call]);
+				},
+				detach: () => {
+					if (locals.get(local.row) === local) locals.delete(local.row);
+				}
+			};
+		},
+		/** Reads every call this process serves a member of, and tells them; a member no longer in theirs is closed out. */
+		refreshAll: () => refresh([...new Set([...locals.values()].map((local) => local.call))]),
+		/** Tells the calls' records that this process still serves its members. */
+		beat: () => store.heartbeat(process, [...locals.keys()]),
+		/** The calls this process serves a member of, for a change made here, such as a removal. */
+		refresh
+	};
+};
+//#endregion
+export { callHub };

package/dist/calls/call-member.d.ts

@@ -1,14 +1,27 @@
 import { CallRemoteTrack, CallTrackSource } from "@protobase/schema/internal";
 //#region src/calls/call-member.d.ts
-/** One member admitted to one call, with what they may send and hear. */
-export type CallMember = {
-  /** The call, as the app names it: members with the same call meet. */
-  call: string;
-  /** Who joins, unique in the call, such as the user's id: the media server knows them by nothing else. */
-  member: string;
+/** What a member may send and hear in a call. */
+export type CallRights = {
   /** Whether the member may send media, or only these sources; nothing when `false`. */
   publish: boolean | CallTrackSource[];
   /** Which of the other members' tracks the member hears; every one by default. */
   hears?: (track: CallRemoteTrack) => boolean;
 };
+/** A record's key, as the records of a function take it: one value, or the values of a key of several fields. */
+export type CallRecordKey = string | number | Array<string | number>;
+/** One member admitted to the call on a record, with what they may send and hear. */
+export type CallMember = CallRights & {
+  /** The record the call is on: whoever reads it sees its calls. The caller must be able to read it to join. */
+  record: {
+    resource: string;
+    key: CallRecordKey;
+  };
+  /**
+   * Who joins, unique in the call, such as the signed-in user's id: take it from the caller, never from the request,
+   * since the other members know them by it.
+   */
+  member: string;
+  /** The function's own checks, repeated every minute after the record's, such as whether the caller is still invited. */
+  recheck?: () => unknown;
+};
 //#endregion

package/dist/calls/call-reads.d.ts

@@ -0,0 +1,29 @@
+import "./call-store.js";
+import { CallRemoteTrack } from "@protobase/schema/internal";
+import { Db } from "@protobase/query";
+//#region src/calls/call-reads.d.ts
+/** Someone in a call now: their members row, the process that serves them and the tracks they send. */
+export type RosterMember = {
+  row: string;
+  member: string;
+  process: string;
+  joined_at: string;
+  tracks: CallRemoteTrack[];
+};
+/** A call as the record's readers see it: who started it, when, when it ended, who is in it and who was removed. */
+export type CallItem = {
+  id: string;
+  started_by: string;
+  started_at: string;
+  /** `null` while it goes on. */
+  ended_at: string | null;
+  members: {
+    member: string;
+    joined_at: string;
+  }[];
+  removed: {
+    member: string;
+    removed_at: string;
+  }[];
+};
+//#endregion

package/dist/calls/call-reads.js

@@ -0,0 +1,79 @@
+import { sql } from "kysely";
+//#region src/calls/call-reads.ts
+const iso = (column) => sql.raw(`to_char(${column} at time zone 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`);
+const ids = (values) => `{${values.join(",")}}`;
+/** Who is in each of these calls now, in the order they came; a call that ended has nobody. Unknown calls are left out. */
+const rosters = async (db, calls) => {
+	const found = /* @__PURE__ */ new Map();
+	if (calls.length === 0) return found;
+	const { rows } = await sql`
+    select c."id"::text as call, c."ended_at" is not null as ended, m."id"::text as row, m."member", m."process"::text as process, ${iso("m.\"joined_at\"")} as joined_at, m."tracks"
+    from "calls"."calls" c left join "calls"."members" m on m."call_id" = c."id" and m."left_at" is null
+    where c."id" = any(${ids(calls)}::uuid[]) order by c."id", m."joined_at", m."id"`.execute(db);
+	for (const row of rows) {
+		const call = found.get(row.call) ?? {
+			ended: row.ended,
+			members: []
+		};
+		found.set(row.call, call);
+		if (row.row !== null) call.members.push({
+			row: row.row,
+			member: row.member,
+			process: row.process,
+			joined_at: row.joined_at,
+			tracks: row.tracks
+		});
+	}
+	return found;
+};
+/** Each record's latest calls: the one going on first, then the newest first; keyed `resource` NUL `key`. */
+const recordCalls = async (db, records) => {
+	const found = new Map(records.map((record) => [recordId(record), []]));
+	if (records.length === 0) return found;
+	const values = JSON.stringify(records.map((record) => ({
+		resource: record.resource,
+		record_key: record.key
+	})));
+	const calls = await sql`
+    select c."id"::text as id, c."resource", c."record_key", c."started_by", ${iso("c.\"started_at\"")} as started_at, ${iso("c.\"ended_at\"")} as ended_at
+    from jsonb_to_recordset(${values}::jsonb) as r("resource" text, "record_key" text)
+    cross join lateral (select * from "calls"."calls" k where k."resource" = r."resource" and k."record_key" = r."record_key" order by k."ended_at" is not null, k."started_at" desc, k."id" limit ${20}) c
+    order by c."ended_at" is not null, c."started_at" desc, c."id"`.execute(db);
+	if (calls.rows.length === 0) return found;
+	const members = await sql`
+    select "call_id"::text as call, "member", ${iso("\"joined_at\"")} as joined_at, ${iso("\"removed_at\"")} as removed_at
+    from "calls"."members" where "call_id" = any(${ids(calls.rows.map((call) => call.id))}::uuid[]) and ("left_at" is null or "removed_at" is not null)
+    order by "joined_at", "id"`.execute(db);
+	const items = /* @__PURE__ */ new Map();
+	for (const call of calls.rows) {
+		const item = {
+			id: call.id,
+			started_by: call.started_by,
+			started_at: call.started_at,
+			ended_at: call.ended_at,
+			members: [],
+			removed: []
+		};
+		items.set(call.id, item);
+		found.get(recordId({
+			resource: call.resource,
+			key: call.record_key
+		})).push(item);
+	}
+	for (const row of members.rows) {
+		const item = items.get(row.call);
+		if (row.removed_at === null) item.members.push({
+			member: row.member,
+			joined_at: row.joined_at
+		});
+		else item.removed.push({
+			member: row.member,
+			removed_at: row.removed_at
+		});
+	}
+	return found;
+};
+/** One string for a record, for maps. */
+const recordId = ({ resource, key }) => `${resource}\u0000${key}`;
+//#endregion
+export { recordCalls, recordId, rosters };

package/dist/calls/call-signals-sql.d.ts

@@ -0,0 +1,12 @@
+import { Db } from "@protobase/query";
+//#region src/calls/call-signals-sql.d.ts
+/** A member's description or candidate for a member another process serves, addressed to that process. */
+export type StoredSignal = {
+  id: string;
+  process: string;
+  call: string;
+  to: string;
+  from: string;
+  body: unknown;
+};
+//#endregion

package/dist/calls/call-signals-sql.js

@@ -0,0 +1,19 @@
+import { sql } from "kysely";
+//#region src/calls/call-signals-sql.ts
+const writeSignal = async (db, signal) => {
+	await sql`insert into "calls"."signals" ("process", "call_id", "to_member", "from_member", "body", "at")
+    values (${signal.process}::uuid, ${signal.call}::uuid, ${signal.to}, ${signal.from}, ${JSON.stringify(signal.body)}::json, now())`.execute(db);
+};
+/**
+* Takes the signals for `process` out of the table, at most `limit`, in the order they were written: each process
+* reads only its own, so ids that commit out of order across processes are never skipped. A sender's signals are
+* written one after the other, so they come in their order.
+*/
+const takeSignals = async (db, process, limit) => {
+	const { rows } = await sql`delete from "calls"."signals" where "id" in (
+      select "id" from "calls"."signals" where "process" = ${process}::uuid order by "id" limit ${limit} for update skip locked)
+    returning "id"::text as id, "process"::text as process, "call_id"::text as call, "to_member" as to, "from_member" as from, "body"`.execute(db);
+	return rows.sort((a, b) => BigInt(a.id) < BigInt(b.id) ? -1 : 1);
+};
+//#endregion
+export { takeSignals, writeSignal };

package/dist/calls/call-store.d.ts

@@ -0,0 +1,30 @@
+import { Refusal } from "./admission.js";
+import { CallRemoteTrack } from "@protobase/schema/internal";
+import { Db } from "@protobase/query";
+//#region src/calls/call-store.d.ts
+/** A record a call is on: its resource and its encoded key. */
+export type CallRecord = {
+  resource: string;
+  key: string;
+};
+export type AdmitInput = {
+  record: CallRecord;
+  member: string;
+  /** The process that serves the member. */
+  process: string;
+  /** The call the browser resumes, with the tracks it sends; a fresh join without. */
+  resume?: {
+    call: string;
+    tracks: CallRemoteTrack[];
+  };
+  maxMembers: number;
+  maxMinutes: number;
+};
+/** The member in the call `call`, as the members row `row`; or why not. */
+export type Admission = {
+  call: string;
+  row: string;
+} | {
+  refused: Refusal;
+};
+//#endregion

package/dist/calls/call-store.js

@@ -0,0 +1,112 @@
+import { writeTransaction } from "../transactions.js";
+import { admission } from "./admission.js";
+import { sql } from "kysely";
+/** Whether `id` can be a call's id, a UUID: anything else is no call. */
+const isCallId = (id) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
+/** The process of a removal row, of someone removed while not in the call. */
+const nobody = "00000000-0000-0000-0000-000000000000";
+const lockCall = async (trx, id) => (await sql`select "id"::text as id, "resource", "record_key", "ended_at" is not null as ended, "ends_at" <= now() as expired
+    from "calls"."calls" where "id" = ${id}::uuid for update`.execute(trx)).rows[0];
+/** Ends the call and the time of everyone still in it; the call's row is locked. */
+const endCall = async (trx, id) => {
+	await sql`update "calls"."calls" set "ended_at" = now() where "id" = ${id}::uuid and "ended_at" is null`.execute(trx);
+	await sql`update "calls"."members" set "left_at" = now() where "call_id" = ${id}::uuid and "left_at" is null`.execute(trx);
+};
+const endIfEmpty = async (trx, id) => {
+	const { rows } = await sql`select "id" from "calls"."members" where "call_id" = ${id}::uuid and "left_at" is null limit 1`.execute(trx);
+	if (rows.length === 0) await endCall(trx, id);
+};
+const liveCall = async (trx, record, member, maxMinutes) => {
+	for (let attempt = 0; attempt < 2; attempt++) {
+		await sql`insert into "calls"."calls" ("id", "resource", "record_key", "started_by", "started_at", "ends_at")
+      values (gen_random_uuid(), ${record.resource}, ${record.key}, ${member}, now(), now() + make_interval(mins => ${maxMinutes}))
+      on conflict ("resource", "record_key") where "ended_at" is null do nothing`.execute(trx);
+		const { rows } = await sql`select "id"::text as id from "calls"."calls"
+      where "resource" = ${record.resource} and "record_key" = ${record.key} and "ended_at" is null`.execute(trx);
+		const call = rows[0] && await lockCall(trx, rows[0].id);
+		if (call && !call.ended && !call.expired) return call.id;
+		if (call && !call.ended) await endCall(trx, call.id);
+	}
+	throw new Error(`The call on ${record.resource} ${record.key} could not be started`);
+};
+const enter = async (trx, call, member, process, tracks) => {
+	const body = JSON.stringify(tracks);
+	const { rows } = await sql`update "calls"."members" set "process" = ${process}::uuid, "seen_at" = now(), "tracks" = ${body}::jsonb
+    where "call_id" = ${call}::uuid and "member" = ${member} and "left_at" is null returning "id"::text as id`.execute(trx);
+	if (rows[0]) return rows[0].id;
+	return (await sql`insert into "calls"."members" ("call_id", "member", "process", "tracks", "joined_at", "seen_at")
+    values (${call}::uuid, ${member}, ${process}::uuid, ${body}::jsonb, now(), now()) returning "id"::text as id`.execute(trx)).rows[0].id;
+};
+/**
+* Lets the member into the record's call, or the call they resume, when they may: one transaction, the call's row
+* locked. The members whose process stopped hearing of them are out first. A resume of a call that ended, or that is
+* on another record, is refused as ended; a fresh join to a record without a call going on starts one.
+*/
+const admit = (db, timeoutMs, input) => writeTransaction(db, timeoutMs, async (trx) => {
+	const { record, member, resume } = input;
+	let call;
+	if (resume) {
+		const resumed = isCallId(resume.call) ? await lockCall(trx, resume.call) : void 0;
+		if (!resumed || resumed.ended || resumed.resource !== record.resource || resumed.record_key !== record.key) return { refused: "ended" };
+		if (resumed.expired) {
+			await endCall(trx, resumed.id);
+			return { refused: "ended" };
+		}
+		call = resumed.id;
+	} else call = await liveCall(trx, record, member, input.maxMinutes);
+	await sql`update "calls"."members" set "left_at" = now()
+      where "call_id" = ${call}::uuid and "left_at" is null and "seen_at" < now() - make_interval(secs => ${30})`.execute(trx);
+	const { rows } = await sql`select "member", "left_at" is null as present from "calls"."members"
+      where "call_id" = ${call}::uuid and ("left_at" is null or ("member" = ${member} and "removed_at" is not null))`.execute(trx);
+	const refused = admission({
+		removed: rows.some((row) => row.member === member && !row.present),
+		present: rows.filter((row) => row.present).map((row) => row.member),
+		member,
+		maxMembers: input.maxMembers
+	});
+	if (refused) return { refused };
+	return {
+		call,
+		row: await enter(trx, call, member, input.process, resume?.tracks ?? [])
+	};
+});
+/** The member of row `row` left, unless another process took them over; the call ends with its last member. */
+const leave = (db, timeoutMs, row, process) => writeTransaction(db, timeoutMs, async (trx) => {
+	const { rows } = await sql`select "call_id"::text as call from "calls"."members" where "id" = ${row}::bigint`.execute(trx);
+	if (!rows[0]) return;
+	const call = await lockCall(trx, rows[0].call);
+	if (!call || call.ended) return;
+	await sql`update "calls"."members" set "left_at" = now() where "id" = ${row}::bigint and "process" = ${process}::uuid and "left_at" is null`.execute(trx);
+	await endIfEmpty(trx, call.id);
+});
+/**
+* Removes the member from the call `call`, and only from it: their time in it ends as removed, or, when they are not in
+* it, a removal is kept, so a join of theirs on its way is refused. Nothing happens to a call that ended or is unknown.
+* Whether they were in it. The call ends when they were its last member.
+*/
+const remove = (db, timeoutMs, callId, member) => writeTransaction(db, timeoutMs, async (trx) => {
+	const call = isCallId(callId) ? await lockCall(trx, callId) : void 0;
+	if (!call || call.ended) return false;
+	const { rows } = await sql`update "calls"."members" set "left_at" = now(), "removed_at" = now()
+      where "call_id" = ${call.id}::uuid and "member" = ${member} and "left_at" is null returning "id"::text as id`.execute(trx);
+	if (rows.length === 0) {
+		await sql`insert into "calls"."members" ("call_id", "member", "process", "tracks", "joined_at", "seen_at", "left_at", "removed_at")
+        values (${call.id}::uuid, ${member}, ${nobody}::uuid, '[]'::jsonb, now(), now(), now(), now())`.execute(trx);
+		return false;
+	}
+	await endIfEmpty(trx, call.id);
+	return true;
+});
+/** The tracks the member of row `row` sends now, while `process` serves them. */
+const setTracks = async (db, row, process, tracks) => {
+	await sql`update "calls"."members" set "tracks" = ${JSON.stringify(tracks)}::jsonb
+    where "id" = ${row}::bigint and "process" = ${process}::uuid and "left_at" is null`.execute(db);
+};
+/** The process still hears of the members of these rows: they stay in their calls. */
+const heartbeat = async (db, process, rows) => {
+	if (rows.length === 0) return;
+	await sql`update "calls"."members" set "seen_at" = now()
+    where "id" = any(${`{${rows.join(",")}}`}::bigint[]) and "process" = ${process}::uuid and "left_at" is null`.execute(db);
+};
+//#endregion
+export { admit, endCall, heartbeat, isCallId, leave, remove, setTracks };

package/dist/calls/call-sweep.js

@@ -0,0 +1,26 @@
+import { writeTransaction } from "../transactions.js";
+import { endCall } from "./call-store.js";
+import { sql } from "kysely";
+//#region src/calls/call-sweep.ts
+/** How long a signal between processes is kept: long after it was read. */
+const signalSeconds = 60;
+/**
+* Ends what should have ended, over every call, whichever process served it: the members no process heard of within
+* `graceSeconds`, as after their socket was lost or their process stopped; the calls past their last minute; the
+* calls nobody is in any more. A call an admission holds is left to the next sweep. Old signals go too.
+*/
+const sweepCalls = (db, timeoutMs) => writeTransaction(db, timeoutMs, async (trx) => {
+	await sql`update "calls"."members" set "left_at" = now()
+      where "left_at" is null and "seen_at" < now() - make_interval(secs => ${30})`.execute(trx);
+	const { rows } = await sql`select "id"::text as id from "calls"."calls" c where "ended_at" is null
+      and ("ends_at" <= now() or not exists (select from "calls"."members" m where m."call_id" = c."id" and m."left_at" is null))
+      for update skip locked`.execute(trx);
+	if (rows.length > 0) {
+		const ended = await sql`select "id"::text as id from "calls"."calls" c where "id" = any(${`{${rows.map((row) => row.id).join(",")}}`}::uuid[])
+        and ("ends_at" <= now() or not exists (select from "calls"."members" m where m."call_id" = c."id" and m."left_at" is null))`.execute(trx);
+		for (const { id } of ended.rows) await endCall(trx, id);
+	}
+	await sql`delete from "calls"."signals" where "at" < now() - make_interval(secs => ${signalSeconds})`.execute(trx);
+});
+//#endregion
+export { sweepCalls };

package/dist/calls/call-watch.js

@@ -0,0 +1,39 @@
+import { recordId } from "./call-reads.js";
+//#region src/calls/call-watch.ts
+/**
+* The records whose calls open pages follow on this process: each read reads all of them in one query, and tells a
+* page only when its record's calls changed.
+*/
+const callWatch = (store) => {
+	const watchers = /* @__PURE__ */ new Set();
+	const read = async (some) => {
+		const records = [...new Map(some.map((watcher) => [recordId(watcher.record), watcher.record])).values()];
+		const found = await store.recordCalls(records);
+		for (const watcher of some) {
+			if (!watchers.has(watcher)) continue;
+			const items = found.get(recordId(watcher.record)) ?? [];
+			const body = JSON.stringify(items);
+			if (watcher.sent === body) continue;
+			watcher.sent = body;
+			watcher.listener(items);
+		}
+	};
+	return {
+		get size() {
+			return watchers.size;
+		},
+		/** Tells `listener` the record's calls now, then whenever they change, until the returned function is called. */
+		add: async (record, listener) => {
+			const watcher = {
+				record,
+				listener
+			};
+			watchers.add(watcher);
+			await read([watcher]);
+			return () => void watchers.delete(watcher);
+		},
+		read: () => read([...watchers])
+	};
+};
+//#endregion
+export { callWatch };

package/dist/calls/calls-access.d.ts

@@ -1,13 +1,28 @@
+import "../types.js";
 import { SocketEvents } from "../functions/function-socket.js";
-import { CallMember } from "./call-member.js";
+import { CallMember, CallRecordKey } from "./call-member.js";
+import { CallItem } from "./call-reads.js";
+import "./calls-service-type.js";
 //#region src/calls/calls-access.d.ts
-/** What a function admits members to calls with. */
+/** What a function admits members to calls with, and sees and changes them by. */
 export type CallsAccess = {
   /**
-   * The member's media session in the call, as the events of the socket the function accepts for them: return
-   * `acceptWebSocket(await calls.join(member))` once the function decided the caller may join. The browser's
-   * `joinCall` from `@protobase/client/calls` speaks to it. Rejects when the app has no `calls` configured.
+   * The member's media session in the call on the record, as the events of the socket the function accepts for them:
+   * return `acceptWebSocket(await calls.join(member))` once the function decided the caller may join. The caller must
+   * be signed in and able to read the record, now and at every minute's check; the browser's `joinCall` from
+   * `@protobase/client/calls` speaks to it. Rejects when the app has no `calls` configured.
    */
   join: (member: CallMember) => Promise<SocketEvents>;
+  /**
+   * Takes the member out of the call `call` at once, and keeps them out of it: their sockets close, the others drop
+   * their connections to them, and their joins and resumes are refused. Whether they were in it; nothing happens to a
+   * call that ended.
+   */
+  remove: (call: string, member: string) => Promise<boolean>;
+  /** The record's latest calls, newest first, the one going on first: with no access check, like `db`. */
+  of: (record: {
+    resource: string;
+    key: CallRecordKey;
+  }) => Promise<CallItem[]>;
 };
 //#endregion