@protobase/client 0.58.5 → 0.58.6

package/dist/calls/index.d.ts

@@ -0,0 +1,4 @@
+import { CallTrack, PublishOptions } from "./media-link.js";
+import { Call, CallState, JoinCallOptions, joinCall } from "./join-call.js";
+import { CallLeftReason, CallMode, CallTrackSource } from "@protobase/schema/internal";
+export { type Call, type CallLeftReason, type CallMode, type CallState, type CallTrack, type CallTrackSource, type JoinCallOptions, type PublishOptions, joinCall };

package/dist/calls/index.js

@@ -0,0 +1,2 @@
+import { joinCall } from "./join-call.js";
+export { joinCall };

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

@@ -0,0 +1,64 @@
+import { CallTrack, PublishOptions } from "./media-link.js";
+import { CallLeftReason, CallTrackSource } from "@protobase/schema/internal";
+//#region src/calls/join-call.d.ts
+/** Where a call stands: `resuming` while the link to Protobase is restored, with media still flowing. */
+export type CallState = {
+  state: 'connecting';
+} | {
+  state: 'joined';
+} | {
+  state: 'resuming';
+} | {
+  state: 'left';
+  reason: CallLeftReason;
+  error?: unknown;
+};
+export type JoinCallOptions = {
+  /**
+   * The socket of the app's function that admits the member, such as `/api/functions/meeting?call=42`: a path on the
+   * page's origin, or an absolute `http(s)` or `ws(s)` URL. The browser sends its session cookie with it.
+   */
+  url: string;
+  /** Every track of other members the member hears, whenever one comes, goes or its media arrives. */
+  onTracks?: (tracks: CallTrack[]) => void;
+  /** Who speaks how loudly, from 0 to 1, for the members whose level changed. */
+  onSpeakers?: (speakers: {
+    member: string;
+    level: number;
+  }[]) => void;
+  onState?: (state: CallState) => void;
+  /** The media server stopped one of the member's own tracks, such as after a demotion. */
+  onUnpublished?: (source: CallTrackSource) => void;
+  /** How long to wait before the `attempt`th try to restore a lost link. */
+  retryDelayMs?: (attempt: number) => number;
+  /** How many tries in a row to restore a lost link before the call is left. Default 8. */
+  maxRetries?: number;
+  WebSocket?: typeof WebSocket;
+  createPeerConnection?: (configuration: RTCConfiguration) => RTCPeerConnection;
+};
+export type Call = {
+  /** The member's participant in the media server. */
+  readonly participant: string;
+  /** Sends tracks under the sources they carry, such as `{ camera, microphone }`; rejects when the member may not. */
+  publish: (tracks: Partial<Record<CallTrackSource, MediaStreamTrack>>, options?: PublishOptions) => Promise<void>;
+  unpublish: (source: CallTrackSource) => Promise<void>;
+  mute: (source: CallTrackSource, muted: boolean) => void;
+  /** How large remote video tracks are shown, so the media server sends a layer that fits, or `hidden` for none. */
+  view: (sids: string[], size: {
+    width: number;
+    height: number;
+  } | 'hidden') => void;
+  /** New ICE credentials, such as after a network change; a failed connection restarts by itself. */
+  restartIce: () => Promise<void>;
+  leave: () => void;
+  /** The tracks of other members the member hears now. */
+  tracks: () => CallTrack[];
+};
+/**
+ * Joins a call through the app's function socket and resolves once the member is in it. Media flows over plain
+ * `RTCPeerConnection`s, to the media server or straight to the other members, as the app's calls are configured;
+ * Protobase relays their offers and answers and decides who is in the call and who hears whom. A lost socket, such as during a deploy, is restored with the browser's own state while
+ * media keeps flowing; when the media server no longer knows the member, the call is joined again with the same tracks.
+ */
+export declare const joinCall: (options: JoinCallOptions) => Promise<Call>;
+//#endregion

package/dist/calls/join-call.js

@@ -0,0 +1,177 @@
+import { peerLink } from "./peer-link.js";
+import { sfuLink } from "./sfu-link.js";
+//#region src/calls/join-call.ts
+const backoff = (attempt) => Math.min(1e4, 500 * 2 ** attempt);
+const socketUrl = (url) => {
+	const resolved = new URL(url, globalThis.location?.href);
+	resolved.protocol = resolved.protocol.replace(/^http/, "ws");
+	return resolved.href;
+};
+/** Close codes after which the member is out of the call: left, or refused by the app. */
+const leftCodes = {
+	1e3: "ended",
+	1008: "removed"
+};
+/**
+* Joins a call through the app's function socket and resolves once the member is in it. Media flows over plain
+* `RTCPeerConnection`s, to the media server or straight to the other members, as the app's calls are configured;
+* Protobase relays their offers and answers and decides who is in the call and who hears whom. A lost socket, such as during a deploy, is restored with the browser's own state while
+* media keeps flowing; when the media server no longer knows the member, the call is joined again with the same tracks.
+*/
+const joinCall = (options) => {
+	const WebSocketOf = options.WebSocket ?? WebSocket;
+	const retryDelay = options.retryDelayMs ?? backoff;
+	const maxRetries = options.maxRetries ?? 8;
+	const url = socketUrl(options.url);
+	let socket;
+	let link;
+	let participant = "";
+	let remote = [];
+	let ended = false;
+	let rejoin = false;
+	let opened = false;
+	let resumedSinceOpen = false;
+	let failures = 0;
+	let chain = Promise.resolve();
+	let joined;
+	const result = new Promise((resolve, reject) => joined = {
+		resolve,
+		reject
+	});
+	const send = (message) => {
+		if (socket.readyState === WebSocketOf.OPEN) socket.send(JSON.stringify(message));
+	};
+	const setState = (state) => options.onState?.(state);
+	const end = (reason, error) => {
+		if (ended) return;
+		ended = true;
+		link?.close();
+		link = void 0;
+		if (socket.readyState === WebSocketOf.OPEN || socket.readyState === WebSocketOf.CONNECTING) socket.close(1e3);
+		joined.reject(error ?? /* @__PURE__ */ new Error(`The call was left: ${reason}`));
+		setState({
+			state: "left",
+			reason,
+			...error !== void 0 && { error }
+		});
+	};
+	const newLink = (joined) => {
+		const input = {
+			iceServers: joined.iceServers,
+			send,
+			onTracks: (tracks) => {
+				remote = tracks;
+				options.onTracks?.(tracks);
+			},
+			onUnpublished: (source) => options.onUnpublished?.(source),
+			...options.createPeerConnection && { createPeerConnection: options.createPeerConnection }
+		};
+		return joined.mode === "peer" ? peerLink(joined.participant, input) : sfuLink(input);
+	};
+	const handle = async (message) => {
+		switch (message.type) {
+			case "joined": {
+				const before = link?.sending();
+				link?.close();
+				participant = message.participant;
+				link = newLink(message);
+				failures = 0;
+				setState({ state: "joined" });
+				joined.resolve(call);
+				for (const [source, { track, simulcast }] of before ?? []) call.publish({ [source]: track }, { simulcast }).catch((error) => end("ended", error));
+				return;
+			}
+			case "resumed":
+				resumedSinceOpen = true;
+				failures = 0;
+				setState({ state: "joined" });
+				await link?.resumed();
+				return;
+			case "speakers":
+				options.onSpeakers?.(message.speakers);
+				return;
+			case "left":
+				if (message.reason === "rejoin") rejoin = true;
+				else end(message.reason);
+				return;
+			default: await link?.receive(message);
+		}
+	};
+	const connect = (mode) => {
+		opened = false;
+		resumedSinceOpen = false;
+		socket = new WebSocketOf(url);
+		socket.onopen = () => {
+			opened = true;
+			chain = chain.then(async () => {
+				const resume = mode === "resume" && link ? await link.resumeState(participant) : void 0;
+				send(resume ? {
+					type: "resume",
+					...resume
+				} : { type: "join" });
+			});
+		};
+		socket.onmessage = (event) => {
+			const message = JSON.parse(String(event.data));
+			chain = chain.then(() => handle(message)).catch((error) => end("ended", error));
+		};
+		socket.onclose = (event) => {
+			chain = chain.then(() => closed(mode, event.code));
+		};
+	};
+	const closed = (mode, code) => {
+		if (ended) return;
+		if (rejoin) {
+			rejoin = false;
+			return connect("join");
+		}
+		const left = leftCodes[code];
+		if (left) return end(left);
+		if (!participant) return end("refused");
+		failures++;
+		if (failures > maxRetries) return end("ended");
+		setState({ state: "resuming" });
+		const next = mode === "resume" && opened && !resumedSinceOpen ? "join" : "resume";
+		setTimeout(() => {
+			if (!ended) connect(next);
+		}, retryDelay(failures - 1));
+	};
+	const call = {
+		get participant() {
+			return participant;
+		},
+		publish: async (tracks, publishOptions) => {
+			if (!link) throw new Error("The call was left");
+			await link.publish(tracks, publishOptions);
+		},
+		unpublish: async (source) => {
+			await link?.unpublish(source);
+		},
+		mute: (source, muted) => link?.mute(source, muted),
+		view: (sids, size) => send(size === "hidden" ? {
+			type: "view",
+			sids,
+			width: 0,
+			height: 0,
+			hidden: true
+		} : {
+			type: "view",
+			sids,
+			...size
+		}),
+		restartIce: async () => {
+			await link?.restartIce();
+		},
+		leave: () => {
+			if (ended) return;
+			send({ type: "leave" });
+			end("ended");
+		},
+		tracks: () => remote
+	};
+	setState({ state: "connecting" });
+	connect("join");
+	return result;
+};
+//#endregion
+export { joinCall };

package/dist/calls/media-link.d.ts

@@ -0,0 +1,11 @@
+import { CallRemoteTrack, CallTrackSource } from "@protobase/schema/internal";
+//#region src/calls/media-link.d.ts
+/** A track of another member, with its media once the browser receives it. */
+export type CallTrack = CallRemoteTrack & {
+  track?: MediaStreamTrack;
+};
+/** How a published video track is sent: with a media server, simulcast sends it in three sizes the server picks from. */
+export type PublishOptions = {
+  simulcast?: boolean;
+};
+//#endregion

package/dist/calls/media-link.js

@@ -0,0 +1,4 @@
+//#region src/calls/media-link.ts
+const createPeerConnection = (configuration) => new RTCPeerConnection(configuration);
+//#endregion
+export { createPeerConnection };

package/dist/calls/msid-tracks.js

@@ -0,0 +1,16 @@
+//#region src/calls/msid-tracks.ts
+/**
+* The `mid` of each media section of a description by the sending browser's track id, which its `a=msid` line names: a
+* receiver's own track may have another id, when the browser reused one of its transceivers for the section.
+*/
+const midsByTrackId = (sdp) => {
+	const mids = /* @__PURE__ */ new Map();
+	for (const section of sdp.split(/\r?\nm=/).slice(1)) {
+		const mid = /^a=mid:(\S+)/m.exec(section)?.[1];
+		const track = /^a=msid:\S+ (\S+)/m.exec(section)?.[1];
+		if (mid !== void 0 && track !== void 0) mids.set(track, mid);
+	}
+	return mids;
+};
+//#endregion
+export { midsByTrackId };

package/dist/calls/negotiation.js

@@ -0,0 +1,52 @@
+//#region src/calls/negotiation.ts
+/**
+* One offer in flight at a time: a change while an offer waits for its answer offers once more after it. `settled`
+* resolves once no offer is in flight or queued, so a caller can wait for its change to be agreed.
+*/
+const negotiation = (offer) => {
+	let inFlight = false;
+	let again = false;
+	const waiting = [];
+	const start = async () => {
+		inFlight = true;
+		again = false;
+		await offer();
+	};
+	const settle = () => {
+		for (const resolve of waiting.splice(0)) resolve();
+	};
+	return {
+		/** Offers now, or once the offer in flight is answered. */
+		request: async () => {
+			if (inFlight) {
+				again = true;
+				return;
+			}
+			await start();
+		},
+		/** The answer to the offer in flight arrived: offers again when a change came meanwhile. */
+		answered: async () => {
+			inFlight = false;
+			if (again) return start();
+			settle();
+		},
+		/** The offer in flight will not be answered, such as on a lost session: it is made again by the next `request`. */
+		abandon: () => {
+			if (inFlight) again = true;
+			inFlight = false;
+		},
+		/** Whether an offer waits to be made again after `abandon`. */
+		get pending() {
+			return again;
+		},
+		settled: () => inFlight || again ? new Promise((resolve) => waiting.push(resolve)) : Promise.resolve(),
+		/** Forgets every offer, for a new peer connection; whoever waited is let go. */
+		reset: () => {
+			inFlight = false;
+			again = false;
+			settle();
+		}
+	};
+};
+//#endregion
+export { negotiation };

package/dist/calls/peer-link.js

@@ -0,0 +1,194 @@
+import { createPeerConnection } from "./media-link.js";
+import { midsByTrackId } from "./msid-tracks.js";
+//#region src/calls/peer-link.ts
+/**
+* The media link without a media server: one `RTCPeerConnection` to each other member, whose browser answers, so either
+* side may offer. Protobase passes the descriptions and candidates between the two ("perfect negotiation": the member
+* whose id sorts first gives way when both offer at once) and says who is in the call and which tracks each member
+* hears. A track goes by the id the sending browser gave it, which the receiving browser sees too.
+*/
+const peerLink = (self, { iceServers, send, onTracks, createPeerConnection: createPeerConnection$1 = createPeerConnection }) => {
+	const peers = /* @__PURE__ */ new Map();
+	const local = /* @__PURE__ */ new Map();
+	let remote = [];
+	let publishing;
+	let publishes = Promise.resolve();
+	const sendOn = (pc, track) => pc.addTransceiver(track, { direction: "sendonly" }).sender;
+	const receivedTrack = ({ member, sid }) => {
+		const pc = peers.get(member)?.pc;
+		const mid = pc?.remoteDescription && midsByTrackId(pc.remoteDescription.sdp).get(sid);
+		return mid === void 0 ? void 0 : pc.getTransceivers().find((transceiver) => transceiver.mid === mid)?.receiver.track;
+	};
+	const emitTracks = () => onTracks(remote.map((track) => ({
+		...track,
+		...receivedTrack(track) && { track: receivedTrack(track) }
+	})));
+	const connect = (member) => {
+		const pc = createPeerConnection$1({ iceServers });
+		const peer = {
+			pc,
+			polite: self < member,
+			makingOffer: false,
+			ignoreOffer: false,
+			senders: /* @__PURE__ */ new Map()
+		};
+		peers.set(member, peer);
+		pc.onnegotiationneeded = async () => {
+			peer.makingOffer = true;
+			try {
+				await pc.setLocalDescription();
+				send({
+					type: "signal",
+					to: member,
+					description: pc.localDescription.toJSON()
+				});
+			} finally {
+				peer.makingOffer = false;
+			}
+		};
+		pc.onicecandidate = (event) => {
+			if (event.candidate) send({
+				type: "signal",
+				to: member,
+				candidate: event.candidate.toJSON()
+			});
+		};
+		pc.oniceconnectionstatechange = () => {
+			if (pc.iceConnectionState === "failed") pc.restartIce();
+		};
+		pc.ontrack = () => emitTracks();
+		for (const [source, { track }] of local) peer.senders.set(source, sendOn(pc, track));
+		return peer;
+	};
+	const disconnect = (member) => {
+		peers.get(member)?.pc.close();
+		peers.delete(member);
+	};
+	const signal = async (from, description, candidate) => {
+		const peer = peers.get(from) ?? connect(from);
+		const { pc } = peer;
+		if (description) {
+			const collision = description.type === "offer" && (peer.makingOffer || pc.signalingState !== "stable");
+			peer.ignoreOffer = !peer.polite && collision;
+			if (peer.ignoreOffer) return;
+			await pc.setRemoteDescription(description);
+			if (description.type === "offer") {
+				await pc.setLocalDescription();
+				send({
+					type: "signal",
+					to: from,
+					description: pc.localDescription.toJSON()
+				});
+			}
+			emitTracks();
+		}
+		if (candidate) await pc.addIceCandidate(candidate).catch((error) => {
+			if (!peer.ignoreOffer) throw error;
+		});
+	};
+	const receive = async (message) => {
+		switch (message.type) {
+			case "peers": {
+				const present = new Set(message.members);
+				for (const member of peers.keys()) if (!present.has(member)) disconnect(member);
+				for (const member of present) if (!peers.has(member)) connect(member);
+				return;
+			}
+			case "signal": return signal(message.from, message.description, message.candidate);
+			case "tracks":
+				remote = message.tracks;
+				emitTracks();
+				return;
+			case "published":
+				publishing?.resolve();
+				return;
+			case "publish-refused":
+				publishing?.reject(new Error(message.reason));
+				return;
+		}
+	};
+	const publishNow = async (tracks) => {
+		const added = Object.entries(tracks);
+		for (const [source] of added) if (local.has(source)) throw new Error(`The call already sends a ${source} track: unpublish it first`);
+		if (added.length === 0) return;
+		const answered = new Promise((resolve, reject) => publishing = {
+			resolve,
+			reject
+		});
+		send({
+			type: "publish",
+			tracks: added.map(([source, track]) => ({
+				cid: track.id,
+				kind: track.kind,
+				source
+			}))
+		});
+		try {
+			await answered;
+		} finally {
+			publishing = void 0;
+		}
+		for (const [source, track] of added) {
+			local.set(source, {
+				track,
+				sid: track.id
+			});
+			for (const peer of peers.values()) peer.senders.set(source, sendOn(peer.pc, track));
+		}
+	};
+	return {
+		receive,
+		publish: (tracks) => {
+			const next = publishes.then(() => publishNow(tracks));
+			publishes = next.catch(() => {});
+			return next;
+		},
+		unpublish: async (source) => {
+			const sending = local.get(source);
+			if (!sending) return;
+			local.delete(source);
+			for (const peer of peers.values()) {
+				const sender = peer.senders.get(source);
+				if (sender && peer.pc.signalingState !== "closed") peer.pc.removeTrack(sender);
+				peer.senders.delete(source);
+			}
+			send({
+				type: "unpublish",
+				sid: sending.sid
+			});
+		},
+		mute: (source, muted) => {
+			const sending = local.get(source);
+			if (!sending) return;
+			sending.track.enabled = !muted;
+			send({
+				type: "mute",
+				sid: sending.sid,
+				muted
+			});
+		},
+		restartIce: async () => {
+			for (const peer of peers.values()) peer.pc.restartIce();
+		},
+		resumeState: async (participant) => ({
+			participant,
+			tracks: [...local].map(([source, { track, sid }]) => ({
+				cid: track.id,
+				sid,
+				kind: track.kind,
+				source
+			}))
+		}),
+		resumed: async () => {},
+		sending: () => new Map([...local].map(([source, { track }]) => [source, {
+			track,
+			simulcast: false
+		}])),
+		close: () => {
+			publishing?.reject(/* @__PURE__ */ new Error("The call ended"));
+			for (const member of [...peers.keys()]) disconnect(member);
+		}
+	};
+};
+//#endregion
+export { peerLink };

package/dist/calls/sfu-link.js

@@ -0,0 +1,261 @@
+import { createPeerConnection } from "./media-link.js";
+import { negotiation } from "./negotiation.js";
+//#region src/calls/sfu-link.ts
+const simulcastLayers = [
+	{
+		rid: "q",
+		quality: "low",
+		scale: 4,
+		maxBitrate: 15e4
+	},
+	{
+		rid: "h",
+		quality: "medium",
+		scale: 2,
+		maxBitrate: 5e5
+	},
+	{
+		rid: "f",
+		quality: "high",
+		scale: 1,
+		maxBitrate: 12e5
+	}
+];
+const singleBitrate = 12e5;
+const trackRequest = (source, track, simulcast) => {
+	if (track.kind === "audio") return {
+		cid: track.id,
+		kind: "audio",
+		source
+	};
+	const { width = 0, height = 0 } = track.getSettings();
+	const layers = simulcast ? simulcastLayers.map((layer) => ({
+		quality: layer.quality,
+		width: Math.round(width / layer.scale),
+		height: Math.round(height / layer.scale),
+		bitrate: layer.maxBitrate
+	})) : [];
+	return {
+		cid: track.id,
+		kind: "video",
+		source,
+		width,
+		height,
+		...simulcast && { layers }
+	};
+};
+const sendEncodings = (track, simulcast) => {
+	if (track.kind === "audio") return void 0;
+	if (!simulcast) return [{ maxBitrate: singleBitrate }];
+	return simulcastLayers.map((layer) => ({
+		rid: layer.rid,
+		scaleResolutionDownBy: layer.scale,
+		maxBitrate: layer.maxBitrate
+	}));
+};
+/**
+* The media link to a media server, over a single `RTCPeerConnection`: the browser always offers, one offer at a time,
+* and the server's answer maps each receiving section's `mid` to the track it carries. The link holds no media library;
+* everything it says goes through `send` to Protobase, which speaks to the media server.
+*/
+const sfuLink = ({ iceServers, send, onTracks, onUnpublished, createPeerConnection: createPeerConnection$1 = createPeerConnection }) => {
+	const pc = createPeerConnection$1({
+		iceServers,
+		bundlePolicy: "max-bundle"
+	});
+	const local = /* @__PURE__ */ new Map();
+	const early = [];
+	let mids = {};
+	let remote = [];
+	let offerId = 0;
+	let publishing;
+	let publishes = Promise.resolve();
+	const offers = negotiation(async () => {
+		const offer = await pc.createOffer();
+		await pc.setLocalDescription(offer);
+		send({
+			type: "offer",
+			sdp: offer.sdp,
+			id: ++offerId
+		});
+	});
+	const offer = async () => {
+		if (pc.getTransceivers().length > 0) await offers.request();
+	};
+	const negotiate = async () => {
+		await offer();
+		await offers.settled();
+	};
+	const receivedTrack = (sid) => {
+		const mid = Object.keys(mids).find((key) => mids[key] === sid);
+		return mid === void 0 ? void 0 : pc.getTransceivers().find((transceiver) => transceiver.mid === mid)?.receiver.track;
+	};
+	const emitTracks = () => onTracks(remote.map((track) => ({
+		...track,
+		...receivedTrack(track.sid) && { track: receivedTrack(track.sid) }
+	})));
+	pc.onicecandidate = (event) => {
+		if (event.candidate) send({
+			type: "candidate",
+			candidate: event.candidate.toJSON()
+		});
+	};
+	pc.oniceconnectionstatechange = () => {
+		if (pc.iceConnectionState === "failed") restartIce();
+	};
+	pc.ontrack = () => emitTracks();
+	const restartIce = async () => {
+		pc.restartIce();
+		await negotiate();
+	};
+	const stopSending = (source) => {
+		const sending = local.get(source);
+		if (!sending) return false;
+		local.delete(source);
+		if (pc.signalingState !== "closed") pc.removeTrack(sending.transceiver.sender);
+		return true;
+	};
+	const receive = async (message) => {
+		switch (message.type) {
+			case "answer":
+				if (message.id !== offerId) return;
+				mids = {
+					...mids,
+					...message.mids
+				};
+				await pc.setRemoteDescription({
+					type: "answer",
+					sdp: message.sdp
+				});
+				for (const candidate of early.splice(0)) await pc.addIceCandidate(candidate);
+				emitTracks();
+				await offers.answered();
+				return;
+			case "candidate":
+				if (pc.remoteDescription) await pc.addIceCandidate(message.candidate);
+				else early.push(message.candidate);
+				return;
+			case "sections":
+				for (let i = 0; i < message.audio; i++) pc.addTransceiver("audio", { direction: "recvonly" });
+				for (let i = 0; i < message.video; i++) pc.addTransceiver("video", { direction: "recvonly" });
+				await offer();
+				return;
+			case "tracks":
+				remote = message.tracks;
+				emitTracks();
+				return;
+			case "unpublished": {
+				const sending = [...local.values()].find((track) => track.sid === message.sid);
+				if (!sending) return;
+				stopSending(sending.source);
+				await offer();
+				onUnpublished(sending.source);
+				return;
+			}
+			case "published":
+				publishing?.resolve(message.tracks);
+				return;
+			case "publish-refused":
+				publishing?.reject(new Error(message.reason));
+				return;
+		}
+	};
+	const publishNow = async (tracks, options) => {
+		const added = Object.entries(tracks).map(([source, track]) => {
+			if (local.has(source)) throw new Error(`The call already sends a ${source} track: unpublish it first`);
+			const simulcast = track.kind === "video" && Boolean(options.simulcast);
+			const encodings = sendEncodings(track, simulcast);
+			return {
+				source,
+				track,
+				transceiver: pc.addTransceiver(track, {
+					direction: "sendonly",
+					...encodings && { sendEncodings: encodings }
+				}),
+				simulcast
+			};
+		});
+		if (added.length === 0) return;
+		const answered = new Promise((resolve, reject) => publishing = {
+			resolve,
+			reject
+		});
+		send({
+			type: "publish",
+			tracks: added.map((track) => trackRequest(track.source, track.track, track.simulcast))
+		});
+		try {
+			const sids = await answered;
+			for (const track of added) local.set(track.source, {
+				...track,
+				sid: sids.find((sid) => sid.cid === track.track.id).sid
+			});
+		} catch (error) {
+			for (const track of added) track.transceiver.stop();
+			throw error;
+		} finally {
+			publishing = void 0;
+		}
+		await negotiate();
+	};
+	return {
+		receive,
+		/** Sends the tracks, under the sources they carry; rejects when the member may not send them. One publish at a time. */
+		publish: (tracks, options = {}) => {
+			const next = publishes.then(() => publishNow(tracks, options));
+			publishes = next.catch(() => {});
+			return next;
+		},
+		/** Stops sending the source's track; the track itself goes on until the app stops it. */
+		unpublish: async (source) => {
+			if (stopSending(source)) await negotiate();
+		},
+		mute: (source, muted) => {
+			const sending = local.get(source);
+			if (!sending?.sid) return;
+			sending.track.enabled = !muted;
+			send({
+				type: "mute",
+				sid: sending.sid,
+				muted
+			});
+		},
+		restartIce,
+		/** What a new server session needs to resume this link, after an offer still in flight is taken back. */
+		resumeState: async (participant) => {
+			if (pc.signalingState === "have-local-offer") {
+				await pc.setLocalDescription({ type: "rollback" });
+				offers.abandon();
+			}
+			if (!pc.localDescription || !pc.remoteDescription) return void 0;
+			const tracks = [...local.values()].flatMap((track) => track.sid ? [{
+				cid: track.track.id,
+				sid: track.sid,
+				kind: track.track.kind,
+				source: track.source
+			}] : []);
+			return {
+				participant,
+				offer: pc.localDescription.sdp,
+				answer: pc.remoteDescription.sdp,
+				tracks
+			};
+		},
+		/** After a resume: offers what changed while the session was lost. */
+		resumed: async () => {
+			if (offers.pending) await offer();
+		},
+		/** The tracks the member sends, by source, to publish again after a rejoin. */
+		sending: () => new Map([...local.values()].map((track) => [track.source, {
+			track: track.track,
+			simulcast: track.simulcast
+		}])),
+		close: () => {
+			publishing?.reject(/* @__PURE__ */ new Error("The call ended"));
+			offers.reset();
+			pc.close();
+		}
+	};
+};
+//#endregion
+export { sfuLink };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/client",
-  "version": "0.58.5",
+  "version": "0.58.6",
   "description": "Typed fetch client for the Protobase REST API.",
   "license": "Apache-2.0",
   "repository": {
@@ -15,7 +15,8 @@
     "node": ">=22.12.0"
   },
   "exports": {
-    ".": "./dist/index.js"
+    ".": "./dist/index.js",
+    "./calls": "./dist/calls/index.js"
   },
   "types": "./dist/index.d.ts",
   "files": [
@@ -30,8 +31,8 @@
   },
   "dependencies": {
     "@better-auth/passkey": "^1.7.12",
-    "@protobase/layout": "0.58.5",
-    "@protobase/schema": "0.58.5",
+    "@protobase/layout": "0.58.6",
+    "@protobase/schema": "0.58.6",
     "@simplewebauthn/browser": "^13.3.0",
     "better-auth": "^1.7.12"
   }