@protobase/server 0.58.5 → 0.58.7

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"));