@byte_fluffy/nexra-sdk 0.1.0-alpha.50 → 0.1.0-alpha.53

package/dist/chunk-RBKLCJ3H.js

@@ -0,0 +1,745 @@
+import {
+  CatalogClient,
+  HttpTransport,
+  NexraApiError,
+  NexraTaskError,
+  NexraWaitTimeoutError,
+  applyMediaGeometry,
+  applyNoWatermark,
+  formatModelDisplayName,
+  getModelSpec,
+  jsonBody,
+  parseServerSentEvents,
+  queryString,
+  sleep
+} from "./chunk-LWJWWD7Z.js";
+import {
+  ASR_MAX_FRAME_BYTES,
+  ORGANIZATION_HEADER,
+  asrInputSecondsLimit,
+  createTaskRequest,
+  decodeVolcengineAsrFrame,
+  encodeVolcengineAsrFrame,
+  isTerminalTaskStatus,
+  volcengineAsrFrameJson
+} from "./chunk-V3F6VPMP.js";
+
+// src/assets.ts
+var AssetsClient = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async upload(file, options = {}) {
+    const name = options.name ?? (isFile(file) ? file.name : void 0);
+    const headers = new Headers({
+      "content-type": file.type || "application/octet-stream",
+      "x-nexra-asset-kind": options.kind ?? inferKind(file.type)
+    });
+    if (name) headers.set("x-nexra-file-name", encodeURIComponent(name));
+    return this.transport.json(
+      "/assets",
+      {
+        method: "POST",
+        body: file,
+        headers,
+        signal: options.signal
+      },
+      { retryable: false }
+    );
+  }
+  import(request, signal) {
+    return this.transport.json("/assets/import", {
+      method: "POST",
+      ...jsonBody(request),
+      signal
+    });
+  }
+  get(assetId, signal) {
+    return this.transport.json(`/assets/${encodeURIComponent(assetId)}`, {
+      signal
+    });
+  }
+  certifyForSeedance(asset, request = {}, signal) {
+    const assetId = typeof asset === "string" ? asset : asset.id;
+    return this.transport.json(
+      `/assets/${encodeURIComponent(assetId)}/certifications/seedance`,
+      {
+        method: "POST",
+        ...jsonBody(request),
+        signal
+      },
+      { retryable: false }
+    );
+  }
+  getSeedanceCertification(asset, signal) {
+    const assetId = typeof asset === "string" ? asset : asset.id;
+    return this.transport.json(
+      `/assets/${encodeURIComponent(assetId)}/certifications/seedance`,
+      { signal }
+    );
+  }
+  async waitForSeedanceCertification(asset, options = {}) {
+    const pollIntervalMs = positiveInteger(options.pollIntervalMs ?? 2e3, "pollIntervalMs");
+    const timeoutMs = positiveInteger(options.timeoutMs ?? 3e5, "timeoutMs");
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+      const certification = await this.getSeedanceCertification(asset, options.signal);
+      if (certification.status !== "processing") return certification;
+      if (Date.now() >= deadline) {
+        throw new Error("Timed out waiting for Seedance Asset certification");
+      }
+      await wait(Math.min(pollIntervalMs, Math.max(1, deadline - Date.now())), options.signal);
+    }
+  }
+  download(asset, signal) {
+    const assetId = typeof asset === "string" ? asset : asset.id;
+    return this.transport.response(`/assets/${encodeURIComponent(assetId)}/content`, {
+      signal
+    });
+  }
+  async stream(asset, signal) {
+    const response = await this.download(asset, signal);
+    if (!response.body) throw new Error("Asset response did not contain a body stream");
+    return response.body;
+  }
+};
+function positiveInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value < 1) throw new TypeError(`${name} must be a positive integer`);
+  return value;
+}
+async function wait(milliseconds, signal) {
+  if (signal?.aborted) throw signal.reason;
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, milliseconds);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    }, { once: true });
+  });
+}
+function inferKind(mimeType) {
+  if (mimeType.startsWith("image/")) return "image";
+  if (mimeType.startsWith("video/")) return "video";
+  if (mimeType.startsWith("audio/")) return "audio";
+  if (mimeType.startsWith("text/") || mimeType === "application/pdf") return "document";
+  if (mimeType.includes("zip") || mimeType.includes("tar")) return "archive";
+  return "other";
+}
+function isFile(value) {
+  return typeof File !== "undefined" && value instanceof File;
+}
+
+// src/models.ts
+function withModelDisplayName(model) {
+  return { ...model, displayName: formatModelDisplayName(model.displayName, model.slug ? { modelId: model.slug } : void 0) };
+}
+var ModelsClient = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async search(params = {}, signal) {
+    const page = await this.transport.json(
+      `/models${queryString({
+        q: params.query,
+        modality: params.modality,
+        operation: params.operation,
+        category: params.category,
+        limit: params.limit,
+        cursor: params.cursor
+      })}`,
+      { signal }
+    );
+    return { ...page, data: page.data.map(withModelDisplayName) };
+  }
+  async get(model, signal) {
+    const detail = await this.transport.json(`/models/${encodeURIComponent(model)}`, {
+      signal
+    });
+    return {
+      ...withModelDisplayName(detail),
+      ...detail.familyVersions ? { familyVersions: detail.familyVersions.map(withModelDisplayName) } : {}
+    };
+  }
+  schema(model, signal) {
+    return this.transport.json(
+      `/models/${encodeURIComponent(model)}/schema`,
+      { signal }
+    );
+  }
+  resources(model, resource, signal) {
+    return this.transport.json(
+      `/models/${encodeURIComponent(model)}/resources/${encodeURIComponent(resource)}`,
+      { signal }
+    );
+  }
+};
+
+// src/voices.ts
+var VoicesClient = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async list(signal) {
+    const response = await this.transport.json("/voices", { signal });
+    return response.data;
+  }
+  get(voiceId, signal) {
+    return this.transport.json(`/voices/${encodeURIComponent(voiceId)}`, { signal });
+  }
+  create(request, options) {
+    if (!options.idempotencyKey.trim()) throw new TypeError("Idempotency-Key is required");
+    return this.transport.json("/voices", {
+      method: "POST",
+      ...jsonBody(request),
+      headers: { "content-type": "application/json", "idempotency-key": options.idempotencyKey },
+      signal: options.signal
+    }, { retryable: true });
+  }
+};
+
+// src/input.ts
+async function normalizeTaskInput(input, assets, signal) {
+  const normalized = await normalizeValue(input, assets, signal, /* @__PURE__ */ new WeakSet());
+  if (!isPlainObject(normalized)) {
+    throw new TypeError("Task input must be a JSON object");
+  }
+  return normalized;
+}
+async function normalizeValue(value, assets, signal, ancestors) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError("Task input numbers must be finite");
+    return value;
+  }
+  if (value instanceof URL) return value.toString();
+  if (typeof Blob !== "undefined" && value instanceof Blob) {
+    const uploaded = await assets.upload(value, { signal });
+    return { assetId: uploaded.id };
+  }
+  if (isMediaAsset(value)) {
+    return { assetId: value.id };
+  }
+  if (isAssetReference(value)) return { assetId: value.assetId };
+  if (Array.isArray(value)) {
+    assertNotCircular(value, ancestors);
+    const normalized = await Promise.all(
+      value.map((item) => normalizeValue(item, assets, signal, ancestors))
+    );
+    ancestors.delete(value);
+    return normalized;
+  }
+  if (isPlainObject(value)) {
+    assertNotCircular(value, ancestors);
+    const normalized = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (item === void 0) continue;
+      normalized[key] = await normalizeValue(item, assets, signal, ancestors);
+    }
+    ancestors.delete(value);
+    return normalized;
+  }
+  throw new TypeError(`Task input contains a non-serializable ${typeof value} value`);
+}
+function assertNotCircular(value, ancestors) {
+  if (ancestors.has(value)) throw new TypeError("Task input cannot contain circular references");
+  ancestors.add(value);
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isAssetReference(value) {
+  return isPlainObject(value) && typeof value.assetId === "string";
+}
+function isMediaAsset(value) {
+  return isPlainObject(value) && typeof value.id === "string" && typeof value.kind === "string" && typeof value.status === "string" && typeof value.source === "string";
+}
+
+// src/tasks.ts
+var TasksClient = class {
+  constructor(transport, assets) {
+    this.transport = transport;
+    this.assets = assets;
+  }
+  transport;
+  assets;
+  async create(model, input, options = {}) {
+    const schema = getModelSpec(model)?.operations[0]?.inputSchema;
+    const mapped = schema && input && typeof input === "object" && !Array.isArray(input) ? applyNoWatermark(schema, applyMediaGeometry(schema, input)) : input;
+    const normalizedInput = await normalizeTaskInput(mapped, this.assets, options.signal);
+    const body = createTaskRequest(model, normalizedInput, {
+      quoteToken: options.quoteToken,
+      submittedAt: options.submittedAt,
+      metadata: options.metadata,
+      callback_url: options.callback_url,
+      webhook: options.webhook,
+      schemaVersion: options.schemaVersion
+    });
+    const idempotencyKey = options.idempotencyKey ?? crypto.randomUUID();
+    return this.transport.json(
+      "/tasks",
+      {
+        method: "POST",
+        ...jsonBody(body),
+        headers: {
+          ...jsonBody(body).headers,
+          "idempotency-key": idempotencyKey
+        },
+        signal: options.signal
+      },
+      { retryable: true }
+    );
+  }
+  get(taskId, signal) {
+    return this.transport.json(`/tasks/${encodeURIComponent(taskId)}`, {
+      signal
+    });
+  }
+  list(params = {}, signal) {
+    return this.transport.json(
+      `/tasks${queryString({
+        status: params.status,
+        model: params.model,
+        limit: params.limit,
+        cursor: params.cursor
+      })}`,
+      { signal }
+    );
+  }
+  cancel(taskId, signal) {
+    return this.transport.json(
+      `/tasks/${encodeURIComponent(taskId)}/cancel`,
+      { method: "POST", signal },
+      { retryable: true }
+    );
+  }
+  async *watch(taskId, options = {}) {
+    let lastEventId = options.lastEventId;
+    let reconnects = 0;
+    let reconnectDelay = 500;
+    const maxReconnects = options.maxReconnects ?? 5;
+    while (true) {
+      const headers = new Headers({ accept: "text/event-stream" });
+      if (lastEventId) headers.set("last-event-id", lastEventId);
+      const response = await this.transport.response(
+        `/tasks/${encodeURIComponent(taskId)}/events`,
+        { headers, signal: options.signal },
+        { retryable: false }
+      );
+      let reachedTerminalState = false;
+      for await (const serverEvent of parseServerSentEvents(response)) {
+        if (serverEvent.id) lastEventId = serverEvent.id;
+        if (serverEvent.retry !== void 0) reconnectDelay = serverEvent.retry;
+        const event = JSON.parse(serverEvent.data);
+        yield event;
+        if (event.status && isTerminalTaskStatus(event.status)) {
+          const task = event.payload?.task;
+          const deliveryPreparing = task && typeof task === "object" && !Array.isArray(task) && task.deliveryStatus === "preparing";
+          if (!deliveryPreparing) reachedTerminalState = true;
+        }
+      }
+      if (reachedTerminalState) return;
+      if (reconnects >= maxReconnects) return;
+      reconnects += 1;
+      await sleep(reconnectDelay, options.signal);
+    }
+  }
+  async wait(taskId, options = {}) {
+    const timeoutController = new AbortController();
+    const timeoutMs = options.timeoutMs;
+    const timeout = timeoutMs ? setTimeout(() => timeoutController.abort("nexra_wait_timeout"), timeoutMs) : void 0;
+    const signal = combineSignals(options.signal, timeoutMs ? timeoutController.signal : void 0);
+    try {
+      const current = await this.get(taskId, signal);
+      if (isTerminalTaskStatus(current.status) && current.deliveryStatus !== "preparing") return current;
+      try {
+        for await (const event of this.watch(taskId, {
+          signal,
+          lastEventId: options.lastEventId,
+          maxReconnects: options.maxReconnects
+        })) {
+          await options.onEvent?.(event);
+        }
+      } catch (error) {
+        if (signal?.aborted) throw error;
+        if (error instanceof NexraApiError && ![405, 406, 501].includes(error.status)) {
+          throw error;
+        }
+      }
+      while (true) {
+        const task = await this.get(taskId, signal);
+        if (isTerminalTaskStatus(task.status) && task.deliveryStatus !== "preparing") return task;
+        await sleep(options.pollIntervalMs ?? 1e3, signal);
+      }
+    } catch (error) {
+      if (timeoutController.signal.aborted && timeoutMs) {
+        throw new NexraWaitTimeoutError(taskId, timeoutMs);
+      }
+      throw error;
+    } finally {
+      if (timeout) clearTimeout(timeout);
+    }
+  }
+  async run(model, input, options = {}) {
+    const task = await this.create(model, input, options);
+    let completed;
+    try {
+      completed = await this.wait(task.id, options);
+    } catch (error) {
+      if (options.cancelOnAbort && options.signal?.aborted) {
+        await this.cancel(task.id).catch(() => void 0);
+      }
+      throw error;
+    }
+    if (completed.status !== "succeeded") {
+      throw new NexraTaskError(completed);
+    }
+    return {
+      taskId: completed.id,
+      output: completed.output,
+      assets: completed.assets ?? [],
+      task: completed
+    };
+  }
+};
+function combineSignals(first, second) {
+  const signals = [first, second].filter((signal) => Boolean(signal));
+  if (signals.length === 0) return void 0;
+  if (signals.length === 1) return signals[0];
+  return AbortSignal.any(signals);
+}
+
+// src/transcription.ts
+var NexraTranscriptionError = class extends Error {
+  constructor(code, message, nexraRequestId, closeCode, upstreamCode) {
+    super(message);
+    this.code = code;
+    this.nexraRequestId = nexraRequestId;
+    this.closeCode = closeCode;
+    this.upstreamCode = upstreamCode;
+    this.name = "NexraTranscriptionError";
+  }
+  code;
+  nexraRequestId;
+  closeCode;
+  upstreamCode;
+};
+function browserSocket(url, headers) {
+  if (["authorization", "x-api-key", "cookie"].some((key) => headers.has(key))) {
+    throw new NexraTranscriptionError("browser_credentials_unsupported", "Browser transcription uses a Nexra session cookie; keep API keys on your server.");
+  }
+  return new WebSocket(url);
+}
+var TranscriptionClient = class {
+  constructor(transport, connect = browserSocket) {
+    this.transport = transport;
+    this.connect = connect;
+  }
+  transport;
+  connect;
+  async *stream(options) {
+    const endpoint = getModelSpec(options.model)?.endpoints.find((endpoint2) => endpoint2.protocol === "volcengine-asr-ws");
+    const operation = endpoint?.httpOperations?.find((operation2) => operation2.key === (options.mode ?? "realtime"));
+    if (!operation) throw new NexraTranscriptionError("unsupported_model", "This model/mode has no supported ASR WebSocket endpoint.");
+    const configuration = structuredClone(options.configuration);
+    const audio = object(configuration.audio);
+    const request = object(configuration.request);
+    const schema = operation.messageParameters;
+    const properties = object(schema.properties);
+    const audioSchema = object(object(properties.audio).properties);
+    const requestSchema = object(object(properties.request).properties);
+    if (!Array.isArray(object(audioSchema.format).enum) || !object(audioSchema.format).enum.includes(audio.format) || request.model_name !== object(requestSchema.model_name).const) {
+      throw new NexraTranscriptionError("invalid_configuration", "Provide the model's native audio format and request.model_name.");
+    }
+    for (const key of ["rate", "bits", "channel"]) {
+      const value = audio[key];
+      const field = object(audioSchema[key]);
+      if (value !== void 0 && (typeof value !== "number" || !Number.isSafeInteger(value) || value < Number(field.minimum ?? 1) || Array.isArray(field.enum) && !field.enum.includes(value))) {
+        throw new NexraTranscriptionError("invalid_configuration", `Invalid audio.${key}.`);
+      }
+    }
+    const all = endpoint.inputSchema;
+    for (const [value, selected, full] of [
+      [audio, audioSchema, object(object(object(all.properties).audio).properties)],
+      [request, requestSchema, object(object(object(all.properties).request).properties)]
+    ]) {
+      for (const key of Object.keys(value)) if (key in full && !(key in selected)) {
+        throw new NexraTranscriptionError("invalid_configuration", `${key} is unavailable in this ASR mode.`);
+      }
+    }
+    const controller = new AbortController();
+    const abort = () => controller.abort(options.signal?.reason);
+    options.signal?.addEventListener("abort", abort, { once: true });
+    if (options.signal?.aborted) abort();
+    const iterator = options.audio[Symbol.asyncIterator]();
+    let socket;
+    let timer;
+    let responseChain = Promise.resolve();
+    let notify;
+    const queue = [];
+    let queuedBytes = 0, pendingBytes = 0;
+    let failure;
+    let done = false, finalSent = false, finalReceived = false;
+    const headers = this.transport.headers();
+    const requestId = headers.get("x-nexra-client-request-id");
+    const error = (code, message, closeCode, upstreamCode) => new NexraTranscriptionError(code, message, this.connect === browserSocket ? void 0 : requestId, closeCode, upstreamCode);
+    const wake = () => {
+      notify?.();
+      notify = void 0;
+    };
+    const fail = (cause) => {
+      if (done) return;
+      failure = { cause };
+      done = true;
+      clearTimeout(timer);
+      controller.abort(cause);
+      socket?.close();
+      wake();
+    };
+    const cancelled = () => fail(controller.signal.reason ?? new DOMException("Aborted", "AbortError"));
+    controller.signal.addEventListener("abort", cancelled, { once: true });
+    const arm = (milliseconds, code) => {
+      clearTimeout(timer);
+      timer = setTimeout(() => fail(error(code, "ASR session timed out.")), milliseconds);
+    };
+    try {
+      let first;
+      do {
+        first = await abortable(iterator.next(), controller.signal);
+      } while (!first.done && first.value.byteLength === 0);
+      if (first.done) throw error("invalid_audio", "Provide at least one nonempty audio chunk.");
+      const url = new URL(this.transport.baseUrl);
+      url.pathname = url.pathname.replace(/\/v1\/?$/, "").replace(/\/$/, "") + operation.pathTemplate;
+      url.protocol = url.protocol === "https:" ? "wss:" : url.protocol === "http:" ? "ws:" : url.protocol;
+      if (!["ws:", "wss:"].includes(url.protocol) || url.username || url.password) throw error("invalid_url", "ASR requires an HTTP(S) API base URL.");
+      const organization = options.organizationId ?? headers.get(ORGANIZATION_HEADER);
+      if (organization) {
+        url.searchParams.set("organization", organization);
+        headers.set(ORGANIZATION_HEADER, organization);
+      }
+      const headerSchema = object(operation.headerParameters?.properties);
+      const resource = object(headerSchema["X-Api-Resource-Id"]).const;
+      if (typeof resource !== "string") throw error("invalid_configuration", "ASR resource metadata is missing.");
+      headers.set("x-api-resource-id", resource);
+      headers.set("x-api-request-id", requestId);
+      socket = this.connect(url, headers);
+      socket.binaryType = "arraybuffer";
+      socket.onmessage = (message) => {
+        if (done) return;
+        if (!(message.data instanceof ArrayBuffer) || (pendingBytes += message.data.byteLength) > ASR_MAX_FRAME_BYTES) {
+          fail(error("invalid_frame", "ASR response buffer exceeded its limit."));
+          return;
+        }
+        responseChain = responseChain.then(async () => {
+          if (done) return;
+          const frame = await decodeVolcengineAsrFrame(new Uint8Array(message.data));
+          pendingBytes -= message.data.byteLength;
+          if (done) return;
+          if (frame.type === 15) throw error("provider_rejected", "ASR provider rejected the session.", void 0, frame.errorCode);
+          if (frame.type !== 9 || finalReceived) throw error("invalid_frame", "Unexpected ASR response.");
+          const response = volcengineAsrFrameJson(frame);
+          const final = Boolean(frame.flags & 2);
+          if (final && (!finalSent || typeof response.result?.text !== "string" || typeof response.audio_info?.duration !== "number")) {
+            throw error("incomplete_result", "ASR final response lacks verified text/duration or arrived before final input.");
+          }
+          const size = new TextEncoder().encode(JSON.stringify(response)).byteLength;
+          if ((queuedBytes += size) > ASR_MAX_FRAME_BYTES) throw error("result_backpressure", "ASR results are not being consumed fast enough.");
+          finalReceived = final;
+          queue.push({ event: { final, response }, bytes: size });
+          wake();
+        }).catch(fail);
+      };
+      socket.onerror = () => {
+        if (!done) arm(1e3, "connection_failed");
+      };
+      socket.onclose = (event) => {
+        void responseChain.then(() => {
+          if (done) return;
+          if (event.code !== 1e3) fail(error("connection_closed", event.reason || "ASR connection closed unexpectedly.", event.code));
+          else if (!finalReceived) fail(error("incomplete_result", "ASR closed without a final result.", event.code));
+          else {
+            done = true;
+            clearTimeout(timer);
+            controller.abort();
+            wake();
+          }
+        });
+      };
+      arm(1e4, "connection_timeout");
+      await abortable(new Promise((resolve, reject) => {
+        const open = () => {
+          cleanup();
+          resolve();
+        };
+        const close = () => {
+          cleanup();
+          reject(error("connection_closed", "ASR connection closed before opening."));
+        };
+        const cleanup = () => {
+          socket.removeEventListener("open", open);
+          socket.removeEventListener("close", close);
+          controller.signal.removeEventListener("abort", cleanup);
+        };
+        socket.addEventListener("open", open, { once: true });
+        socket.addEventListener("close", close, { once: true });
+        controller.signal.addEventListener("abort", cleanup, { once: true });
+      }), controller.signal);
+      socket.send(encodeVolcengineAsrFrame(1, new TextEncoder().encode(JSON.stringify(configuration)), { json: true }));
+      options.onConnected?.();
+      controller.signal.throwIfAborted();
+      const limit = asrInputSecondsLimit(operation.pathTemplate);
+      const bytesPerSecond = Number(audio.rate ?? 16e3) * Number(audio.bits ?? 16) / 8 * Number(audio.channel ?? 1);
+      if (!Number.isFinite(bytesPerSecond) || bytesPerSecond <= 0) throw error("invalid_configuration", "Invalid audio sample configuration.");
+      let sentBytes = 0;
+      const pump = async () => {
+        let chunk = first;
+        while (!chunk.done) {
+          controller.signal.throwIfAborted();
+          const bytes = chunk.value;
+          if (!(bytes instanceof Uint8Array) || bytes.length + 8 > ASR_MAX_FRAME_BYTES) throw error("invalid_audio", "Invalid ASR audio chunk.");
+          if (bytes.length) {
+            if ((audio.format === "pcm" || audio.format === "wav") && limit !== void 0 && (sentBytes + bytes.length) / bytesPerSecond > limit + (audio.format === "wav" ? 0.01 : 0)) {
+              throw error("audio_duration_exceeded", "Sentence recognition accepts at most 60 seconds.");
+            }
+            if (socket.bufferedAmount > 1024 * 1024) throw error("audio_backpressure", "ASR audio send buffer is full.");
+            socket.send(encodeVolcengineAsrFrame(2, bytes));
+            sentBytes += bytes.length;
+          }
+          arm(1e4, "audio_timeout");
+          chunk = await abortable(iterator.next(), controller.signal);
+        }
+        finalSent = true;
+        socket.send(encodeVolcengineAsrFrame(2, new Uint8Array(), { final: true }));
+        arm(1e4, "final_timeout");
+      };
+      void pump().catch((cause) => {
+        if (!done) fail(cause);
+      });
+      for (; ; ) {
+        if (failure) throw failure.cause;
+        const next = queue.shift();
+        if (next) {
+          queuedBytes -= next.bytes;
+          yield next.event;
+        } else if (done) return;
+        else await new Promise((resolve) => {
+          notify = resolve;
+        });
+      }
+    } finally {
+      done = true;
+      clearTimeout(timer);
+      controller.abort();
+      controller.signal.removeEventListener("abort", cancelled);
+      options.signal?.removeEventListener("abort", abort);
+      if (socket) {
+        socket.onmessage = null;
+        socket.onerror = null;
+        socket.onclose = null;
+        socket.close();
+      }
+      if (iterator.return) void Promise.resolve(iterator.return()).catch(() => {
+      });
+    }
+  }
+};
+function object(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+async function abortable(promise, signal) {
+  let abort;
+  try {
+    return await Promise.race([promise, new Promise((_, reject) => {
+      abort = () => reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+      if (signal.aborted) abort();
+      else signal.addEventListener("abort", abort, { once: true });
+    })]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
+
+// src/client.ts
+var NexraClient = class {
+  assets;
+  catalog;
+  models;
+  tasks;
+  voices;
+  transcription;
+  constructor(options = {}, connect) {
+    const transport = new HttpTransport(options);
+    this.assets = new AssetsClient(transport);
+    this.catalog = new CatalogClient(transport);
+    this.models = new ModelsClient(transport);
+    this.tasks = new TasksClient(transport, this.assets);
+    this.voices = new VoicesClient(transport);
+    this.transcription = new TranscriptionClient(transport, connect);
+  }
+  run(model, input, options = {}) {
+    return this.tasks.run(model, input, options);
+  }
+};
+function createNexra(options = {}) {
+  return new NexraClient(options);
+}
+
+// src/webhooks.ts
+async function verifyWebhook(request, secret, options = {}) {
+  const webhookId = request.headers.get("nexra-webhook-id");
+  const timestamp = request.headers.get("nexra-webhook-timestamp");
+  const signatureHeader = request.headers.get("nexra-webhook-signature");
+  if (!webhookId || !timestamp || !signatureHeader) return false;
+  const timestampSeconds = Number(timestamp);
+  if (!Number.isFinite(timestampSeconds)) return false;
+  const nowSeconds = Math.floor((options.now ?? /* @__PURE__ */ new Date()).getTime() / 1e3);
+  if (Math.abs(nowSeconds - timestampSeconds) > (options.toleranceSeconds ?? 300)) {
+    return false;
+  }
+  const body = await request.clone().text();
+  const signedPayload = `${webhookId}.${timestamp}.${body}`;
+  const key = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const digest = new Uint8Array(
+    await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(signedPayload))
+  );
+  const expected = toBase64Url(digest);
+  const signatures = signatureHeader.split(" ").flatMap((part) => part.split(",")).map((part) => part.trim()).filter((part) => part.startsWith("v1=")).map((part) => part.slice(3));
+  return signatures.some((signature) => timingSafeEqual(signature, expected));
+}
+function toBase64Url(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function timingSafeEqual(left, right) {
+  if (left.length !== right.length) return false;
+  let difference = 0;
+  for (let index = 0; index < left.length; index += 1) {
+    difference |= left.charCodeAt(index) ^ right.charCodeAt(index);
+  }
+  return difference === 0;
+}
+
+export {
+  AssetsClient,
+  ModelsClient,
+  VoicesClient,
+  TasksClient,
+  NexraTranscriptionError,
+  TranscriptionClient,
+  NexraClient,
+  createNexra,
+  verifyWebhook
+};