farvex 0.2.0 → 1.0.0

package/dist/react/index.js

@@ -1,3301 +1,113 @@
 "use client";
-import { RoomContext, RoomAudioRenderer, useLocalParticipant } from '@livekit/components-react';
-import { createContext, useRef, useState, useEffect, useMemo, useCallback, useContext, useSyncExternalStore } from 'react';
-import { Room, RoomEvent, ConnectionState, Track, ConnectionQuality } from 'livekit-client';
-import { io } from 'socket.io-client';
-import { jsx, jsxs } from 'react/jsx-runtime';
+import { createContext, useEffect, useContext, useSyncExternalStore, useState } from 'react';
+import { jsx } from 'react/jsx-runtime';
 
-// src/react/provider.tsx
-
-// src/shared/types.ts
-function nullify(value) {
-  if (value === void 0 || value === null) {
-    return null;
-  }
-  if (typeof value === "string" && value.length === 0) {
-    return null;
-  }
-  return value;
-}
-
-// src/shared/error.ts
-function make(kind, retryable, code, title, overrides = {}) {
-  return {
-    kind,
-    code,
-    title,
-    retryable,
-    ...overrides
-  };
-}
-var callpadError = {
-  validation: (code, title, ov) => make("validation", false, code, title, ov),
-  unauth: (code, title, ov) => make("unauth", false, code, title, ov),
-  forbidden: (code, title, ov) => make("forbidden", false, code, title, ov),
-  notfound: (code, title, ov) => make("notfound", false, code, title, ov),
-  precondition: (code, title, ov) => make("precondition", false, code, title, ov),
-  conflict: (code, title, ov) => make("conflict", false, code, title, ov),
-  internal: (code, title, ov) => make("internal", true, code, title, ov),
-  unavailable: (code, title, ov) => make("unavailable", true, code, title, ov),
-  timeout: (code, title, ov) => make("timeout", true, code, title, ov),
-  network: (code, title, ov) => make("network", true, code, title, ov),
-  rateLimited: (code, title, ov) => make("rate_limited", true, code, title, ov),
-  mediaDevice: (code, title, ov) => make("media_device", false, code, title, ov),
-  mediaUnavailable: (code, title, ov) => make("media_unavailable", true, code, title, ov),
-  disposed: () => make("disposed", false, "callpad.disposed", "Client has been disposed"),
-  fromUnknown: (cause, context) => {
-    if (cause instanceof Error) {
-      return make(
-        "internal",
-        false,
-        "callpad.unknown",
-        context ?? "Unknown error",
-        {
-          detail: cause.message,
-          cause
-        }
-      );
-    }
-    return make(
-      "internal",
-      false,
-      "callpad.unknown",
-      context ?? "Unknown error",
-      {
-        detail: typeof cause === "string" ? cause : void 0
-      }
-    );
-  }
-};
-
-// src/shared/result.ts
-function ok(value) {
-  return { ok: true, value };
-}
-function err(error) {
-  return { ok: false, error };
-}
-
-// src/core/logger.ts
-var noopLogger = {
-  debug: () => void 0,
-  info: () => void 0,
-  warn: () => void 0,
-  error: () => void 0,
-  child: () => noopLogger
-};
-
-// src/api/generated/core/bodySerializer.ts
-var jsonBodySerializer = {
-  bodySerializer: (body) => JSON.stringify(
-    body,
-    (key, value) => typeof value === "bigint" ? value.toString() : value
-  )
-};
-
-// src/api/generated/core/auth.ts
-var getAuthToken = async (auth, callback) => {
-  const token = typeof callback === "function" ? await callback(auth) : callback;
-  if (!token) {
-    return;
-  }
-  if (auth.scheme === "bearer") {
-    return `Bearer ${token}`;
-  }
-  if (auth.scheme === "basic") {
-    return `Basic ${btoa(token)}`;
-  }
-  return token;
-};
-
-// src/api/generated/core/pathSerializer.ts
-var separatorArrayExplode = (style) => {
-  switch (style) {
-    case "label":
-      return ".";
-    case "matrix":
-      return ";";
-    case "simple":
-      return ",";
-    default:
-      return "&";
-  }
-};
-var separatorArrayNoExplode = (style) => {
-  switch (style) {
-    case "form":
-      return ",";
-    case "pipeDelimited":
-      return "|";
-    case "spaceDelimited":
-      return "%20";
-    default:
-      return ",";
-  }
-};
-var separatorObjectExplode = (style) => {
-  switch (style) {
-    case "label":
-      return ".";
-    case "matrix":
-      return ";";
-    case "simple":
-      return ",";
-    default:
-      return "&";
-  }
-};
-var serializeArrayParam = ({
-  allowReserved,
-  explode,
-  name,
-  style,
-  value
-}) => {
-  if (!explode) {
-    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
-    switch (style) {
-      case "label":
-        return `.${joinedValues2}`;
-      case "matrix":
-        return `;${name}=${joinedValues2}`;
-      case "simple":
-        return joinedValues2;
-      default:
-        return `${name}=${joinedValues2}`;
-    }
-  }
-  const separator = separatorArrayExplode(style);
-  const joinedValues = value.map((v) => {
-    if (style === "label" || style === "simple") {
-      return allowReserved ? v : encodeURIComponent(v);
-    }
-    return serializePrimitiveParam({
-      allowReserved,
-      name,
-      value: v
-    });
-  }).join(separator);
-  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
-};
-var serializePrimitiveParam = ({
-  allowReserved,
-  name,
-  value
-}) => {
-  if (value === void 0 || value === null) {
-    return "";
-  }
-  if (typeof value === "object") {
-    throw new Error(
-      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
-    );
-  }
-  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
-};
-var serializeObjectParam = ({
-  allowReserved,
-  explode,
-  name,
-  style,
-  value,
-  valueOnly
-}) => {
-  if (value instanceof Date) {
-    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
-  }
-  if (style !== "deepObject" && !explode) {
-    let values = [];
-    Object.entries(value).forEach(([key, v]) => {
-      values = [
-        ...values,
-        key,
-        allowReserved ? v : encodeURIComponent(v)
-      ];
-    });
-    const joinedValues2 = values.join(",");
-    switch (style) {
-      case "form":
-        return `${name}=${joinedValues2}`;
-      case "label":
-        return `.${joinedValues2}`;
-      case "matrix":
-        return `;${name}=${joinedValues2}`;
-      default:
-        return joinedValues2;
-    }
-  }
-  const separator = separatorObjectExplode(style);
-  const joinedValues = Object.entries(value).map(
-    ([key, v]) => serializePrimitiveParam({
-      allowReserved,
-      name: style === "deepObject" ? `${name}[${key}]` : key,
-      value: v
-    })
-  ).join(separator);
-  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
-};
-
-// src/api/generated/client/utils.ts
-var PATH_PARAM_RE = /\{[^{}]+\}/g;
-var defaultPathSerializer = ({ path, url: _url }) => {
-  let url = _url;
-  const matches = _url.match(PATH_PARAM_RE);
-  if (matches) {
-    for (const match of matches) {
-      let explode = false;
-      let name = match.substring(1, match.length - 1);
-      let style = "simple";
-      if (name.endsWith("*")) {
-        explode = true;
-        name = name.substring(0, name.length - 1);
-      }
-      if (name.startsWith(".")) {
-        name = name.substring(1);
-        style = "label";
-      } else if (name.startsWith(";")) {
-        name = name.substring(1);
-        style = "matrix";
-      }
-      const value = path[name];
-      if (value === void 0 || value === null) {
-        continue;
-      }
-      if (Array.isArray(value)) {
-        url = url.replace(
-          match,
-          serializeArrayParam({ explode, name, style, value })
-        );
-        continue;
-      }
-      if (typeof value === "object") {
-        url = url.replace(
-          match,
-          serializeObjectParam({
-            explode,
-            name,
-            style,
-            value,
-            valueOnly: true
-          })
-        );
-        continue;
-      }
-      if (style === "matrix") {
-        url = url.replace(
-          match,
-          `;${serializePrimitiveParam({
-            name,
-            value
-          })}`
-        );
-        continue;
-      }
-      const replaceValue = encodeURIComponent(
-        style === "label" ? `.${value}` : value
-      );
-      url = url.replace(match, replaceValue);
-    }
-  }
-  return url;
-};
-var createQuerySerializer = ({
-  allowReserved,
-  array,
-  object
-} = {}) => {
-  const querySerializer = (queryParams) => {
-    const search = [];
-    if (queryParams && typeof queryParams === "object") {
-      for (const name in queryParams) {
-        const value = queryParams[name];
-        if (value === void 0 || value === null) {
-          continue;
-        }
-        if (Array.isArray(value)) {
-          const serializedArray = serializeArrayParam({
-            allowReserved,
-            explode: true,
-            name,
-            style: "form",
-            value,
-            ...array
-          });
-          if (serializedArray) search.push(serializedArray);
-        } else if (typeof value === "object") {
-          const serializedObject = serializeObjectParam({
-            allowReserved,
-            explode: true,
-            name,
-            style: "deepObject",
-            value,
-            ...object
-          });
-          if (serializedObject) search.push(serializedObject);
-        } else {
-          const serializedPrimitive = serializePrimitiveParam({
-            allowReserved,
-            name,
-            value
-          });
-          if (serializedPrimitive) search.push(serializedPrimitive);
-        }
-      }
-    }
-    return search.join("&");
-  };
-  return querySerializer;
-};
-var getParseAs = (contentType) => {
-  if (!contentType) {
-    return "stream";
-  }
-  const cleanContent = contentType.split(";")[0]?.trim();
-  if (!cleanContent) {
-    return;
-  }
-  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
-    return "json";
-  }
-  if (cleanContent === "multipart/form-data") {
-    return "formData";
-  }
-  if (["application/", "audio/", "image/", "video/"].some(
-    (type) => cleanContent.startsWith(type)
-  )) {
-    return "blob";
-  }
-  if (cleanContent.startsWith("text/")) {
-    return "text";
-  }
-};
-var setAuthParams = async ({
-  security,
-  ...options
-}) => {
-  for (const auth of security) {
-    const token = await getAuthToken(auth, options.auth);
-    if (!token) {
-      continue;
-    }
-    const name = auth.name ?? "Authorization";
-    switch (auth.in) {
-      case "query":
-        if (!options.query) {
-          options.query = {};
-        }
-        options.query[name] = token;
-        break;
-      case "cookie":
-        options.headers.append("Cookie", `${name}=${token}`);
-        break;
-      case "header":
-      default:
-        options.headers.set(name, token);
-        break;
-    }
-    return;
-  }
-};
-var buildUrl = (options) => {
-  const url = getUrl({
-    baseUrl: options.baseUrl,
-    path: options.path,
-    query: options.query,
-    querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
-    url: options.url
-  });
-  return url;
-};
-var getUrl = ({
-  baseUrl,
-  path,
-  query,
-  querySerializer,
-  url: _url
-}) => {
-  const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
-  let url = (baseUrl ?? "") + pathUrl;
-  if (path) {
-    url = defaultPathSerializer({ path, url });
-  }
-  let search = query ? querySerializer(query) : "";
-  if (search.startsWith("?")) {
-    search = search.substring(1);
-  }
-  if (search) {
-    url += `?${search}`;
-  }
-  return url;
-};
-var mergeConfigs = (a, b) => {
-  const config = { ...a, ...b };
-  if (config.baseUrl?.endsWith("/")) {
-    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
-  }
-  config.headers = mergeHeaders(a.headers, b.headers);
-  return config;
-};
-var mergeHeaders = (...headers) => {
-  const mergedHeaders = new Headers();
-  for (const header of headers) {
-    if (!header || typeof header !== "object") {
-      continue;
-    }
-    const iterator = header instanceof Headers ? header.entries() : Object.entries(header);
-    for (const [key, value] of iterator) {
-      if (value === null) {
-        mergedHeaders.delete(key);
-      } else if (Array.isArray(value)) {
-        for (const v of value) {
-          mergedHeaders.append(key, v);
-        }
-      } else if (value !== void 0) {
-        mergedHeaders.set(
-          key,
-          typeof value === "object" ? JSON.stringify(value) : value
-        );
-      }
-    }
-  }
-  return mergedHeaders;
-};
-var Interceptors = class {
-  _fns;
-  constructor() {
-    this._fns = [];
-  }
-  clear() {
-    this._fns = [];
-  }
-  getInterceptorIndex(id) {
-    if (typeof id === "number") {
-      return this._fns[id] ? id : -1;
-    } else {
-      return this._fns.indexOf(id);
-    }
-  }
-  exists(id) {
-    const index = this.getInterceptorIndex(id);
-    return !!this._fns[index];
-  }
-  eject(id) {
-    const index = this.getInterceptorIndex(id);
-    if (this._fns[index]) {
-      this._fns[index] = null;
-    }
-  }
-  update(id, fn) {
-    const index = this.getInterceptorIndex(id);
-    if (this._fns[index]) {
-      this._fns[index] = fn;
-      return id;
-    } else {
-      return false;
-    }
-  }
-  use(fn) {
-    this._fns = [...this._fns, fn];
-    return this._fns.length - 1;
-  }
-};
-var createInterceptors = () => ({
-  error: new Interceptors(),
-  request: new Interceptors(),
-  response: new Interceptors()
-});
-var defaultQuerySerializer = createQuerySerializer({
-  allowReserved: false,
-  array: {
-    explode: true,
-    style: "form"
-  },
-  object: {
-    explode: true,
-    style: "deepObject"
-  }
-});
-var defaultHeaders = {
-  "Content-Type": "application/json"
-};
-var createConfig = (override = {}) => ({
-  ...jsonBodySerializer,
-  headers: defaultHeaders,
-  parseAs: "auto",
-  querySerializer: defaultQuerySerializer,
-  ...override
-});
-
-// src/api/generated/client/client.ts
-var createClient = (config = {}) => {
-  let _config = mergeConfigs(createConfig(), config);
-  const getConfig = () => ({ ..._config });
-  const setConfig = (config2) => {
-    _config = mergeConfigs(_config, config2);
-    return getConfig();
-  };
-  const interceptors = createInterceptors();
-  const request = async (options) => {
-    const opts = {
-      ..._config,
-      ...options,
-      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
-      headers: mergeHeaders(_config.headers, options.headers)
-    };
-    if (opts.security) {
-      await setAuthParams({
-        ...opts,
-        security: opts.security
-      });
-    }
-    if (opts.body && opts.bodySerializer) {
-      opts.body = opts.bodySerializer(opts.body);
-    }
-    if (opts.body === void 0 || opts.body === "") {
-      opts.headers.delete("Content-Type");
-    }
-    const url = buildUrl(opts);
-    const requestInit = {
-      redirect: "follow",
-      ...opts
-    };
-    let request2 = new Request(url, requestInit);
-    for (const fn of interceptors.request._fns) {
-      if (fn) {
-        request2 = await fn(request2, opts);
-      }
-    }
-    const _fetch = opts.fetch;
-    let response = await _fetch(request2);
-    for (const fn of interceptors.response._fns) {
-      if (fn) {
-        response = await fn(response, request2, opts);
-      }
-    }
-    const result = {
-      request: request2,
-      response
-    };
-    if (response.ok) {
-      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
-        return opts.responseStyle === "data" ? {} : {
-          data: {},
-          ...result
-        };
-      }
-      const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
-      if (parseAs === "stream") {
-        return opts.responseStyle === "data" ? response.body : {
-          data: response.body,
-          ...result
-        };
-      }
-      let data = await response[parseAs]();
-      if (parseAs === "json") {
-        if (opts.responseValidator) {
-          await opts.responseValidator(data);
-        }
-        if (opts.responseTransformer) {
-          data = await opts.responseTransformer(data);
-        }
-      }
-      return opts.responseStyle === "data" ? data : {
-        data,
-        ...result
-      };
-    }
-    let error = await response.text();
-    try {
-      error = JSON.parse(error);
-    } catch {
-    }
-    let finalError = error;
-    for (const fn of interceptors.error._fns) {
-      if (fn) {
-        finalError = await fn(error, response, request2, opts);
-      }
-    }
-    finalError = finalError || {};
-    if (opts.throwOnError) {
-      throw finalError;
-    }
-    return opts.responseStyle === "data" ? void 0 : {
-      error: finalError,
-      ...result
-    };
-  };
-  return {
-    buildUrl,
-    connect: (options) => request({ ...options, method: "CONNECT" }),
-    delete: (options) => request({ ...options, method: "DELETE" }),
-    get: (options) => request({ ...options, method: "GET" }),
-    getConfig,
-    head: (options) => request({ ...options, method: "HEAD" }),
-    interceptors,
-    options: (options) => request({ ...options, method: "OPTIONS" }),
-    patch: (options) => request({ ...options, method: "PATCH" }),
-    post: (options) => request({ ...options, method: "POST" }),
-    put: (options) => request({ ...options, method: "PUT" }),
-    request,
-    setConfig,
-    trace: (options) => request({ ...options, method: "TRACE" })
-  };
-};
-
-// src/api/client-config.ts
-var createClientConfig = (base) => ({
-  ...base,
-  throwOnError: false
-});
-
-// src/api/generated/client.gen.ts
-var client = createClient(createClientConfig(createConfig({
-  baseUrl: "http://localhost:3002"
-})));
-
-// src/api/map-error.ts
-function isBackendErrorBody(body) {
-  if (body === null || typeof body !== "object") {
-    return false;
-  }
-  const maybe = body;
-  if (maybe.error === null || typeof maybe.error !== "object") {
-    return false;
-  }
-  const e = maybe.error;
-  return typeof e.code === "string" && typeof e.title === "string" && typeof e.kind === "string";
-}
-var kindMap = {
-  validation: "validation",
-  unauth: "unauth",
-  forbidden: "forbidden",
-  notfound: "notfound",
-  precondition: "precondition",
-  conflict: "conflict",
-  internal: "internal",
-  unavailable: "unavailable",
-  timeout: "timeout"
-};
-function mapError(body, status) {
-  if (status === 0 || status === void 0 || status === null) {
-    return callpadError.network("callpad.network", "Network error", {
-      status: status ?? void 0
-    });
-  }
-  if (!isBackendErrorBody(body)) {
-    if (status === 401) {
-      return callpadError.unauth("callpad.unauth", "Unauthorized", { status });
-    }
-    if (status === 403) {
-      return callpadError.forbidden("callpad.forbidden", "Forbidden", {
-        status
-      });
-    }
-    if (status === 404) {
-      return callpadError.notfound("callpad.not_found", "Not found", {
-        status
-      });
-    }
-    if (status >= 500) {
-      return callpadError.internal(
-        "callpad.internal",
-        "Internal server error",
-        { status }
-      );
-    }
-    return callpadError.internal(
-      "callpad.unknown_response",
-      "Unexpected response shape",
-      {
-        status
-      }
-    );
-  }
-  const e = body.error;
-  const kind = kindMap[e.kind] ?? "internal";
-  return {
-    kind,
-    code: e.code,
-    title: e.title,
-    detail: e.detail,
-    retryable: e.retryable,
-    issues: e.issues,
-    status
-  };
-}
-
-// src/api/call.ts
-async function apiCall(call) {
-  try {
-    const res = await call();
-    if (res.error !== void 0 || !res.response.ok) {
-      return err(
-        mapError(
-          res.error !== void 0 ? { error: res.error } : void 0,
-          res.response.status
-        )
-      );
-    }
-    if (res.data === void 0) {
-      return err(
-        callpadError.internal(
-          "callpad.empty_response",
-          "Expected response body, got empty"
-        )
-      );
-    }
-    return ok(res.data);
-  } catch (cause) {
-    return err(callpadError.fromUnknown(cause, "HTTP request failed"));
-  }
-}
-
-// src/api/generated/sdk.gen.ts
-var getApiV1PulseGrants = (options) => {
-  return (options?.client ?? client).get({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/pulse/grants",
-    ...options
-  });
-};
-var getApiV1VendorsBySlugPresence = (options) => {
-  return (options.client ?? client).get({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/vendors/{slug}/presence",
-    ...options
-  });
-};
-var deleteApiV1VendorsBySlugPresenceStatus = (options) => {
-  return (options.client ?? client).delete({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/vendors/{slug}/presence/status",
-    ...options
-  });
-};
-var putApiV1VendorsBySlugPresenceStatus = (options) => {
-  return (options.client ?? client).put({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/vendors/{slug}/presence/status",
-    ...options,
-    headers: {
-      "Content-Type": "application/json",
-      ...options.headers
-    }
-  });
-};
-var getApiV1Sessions = (options) => {
-  return (options?.client ?? client).get({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/sessions",
-    ...options
-  });
-};
-var postApiV1Sessions = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/sessions",
-    ...options,
-    headers: {
-      "Content-Type": "application/json",
-      ...options.headers
-    }
-  });
-};
-var getApiV1SessionsInvites = (options) => {
-  return (options?.client ?? client).get({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/sessions/invites",
-    ...options
-  });
-};
-var postApiV1SessionsBySessionIdInvitesByInviteIdAccept = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/sessions/{sessionId}/invites/{inviteId}/accept",
-    ...options
-  });
-};
-var postApiV1SessionsBySessionIdInvitesByInviteIdReject = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/sessions/{sessionId}/invites/{inviteId}/reject",
-    ...options
-  });
-};
-var getApiV1SessionsBySessionId = (options) => {
-  return (options.client ?? client).get({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/sessions/{sessionId}",
-    ...options
-  });
-};
-var patchApiV1SessionsBySessionId = (options) => {
-  return (options.client ?? client).patch({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/sessions/{sessionId}",
-    ...options,
-    headers: {
-      "Content-Type": "application/json",
-      ...options.headers
-    }
-  });
-};
-var postApiV1SessionsBySessionIdJoin = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/sessions/{sessionId}/join",
-    ...options
-  });
-};
-var postApiV1SessionsBySessionIdCancel = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/sessions/{sessionId}/cancel",
-    ...options
-  });
-};
-var postApiV1SessionsBySessionIdLeave = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/sessions/{sessionId}/leave",
-    ...options
-  });
-};
-var postApiV1SessionsBySessionIdHold = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/sessions/{sessionId}/hold",
-    ...options
-  });
-};
-var postApiV1SessionsBySessionIdUnhold = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/sessions/{sessionId}/unhold",
-    ...options
-  });
-};
-var postApiV1SessionsBySessionIdEnd = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/sessions/{sessionId}/end",
-    ...options
-  });
-};
-var postApiV1SessionsBySessionIdParticipants = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/sessions/{sessionId}/participants",
-    ...options,
-    headers: {
-      "Content-Type": "application/json",
-      ...options.headers
-    }
-  });
-};
-var deleteApiV1SessionsBySessionIdParticipantsByParticipantId = (options) => {
-  return (options.client ?? client).delete({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/sessions/{sessionId}/participants/{participantId}",
-    ...options
-  });
-};
-var postApiV1SessionsBySessionIdRecordings = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/sessions/{sessionId}/recordings",
-    ...options
-  });
-};
-var postApiV1SessionsBySessionIdRecordingsByRecordingIdStop = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/v1/sessions/{sessionId}/recordings/{recordingId}/stop",
-    ...options
-  });
-};
-
-// src/api/retry.ts
-var RETRY_STATUSES = /* @__PURE__ */ new Set([502, 503, 504]);
-var DEFAULT_MAX_ATTEMPTS = 3;
-var DEFAULT_INITIAL_DELAY_MS = 300;
-function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-function nextDelay(attempt, initial) {
-  return initial * 2 ** (attempt - 1);
-}
-function makeRetryingFetch(base, opts = {}) {
-  const maxAttempts = opts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
-  const initialDelay = opts.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS;
-  return async (request) => {
-    let attempt = 0;
-    while (true) {
-      attempt += 1;
-      const res = await base(request.clone());
-      if (!RETRY_STATUSES.has(res.status) || attempt >= maxAttempts) {
-        return res;
-      }
-      await sleep(nextDelay(attempt, initialDelay));
-    }
-  };
-}
-
-// src/core/dispatch.ts
-function dispatchFromView(view) {
-  return {
-    id: view.id,
-    source: view.source,
-    strategy: view.strategy,
-    state: view.state,
-    candidateParticipantIds: view.candidateParticipantIds,
-    winnerParticipantId: nullify(view.winnerParticipantId),
-    startedAt: view.startedAt,
-    resolvedAt: nullify(view.resolvedAt),
-    timeoutAt: nullify(view.timeoutAt)
-  };
-}
-
-// src/core/participant.ts
-var DEFAULT_MEDIA = {
-  micPublished: false,
-  micMuted: true,
-  cameraPublished: false,
-  cameraMuted: true,
-  screenShareActive: false
-};
-function participantFromView(view, selfParticipantId, mediaLookup) {
-  const media = mediaLookup.get(view.participantIdentity);
-  return {
-    id: view.id,
-    ref: view.ref,
-    info: view.info,
-    role: view.role,
-    capabilities: view.capabilities,
-    transport: view.transport,
-    state: view.state,
-    participantIdentity: view.participantIdentity,
-    participantSid: nullify(view.participantSid),
-    invitedAt: view.invitedAt,
-    acceptedAt: nullify(view.acceptedAt),
-    joinedAt: nullify(view.joinedAt),
-    endedAt: nullify(view.endedAt),
-    leftReason: nullify(view.leftReason),
-    failureReason: nullify(view.failureReason),
-    isSelf: selfParticipantId !== null && view.id === selfParticipantId,
-    isSpeaking: media?.isSpeaking ?? false,
-    audioLevel: media?.audioLevel ?? 0,
-    connectionQuality: media?.connectionQuality ?? "unknown",
-    media: media ? {
-      micPublished: media.micPublished,
-      micMuted: media.micMuted,
-      cameraPublished: media.cameraPublished,
-      cameraMuted: media.cameraMuted,
-      screenShareActive: media.screenShareActive
-    } : DEFAULT_MEDIA
-  };
-}
-
-// src/core/recording.ts
-function recordingFromView(view) {
-  return {
-    id: view.id,
-    target: view.target,
-    policy: view.policy,
-    state: view.state,
-    livekitEgressId: nullify(view.livekitEgressId),
-    requestedAt: view.requestedAt,
-    startedAt: nullify(view.startedAt),
-    stoppedAt: nullify(view.stoppedAt),
-    failureReason: nullify(view.failureReason)
-  };
-}
-
-// src/core/state/event-bus.ts
-var EventBus = class {
-  handlers = /* @__PURE__ */ new Map();
-  on(type, handler) {
-    let set = this.handlers.get(type);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.handlers.set(type, set);
-    }
-    set.add(handler);
-    return () => {
-      set?.delete(handler);
-    };
-  }
-  emit(type, payload) {
-    const set = this.handlers.get(type);
-    if (!set) {
-      return;
-    }
-    for (const handler of set) {
-      try {
-        handler(payload);
-      } catch {
-      }
-    }
-  }
-  clear() {
-    this.handlers.clear();
-  }
-  hasHandlers(type) {
-    const set = this.handlers.get(type);
-    return set !== void 0 && set.size > 0;
-  }
-};
-
-// src/core/state/reconciler.ts
-function shouldApplyUpsert(prev, incoming) {
-  if (prev === void 0) {
-    return true;
-  }
-  return incoming.version > prev.version;
-}
-
-// src/core/telephony-leg.ts
-function telephonyLegFromOperation(participant, op) {
-  return {
-    id: op.id,
-    participantId: participant.id,
-    participantIdentity: participant.participantIdentity,
-    direction: op.direction,
-    state: op.state,
-    remotePhoneNumber: op.remotePhoneNumber,
-    localPhoneNumber: nullify(op.localPhoneNumber),
-    livekitSipCallId: nullify(op.provider.livekitSipCallId),
-    providerSipCallId: nullify(op.provider.providerSipCallId),
-    livekitSipTrunkId: nullify(op.provider.livekitSipTrunkId),
-    vendorPhoneNumberId: nullify(op.provider.vendorPhoneNumberId),
-    sipExtension: nullify(op.provider.sipExtension),
-    createdAt: op.createdAt,
-    ringingAt: nullify(op.ringingAt),
-    activeAt: nullify(op.activeAt),
-    endedAt: nullify(op.endedAt),
-    failureReason: nullify(op.failureReason),
-    sipStatusCode: nullify(op.sipStatusCode),
-    providerError: nullify(op.providerError)
-  };
-}
-function collectSipLegs(participants) {
-  const legs = [];
-  for (const participant of participants) {
-    for (const op of participant.operations) {
-      if (op.kind === "sip_leg") {
-        legs.push(telephonyLegFromOperation(participant, op));
-      }
-    }
-  }
-  return legs;
-}
-var DEFAULT_ROTATE_LEAD_MS = 10 * 60 * 1e3;
-var FORWARDED_EVENTS = [
-  "session.upsert",
-  "session.remove",
-  "session.invite.upsert",
-  "session.invite.remove"
-];
-var PulseTransport = class {
-  socket = null;
-  grant = null;
-  rotateTimer = null;
-  status = "idle";
-  disposed = false;
-  bus = new EventBus();
-  rotateLeadMs;
-  logger;
-  grantFetcher;
-  constructor(opts) {
-    this.rotateLeadMs = opts.rotateLeadMs ?? DEFAULT_ROTATE_LEAD_MS;
-    this.logger = opts.logger.child({ component: "pulse" });
-    this.grantFetcher = opts.grantFetcher;
-  }
-  getStatus() {
-    return this.status;
-  }
-  on(type, handler) {
-    return this.bus.on(type, handler);
-  }
-  async connect() {
-    if (this.disposed) {
-      return err(callpadError.disposed());
-    }
-    if (this.status === "connected" || this.status === "connecting") {
-      return ok(void 0);
-    }
-    this.setStatus("connecting");
-    const grant = await this.grantFetcher();
-    if (!grant.ok) {
-      this.setStatus("disconnected");
-      return err(grant.error);
-    }
-    this.grant = grant.value;
-    try {
-      await this.openSocket(grant.value);
-    } catch (cause) {
-      this.setStatus("disconnected");
-      return err(
-        callpadError.unavailable(
-          "pulse.connect_failed",
-          "Pulse connect failed",
-          {
-            cause: cause instanceof Error ? cause : void 0
-          }
-        )
-      );
-    }
-    this.scheduleRotate(grant.value);
-    return ok(void 0);
-  }
-  async disconnect() {
-    this.clearRotate();
-    this.closeSocket();
-    this.setStatus("disconnected");
-  }
-  async dispose() {
-    if (this.disposed) {
-      return;
-    }
-    this.disposed = true;
-    this.clearRotate();
-    this.closeSocket();
-    this.bus.clear();
-    this.status = "disconnected";
-  }
-  setStatus(next) {
-    if (next === this.status) {
-      return;
-    }
-    const previous = this.status;
-    this.status = next;
-    this.bus.emit("status.changed", { status: next, previous });
-  }
-  openSocket(grant) {
-    return new Promise((resolve, reject) => {
-      const socket = io(grant.url, {
-        path: grant.path,
-        transports: ["websocket"],
-        auth: { token: grant.token },
-        reconnection: true,
-        reconnectionAttempts: Infinity
-      });
-      socket.on("connect", () => {
-        this.setStatus("connected");
-      });
-      socket.on("reconnect_attempt", () => {
-        this.setStatus("recovering");
-      });
-      socket.on("disconnect", () => {
-        if (!this.disposed) {
-          this.setStatus("recovering");
-        }
-      });
-      socket.on("connect_error", (cause) => {
-        const error = callpadError.unavailable(
-          "pulse.connect_error",
-          "Pulse socket error",
-          { cause: cause instanceof Error ? cause : void 0 }
-        );
-        this.bus.emit("error", { error });
-      });
-      for (const event of FORWARDED_EVENTS) {
-        socket.on(event, (payload) => {
-          this.bus.emit(event, payload);
-        });
-      }
-      socket.once("connect", () => resolve());
-      socket.once("connect_error", (cause) => {
-        if (this.status !== "connected") {
-          reject(cause);
-        }
-      });
-      this.socket = socket;
-    });
-  }
-  closeSocket() {
-    if (!this.socket) {
-      return;
-    }
-    this.socket.removeAllListeners();
-    this.socket.disconnect();
-    this.socket = null;
-  }
-  scheduleRotate(grant) {
-    this.clearRotate();
-    const expiresAt = Date.parse(grant.expiresAt);
-    if (Number.isNaN(expiresAt)) {
-      return;
-    }
-    const refreshAt = Math.max(0, expiresAt - Date.now() - this.rotateLeadMs);
-    this.rotateTimer = setTimeout(() => {
-      void this.rotateGrant();
-    }, refreshAt);
-    this.rotateTimer.unref?.();
-  }
-  scheduleRotateRetry() {
-    this.clearRotate();
-    this.rotateTimer = setTimeout(() => {
-      void this.rotateGrant();
-    }, this.rotateLeadMs);
-    this.rotateTimer.unref?.();
-  }
-  clearRotate() {
-    if (this.rotateTimer) {
-      clearTimeout(this.rotateTimer);
-      this.rotateTimer = null;
-    }
-  }
-  async rotateGrant() {
-    if (this.disposed) {
-      return;
-    }
-    const grant = await this.grantFetcher();
-    if (!grant.ok) {
-      this.logger.warn(
-        { code: grant.error.code },
-        "pulse grant refresh failed"
-      );
-      this.scheduleRotateRetry();
-      return;
-    }
-    this.grant = grant.value;
-    this.closeSocket();
-    try {
-      await this.openSocket(grant.value);
-    } catch (cause) {
-      this.logger.warn(
-        { err: cause instanceof Error ? cause : void 0 },
-        "pulse reopen failed"
-      );
-    }
-    this.scheduleRotate(grant.value);
-  }
-};
-function qualityOf(q) {
-  switch (q) {
-    case ConnectionQuality.Excellent:
-      return "excellent";
-    case ConnectionQuality.Good:
-      return "good";
-    case ConnectionQuality.Poor:
-      return "poor";
-    case ConnectionQuality.Lost:
-      return "lost";
-    default:
-      return "unknown";
-  }
-}
-function snapshotOf(p) {
-  const micPub = p.getTrackPublication(Track.Source.Microphone);
-  const camPub = p.getTrackPublication(Track.Source.Camera);
-  const screenPub = p.getTrackPublication(Track.Source.ScreenShare);
-  return {
-    identity: p.identity,
-    isSpeaking: p.isSpeaking,
-    audioLevel: p.audioLevel,
-    micPublished: micPub !== void 0,
-    micMuted: micPub?.isMuted ?? true,
-    cameraPublished: camPub !== void 0,
-    cameraMuted: camPub?.isMuted ?? true,
-    screenShareActive: screenPub !== void 0 && !screenPub.isMuted,
-    connectionQuality: qualityOf(p.connectionQuality)
-  };
-}
-function snapshotEquals(a, b) {
-  return a.isSpeaking === b.isSpeaking && a.audioLevel === b.audioLevel && a.micPublished === b.micPublished && a.micMuted === b.micMuted && a.cameraPublished === b.cameraPublished && a.cameraMuted === b.cameraMuted && a.screenShareActive === b.screenShareActive && a.connectionQuality === b.connectionQuality;
-}
-var MediaRoomAdapter = class {
-  room;
-  bus = new EventBus();
-  logger;
-  snapshots = /* @__PURE__ */ new Map();
-  state = "unconnected";
-  disposed = false;
-  constructor(logger) {
-    this.logger = logger.child({ component: "media" });
-    this.room = new Room({
-      adaptiveStream: true,
-      dynacast: true,
-      disconnectOnPageLeave: false,
-      singlePeerConnection: false
-    });
-    this.wireRoomEvents();
-  }
-  getRoom() {
-    return this.room;
-  }
-  getState() {
-    return this.state;
-  }
-  getSnapshot(identity) {
-    return this.snapshots.get(identity);
-  }
-  listSnapshots() {
-    return this.snapshots;
-  }
-  on(type, handler) {
-    return this.bus.on(type, handler);
-  }
-  async connect(opts) {
-    if (this.disposed) {
-      return err(callpadError.disposed());
-    }
-    this.setState("connecting");
-    try {
-      await this.room.connect(opts.url, opts.token);
-      await this.room.localParticipant.setMicrophoneEnabled(true);
-      if (opts.video === true) {
-        await this.room.localParticipant.setCameraEnabled(true);
-      }
-      return ok(void 0);
-    } catch (cause) {
-      this.setState("disconnected");
-      return err(
-        callpadError.mediaUnavailable(
-          "media.connect_failed",
-          "Media connect failed",
-          {
-            cause: cause instanceof Error ? cause : void 0
-          }
-        )
-      );
-    }
-  }
-  async disconnect() {
-    await this.room.disconnect(true);
-    this.snapshots.clear();
-    this.setState("disconnected");
-  }
-  async dispose() {
-    if (this.disposed) {
-      return;
-    }
-    this.disposed = true;
-    await this.room.disconnect(true);
-    this.bus.clear();
-    this.snapshots.clear();
-    this.state = "disconnected";
-  }
-  setState(next) {
-    if (next === this.state) {
-      return;
-    }
-    const previous = this.state;
-    this.state = next;
-    this.bus.emit("state.changed", { state: next, previous });
-  }
-  wireRoomEvents() {
-    this.room.on(RoomEvent.ConnectionStateChanged, (state) => {
-      switch (state) {
-        case ConnectionState.Connected:
-          this.setState("connected");
-          break;
-        case ConnectionState.Connecting:
-          this.setState("connecting");
-          break;
-        case ConnectionState.Reconnecting:
-          this.setState("reconnecting");
-          break;
-        case ConnectionState.Disconnected:
-          this.setState("disconnected");
-          break;
-      }
-    });
-    const refresh = (p) => {
-      const snapshot = snapshotOf(p);
-      const previous = this.snapshots.get(p.identity);
-      if (previous && snapshotEquals(previous, snapshot)) {
-        return;
-      }
-      this.snapshots.set(p.identity, snapshot);
-      this.bus.emit("participant.changed", { identity: p.identity, snapshot });
-    };
-    this.room.on(
-      RoomEvent.ParticipantConnected,
-      (p) => refresh(p)
-    );
-    this.room.on(RoomEvent.ParticipantDisconnected, (p) => {
-      this.snapshots.delete(p.identity);
-      this.bus.emit("participant.changed", {
-        identity: p.identity,
-        snapshot: {
-          identity: p.identity,
-          isSpeaking: false,
-          audioLevel: 0,
-          micPublished: false,
-          micMuted: true,
-          cameraPublished: false,
-          cameraMuted: true,
-          screenShareActive: false,
-          connectionQuality: "lost"
-        }
-      });
-    });
-    this.room.on(RoomEvent.TrackSubscribed, (_track, _pub, p) => refresh(p));
-    this.room.on(RoomEvent.TrackUnsubscribed, (_track, _pub, p) => refresh(p));
-    this.room.on(RoomEvent.TrackMuted, (_pub, p) => refresh(p));
-    this.room.on(RoomEvent.TrackUnmuted, (_pub, p) => refresh(p));
-    this.room.on(
-      RoomEvent.LocalTrackPublished,
-      (_pub, p) => refresh(p)
-    );
-    this.room.on(
-      RoomEvent.LocalTrackUnpublished,
-      (_pub, p) => refresh(p)
-    );
-    this.room.on(
-      RoomEvent.ConnectionQualityChanged,
-      (_q, p) => refresh(p)
-    );
-    this.room.on(RoomEvent.ActiveSpeakersChanged, (speakers) => {
-      const identities = speakers.map((p) => p.identity);
-      this.bus.emit("active_speakers.changed", { identities });
-    });
-    this.room.on(RoomEvent.MediaDevicesError, (cause) => {
-      this.bus.emit("error", {
-        error: callpadError.mediaDevice(
-          "media.device_error",
-          "Media device error",
-          {
-            cause: cause instanceof Error ? cause : void 0
-          }
-        )
-      });
-      this.logger.warn(
-        { err: cause instanceof Error ? cause : void 0 },
-        "media device error"
-      );
-    });
-  }
-};
-
-// src/core/session/session.ts
-var Session = class {
-  view;
-  vendor;
-  logger;
-  bus = new EventBus();
-  media;
-  commands;
-  ctx;
-  mediaStatus = "unconnected";
-  selfParticipantId;
-  disposed = false;
-  cachedGrant = null;
-  cachedParticipants = null;
-  cachedTelephonyLegs = null;
-  cachedRecordings = null;
-  cachedDispatches = null;
-  constructor(opts) {
-    this.vendor = opts.vendor;
-    this.logger = opts.logger.child({ session: opts.view.id });
-    this.view = opts.view;
-    this.selfParticipantId = opts.selfParticipantId;
-    this.commands = opts.commands;
-    this.media = new MediaRoomAdapter(this.logger);
-    this.ctx = {
-      session: this,
-      media: this.media,
-      applyView: (view) => this.applyView(view)
-    };
-    this.wireMedia();
-  }
-  get id() {
-    return this.view.id;
-  }
-  get callId() {
-    return this.view.callId;
-  }
-  get vendorId() {
-    return this.view.vendorId;
-  }
-  get vendorSlug() {
-    return this.vendor;
-  }
-  get mediaType() {
-    return this.view.mediaType;
-  }
-  get state() {
-    return this.view.state;
-  }
-  get version() {
-    return this.view.version;
-  }
-  get route() {
-    return this.view.route;
-  }
-  get viewSnapshot() {
-    return this.view;
-  }
-  get mediaStatusSnapshot() {
-    return this.mediaStatus;
-  }
-  get mediaRoom() {
-    return this.media.getRoom();
-  }
-  get participants() {
-    if (this.cachedParticipants === null) {
-      const lookup = this.media.listSnapshots();
-      this.cachedParticipants = this.view.participants.map(
-        (p) => participantFromView(p, this.selfParticipantId, lookup)
-      );
-    }
-    return this.cachedParticipants;
-  }
-  get telephonyLegs() {
-    if (this.cachedTelephonyLegs === null) {
-      this.cachedTelephonyLegs = collectSipLegs(this.view.participants);
-    }
-    return this.cachedTelephonyLegs;
-  }
-  get dispatches() {
-    if (this.cachedDispatches === null) {
-      this.cachedDispatches = this.view.dispatches.map(dispatchFromView);
-    }
-    return this.cachedDispatches;
-  }
-  get recordings() {
-    if (this.cachedRecordings === null) {
-      this.cachedRecordings = this.view.recordings.map(recordingFromView);
-    }
-    return this.cachedRecordings;
-  }
-  get activeRecording() {
-    const active = this.view.recordings.find(
-      (r) => r.state === "requested" || r.state === "active"
-    );
-    return active ? recordingFromView(active) : null;
-  }
-  get self() {
-    if (this.selfParticipantId === null) {
-      return null;
-    }
-    return this.participants.find((p) => p.id === this.selfParticipantId) ?? null;
-  }
-  capabilitiesOf(participantId) {
-    const id = participantId ?? this.selfParticipantId;
-    if (id === null || id === void 0) {
-      return [];
-    }
-    const participant = this.view.participants.find((p) => p.id === id);
-    return participant?.capabilities ?? [];
-  }
-  on(type, handler) {
-    return this.bus.on(type, handler);
-  }
-  applyView(next) {
-    const previous = this.view;
-    if (!shouldApplyUpsert(previous, next)) {
-      return;
-    }
-    this.view = next;
-    this.invalidateCaches();
-    this.bus.emit("view.changed", { view: next, previous });
-    if (next.state !== previous.state) {
-      this.bus.emit("state.changed", {
-        state: next.state,
-        previous: previous.state
-      });
-    }
-    this.diffParticipants(previous, next);
-    this.diffTelephonyLegs(previous, next);
-    this.diffDispatches(previous, next);
-    this.diffRecordings(previous, next);
-    if (previous.state !== "on_hold" && next.state === "on_hold") {
-      this.bus.emit("session.held", { heldAt: (/* @__PURE__ */ new Date()).toISOString() });
-    }
-    if (previous.state === "on_hold" && next.state !== "on_hold" && next.state !== "ended") {
-      this.bus.emit("session.unheld", { unheldAt: (/* @__PURE__ */ new Date()).toISOString() });
-    }
-    if (previous.state !== "ended" && next.state === "ended") {
-      this.bus.emit("session.ended", {
-        reason: next.endReason ?? "completed",
-        endedAt: next.endedAt ?? (/* @__PURE__ */ new Date()).toISOString()
-      });
-    }
-  }
-  async dispatch(name, ...rest) {
-    if (this.disposed) {
-      return err(callpadError.disposed());
-    }
-    const cmd = this.commands.get(name);
-    if (!cmd) {
-      return err(
-        callpadError.notfound(
-          "session.unknown_command",
-          `Unknown session command: ${String(name)}`
-        )
-      );
-    }
-    return cmd.execute(this.ctx, rest[0]);
-  }
-  async join() {
-    if (this.disposed) {
-      return err(callpadError.disposed());
-    }
-    if (this.mediaStatus === "connected") {
-      return ok(void 0);
-    }
-    if (this.isEnded()) {
-      return ok(void 0);
-    }
-    const grant = await this.requestGrant();
-    if (!grant.ok) {
-      return grant;
-    }
-    return this.joinWithGrant(grant.value);
-  }
-  async joinWithGrant(grant) {
-    if (this.disposed) {
-      return err(callpadError.disposed());
-    }
-    if (this.mediaStatus === "connected") {
-      return ok(void 0);
-    }
-    if (this.isEnded()) {
-      return ok(void 0);
-    }
-    const previousSelfId = this.selfParticipantId;
-    this.cachedGrant = grant;
-    this.selfParticipantId = grant.participantId;
-    this.cachedParticipants = null;
-    const connected = await this.media.connect({
-      url: grant.url,
-      token: grant.token,
-      video: this.view.mediaType === "video"
-    });
-    if (!connected.ok) {
-      this.cachedGrant = null;
-      this.selfParticipantId = previousSelfId;
-      this.cachedParticipants = null;
-      if (this.isEnded()) {
-        return ok(void 0);
-      }
-    }
-    return connected;
-  }
-  isEnded() {
-    return this.view.state === "ended";
-  }
-  leave() {
-    return this.dispatch("leave");
-  }
-  cancel() {
-    return this.dispatch("cancel");
-  }
-  end() {
-    return this.dispatch("end");
-  }
-  hold() {
-    return this.dispatch("hold");
-  }
-  unhold() {
-    return this.dispatch("unhold");
-  }
-  startRecording() {
-    return this.dispatch("startRecording");
-  }
-  stopRecording(recordingId) {
-    return this.dispatch("stopRecording", recordingId);
-  }
-  invite(target2) {
-    return this.dispatch("invite", target2);
-  }
-  removeParticipant(participantId) {
-    return this.dispatch("removeParticipant", participantId);
-  }
-  updateName(name) {
-    return this.dispatch("updateName", name);
-  }
-  mediaGrant() {
-    return this.cachedGrant;
-  }
-  async dispose() {
-    if (this.disposed) {
-      return;
-    }
-    this.disposed = true;
-    await this.media.dispose();
-    this.bus.clear();
-  }
-  async requestGrant() {
-    return apiCall(
-      () => postApiV1SessionsBySessionIdJoin({
-        path: { sessionId: this.id },
-        query: { vendor: this.vendor }
-      })
-    );
-  }
-  invalidateCaches() {
-    this.cachedParticipants = null;
-    this.cachedTelephonyLegs = null;
-    this.cachedRecordings = null;
-    this.cachedDispatches = null;
-  }
-  wireMedia() {
-    this.media.on("state.changed", ({ state }) => {
-      this.mediaStatus = state;
-      this.bus.emit("media.status.changed", { status: state });
-    });
-    this.media.on("participant.changed", ({ identity }) => {
-      this.cachedParticipants = null;
-      const view = this.view.participants.find(
-        (p2) => p2.participantIdentity === identity
-      );
-      if (!view) {
-        return;
-      }
-      const p = participantFromView(
-        view,
-        this.selfParticipantId,
-        this.media.listSnapshots()
-      );
-      this.bus.emit("participant.updated", { participant: p });
-    });
-    this.media.on("error", ({ error }) => {
-      this.bus.emit("error", { error });
-    });
-  }
-  diffParticipants(prev, next) {
-    const byId = new Map(prev.participants.map((p) => [p.id, p]));
-    const lookup = this.media.listSnapshots();
-    const prevJoinedCount = prev.participants.filter(
-      (p) => p.state === "joined"
-    ).length;
-    for (const current of next.participants) {
-      const before = byId.get(current.id);
-      const participant = participantFromView(
-        current,
-        this.selfParticipantId,
-        lookup
-      );
-      if (!before) {
-        this.bus.emit("participant.invited", { participant });
-        continue;
-      }
-      if (before.state === current.state) {
-        continue;
-      }
-      switch (current.state) {
-        case "accepted":
-          this.bus.emit("participant.accepted", { participant });
-          break;
-        case "joined": {
-          const isFirstJoin = prevJoinedCount === 0;
-          this.bus.emit("participant.joined", { participant, isFirstJoin });
-          break;
-        }
-        case "left": {
-          const reason = nullify(current.leftReason) ?? "left";
-          this.bus.emit("participant.left", { participant, reason });
-          break;
-        }
-        case "declined":
-          this.bus.emit("participant.declined", { participant });
-          break;
-        case "withdrawn":
-          this.bus.emit("participant.withdrawn", { participant });
-          break;
-        case "removed":
-          this.bus.emit("participant.removed", { participant });
-          break;
-        case "failed": {
-          const reason = nullify(current.failureReason) ?? "unknown";
-          const failedSipLeg = current.operations.find(
-            (op) => op.kind === "sip_leg" && op.state === "failed"
-          );
-          this.bus.emit("participant.failed", {
-            participant,
-            reason,
-            legFailureReason: nullify(failedSipLeg?.failureReason ?? null),
-            sipStatusCode: nullify(failedSipLeg?.sipStatusCode ?? null)
-          });
-          break;
-        }
-        default:
-          this.bus.emit("participant.updated", { participant });
-      }
-    }
-  }
-  diffTelephonyLegs(prev, next) {
-    const beforeState = /* @__PURE__ */ new Map();
-    for (const p of prev.participants) {
-      for (const op of p.operations) {
-        if (op.kind === "sip_leg") {
-          beforeState.set(op.id, op.state);
-        }
-      }
-    }
-    for (const participant of next.participants) {
-      for (const op of participant.operations) {
-        if (op.kind !== "sip_leg") {
-          continue;
-        }
-        const beforeOp = beforeState.get(op.id);
-        if (beforeOp === op.state) {
-          continue;
-        }
-        this.bus.emit("telephony_leg.updated", {
-          leg: telephonyLegFromOperation(participant, op)
-        });
-      }
-    }
-  }
-  diffDispatches(prev, next) {
-    const byId = new Map(prev.dispatches.map((d) => [d.id, d]));
-    for (const current of next.dispatches) {
-      const before = byId.get(current.id);
-      const dispatch = dispatchFromView(current);
-      if (!before) {
-        if (current.state === "active") {
-          this.bus.emit("dispatch.started", { dispatch });
-        }
-        continue;
-      }
-      if (before.state === current.state) {
-        continue;
-      }
-      switch (current.state) {
-        case "resolved":
-          this.bus.emit("dispatch.resolved", { dispatch });
-          break;
-        case "cancelled":
-          this.bus.emit("dispatch.cancelled", { dispatch });
-          break;
-        case "expired":
-          this.bus.emit("dispatch.expired", { dispatch });
-          break;
-      }
-    }
-  }
-  diffRecordings(prev, next) {
-    const byId = new Map(prev.recordings.map((r) => [r.id, r]));
-    for (const current of next.recordings) {
-      const before = byId.get(current.id);
-      const recording = recordingFromView(current);
-      if (!before) {
-        this.bus.emit("recording.requested", { recording });
-        continue;
-      }
-      if (before.state === current.state) {
-        continue;
-      }
-      if (current.state === "active") {
-        this.bus.emit("recording.started", { recording });
-        continue;
-      }
-      if (current.state === "stopped") {
-        this.bus.emit("recording.stopped", { recording });
-        continue;
-      }
-      if (current.state === "failed") {
-        this.bus.emit("recording.failed", {
-          recording,
-          reason: nullify(current.failureReason)
-        });
-      }
-    }
-  }
-};
-
-// src/core/session/commands.ts
-function target(ctx) {
-  return {
-    path: { sessionId: ctx.session.id },
-    query: { vendor: ctx.session.vendorSlug }
-  };
-}
-var holdCommand = {
-  name: "hold",
-  async execute(ctx) {
-    const res = await apiCall(
-      () => postApiV1SessionsBySessionIdHold(target(ctx))
-    );
-    if (!res.ok) {
-      return res;
-    }
-    ctx.applyView(res.value);
-    return ok(void 0);
-  }
-};
-var unholdCommand = {
-  name: "unhold",
-  async execute(ctx) {
-    const res = await apiCall(
-      () => postApiV1SessionsBySessionIdUnhold(target(ctx))
-    );
-    if (!res.ok) {
-      return res;
-    }
-    ctx.applyView(res.value);
-    return ok(void 0);
-  }
-};
-var cancelCommand = {
-  name: "cancel",
-  async execute(ctx) {
-    const res = await apiCall(
-      () => postApiV1SessionsBySessionIdCancel(target(ctx))
-    );
-    if (!res.ok) {
-      return res;
-    }
-    ctx.applyView(res.value);
-    return ok(void 0);
-  }
-};
-var endCommand = {
-  name: "end",
-  async execute(ctx) {
-    const res = await apiCall(
-      () => postApiV1SessionsBySessionIdEnd(target(ctx))
-    );
-    if (!res.ok) {
-      return res;
-    }
-    ctx.applyView(res.value);
-    return ok(void 0);
-  }
-};
-var leaveCommand = {
-  name: "leave",
-  async execute(ctx) {
-    if (ctx.session.state === "ended") {
-      await ctx.media.disconnect();
-      return ok(void 0);
-    }
-    const res = await apiCall(
-      () => postApiV1SessionsBySessionIdLeave(target(ctx))
-    );
-    await ctx.media.disconnect();
-    if (!res.ok) {
-      return res;
-    }
-    ctx.applyView(res.value);
-    return ok(void 0);
-  }
-};
-var inviteCommand = {
-  name: "invite",
-  async execute(ctx, invited) {
-    const body = { target: invited };
-    const res = await apiCall(
-      () => postApiV1SessionsBySessionIdParticipants({
-        ...target(ctx),
-        body
-      })
-    );
-    if (!res.ok) {
-      return res;
-    }
-    ctx.applyView(res.value);
-    return ok(void 0);
-  }
-};
-var removeParticipantCommand = {
-  name: "removeParticipant",
-  async execute(ctx, participantId) {
-    const res = await apiCall(
-      () => deleteApiV1SessionsBySessionIdParticipantsByParticipantId({
-        path: { sessionId: ctx.session.id, participantId },
-        query: { vendor: ctx.session.vendorSlug }
-      })
-    );
-    if (!res.ok) {
-      return res;
-    }
-    ctx.applyView(res.value);
-    return ok(void 0);
-  }
-};
-var updateNameCommand = {
-  name: "updateName",
-  async execute(ctx, name) {
-    const res = await apiCall(
-      () => patchApiV1SessionsBySessionId({
-        ...target(ctx),
-        body: { name }
-      })
-    );
-    if (!res.ok) {
-      return res;
-    }
-    ctx.applyView(res.value);
-    return ok(void 0);
-  }
-};
-var startRecordingCommand = {
-  name: "startRecording",
-  async execute(ctx) {
-    const res = await apiCall(
-      () => postApiV1SessionsBySessionIdRecordings(target(ctx))
-    );
-    if (!res.ok) {
-      return res;
-    }
-    return ok(void 0);
-  }
-};
-var stopRecordingCommand = {
-  name: "stopRecording",
-  async execute(ctx, recordingId) {
-    const res = await apiCall(
-      () => postApiV1SessionsBySessionIdRecordingsByRecordingIdStop({
-        path: { sessionId: ctx.session.id, recordingId },
-        query: { vendor: ctx.session.vendorSlug }
-      })
-    );
-    if (!res.ok) {
-      return res;
-    }
-    return ok(void 0);
-  }
-};
-
-// src/core/managers/session-manager.ts
-var ACTIVE_STATES = /* @__PURE__ */ new Set(["ringing", "active", "on_hold"]);
-var SessionManager = class {
-  sessions = /* @__PURE__ */ new Map();
-  vendor;
-  logger;
-  pulse;
-  commands;
-  selfParticipantId;
-  bus = new EventBus();
-  unsubs = [];
-  cachedList = null;
-  disposed = false;
-  constructor(opts) {
-    this.vendor = opts.vendor;
-    this.logger = opts.logger.child({ component: "session-manager" });
-    this.pulse = opts.pulse;
-    this.selfParticipantId = opts.selfParticipantId;
-    this.commands = opts.commands;
-    this.unsubs.push(
-      this.pulse.on("session.upsert", (view) => this.onUpsert(view)),
-      this.pulse.on(
-        "session.remove",
-        ({ sessionId, version }) => this.onRemove(sessionId, version)
-      )
-    );
-  }
-  list() {
-    if (this.cachedList === null) {
-      this.cachedList = Array.from(this.sessions.values());
-    }
-    return this.cachedList;
-  }
-  get(id) {
-    return this.sessions.get(id) ?? null;
-  }
-  active() {
-    for (const session of this.sessions.values()) {
-      if (ACTIVE_STATES.has(session.state)) {
-        return session;
-      }
-    }
-    return null;
-  }
-  activeId() {
-    return this.active()?.id ?? null;
-  }
-  on(type, handler) {
-    return this.bus.on(type, handler);
-  }
-  async prime() {
-    if (this.disposed) {
-      return err(callpadError.disposed());
-    }
-    const res = await apiCall(
-      () => getApiV1Sessions({ query: { vendor: this.vendor, limit: 50 } })
-    );
-    if (!res.ok) {
-      return res;
-    }
-    for (const view of res.value.items) {
-      this.onUpsert(view);
-    }
-    return ok(void 0);
-  }
-  async create(body) {
-    if (this.disposed) {
-      return err(callpadError.disposed());
-    }
-    const res = await apiCall(
-      () => postApiV1Sessions({
-        query: { vendor: this.vendor },
-        body
-      })
-    );
-    if (!res.ok) {
-      return res;
-    }
-    const session = this.onUpsert(res.value);
-    return ok(session);
-  }
-  async fetchById(id) {
-    if (this.disposed) {
-      return err(callpadError.disposed());
-    }
-    const res = await apiCall(
-      () => getApiV1SessionsBySessionId({
-        path: { sessionId: id },
-        query: { vendor: this.vendor }
-      })
-    );
-    if (!res.ok) {
-      return res;
-    }
-    const session = this.onUpsert(res.value);
-    return ok(session);
-  }
-  onAcceptedInvite(view) {
-    return this.onUpsert(view);
-  }
-  onUpsert(view) {
-    const existing = this.sessions.get(view.id);
-    if (existing) {
-      if (shouldApplyUpsert(existing, view)) {
-        existing.applyView(view);
-      }
-      return existing;
-    }
-    const session = new Session({
-      vendor: this.vendor,
-      view,
-      logger: this.logger,
-      selfParticipantId: this.selfParticipantId,
-      commands: this.commands
-    });
-    this.sessions.set(view.id, session);
-    this.cachedList = null;
-    this.bus.emit("session.added", { session });
-    return session;
-  }
-  onRemove(sessionId, _version) {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      return;
-    }
-    this.sessions.delete(sessionId);
-    this.cachedList = null;
-    this.bus.emit("session.removed", { sessionId });
-    void session.dispose();
-  }
-  async dispose() {
-    if (this.disposed) {
-      return;
-    }
-    this.disposed = true;
-    for (const unsub of this.unsubs) {
-      unsub();
-    }
-    await Promise.all(
-      Array.from(this.sessions.values(), (session) => session.dispose())
-    );
-    this.sessions.clear();
-    this.bus.clear();
-  }
-};
-
-// src/core/invite.ts
-var Invite = class {
-  view;
-  vendor;
-  onAccept;
-  disposed = false;
-  constructor(view, vendor, onAccept) {
-    this.view = view;
-    this.vendor = vendor;
-    this.onAccept = onAccept;
-  }
-  get id() {
-    return this.view.id;
-  }
-  get sessionId() {
-    return this.view.sessionId;
-  }
-  get callId() {
-    return this.view.callId;
-  }
-  get state() {
-    return this.view.state;
-  }
-  get createdAt() {
-    return this.view.createdAt;
-  }
-  get expiresAt() {
-    return nullify(this.view.expiresAt);
-  }
-  get completedAt() {
-    return nullify(this.view.completedAt);
-  }
-  get dispatchId() {
-    return nullify(this.view.dispatchId);
-  }
-  get recipient() {
-    return this.view.recipient;
-  }
-  get participantId() {
-    return this.view.participantId;
-  }
-  get inviterParticipantId() {
-    return nullify(this.view.inviterParticipantId);
-  }
-  get session() {
-    return this.view.session;
-  }
-  applyView(next) {
-    this.view = next;
-  }
-  async accept() {
-    if (this.disposed) {
-      return err(callpadError.disposed());
-    }
-    const res = await apiCall(
-      () => postApiV1SessionsBySessionIdInvitesByInviteIdAccept({
-        path: { sessionId: this.sessionId, inviteId: this.id },
-        query: { vendor: this.vendor }
-      })
-    );
-    if (!res.ok) {
-      return res;
-    }
-    return this.onAccept(res.value);
-  }
-  async reject() {
-    if (this.disposed) {
-      return err(callpadError.disposed());
-    }
-    const res = await apiCall(
-      () => postApiV1SessionsBySessionIdInvitesByInviteIdReject({
-        path: { sessionId: this.sessionId, inviteId: this.id },
-        query: { vendor: this.vendor }
-      })
-    );
-    if (!res.ok) {
-      return res;
-    }
-    return ok(void 0);
-  }
-  dispose() {
-    this.disposed = true;
-  }
-};
-
-// src/core/managers/invite-manager.ts
-var InviteManager = class {
-  invites = /* @__PURE__ */ new Map();
-  sessionIndex = /* @__PURE__ */ new Map();
-  vendor;
-  pulse;
-  onAccept;
-  bus = new EventBus();
-  unsubs = [];
-  cachedList = null;
-  disposed = false;
-  constructor(opts) {
-    this.vendor = opts.vendor;
-    this.pulse = opts.pulse;
-    this.onAccept = opts.onAccept;
-    this.unsubs.push(
-      this.pulse.on("session.invite.upsert", (view) => this.onUpsert(view)),
-      this.pulse.on(
-        "session.invite.remove",
-        ({ inviteId }) => this.onRemove(inviteId)
-      ),
-      this.pulse.on(
-        "session.remove",
-        ({ sessionId }) => this.dropBySession(sessionId)
-      )
-    );
-  }
-  list() {
-    if (this.cachedList === null) {
-      this.cachedList = Array.from(this.invites.values());
-    }
-    return this.cachedList;
-  }
-  get(id) {
-    return this.invites.get(id) ?? null;
-  }
-  first() {
-    const iterator = this.invites.values().next();
-    return iterator.done ? null : iterator.value;
-  }
-  on(type, handler) {
-    return this.bus.on(type, handler);
-  }
-  async prime() {
-    if (this.disposed) {
-      return err(callpadError.disposed());
-    }
-    const res = await apiCall(
-      () => getApiV1SessionsInvites({ query: { vendor: this.vendor } })
-    );
-    if (!res.ok) {
-      return res;
-    }
-    for (const view of res.value) {
-      this.onUpsert(view);
-    }
-    return ok(void 0);
-  }
-  onUpsert(view) {
-    if (view.state !== "pending") {
-      this.onRemove(view.id);
-      return;
-    }
-    const existing = this.invites.get(view.id);
-    if (existing) {
-      if (!shouldApplyUpsert(existing.session, view.session)) {
-        return;
-      }
-      existing.applyView(view);
-      this.bus.emit("invite.updated", { invite: existing });
-      return;
-    }
-    const invite = new Invite(view, this.vendor, this.onAccept);
-    this.invites.set(view.id, invite);
-    this.trackSession(view.sessionId, view.id);
-    this.cachedList = null;
-    this.bus.emit("invite.added", { invite });
-  }
-  onRemove(inviteId) {
-    const existing = this.invites.get(inviteId);
-    if (!existing) {
-      return;
-    }
-    this.invites.delete(inviteId);
-    this.untrackSession(existing.sessionId, inviteId);
-    this.cachedList = null;
-    this.bus.emit("invite.removed", { inviteId });
-    existing.dispose();
-  }
-  dropBySession(sessionId) {
-    const ids = this.sessionIndex.get(sessionId);
-    if (!ids) {
-      return;
-    }
-    for (const inviteId of ids) {
-      this.onRemove(inviteId);
-    }
-  }
-  trackSession(sessionId, inviteId) {
-    let set = this.sessionIndex.get(sessionId);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.sessionIndex.set(sessionId, set);
-    }
-    set.add(inviteId);
-  }
-  untrackSession(sessionId, inviteId) {
-    const set = this.sessionIndex.get(sessionId);
-    if (!set) {
-      return;
-    }
-    set.delete(inviteId);
-    if (set.size === 0) {
-      this.sessionIndex.delete(sessionId);
-    }
-  }
-  async dispose() {
-    if (this.disposed) {
-      return;
-    }
-    this.disposed = true;
-    for (const unsub of this.unsubs) {
-      unsub();
-    }
-    for (const invite of this.invites.values()) {
-      invite.dispose();
-    }
-    this.invites.clear();
-    this.sessionIndex.clear();
-    this.bus.clear();
-  }
-};
-
-// src/core/presence.ts
-function presenceFromItem(item) {
-  return {
-    id: item.id,
-    availability: nullify(item.availability),
-    connectivity: nullify(item.connectivity),
-    lastSeenAt: nullify(item.lastSeenAt)
-  };
-}
-
-// src/core/managers/presence-manager.ts
-var PresenceManager = class {
-  vendor;
-  bus = new EventBus();
-  disposed = false;
-  constructor(opts) {
-    this.vendor = opts.vendor;
-  }
-  on(type, handler) {
-    return this.bus.on(type, handler);
-  }
-  async get(refs) {
-    if (this.disposed) {
-      return err(callpadError.disposed());
-    }
-    if (refs.length === 0) {
-      return ok(/* @__PURE__ */ new Map());
-    }
-    const byKind = /* @__PURE__ */ new Map();
-    for (const ref of refs) {
-      const list = byKind.get(ref.kind) ?? [];
-      list.push(ref.id);
-      byKind.set(ref.kind, list);
-    }
-    const responses = await Promise.all(
-      Array.from(byKind.entries()).map(
-        ([kind, ids]) => apiCall(
-          () => getApiV1VendorsBySlugPresence({
-            path: { slug: this.vendor },
-            query: { type: kind, ids: ids.join(",") }
-          })
-        )
-      )
-    );
-    const result = /* @__PURE__ */ new Map();
-    for (const res of responses) {
-      if (!res.ok) {
-        return res;
-      }
-      for (const item of res.value.items) {
-        const snapshot = presenceFromItem(item);
-        result.set(snapshot.id, snapshot);
-        this.bus.emit("presence.updated", { snapshot });
-      }
-    }
-    return ok(result);
-  }
-  async setMyStatus(mode, note) {
-    if (this.disposed) {
-      return err(callpadError.disposed());
-    }
-    const res = await apiCall(
-      () => putApiV1VendorsBySlugPresenceStatus({
-        path: { slug: this.vendor },
-        body: { status: mode, note: note ?? void 0 }
-      })
-    );
-    if (!res.ok) {
-      return res;
-    }
-    return ok(void 0);
-  }
-  async clearMyStatus() {
-    if (this.disposed) {
-      return err(callpadError.disposed());
-    }
-    const res = await apiCall(
-      () => deleteApiV1VendorsBySlugPresenceStatus({
-        path: { slug: this.vendor }
-      })
-    );
-    if (!res.ok) {
-      return res;
-    }
-    return ok(void 0);
-  }
-  async dispose() {
-    this.disposed = true;
-    this.bus.clear();
-  }
-};
-
-// src/core/plugin.ts
-var PluginHost = class {
-  handles = [];
-  async register(plugin, ctx) {
-    const handle = await plugin.install(ctx);
-    this.handles.push(handle);
-  }
-  async disposeAll() {
-    while (this.handles.length > 0) {
-      const h = this.handles.pop();
-      if (h) {
-        try {
-          await h.dispose();
-        } catch {
-        }
-      }
-    }
-  }
-};
-
-// src/core/client.ts
-var CallpadClient = class {
-  config;
-  logger;
-  bus = new EventBus();
-  pluginHost = new PluginHost();
-  sessionCommands = /* @__PURE__ */ new Map();
-  pulseTransport = null;
-  sessions = null;
-  invites = null;
-  presence = null;
-  responseInterceptorId = null;
-  status = "idle";
-  disposed = false;
-  constructor(config) {
-    this.config = config;
-    this.logger = (config.logger ?? noopLogger).child({
-      component: "callpad-client"
-    });
-    this.registerSessionCommand(holdCommand);
-    this.registerSessionCommand(unholdCommand);
-    this.registerSessionCommand(cancelCommand);
-    this.registerSessionCommand(endCommand);
-    this.registerSessionCommand(leaveCommand);
-    this.registerSessionCommand(inviteCommand);
-    this.registerSessionCommand(removeParticipantCommand);
-    this.registerSessionCommand(updateNameCommand);
-    this.registerSessionCommand(startRecordingCommand);
-    this.registerSessionCommand(stopRecordingCommand);
-  }
-  registerSessionCommand(cmd) {
-    this.sessionCommands.set(
-      cmd.name,
-      cmd
-    );
-  }
-  getStatus() {
-    return this.status;
-  }
-  getSessions() {
-    if (!this.sessions) {
-      throw new Error(
-        "CallpadClient: sessions not initialized; call connect() first"
-      );
-    }
-    return this.sessions;
-  }
-  getInvites() {
-    if (!this.invites) {
-      throw new Error(
-        "CallpadClient: invites not initialized; call connect() first"
-      );
-    }
-    return this.invites;
-  }
-  getPresence() {
-    if (!this.presence) {
-      throw new Error(
-        "CallpadClient: presence not initialized; call connect() first"
-      );
-    }
-    return this.presence;
-  }
-  on(type, handler) {
-    return this.bus.on(type, handler);
-  }
-  async connect() {
-    if (this.disposed) {
-      return err(callpadError.disposed());
-    }
-    if (this.status === "ready" || this.status === "connecting") {
-      return ok(void 0);
-    }
-    this.setStatus("connecting");
-    this.configureApiClient();
-    const pulse = new PulseTransport({
-      grantFetcher: () => this.fetchPulseGrant(),
-      logger: this.logger
-    });
-    this.pulseTransport = pulse;
-    const sessions = new SessionManager({
-      vendor: this.config.vendor,
-      logger: this.logger,
-      pulse,
-      selfParticipantId: null,
-      commands: this.sessionCommands
-    });
-    const invites = new InviteManager({
-      vendor: this.config.vendor,
-      pulse,
-      onAccept: async ({ session: view, joinGrant }) => {
-        const session = sessions.onAcceptedInvite(view);
-        return session.joinWithGrant(joinGrant);
-      }
-    });
-    const presence = new PresenceManager({
-      vendor: this.config.vendor
-    });
-    sessions.on("session.added", ({ session }) => {
-      this.bus.emit("session.added", { session });
-    });
-    sessions.on("session.removed", ({ sessionId }) => {
-      this.bus.emit("session.removed", { sessionId });
-    });
-    invites.on("invite.added", ({ invite }) => {
-      this.bus.emit("invite.added", { inviteId: invite.id });
-    });
-    invites.on("invite.removed", ({ inviteId }) => {
-      this.bus.emit("invite.removed", { inviteId });
-    });
-    pulse.on("status.changed", ({ status }) => {
-      if (status === "recovering") {
-        this.setStatus("degraded");
-      } else if (status === "connected") {
-        this.setStatus("ready");
-      } else if (status === "disconnected") {
-        this.setStatus("offline");
-      }
-    });
-    this.sessions = sessions;
-    this.invites = invites;
-    this.presence = presence;
-    const [connectPulse, sessionsPrime, invitesPrime] = await Promise.all([
-      pulse.connect(),
-      sessions.prime(),
-      invites.prime()
-    ]);
-    if (!connectPulse.ok) {
-      this.setStatus("offline");
-      this.bus.emit("error", { error: connectPulse.error });
-      return connectPulse;
-    }
-    for (const r of [sessionsPrime, invitesPrime]) {
-      if (!r.ok) {
-        this.logger.warn({ code: r.error.code }, "prime failed");
-      }
-    }
-    this.setStatus("ready");
-    return ok(void 0);
-  }
-  async dispose() {
-    if (this.disposed) {
-      return;
-    }
-    this.disposed = true;
-    if (this.responseInterceptorId !== null) {
-      client.interceptors.response.eject(this.responseInterceptorId);
-      this.responseInterceptorId = null;
-    }
-    await this.pluginHost.disposeAll();
-    await this.sessions?.dispose();
-    await this.invites?.dispose();
-    await this.presence?.dispose();
-    await this.pulseTransport?.dispose();
-    this.bus.clear();
-    this.setStatus("disposed");
-  }
-  async createSession(body) {
-    const manager = this.sessions;
-    if (!manager) {
-      return err(
-        callpadError.precondition(
-          "callpad.not_connected",
-          "Client not connected"
-        )
-      );
-    }
-    return manager.create(body);
-  }
-  async use(plugin) {
-    const pulse = this.pulseTransport;
-    const sessions = this.sessions;
-    const invites = this.invites;
-    const presence = this.presence;
-    if (!pulse || !sessions || !invites || !presence) {
-      return err(
-        callpadError.precondition(
-          "callpad.not_connected",
-          "Plugins require connect() first"
-        )
-      );
-    }
-    const ctx = {
-      logger: this.logger.child({ plugin: plugin.name }),
-      pulse,
-      sessions,
-      invites,
-      presence,
-      registerSessionCommand: (cmd) => this.registerSessionCommand(cmd),
-      onSessionCreated: (handler) => this.bus.on("session.added", ({ session }) => handler(session)),
-      onSessionDisposed: (handler) => this.bus.on("session.removed", ({ sessionId }) => handler(sessionId))
-    };
-    try {
-      await this.pluginHost.register(plugin, ctx);
-      return ok(void 0);
-    } catch (cause) {
-      return err(
-        callpadError.internal(
-          "callpad.plugin_install_failed",
-          `Plugin "${plugin.name}" failed to install`,
-          { cause: cause instanceof Error ? cause : void 0 }
-        )
-      );
-    }
-  }
-  configureApiClient() {
-    const baseUrl = this.config.apiBaseUrl;
-    const auth = this.config.auth.getAccessToken;
-    const retryingFetch = makeRetryingFetch((request) => fetch(request), {
-      maxAttempts: 3,
-      initialDelayMs: 300
-    });
-    client.setConfig({
-      baseUrl,
-      auth: async () => auth(),
-      fetch: retryingFetch
-    });
-    if (this.responseInterceptorId !== null) {
-      client.interceptors.response.eject(this.responseInterceptorId);
-    }
-    let unauthorizedFired = false;
-    this.responseInterceptorId = client.interceptors.response.use(
-      (response) => {
-        if (response.status === 401) {
-          if (!unauthorizedFired) {
-            unauthorizedFired = true;
-            this.config.auth.onUnauthorized?.();
-          }
-        } else if (unauthorizedFired) {
-          unauthorizedFired = false;
-        }
-        return response;
-      }
-    );
-  }
-  async fetchPulseGrant() {
-    return apiCall(
-      () => getApiV1PulseGrants({
-        query: { vendor: this.config.vendor }
-      })
-    );
-  }
-  setStatus(next) {
-    if (next === this.status) {
-      return;
-    }
-    const previous = this.status;
-    this.status = next;
-    this.bus.emit("status.changed", { status: next, previous });
-  }
-};
-function createCallpadClient(config) {
-  return new CallpadClient(config);
-}
+// src/react/index.tsx
 var CallpadContext = createContext(null);
-CallpadContext.displayName = "CallpadContext";
-function useCallpadContext() {
-  const ctx = useContext(CallpadContext);
-  if (ctx === null) {
-    throw new Error("useCallpad must be used inside <CallpadProvider>");
-  }
-  return ctx;
-}
-function useExternalStore(subscribe, getSnapshot, getServerSnapshot) {
-  return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-}
-
-// src/react/internal/use-client-store.ts
-function useClientStore(events, read, fallback) {
-  const { client: client2 } = useCallpadContext();
-  return useExternalStore(
-    (cb) => {
-      const unsubs = [client2.on("status.changed", cb)];
-      for (const event of events) {
-        unsubs.push(client2.on(event, cb));
-      }
-      return () => {
-        for (const u of unsubs) {
-          u();
-        }
-      };
-    },
-    () => {
-      const status = client2.getStatus();
-      if (status === "idle" || status === "connecting") {
-        return fallback;
-      }
-      return read(client2);
-    },
-    () => fallback
-  );
-}
-function CallpadProvider({
-  config,
-  children,
-  audioRenderer
-}) {
-  const clientRef = useRef(null);
-  if (clientRef.current === null) {
-    clientRef.current = createCallpadClient(config);
-  }
-  const client2 = clientRef.current;
-  const [status, setStatus] = useState(client2.getStatus());
-  const placeholderRoomRef = useRef(null);
-  if (placeholderRoomRef.current === null) {
-    placeholderRoomRef.current = new Room();
-  }
-  const [activeRoom, setActiveRoom] = useState(null);
-  const contextRoom = activeRoom ?? placeholderRoomRef.current;
-  useEffect(() => {
-    const placeholder = placeholderRoomRef.current;
-    return () => {
-      if (placeholder) {
-        void placeholder.disconnect();
-      }
-    };
-  }, []);
-  useEffect(() => {
-    void client2.connect();
-    const unsubStatus = client2.on("status.changed", ({ status: next }) => {
-      setStatus(next);
-    });
-    return () => {
-      unsubStatus();
-      void client2.dispose();
-    };
-  }, [client2]);
+var CallpadProvider = ({
+  client,
+  connect = false,
+  disposeOnUnmount = false,
+  children
+}) => {
   useEffect(() => {
-    if (status !== "ready" && status !== "degraded") {
-      setActiveRoom(null);
+    if (!connect) {
       return;
     }
-    const updateRoom = () => {
-      const active = client2.getSessions().active();
-      setActiveRoom(active?.mediaRoom ?? null);
-    };
-    updateRoom();
-    const unsubs = [];
-    unsubs.push(client2.on("session.added", updateRoom));
-    unsubs.push(client2.on("session.removed", updateRoom));
+    void client.connect().catch(() => void 0);
     return () => {
-      for (const u of unsubs) {
-        u();
+      if (disposeOnUnmount) {
+        void client.dispose();
+        return;
       }
+      void client.disconnect();
     };
-  }, [client2, status]);
-  const value = useMemo(() => ({ client: client2, status }), [client2, status]);
-  return /* @__PURE__ */ jsx(CallpadContext.Provider, { value, children: /* @__PURE__ */ jsxs(RoomContext.Provider, { value: contextRoom, children: [
-    activeRoom ? audioRenderer ?? /* @__PURE__ */ jsx(RoomAudioRenderer, {}) : null,
-    children
-  ] }) });
-}
-
-// src/react/hooks/useCallpadClient.ts
-function useCallpadClient() {
-  const ctx = useCallpadContext();
-  return { client: ctx.client, status: ctx.status };
-}
-function useClientEvent(event, handler) {
-  const { client: client2 } = useCallpadContext();
-  const handlerRef = useRef(handler);
-  handlerRef.current = handler;
-  useEffect(() => {
-    return client2.on(event, (payload) => {
-      handlerRef.current(payload);
-    });
-  }, [client2, event]);
-}
-
-// src/react/hooks/useSession.ts
-var EVENTS = ["session.added", "session.removed"];
-function useSessions() {
-  return useClientStore(EVENTS, (c) => c.getSessions().list(), []);
-}
-function useSession(sessionId) {
-  return useClientStore(
-    EVENTS,
-    (c) => sessionId === void 0 ? c.getSessions().active() : c.getSessions().get(sessionId),
-    null
+  }, [client, connect, disposeOnUnmount]);
+  return /* @__PURE__ */ jsx(CallpadContext.Provider, { value: client, children });
+};
+var useCallpad = () => {
+  const client = useContext(CallpadContext);
+  if (!client) {
+    throw new Error("CallpadProvider is required");
+  }
+  return client;
+};
+var useStatus = () => {
+  const client = useCallpad();
+  return useSyncExternalStore(
+    (notify) => client.subscribe("status", notify),
+    () => client.status,
+    () => "idle"
   );
-}
-function useSessionEvent(event, handler, sessionId) {
-  const session = useSession(sessionId);
-  const handlerRef = useRef(handler);
-  handlerRef.current = handler;
-  useEffect(() => {
-    if (!session) {
-      return;
-    }
-    return session.on(event, (payload) => {
-      handlerRef.current(payload);
-    });
-  }, [session, event]);
-}
-
-// src/react/hooks/useIncomingInvite.ts
-function useIncomingInvites() {
-  return useClientStore(
-    ["invite.added", "invite.removed"],
-    (client2) => client2.getInvites().list(),
-    []
+};
+var useSessions = () => {
+  const client = useCallpad();
+  return useSyncExternalStore(
+    (notify) => client.subscribe("sessions", notify),
+    () => client.sessions.list(),
+    () => []
+  );
+};
+var useSession = (sessionId) => {
+  const client = useCallpad();
+  return useSyncExternalStore(
+    (notify) => client.subscribe(sessionId ? `session:${sessionId}` : "sessions", notify),
+    () => client.sessions.get(sessionId),
+    () => null
+  );
+};
+var useIncomingInvites = () => {
+  const client = useCallpad();
+  return useSyncExternalStore(
+    (notify) => client.subscribe("invites", notify),
+    () => client.invites.list(),
+    () => []
   );
-}
-function useIncomingInvite() {
+};
+var useIncomingInvite = () => {
   const invites = useIncomingInvites();
   return invites[0] ?? null;
-}
-function formatSeconds(total) {
-  const minutes = Math.floor(total / 60);
-  const seconds = total % 60;
-  return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
-}
-function useCallDuration(sessionId) {
-  const session = useSession(sessionId);
-  const startIso = session?.viewSnapshot.activatedAt ?? null;
-  const [elapsed, setElapsed] = useState(0);
-  useEffect(() => {
-    if (startIso === null || startIso === void 0 || startIso === "") {
-      setElapsed(0);
-      return;
-    }
-    const startedAt = Date.parse(startIso);
-    if (Number.isNaN(startedAt)) {
-      setElapsed(0);
-      return;
-    }
-    const tick = () => {
-      setElapsed(Math.max(0, Math.floor((Date.now() - startedAt) / 1e3)));
-    };
-    tick();
-    const handle = setInterval(tick, 1e3);
-    return () => clearInterval(handle);
-  }, [startIso]);
-  return { formatted: formatSeconds(elapsed), elapsedSeconds: elapsed };
-}
-
-// src/react/hooks/useIsHeld.ts
-function useIsHeld(sessionId) {
-  const session = useSession(sessionId);
-  return session?.state === "on_hold";
-}
-
-// src/react/hooks/useActiveRecording.ts
-function useActiveRecording(sessionId) {
-  const session = useSession(sessionId);
-  return session?.activeRecording ?? null;
-}
-
-// src/react/hooks/useSessionParticipants.ts
-function useSessionParticipants(sessionId) {
-  const session = useSession(sessionId);
-  return session?.participants ?? [];
-}
-function useSessionParticipant(participantId, sessionId) {
-  const session = useSession(sessionId);
-  if (!session) {
-    return null;
-  }
-  return session.participants.find((p) => p.id === participantId) ?? null;
-}
-function useSelfParticipant(sessionId) {
+};
+var useCan = (sessionId, action) => {
+  const client = useCallpad();
   const session = useSession(sessionId);
   if (!session) {
-    return null;
+    return false;
   }
-  return session.participants.find((p) => p.isSelf) ?? null;
-}
-function useSessionCapabilities(sessionId) {
-  const self = useSelfParticipant(sessionId);
-  return useMemo(() => new Set(self?.capabilities ?? []), [self]);
-}
-
-// src/react/hooks/useSessionDispatches.ts
-function useSessionDispatches(sessionId) {
-  const session = useSession(sessionId);
-  return session?.dispatches ?? [];
-}
-async function noop() {
-  return Promise.resolve();
-}
-function noopControls() {
-  return {
-    mic: { muted: true, toggle: noop, setMuted: noop },
-    camera: { enabled: false, toggle: noop },
-    screenShare: { active: false, toggle: noop },
-    hold: { active: false, enabled: false, toggle: noop },
-    recording: { active: false, enabled: false, toggle: noop },
-    leave: { enabled: false, run: noop },
-    end: { enabled: false, run: noop }
-  };
-}
-function makeControls(input) {
-  const { session, capabilities, isHeld, activeRecordingId, local, setters } = input;
-  const canHold = capabilities.has("hold_session");
-  const canStartRecording = capabilities.has("start_recording");
-  const canStopRecording = capabilities.has("stop_recording");
-  const recordingActive = activeRecordingId !== null;
-  const recordingEnabled = recordingActive ? canStopRecording : canStartRecording;
-  const canEnd = capabilities.has("end_session");
-  return {
-    mic: {
-      muted: !local.isMicrophoneEnabled,
-      setMuted: async (v) => {
-        await setters.setMic(!v);
-      },
-      toggle: async () => {
-        await setters.setMic(!local.isMicrophoneEnabled);
-      }
-    },
-    camera: {
-      enabled: local.isCameraEnabled,
-      toggle: async () => {
-        await setters.setCamera(!local.isCameraEnabled);
-      }
-    },
-    screenShare: {
-      active: local.isScreenShareEnabled,
-      toggle: async () => {
-        await setters.setScreenShare(!local.isScreenShareEnabled);
-      }
-    },
-    hold: {
-      active: isHeld,
-      enabled: canHold,
-      toggle: async () => {
-        if (!canHold) {
-          return;
-        }
-        if (isHeld) {
-          await session.unhold();
-        } else {
-          await session.hold();
-        }
-      }
-    },
-    recording: {
-      active: recordingActive,
-      enabled: recordingEnabled,
-      toggle: async () => {
-        if (recordingActive) {
-          if (!canStopRecording) {
-            return;
-          }
-          await session.stopRecording(activeRecordingId);
-        } else {
-          if (!canStartRecording) {
-            return;
-          }
-          await session.startRecording();
-        }
-      }
-    },
-    leave: {
-      enabled: true,
-      run: async () => {
-        await session.leave();
-      }
-    },
-    end: {
-      enabled: canEnd,
-      run: async () => {
-        if (!canEnd) {
-          return;
-        }
-        await session.end();
-      }
-    }
-  };
-}
-function useCallControls(sessionId) {
+  return client.sessions.can(session, action);
+};
+var useSessionDuration = (sessionId) => {
   const session = useSession(sessionId);
-  const capabilities = useSessionCapabilities(sessionId);
-  const isHeld = useIsHeld(sessionId);
-  const activeRecording = useActiveRecording(sessionId);
-  const {
-    localParticipant,
-    isMicrophoneEnabled,
-    isCameraEnabled,
-    isScreenShareEnabled
-  } = useLocalParticipant();
-  const setMic = useCallback(
-    async (v) => {
-      await localParticipant?.setMicrophoneEnabled(v);
-    },
-    [localParticipant]
-  );
-  const setCamera = useCallback(
-    async (v) => {
-      await localParticipant?.setCameraEnabled(v);
-    },
-    [localParticipant]
-  );
-  const setScreenShare = useCallback(
-    async (v) => {
-      await localParticipant?.setScreenShareEnabled(v);
-    },
-    [localParticipant]
-  );
-  if (!session) {
-    return noopControls();
-  }
-  return makeControls({
-    session,
-    capabilities,
-    isHeld,
-    activeRecordingId: activeRecording?.id ?? null,
-    local: {
-      isMicrophoneEnabled: isMicrophoneEnabled ?? false,
-      isCameraEnabled: isCameraEnabled ?? false,
-      isScreenShareEnabled: isScreenShareEnabled ?? false
-    },
-    setters: { setMic, setCamera, setScreenShare }
-  });
-}
-function usePresence(refs) {
-  const { client: client2 } = useCallpadContext();
-  const [snapshots, setSnapshots] = useState(/* @__PURE__ */ new Map());
-  const refsRef = useRef(refs);
-  refsRef.current = refs;
-  const key = refs.map((r) => `${r.kind}:${r.id}`).sort().join("|");
+  const [now, setNow] = useState(() => Date.now());
   useEffect(() => {
-    const current = refsRef.current;
-    if (current.length === 0) {
-      setSnapshots(/* @__PURE__ */ new Map());
+    if (!session || session.state === "ended") {
       return;
     }
-    let cancelled = false;
-    void client2.getPresence().get(current).then((res) => {
-      if (!cancelled && res.ok) {
-        setSnapshots(res.value);
-      }
-    });
-    const unsub = client2.getPresence().on("presence.updated", ({ snapshot }) => {
-      setSnapshots((prev) => {
-        const next = new Map(prev);
-        next.set(snapshot.id, snapshot);
-        return next;
-      });
-    });
+    setNow(Date.now());
+    const timer = window.setInterval(() => {
+      setNow(Date.now());
+    }, 1e3);
     return () => {
-      cancelled = true;
-      unsub();
+      window.clearInterval(timer);
     };
-  }, [client2, key]);
-  return snapshots;
-}
-function useMyPresence() {
-  const { client: client2 } = useCallpadContext();
-  const setStatus = useCallback(
-    async (mode, note) => {
-      await client2.getPresence().setMyStatus(mode, note);
-    },
-    [client2]
-  );
-  const clearStatus = useCallback(async () => {
-    await client2.getPresence().clearMyStatus();
-  }, [client2]);
-  return { snapshot: null, setStatus, clearStatus };
-}
+  }, [session]);
+  return durationOf(session, now);
+};
+var durationOf = (session, now) => {
+  if (!session) {
+    return { seconds: 0, startedAt: null, endedAt: null, running: false };
+  }
+  const startedAt = session.answeredAt ?? session.createdAt;
+  const endedAt = session.endedAt;
+  const end = endedAt ? Date.parse(endedAt) : now;
+  return {
+    seconds: Math.max(0, Math.floor((end - Date.parse(startedAt)) / 1e3)),
+    startedAt,
+    endedAt,
+    running: !endedAt && session.state !== "ended"
+  };
+};
 
-export { CallpadProvider, useActiveRecording, useCallControls, useCallDuration, useCallpadClient, useClientEvent, useIncomingInvite, useIncomingInvites, useIsHeld, useMyPresence, usePresence, useSelfParticipant, useSession, useSessionCapabilities, useSessionDispatches, useSessionEvent, useSessionParticipant, useSessionParticipants, useSessions };
+export { CallpadProvider, useCallpad, useCan, useIncomingInvite, useIncomingInvites, useSession, useSessionDuration, useSessions, useStatus };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map