@protobase/client 0.58.8 → 0.59.0

package/dist/channel-connection.d.ts

@@ -0,0 +1,13 @@
+//#region src/channel-connection.d.ts
+/** The part of the browser's `WebSocket` a connection uses, which a test hands its own of. */
+export type SocketLike = {
+  readonly readyState: number;
+  send(data: string): void;
+  close(code?: number): void;
+  onopen: ((event: unknown) => void) | null;
+  onmessage: ((event: {
+    data: unknown;
+  }) => void) | null;
+  onclose: ((event: unknown) => void) | null;
+};
+//#endregion

package/dist/channel-connection.js

@@ -0,0 +1,113 @@
+import { ChannelRefusal } from "./channel-types.js";
+//#region src/channel-connection.ts
+/** How often the client pings, the server's `channelBounds.pingMs`; no pong in twice that drops the connection. */
+const pingMs = 5e3;
+const openState = 1;
+const protocol = "protobase.channels";
+/**
+* The one socket of a client's channels: opened on `start`, connected again after a pause that grows with each failure
+* while it is wanted, closed on `stop`. It pings every `pingMs`, hands the server a token that changed, and drops a
+* socket that answered no ping in twice that, as one whose network went away.
+*/
+const channelConnection = ({ url, token, socket: open, retryDelay, onOpen, onDown, onMessage }) => {
+	let socket;
+	let wanted = false;
+	let failures = 0;
+	let lastRef = 0;
+	let sentToken;
+	let heardAt = 0;
+	let ping;
+	let retry;
+	const pending = /* @__PURE__ */ new Map();
+	const dropPending = () => {
+		for (const { reject } of pending.values()) reject(new ChannelRefusal("disconnected", "The connection dropped before the server answered"));
+		pending.clear();
+	};
+	const handover = async (current) => {
+		const fresh = await token?.();
+		if (socket !== current || current.readyState !== openState || fresh === void 0 || fresh === sentToken) return;
+		sentToken = fresh;
+		current.send(JSON.stringify({
+			type: "token",
+			token: fresh
+		}));
+	};
+	const connect = async () => {
+		const offered = await token?.();
+		if (!wanted || socket) return;
+		sentToken = offered;
+		const current = open(url(), offered === void 0 ? [protocol] : [protocol, `bearer.${offered}`]);
+		socket = current;
+		current.onopen = () => {
+			failures = 0;
+			heardAt = Date.now();
+			ping = setInterval(() => {
+				if (Date.now() - heardAt > 1e4) return current.close();
+				current.send(JSON.stringify({ type: "ping" }));
+				handover(current);
+			}, pingMs);
+			onOpen();
+		};
+		current.onmessage = ({ data }) => {
+			heardAt = Date.now();
+			if (typeof data !== "string") return;
+			const message = JSON.parse(data);
+			if (message.type !== "reply") return onMessage(message);
+			const waiting = pending.get(message.ref);
+			pending.delete(message.ref);
+			if (message.ok) waiting?.resolve(message);
+			else waiting?.reject(new ChannelRefusal(message.error.code, message.error.message));
+		};
+		current.onclose = () => {
+			if (socket !== current) return;
+			clearInterval(ping);
+			socket = void 0;
+			dropPending();
+			if (!wanted) return;
+			onDown();
+			retry = setTimeout(() => {
+				retry = void 0;
+				connect();
+			}, retryDelay(failures++));
+		};
+	};
+	const sendNow = (message) => {
+		if (socket?.readyState !== openState) return false;
+		socket.send(JSON.stringify(message));
+		return true;
+	};
+	return {
+		/** Opens the socket, unless it is open or opening. */
+		start: () => {
+			wanted = true;
+			if (!socket && retry === void 0) connect();
+		},
+		/** Closes the socket for good, until the next `start`. */
+		stop: () => {
+			wanted = false;
+			clearTimeout(retry);
+			retry = void 0;
+			clearInterval(ping);
+			const current = socket;
+			socket = void 0;
+			dropPending();
+			current?.close(1e3);
+		},
+		/** Sends a message with a ref, and resolves with its reply, or rejects with its refusal. */
+		request: (message) => new Promise((resolve, reject) => {
+			const ref = String(++lastRef);
+			if (!sendNow({
+				...message,
+				ref
+			})) return reject(new ChannelRefusal("disconnected", "The connection is down"));
+			pending.set(ref, {
+				resolve,
+				reject
+			});
+		}),
+		/** Sends a message that gets no reply; `false` when the socket is not open. */
+		post: sendNow
+	};
+};
+//#endregion
+export { channelConnection, pingMs };

package/dist/channel-types.d.ts

@@ -0,0 +1,44 @@
+//#region src/channel-types.d.ts
+/** Who sent a broadcast or tracks a presence, stamped by the server from their session: a user's id, `null` for a visitor. */
+export type ChannelUser = string | number | null;
+/** One connection's presence on a channel: its id, the same while it is tracked, its user and the state it tracks. */
+export type PresenceEntry = {
+  id: string;
+  user: ChannelUser;
+  state: unknown;
+};
+/** What changed in a channel's presence: connections that started tracking, changed their state, or left. */
+export type PresenceChange = {
+  joins: PresenceEntry[];
+  updates: PresenceEntry[];
+  leaves: PresenceEntry[];
+};
+/** Why the server refused a message or ended a channel, such as `not-found` for a record the caller may not read. */
+export type ChannelError = {
+  code: string;
+  message: string;
+};
+/** A broadcast as a channel hears it: with `server`, the app's own code sent it, and `user` is `null`. */
+export type ChannelMessage = {
+  event: string;
+  payload: unknown;
+  user: ChannelUser;
+  server?: true;
+};
+/**
+ * Where a channel stands: `joining`, also while the connection is down; `joined`; `refused`, never joined, as for a
+ * record there is none of or the caller may not read; `closed`, left by the server, as once the caller may no longer
+ * read the record. A refused or closed channel is not joined again: leave it and take a new one.
+ */
+export type ChannelStatus = {
+  state: 'joining' | 'joined';
+} | {
+  state: 'refused' | 'closed';
+  error: ChannelError;
+};
+/** A refusal of the server, or `disconnected` for a message whose connection dropped before its reply. */
+export declare class ChannelRefusal extends Error {
+  readonly code: string;
+  constructor(code: string, message: string);
+}
+//#endregion

package/dist/channel-types.js

@@ -0,0 +1,12 @@
+//#region src/channel-types.ts
+/** A refusal of the server, or `disconnected` for a message whose connection dropped before its reply. */
+var ChannelRefusal = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "ChannelRefusal";
+	}
+};
+//#endregion
+export { ChannelRefusal };

package/dist/channels.d.ts

@@ -0,0 +1,29 @@
+import { ChannelMessage, ChannelStatus, PresenceChange, PresenceEntry } from "./channel-types.js";
+import { KeyValue } from "@protobase/schema";
+//#region src/channels.d.ts
+/** A record's channel as one caller of `client.channel` holds it; `leave` lets it go. */
+export type Channel = {
+  status: () => ChannelStatus;
+  /** Follows the status until the returned function is called. */
+  onStatus: (listener: (status: ChannelStatus) => void) => () => void;
+  /** The channel's presence now: every connection on it that tracks a state, this one included. */
+  presence: () => PresenceEntry[];
+  /** Follows the presence until the returned function is called: the whole of it, and what changed when a diff did it. */
+  onPresence: (listener: (entries: PresenceEntry[], change?: PresenceChange) => void) => () => void;
+  /** Tracks this connection's state on the channel, or replaces it; applied once joined, and again after a reconnect. */
+  track: (state: unknown) => Promise<void>;
+  untrack: () => Promise<void>;
+  /**
+   * Broadcasts to the others on the channel; with `self` this connection hears it too. With `ack` it resolves once the
+   * server took it, or rejects with its `ChannelRefusal`; without, once it was sent.
+   */
+  send: (event: string, payload: unknown, options?: {
+    self?: boolean;
+    ack?: boolean;
+  }) => Promise<void>;
+  /** Hears the channel's broadcasts of `event` until the returned function is called. */
+  on: (event: string, listener: (message: ChannelMessage) => void) => () => void;
+  /** Lets the channel go; the connection leaves it once every holder did, and closes once it holds no channel. */
+  leave: () => void;
+};
+//#endregion

package/dist/channels.js

@@ -0,0 +1,204 @@
+import { ChannelRefusal } from "./channel-types.js";
+import { channelConnection } from "./channel-connection.js";
+import { encodeKey } from "@protobase/schema/internal";
+//#region src/channels.ts
+const unlessDropped = (error) => {
+	if (error instanceof ChannelRefusal && error.code === "disconnected") return;
+	throw error;
+};
+const notJoined = () => new ChannelRefusal("not-joined", "The channel is not joined yet");
+/**
+* The client's channels of records (`/api/channels`), all on one socket, opened with the first channel and closed
+* after the last. A dropped socket connects again by itself, joins every channel again and tracks their states again.
+*/
+const channelsClient = (options) => {
+	const joined = /* @__PURE__ */ new Map();
+	const byName = /* @__PURE__ */ new Map();
+	const setStatus = (channel, status) => {
+		channel.status = status;
+		for (const listener of channel.statusListeners) listener(status);
+	};
+	const tellPresence = (channel, change) => {
+		const entries = [...channel.presence.values()];
+		for (const listener of channel.presenceListeners) listener(entries, change);
+	};
+	const join = (channel) => {
+		connection.request({
+			type: "join",
+			resource: channel.resource,
+			key: channel.key
+		}).then((reply) => {
+			if (joined.get(`${channel.resource}/${channel.key}`) !== channel) return;
+			channel.name = reply.channel;
+			byName.set(channel.name, channel);
+			setStatus(channel, { state: "joined" });
+			if (channel.tracked) connection.request({
+				type: "track",
+				channel: channel.name,
+				state: channel.tracked.state
+			}).catch(unlessDropped);
+		}).catch((error) => {
+			if (!(error instanceof ChannelRefusal) || error.code === "disconnected") return unlessDropped(error);
+			setStatus(channel, {
+				state: "refused",
+				error: {
+					code: error.code,
+					message: error.message
+				}
+			});
+		});
+	};
+	const hear = (message) => {
+		if (message.type === "pong" || message.type === "reply" || message.type === "error") return;
+		const channel = byName.get(message.channel);
+		if (!channel) return;
+		if (message.type === "presence") {
+			channel.presence = new Map(message.entries.map((entry) => [entry.id, entry]));
+			return tellPresence(channel);
+		}
+		if (message.type === "presence_diff") {
+			for (const entry of message.leaves) channel.presence.delete(entry.id);
+			for (const entry of [...message.joins, ...message.updates]) channel.presence.set(entry.id, entry);
+			return tellPresence(channel, {
+				joins: message.joins,
+				updates: message.updates,
+				leaves: message.leaves
+			});
+		}
+		if (message.type === "broadcast") {
+			const { event, payload, user, server } = message;
+			for (const listener of channel.eventListeners.get(event) ?? []) listener({
+				event,
+				payload,
+				user,
+				...server && { server }
+			});
+			return;
+		}
+		byName.delete(message.channel);
+		channel.presence.clear();
+		tellPresence(channel);
+		setStatus(channel, {
+			state: "closed",
+			error: message.error
+		});
+	};
+	const connection = channelConnection({
+		...options,
+		onOpen: () => {
+			for (const channel of joined.values()) if (channel.status.state === "joining") join(channel);
+		},
+		onDown: () => {
+			byName.clear();
+			for (const channel of joined.values()) if (channel.status.state === "joined") setStatus(channel, { state: "joining" });
+		},
+		onMessage: hear
+	});
+	const release = (id, channel) => {
+		channel.holders -= 1;
+		if (channel.holders > 0) return;
+		joined.delete(id);
+		if (channel.name !== void 0) {
+			byName.delete(channel.name);
+			connection.post({
+				type: "leave",
+				channel: channel.name
+			});
+		}
+		if (joined.size === 0) connection.stop();
+	};
+	const handleOf = (id, channel) => {
+		let left = false;
+		const own = /* @__PURE__ */ new Set();
+		const listen = (set, listener) => {
+			set.add(listener);
+			const off = () => {
+				set.delete(listener);
+				own.delete(off);
+			};
+			own.add(off);
+			return off;
+		};
+		const joinedName = () => channel.status.state === "joined" ? channel.name : void 0;
+		return {
+			status: () => channel.status,
+			onStatus: (listener) => listen(channel.statusListeners, listener),
+			presence: () => [...channel.presence.values()],
+			onPresence: (listener) => listen(channel.presenceListeners, listener),
+			track: async (state) => {
+				channel.tracked = { state };
+				const name = joinedName();
+				if (name !== void 0) await connection.request({
+					type: "track",
+					channel: name,
+					state
+				});
+			},
+			untrack: async () => {
+				channel.tracked = void 0;
+				const name = joinedName();
+				if (name !== void 0) await connection.request({
+					type: "untrack",
+					channel: name
+				});
+			},
+			send: async (event, payload, { self, ack } = {}) => {
+				const name = joinedName();
+				if (name === void 0) throw notJoined();
+				const message = {
+					type: "send",
+					channel: name,
+					event,
+					payload,
+					...self && { self }
+				};
+				if (ack) {
+					await connection.request({
+						...message,
+						ack
+					});
+					return;
+				}
+				if (!connection.post(message)) throw new ChannelRefusal("disconnected", "The connection is down");
+			},
+			on: (event, listener) => {
+				const listeners = channel.eventListeners.get(event) ?? /* @__PURE__ */ new Set();
+				channel.eventListeners.set(event, listeners);
+				return listen(listeners, listener);
+			},
+			leave: () => {
+				if (left) return;
+				left = true;
+				for (const off of [...own]) off();
+				release(id, channel);
+			}
+		};
+	};
+	return { 
+	/** The channel of the record with this key, joined as soon as the socket is open. */
+channel: (resource, key) => {
+		const encoded = encodeKey(key);
+		const id = `${resource}/${encoded}`;
+		const existing = joined.get(id);
+		if (existing) {
+			existing.holders += 1;
+			return handleOf(id, existing);
+		}
+		const channel = {
+			resource,
+			key: encoded,
+			status: { state: "joining" },
+			presence: /* @__PURE__ */ new Map(),
+			holders: 1,
+			statusListeners: /* @__PURE__ */ new Set(),
+			presenceListeners: /* @__PURE__ */ new Set(),
+			eventListeners: /* @__PURE__ */ new Map()
+		};
+		joined.set(id, channel);
+		connection.start();
+		join(channel);
+		return handleOf(id, channel);
+	} };
+};
+//#endregion
+export { channelsClient };

package/dist/client.d.ts

@@ -1,3 +1,4 @@
+import { Channel } from "./channels.js";
 import { ClientOptions } from "./transport.js";
 import { RegisteredDevice, WebDeviceRegistration } from "./devices.js";
 import { InboxPage } from "./notification-history.js";
@@ -97,6 +98,7 @@ export declare const createClient: (options?: ClientOptions) => {
   formChallenge: (name: string) => Promise<FormChallenge>;
   submitForm: (name: string, values: Record<string, unknown>, proof: FormProof) => Promise<void>;
   live: (handlers: LiveHandlers) => () => void;
+  channel: (resource: string, key: KeyValue | readonly KeyValue[]) => Channel;
   devices: {
     register: (device: WebDeviceRegistration) => Promise<RegisteredDevice>;
     remove: (id: string) => Promise<void>;

package/dist/client.js

@@ -3,11 +3,18 @@ import { originOf, photosWithOrigin, withFileOrigin } from "./file-urls.js";
 import { createTransport } from "./transport.js";
 import { fetchWithProgress } from "./upload-request.js";
 import { followLive } from "./live.js";
+import { sharedLive } from "./shared-live.js";
+import { channelsClient } from "./channels.js";
 import { devicesClient } from "./devices.js";
 import { notificationHistoryClient } from "./notification-history.js";
 import { encodeKey } from "@protobase/schema/internal";
 //#region src/client.ts
 const nameOf = (resource) => typeof resource === "string" ? resource : resource.toModel().name;
+const channelsUrl = (baseUrl = "/api/v1") => {
+	const url = new URL(`${baseUrl.replace(/\/[^/]*$/, "")}/channels`, globalThis.location?.href);
+	url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+	return url.toString();
+};
 const keyPath = (resource, key) => `/${nameOf(resource)}/${encodeKey(key)}`;
 const toPage = (body, response, origin) => ({
 	items: body.items.map((item) => withFileOrigin(item, origin)),
@@ -412,7 +419,17 @@ const createClient = (options = {}) => {
 	* Hears which records of the `.live()` resources the caller may read change, as they do, until the returned function
 	* is called (`GET /api/live`); it connects again by itself.
 	*/
-	const live = (handlers) => followLive(send, handlers);
+	const live = sharedLive((handlers) => followLive(send, handlers));
+	/**
+	* The channel of a record (`/api/channels`): who else is on it and what they track (presence), and the events they
+	* send (broadcasts), for whoever may read the record. Every channel of the client shares one socket.
+	*/
+	const { channel } = channelsClient({
+		url: () => channelsUrl(options.baseUrl),
+		...options.token && { token: () => options.token({ refresh: false }) },
+		socket: options.webSocket ?? ((url, protocols) => new WebSocket(url, protocols)),
+		retryDelay: (attempt) => Math.min(3e4, 1e3 * 2 ** attempt)
+	});
 	return {
 		list,
 		search,
@@ -441,6 +458,7 @@ const createClient = (options = {}) => {
 		formChallenge,
 		submitForm,
 		live,
+		channel,
 		devices: devicesClient(send),
 		notifications: notificationHistoryClient(send)
 	};

package/dist/index.d.ts

@@ -1,3 +1,6 @@
+import { ChannelError, ChannelMessage, ChannelRefusal, ChannelStatus, ChannelUser, PresenceChange, PresenceEntry } from "./channel-types.js";
+import { SocketLike } from "./channel-connection.js";
+import { Channel } from "./channels.js";
 import { ClientOptions } from "./transport.js";
 import { DevicesClient, RegisteredDevice, WebDeviceRegistration } from "./devices.js";
 import { InboxNotification, InboxPage, NotificationHistoryClient } from "./notification-history.js";
@@ -24,4 +27,4 @@ import { AuthSession, AuthSessionOptions, createAuthSession, tokenExpiry } from
 import { createStaticSession } from "./static-session.js";
 import { AssistantClient, AssistantClientOptions, AssistantConnection, createAssistantClient } from "./assistant.js";
 import { RuntimeClient, RuntimeClientOptions, RuntimeLastUpdate, RuntimePolicy, RuntimeStatus, RuntimeUpdateStage, createRuntimeClient } from "./runtime.js";
-export { type AccountSecurity, type AccountSignIn, type ActiveRole, type Aggregate, type AggregateGroup, type AggregateParams, type AggregateSplitTotal, ApiError, type AppUser, type AssistantClient, type AssistantClientOptions, type AssistantConnection, AuthError, type AuthSession, type AuthSessionOptions, type AuthUser, type AuthenticatorSetup, type BatchOp, type BatchRef, type BatchResult, type Client, type ClientOptions, type CommentPage, type CommentPerson, type ConnectClient, type ConnectedApp, type ConnectingClient, type CurrentOrganization, type DeviceSession, type DevicesClient, type Facet, type FilterInput, type FormChallenge, type FormProof, type Histogram, type HistogramBucket, type HistoryChange, type HistoryPage, type InboxNotification, type InboxPage, type InvitationPreview, type InvitationSent, type InvokeOptions, type ListPage, type ListParams, type LiveChange, type LiveHandlers, type MapBounds, type MapBucket, type MapLayerModel, type MapParams, type MapResult, type MentionableUser, type Meta, type MetaResult, type NotificationHistoryClient, type Organization, type OrganizationInvitation, type OrganizationMember, type OrganizationPerson, type OrganizationRole, type OrganizationsClient, type OrganizationsFound, type Passkey, type PlatformSignIn, type PluginRef, PreconditionFailedError, type ProblemDetails, type ProblemError, type PublicForm, type RecordComment, type RecordOf, type RecordPermissions, type RecordPhotos, type RegisteredDevice, type RelatedLabels, type RequiredSetup, type ResourcePermissions, type ResourceRef, type RoleLabel, type RoleOption, type RolesClient, type RuntimeClient, type RuntimeClientOptions, type RuntimeLastUpdate, type RuntimePolicy, type RuntimeStatus, type RuntimeUpdateStage, type SamlSignIn, type Series, type SeriesParams, type SeriesPoint, type SetupStatus, type SignInMethod, type SignInPolicy, type SignInPolicyClient, type SignInPolicyState, type SignInResult, type SignInRule, type SourceMeta, type SourceRef, type StaffAccessRule, type StaffSignIn, type StaffSignInClient, type Stored, type StoredFile, type StoredFileVariant, type TwoFactorMethod, type UploadOptions, type UploadProgress, type UploadResult, type UserInvitation, type UserInvitationSent, type UsersClient, type UsersFound, type WebDeviceRegistration, createAssistantClient, createAuthSession, createClient, createRuntimeClient, createStaticSession, fileUrl, filterText, isApiError, listWire, routedClient, sourceMeta, tokenExpiry };
+export { type AccountSecurity, type AccountSignIn, type ActiveRole, type Aggregate, type AggregateGroup, type AggregateParams, type AggregateSplitTotal, ApiError, type AppUser, type AssistantClient, type AssistantClientOptions, type AssistantConnection, AuthError, type AuthSession, type AuthSessionOptions, type AuthUser, type AuthenticatorSetup, type BatchOp, type BatchRef, type BatchResult, type Channel, type ChannelError, type ChannelMessage, ChannelRefusal, type ChannelStatus, type ChannelUser, type Client, type ClientOptions, type CommentPage, type CommentPerson, type ConnectClient, type ConnectedApp, type ConnectingClient, type CurrentOrganization, type DeviceSession, type DevicesClient, type Facet, type FilterInput, type FormChallenge, type FormProof, type Histogram, type HistogramBucket, type HistoryChange, type HistoryPage, type InboxNotification, type InboxPage, type InvitationPreview, type InvitationSent, type InvokeOptions, type ListPage, type ListParams, type LiveChange, type LiveHandlers, type MapBounds, type MapBucket, type MapLayerModel, type MapParams, type MapResult, type MentionableUser, type Meta, type MetaResult, type NotificationHistoryClient, type Organization, type OrganizationInvitation, type OrganizationMember, type OrganizationPerson, type OrganizationRole, type OrganizationsClient, type OrganizationsFound, type Passkey, type PlatformSignIn, type PluginRef, PreconditionFailedError, type PresenceChange, type PresenceEntry, type ProblemDetails, type ProblemError, type PublicForm, type RecordComment, type RecordOf, type RecordPermissions, type RecordPhotos, type RegisteredDevice, type RelatedLabels, type RequiredSetup, type ResourcePermissions, type ResourceRef, type RoleLabel, type RoleOption, type RolesClient, type RuntimeClient, type RuntimeClientOptions, type RuntimeLastUpdate, type RuntimePolicy, type RuntimeStatus, type RuntimeUpdateStage, type SamlSignIn, type Series, type SeriesParams, type SeriesPoint, type SetupStatus, type SignInMethod, type SignInPolicy, type SignInPolicyClient, type SignInPolicyState, type SignInResult, type SignInRule, type SocketLike, type SourceMeta, type SourceRef, type StaffAccessRule, type StaffSignIn, type StaffSignInClient, type Stored, type StoredFile, type StoredFileVariant, type TwoFactorMethod, type UploadOptions, type UploadProgress, type UploadResult, type UserInvitation, type UserInvitationSent, type UsersClient, type UsersFound, type WebDeviceRegistration, createAssistantClient, createAuthSession, createClient, createRuntimeClient, createStaticSession, fileUrl, filterText, isApiError, listWire, routedClient, sourceMeta, tokenExpiry };

package/dist/index.js

@@ -1,6 +1,7 @@
 import { filterText, listWire } from "./query-string.js";
 import { fileUrl } from "./file-urls.js";
 import { ApiError, PreconditionFailedError, isApiError } from "./problem.js";
+import { ChannelRefusal } from "./channel-types.js";
 import { createClient } from "./client.js";
 import { routedClient } from "./routed-client.js";
 import { sourceMeta } from "./source-meta.js";
@@ -9,4 +10,4 @@ import { createAuthSession, tokenExpiry } from "./auth.js";
 import { createStaticSession } from "./static-session.js";
 import { createAssistantClient } from "./assistant.js";
 import { createRuntimeClient } from "./runtime.js";
-export { ApiError, AuthError, PreconditionFailedError, createAssistantClient, createAuthSession, createClient, createRuntimeClient, createStaticSession, fileUrl, filterText, isApiError, listWire, routedClient, sourceMeta, tokenExpiry };
+export { ApiError, AuthError, ChannelRefusal, PreconditionFailedError, createAssistantClient, createAuthSession, createClient, createRuntimeClient, createStaticSession, fileUrl, filterText, isApiError, listWire, routedClient, sourceMeta, tokenExpiry };

package/dist/routed-client.js

@@ -40,6 +40,7 @@ const routedClient = (own, sourceOf) => {
 		formChallenge: (name) => own.formChallenge(name),
 		submitForm: (name, values, proof) => own.submitForm(name, values, proof),
 		live: (handlers) => own.live(handlers),
+		channel: (resource, key) => own.channel(resource, key),
 		devices: own.devices,
 		notifications: own.notifications
 	};

package/dist/shared-live.js

@@ -0,0 +1,29 @@
+//#region src/shared-live.ts
+/**
+* `client.live` for every caller of one client on one stream: the first caller opens it, each hears every event, and
+* the last to stop closes it. A page with many live views then holds one connection however many there are, which a
+* browser's six per host under HTTP/1.1 need.
+*/
+const sharedLive = (follow) => {
+	const subscribers = /* @__PURE__ */ new Set();
+	let stop;
+	const each = (call) => {
+		for (const handlers of [...subscribers]) call(handlers);
+	};
+	return (handlers) => {
+		const subscriber = { ...handlers };
+		subscribers.add(subscriber);
+		stop ??= follow({
+			onChanges: (changes) => each((one) => one.onChanges(changes)),
+			onResync: () => each((one) => one.onResync()),
+			onRetry: (error) => each((one) => one.onRetry?.(error))
+		});
+		return () => {
+			if (!subscribers.delete(subscriber) || subscribers.size > 0) return;
+			stop?.();
+			stop = void 0;
+		};
+	};
+};
+//#endregion
+export { sharedLive };

package/dist/transport.d.ts

@@ -1,3 +1,4 @@
+import { SocketLike } from "./channel-connection.js";
 //#region src/transport.d.ts
 export type ClientOptions = {
   /** Where `/api/v1` lives, without a trailing slash. Defaults to `/api/v1` on the current origin. */
@@ -15,6 +16,8 @@ export type ClientOptions = {
   }) => Promise<string | undefined>;
   /** Called when a request is still 401 after the retry: the session is over. */
   onUnauthenticated?: () => void;
+  /** Opens the socket of `client.channel`; the global `WebSocket` by default. */
+  webSocket?: (url: string, protocols: string[]) => SocketLike;
 };
 export type Request = {
   method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/client",
-  "version": "0.58.8",
+  "version": "0.59.0",
   "description": "Typed fetch client for the Protobase REST API.",
   "license": "Apache-2.0",
   "repository": {
@@ -31,8 +31,8 @@
   },
   "dependencies": {
     "@better-auth/passkey": "^1.7.12",
-    "@protobase/layout": "0.58.8",
-    "@protobase/schema": "0.58.8",
+    "@protobase/layout": "0.59.0",
+    "@protobase/schema": "0.59.0",
     "@simplewebauthn/browser": "^13.3.0",
     "better-auth": "^1.7.12"
   }