@protobase/server 0.62.1 → 0.62.2

package/dist/calls/call-hub.js

@@ -142,6 +142,7 @@ const callHub = ({ store, manyProcesses, report }) => {
 			};
 			return {
 				call: admitted.call,
+				started: admitted.started,
 				room,
 				listen: async (listener) => {
 					local.listener = listener;

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

@@ -1,3 +1,4 @@
+import { CallRingInput } from "./call-ring.js";
 import { CallRemoteTrack, CallTrackSource } from "@protobase/schema/internal";
 //#region src/calls/call-member.d.ts
 /** What a member may send and hear in a call. */
@@ -23,5 +24,7 @@ export type CallMember = CallRights & {
   member: string;
   /** The function's own checks, repeated every minute after the record's, such as whether the caller is still invited. */
   recheck?: () => unknown;
+  /** Whom the call rings, on any page of the app they have open, when this join starts it. */
+  ring?: CallRingInput;
 };
 //#endregion

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

@@ -0,0 +1,12 @@
+//#region src/calls/call-ring.d.ts
+/** Whom a call rings when a join starts it, and what the ring says. */
+export type CallRingInput = {
+  /** The users rung, by their ids, such as the record's other members; the member who starts the call is not. */
+  users: readonly string[];
+  /** What the ring and the bell say, such as "Ann is calling". */
+  title: string;
+  body?: string;
+  /** Where the bell's entry leads, an absolute URL; the record's page by default. */
+  url?: string;
+};
+//#endregion

package/dist/calls/call-ring.js

@@ -0,0 +1,8 @@
+/** The ring as given, or an error naming what is wrong with it. */
+const checkRing = (ring) => {
+	if (!Array.isArray(ring.users) || ring.users.length > 50 || !ring.users.every((user) => typeof user === "string" && user.length > 0)) throw new TypeError(`calls.join's ring.users must be a list of at most 50 user ids, each a non-empty string`);
+	if (typeof ring.title !== "string" || ring.title.length === 0) throw new TypeError("calls.join's ring.title must be a non-empty string");
+	return ring;
+};
+//#endregion
+export { checkRing };

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

@@ -20,10 +20,11 @@ export type AdmitInput = {
   maxMembers: number;
   maxMinutes: number;
 };
-/** The member in the call `call`, as the members row `row`; or why not. */
+/** The member in the call `call`, as the members row `row`, with whether their join started it; or why not. */
 export type Admission = {
   call: string;
   row: string;
+  started: boolean;
 } | {
   refused: Refusal;
 };

package/dist/calls/call-store.js

@@ -18,13 +18,16 @@ const endIfEmpty = async (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")
+		const inserted = 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);
+      on conflict ("resource", "record_key") where "ended_at" is null do nothing returning "id"::text as id`.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 && !call.expired) return {
+			id: call.id,
+			started: inserted.rows[0]?.id === 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`);
@@ -45,6 +48,7 @@ const enter = async (trx, call, member, process, tracks) => {
 const admit = (db, timeoutMs, input) => writeTransaction(db, timeoutMs, async (trx) => {
 	const { record, member, resume } = input;
 	let call;
+	let started = false;
 	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" };
@@ -53,7 +57,11 @@ const admit = (db, timeoutMs, input) => writeTransaction(db, timeoutMs, async (t
 			return { refused: "ended" };
 		}
 		call = resumed.id;
-	} else call = await liveCall(trx, record, member, input.maxMinutes);
+	} else {
+		const live = await liveCall(trx, record, member, input.maxMinutes);
+		call = live.id;
+		started = live.started;
+	}
 	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"
@@ -67,7 +75,8 @@ const admit = (db, timeoutMs, input) => writeTransaction(db, timeoutMs, async (t
 	if (refused) return { refused };
 	return {
 		call,
-		row: await enter(trx, call, member, input.process, resume?.tracks ?? [])
+		row: await enter(trx, call, member, input.process, resume?.tracks ?? []),
+		started
 	};
 });
 /** The member of row `row` left, unless another process took them over; the call ends with its last member. */
@@ -108,5 +117,11 @@ const heartbeat = async (db, process, rows) => {
 	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);
 };
+/** The record the call is on; `undefined` for an unknown call. */
+const callRecord = async (db, call) => {
+	if (!isCallId(call)) return;
+	const { rows } = await sql`select "resource", "record_key" as key from "calls"."calls" where "id" = ${call}::uuid`.execute(db);
+	return rows[0];
+};
 //#endregion
-export { admit, endCall, heartbeat, isCallId, leave, remove, setTracks };
+export { admit, callRecord, endCall, heartbeat, isCallId, leave, remove, setTracks };

package/dist/calls/call-sweep.js

@@ -7,20 +7,27 @@ 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.
+* calls nobody is in any more. A call an admission holds is left to the next sweep. Old signals go too. The records
+* whose calls it changed.
 */
 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 left = await sql`update "calls"."members" set "left_at" = now()
+      where "left_at" is null and "seen_at" < now() - make_interval(secs => ${30}) returning "call_id"::text as id`.execute(trx);
+	const changed = new Set(left.rows.map((row) => row.id));
 	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);
+		for (const { id } of ended.rows) {
+			await endCall(trx, id);
+			changed.add(id);
+		}
 	}
 	await sql`delete from "calls"."signals" where "at" < now() - make_interval(secs => ${signalSeconds})`.execute(trx);
+	if (changed.size === 0) return [];
+	return (await sql`select distinct "resource", "record_key" as key from "calls"."calls" where "id" = any(${`{${[...changed].join(",")}}`}::uuid[])`.execute(trx)).rows;
 });
 //#endregion
 export { sweepCalls };

package/dist/calls/calls-access.js

@@ -1,4 +1,5 @@
 import { forbidden } from "../problem.js";
+import { checkRing } from "./call-ring.js";
 //#region src/calls/calls-access.ts
 /** The largest message of a member's socket: a description, with room to spare. */
 const maxMessageBytes = 307200;
@@ -26,11 +27,16 @@ const callsAccess = (service, caller) => {
 			const record = service.recordOf(resource, key);
 			const mayRead = () => records.get(resource, key);
 			await mayRead();
+			const ring = member.ring && checkRing(member.ring);
+			const by = {
+				user: String(session.user.id),
+				...ring && { ring }
+			};
 			return {
 				...await (await service.runtime()).relay(record, member.member, {
 					publish: member.publish,
 					...member.hears && { hears: member.hears }
-				}),
+				}, by),
 				maxMessageBytes,
 				recheck: async () => {
 					await mayRead();

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

@@ -1,9 +1,11 @@
 import { CallsOptions } from "./calls-options.js";
 import { SocketEvents } from "../functions/function-socket.js";
+import { CallRingInput } from "./call-ring.js";
 import { CallRights } from "./call-member.js";
 import { CallRecord } from "./call-store.js";
 import { CallItem } from "./call-reads.js";
 import { CallStore } from "./calls-store.js";
+import { Ringer } from "./ringer.js";
 import { Db } from "@protobase/query";
 //#region src/calls/calls-runtime.d.ts
 export type CallsRuntimeInput = {
@@ -13,17 +15,31 @@ export type CallsRuntimeInput = {
   report: (error: unknown) => void;
   /** Memory in tests; the `calls` schema otherwise. */
   store?: CallStore;
+  /** The rings of calls, which joins with a `ring` start. */
+  rings?: Ringer;
+  /** Tells the record's readers its calls changed, such as on the record's channel. */
+  announce?: (record: CallRecord, items: CallItem[]) => Promise<void>;
 };
 /**
  * An app's calls on this process: the members it serves, through the configured plugin, and the records whose calls
  * its pages follow. While it serves a member or a page, it reads them every second and, every five, marks its members
  * as served and sweeps every call, whichever process served it; with neither, it runs no timer.
  */
-export declare const callsRuntime: ({ db, timeoutMs, options, report, store }: CallsRuntimeInput) => {
+export declare const callsRuntime: ({ db, timeoutMs, options, report, store, rings, announce }: CallsRuntimeInput) => {
   /** The events of the member's socket, relayed to the plugin: they come into the record's call at their `join`. */
-  relay: (record: CallRecord, member: string, rights: CallRights) => Promise<SocketEvents>;
+  relay: (record: CallRecord, member: string, rights: CallRights, by?: {
+    user?: string;
+    ring?: CallRingInput;
+  }) => Promise<SocketEvents>;
   /** Removes the member from the call, and only from it: whether they were in it. */
   remove: (call: string, member: string) => Promise<boolean>;
+  /** The calls that ring the user now, and declining one. */
+  rings: () => {
+    start: (call: string, record: CallRecord, by: string, ring: CallRingInput) => Promise<void>;
+    stop: (call: string, userId: string) => Promise<void>;
+    settle: () => Promise<void>;
+    of: (userId: string) => Promise<import("@protobase/schema/internal").CallRing[]>;
+  };
   /** The record's latest calls, newest first, once every call that should have ended has. */
   of: (record: CallRecord) => Promise<CallItem[]>;
   /** Tells `listener` the record's calls now and whenever they change, until the returned function is called. */

package/dist/calls/calls-runtime.js

@@ -18,7 +18,7 @@ const loadBackend = async (settings) => {
 * its pages follow. While it serves a member or a page, it reads them every second and, every five, marks its members
 * as served and sweeps every call, whichever process served it; with neither, it runs no timer.
 */
-const callsRuntime = ({ db, timeoutMs, options, report, store = sqlCallStore(db, timeoutMs) }) => {
+const callsRuntime = ({ db, timeoutMs, options, report, store = sqlCallStore(db, timeoutMs), rings, announce }) => {
 	const hub = callHub({
 		store,
 		manyProcesses: options.processes === "many",
@@ -30,12 +30,20 @@ const callsRuntime = ({ db, timeoutMs, options, report, store = sqlCallStore(db,
 	let backend;
 	let timer;
 	let reads = 0;
+	const changed = (records) => {
+		if (!announce) return;
+		for (const record of records) store.recordCalls([record]).then((found) => announce(record, found.get(recordId(record)) ?? [])).catch(report);
+	};
+	const sweep = async () => {
+		changed(await store.sweep());
+		await rings?.settle();
+	};
 	const busy = () => hub.size > 0 || watch.size > 0;
 	const tick = async () => {
 		reads++;
 		if (reads % beatEvery === 0) {
 			await hub.beat();
-			await store.sweep();
+			await sweep();
 		}
 		await hub.refreshAll();
 		await watch.read();
@@ -50,14 +58,27 @@ const callsRuntime = ({ db, timeoutMs, options, report, store = sqlCallStore(db,
 		}, readEveryMs);
 		timer.unref?.();
 	};
-	const door = { admit: async (input, link) => {
+	const door = { admit: async ({ user, ring, ...input }, link) => {
 		const admitted = await hub.admit(input, link);
 		schedule();
-		return admitted;
+		if ("refused" in admitted) return admitted;
+		changed([input.record]);
+		if (rings && user !== void 0) {
+			if (ring && admitted.started) await rings.start(admitted.call, input.record, user, ring).catch(report);
+			await rings.stop(admitted.call, user).catch(report);
+		}
+		return {
+			...admitted,
+			leave: async () => {
+				await admitted.leave();
+				changed([input.record]);
+				await rings?.settle();
+			}
+		};
 	} };
 	return {
 		/** The events of the member's socket, relayed to the plugin: they come into the record's call at their `join`. */
-		relay: async (record, member, rights) => {
+		relay: async (record, member, rights, by = {}) => {
 			backend ??= loadBackend(options.backend);
 			return memberRelay({
 				door,
@@ -67,23 +88,32 @@ const callsRuntime = ({ db, timeoutMs, options, report, store = sqlCallStore(db,
 				rights,
 				maxMembers,
 				maxMinutes,
-				report
+				report,
+				...by
 			});
 		},
 		/** Removes the member from the call, and only from it: whether they were in it. */
 		remove: async (call, member) => {
+			const record = await store.recordOf(call);
 			const removed = await store.remove(call, member);
 			await hub.refresh([call]);
+			if (record) changed([record]);
+			await rings?.settle();
 			return removed;
 		},
+		/** The calls that ring the user now, and declining one. */
+		rings: () => {
+			if (!rings) throw new Error("Not implemented: rings without a ring store");
+			return rings;
+		},
 		/** The record's latest calls, newest first, once every call that should have ended has. */
 		of: async (record) => {
-			await store.sweep();
+			await sweep();
 			return (await store.recordCalls([record])).get(recordId(record)) ?? [];
 		},
 		/** Tells `listener` the record's calls now and whenever they change, until the returned function is called. */
 		watch: async (record, listener) => {
-			await store.sweep();
+			await sweep();
 			const stop = await watch.add(record, listener);
 			schedule();
 			return stop;

package/dist/calls/calls-service.js

@@ -1,19 +1,47 @@
 import { toolKey } from "../assistant/records.js";
-import { encodeKey } from "@protobase/schema/internal";
+import { sendNotification } from "../notifications/send-notification.js";
+import { callsChannelEvent, decodeKey, encodeKey } from "@protobase/schema/internal";
+import { appPath } from "@protobase/schema";
 //#region src/calls/calls-service.ts
 /** An app's calls over its resources: the runtime loaded at the first use, so an app that never calls loads none of it. */
-const callsService = (deps, options) => {
+const callsService = (deps, options, wiring) => {
 	let runtime;
+	const load = async () => {
+		const [{ callsRuntime }, { ringer, ringMessage }, { sqlRingStore }] = await Promise.all([
+			import("./calls-runtime.js"),
+			import("./ringer.js"),
+			import("./ring-store.js")
+		]);
+		const { db, statementTimeoutMs, report, registry } = deps();
+		const recordUrl = ({ resource, key }) => wiring.origin === void 0 ? void 0 : new URL(appPath({
+			kind: "record",
+			resource,
+			key: decodeKey(key, registry.find(resource).keyTypes)
+		}), wiring.origin).href;
+		return callsRuntime({
+			db,
+			timeoutMs: statementTimeoutMs,
+			options,
+			report,
+			rings: ringer({
+				store: sqlRingStore(db, wiring.notices),
+				recordUrl,
+				...wiring.doNotDisturb && { doNotDisturb: (userIds) => wiring.doNotDisturb(db, userIds) },
+				...wiring.notifications && { notify: ({ userIds, ...notification }) => sendNotification(db, {
+					userIds,
+					inbox: true
+				}, ringMessage(notification)) }
+			}),
+			announce: (record, items) => wiring.channels().broadcast({
+				resource: record.resource,
+				key: record.key,
+				event: callsChannelEvent,
+				payload: { items }
+			})
+		});
+	};
 	return {
-		runtime: () => runtime ??= import("./calls-runtime.js").then(({ callsRuntime }) => {
-			const { db, statementTimeoutMs, report } = deps();
-			return callsRuntime({
-				db,
-				timeoutMs: statementTimeoutMs,
-				options,
-				report
-			});
-		}),
+		runtime: () => runtime ??= load(),
 		recordOf: (resource, key) => {
 			const found = toolKey(deps(), resource, key);
 			return {

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

@@ -1,7 +1,11 @@
+import { EventsOptions } from "../changes/events-options.js";
 import { Db } from "@protobase/query";
 //#region src/calls/calls-sql.d.ts
-/** The SQL that adds the `calls` schema and its tables, `undefined` when they are there. They are never dropped. */
-export declare const callsMigration: (db: Db) => Promise<"create schema if not exists \"calls\";\n\ncreate table if not exists \"calls\".\"calls\" (\n  \"id\" uuid primary key,\n  \"resource\" text not null,\n  \"record_key\" text not null,\n  \"started_by\" text not null,\n  \"started_at\" timestamptz not null,\n  \"ends_at\" timestamptz not null,\n  \"ended_at\" timestamptz\n);\ncreate unique index if not exists \"calls_live\" on \"calls\".\"calls\" (\"resource\", \"record_key\") where \"ended_at\" is null;\ncreate index if not exists \"calls_record\" on \"calls\".\"calls\" (\"resource\", \"record_key\", \"started_at\");\n\ncreate table if not exists \"calls\".\"members\" (\n  \"id\" bigint generated always as identity primary key,\n  \"call_id\" uuid not null references \"calls\".\"calls\" (\"id\") on delete cascade,\n  \"member\" text not null,\n  \"process\" uuid not null,\n  \"tracks\" jsonb not null,\n  \"joined_at\" timestamptz not null,\n  \"seen_at\" timestamptz not null,\n  \"left_at\" timestamptz,\n  \"removed_at\" timestamptz\n);\ncreate unique index if not exists \"members_present\" on \"calls\".\"members\" (\"call_id\", \"member\") where \"left_at\" is null;\ncreate index if not exists \"members_call\" on \"calls\".\"members\" (\"call_id\", \"member\");\ncreate index if not exists \"members_seen\" on \"calls\".\"members\" (\"seen_at\") where \"left_at\" is null;\n\ncreate table if not exists \"calls\".\"signals\" (\n  \"id\" bigint generated always as identity primary key,\n  \"process\" uuid not null,\n  \"call_id\" uuid not null,\n  \"to_member\" text not null,\n  \"from_member\" text not null,\n  \"body\" json not null,\n  \"at\" timestamptz not null\n);\ncreate index if not exists \"signals_process\" on \"calls\".\"signals\" (\"process\", \"id\");\ncreate index if not exists \"signals_at\" on \"calls\".\"signals\" (\"at\");;" | undefined>;
+/**
+ * The SQL that adds the `calls` schema and its tables, and the changes schema's notices table rings reach open pages
+ * through, `undefined` when they are there. They are never dropped.
+ */
+export declare const callsMigration: (db: Db, events?: EventsOptions) => Promise<string | undefined>;
 /** Refuses to go on while the app has `calls` and the database lacks their tables; the project's migrations add them. */
-export declare const checkCalls: (db: Db, calls: unknown) => Promise<void>;
+export declare const checkCalls: (db: Db, calls: unknown, events?: EventsOptions) => Promise<void>;
 //#endregion

package/dist/calls/calls-sql.js

@@ -1,3 +1,6 @@
+import { quoteIdent } from "../changes/capture-sql.js";
+import { noticesTableSql } from "../live/notices-sql.js";
+import { changesSchema } from "../changes/events-options.js";
 import { migrationCommand } from "../changes/capture-schema.js";
 import { sql } from "kysely";
 //#region src/calls/calls-sql.ts
@@ -9,6 +12,8 @@ import { sql } from "kysely";
 *   them and when it last heard of them. A removal of someone not in the call is a row that starts and ends at once.
 * - `signals`: with several processes, a member's description or candidate for a member another process serves,
 *   taken out by that process as it reads it, and deleted after a minute when no process did.
+* - `rings`: a user a call rang, by their id, with the ring's text, until when it rings, and when it stopped: they
+*   joined the call, declined, or the call ended.
 */
 const callsSchemaSql = `create schema if not exists "calls";
 
@@ -49,18 +54,36 @@ create table if not exists "calls"."signals" (
   "at" timestamptz not null
 );
 create index if not exists "signals_process" on "calls"."signals" ("process", "id");
-create index if not exists "signals_at" on "calls"."signals" ("at");`;
-const hasCallsTables = async (db) => (await sql`select to_regclass('calls.calls') is not null and to_regclass('calls.members') is not null and to_regclass('calls.signals') is not null as found`.execute(db)).rows[0].found;
-/** The SQL that adds the `calls` schema and its tables, `undefined` when they are there. They are never dropped. */
-const callsMigration = async (db) => {
-	if (await hasCallsTables(db)) return void 0;
-	return `${callsSchemaSql};`;
+create index if not exists "signals_at" on "calls"."signals" ("at");
+
+create table if not exists "calls"."rings" (
+  "call_id" uuid not null references "calls"."calls" ("id") on delete cascade,
+  "user_id" text not null,
+  "title" text not null,
+  "body" text,
+  "rung_at" timestamptz not null,
+  "until" timestamptz not null,
+  "stopped_at" timestamptz,
+  primary key ("call_id", "user_id")
+);
+create index if not exists "rings_user" on "calls"."rings" ("user_id", "until") where "stopped_at" is null;
+create index if not exists "rings_until" on "calls"."rings" ("until") where "stopped_at" is null;`;
+const hasCallsTables = async (db) => (await sql`select to_regclass('calls.calls') is not null and to_regclass('calls.members') is not null and to_regclass('calls.signals') is not null and to_regclass('calls.rings') is not null as found`.execute(db)).rows[0].found;
+const noticesTable = (events) => `${quoteIdent(changesSchema(events))}."notices"`;
+const hasNotices = async (db, events) => (await sql`select to_regclass(${noticesTable(events)}) is not null as found`.execute(db)).rows[0].found;
+/**
+* The SQL that adds the `calls` schema and its tables, and the changes schema's notices table rings reach open pages
+* through, `undefined` when they are there. They are never dropped.
+*/
+const callsMigration = async (db, events) => {
+	const statements = [...await hasCallsTables(db) ? [] : [callsSchemaSql], ...await hasNotices(db, events) ? [] : [`create schema if not exists ${quoteIdent(changesSchema(events))}`, noticesTableSql(changesSchema(events))]];
+	return statements.length === 0 ? void 0 : `${statements.join(";\n\n")};`;
 };
 /** Refuses to go on while the app has `calls` and the database lacks their tables; the project's migrations add them. */
-const checkCalls = async (db, calls) => {
+const checkCalls = async (db, calls, events) => {
 	if (!calls) return;
-	if (await hasCallsTables(db)) return;
-	throw new Error(`The calls schema is missing, and calls keep their records in it. Write it as a migration with \`${migrationCommand}\`, apply it with the project's migrations, then start again.`);
+	if (await hasCallsTables(db) && await hasNotices(db, events)) return;
+	throw new Error(`The calls schema or the notices table that rings go through is missing. Write them as a migration with \`${migrationCommand}\`, apply it with the project's migrations, then start again.`);
 };
 //#endregion
 export { callsMigration, callsSchemaSql, checkCalls };

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

@@ -11,7 +11,10 @@ export type CallStore = {
   remove: (call: string, member: string) => Promise<boolean>;
   setTracks: (row: string, process: string, tracks: CallRemoteTrack[]) => Promise<void>;
   heartbeat: (process: string, rows: readonly string[]) => Promise<void>;
-  sweep: () => Promise<void>;
+  /** Ends what should have ended: the records whose calls it changed. */
+  sweep: () => Promise<CallRecord[]>;
+  /** The record the call is on; `undefined` for an unknown call. */
+  recordOf: (call: string) => Promise<CallRecord | undefined>;
   rosters: (calls: readonly string[]) => Promise<Map<string, {
     ended: boolean;
     members: RosterMember[];

package/dist/calls/calls-store.js

@@ -1,6 +1,6 @@
+import { admit, callRecord, heartbeat, leave, remove, setTracks } from "./call-store.js";
 import { recordCalls, rosters } from "./call-reads.js";
 import { takeSignals, writeSignal } from "./call-signals-sql.js";
-import { admit, heartbeat, leave, remove, setTracks } from "./call-store.js";
 import { sweepCalls } from "./call-sweep.js";
 //#region src/calls/calls-store.ts
 /** The `calls` schema of the app's database; writes under the API's statement timeout. */
@@ -11,6 +11,7 @@ const sqlCallStore = (db, timeoutMs) => ({
 	setTracks: (row, process, tracks) => setTracks(db, row, process, tracks),
 	heartbeat: (process, rows) => heartbeat(db, process, rows),
 	sweep: () => sweepCalls(db, timeoutMs),
+	recordOf: (call) => callRecord(db, call),
 	rosters: (calls) => rosters(db, calls),
 	recordCalls: (records) => recordCalls(db, records),
 	writeSignal: (signal) => writeSignal(db, signal),

package/dist/calls/member-relay.js

@@ -15,7 +15,7 @@ const refusals = {
 * may not make, and tells the call and the plugin how the socket ended. The plugin only ever sees well-formed messages
 * of a member Protobase let in.
 */
-const memberRelay = ({ door, backend, record, member, rights, maxMembers, maxMinutes, report }) => {
+const memberRelay = ({ door, backend, record, member, rights, maxMembers, maxMinutes, report, user, ring }) => {
 	let browser;
 	let session;
 	let inCall;
@@ -54,7 +54,9 @@ const memberRelay = ({ door, backend, record, member, rights, maxMembers, maxMin
 			member,
 			maxMembers,
 			maxMinutes,
-			...resume && { resume }
+			...resume && { resume },
+			...user !== void 0 && { user },
+			...ring && !resume && { ring }
 		}, {
 			send,
 			close

package/dist/calls/ring-routes.js

@@ -0,0 +1,28 @@
+import { isCallId } from "./call-store.js";
+import { Hono } from "hono";
+import { declineWord } from "@protobase/schema/internal";
+//#region src/calls/ring-routes.ts
+const noStore = { "Cache-Control": "no-store" };
+const userOf = (session) => session.anonymous || session.client ? void 0 : String(session.user.id);
+/**
+* The rings of the signed-in user, mounted at `ringsPath` behind the API's authenticator: `GET /` the calls that ring
+* them now, newest first, and `POST /{call}/decline` stops a call ringing them, on every page they have open. The
+* user comes from the session alone.
+*/
+const ringRoutes = (calls) => {
+	const app = new Hono();
+	app.get("/", async (c) => {
+		const user = userOf(c.get("session"));
+		const items = user === void 0 ? [] : await (await calls.runtime()).rings().of(user);
+		return c.json({ items }, 200, noStore);
+	});
+	app.post(`/:call/${declineWord}`, async (c) => {
+		const user = userOf(c.get("session"));
+		const call = c.req.param("call");
+		if (user !== void 0 && isCallId(call)) await (await calls.runtime()).rings().stop(call, user);
+		return c.body(null, 204);
+	});
+	return app;
+};
+//#endregion
+export { ringRoutes };

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

@@ -0,0 +1,14 @@
+import { RingText } from "./rings-sql.js";
+import { CallRing } from "@protobase/schema/internal";
+import { Db } from "@protobase/query";
+//#region src/calls/ring-store.d.ts
+/** Where the rings of calls are kept and their users' pages told of them: the `calls` schema, or memory in tests. */
+export type RingStore = {
+  start: (call: string, userIds: readonly string[], text: RingText, seconds: number) => Promise<string[]>;
+  stop: (call: string, userId: string) => Promise<boolean>;
+  stopEnded: () => Promise<string[]>;
+  of: (userId: string) => Promise<CallRing[]>;
+  /** Tells these users' open pages that the calls ringing them changed. */
+  notice: (userIds: readonly string[]) => Promise<void>;
+};
+//#endregion

package/dist/calls/ring-store.js

@@ -0,0 +1,12 @@
+import { ringsOf, startRings, stopEndedRings, stopRing, writeRingNotices } from "./rings-sql.js";
+//#region src/calls/ring-store.ts
+/** The `calls` schema's rings, and the notices table of the changes schema `notices`. */
+const sqlRingStore = (db, notices) => ({
+	start: (call, userIds, text, seconds) => startRings(db, call, userIds, text, seconds),
+	stop: (call, userId) => stopRing(db, call, userId),
+	stopEnded: () => stopEndedRings(db),
+	of: (userId) => ringsOf(db, userId),
+	notice: (userIds) => writeRingNotices(db, notices, userIds)
+});
+//#endregion
+export { sqlRingStore };

package/dist/calls/ringer.d.ts

@@ -0,0 +1,40 @@
+import { CallRingInput } from "./call-ring.js";
+import { CallRecord } from "./call-store.js";
+import { RingStore } from "./ring-store.js";
+import { CallRing } from "@protobase/schema/internal";
+//#region src/calls/ringer.d.ts
+/** The bell's entry of a ring, sent to every user it names, also to those on do not disturb. */
+export type RingNotification = {
+  userIds: string[];
+  title: string;
+  body?: string;
+  url?: string;
+  data: {
+    call: string;
+    resource: string;
+    key: string;
+  };
+};
+export type RingerInput = {
+  store: RingStore;
+  /** The users on do not disturb of these, with `status`: they are not rung, and keep the ring in their bell. */
+  doNotDisturb?: (userIds: readonly string[]) => Promise<Set<string>>;
+  /** Sends the bell's entry, with notifications: their push job holds the push of someone on do not disturb. */
+  notify?: (notification: RingNotification) => Promise<void>;
+  /** The record's page in the app, as an absolute URL, where a ring's entry leads by default; none without the app's address. */
+  recordUrl: (record: CallRecord) => string | undefined;
+};
+/**
+ * The rings of calls: started when a join starts a call with a `ring`, stopped for a user once they join the call or
+ * decline it, and for everyone once the call ends. Each change reaches the user's open pages as a live notice.
+ */
+export declare const ringer: ({ store, doNotDisturb, notify, recordUrl }: RingerInput) => {
+  start: (call: string, record: CallRecord, by: string, ring: CallRingInput) => Promise<void>;
+  /** The user joined the call, or declined it: it rings them no more, on any page. */
+  stop: (call: string, userId: string) => Promise<void>;
+  /** Stops the rings of the calls that ended. */
+  settle: () => Promise<void>;
+  of: (userId: string) => Promise<CallRing[]>;
+};
+export type Ringer = ReturnType<typeof ringer>;
+//#endregion

package/dist/calls/ringer.js

@@ -0,0 +1,53 @@
+//#region src/calls/ringer.ts
+/** How long a call rings the people it names, unless they answer or decline first, or it ends. */
+const ringSeconds = 30;
+/**
+* The bell's entry and push of a ring: urgent, kept by push services no longer than a minute, and tagged by its call,
+* its id without hyphens as a push tag takes it, so the call's later pushes replace it.
+*/
+const ringMessage = ({ title, body, url, data }) => ({
+	title,
+	...body !== void 0 && { body },
+	...url !== void 0 && { url },
+	data,
+	urgency: "high",
+	ttl: 60,
+	tag: data.call.replaceAll("-", "")
+});
+/**
+* The rings of calls: started when a join starts a call with a `ring`, stopped for a user once they join the call or
+* decline it, and for everyone once the call ends. Each change reaches the user's open pages as a live notice.
+*/
+const ringer = ({ store, doNotDisturb, notify, recordUrl }) => ({
+	start: async (call, record, by, ring) => {
+		const named = [...new Set(ring.users)].filter((user) => user !== by);
+		if (named.length === 0) return;
+		const quiet = doNotDisturb ? await doNotDisturb(named) : /* @__PURE__ */ new Set();
+		const rung = await store.start(call, named.filter((user) => !quiet.has(user)), {
+			title: ring.title,
+			body: ring.body ?? null
+		}, 30);
+		await store.notice(rung);
+		const url = ring.url ?? recordUrl(record);
+		await notify?.({
+			userIds: named,
+			title: ring.title,
+			...ring.body !== void 0 && { body: ring.body },
+			...url !== void 0 && { url },
+			data: {
+				call,
+				resource: record.resource,
+				key: record.key
+			}
+		});
+	},
+	/** The user joined the call, or declined it: it rings them no more, on any page. */
+	stop: async (call, userId) => {
+		if (await store.stop(call, userId)) await store.notice([userId]);
+	},
+	/** Stops the rings of the calls that ended. */
+	settle: async () => store.notice(await store.stopEnded()),
+	of: (userId) => store.of(userId)
+});
+//#endregion
+export { ringMessage, ringSeconds, ringer };

package/dist/calls/rings-sql.d.ts

@@ -0,0 +1,9 @@
+import { CallRing } from "@protobase/schema/internal";
+import { Db } from "@protobase/query";
+//#region src/calls/rings-sql.d.ts
+/** What a ring says, as the app gives it: the bell and the ringing page show it. */
+export type RingText = {
+  title: string;
+  body: string | null;
+};
+//#endregion

package/dist/calls/rings-sql.js

@@ -0,0 +1,50 @@
+import { quoteIdent } from "../changes/capture-sql.js";
+import { ringNotice } from "@protobase/schema/internal";
+import { sql } from "kysely";
+//#region src/calls/rings-sql.ts
+const users = (values) => `{${values.map((value) => JSON.stringify(value)).join(",")}}`;
+/** Rings these users for the call until `seconds` from now; a user it rang already is not rung again. The users it rang. */
+const startRings = async (db, call, userIds, text, seconds) => {
+	if (userIds.length === 0) return [];
+	const { rows } = await sql`insert into "calls"."rings" ("call_id", "user_id", "title", "body", "rung_at", "until")
+    select ${call}::uuid, u, ${text.title}, ${text.body}, now(), now() + make_interval(secs => ${seconds}) from unnest(${users(userIds)}::text[]) as u
+    on conflict ("call_id", "user_id") do nothing returning "user_id"`.execute(db);
+	return rows.map((row) => row.user_id);
+};
+/** Stops the call ringing the user, as when they joined or declined it: whether it rang them still. */
+const stopRing = async (db, call, userId) => {
+	const { rows } = await sql`update "calls"."rings" set "stopped_at" = now()
+    where "call_id" = ${call}::uuid and "user_id" = ${userId} and "stopped_at" is null and "until" > now() returning "user_id"`.execute(db);
+	return rows.length > 0;
+};
+/** Stops the rings of calls that ended: the users they rang still. */
+const stopEndedRings = async (db) => {
+	const { rows } = await sql`update "calls"."rings" r set "stopped_at" = now() from "calls"."calls" c
+    where c."id" = r."call_id" and r."stopped_at" is null and r."until" > now() and c."ended_at" is not null returning r."user_id"`.execute(db);
+	return [...new Set(rows.map((row) => row.user_id))];
+};
+/** How many rings a page shows at once at most: the newest. */
+const shownRings = 5;
+/** The calls that ring the user now, newest first. */
+const ringsOf = async (db, userId) => {
+	const { rows } = await sql`select r."call_id"::text as call, c."resource", c."record_key" as key, c."started_by", r."title", r."body",
+      greatest(0, ceil(extract(epoch from r."until" - now()) * 1000))::int as remaining_ms
+    from "calls"."rings" r join "calls"."calls" c on c."id" = r."call_id"
+    where r."user_id" = ${userId} and r."stopped_at" is null and r."until" > now() and c."ended_at" is null
+    order by r."rung_at" desc limit ${shownRings}`.execute(db);
+	return rows;
+};
+/**
+* Tells these users' open pages, through the live stream's notices, that the calls ringing them changed. The table is
+* locked against other writers first, so the notice commits in the order of its id and no reader skips it.
+*/
+const writeRingNotices = async (db, schema, userIds) => {
+	if (userIds.length === 0) return;
+	const table = sql.raw(`${quoteIdent(schema)}."notices"`);
+	await db.transaction().execute(async (trx) => {
+		await sql`lock table ${table} in share row exclusive mode`.execute(trx);
+		await sql`insert into ${table} ("resource", "record_key", "operation") select ${ringNotice}, u, 'update' from unnest(${users([...new Set(userIds)])}::text[]) as u`.execute(trx);
+	});
+};
+//#endregion
+export { ringsOf, startRings, stopEndedRings, stopRing, writeRingNotices };

package/dist/create-admin.js

@@ -60,6 +60,7 @@ import { createWebhooks } from "./webhooks/webhooks.js";
 import { webhookTable } from "./webhooks/table/webhook-table.js";
 import { subscriptionUrlCheck, subscriptionWriteCheck } from "./webhooks/table/validate-hook.js";
 import { callsService } from "./calls/calls-service.js";
+import { ringRoutes } from "./calls/ring-routes.js";
 import { deviceStore, removeDevicesWithUsers } from "./notifications/device-store-of.js";
 import { historyStore, removeHistoryWithUsers } from "./notifications/history-store-of.js";
 import { devicesPath, historyPath } from "./notifications/paths.js";
@@ -111,7 +112,7 @@ import { createScanGuard } from "./scan-guard.js";
 import { failedJobs, failedJobsView } from "./jobs/failed-jobs.js";
 import { Hono } from "hono";
 import { accountPage, accountPageName, checkPages, settingsResources, withSettingsFields } from "@protobase/layout";
-import { statusPath } from "@protobase/schema/internal";
+import { ringsPath, statusPath } from "@protobase/schema/internal";
 //#region src/create-admin.ts
 const declaredRoles = (auth, roles) => {
 	const names = [...auth?.roles ?? [], ...Object.keys(roles?.definitions ?? {})];
@@ -265,7 +266,13 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 			...model && { model },
 			...options.onUnhandledError && { report: options.onUnhandledError }
 		} },
-		...calls && { calls: callsService(() => deps, calls) }
+		...calls && { calls: callsService(() => deps, calls, {
+			notices: changes,
+			channels: () => channels,
+			notifications: Boolean(notifications),
+			...auth?.origins[0] && { origin: auth.origins[0] },
+			...statusTables && { doNotDisturb: (ringDb, userIds) => onDoNotDisturb(ringDb, statusTables.statuses, userIds) }
+		}) }
 	};
 	const appName = shownAppName(auth, globalThis.process?.env ?? {});
 	const meta = createMeta(deps, appName, icons?.favicon ? faviconPath : void 0);
@@ -461,6 +468,7 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 		app.route(historyPath(systemPath), guarded((routes) => void routes.route("/", historyRoutes(history, auth?.origins ?? []))));
 	}
 	if (statusTables) app.route(statusPath(systemPath), guarded((routes) => void routes.route("/", statusRoutes(db, statusTables))));
+	if (deps.calls) app.route(ringsPath(systemPath), guarded((routes) => void routes.route("/", ringRoutes(deps.calls))));
 	if (forms) app.route(`${systemPath}/forms`, formRoutes(deps, forms));
 	const feed = tableFeed({
 		db,
@@ -502,7 +510,7 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 			}));
 		}
 	}
-	if (appModels.some((model) => model.live)) app.route(systemPath || "/", guarded((live) => void live.route("/", liveRoutes(feed, (session) => visibleNotices(deps, session))), withAnonymous(authenticate, options.roles)));
+	if (appModels.some((model) => model.live) || deps.calls) app.route(systemPath || "/", guarded((live) => void live.route("/", liveRoutes(feed, (session) => visibleNotices(deps, session))), withAnonymous(authenticate, options.roles)));
 	app.route(basePath, api);
 	app.route(`${deps.systemPath}/meta`, metaApp);
 	app.route(systemPath || "/", webManifestRoute(appName, identity, icons));

package/dist/index.js

@@ -63,21 +63,22 @@ import { recordOf, resourceChange } from "./changes/resource-change.js";
 import { defineFunction } from "./functions/define-function.js";
 import { newWebhookSecret } from "./webhooks/standard-webhooks.js";
 import { subscription } from "./webhooks/subscription.js";
+import { historyIdPattern, historyLimits } from "./notifications/history.js";
+import { PushMessageError, maxTtlSeconds, pushMessage, urgencies } from "./notifications/message.js";
+import { NotificationSendError, maxMessageBytes, maxRecipients } from "./notifications/send-input.js";
+import { sendNotification } from "./notifications/send-notification.js";
 import { maxHistoryPage, maxUnreadCount } from "./notifications/history-store.js";
 import { generateVapidKeys } from "./notifications/web-push/keys.js";
 import { DeviceStoreError, postgresDeviceStore } from "./notifications/postgres-store.js";
 import { deviceStore, removeDevicesWithUsers } from "./notifications/device-store-of.js";
-import { historyIdPattern, historyLimits } from "./notifications/history.js";
 import { HistoryStoreError, postgresHistoryStore } from "./notifications/postgres-history-store.js";
 import { historyStore, removeHistoryWithUsers } from "./notifications/history-store-of.js";
 import { deviceIdParam, devicesPath, historyIdParam, historyPath } from "./notifications/paths.js";
 import { defaultHistoryPage } from "./notifications/history-routes.js";
 import { maxDevicesPerUser } from "./notifications/routes.js";
-import { PushMessageError, maxTtlSeconds, pushMessage, urgencies } from "./notifications/message.js";
 import { readVapidSettings, vapidPrivateKeyVariable, vapidPublicKeyVariable, vapidSubjectVariable } from "./notifications/web-push/vapid-settings.js";
 import { webPushSender } from "./notifications/web-push/web-push-sender.js";
 import { notificationSenders } from "./notifications/senders-of.js";
-import { NotificationSendError, maxMessageBytes, maxRecipients } from "./notifications/send-input.js";
 import { onDoNotDisturb } from "./status/do-not-disturb.js";
 import { statusNames } from "./status/options.js";
 import { errorReportingSettings, errorReportingVariable } from "./error-reporting/error-reporting-settings.js";
@@ -115,7 +116,6 @@ import { channelSendsMigration, checkChannelSends } from "./channels/sends-schem
 import { callsMigration, checkCalls } from "./calls/calls-sql.js";
 import { checkAi } from "./ai/check-ai.js";
 import { checkNotificationsSchema, notificationsMigration } from "./notifications/schema.js";
-import { sendNotification } from "./notifications/send-notification.js";
 import { checkStatusSchema, statusMigration } from "./status/schema.js";
 import { maxWidgetPropsBytes, widget } from "./assistant/widget.js";
 import { checkQueryRunner, queryRunnerMigration } from "./assistant/query-runner/query-runner.js";

package/dist/jobs/runtime.js

@@ -4,8 +4,8 @@ import "./schedule.js";
 import { runJob, validatePayload } from "./run-job.js";
 import { platformMailer } from "../mail/platform-mailer.js";
 import "../notifications/push-job-name.js";
-import { runInBackground } from "../background-work.js";
 import { sendNotification } from "../notifications/send-notification.js";
+import { runInBackground } from "../background-work.js";
 import { busyDatabase } from "./busy-database.js";
 import { jobsDatabase } from "./database.js";
 import { queueOptions, queueSettingsDiffer, sendOptions, workOptions } from "./options.js";

package/dist/live/visible-notices.js

@@ -1,8 +1,10 @@
 import { requestAccess } from "../request-access.js";
+import { ringNotice } from "@protobase/schema/internal";
 //#region src/live/visible-notices.ts
 /**
-* Which notices a caller hears of: those of the live resources they may list or read, in their tenant. A notice names
-* a record, never its values, and the page reads the record again as the caller, so no row filter applies here.
+* Which notices a caller hears of: those of the live resources they may list or read, in their tenant, and, with
+* calls, those of the calls that ring them (`ringNotice`, keyed by the user's id). A notice names a record, never its
+* values, and the page reads the record again as the caller, so no row filter applies here.
 */
 const visibleNotices = async (deps, session) => {
 	const readable = /* @__PURE__ */ new Map();
@@ -12,7 +14,11 @@ const visibleNotices = async (deps, session) => {
 		if (entry.model.tenant && session.tenant === void 0) continue;
 		readable.set(entry.name, entry.model.tenant ? String(session.tenant) : void 0);
 	}
-	return (notice) => readable.has(notice.resource) && (readable.get(notice.resource) === void 0 || readable.get(notice.resource) === notice.tenant);
+	const rung = deps.calls && !session.anonymous && !session.client ? String(session.user.id) : void 0;
+	return (notice) => {
+		if (notice.resource === ringNotice) return rung !== void 0 && notice.key === rung;
+		return readable.has(notice.resource) && (readable.get(notice.resource) === void 0 || readable.get(notice.resource) === notice.tenant);
+	};
 };
 //#endregion
 export { visibleNotices };

package/dist/meta.d.ts

@@ -61,6 +61,8 @@ export type CallerMeta = {
   };
   /** With `status: {}`: people set their own status, and see the statuses of those they share an organization with. */
   status?: true;
+  /** With `calls`: the app's calls ring people, on any page they have open, through the live stream. */
+  calls?: true;
   /** The language the admin app's screens are in, when the app sets one for everyone. */
   locale?: Locale;
   /** The hosts besides the app's own whose images the admin app draws with the page's referrer, when there are any. */

package/dist/meta.js

@@ -98,6 +98,7 @@ const createMeta = (deps, appName, appIcon) => {
 				...deps.webPushKey && { webPushKey: deps.webPushKey }
 			} },
 			...deps.status && { status: true },
+			...deps.calls && { calls: true },
 			...deps.locale && { locale: deps.locale },
 			...deps.files && deps.files.trustedHosts.length > 0 && { files: { trustedHosts: deps.files.trustedHosts } },
 			...plugins.length > 0 && { plugins },

package/dist/notifications/deliver.js

@@ -1,7 +1,7 @@
 import { FatalJobError } from "../jobs/run-job.js";
 import { PushMessageError } from "./message.js";
-import { PushSenderError } from "./guarded-sender.js";
 import { historyEntry } from "./send-input.js";
+import { PushSenderError } from "./guarded-sender.js";
 import { NotificationStoreError, storeCall } from "./store-call.js";
 //#region src/notifications/deliver.ts
 const tally = () => ({

package/dist/notifications/history-routes.js

@@ -1,6 +1,6 @@
 import { badRequest } from "../problem.js";
-import "./history-store.js";
 import { historyIdPattern } from "./history.js";
+import "./history-store.js";
 import { ownSignInUser } from "./caller.js";
 import { historyCursor, historyPosition } from "./history-cursor.js";
 import { jsonBody, jsonOnly, limitedBody, queryOf } from "./history-request.js";

package/dist/notifications/postgres-history-store.js

@@ -1,7 +1,7 @@
 import { isDatabaseError } from "../error-handler.js";
+import { checkedNotification } from "./history.js";
 import { requiredPage, requiredText, requiredTime } from "./history-store.js";
 import { historyColumns, historyNames } from "./options.js";
-import { checkedNotification } from "./history.js";
 import { sql } from "kysely";
 //#region src/notifications/postgres-history-store.ts
 /**

package/dist/notifications/push-job.js

@@ -1,11 +1,11 @@
 import { defineJob } from "../jobs/define-job.js";
+import { pushJobName } from "./push-job-name.js";
 import { deviceStore } from "./device-store-of.js";
 import { HistoryStoreError } from "./postgres-history-store.js";
 import { historyStore } from "./history-store-of.js";
 import { holdJob, replaceJobData, saveJobProgress } from "../jobs/job-progress.js";
 import { deliver } from "./deliver.js";
 import { noProgress, pushPayload } from "./push-payload.js";
-import { pushJobName } from "./push-job-name.js";
 //#region src/notifications/push-job.ts
 const userGone = "23503";
 /**

package/dist/notifications/send-notification.js

@@ -1,6 +1,6 @@
 import { currentJobs } from "../jobs/current.js";
-import { checkedSend } from "./send-input.js";
 import { pushJobName } from "./push-job-name.js";
+import { checkedSend } from "./send-input.js";
 //#region src/notifications/send-notification.ts
 /**
 * Sends `message` to users or to devices as a background job, enqueued in `db`'s transaction when it is one, so it

package/dist/notifications/web-push/web-push-sender.js

@@ -1,6 +1,6 @@
+import { PushMessageError, pushMessage } from "../message.js";
 import { fromBase64url, isPublicPoint } from "./keys.js";
 import { isPushEndpoint } from "../push-hosts.js";
-import { PushMessageError, pushMessage } from "../message.js";
 import { encryptPayload, maxPlaintextBytes } from "./encrypt.js";
 import { webPushPayload } from "./payload.js";
 import { postPush } from "./post.js";

package/dist/package.js

@@ -1,4 +1,4 @@
 //#region package.json
-var version = "0.62.1";
+var version = "0.62.2";
 //#endregion
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/server",
-  "version": "0.62.1",
+  "version": "0.62.2",
   "description": "The Protobase REST API as a Hono app, with Better Auth sign-in.",
   "license": "Apache-2.0",
   "repository": {
@@ -42,9 +42,9 @@
     "@better-auth/sso": "^1.7.12",
     "@livekit/protocol": "1.53.1",
     "@modelcontextprotocol/server": "^2.3.1",
-    "@protobase/layout": "0.62.1",
-    "@protobase/query": "0.62.1",
-    "@protobase/schema": "0.62.1",
+    "@protobase/layout": "0.62.2",
+    "@protobase/query": "0.62.2",
+    "@protobase/schema": "0.62.2",
     "@react-email/render": "^2.1.0",
     "@scalar/hono-api-reference": "^0.12.10",
     "@sentry/core": "^11.7.0",