farvex 0.1.0 → 0.2.0

package/dist/mock/index.cjs

@@ -0,0 +1,3267 @@
+'use strict';
+
+var socket_ioClient = require('socket.io-client');
+var livekitClient = require('livekit-client');
+
+// 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/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/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 = socket_ioClient.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 livekitClient.ConnectionQuality.Excellent:
+      return "excellent";
+    case livekitClient.ConnectionQuality.Good:
+      return "good";
+    case livekitClient.ConnectionQuality.Poor:
+      return "poor";
+    case livekitClient.ConnectionQuality.Lost:
+      return "lost";
+    default:
+      return "unknown";
+  }
+}
+function snapshotOf(p) {
+  const micPub = p.getTrackPublication(livekitClient.Track.Source.Microphone);
+  const camPub = p.getTrackPublication(livekitClient.Track.Source.Camera);
+  const screenPub = p.getTrackPublication(livekitClient.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 livekitClient.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(livekitClient.RoomEvent.ConnectionStateChanged, (state) => {
+      switch (state) {
+        case livekitClient.ConnectionState.Connected:
+          this.setState("connected");
+          break;
+        case livekitClient.ConnectionState.Connecting:
+          this.setState("connecting");
+          break;
+        case livekitClient.ConnectionState.Reconnecting:
+          this.setState("reconnecting");
+          break;
+        case livekitClient.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(
+      livekitClient.RoomEvent.ParticipantConnected,
+      (p) => refresh(p)
+    );
+    this.room.on(livekitClient.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(livekitClient.RoomEvent.TrackSubscribed, (_track, _pub, p) => refresh(p));
+    this.room.on(livekitClient.RoomEvent.TrackUnsubscribed, (_track, _pub, p) => refresh(p));
+    this.room.on(livekitClient.RoomEvent.TrackMuted, (_pub, p) => refresh(p));
+    this.room.on(livekitClient.RoomEvent.TrackUnmuted, (_pub, p) => refresh(p));
+    this.room.on(
+      livekitClient.RoomEvent.LocalTrackPublished,
+      (_pub, p) => refresh(p)
+    );
+    this.room.on(
+      livekitClient.RoomEvent.LocalTrackUnpublished,
+      (_pub, p) => refresh(p)
+    );
+    this.room.on(
+      livekitClient.RoomEvent.ConnectionQualityChanged,
+      (_q, p) => refresh(p)
+    );
+    this.room.on(livekitClient.RoomEvent.ActiveSpeakersChanged, (speakers) => {
+      const identities = speakers.map((p) => p.identity);
+      this.bus.emit("active_speakers.changed", { identities });
+    });
+    this.room.on(livekitClient.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/mock/mock-fetch.ts
+function keyOf(method, path) {
+  return `${method.toUpperCase()} ${path}`;
+}
+function makeMockFetch() {
+  const routes = /* @__PURE__ */ new Map();
+  const fn = async (request) => {
+    const url = new URL(request.url);
+    const key = keyOf(request.method, url.pathname);
+    const stub = routes.get(key);
+    if (!stub) {
+      return new Response(
+        JSON.stringify({
+          error: {
+            code: "mock.not_stubbed",
+            title: "Not stubbed",
+            kind: "notfound",
+            retryable: false
+          }
+        }),
+        {
+          status: 404,
+          headers: { "content-type": "application/json" }
+        }
+      );
+    }
+    return new Response(JSON.stringify(stub.body), {
+      status: stub.status,
+      headers: { "content-type": "application/json" }
+    });
+  };
+  fn.stub = (method, path, body, status = 200) => {
+    routes.set(keyOf(method, path), { status, body });
+  };
+  fn.reset = () => {
+    routes.clear();
+  };
+  return fn;
+}
+
+// src/mock/scenarios.ts
+var EMPTY_GRANT = {
+  url: "wss://pulse.mock",
+  path: "/pulse/socket.io",
+  namespace: "/",
+  token: "mock-token",
+  expiresAt: new Date(Date.now() + 15 * 6e4).toISOString()
+};
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function makeSessionPage(items) {
+  return { items, nextCursor: "" };
+}
+function baseSession(partial) {
+  const ts = now();
+  const base = {
+    id: "ses_mock",
+    callId: "call_mock",
+    vendorId: 1,
+    version: 1,
+    name: "",
+    direction: "outbound",
+    channel: "webrtc",
+    mediaType: "audio",
+    state: "active",
+    room: { name: "mock-room", sid: "" },
+    hostAgentId: "",
+    createdAt: ts,
+    activatedAt: ts,
+    endedAt: "",
+    endReason: "completed",
+    route: {
+      sourceKind: "direct",
+      teamId: "",
+      queueId: "",
+      ivrPath: []
+    },
+    participants: [],
+    dispatches: [],
+    recordings: [],
+    ...partial
+  };
+  return base;
+}
+function webrtcAgent(id, agentId, state) {
+  const ts = now();
+  return {
+    id,
+    ref: { kind: "agent", agentId },
+    info: {
+      kind: "agent",
+      agentId,
+      userId: 1e3,
+      firstName: "",
+      lastName: "",
+      avatarUrl: "",
+      phoneNumber: ""
+    },
+    role: "host",
+    capabilities: [
+      "hold_session",
+      "end_session",
+      "start_recording",
+      "stop_recording",
+      "invite_participant",
+      "remove_participant",
+      "update_session"
+    ],
+    transport: "webrtc",
+    state,
+    participantIdentity: `agent:${agentId}`,
+    participantSid: "",
+    lastSignalAt: "",
+    invitedAt: ts,
+    acceptedAt: state === "invited" ? "" : ts,
+    joinedAt: state === "joined" ? ts : "",
+    endedAt: "",
+    leftReason: "left",
+    failureReason: "unknown",
+    operations: []
+  };
+}
+function phoneParticipant(id, phone, legState) {
+  const ts = now();
+  return {
+    id,
+    ref: { kind: "phone", phoneNumber: phone },
+    info: {
+      kind: "phone",
+      phoneNumber: phone,
+      firstName: "",
+      lastName: "",
+      avatarUrl: ""
+    },
+    role: "participant",
+    capabilities: [],
+    transport: "sip",
+    state: legState === "active" ? "joined" : "invited",
+    participantIdentity: `phone:${phone}`,
+    participantSid: "",
+    lastSignalAt: "",
+    invitedAt: ts,
+    acceptedAt: "",
+    joinedAt: legState === "active" ? ts : "",
+    endedAt: "",
+    leftReason: "left",
+    failureReason: "unknown",
+    operations: [
+      {
+        id: `leg_${id}`,
+        kind: "sip_leg",
+        state: legState,
+        direction: "outbound",
+        createdAt: ts,
+        ringingAt: legState === "ringing" || legState === "active" ? ts : "",
+        activeAt: legState === "active" ? ts : "",
+        endedAt: "",
+        localPhoneNumber: "+10000000000",
+        remotePhoneNumber: phone,
+        provider: {
+          livekitSipCallId: "",
+          providerSipCallId: "",
+          livekitSipTrunkId: "",
+          livekitDispatchRuleId: "",
+          vendorPhoneNumberId: "",
+          sipExtension: ""
+        },
+        failureReason: "unknown",
+        sipStatusCode: 0,
+        providerError: ""
+      }
+    ]
+  };
+}
+var idleScenario = {
+  name: "idle",
+  sessions: makeSessionPage([]),
+  invites: [],
+  pulseGrant: EMPTY_GRANT
+};
+var activeSession = baseSession({
+  id: "ses_active",
+  state: "active",
+  participants: [webrtcAgent("p_self", "agent_self", "joined")]
+});
+var activeCallScenario = {
+  name: "activeAudioCall",
+  sessions: makeSessionPage([activeSession]),
+  invites: [],
+  pulseGrant: EMPTY_GRANT
+};
+var recordingSession = baseSession({
+  id: "ses_recording",
+  state: "active",
+  participants: [webrtcAgent("p_self", "agent_self", "joined")],
+  recordings: [
+    {
+      id: "rec_1",
+      target: { kind: "session" },
+      policy: "manual",
+      state: "active",
+      livekitEgressId: "eg_1",
+      requestedAt: now(),
+      startedAt: now(),
+      stoppedAt: "",
+      failureReason: ""
+    }
+  ]
+});
+var recordingScenario = {
+  name: "activeWithRecording",
+  sessions: makeSessionPage([recordingSession]),
+  invites: [],
+  pulseGrant: EMPTY_GRANT
+};
+var heldSession = baseSession({
+  id: "ses_held",
+  state: "on_hold",
+  participants: [webrtcAgent("p_self", "agent_self", "joined")]
+});
+var heldScenario = {
+  name: "held",
+  sessions: makeSessionPage([heldSession]),
+  invites: [],
+  pulseGrant: EMPTY_GRANT
+};
+var dispatchSession = baseSession({
+  id: "ses_dispatch",
+  state: "ringing",
+  route: {
+    sourceKind: "queue",
+    teamId: "",
+    queueId: "queue_1",
+    ivrPath: []
+  },
+  participants: [
+    webrtcAgent("p_a", "agent_a", "invited"),
+    webrtcAgent("p_b", "agent_b", "invited"),
+    webrtcAgent("p_c", "agent_c", "invited")
+  ],
+  dispatches: [
+    {
+      id: "disp_1",
+      kind: "ring_group",
+      source: { kind: "queue", queueId: "queue_1" },
+      strategy: "parallel",
+      state: "active",
+      candidateParticipantIds: ["p_a", "p_b", "p_c"],
+      winnerParticipantId: "",
+      startedAt: now(),
+      resolvedAt: "",
+      timeoutAt: new Date(Date.now() + 6e4).toISOString()
+    }
+  ]
+});
+var ringGroupDispatchScenario = {
+  name: "ringGroupDispatch",
+  sessions: makeSessionPage([dispatchSession]),
+  invites: [],
+  pulseGrant: EMPTY_GRANT
+};
+var dispatchResolvedSession = baseSession({
+  id: "ses_dispatch_resolved",
+  state: "active",
+  participants: [
+    webrtcAgent("p_a", "agent_a", "joined"),
+    { ...webrtcAgent("p_b", "agent_b", "invited"), state: "withdrawn" },
+    { ...webrtcAgent("p_c", "agent_c", "invited"), state: "withdrawn" }
+  ],
+  dispatches: [
+    {
+      id: "disp_1",
+      kind: "ring_group",
+      source: { kind: "queue", queueId: "queue_1" },
+      strategy: "parallel",
+      state: "resolved",
+      candidateParticipantIds: ["p_a", "p_b", "p_c"],
+      winnerParticipantId: "p_a",
+      startedAt: now(),
+      resolvedAt: now(),
+      timeoutAt: ""
+    }
+  ]
+});
+var dispatchResolvedScenario = {
+  name: "dispatchResolved",
+  sessions: makeSessionPage([dispatchResolvedSession]),
+  invites: [],
+  pulseGrant: EMPTY_GRANT
+};
+var sipLegSession = baseSession({
+  id: "ses_sip",
+  channel: "mixed",
+  state: "active",
+  participants: [
+    webrtcAgent("p_self", "agent_self", "joined"),
+    phoneParticipant("p_phone", "+15551234567", "active")
+  ]
+});
+var sipLegConnectedScenario = {
+  name: "sipLegConnected",
+  sessions: makeSessionPage([sipLegSession]),
+  invites: [],
+  pulseGrant: EMPTY_GRANT
+};
+var incomingInviteSession = baseSession({
+  id: "ses_ringing",
+  state: "ringing",
+  direction: "inbound",
+  participants: [
+    phoneParticipant("p_caller", "+15551234567", "ringing"),
+    webrtcAgent("p_me", "agent_me", "invited")
+  ]
+});
+var incomingInviteView = {
+  id: "inv_1",
+  sessionId: incomingInviteSession.id,
+  callId: incomingInviteSession.callId,
+  state: "pending",
+  createdAt: now(),
+  expiresAt: new Date(Date.now() + 3e4).toISOString(),
+  completedAt: "",
+  dispatchId: "",
+  recipient: {
+    kind: "agent",
+    vendorId: 1,
+    agentId: "agent_me",
+    userId: 1e3
+  },
+  participantId: "p_me",
+  inviterParticipantId: "p_caller",
+  session: incomingInviteSession
+};
+var incomingInviteScenario = {
+  name: "incomingInvite",
+  sessions: makeSessionPage([incomingInviteSession]),
+  invites: [incomingInviteView],
+  pulseGrant: EMPTY_GRANT
+};
+var SCENARIOS = {
+  idle: idleScenario,
+  incomingInvite: incomingInviteScenario,
+  outboundDialing: idleScenario,
+  activeAudioCall: activeCallScenario,
+  activeWithRecording: recordingScenario,
+  ringGroupDispatch: ringGroupDispatchScenario,
+  dispatchResolved: dispatchResolvedScenario,
+  sipLegConnected: sipLegConnectedScenario,
+  held: heldScenario,
+  ended: idleScenario
+};
+
+// src/mock/mock-client.ts
+var BASE_CONFIG = {
+  apiBaseUrl: "http://mock.local",
+  vendor: "mock-vendor",
+  auth: {
+    getAccessToken: async () => "mock-access-token"
+  }
+};
+function createMockCallpadClient(opts = {}) {
+  const scenario = opts.scenario ?? "idle";
+  const data = SCENARIOS[scenario];
+  const fakeFetch = makeMockFetch();
+  fakeFetch.stub("GET", "/api/v1/sessions", data.sessions);
+  fakeFetch.stub("GET", "/api/v1/sessions/invites", data.invites);
+  fakeFetch.stub("GET", "/api/v1/pulse/grants", data.pulseGrant);
+  client.setConfig({ baseUrl: BASE_CONFIG.apiBaseUrl, fetch: fakeFetch });
+  const client2 = createCallpadClient({ ...BASE_CONFIG, ...opts.config });
+  return { client: client2, fetch: fakeFetch, scenario };
+}
+
+exports.SCENARIOS = SCENARIOS;
+exports.createMockCallpadClient = createMockCallpadClient;
+exports.makeMockFetch = makeMockFetch;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map