@protobase/server 0.58.4 → 0.58.6

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

@@ -0,0 +1,14 @@
+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;
+  /** 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;
+};
+//#endregion

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

@@ -0,0 +1,13 @@
+import { SocketEvents } from "../functions/function-socket.js";
+import { CallMember } from "./call-member.js";
+//#region src/calls/calls-access.d.ts
+/** What a function admits members to calls with. */
+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.
+   */
+  join: (member: CallMember) => Promise<SocketEvents>;
+};
+//#endregion

package/dist/calls/calls-access.js

@@ -0,0 +1,25 @@
+//#region src/calls/calls-access.ts
+const checkMember = ({ call, member }) => {
+	if (typeof call !== "string" || call.length === 0) throw new TypeError("calls.join needs the call, a non-empty string");
+	if (typeof member !== "string" || member.length === 0) throw new TypeError("calls.join needs the member, a non-empty string");
+};
+const loadBackend = async (settings) => {
+	if (settings.kind === "livekit") return (await import("./livekit/livekit-session.js")).liveKitBackend(settings);
+	return (await import("./peer/peer-backend.js")).peerBackend(settings);
+};
+/**
+* Calls as a function sees them: each member's socket goes through the relay to the configured plugin, made once, at
+* the first join, so an app without calls loads none of their code.
+*/
+const callsAccess = (options) => {
+	let backend;
+	return { join: async (member) => {
+		if (!options) throw new Error("This app has no calls: configure calls: { backend } in protobase.config.ts");
+		checkMember(member);
+		backend ??= loadBackend(options.backend);
+		const [{ memberRelay }, plugin] = await Promise.all([import("./member-relay.js"), backend]);
+		return memberRelay(plugin, member);
+	} };
+};
+//#endregion
+export { callsAccess };

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

@@ -0,0 +1,33 @@
+//#region src/calls/calls-options.d.ts
+/** A LiveKit server, self-hosted or LiveKit Cloud, that carries the calls' media. */
+export type LiveKitBackend = {
+  kind: 'livekit';
+  /** Its address, such as `wss://livekit.example.com` or `ws://127.0.0.1:7880`. */
+  url: string;
+  /** The API key and secret Protobase signs each member's LiveKit token with. */
+  apiKey: string;
+  apiSecret: string;
+};
+/** An ICE server the members' browsers reach each other through, such as a STUN or TURN server. */
+export type CallIceServer = {
+  urls: string[];
+  username?: string;
+  credential?: string;
+};
+/**
+ * No media server: each member's browser sends its media to every other member's, and Protobase passes their offers,
+ * answers and candidates between them. For small calls; members meet only on the same process.
+ */
+export type PeerBackend = {
+  kind: 'peer';
+  iceServers?: CallIceServer[];
+};
+/** The media plugin a call's members send and receive their media through. */
+export type CallBackend = LiveKitBackend | PeerBackend;
+/** Calls: the media plugin behind them. Without `calls`, an app loads none of the calls code. */
+export type CallsOptions = {
+  backend: CallBackend;
+};
+/** The options, or an error naming what is wrong with them: the backend's kind and each of its settings. */
+export declare const checkCallsOptions: (options: CallsOptions) => CallsOptions;
+//#endregion

package/dist/calls/calls-options.js

@@ -0,0 +1,21 @@
+//#region src/calls/calls-options.ts
+const nonEmpty = (value) => typeof value === "string" && value.length > 0;
+/** The options, or an error naming what is wrong with them: the backend's kind and each of its settings. */
+const checkCallsOptions = (options) => {
+	const backend = options?.backend;
+	if (backend?.kind === "peer") {
+		const servers = backend.iceServers;
+		if (servers !== void 0 && (!Array.isArray(servers) || servers.some((server) => !Array.isArray(server?.urls) || !server.urls.every(nonEmpty)))) throw new Error("calls.backend.iceServers must be a list of { urls: string[], username?, credential? }");
+		return options;
+	}
+	if (backend?.kind !== "livekit") throw new Error(`calls.backend.kind must be 'livekit' or 'peer', not ${JSON.stringify(backend?.kind)}`);
+	for (const key of [
+		"url",
+		"apiKey",
+		"apiSecret"
+	]) if (!nonEmpty(backend[key])) throw new Error(`calls.backend.${key} must be a non-empty string, such as from an environment variable`);
+	if (!/^(wss?|https?):\/\//.test(backend.url)) throw new Error(`calls.backend.url must start with wss://, ws://, https:// or http://, not ${backend.url}`);
+	return options;
+};
+//#endregion
+export { checkCallsOptions };

package/dist/calls/client-message.js

@@ -0,0 +1,106 @@
+import { z } from "zod";
+//#region src/calls/client-message.ts
+const id = z.string().min(1).max(256);
+const sdp = z.string().min(1).max(262144);
+const kind = z.enum(["audio", "video"]);
+const size = z.number().int().min(0).max(16384);
+const layer = z.strictObject({
+	quality: z.enum([
+		"low",
+		"medium",
+		"high"
+	]),
+	width: size,
+	height: size,
+	bitrate: z.number().int().min(0).max(1e8)
+});
+const source = z.enum([
+	"camera",
+	"microphone",
+	"screen",
+	"screen-audio"
+]);
+const track = z.strictObject({
+	cid: id,
+	kind,
+	source,
+	width: size.optional(),
+	height: size.optional(),
+	layers: z.array(layer).max(3).optional()
+});
+const candidate = z.strictObject({
+	candidate: z.string().max(4096),
+	sdpMid: z.string().max(64).nullable().optional(),
+	sdpMLineIndex: z.number().int().min(0).max(1024).nullable().optional(),
+	usernameFragment: z.string().max(256).nullable().optional()
+});
+const description = z.strictObject({
+	type: z.enum(["offer", "answer"]),
+	sdp
+});
+const message = z.discriminatedUnion("type", [
+	z.strictObject({ type: z.literal("join") }),
+	z.strictObject({
+		type: z.literal("resume"),
+		participant: id,
+		offer: sdp.optional(),
+		answer: sdp.optional(),
+		tracks: z.array(z.strictObject({
+			cid: id,
+			sid: id,
+			kind,
+			source
+		})).max(16)
+	}),
+	z.strictObject({
+		type: z.literal("publish"),
+		tracks: z.array(track).min(1).max(4)
+	}),
+	z.strictObject({
+		type: z.literal("offer"),
+		sdp,
+		id: z.number().int().min(0)
+	}),
+	z.strictObject({
+		type: z.literal("candidate"),
+		candidate
+	}),
+	z.strictObject({
+		type: z.literal("unpublish"),
+		sid: id
+	}),
+	z.strictObject({
+		type: z.literal("mute"),
+		sid: id,
+		muted: z.boolean()
+	}),
+	z.strictObject({
+		type: z.literal("signal"),
+		to: id,
+		description: description.optional(),
+		candidate: candidate.optional()
+	}),
+	z.strictObject({
+		type: z.literal("view"),
+		sids: z.array(id).min(1).max(256),
+		width: size,
+		height: size,
+		hidden: z.boolean().optional()
+	}),
+	z.strictObject({ type: z.literal("leave") })
+]);
+/** A browser's message, or `undefined` when it is no message of the call protocol. */
+const parseClientMessage = (data) => {
+	if (typeof data !== "string") return void 0;
+	let json;
+	try {
+		json = JSON.parse(data);
+	} catch (error) {
+		if (error instanceof SyntaxError) return void 0;
+		throw error;
+	}
+	const parsed = message.safeParse(json);
+	return parsed.success ? parsed.data : void 0;
+};
+//#endregion
+export { parseClientMessage };

package/dist/calls/livekit/join-url.js

@@ -0,0 +1,33 @@
+import { ClientInfo, ClientInfo_SDK, ConnectionSettings, JoinRequest, WrappedJoinRequest, WrappedJoinRequest_Compression } from "@livekit/protocol";
+/** The bridge as LiveKit's client info names it. */
+const clientInfo = () => new ClientInfo({
+	sdk: ClientInfo_SDK.UNKNOWN,
+	protocol: 17,
+	version: "protobase-calls-1"
+});
+/**
+* The single peer connection signal endpoint (`/rtc/v1`) with the member's token and join request. The request is
+* standard base64 with `+` and `/` replaced and the `=` padding kept, which LiveKit's decoder needs.
+*/
+const joinUrl = (base, token, { resume }) => {
+	const join = new JoinRequest({
+		clientInfo: clientInfo(),
+		connectionSettings: new ConnectionSettings({
+			autoSubscribe: false,
+			adaptiveStream: false
+		}),
+		reconnect: resume !== void 0,
+		participantSid: resume?.participant ?? ""
+	});
+	const wrapped = new WrappedJoinRequest({
+		compression: WrappedJoinRequest_Compression.NONE,
+		joinRequest: join.toBinary()
+	});
+	const encoded = Buffer.from(wrapped.toBinary()).toString("base64").replaceAll("+", "-").replaceAll("/", "_");
+	const url = new URL("rtc/v1", `${base.replace(/\/+$/, "")}/`);
+	url.searchParams.set("access_token", token);
+	url.searchParams.set("join_request", encoded);
+	return url.href;
+};
+//#endregion
+export { joinUrl };

package/dist/calls/livekit/livekit-session.js

@@ -0,0 +1,323 @@
+import { resumeCloseCode } from "../media-backend.js";
+import { joinUrl } from "./join-url.js";
+import { liveKitToken } from "./livekit-token.js";
+import { openSignalSocket } from "./signal-socket.js";
+import { grantSources, liveKitQuality, liveKitSource, remoteTracksOf } from "./track-mapping.js";
+import { AddTrackRequest, DisconnectReason, LeaveRequest, LeaveRequest_Action, MuteTrackRequest, ParticipantInfo_State, RequestResponse_Reason, SessionDescription, SignalTarget, SyncState, TrackInfo, TrackPublishedResponse, TrackType, TrickleRequest, UpdateSubscription, UpdateTrackSettings, VideoLayer } from "@livekit/protocol";
+//#region src/calls/livekit/livekit-session.ts
+/** How long the media server has to accept a track before the publish is refused. */
+const publishTimeoutMs = 1e4;
+/** LiveKit's own ping defaults, for a resumed session, whose answer carries none. */
+const resumePing = {
+	interval: 5,
+	timeout: 15
+};
+const leftReason = (leave) => {
+	if (leave.action === LeaveRequest_Action.RECONNECT) return "rejoin";
+	if (leave.reason === DisconnectReason.PARTICIPANT_REMOVED || leave.reason === DisconnectReason.DUPLICATE_IDENTITY) return "removed";
+	return "ended";
+};
+const syncState = (resume) => new SyncState({
+	offer: new SessionDescription({
+		type: "offer",
+		sdp: resume.offer
+	}),
+	answer: new SessionDescription({
+		type: "answer",
+		sdp: resume.answer
+	}),
+	publishTracks: resume.tracks.map((track) => new TrackPublishedResponse({
+		cid: track.cid,
+		track: new TrackInfo({
+			sid: track.sid,
+			type: track.kind === "audio" ? TrackType.AUDIO : TrackType.VIDEO
+		})
+	})),
+	subscription: new UpdateSubscription({
+		subscribe: true,
+		trackSids: []
+	})
+});
+const addTrackRequest = (track) => new AddTrackRequest({
+	cid: track.cid,
+	name: track.source,
+	type: track.kind === "audio" ? TrackType.AUDIO : TrackType.VIDEO,
+	source: liveKitSource(track.source),
+	width: track.width ?? 0,
+	height: track.height ?? 0,
+	layers: (track.layers ?? []).map((layer) => new VideoLayer({
+		quality: liveKitQuality(layer.quality),
+		width: layer.width,
+		height: layer.height,
+		bitrate: layer.bitrate
+	}))
+});
+/**
+* One member's LiveKit signal session, in this process: the browser's call messages become LiveKit's signal requests,
+* and LiveKit's answers, candidates and room changes become call messages. Protobase decides who hears what: nothing is
+* subscribed until `hears` admits it. The session keeps nothing a new one could not rebuild from the browser's `resume`,
+* so a member moves to another session, or process, without losing media.
+*/
+const liveKitSession = (backend, member, link, deps) => {
+	const hears = member.hears ?? (() => true);
+	let signal;
+	let finished = false;
+	const participants = /* @__PURE__ */ new Map();
+	const heard = /* @__PURE__ */ new Set();
+	const publishing = /* @__PURE__ */ new Map();
+	const toBrowser = (message) => link.send(message);
+	const finish = (code, reason) => {
+		if (finished) return;
+		finished = true;
+		signal?.close();
+		for (const pending of publishing.values()) pending.reject("The call session ended");
+		link.close(code, reason);
+	};
+	const leave = () => {
+		signal?.send({
+			case: "leave",
+			value: new LeaveRequest({
+				reason: DisconnectReason.CLIENT_INITIATED,
+				action: LeaveRequest_Action.DISCONNECT
+			})
+		});
+		finish(1e3, "left");
+	};
+	const updateTracks = () => {
+		const tracks = remoteTracksOf([...participants.values()]).filter(hears);
+		const added = tracks.filter((track) => !heard.has(track.sid)).map((track) => track.sid);
+		const current = new Set(tracks.map((track) => track.sid));
+		for (const sid of heard) if (!current.has(sid)) heard.delete(sid);
+		for (const sid of added) heard.add(sid);
+		if (added.length > 0) signal?.send({
+			case: "subscription",
+			value: new UpdateSubscription({
+				trackSids: added,
+				subscribe: true
+			})
+		});
+		toBrowser({
+			type: "tracks",
+			tracks
+		});
+	};
+	const updateParticipants = (infos, self) => {
+		for (const info of infos) {
+			if (info.identity === self) continue;
+			if (info.state === ParticipantInfo_State.DISCONNECTED) participants.delete(info.sid);
+			else participants.set(info.sid, info);
+		}
+		updateTracks();
+	};
+	const onSignal = (message) => {
+		switch (message.case) {
+			case "join": {
+				const join = message.value;
+				signal.keepAlive(join.pingInterval || resumePing.interval, join.pingTimeout || resumePing.timeout);
+				toBrowser({
+					type: "joined",
+					mode: "sfu",
+					participant: join.participant.sid,
+					iceServers: join.iceServers.map((server) => ({
+						urls: server.urls,
+						...server.username && {
+							username: server.username,
+							credential: server.credential
+						}
+					}))
+				});
+				updateParticipants(join.otherParticipants, member.member);
+				return;
+			}
+			case "reconnect":
+				signal.keepAlive(resumePing.interval, resumePing.timeout);
+				toBrowser({ type: "resumed" });
+				return;
+			case "answer":
+				toBrowser({
+					type: "answer",
+					sdp: message.value.sdp,
+					id: message.value.id,
+					mids: message.value.midToTrackId
+				});
+				return;
+			case "trickle":
+				toBrowser({
+					type: "candidate",
+					candidate: JSON.parse(message.value.candidateInit)
+				});
+				return;
+			case "mediaSectionsRequirement":
+				toBrowser({
+					type: "sections",
+					audio: message.value.numAudios,
+					video: message.value.numVideos
+				});
+				return;
+			case "update":
+				updateParticipants(message.value.participants, member.member);
+				return;
+			case "trackPublished":
+				publishing.get(message.value.cid)?.resolve(message.value.track.sid);
+				return;
+			case "requestResponse": {
+				const { request, reason, message: why } = message.value;
+				if (request.case === "addTrack" && reason !== RequestResponse_Reason.OK) publishing.get(request.value.cid)?.reject(why || RequestResponse_Reason[reason]);
+				return;
+			}
+			case "trackUnpublished":
+				toBrowser({
+					type: "unpublished",
+					sid: message.value.trackSid
+				});
+				return;
+			case "speakersChanged":
+				toBrowser({
+					type: "speakers",
+					speakers: message.value.speakers.flatMap((speaker) => {
+						const info = participants.get(speaker.sid);
+						return info ? [{
+							member: info.identity,
+							level: speaker.active ? speaker.level : 0
+						}] : [];
+					})
+				});
+				return;
+			case "leave": {
+				const leave = message.value;
+				if (leave.action === LeaveRequest_Action.RESUME) return finish(resumeCloseCode, "resume");
+				toBrowser({
+					type: "left",
+					reason: leftReason(leave)
+				});
+				return finish(1e3, "left");
+			}
+		}
+	};
+	const connect = async (options) => {
+		const canPublish = member.publish !== false && !(Array.isArray(member.publish) && member.publish.length === 0);
+		const token = await liveKitToken(backend, {
+			room: member.call,
+			identity: member.member,
+			canPublish,
+			...Array.isArray(member.publish) && { canPublishSources: member.publish.map((source) => grantSources[source]) }
+		});
+		signal = deps.connect({
+			url: joinUrl(backend.url.replace(/^http/, "ws"), token, options),
+			onMessage: onSignal,
+			onClose: () => finish(resumeCloseCode, "resume")
+		});
+	};
+	const publish = async (tracks) => {
+		const published = tracks.map((track) => new Promise((resolve, reject) => {
+			const timer = setTimeout(() => reject("The media server did not accept the track in time"), publishTimeoutMs);
+			const settle = () => {
+				clearTimeout(timer);
+				publishing.delete(track.cid);
+			};
+			publishing.set(track.cid, {
+				resolve: (sid) => (settle(), resolve({
+					cid: track.cid,
+					sid
+				})),
+				reject: (reason) => (settle(), reject(reason))
+			});
+			signal.send({
+				case: "addTrack",
+				value: addTrackRequest(track)
+			});
+		}));
+		const settled = await Promise.allSettled(published);
+		const refused = settled.find((result) => result.status === "rejected");
+		if (refused) return toBrowser({
+			type: "publish-refused",
+			reason: String(refused.reason)
+		});
+		toBrowser({
+			type: "published",
+			tracks: settled.map((result) => result.value)
+		});
+	};
+	const receive = async (message) => {
+		if (message.type === "join") return connect({});
+		if (message.type === "resume") {
+			if (!message.offer || !message.answer) {
+				toBrowser({
+					type: "left",
+					reason: "rejoin"
+				});
+				return finish(1e3, "left");
+			}
+			await connect({ resume: { participant: message.participant } });
+			signal.send({
+				case: "syncState",
+				value: syncState({
+					...message,
+					offer: message.offer,
+					answer: message.answer
+				})
+			});
+			return;
+		}
+		if (!signal || finished) return;
+		switch (message.type) {
+			case "publish": return publish(message.tracks);
+			case "offer": return signal.send({
+				case: "offer",
+				value: new SessionDescription({
+					type: "offer",
+					sdp: message.sdp,
+					id: message.id
+				})
+			});
+			case "candidate": return signal.send({
+				case: "trickle",
+				value: new TrickleRequest({
+					candidateInit: JSON.stringify(message.candidate),
+					target: SignalTarget.PUBLISHER
+				})
+			});
+			case "mute": return signal.send({
+				case: "mute",
+				value: new MuteTrackRequest({
+					sid: message.sid,
+					muted: message.muted
+				})
+			});
+			case "view": {
+				const sids = message.sids.filter((sid) => heard.has(sid));
+				if (sids.length === 0) return;
+				return signal.send({
+					case: "trackSetting",
+					value: new UpdateTrackSettings({
+						trackSids: sids,
+						disabled: message.hidden ?? false,
+						width: message.width,
+						height: message.height
+					})
+				});
+			}
+			case "leave": return leave();
+		}
+	};
+	return {
+		receive,
+		end: (how) => {
+			if (finished) return;
+			finished = true;
+			if (how === "left") signal?.send({
+				case: "leave",
+				value: new LeaveRequest({
+					reason: DisconnectReason.PARTICIPANT_REMOVED,
+					action: LeaveRequest_Action.DISCONNECT
+				})
+			});
+			signal?.close();
+			for (const pending of publishing.values()) pending.reject("The call session ended");
+		}
+	};
+};
+/** The LiveKit plugin: each member's signal session to a LiveKit server, self-hosted or LiveKit Cloud. */
+const liveKitBackend = (settings, deps = { connect: openSignalSocket }) => ({ open: (member, link) => liveKitSession(settings, member, link, deps) });
+//#endregion
+export { liveKitBackend };

package/dist/calls/livekit/livekit-token.js

@@ -0,0 +1,26 @@
+import { SignJWT } from "jose";
+//#region src/calls/livekit/livekit-token.ts
+/** How long a member's token admits a join; a resume mints a new one. */
+const tokenSeconds = 600;
+/**
+* A LiveKit access token for one member of one room, signed with the backend's key: no name, metadata or data
+* messages, since names, roles and chat stay in Protobase.
+*/
+const liveKitToken = async ({ apiKey, apiSecret }, grant) => {
+	const now = Math.floor(Date.now() / 1e3);
+	const video = {
+		room: grant.room,
+		roomJoin: true,
+		canSubscribe: true,
+		canPublish: grant.canPublish,
+		canPublishData: false,
+		canUpdateOwnMetadata: false,
+		...grant.canPublishSources && { canPublishSources: grant.canPublishSources }
+	};
+	return new SignJWT({ video }).setProtectedHeader({
+		alg: "HS256",
+		typ: "JWT"
+	}).setIssuer(apiKey).setSubject(grant.identity).setNotBefore(now).setExpirationTime(now + tokenSeconds).setJti(grant.identity).sign(new TextEncoder().encode(apiSecret));
+};
+//#endregion
+export { liveKitToken };

package/dist/calls/livekit/signal-socket.js

@@ -0,0 +1,60 @@
+import { Ping, SignalRequest, SignalResponse } from "@livekit/protocol";
+//#region src/calls/livekit/signal-socket.ts
+/** A WebSocket to LiveKit's signal endpoint speaking its protobuf messages, for one member. */
+const openSignalSocket = ({ url, onMessage, onClose }) => {
+	const socket = new WebSocket(url);
+	socket.binaryType = "arraybuffer";
+	let pinger;
+	let lastPong = Date.now();
+	let closed = false;
+	const queued = [];
+	const stop = () => {
+		if (closed) return false;
+		closed = true;
+		clearInterval(pinger);
+		return true;
+	};
+	const close = () => {
+		if (stop()) socket.close();
+	};
+	socket.onmessage = (event) => {
+		const { message } = SignalResponse.fromBinary(new Uint8Array(event.data));
+		if (message.case === "pongResp") lastPong = Date.now();
+		onMessage(message);
+	};
+	socket.onopen = () => {
+		for (const data of queued.splice(0)) socket.send(data);
+	};
+	socket.onclose = () => {
+		if (stop()) onClose();
+	};
+	socket.onerror = () => {};
+	const send = (message) => {
+		const data = new SignalRequest({ message }).toBinary();
+		if (socket.readyState === WebSocket.CONNECTING) queued.push(data);
+		else if (socket.readyState === WebSocket.OPEN) socket.send(data);
+	};
+	return {
+		send,
+		keepAlive: (intervalSeconds, timeoutSeconds) => {
+			clearInterval(pinger);
+			lastPong = Date.now();
+			pinger = setInterval(() => {
+				if (Date.now() - lastPong > timeoutSeconds * 1e3) {
+					if (stop()) {
+						socket.close();
+						onClose();
+					}
+					return;
+				}
+				send({
+					case: "pingReq",
+					value: new Ping({ timestamp: BigInt(Date.now()) })
+				});
+			}, intervalSeconds * 1e3);
+		},
+		close
+	};
+};
+//#endregion
+export { openSignalSocket };

package/dist/calls/livekit/track-mapping.js

@@ -0,0 +1,36 @@
+import { ParticipantInfo_State, TrackSource, TrackType, VideoQuality } from "@livekit/protocol";
+//#region src/calls/livekit/track-mapping.ts
+const sources = {
+	camera: TrackSource.CAMERA,
+	microphone: TrackSource.MICROPHONE,
+	screen: TrackSource.SCREEN_SHARE,
+	"screen-audio": TrackSource.SCREEN_SHARE_AUDIO
+};
+/** The names LiveKit's token grants give each source in `canPublishSources`. */
+const grantSources = {
+	camera: "camera",
+	microphone: "microphone",
+	screen: "screen_share",
+	"screen-audio": "screen_share_audio"
+};
+const liveKitSource = (source) => sources[source];
+/** A LiveKit source as the call protocol names it; an unknown one counts as the camera or microphone of its kind. */
+const callSource = (source, type) => {
+	return Object.keys(sources).find((name) => sources[name] === source) ?? (type === TrackType.AUDIO ? "microphone" : "camera");
+};
+const liveKitQuality = (quality) => ({
+	low: VideoQuality.LOW,
+	medium: VideoQuality.MEDIUM,
+	high: VideoQuality.HIGH
+})[quality];
+const remoteTrack = (member, track) => ({
+	sid: track.sid,
+	member,
+	kind: track.type === TrackType.AUDIO ? "audio" : "video",
+	source: callSource(track.source, track.type),
+	muted: track.muted
+});
+/** The audio and video tracks of the participants that are still in the room, each under its participant's identity. */
+const remoteTracksOf = (participants) => participants.filter((participant) => participant.state !== ParticipantInfo_State.DISCONNECTED).flatMap((participant) => participant.tracks.filter((track) => track.type !== TrackType.DATA).map((track) => remoteTrack(participant.identity, track)));
+//#endregion
+export { callSource, grantSources, liveKitQuality, liveKitSource, remoteTracksOf };

package/dist/calls/media-backend.js

@@ -0,0 +1,5 @@
+//#region src/calls/media-backend.ts
+/** The close code that has the browser resume on a new socket: the server lost its session, not the member. */
+const resumeCloseCode = 4e3;
+//#endregion
+export { resumeCloseCode };

package/dist/calls/member-relay.js

@@ -0,0 +1,56 @@
+import { parseClientMessage } from "./client-message.js";
+//#region src/calls/member-relay.ts
+/** The close code of a socket whose caller Protobase refused at a recheck: the member leaves the call too. */
+const refusedCloseCode = 1008;
+const mayPublish = (member, tracks) => member.publish === true || Array.isArray(member.publish) && tracks.every((track) => member.publish.includes(track.source));
+/**
+* One member's socket, relayed to the call's media plugin: the relay reads and checks the browser's messages, refuses a
+* publish the member may not make, opens the member's session at their `join` or `resume` and tells it how the socket
+* ended. The plugin only ever sees well-formed messages of a member Protobase admitted.
+*/
+const memberRelay = (backend, member) => {
+	let browser;
+	let session;
+	let finished = false;
+	const send = (message) => void browser.send(JSON.stringify(message));
+	const close = (code, reason) => {
+		if (finished) return;
+		finished = true;
+		session?.end(code === 1e3 || code === refusedCloseCode ? "left" : "lost");
+		browser.close(code, reason);
+	};
+	const relay = async (message) => {
+		if (message.type === "join" || message.type === "resume") {
+			if (session) return close(refusedCloseCode, "The call session already started");
+			session = backend.open(member, {
+				send,
+				close
+			});
+			return session.receive(message);
+		}
+		if (!session) return close(refusedCloseCode, "Join or resume the call first");
+		if (message.type === "publish" && !mayPublish(member, message.tracks)) return send({
+			type: "publish-refused",
+			reason: "The member may not publish these tracks"
+		});
+		await session.receive(message);
+	};
+	return {
+		onOpen: (socket) => {
+			browser = socket;
+		},
+		onMessage: async (data) => {
+			if (finished) return;
+			const message = parseClientMessage(data);
+			if (!message) return close(refusedCloseCode, "Not a call message");
+			await relay(message);
+		},
+		onClose: (code) => {
+			if (finished) return;
+			finished = true;
+			session?.end(code === refusedCloseCode ? "left" : "lost");
+		}
+	};
+};
+//#endregion
+export { memberRelay };

package/dist/calls/peer/peer-backend.js

@@ -0,0 +1,131 @@
+//#region src/calls/peer/peer-backend.ts
+/** How long a member whose socket was lost stays in the call for the others, waiting for their browser to resume. */
+const awayMs = 3e4;
+/**
+* The peer plugin: no media server. Protobase passes each member's descriptions and candidates to the member they name,
+* and tells every member who else is in the call and which of their tracks they hear; the browsers send their media to
+* each other directly. Members meet only within this process, which keeps who is in each call.
+*/
+const peerBackend = (settings) => {
+	const calls = /* @__PURE__ */ new Map();
+	const membersOf = (call) => [...calls.get(call)?.values() ?? []];
+	const announce = (call) => {
+		const present = membersOf(call);
+		for (const viewer of present) {
+			if (viewer.away) continue;
+			const others = present.filter((other) => other !== viewer);
+			const hears = viewer.member.hears ?? (() => true);
+			viewer.link.send({
+				type: "peers",
+				members: others.map((other) => other.member.member)
+			});
+			viewer.link.send({
+				type: "tracks",
+				tracks: others.flatMap((other) => [...other.tracks.values()]).filter(hears)
+			});
+		}
+	};
+	const remove = (self) => {
+		const call = calls.get(self.member.call);
+		if (call?.get(self.member.member) !== self) return;
+		clearTimeout(self.away);
+		call.delete(self.member.member);
+		if (call.size === 0) calls.delete(self.member.call);
+		announce(self.member.call);
+	};
+	const open = (member, link) => {
+		const self = {
+			member,
+			link,
+			tracks: /* @__PURE__ */ new Map()
+		};
+		const enter = () => {
+			const call = calls.get(member.call) ?? /* @__PURE__ */ new Map();
+			calls.set(member.call, call);
+			const before = call.get(member.member);
+			call.set(member.member, self);
+			if (before) {
+				clearTimeout(before.away);
+				if (!before.away) {
+					before.link.send({
+						type: "left",
+						reason: "removed"
+					});
+					before.link.close(1e3, "left");
+				}
+			}
+		};
+		const receive = (message) => {
+			switch (message.type) {
+				case "join":
+				case "resume":
+					if (message.type === "resume") for (const track of message.tracks) self.tracks.set(track.sid, {
+						sid: track.sid,
+						member: member.member,
+						kind: track.kind,
+						source: track.source,
+						muted: false
+					});
+					enter();
+					link.send(message.type === "join" ? {
+						type: "joined",
+						mode: "peer",
+						participant: member.member,
+						iceServers: settings.iceServers ?? []
+					} : { type: "resumed" });
+					return announce(member.call);
+				case "publish":
+					for (const track of message.tracks) self.tracks.set(track.cid, {
+						sid: track.cid,
+						member: member.member,
+						kind: track.kind,
+						source: track.source,
+						muted: false
+					});
+					link.send({
+						type: "published",
+						tracks: message.tracks.map((track) => ({
+							cid: track.cid,
+							sid: track.cid
+						}))
+					});
+					return announce(member.call);
+				case "unpublish":
+					self.tracks.delete(message.sid);
+					return announce(member.call);
+				case "mute": {
+					const track = self.tracks.get(message.sid);
+					if (!track) return;
+					track.muted = message.muted;
+					return announce(member.call);
+				}
+				case "signal": {
+					const to = calls.get(member.call)?.get(message.to);
+					if (!to || to.away || to === self) return;
+					to.link.send({
+						type: "signal",
+						from: member.member,
+						...message.description && { description: message.description },
+						...message.candidate && { candidate: message.candidate }
+					});
+					return;
+				}
+				case "leave": return link.close(1e3, "left");
+				case "offer":
+				case "candidate":
+				case "view": return;
+			}
+		};
+		return {
+			receive,
+			end: (how) => {
+				if (how === "left") return remove(self);
+				if (calls.get(member.call)?.get(member.member) !== self) return;
+				self.away = setTimeout(() => remove(self), awayMs);
+			}
+		};
+	};
+	return { open };
+};
+//#endregion
+export { peerBackend };

package/dist/create-admin.d.ts

@@ -9,6 +9,7 @@ import { CommentUsers } from "./comments/comment-users.js";
 import { HistoryOptions } from "./history/options.js";
 import { WebhooksOptions } from "./webhooks/table/options.js";
 import { NotificationsOptions } from "./notifications/options.js";
+import { CallsOptions } from "./calls/calls-options.js";
 import { SubscriptionDefinition } from "./webhooks/subscription.js";
 import { FilesOptions } from "./files/options.js";
 import { Difficulty } from "./forms/challenge.js";
@@ -54,6 +55,8 @@ export type CreateAdminInput = {
   realtime?: RealtimeOptions;
   /** Each user's devices and the endpoints that register them, from `notifications: {}` (see `NotificationsOptions`). */
   notifications?: NotificationsOptions;
+  /** The media server behind the calls functions admit members to with `calls.join` (see `CallsOptions`). */
+  calls?: CallsOptions;
   /**
    * The app's iOS and Android build (see `MobileConfig`): the API answers its Capacitor origins through CORS, and sign-in
    * at `/api/auth` trusts the Capacitor origin a request names, without CORS, as the app calls it through native HTTP.
@@ -93,5 +96,5 @@ export type CreateAdminInput = {
   upgradeWebSocket?: UpgradeWebSocket;
 };
 /** The admin REST API as a Hono app. It uses only Web APIs, so it runs on Node, Workers and anywhere else Hono does. */
-export declare const createAdmin: ({ resources: appResources, views: appViews, pages, userMenu, bottomBars, db, authenticate, auth, functions, secret, files: filesOptions, events, history: historyOptions, jobs, subscriptions, webhooks: webhooksOptions, realtime, notifications, mobile, app: identity, icons, bundlePlugins, fieldTypes, options, formsDifficulty, commentUsers: givenCommentUsers, verifyToken, upgradeWebSocket }: CreateAdminInput) => Admin;
+export declare const createAdmin: ({ resources: appResources, views: appViews, pages, userMenu, bottomBars, db, authenticate, auth, functions, secret, files: filesOptions, events, history: historyOptions, jobs, subscriptions, webhooks: webhooksOptions, realtime, notifications, calls, mobile, app: identity, icons, bundlePlugins, fieldTypes, options, formsDifficulty, commentUsers: givenCommentUsers, verifyToken, upgradeWebSocket }: CreateAdminInput) => Admin;
 //#endregion

package/dist/create-admin.js

@@ -108,7 +108,7 @@ const declaredRoles = (auth, roles) => {
 	return names.length > 0 ? [...new Set(names)] : void 0;
 };
 /** The admin REST API as a Hono app. It uses only Web APIs, so it runs on Node, Workers and anywhere else Hono does. */
-const createAdmin = ({ resources: appResources, views: appViews = [], pages = [], userMenu, bottomBars = [], db, authenticate, auth, functions = {}, secret, files: filesOptions, events, history: historyOptions, jobs = [], subscriptions = [], webhooks: webhooksOptions, realtime, notifications, mobile, app: identity, icons, bundlePlugins = [], fieldTypes = {}, options = {}, formsDifficulty, commentUsers: givenCommentUsers, verifyToken, upgradeWebSocket }) => {
+const createAdmin = ({ resources: appResources, views: appViews = [], pages = [], userMenu, bottomBars = [], db, authenticate, auth, functions = {}, secret, files: filesOptions, events, history: historyOptions, jobs = [], subscriptions = [], webhooks: webhooksOptions, realtime, notifications, calls, mobile, app: identity, icons, bundlePlugins = [], fieldTypes = {}, options = {}, formsDifficulty, commentUsers: givenCommentUsers, verifyToken, upgradeWebSocket }) => {
 	const basePath = options.basePath ?? "/api/v1";
 	const appModels = appResources.map((resource) => resource.toModel());
 	const withComments = appModels.some((model) => model.comments);
@@ -388,6 +388,7 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 		wake: () => wakeDispatch(deps),
 		upgradeWebSocket,
 		upgradeAuthenticate,
+		...calls && { calls },
 		report
 	}));
 	const verifyGoTrue = auth ? jwtVerifier(goTrueTokens({ auth })) : () => Promise.reject(unauthorized("This app signs no user tokens"));

package/dist/functions/define-function.d.ts

@@ -2,6 +2,7 @@ import { DecryptField } from "../encryption/decrypt-field-types.js";
 import { Session } from "../types.js";
 import { Caller } from "../api-keys/resolve-caller.js";
 import { SocketEvents } from "./function-socket.js";
+import { CallsAccess } from "../calls/calls-access.js";
 import { FunctionRecords } from "./records.js";
 import { Capability } from "@protobase/schema";
 import { Db } from "@protobase/query";
@@ -22,6 +23,8 @@ export type PublicFunctionContext = {
    * not repeated unless it passes them as `recheck`. `maxMessageBytes` lowers the largest message the socket takes.
    */
   acceptWebSocket: (events: SocketEvents) => Response;
+  /** Admits a member to a call's media, over the socket the function accepts: see `CallsAccess`. */
+  calls: CallsAccess;
 };
 /** Who called a function, and the app's resources as them. */
 export type FunctionCaller = {

package/dist/functions/routes.js

@@ -3,6 +3,7 @@ import { namingTimeouts } from "../statement-timeout.js";
 import { auditOrigin } from "../audit/origin.js";
 import { invokeFunction } from "./define-function.js";
 import { runInBackground } from "../background-work.js";
+import { callsAccess } from "../calls/calls-access.js";
 import { socketAcceptor } from "./accept-socket.js";
 import { functionGate, requireGate } from "./function-gate.js";
 import { sameCaller } from "./same-caller.js";
@@ -23,7 +24,8 @@ const isUpgrade = (request) => request.headers.get("upgrade")?.toLowerCase() ===
 * A function may answer an upgrade with a socket, only once it returned. While it is open, its caller is checked again
 * every minute: a protected function's always, a public one's once `caller()` resolved.
 */
-const functionRoutes = ({ basePath, functions, authenticate, access, db, records, decryptField, onError, wake, upgradeWebSocket, upgradeAuthenticate = authenticate, report }) => {
+const functionRoutes = ({ basePath, functions, authenticate, access, db, records, decryptField, onError, wake, upgradeWebSocket, upgradeAuthenticate = authenticate, calls: callsOptions, report }) => {
+	const calls = callsAccess(callsOptions);
 	const app = new Hono().basePath(basePath);
 	app.onError(onError);
 	const sessionOf = (request) => isUpgrade(request) ? upgradeAuthenticate(request) : authenticate(request);
@@ -67,7 +69,8 @@ const functionRoutes = ({ basePath, functions, authenticate, access, db, records
 					name,
 					db,
 					caller: resolveCaller,
-					acceptWebSocket: acceptor.accept
+					acceptWebSocket: acceptor.accept,
+					calls
 				};
 				return acceptor.answer(name, await invokeFunction(name, fn, request, context));
 			}
@@ -95,7 +98,8 @@ const functionRoutes = ({ basePath, functions, authenticate, access, db, records
 				...caller,
 				caller: async () => caller,
 				decryptField: decryptField(reader),
-				acceptWebSocket: acceptor.accept
+				acceptWebSocket: acceptor.accept,
+				calls
 			};
 			return acceptor.answer(name, await invokeFunction(name, fn, request, context));
 		}));

package/dist/index.d.ts

@@ -21,6 +21,7 @@ import { DeviceStore } from "./notifications/device-store.js";
 import { HistoryStore, maxHistoryPage, maxUnreadCount } from "./notifications/history-store.js";
 import { PushAnswer, PushSender } from "./notifications/sender.js";
 import { DeviceColumn, HistoryColumn, NotificationsOptions } from "./notifications/options.js";
+import { CallBackend, CallsOptions, LiveKitBackend } from "./calls/calls-options.js";
 import { EventData, RunContext, SubscriptionDefinition, SubscriptionEvent, SubscriptionOptions, subscription } from "./webhooks/subscription.js";
 import { Sharp, renderVariant, thumbHash } from "./files/images.js";
 import { FileProvider, FileStore, StoredObject } from "./files/store.js";
@@ -28,6 +29,8 @@ import { FilesOptions } from "./files/options.js";
 import { ApiKeys, ApiKeysOptions, apiKeySettings, apiKeyVariables } from "./api-keys/api-key-settings.js";
 import { Caller, CallerOptions, apiKeyCaller } from "./api-keys/resolve-caller.js";
 import { FunctionSocket, SocketEvents } from "./functions/function-socket.js";
+import { CallMember } from "./calls/call-member.js";
+import { CallsAccess } from "./calls/calls-access.js";
 import { ResourceSource, configExports } from "./resource-source.js";
 import { ErrorReportingOptions, ErrorReportingSettings, errorReportingSettings, errorReportingVariable } from "./error-reporting/error-reporting-settings.js";
 import { ChatMessage, ChatTextPart, Completion, CompletionOptions, ModelError, ModelSettings, ReasoningDetail, ReasoningEffort, ToolCall, ToolSpec, streamChatCompletion } from "./assistant/chat-completions.js";
@@ -171,4 +174,4 @@ import { DrainResult, JobsRuntime, StartJobsOptions, startJobs } from "./jobs/ru
 import { jobsDrainApp } from "./jobs/drain-route.js";
 import { checkJobsSchema, jobsSchema, jobsSchemaMigration } from "./jobs/schema.js";
 import { AdminAuth, CreateAuthOptions, UserCreatedHook, normalizeRoles } from "./better-auth/create-auth.js";
-export { type Admin, type AdminAuth, type AdminOptions, type AggregateParams, type ApiFunction, type ApiKeys, type ApiKeysOptions, type ApnsEnvironment, type AppIcons, type AppIdentity, type AppPoolConfig, type ApplyOptions, type ApplyResult, type ApprovalAnswer, type ApprovalRequest, type ArgumentsPayload, type AssistantBackend, type AssistantOptions, type AssistantSettings, type AssistantTool, type AuditEvent, type AuditQueue, type AuthHooks, type AuthSettings, type AuthenticateSettings, type Authenticator, type BaseToolContext, type BatchOperation, type BatchResult, type BetterAuthAuthenticator, type BetterAuthAuthenticatorOptions, type Caller, type CallerOptions, type CapturedRow, type CascadingKey, type ChatMessage, type ChatTextPart, type CheckAiInput, type CleanupEntry, type CleanupReport, type CleanupSchedule, type CoalescedChange, type CommentItem, type CommentToolsInput, type CommentUsers, type Completion, type CompletionOptions, ConnectionsBusy, type Conversation, type ConversationRecord, type ConversationStore, type ConversationsOptions, type CorsOptions, type CorsOrigins, type CreateAdminInput, type CreateAuthOptions, type DecryptField, type Device, type DeviceColumn, type DeviceKind, type DeviceStore, DeviceStoreError, type DrainResult, type EmailComponent, type EmailOptions, type EmailTemplate, type EncryptionStatus, type EncryptionTools, type EncryptionToolsInput, type EnqueueJob, type EnqueueOptions, type ErrorReporter, type ErrorReportingOptions, type ErrorReportingSettings, type EventData, type EventsOptions, FatalJobError, type FieldApplied, type FieldDecrypter, type FieldReader, type FieldStatus, type FileCleanupInput, type FileLimits, type FileObject, type FileProvider, type FileProviderSettings, type FileRef, type FileStore, type FileVariantObject, type FilesOptions, type FunctionApp, type FunctionCaller, type FunctionContext, type FunctionEnv, type FunctionHandler, type FunctionOptions, type FunctionRecords, type FunctionSocket, type FunctionSource, type HistoryColumn, type HistoryOptions, type HistoryPosition, type HistoryStore, HistoryStoreError, type HookContext, HttpProblem, type IssueTokenOptions, type JobContext, type JobDeclaration, type JobDefinition, type JobName, type JobOptions, type JobPayload, type JobRun, type JobsRuntime, type JsonObject, type JsonValue, type JwtOptions, type JwtVerifyOptions, type KeyFunctionContext, type LinkedAccount, type ListParams, type LocalFilesOptions, type MailMessage, type Mailer, type MapLayer, type MapOptions, type MapSettings, type McpApprovals, type McpGateInput, type McpHandlerInput, type McpRoutesInput, type McpServerInput, type McpToolsInput, type McpWrites, type MemberInput, type Membership, MissingCredentials, type MobileConfig, ModelError, type ModelSettings, type NewDevice, type NewNotification, type NewOrganization, type NewUser, type NotificationRecipients, NotificationSendError, type NotificationsOptions, type OperatorProvider, type OrganizationRole, type OrganizationsOptions, type PgModule, type PipelineHook, type PlatformSignIn, type PluginOption, type PluginRef, type PngIcon, type ProtectedFunctionOptions, type PublicFunctionContext, type PublicFunctionEnv, type PublicFunctionHandler, type PublicFunctionOptions, type PushAnswer, type PushMessage, PushMessageError, type PushSender, type QueryOptions, type QueryResult, type ReadableResources, type RealtimeOptions, type RealtimePrune, type ReasoningDetail, type ReasoningEffort, type RebindOption, type RecordGroups, type RecordKey, type RecordKeyInput, type RecordPage, type RenderedEmail, type ResourceChange, type ResourceSource, type RoleDefinition, type RolesInput, type RunContext, type RuntimeOptions, type S3Bucket, type S3FilesOptions, type S3ListPage, type S3Object, type ScanGuardMode, type ScheduledDelete, type SendNotification, type Session, type SessionOrganization, type Sharp, type SignInPolicy, type SignInRule, type SignatureOptions, type SocketEvents, type SourceOption, type SourceRef, type StaffAccessRule, type StaffSignIn, type StandardSchema, type StandardWebhookOptions, type StartJobsOptions, type StoreFileInput, type StoredMember, type StoredNotification, type StoredObject, type StoredOrganization, type StoredUser, type StrayValues, type SubscriptionDefinition, type SubscriptionEvent, type SubscriptionOptions, type TenantValue, type ToolAnnotations, type ToolCall, type ToolComment, type ToolCommentPage, type ToolComments, type ToolContext, type ToolRecord, type ToolRecords, type ToolSpec, type TrustedApp, type TurnOptions, type UnreadableEntry, type Urgency, type User, type UserCreatedHook, type VapidSettings, type ViewSource, type WebPushFields, type WebPushOptions, type WebhooksOptions, type WidgetOptions, type WriteEvent, type WriteOperation, type WriteRecordToolsInput, addAppRoleToOwners, addCommentTool, addMember, apiKeyCaller, apiKeySettings, apiKeyVariables, appNameOver, aspectRatio, assistantProtocolRoutes, assistantRoles, assistantSettings, assistantVariables, authSchemaDrift, authSchemaMigration, authStoreTables, backgroundSettled, badRequest, batchWriteTool, beforeSignInPluginsVariable, betterAuthTokens, capSocketMessages, changesMigration, checkAi, checkAuthSchema, checkChanges, checkComments, checkComputed, checkJobsSchema, checkNotificationsSchema, checkQueryRunner, checkRealtimeRelay, checkResourcesOutsideAuthStore, checkSourceNames, checkViewQueries, checkWebhooksSchema, coalesce, commentTools, commentsMigration, computedMigration, configExports, consoleAuditQueue, conversationKey, countRecordsTool, createAdmin, createConversations, createEncryptionTools, createFileCleanup, createOrganization, createRecordTool, createUser, defaultAppName, defaultHistoryPage, defaultSignInPolicy, defineEmail, defineFunction, defineJob, defineTool, deleteRecordTool, deleteUser, describeResourceTool, deviceIdParam, deviceStore, devicesPath, enqueueJob, errorReportingSettings, errorReportingVariable, eventMatcher, fileConversationStore, fileSize, fileType, forbidden, formatUri, functionApp, generateVapidKeys, getRecordTool, goTruePath, handleDroppedConnections, hasUsers, historyIdParam, historyIdPattern, historyLimits, historyPath, historyStore, honorSocketMessageCaps, imageSize, isBackgroundWork, isCaptured, isJobDefinition, isOAuthWellKnownPath, isSchedule, issueToken, jobDefinitions, jobsDrainApp, jobsSchema, jobsSchemaMigration, jwtAuthenticator, jwtVerifier, limitedFileStore, listCommentsTool, listOrganizations, listRecordsTool, listResourcesTool, listUsers, localFileStore, longQueryTimeoutMs, mapSettings, mapStyleUrl, mapStyleVariable, maxDevicesPerUser, maxHistoryPage, maxMessageBytes, maxRecipients, maxTokenTtlSeconds, maxTtlSeconds, maxUnreadCount, maxWidgetPropsBytes, mcpApprovals, mcpGate, mcpHandler, mcpIcons, mcpInstructions, mcpRoutes, mcpServer, mcpToolContext, mcpTools, migrationCommand, newWebhookSecret, normalizeRoles, notFound, notificationSenders, notificationsMigration, oauthWellKnownPaths, objectKey, parseColumns, parseRoles, passwordLength, pluginOptions, pluginsBeforeSignIn, pluginsFor, pluginsVariable, pngIcons, poolWaitMs, postgresDeviceStore, postgresHistoryStore, processor, pushMessage, queryRunnerMigration, readDbConnections, readJson, readOnlyQueryTool, readOperatorSettings, readOutbox, readPlatformSignIn, readRecordTools, readVapidSettings, readWriteQueryTool, readableResources, realtimeLimits, realtimeRelayMigration, recordOf, refusalOf, refused, relayed, removeDevicesWithUsers, removeHistoryWithUsers, removeMember, renderVariant, requestApproval, requireEnv, resourceChange, roleChoices, runInBackground, runReadOnlyQuery, runReadWriteQuery, runTurn, runtimeUrl, runtimeVariable, s3FileStore, seesAssistant, seesRuntime, sendNotification, sessionOf, setMemberRoles, setUserBanned, setUserRole, shownAppName, signInPolicyMethods, socketMessageCapOf, sourceOptions, sourcesFor, sourcesVariable, startErrorReporting, startJobs, storageCleanupSchedule, storageProvider, storeFile, storeUsage, streamChatCompletion, subscription, supabasePath, thumbHash, unauthorized, updateRecordTool, urgencies, vapidPrivateKeyVariable, vapidPublicKeyVariable, vapidSubjectVariable, variantPath, verifySignature, verifyStandardWebhook, waitUntil, wantsLongQueries, webManifestPath, webPushSender, webauthnPath, webhooksMigration, widget, withCacheBreakpoints, withTrustedApps, writeRecordTools };
+export { type Admin, type AdminAuth, type AdminOptions, type AggregateParams, type ApiFunction, type ApiKeys, type ApiKeysOptions, type ApnsEnvironment, type AppIcons, type AppIdentity, type AppPoolConfig, type ApplyOptions, type ApplyResult, type ApprovalAnswer, type ApprovalRequest, type ArgumentsPayload, type AssistantBackend, type AssistantOptions, type AssistantSettings, type AssistantTool, type AuditEvent, type AuditQueue, type AuthHooks, type AuthSettings, type AuthenticateSettings, type Authenticator, type BaseToolContext, type BatchOperation, type BatchResult, type BetterAuthAuthenticator, type BetterAuthAuthenticatorOptions, type CallBackend, type CallMember, type Caller, type CallerOptions, type CallsAccess, type CallsOptions, type CapturedRow, type CascadingKey, type ChatMessage, type ChatTextPart, type CheckAiInput, type CleanupEntry, type CleanupReport, type CleanupSchedule, type CoalescedChange, type CommentItem, type CommentToolsInput, type CommentUsers, type Completion, type CompletionOptions, ConnectionsBusy, type Conversation, type ConversationRecord, type ConversationStore, type ConversationsOptions, type CorsOptions, type CorsOrigins, type CreateAdminInput, type CreateAuthOptions, type DecryptField, type Device, type DeviceColumn, type DeviceKind, type DeviceStore, DeviceStoreError, type DrainResult, type EmailComponent, type EmailOptions, type EmailTemplate, type EncryptionStatus, type EncryptionTools, type EncryptionToolsInput, type EnqueueJob, type EnqueueOptions, type ErrorReporter, type ErrorReportingOptions, type ErrorReportingSettings, type EventData, type EventsOptions, FatalJobError, type FieldApplied, type FieldDecrypter, type FieldReader, type FieldStatus, type FileCleanupInput, type FileLimits, type FileObject, type FileProvider, type FileProviderSettings, type FileRef, type FileStore, type FileVariantObject, type FilesOptions, type FunctionApp, type FunctionCaller, type FunctionContext, type FunctionEnv, type FunctionHandler, type FunctionOptions, type FunctionRecords, type FunctionSocket, type FunctionSource, type HistoryColumn, type HistoryOptions, type HistoryPosition, type HistoryStore, HistoryStoreError, type HookContext, HttpProblem, type IssueTokenOptions, type JobContext, type JobDeclaration, type JobDefinition, type JobName, type JobOptions, type JobPayload, type JobRun, type JobsRuntime, type JsonObject, type JsonValue, type JwtOptions, type JwtVerifyOptions, type KeyFunctionContext, type LinkedAccount, type ListParams, type LiveKitBackend, type LocalFilesOptions, type MailMessage, type Mailer, type MapLayer, type MapOptions, type MapSettings, type McpApprovals, type McpGateInput, type McpHandlerInput, type McpRoutesInput, type McpServerInput, type McpToolsInput, type McpWrites, type MemberInput, type Membership, MissingCredentials, type MobileConfig, ModelError, type ModelSettings, type NewDevice, type NewNotification, type NewOrganization, type NewUser, type NotificationRecipients, NotificationSendError, type NotificationsOptions, type OperatorProvider, type OrganizationRole, type OrganizationsOptions, type PgModule, type PipelineHook, type PlatformSignIn, type PluginOption, type PluginRef, type PngIcon, type ProtectedFunctionOptions, type PublicFunctionContext, type PublicFunctionEnv, type PublicFunctionHandler, type PublicFunctionOptions, type PushAnswer, type PushMessage, PushMessageError, type PushSender, type QueryOptions, type QueryResult, type ReadableResources, type RealtimeOptions, type RealtimePrune, type ReasoningDetail, type ReasoningEffort, type RebindOption, type RecordGroups, type RecordKey, type RecordKeyInput, type RecordPage, type RenderedEmail, type ResourceChange, type ResourceSource, type RoleDefinition, type RolesInput, type RunContext, type RuntimeOptions, type S3Bucket, type S3FilesOptions, type S3ListPage, type S3Object, type ScanGuardMode, type ScheduledDelete, type SendNotification, type Session, type SessionOrganization, type Sharp, type SignInPolicy, type SignInRule, type SignatureOptions, type SocketEvents, type SourceOption, type SourceRef, type StaffAccessRule, type StaffSignIn, type StandardSchema, type StandardWebhookOptions, type StartJobsOptions, type StoreFileInput, type StoredMember, type StoredNotification, type StoredObject, type StoredOrganization, type StoredUser, type StrayValues, type SubscriptionDefinition, type SubscriptionEvent, type SubscriptionOptions, type TenantValue, type ToolAnnotations, type ToolCall, type ToolComment, type ToolCommentPage, type ToolComments, type ToolContext, type ToolRecord, type ToolRecords, type ToolSpec, type TrustedApp, type TurnOptions, type UnreadableEntry, type Urgency, type User, type UserCreatedHook, type VapidSettings, type ViewSource, type WebPushFields, type WebPushOptions, type WebhooksOptions, type WidgetOptions, type WriteEvent, type WriteOperation, type WriteRecordToolsInput, addAppRoleToOwners, addCommentTool, addMember, apiKeyCaller, apiKeySettings, apiKeyVariables, appNameOver, aspectRatio, assistantProtocolRoutes, assistantRoles, assistantSettings, assistantVariables, authSchemaDrift, authSchemaMigration, authStoreTables, backgroundSettled, badRequest, batchWriteTool, beforeSignInPluginsVariable, betterAuthTokens, capSocketMessages, changesMigration, checkAi, checkAuthSchema, checkChanges, checkComments, checkComputed, checkJobsSchema, checkNotificationsSchema, checkQueryRunner, checkRealtimeRelay, checkResourcesOutsideAuthStore, checkSourceNames, checkViewQueries, checkWebhooksSchema, coalesce, commentTools, commentsMigration, computedMigration, configExports, consoleAuditQueue, conversationKey, countRecordsTool, createAdmin, createConversations, createEncryptionTools, createFileCleanup, createOrganization, createRecordTool, createUser, defaultAppName, defaultHistoryPage, defaultSignInPolicy, defineEmail, defineFunction, defineJob, defineTool, deleteRecordTool, deleteUser, describeResourceTool, deviceIdParam, deviceStore, devicesPath, enqueueJob, errorReportingSettings, errorReportingVariable, eventMatcher, fileConversationStore, fileSize, fileType, forbidden, formatUri, functionApp, generateVapidKeys, getRecordTool, goTruePath, handleDroppedConnections, hasUsers, historyIdParam, historyIdPattern, historyLimits, historyPath, historyStore, honorSocketMessageCaps, imageSize, isBackgroundWork, isCaptured, isJobDefinition, isOAuthWellKnownPath, isSchedule, issueToken, jobDefinitions, jobsDrainApp, jobsSchema, jobsSchemaMigration, jwtAuthenticator, jwtVerifier, limitedFileStore, listCommentsTool, listOrganizations, listRecordsTool, listResourcesTool, listUsers, localFileStore, longQueryTimeoutMs, mapSettings, mapStyleUrl, mapStyleVariable, maxDevicesPerUser, maxHistoryPage, maxMessageBytes, maxRecipients, maxTokenTtlSeconds, maxTtlSeconds, maxUnreadCount, maxWidgetPropsBytes, mcpApprovals, mcpGate, mcpHandler, mcpIcons, mcpInstructions, mcpRoutes, mcpServer, mcpToolContext, mcpTools, migrationCommand, newWebhookSecret, normalizeRoles, notFound, notificationSenders, notificationsMigration, oauthWellKnownPaths, objectKey, parseColumns, parseRoles, passwordLength, pluginOptions, pluginsBeforeSignIn, pluginsFor, pluginsVariable, pngIcons, poolWaitMs, postgresDeviceStore, postgresHistoryStore, processor, pushMessage, queryRunnerMigration, readDbConnections, readJson, readOnlyQueryTool, readOperatorSettings, readOutbox, readPlatformSignIn, readRecordTools, readVapidSettings, readWriteQueryTool, readableResources, realtimeLimits, realtimeRelayMigration, recordOf, refusalOf, refused, relayed, removeDevicesWithUsers, removeHistoryWithUsers, removeMember, renderVariant, requestApproval, requireEnv, resourceChange, roleChoices, runInBackground, runReadOnlyQuery, runReadWriteQuery, runTurn, runtimeUrl, runtimeVariable, s3FileStore, seesAssistant, seesRuntime, sendNotification, sessionOf, setMemberRoles, setUserBanned, setUserRole, shownAppName, signInPolicyMethods, socketMessageCapOf, sourceOptions, sourcesFor, sourcesVariable, startErrorReporting, startJobs, storageCleanupSchedule, storageProvider, storeFile, storeUsage, streamChatCompletion, subscription, supabasePath, thumbHash, unauthorized, updateRecordTool, urgencies, vapidPrivateKeyVariable, vapidPublicKeyVariable, vapidSubjectVariable, variantPath, verifySignature, verifyStandardWebhook, waitUntil, wantsLongQueries, webManifestPath, webPushSender, webauthnPath, webhooksMigration, widget, withCacheBreakpoints, withTrustedApps, writeRecordTools };

package/dist/internal.d.ts

@@ -1,4 +1,5 @@
 import { checkNotificationsOptions } from "./notifications/options.js";
+import { checkCallsOptions } from "./calls/calls-options.js";
 import { isSubscription } from "./webhooks/subscription.js";
 import { appPool, longQueryPool } from "./app-pool.js";
 import { AppAuthInput, appAuthOptions, buildAppAuth } from "./better-auth/auth-settings.js";
@@ -10,4 +11,4 @@ import { fileProviderOf } from "./files/provider-settings.js";
 import { declaredJob } from "./jobs/declared-job.js";
 import { AuthPlugins, buildAuth, createAuth, loadAuthPlugins } from "./better-auth/create-auth.js";
 import { webhooksModule } from "./webhooks/table/webhooks-module.js";
-export { type AppAuthInput, type AuthPlugins, appAuthOptions, appPool, betterAuthAuthenticator, buildAppAuth, buildAuth, buildAuthenticator, checkNotificationsOptions, createAuth, declaredJob, fileProviderOf, isSubscription, loadAuthPlugins, localFiles, longQueryPool, s3Files, webhooksModule };
+export { type AppAuthInput, type AuthPlugins, appAuthOptions, appPool, betterAuthAuthenticator, buildAppAuth, buildAuth, buildAuthenticator, checkCallsOptions, checkNotificationsOptions, createAuth, declaredJob, fileProviderOf, isSubscription, loadAuthPlugins, localFiles, longQueryPool, s3Files, webhooksModule };

package/dist/internal.js

@@ -10,4 +10,5 @@ import { declaredJob } from "./jobs/declared-job.js";
 import { appAuthOptions, buildAppAuth } from "./better-auth/auth-settings.js";
 import { buildAuthenticator } from "./better-auth/authenticate-settings.js";
 import { webhooksModule } from "./webhooks/table/webhooks-module.js";
-export { appAuthOptions, appPool, betterAuthAuthenticator, buildAppAuth, buildAuth, buildAuthenticator, checkNotificationsOptions, createAuth, declaredJob, fileProviderOf, isSubscription, loadAuthPlugins, localFiles, longQueryPool, s3Files, webhooksModule };
+import { checkCallsOptions } from "./calls/calls-options.js";
+export { appAuthOptions, appPool, betterAuthAuthenticator, buildAppAuth, buildAuth, buildAuthenticator, checkCallsOptions, checkNotificationsOptions, createAuth, declaredJob, fileProviderOf, isSubscription, loadAuthPlugins, localFiles, longQueryPool, s3Files, webhooksModule };

package/dist/package.js

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

package/dist/webhooks/attempt.js

@@ -54,7 +54,8 @@ const callFunction = async (name, subscription, event, options, context, signal)
 		name,
 		db: context.db,
 		caller: async () => caller,
-		acceptWebSocket
+		acceptWebSocket,
+		calls: { join: async () => acceptWebSocket() }
 	};
 	return invokeFunction(name, fn, await request("http://protobase.internal/", event, options, signal), fn.options.public ? functionContext : {
 		...functionContext,

package/package.json

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