farvex 0.2.0 → 1.0.1

package/dist/index.js

@@ -1,114 +1,138 @@
-import { io } from 'socket.io-client';
-import { Room, RoomEvent, ConnectionState, Track, ConnectionQuality } from 'livekit-client';
+import { Centrifuge, UnauthorizedError } from 'centrifuge';
 
-// 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/api/generated/core/bodySerializer.gen.ts
+var jsonBodySerializer = {
+  bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : 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
+// src/api/generated/core/serverSentEvents.gen.ts
+function createSseClient({
+  onRequest,
+  onSseError,
+  onSseEvent,
+  responseTransformer,
+  responseValidator,
+  sseDefaultRetryDelay,
+  sseMaxRetryAttempts,
+  sseMaxRetryDelay,
+  sseSleepFn,
+  url,
+  ...options
+}) {
+  let lastEventId;
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const createStream = async function* () {
+    let retryDelay = sseDefaultRetryDelay ?? 3e3;
+    let attempt = 0;
+    const signal = options.signal ?? new AbortController().signal;
+    while (true) {
+      if (signal.aborted) break;
+      attempt++;
+      const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+      if (lastEventId !== void 0) {
+        headers.set("Last-Event-ID", lastEventId);
+      }
+      try {
+        const requestInit = {
+          redirect: "follow",
+          ...options,
+          body: options.serializedBody,
+          headers,
+          signal
+        };
+        let request = new Request(url, requestInit);
+        if (onRequest) {
+          request = await onRequest(url, requestInit);
         }
-      );
-    }
-    return make(
-      "internal",
-      false,
-      "callpad.unknown",
-      context ?? "Unknown error",
-      {
-        detail: typeof cause === "string" ? cause : void 0
+        const _fetch = options.fetch ?? globalThis.fetch;
+        const response = await _fetch(request);
+        if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+        if (!response.body) throw new Error("No body in SSE response");
+        const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+        let buffer = "";
+        const abortHandler = () => {
+          try {
+            reader.cancel();
+          } catch {
+          }
+        };
+        signal.addEventListener("abort", abortHandler);
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += value;
+            buffer = buffer.replace(/\r\n?/g, "\n");
+            const chunks = buffer.split("\n\n");
+            buffer = chunks.pop() ?? "";
+            for (const chunk of chunks) {
+              const lines = chunk.split("\n");
+              const dataLines = [];
+              let eventName;
+              for (const line of lines) {
+                if (line.startsWith("data:")) {
+                  dataLines.push(line.replace(/^data:\s*/, ""));
+                } else if (line.startsWith("event:")) {
+                  eventName = line.replace(/^event:\s*/, "");
+                } else if (line.startsWith("id:")) {
+                  lastEventId = line.replace(/^id:\s*/, "");
+                } else if (line.startsWith("retry:")) {
+                  const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+                  if (!Number.isNaN(parsed)) {
+                    retryDelay = parsed;
+                  }
+                }
+              }
+              let data;
+              let parsedJson = false;
+              if (dataLines.length) {
+                const rawData = dataLines.join("\n");
+                try {
+                  data = JSON.parse(rawData);
+                  parsedJson = true;
+                } catch {
+                  data = rawData;
+                }
+              }
+              if (parsedJson) {
+                if (responseValidator) {
+                  await responseValidator(data);
+                }
+                if (responseTransformer) {
+                  data = await responseTransformer(data);
+                }
+              }
+              onSseEvent?.({
+                data,
+                event: eventName,
+                id: lastEventId,
+                retry: retryDelay
+              });
+              if (dataLines.length) {
+                yield data;
+              }
+            }
+          }
+        } finally {
+          signal.removeEventListener("abort", abortHandler);
+          reader.releaseLock();
+        }
+        break;
+      } catch (error) {
+        onSseError?.(error);
+        if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) {
+          break;
+        }
+        const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4);
+        await sleep(backoff);
       }
-    );
-  }
-};
-
-// src/shared/result.ts
-function ok(value) {
-  return { ok: true, value };
-}
-function err(error) {
-  return { ok: false, error };
-}
-function isOk(r) {
-  return r.ok;
-}
-function isErr(r) {
-  return !r.ok;
+    }
+  };
+  const stream = createStream();
+  return { stream };
 }
 
-// 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
+// src/api/generated/core/pathSerializer.gen.ts
 var separatorArrayExplode = (style) => {
   switch (style) {
     case "label":
@@ -207,11 +231,7 @@ var serializeObjectParam = ({
   if (style !== "deepObject" && !explode) {
     let values = [];
     Object.entries(value).forEach(([key, v]) => {
-      values = [
-        ...values,
-        key,
-        allowReserved ? v : encodeURIComponent(v)
-      ];
+      values = [...values, key, allowReserved ? v : encodeURIComponent(v)];
     });
     const joinedValues2 = values.join(",");
     switch (style) {
@@ -236,7 +256,7 @@ var serializeObjectParam = ({
   return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
 };
 
-// src/api/generated/client/utils.ts
+// src/api/generated/core/utils.gen.ts
 var PATH_PARAM_RE = /\{[^{}]+\}/g;
 var defaultPathSerializer = ({ path, url: _url }) => {
   let url = _url;
@@ -262,10 +282,7 @@ var defaultPathSerializer = ({ path, url: _url }) => {
         continue;
       }
       if (Array.isArray(value)) {
-        url = url.replace(
-          match,
-          serializeArrayParam({ explode, name, style, value })
-        );
+        url = url.replace(match, serializeArrayParam({ explode, name, style, value }));
         continue;
       }
       if (typeof value === "object") {
@@ -299,10 +316,62 @@ var defaultPathSerializer = ({ path, url: _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;
+};
+function getValidRequestBody(options) {
+  const hasBody = options.body !== void 0;
+  const isSerializedBody = hasBody && options.bodySerializer;
+  if (isSerializedBody) {
+    if ("serializedBody" in options) {
+      const hasSerializedBody = options.serializedBody !== void 0 && options.serializedBody !== "";
+      return hasSerializedBody ? options.serializedBody : null;
+    }
+    return options.body !== "" ? options.body : null;
+  }
+  if (hasBody) {
+    return options.body;
+  }
+  return void 0;
+}
+
+// src/api/generated/core/auth.gen.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/client/utils.gen.ts
 var createQuerySerializer = ({
-  allowReserved,
-  array,
-  object
+  parameters = {},
+  ...args
 } = {}) => {
   const querySerializer = (queryParams) => {
     const search = [];
@@ -312,29 +381,30 @@ var createQuerySerializer = ({
         if (value === void 0 || value === null) {
           continue;
         }
+        const options = parameters[name] || args;
         if (Array.isArray(value)) {
           const serializedArray = serializeArrayParam({
-            allowReserved,
+            allowReserved: options.allowReserved,
             explode: true,
             name,
             style: "form",
             value,
-            ...array
+            ...options.array
           });
           if (serializedArray) search.push(serializedArray);
         } else if (typeof value === "object") {
           const serializedObject = serializeObjectParam({
-            allowReserved,
+            allowReserved: options.allowReserved,
             explode: true,
             name,
             style: "deepObject",
             value,
-            ...object
+            ...options.object
           });
           if (serializedObject) search.push(serializedObject);
         } else {
           const serializedPrimitive = serializePrimitiveParam({
-            allowReserved,
+            allowReserved: options.allowReserved,
             name,
             value
           });
@@ -360,20 +430,28 @@ var getParseAs = (contentType) => {
   if (cleanContent === "multipart/form-data") {
     return "formData";
   }
-  if (["application/", "audio/", "image/", "video/"].some(
-    (type) => cleanContent.startsWith(type)
-  )) {
+  if (["application/", "audio/", "image/", "video/"].some((type) => cleanContent.startsWith(type))) {
     return "blob";
   }
   if (cleanContent.startsWith("text/")) {
     return "text";
   }
+  return;
 };
-var setAuthParams = async ({
-  security,
-  ...options
-}) => {
-  for (const auth of security) {
+var checkForExistence = (options, name) => {
+  if (!name) {
+    return false;
+  }
+  if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) {
+    return true;
+  }
+  return false;
+};
+async function setAuthParams(options) {
+  for (const auth of options.security ?? []) {
+    if (checkForExistence(options, auth.name)) {
+      continue;
+    }
     const token = await getAuthToken(auth, options.auth);
     if (!token) {
       continue;
@@ -394,40 +472,15 @@ var setAuthParams = async ({
         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 buildUrl = (options) => getUrl({
+  baseUrl: options.baseUrl,
+  path: options.path,
+  query: options.query,
+  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+  url: options.url
+});
 var mergeConfigs = (a, b) => {
   const config = { ...a, ...b };
   if (config.baseUrl?.endsWith("/")) {
@@ -436,13 +489,20 @@ var mergeConfigs = (a, b) => {
   config.headers = mergeHeaders(a.headers, b.headers);
   return config;
 };
+var headersEntries = (headers) => {
+  const entries = [];
+  headers.forEach((value, key) => {
+    entries.push([key, value]);
+  });
+  return entries;
+};
 var mergeHeaders = (...headers) => {
   const mergedHeaders = new Headers();
   for (const header of headers) {
-    if (!header || typeof header !== "object") {
+    if (!header) {
       continue;
     }
-    const iterator = header instanceof Headers ? header.entries() : Object.entries(header);
+    const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
     for (const [key, value] of iterator) {
       if (value === null) {
         mergedHeaders.delete(key);
@@ -461,42 +521,37 @@ var mergeHeaders = (...headers) => {
   return mergedHeaders;
 };
 var Interceptors = class {
-  _fns;
-  constructor() {
-    this._fns = [];
-  }
+  fns = [];
   clear() {
-    this._fns = [];
+    this.fns = [];
   }
-  getInterceptorIndex(id) {
-    if (typeof id === "number") {
-      return this._fns[id] ? id : -1;
-    } else {
-      return this._fns.indexOf(id);
+  eject(id) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = null;
     }
   }
   exists(id) {
     const index = this.getInterceptorIndex(id);
-    return !!this._fns[index];
+    return Boolean(this.fns[index]);
   }
-  eject(id) {
-    const index = this.getInterceptorIndex(id);
-    if (this._fns[index]) {
-      this._fns[index] = null;
+  getInterceptorIndex(id) {
+    if (typeof id === "number") {
+      return this.fns[id] ? id : -1;
     }
+    return this.fns.indexOf(id);
   }
   update(id, fn) {
     const index = this.getInterceptorIndex(id);
-    if (this._fns[index]) {
-      this._fns[index] = fn;
+    if (this.fns[index]) {
+      this.fns[index] = fn;
       return id;
-    } else {
-      return false;
     }
+    return false;
   }
   use(fn) {
-    this._fns = [...this._fns, fn];
-    return this._fns.length - 1;
+    this.fns.push(fn);
+    return this.fns.length - 1;
   }
 };
 var createInterceptors = () => ({
@@ -526,7 +581,7 @@ var createConfig = (override = {}) => ({
   ...override
 });
 
-// src/api/generated/client/client.ts
+// src/api/generated/client/client.gen.ts
 var createClient = (config = {}) => {
   let _config = mergeConfigs(createConfig(), config);
   const getConfig = () => ({ ..._config });
@@ -535,2362 +590,886 @@ var createClient = (config = {}) => {
     return getConfig();
   };
   const interceptors = createInterceptors();
-  const request = async (options) => {
+  const beforeRequest = async (options) => {
     const opts = {
       ..._config,
       ...options,
       fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
-      headers: mergeHeaders(_config.headers, options.headers)
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: void 0
     };
     if (opts.security) {
-      await setAuthParams({
-        ...opts,
-        security: opts.security
-      });
+      await setAuthParams(opts);
+    }
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
     }
-    if (opts.body && opts.bodySerializer) {
-      opts.body = opts.bodySerializer(opts.body);
+    if (opts.body !== void 0 && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
     }
-    if (opts.body === void 0 || opts.body === "") {
+    if (opts.body === void 0 || opts.serializedBody === "") {
       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 resolvedOpts = opts;
+    const url = buildUrl(resolvedOpts);
+    return { opts: resolvedOpts, url };
+  };
+  const request = async (options) => {
+    const throwOnError = options.throwOnError ?? _config.throwOnError;
+    const responseStyle = options.responseStyle ?? _config.responseStyle;
+    let request2;
+    let response;
+    try {
+      const { opts, url } = await beforeRequest(options);
+      const requestInit = {
+        redirect: "follow",
+        ...opts,
+        body: getValidRequestBody(opts)
+      };
+      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 _fetch = opts.fetch;
+      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: {},
+      const result = {
+        request: request2,
+        response
+      };
+      if (response.ok) {
+        const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+        if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+          let emptyData;
+          switch (parseAs) {
+            case "arrayBuffer":
+            case "blob":
+            case "text":
+              emptyData = await response[parseAs]();
+              break;
+            case "formData":
+              emptyData = new FormData();
+              break;
+            case "stream":
+              emptyData = response.body;
+              break;
+            case "json":
+            default:
+              emptyData = {};
+              break;
+          }
+          return opts.responseStyle === "data" ? emptyData : {
+            data: emptyData,
+            ...result
+          };
+        }
+        let data;
+        switch (parseAs) {
+          case "arrayBuffer":
+          case "blob":
+          case "formData":
+          case "text":
+            data = await response[parseAs]();
+            break;
+          case "json": {
+            const text = await response.text();
+            data = text ? JSON.parse(text) : {};
+            break;
+          }
+          case "stream":
+            return opts.responseStyle === "data" ? response.body : {
+              data: response.body,
+              ...result
+            };
+        }
+        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
         };
       }
-      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
-        };
+      const textError = await response.text();
+      let jsonError;
+      try {
+        jsonError = JSON.parse(textError);
+      } catch {
       }
-      let data = await response[parseAs]();
-      if (parseAs === "json") {
-        if (opts.responseValidator) {
-          await opts.responseValidator(data);
-        }
-        if (opts.responseTransformer) {
-          data = await opts.responseTransformer(data);
+      throw jsonError ?? textError;
+    } catch (error) {
+      let finalError = error;
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError = await fn(finalError, response, request2, options);
         }
       }
-      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 (throwOnError) {
+        throw finalError;
       }
+      return responseStyle === "data" ? void 0 : {
+        error: finalError,
+        request: request2,
+        response
+      };
     }
-    finalError = finalError || {};
-    if (opts.throwOnError) {
-      throw finalError;
-    }
-    return opts.responseStyle === "data" ? void 0 : {
-      error: finalError,
-      ...result
-    };
   };
+  const makeMethodFn = (method) => (options) => request({ ...options, method });
+  const makeSseFn = (method) => async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    return createSseClient({
+      ...opts,
+      body: opts.body,
+      method,
+      onRequest: async (url2, init) => {
+        let request2 = new Request(url2, init);
+        for (const fn of interceptors.request.fns) {
+          if (fn) {
+            request2 = await fn(request2, opts);
+          }
+        }
+        return request2;
+      },
+      serializedBody: getValidRequestBody(opts),
+      url
+    });
+  };
+  const _buildUrl = (options) => buildUrl({ ..._config, ...options });
   return {
-    buildUrl,
-    connect: (options) => request({ ...options, method: "CONNECT" }),
-    delete: (options) => request({ ...options, method: "DELETE" }),
-    get: (options) => request({ ...options, method: "GET" }),
+    buildUrl: _buildUrl,
+    connect: makeMethodFn("CONNECT"),
+    delete: makeMethodFn("DELETE"),
+    get: makeMethodFn("GET"),
     getConfig,
-    head: (options) => request({ ...options, method: "HEAD" }),
+    head: makeMethodFn("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" }),
+    options: makeMethodFn("OPTIONS"),
+    patch: makeMethodFn("PATCH"),
+    post: makeMethodFn("POST"),
+    put: makeMethodFn("PUT"),
     request,
     setConfig,
-    trace: (options) => request({ ...options, method: "TRACE" })
+    sse: {
+      connect: makeSseFn("CONNECT"),
+      delete: makeSseFn("DELETE"),
+      get: makeSseFn("GET"),
+      head: makeSseFn("HEAD"),
+      options: makeSseFn("OPTIONS"),
+      patch: makeSseFn("PATCH"),
+      post: makeSseFn("POST"),
+      put: makeSseFn("PUT"),
+      trace: makeSseFn("TRACE")
+    },
+    trace: makeMethodFn("TRACE")
   };
 };
 
-// src/api/client-config.ts
-var createClientConfig = (base) => ({
-  ...base,
-  throwOnError: false
-});
+// src/api/client.ts
+var CallpadError = class extends Error {
+  constructor(code, message, status) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "CallpadError";
+  }
+  code;
+  status;
+};
+var apiClient = (config) => {
+  const client2 = createClient({
+    baseUrl: config.apiUrl,
+    fetch: config.fetch
+  });
+  client2.interceptors.request.use(async (request) => {
+    const token = await config.auth.getAccessToken();
+    request.headers.set("Authorization", `Bearer ${token}`);
+    return request;
+  });
+  return client2;
+};
+var unwrap = async (result, auth) => {
+  const response = await result;
+  if (response.error !== void 0) {
+    if (response.response?.status === 401) {
+      await auth?.onUnauthorized?.();
+    }
+    throw errorFrom(response.error, response.response?.status);
+  }
+  if (response.data === void 0) {
+    throw new CallpadError("empty_response", "API response did not include data");
+  }
+  return response.data;
+};
+var errorFrom = (error, status) => {
+  if (isProblem(error)) {
+    return new CallpadError(error.code, error.message, status);
+  }
+  if (error instanceof Error) {
+    return new CallpadError("request_failed", error.message, status);
+  }
+  if (typeof error === "string" && error.length > 0) {
+    return new CallpadError("request_failed", error, status);
+  }
+  return new CallpadError("request_failed", "Request failed", status);
+};
+var isProblem = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const problem = value;
+  return typeof problem.code === "string" && typeof problem.message === "string";
+};
 
 // src/api/generated/client.gen.ts
-var client = createClient(createClientConfig(createConfig({
-  baseUrl: "http://localhost:3002"
-})));
+var client = createClient(createConfig());
 
-// src/api/map-error.ts
-function isBackendErrorBody(body) {
-  if (body === null || typeof body !== "object") {
-    return false;
+// src/api/generated/sdk.gen.ts
+var getRealtimeToken = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api/v1/realtime/token",
+  ...options
+});
+var listSessions = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api/v1/sessions",
+  ...options
+});
+var createSessionToken = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api/v1/sessions/{sessionId}/tokens",
+  ...options
+});
+var leaveSession = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api/v1/sessions/{sessionId}/leave",
+  ...options
+});
+var endSession = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api/v1/sessions/{sessionId}/end",
+  ...options
+});
+var startRecording = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api/v1/sessions/{sessionId}/recording/start",
+  ...options
+});
+var stopRecording = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api/v1/sessions/{sessionId}/recording/stop",
+  ...options
+});
+var addSessionParticipant = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api/v1/sessions/{sessionId}/participants",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
   }
-  const maybe = body;
-  if (maybe.error === null || typeof maybe.error !== "object") {
-    return false;
+});
+var removeSessionParticipant = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api/v1/sessions/{sessionId}/participants/{participantId}",
+  ...options
+});
+var acceptSessionParticipant = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api/v1/sessions/{sessionId}/participants/{participantId}/accept",
+  ...options
+});
+var rejectSessionParticipant = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api/v1/sessions/{sessionId}/participants/{participantId}/reject",
+  ...options
+});
+var createSession = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api/v1/vendors/{vendor}/sessions",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
   }
-  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"
+});
+
+// src/core/events.ts
+var createEmitter = () => {
+  const listeners = /* @__PURE__ */ new Map();
+  const emit = (event, payload) => {
+    const fns = listeners.get(event);
+    if (!fns) {
+      return;
+    }
+    for (const fn of fns) {
+      try {
+        fn(payload);
+      } catch (err) {
+        if (event !== "error") {
+          emit("error", err instanceof Error ? err : new Error("Event listener failed"));
+        }
+      }
+    }
+  };
+  return {
+    on: (event, fn) => {
+      let fns = listeners.get(event);
+      if (!fns) {
+        fns = /* @__PURE__ */ new Set();
+        listeners.set(event, fns);
+      }
+      fns.add(fn);
+      return () => {
+        fns?.delete(fn);
+        if (fns?.size === 0) {
+          listeners.delete(event);
+        }
+      };
+    },
+    emit
+  };
 };
-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 });
+var createRealtime = (client2, auth, store, emitter) => {
+  let rt = null;
+  let disposed = false;
+  const fetchToken = async () => unwrap(getRealtimeToken({ client: client2 }), auth);
+  const refreshToken = async () => {
+    try {
+      const token = await fetchToken();
+      return token.token;
+    } catch (err) {
+      if (err instanceof CallpadError && (err.status === 401 || err.status === 403)) {
+        throw new UnauthorizedError(err.message);
+      }
+      throw err;
     }
-    if (status === 403) {
-      return callpadError.forbidden("callpad.forbidden", "Forbidden", {
-        status
-      });
+  };
+  const applyMessage = (message) => {
+    if (message.event === "session.upsert") {
+      const change = store.upsert(message.data);
+      if (change === "added") {
+        emitter.emit("session.added", message.data);
+      }
+      if (change === "updated") {
+        emitter.emit("session.updated", message.data);
+      }
+      return;
     }
-    if (status === 404) {
-      return callpadError.notfound("callpad.not_found", "Not found", {
-        status
+    if (store.remove(message.data)) {
+      emitter.emit("session.removed", {
+        sessionId: message.data.id,
+        vendor: message.data.vendor,
+        version: message.data.version
       });
     }
-    if (status >= 500) {
-      return callpadError.internal(
-        "callpad.internal",
-        "Internal server error",
-        { status }
-      );
+  };
+  const setStatus = (status) => {
+    store.setStatus(status);
+    emitter.emit("status", status);
+  };
+  const disconnect = async () => {
+    rt?.disconnect();
+    rt = null;
+    if (!disposed) {
+      setStatus("offline");
     }
-    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 {
+    connect: async () => {
+      if (rt) {
+        return;
       }
+      disposed = false;
+      setStatus("connecting");
+      try {
+        const first = await fetchToken();
+        rt = new Centrifuge(first.url, {
+          token: first.token,
+          getToken: refreshToken
+        });
+        rt.on("connecting", () => {
+          const next = store.getStatus() === "ready" ? "reconnecting" : "connecting";
+          setStatus(next);
+        });
+        rt.on("connected", () => {
+          setStatus("ready");
+        });
+        rt.on("disconnected", () => {
+          if (!disposed) {
+            setStatus("offline");
+          }
+        });
+        rt.on("error", (ctx) => {
+          emitter.emit("error", new Error(ctx.error.message));
+        });
+        rt.on("publication", (ctx) => {
+          try {
+            const message = parseMessage(ctx.data);
+            if (message) {
+              applyMessage(message);
+            }
+          } catch (err) {
+            emitter.emit("error", err instanceof Error ? err : new Error("Realtime event failed"));
+          }
+        });
+        rt.connect();
+        await rt.ready();
+      } catch (err) {
+        await disconnect();
+        throw err;
+      }
+    },
+    disconnect,
+    dispose: async () => {
+      disposed = true;
+      rt?.disconnect();
+      rt = null;
+      setStatus("disposed");
     }
+  };
+};
+var parseMessage = (value) => {
+  if (!value || typeof value !== "object") {
     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();
+  const message = value;
+  if (message.event === "session.upsert" && message.data) {
+    return message;
   }
-  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();
+  if (message.event === "session.remove" && message.data) {
+    return message;
   }
+  return null;
 };
 
-// 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;
+// src/core/store.ts
+var createSessionStore = (userId) => {
+  const sessions = /* @__PURE__ */ new Map();
+  const subscribers = /* @__PURE__ */ new Map();
+  let status = "idle";
+  let activeId = null;
+  let listCache = [];
+  let invitesCache = [];
+  let inviteKey = "";
+  let inviteExpiryTimer = null;
+  const emit = (topic) => {
+    const fns = subscribers.get(topic);
+    if (!fns) {
+      return;
     }
-    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());
+    for (const fn of fns) {
+      fn();
     }
-    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 subscribe = (topic, fn) => {
+    let fns = subscribers.get(topic);
+    if (!fns) {
+      fns = /* @__PURE__ */ new Set();
+      subscribers.set(topic, fns);
     }
-    const res = await apiCall(
-      () => getApiV1SessionsInvites({ query: { vendor: this.vendor } })
+    fns.add(fn);
+    return () => {
+      fns?.delete(fn);
+      if (fns?.size === 0) {
+        subscribers.delete(topic);
+      }
+    };
+  };
+  const refresh = () => {
+    listCache = Array.from(sessions.values()).sort(
+      (a, b) => b.createdAt.localeCompare(a.createdAt)
     );
-    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;
+    if (activeId) {
+      const active = sessions.get(activeId);
+      if (!active || active.state === "ended") {
+        activeId = null;
       }
-      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);
+    if (!activeId) {
+      activeId = listCache.find((session) => session.state !== "ended")?.id ?? null;
     }
-  }
-  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;
+  };
+  const refreshInvites = () => {
+    const now = Date.now();
+    const invites = listCache.map((session) => inviteFrom(session, userId, now)).filter((invite) => invite !== null);
+    scheduleInviteExpiry(invites, now);
+    const nextKey = invites.map(
+      (invite) => `${invite.session.id}:${invite.participant.id}:${invite.participant.state}:${invite.participant.inviteExpiresAt ?? ""}`
+    ).join("|");
+    if (nextKey === inviteKey) {
+      invitesCache = invites;
+      return false;
     }
-    set.delete(inviteId);
-    if (set.size === 0) {
-      this.sessionIndex.delete(sessionId);
+    inviteKey = nextKey;
+    invitesCache = invites;
+    return true;
+  };
+  const clearInviteExpiryTimer = () => {
+    if (inviteExpiryTimer) {
+      globalThis.clearTimeout(inviteExpiryTimer);
+      inviteExpiryTimer = null;
     }
-  }
-  async dispose() {
-    if (this.disposed) {
+  };
+  const scheduleInviteExpiry = (invites, now) => {
+    clearInviteExpiryTimer();
+    const nextExpiry = invites.reduce((min, invite) => {
+      const expiresAt = inviteExpiryMs(invite.participant);
+      if (expiresAt === null) {
+        return min;
+      }
+      return min === null ? expiresAt : Math.min(min, expiresAt);
+    }, null);
+    if (nextExpiry === null) {
       return;
     }
-    this.disposed = true;
-    for (const unsub of this.unsubs) {
-      unsub();
-    }
-    for (const invite of this.invites.values()) {
-      invite.dispose();
+    inviteExpiryTimer = globalThis.setTimeout(
+      () => {
+        inviteExpiryTimer = null;
+        if (refreshInvites()) {
+          emit("invites");
+        }
+      },
+      Math.max(0, nextExpiry - now)
+    );
+  };
+  const notifySessionChange = (sessionId) => {
+    refresh();
+    const invitesChanged = refreshInvites();
+    emit(`session:${sessionId}`);
+    emit("sessions");
+    if (invitesChanged) {
+      emit("invites");
     }
-    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());
+  const get = (sessionId) => {
+    if (sessionId) {
+      return sessions.get(sessionId) ?? null;
     }
-    if (refs.length === 0) {
-      return ok(/* @__PURE__ */ new Map());
+    if (!activeId) {
+      return null;
     }
-    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);
+    return sessions.get(activeId) ?? null;
+  };
+  const upsert = (session, mode = "event") => {
+    const prev = sessions.get(session.id);
+    const stale = prev ? mode === "command" ? session.version < prev.version : session.version <= prev.version : false;
+    if (stale) {
+      return null;
     }
-    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;
+    sessions.set(session.id, session);
+    notifySessionChange(session.id);
+    return prev ? "updated" : "added";
+  };
+  return {
+    getStatus: () => status,
+    setStatus: (next) => {
+      if (status === next) {
+        return;
       }
-      for (const item of res.value.items) {
-        const snapshot = presenceFromItem(item);
-        result.set(snapshot.id, snapshot);
-        this.bus.emit("presence.updated", { snapshot });
+      status = next;
+      emit("status");
+    },
+    list: () => listCache,
+    get,
+    invites: () => invitesCache,
+    invite: (sessionId) => invitesCache.find((invite) => invite.session.id === sessionId) ?? null,
+    sync: (items) => {
+      for (const session of items) {
+        const prev = sessions.get(session.id);
+        if (!prev || session.version >= prev.version) {
+          sessions.set(session.id, session);
+        }
       }
-    }
-    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();
+      refresh();
+      const invitesChanged = refreshInvites();
+      emit("sessions");
+      for (const session of items) {
+        emit(`session:${session.id}`);
+      }
+      if (invitesChanged) {
+        emit("invites");
+      }
+    },
+    upsert,
+    remove: (payload) => {
+      const prev = sessions.get(payload.id);
+      if (!prev) {
+        return false;
+      }
+      if (payload.version !== void 0 && payload.version < prev.version) {
+        return false;
+      }
+      sessions.delete(payload.id);
+      notifySessionChange(payload.id);
+      return true;
+    },
+    patchRecording: (control) => {
+      const prev = sessions.get(control.sessionId);
+      if (!prev || control.sessionVersion < prev.version) {
+        return null;
+      }
+      const next = {
+        ...prev,
+        version: Math.max(prev.version, control.sessionVersion),
+        recording: control.recording
+      };
+      sessions.set(next.id, next);
+      notifySessionChange(next.id);
+      return next;
+    },
+    can: (session, action) => can(session, userId, action),
+    dispose: () => {
+      clearInviteExpiryTimer();
+      subscribers.clear();
+    },
+    subscribe
+  };
+};
+var selfParticipant = (session, userId) => session.participants.find((participant) => participant.userId === userId) ?? null;
+var inviteFrom = (session, userId, now) => {
+  const participant = selfParticipant(session, userId);
+  if (!participant || session.state === "ended" || !isActiveInvite(participant, now)) {
+    return null;
   }
+  return { session, participant };
 };
-
-// src/core/plugin.ts
-var PluginHost = class {
-  handles = [];
-  async register(plugin, ctx) {
-    const handle = await plugin.install(ctx);
-    this.handles.push(handle);
+var can = (session, userId, action) => {
+  const self = selfParticipant(session, userId);
+  if (!self || session.state === "ended") {
+    return false;
   }
-  async disposeAll() {
-    while (this.handles.length > 0) {
-      const h = this.handles.pop();
-      if (h) {
-        try {
-          await h.dispose();
-        } catch {
-        }
-      }
-    }
+  switch (action) {
+    case "accept":
+    case "reject":
+      return isActiveInvite(self);
+    case "join":
+      return self.transport === "webrtc" && (self.state === "accepted" || self.state === "joined");
+    case "leave":
+      return self.state === "accepted" || self.state === "joined";
+    case "end":
+    case "addParticipant":
+    case "removeParticipant":
+      return isHost(self) && (self.state === "accepted" || self.state === "joined");
+    case "startRecording":
+      return isHost(self) && session.state === "active" && session.recording.status === "off";
+    case "stopRecording":
+      return isHost(self) && session.recording.status === "recording";
+  }
+};
+var isActiveInvite = (participant, now = Date.now()) => {
+  const expiresAt = inviteExpiryMs(participant);
+  return participant.state === "invited" && expiresAt !== null && expiresAt > now;
+};
+var inviteExpiryMs = (participant) => {
+  if (!participant.inviteExpiresAt) {
+    return null;
   }
+  const expiresAt = Date.parse(participant.inviteExpiresAt);
+  return Number.isFinite(expiresAt) ? expiresAt : null;
 };
+var isHost = (participant) => participant.role === "host" && (participant.kind === "agent" || participant.kind === "vendor_user");
 
 // 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;
+var createSessionClient = (config) => {
+  const core = createCore(config);
+  return {
+    kind: "session",
+    get status() {
+      return core.store.getStatus();
+    },
+    sessions: {
+      ...createCommonSessions(core),
+      start: (input) => startSession(core, input.vendor, input.target)
+    },
+    invites: {
+      list: core.store.invites,
+      get: core.store.invite
+    },
+    connect: core.connect,
+    disconnect: core.realtime.disconnect,
+    dispose: core.dispose,
+    on: core.emitter.on,
+    subscribe: core.store.subscribe
+  };
+};
+var createHostClient = (config) => {
+  const core = createCore(config);
+  return {
+    kind: "host",
+    vendor: config.vendor,
+    get status() {
+      return core.store.getStatus();
+    },
+    sessions: {
+      ...createCommonSessions(core),
+      start: (input) => startSession(core, config.vendor, input.target)
+    },
+    invites: {
+      list: core.store.invites,
+      get: core.store.invite
+    },
+    host: createHostControls(core),
+    connect: core.connect,
+    disconnect: core.realtime.disconnect,
+    dispose: core.dispose,
+    on: core.emitter.on,
+    subscribe: core.store.subscribe
+  };
+};
+var createCore = (config) => {
+  const api = apiClient(config);
+  const store = createSessionStore(config.userId);
+  const emitter = createEmitter();
+  const realtime = createRealtime(api, config.auth, store, emitter);
+  const applySession = (session, mode = "event") => {
+    const change = store.upsert(session, mode);
+    if (change === "added") {
+      emitter.emit("session.added", session);
     }
-    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"
-        )
-      );
+    if (change === "updated") {
+      emitter.emit("session.updated", session);
     }
-    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"
-        )
-      );
+    return session;
+  };
+  const applyStarted = (started, mode = "event") => {
+    applySession(started.session, mode);
+    return started;
+  };
+  const patchRecording = (control) => {
+    const session = store.patchRecording(control);
+    if (session) {
+      emitter.emit("session.updated", session);
     }
-    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))
-    };
+    return control;
+  };
+  const connect = async () => {
     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);
+      await realtime.connect();
+    } catch (err) {
+      emitter.emit("error", err instanceof Error ? err : new Error("Connection failed"));
+      throw err;
     }
-    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;
+  };
+  const dispose = async () => {
+    await realtime.dispose();
+    store.dispose();
+  };
+  return {
+    api,
+    auth: config.auth,
+    store,
+    emitter,
+    realtime,
+    connect,
+    dispose,
+    applySession,
+    applyStarted,
+    patchRecording
+  };
+};
+var createCommonSessions = (core) => ({
+  list: core.store.list,
+  get: core.store.get,
+  sync: async (query) => {
+    const response = await unwrap(listSessions({ client: core.api, query }), core.auth);
+    core.store.sync(response.items);
+    return core.store.list();
+  },
+  join: (sessionId) => unwrap(createSessionToken({ client: core.api, path: { sessionId } }), core.auth),
+  accept: async (input) => core.applyStarted(
+    await unwrap(
+      acceptSessionParticipant({
+        client: core.api,
+        path: {
+          sessionId: input.sessionId,
+          participantId: input.participantId
         }
-        return response;
-      }
-    );
-  }
-  async fetchPulseGrant() {
-    return apiCall(
-      () => getApiV1PulseGrants({
-        query: { vendor: this.config.vendor }
-      })
-    );
-  }
-  setStatus(next) {
-    if (next === this.status) {
-      return;
+      }),
+      core.auth
+    ),
+    "command"
+  ),
+  reject: async (input) => core.applySession(
+    await unwrap(
+      rejectSessionParticipant({
+        client: core.api,
+        path: {
+          sessionId: input.sessionId,
+          participantId: input.participantId
+        }
+      }),
+      core.auth
+    ),
+    "command"
+  ),
+  leave: async (sessionId) => core.applySession(
+    await unwrap(leaveSession({ client: core.api, path: { sessionId } }), core.auth),
+    "command"
+  ),
+  can: core.store.can
+});
+var createHostControls = (core) => ({
+  end: async (sessionId) => {
+    await unwrap(endSession({ client: core.api, path: { sessionId } }), core.auth);
+    if (core.store.remove({ id: sessionId })) {
+      core.emitter.emit("session.removed", { sessionId });
     }
-    const previous = this.status;
-    this.status = next;
-    this.bus.emit("status.changed", { status: next, previous });
-  }
-};
-function createCallpadClient(config) {
-  return new CallpadClient(config);
-}
+  },
+  addParticipant: async (input) => core.applyStarted(
+    await unwrap(
+      addSessionParticipant({
+        client: core.api,
+        path: { sessionId: input.sessionId },
+        body: { target: input.target }
+      }),
+      core.auth
+    ),
+    "command"
+  ),
+  removeParticipant: async (input) => core.applySession(
+    await unwrap(
+      removeSessionParticipant({
+        client: core.api,
+        path: {
+          sessionId: input.sessionId,
+          participantId: input.participantId
+        }
+      }),
+      core.auth
+    ),
+    "command"
+  ),
+  startRecording: async (sessionId) => core.patchRecording(
+    await unwrap(startRecording({ client: core.api, path: { sessionId } }), core.auth)
+  ),
+  stopRecording: async (sessionId) => core.patchRecording(
+    await unwrap(stopRecording({ client: core.api, path: { sessionId } }), core.auth)
+  )
+});
+var startSession = async (core, vendor, target) => core.applyStarted(
+  await unwrap(
+    createSession({
+      client: core.api,
+      path: { vendor },
+      body: { target }
+    }),
+    core.auth
+  ),
+  "command"
+);
 
-export { CallpadClient, callpadError, createCallpadClient, err, isErr, isOk, noopLogger, ok };
+export { CallpadError, createHostClient, createSessionClient };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map