@breeze.blue/sdk 0.3.0

package/dist/client.js

@@ -0,0 +1,331 @@
+import { AudioResponse } from "./audio.js";
+import { BreezeBlueConfigurationError, errorFromResponse } from "./errors.js";
+import { camelizeKeys, snakeizeKeys } from "./_transform.js";
+import { SDK_NAME, SDK_VERSION } from "./version.js";
+const DEFAULT_BASE_URL = "https://api.breeze.blue";
+const DEFAULT_TIMEOUT_MS = 60_000;
+export class BreezeBlueClient {
+    apiKey;
+    baseUrl;
+    fetch;
+    headers;
+    timeout;
+    textToSpeech;
+    generationJobs;
+    voices;
+    history;
+    models;
+    account;
+    constructor(options = {}) {
+        const envApiKey = typeof process !== "undefined" ? process.env.BREEZE_API_KEY : undefined;
+        const envBaseUrl = typeof process !== "undefined" ? process.env.BREEZE_BASE_URL : undefined;
+        const apiKey = options.apiKey ?? envApiKey;
+        if (!apiKey) {
+            throw new BreezeBlueConfigurationError("Missing Breeze API key. Pass apiKey or set BREEZE_API_KEY.");
+        }
+        this.apiKey = apiKey;
+        this.baseUrl = normalizeBaseUrl(options.baseUrl ?? envBaseUrl ?? DEFAULT_BASE_URL);
+        this.fetch = options.fetch ?? globalThis.fetch;
+        this.headers = options.headers;
+        this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+        this.textToSpeech = new TextToSpeechResource(this);
+        this.generationJobs = new GenerationJobsResource(this);
+        this.voices = new VoicesResource(this);
+        this.history = new HistoryResource(this);
+        this.models = new ModelsResource(this);
+        this.account = new AccountResource(this);
+    }
+    async requestJson(method, path, params, body, options) {
+        const response = await this.request(method, path, params, body, options);
+        const text = await response.text();
+        if (!text) {
+            return undefined;
+        }
+        return camelizeKeys(JSON.parse(text));
+    }
+    async requestAudio(method, path, params, body, options) {
+        const response = await this.request(method, path, params, body, options);
+        return new AudioResponse(response);
+    }
+    async request(method, path, params, body, options) {
+        const signal = buildAbortSignal(options?.signal, options?.timeout ?? this.timeout);
+        const wireParams = params ? snakeizeKeys(params) : undefined;
+        const wireBody = transformRequestBody(body);
+        try {
+            const response = await this.fetch(buildUrl(this.baseUrl, path, wireParams), {
+                method,
+                headers: this.buildHeaders(wireBody, options?.headers),
+                body: bodyToRequestBody(wireBody),
+                signal: signal.signal,
+            });
+            if (!response.ok) {
+                throw await errorFromResponse(response);
+            }
+            return response;
+        }
+        finally {
+            signal.cleanup();
+        }
+    }
+    buildHeaders(body, requestHeaders) {
+        const headers = new Headers(this.headers);
+        headers.set("xi-api-key", this.apiKey);
+        headers.set("x-breeze-sdk", `${SDK_NAME}/${SDK_VERSION}`);
+        mergeHeaders(headers, requestHeaders);
+        if (body !== undefined && !(body instanceof FormData) && !headers.has("content-type")) {
+            headers.set("content-type", "application/json");
+        }
+        return headers;
+    }
+}
+class TextToSpeechResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    convert(voiceId, request, options = {}) {
+        return this.client.requestAudio("POST", `/v1/text-to-speech/${encodeURIComponent(voiceId)}`, { outputFormat: options.outputFormat }, request, options);
+    }
+    createJob(voiceId, request, options = {}) {
+        return this.client.requestJson("POST", `/v1/text-to-speech/${encodeURIComponent(voiceId)}`, { outputFormat: options.outputFormat, delivery: "async" }, request, options);
+    }
+    stream(voiceId, request, options = {}) {
+        return this.client.requestAudio("POST", `/v1/text-to-speech/${encodeURIComponent(voiceId)}/stream`, {
+            outputFormat: options.outputFormat,
+            optimizeStreamingLatency: options.optimizeStreamingLatency,
+            enableLogging: options.enableLogging,
+        }, request, options);
+    }
+}
+class GenerationJobsResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    get(generationJobId, options) {
+        return this.client.requestJson("GET", `/v1/generation-jobs/${encodeURIComponent(generationJobId)}`, undefined, undefined, options);
+    }
+    downloadAudio(generationJobId, options) {
+        return this.client.requestAudio("GET", `/v1/generation-jobs/${encodeURIComponent(generationJobId)}/audio`, undefined, undefined, options);
+    }
+}
+/**
+ * Voice CRUD plus the two-step preview → save flow for Breeze voices.
+ *
+ * Breeze's voice creation is always two steps: produce a preview
+ * (`createClonePreview` from an audio sample, or `createDesignPreview` from
+ * a text description), then persist it with `savePreview`. Preview generation
+ * never creates a saved voice until `savePreview` is called.
+ */
+class VoicesResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    // -- listing / single voice CRUD --------------------------------------
+    search(params = {}, options) {
+        return this.client.requestJson("GET", "/v1/voices", params, undefined, options);
+    }
+    get(voiceId, options) {
+        return this.client.requestJson("GET", `/v1/voices/${encodeURIComponent(voiceId)}`, undefined, undefined, options);
+    }
+    edit(voiceId, request, options) {
+        return this.client.requestJson("PATCH", `/v1/voices/${encodeURIComponent(voiceId)}`, undefined, voiceEditForm(request), options);
+    }
+    delete(voiceId, options) {
+        return this.client.requestJson("DELETE", `/v1/voices/${encodeURIComponent(voiceId)}`, undefined, undefined, options);
+    }
+    // -- voice settings ---------------------------------------------------
+    getSettings(voiceId, options) {
+        return this.client.requestJson("GET", `/v1/voices/${encodeURIComponent(voiceId)}/settings`, undefined, undefined, options);
+    }
+    editSettings(voiceId, settings, options) {
+        return this.client.requestJson("PATCH", `/v1/voices/${encodeURIComponent(voiceId)}/settings`, undefined, settings, options);
+    }
+    // -- two-step preview → save flow -------------------------------------
+    /**
+     * Generate a clone preview from a single audio sample. Returns a
+     * `generatedVoiceId`; call {@link savePreview} after the user accepts
+     * the preview to persist it as a real voice.
+     */
+    async createClonePreview(request, options) {
+        return this.client.requestJson("POST", "/v1/voice-previews/clone", undefined, clonePreviewForm(request), options);
+    }
+    /**
+     * Design preview voices from a text prompt (no audio sample). Returns one
+     * or more previews; pass the chosen `generatedVoiceId` to
+     * {@link savePreview}.
+     */
+    createDesignPreview(request, options = {}) {
+        return this.client.requestJson("POST", "/v1/voice-previews/design", { outputFormat: options.outputFormat }, request, options);
+    }
+    /** Stream the audio of a clone or design preview before saving. */
+    streamPreview(generatedVoiceId, options = {}) {
+        return this.client.requestAudio("GET", `/v1/voice-previews/${encodeURIComponent(generatedVoiceId)}/stream`, { outputFormat: options.outputFormat }, undefined, options);
+    }
+    /** Persist a clone or design preview as a real voice asset. */
+    savePreview(request, options) {
+        return this.client.requestJson("POST", `/v1/voice-previews/${encodeURIComponent(request.generatedVoiceId)}/save`, undefined, {
+            voiceName: request.voiceName,
+            voiceDescription: request.voiceDescription,
+            labels: request.labels,
+            playedNotSelectedVoiceIds: request.playedNotSelectedVoiceIds,
+        }, options);
+    }
+}
+class HistoryResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    list(params = {}, options) {
+        return this.client.requestJson("GET", "/v1/history", params, undefined, options);
+    }
+    get(historyItemId, options) {
+        return this.client.requestJson("GET", `/v1/history/${encodeURIComponent(historyItemId)}`, undefined, undefined, options);
+    }
+    downloadAudio(historyItemId, options) {
+        return this.client.requestAudio("GET", `/v1/history/${encodeURIComponent(historyItemId)}/audio`, undefined, undefined, options);
+    }
+    delete(historyItemId, options) {
+        return this.client.requestJson("DELETE", `/v1/history/${encodeURIComponent(historyItemId)}`, undefined, undefined, options);
+    }
+}
+class ModelsResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    list(options) {
+        return this.client.requestJson("GET", "/v1/models", undefined, undefined, options);
+    }
+}
+class AccountResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    balance(options) {
+        return this.client.requestJson("GET", "/v1/balance", undefined, undefined, options);
+    }
+    usage(params = {}, options) {
+        return this.client.requestJson("GET", "/v1/usage", params, undefined, options);
+    }
+}
+function normalizeBaseUrl(value) {
+    return value.replace(/\/+$/, "");
+}
+function buildAbortSignal(inputSignal, timeoutMs) {
+    if (!timeoutMs || timeoutMs <= 0) {
+        return { signal: inputSignal, cleanup: () => { } };
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(new Error(`Breeze request timed out after ${timeoutMs}ms.`)), timeoutMs);
+    let abortListener;
+    if (inputSignal) {
+        if (inputSignal.aborted) {
+            controller.abort(inputSignal.reason);
+        }
+        else {
+            abortListener = () => controller.abort(inputSignal.reason);
+            inputSignal.addEventListener("abort", abortListener, { once: true });
+        }
+    }
+    return {
+        signal: controller.signal,
+        cleanup: () => {
+            clearTimeout(timeout);
+            if (abortListener) {
+                inputSignal?.removeEventListener("abort", abortListener);
+            }
+        },
+    };
+}
+function buildUrl(baseUrl, path, params) {
+    const url = new URL(`${baseUrl}${path}`);
+    for (const [key, value] of Object.entries(params ?? {})) {
+        if (value === undefined || value === null)
+            continue;
+        url.searchParams.set(key, String(value));
+    }
+    return url.toString();
+}
+function bodyToRequestBody(body) {
+    if (body === undefined)
+        return undefined;
+    if (body instanceof FormData)
+        return body;
+    return JSON.stringify(body);
+}
+function transformRequestBody(body) {
+    if (body === undefined)
+        return undefined;
+    if (body instanceof FormData)
+        return body;
+    return snakeizeKeys(body);
+}
+function mergeHeaders(headers, input) {
+    if (!input)
+        return;
+    new Headers(input).forEach((value, key) => headers.set(key, value));
+}
+function clonePreviewForm(request) {
+    if (request.removeBackgroundNoise) {
+        throw new BreezeBlueConfigurationError("removeBackgroundNoise is not supported by the Breeze Developer API.");
+    }
+    const form = new FormData();
+    form.set("name", request.name);
+    appendOptional(form, "description", request.description);
+    appendOptional(form, "labels", request.labels ? JSON.stringify(request.labels) : undefined);
+    appendOptional(form, "text", request.text);
+    appendOptional(form, "instructions", request.instructions);
+    for (const file of normalizeFiles(request.file, request.files)) {
+        appendFile(form, "files", file);
+    }
+    return form;
+}
+function voiceEditForm(request) {
+    const form = new FormData();
+    form.set("name", request.name);
+    appendOptional(form, "description", request.description);
+    appendOptional(form, "labels", request.labels ? JSON.stringify(request.labels) : undefined);
+    for (const file of normalizeFiles(request.file, request.files)) {
+        appendFile(form, "files", file);
+    }
+    return form;
+}
+function appendOptional(form, key, value) {
+    if (value === undefined)
+        return;
+    form.set(key, String(value));
+}
+function normalizeFiles(file, files) {
+    if (files && files.length > 0)
+        return files;
+    return file === undefined ? [] : [file];
+}
+function appendFile(form, key, input) {
+    const upload = isUploadFile(input) ? input : { data: input };
+    const blob = toBlob(upload.data, upload.contentType);
+    const filename = upload.filename ?? filenameFromUpload(upload.data);
+    form.append(key, blob, filename);
+}
+function isUploadFile(value) {
+    return typeof value === "object" && value !== null && "data" in value;
+}
+function toBlob(data, contentType) {
+    if (data instanceof Blob)
+        return data;
+    if (typeof data === "string")
+        return new Blob([data], { type: contentType ?? "application/octet-stream" });
+    if (data instanceof ArrayBuffer)
+        return new Blob([data], { type: contentType ?? "application/octet-stream" });
+    const copy = new Uint8Array(data.byteLength);
+    copy.set(data);
+    return new Blob([copy.buffer], { type: contentType ?? "application/octet-stream" });
+}
+function filenameFromUpload(data) {
+    if (data instanceof File && data.name)
+        return data.name;
+    return "sample.wav";
+}

package/dist/errors.d.ts

@@ -0,0 +1,50 @@
+export interface BreezeBlueErrorPayload {
+    ok?: false;
+    code?: string;
+    detail?: string;
+    error?: string;
+    meta?: Record<string, unknown> | null;
+}
+export declare class BreezeBlueError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class BreezeBlueConfigurationError extends BreezeBlueError {
+}
+export declare class BreezeBlueAPIError extends BreezeBlueError {
+    readonly status: number;
+    readonly code: string;
+    readonly detail: string;
+    readonly meta: Record<string, unknown> | null;
+    readonly headers: Headers;
+    constructor(params: {
+        status: number;
+        code: string;
+        detail: string;
+        meta?: Record<string, unknown> | null;
+        headers: Headers;
+    });
+}
+export declare class BreezeBlueAuthenticationError extends BreezeBlueAPIError {
+}
+export declare class BreezeBlueBadRequestError extends BreezeBlueAPIError {
+}
+export declare class BreezeBlueForbiddenError extends BreezeBlueAPIError {
+}
+export declare class BreezeBlueNotFoundError extends BreezeBlueAPIError {
+}
+export declare class BreezeBlueConflictError extends BreezeBlueAPIError {
+}
+export declare class BreezeBlueValidationError extends BreezeBlueAPIError {
+}
+export declare class BreezeBlueRateLimitError extends BreezeBlueAPIError {
+}
+export declare class BreezeBlueGenerationNotReadyError extends BreezeBlueAPIError {
+    get retryAfter(): number | null;
+}
+export declare class BreezeBlueInsufficientCreditsError extends BreezeBlueAPIError {
+}
+export declare class BreezeBlueUpstreamError extends BreezeBlueAPIError {
+}
+export declare class BreezeBlueServiceUnavailableError extends BreezeBlueAPIError {
+}
+export declare function errorFromResponse(response: Response): Promise<BreezeBlueAPIError>;

package/dist/errors.js

@@ -0,0 +1,151 @@
+export class BreezeBlueError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = new.target.name;
+    }
+}
+export class BreezeBlueConfigurationError extends BreezeBlueError {
+}
+export class BreezeBlueAPIError extends BreezeBlueError {
+    status;
+    code;
+    detail;
+    meta;
+    headers;
+    constructor(params) {
+        super(params.detail || params.code);
+        this.status = params.status;
+        this.code = params.code;
+        this.detail = params.detail;
+        this.meta = params.meta ?? null;
+        this.headers = params.headers;
+    }
+}
+export class BreezeBlueAuthenticationError extends BreezeBlueAPIError {
+}
+export class BreezeBlueBadRequestError extends BreezeBlueAPIError {
+}
+export class BreezeBlueForbiddenError extends BreezeBlueAPIError {
+}
+export class BreezeBlueNotFoundError extends BreezeBlueAPIError {
+}
+export class BreezeBlueConflictError extends BreezeBlueAPIError {
+}
+export class BreezeBlueValidationError extends BreezeBlueAPIError {
+}
+export class BreezeBlueRateLimitError extends BreezeBlueAPIError {
+}
+export class BreezeBlueGenerationNotReadyError extends BreezeBlueAPIError {
+    get retryAfter() {
+        const value = this.headers.get("retry-after");
+        if (!value)
+            return null;
+        const parsed = Number.parseInt(value, 10);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+}
+export class BreezeBlueInsufficientCreditsError extends BreezeBlueAPIError {
+}
+export class BreezeBlueUpstreamError extends BreezeBlueAPIError {
+}
+export class BreezeBlueServiceUnavailableError extends BreezeBlueAPIError {
+}
+const codeErrorMap = new Map([
+    ["BAD_REQUEST", BreezeBlueBadRequestError],
+    ["VALIDATION_ERROR", BreezeBlueValidationError],
+    ["AUTH_REQUIRED", BreezeBlueAuthenticationError],
+    ["AUTH_INVALID_SESSION", BreezeBlueAuthenticationError],
+    ["AUTH_SESSION_EXPIRED", BreezeBlueAuthenticationError],
+    ["AUTH_USER_UNAVAILABLE", BreezeBlueAuthenticationError],
+    ["AUTH_CONFIG_MISSING", BreezeBlueAuthenticationError],
+    ["FORBIDDEN", BreezeBlueForbiddenError],
+    ["RESOURCE_NOT_FOUND", BreezeBlueNotFoundError],
+    ["CONFLICT", BreezeBlueConflictError],
+    ["BILLING_INSUFFICIENT_CREDITS", BreezeBlueInsufficientCreditsError],
+    ["RATE_LIMITED", BreezeBlueRateLimitError],
+    ["GENERATION_CONCURRENCY_EXCEEDED", BreezeBlueRateLimitError],
+    ["GENERATION_NOT_READY", BreezeBlueGenerationNotReadyError],
+    ["UPSTREAM_BILLING_ERROR", BreezeBlueUpstreamError],
+    ["UPSTREAM_GENERATION_ERROR", BreezeBlueUpstreamError],
+    ["UPSTREAM_TIMEOUT", BreezeBlueUpstreamError],
+    ["UPSTREAM_GENERATION_SERVICE_ERROR", BreezeBlueUpstreamError],
+    ["UPSTREAM_ASSET_STORAGE_ERROR", BreezeBlueUpstreamError],
+    ["GENERATION_INVALID_RESPONSE", BreezeBlueUpstreamError],
+    ["GENERATION_FAILED", BreezeBlueUpstreamError],
+    ["VOICE_DESIGN_FAILED", BreezeBlueUpstreamError],
+    ["VOICE_CLONE_FAILED", BreezeBlueUpstreamError],
+    ["GENERATION_CAPACITY_EXCEEDED", BreezeBlueServiceUnavailableError],
+    ["LLM_CONFIG_NOT_FOUND", BreezeBlueServiceUnavailableError],
+]);
+const statusErrorMap = new Map([
+    [400, BreezeBlueBadRequestError],
+    [401, BreezeBlueAuthenticationError],
+    [402, BreezeBlueInsufficientCreditsError],
+    [403, BreezeBlueForbiddenError],
+    [404, BreezeBlueNotFoundError],
+    [409, BreezeBlueConflictError],
+    [422, BreezeBlueValidationError],
+    [425, BreezeBlueGenerationNotReadyError],
+    [429, BreezeBlueRateLimitError],
+    [502, BreezeBlueUpstreamError],
+    [503, BreezeBlueServiceUnavailableError],
+    [504, BreezeBlueUpstreamError],
+]);
+export async function errorFromResponse(response) {
+    const payload = await readErrorPayload(response);
+    const code = payload.code || fallbackCode(response.status);
+    const detail = payload.detail || payload.error || response.statusText || code;
+    const params = {
+        status: response.status,
+        code,
+        detail,
+        meta: payload.meta ?? null,
+        headers: response.headers,
+    };
+    const errorType = codeErrorMap.get(code) ?? statusErrorMap.get(response.status) ?? BreezeBlueAPIError;
+    return new errorType(params);
+}
+async function readErrorPayload(response) {
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+        try {
+            const value = await response.json();
+            if (value && typeof value === "object") {
+                return value;
+            }
+        }
+        catch {
+            return {};
+        }
+    }
+    try {
+        const text = await response.text();
+        return text ? { detail: text, error: text } : {};
+    }
+    catch {
+        return {};
+    }
+}
+function fallbackCode(status) {
+    if (status === 401)
+        return "AUTH_REQUIRED";
+    if (status === 400)
+        return "BAD_REQUEST";
+    if (status === 403)
+        return "FORBIDDEN";
+    if (status === 404)
+        return "RESOURCE_NOT_FOUND";
+    if (status === 409)
+        return "CONFLICT";
+    if (status === 422)
+        return "VALIDATION_ERROR";
+    if (status === 425)
+        return "GENERATION_NOT_READY";
+    if (status === 502)
+        return "UPSTREAM_GENERATION_ERROR";
+    if (status === 503)
+        return "SERVICE_UNAVAILABLE";
+    if (status === 504)
+        return "UPSTREAM_TIMEOUT";
+    return "API_ERROR";
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { AudioResponse } from "./audio.js";
+export { BreezeBlueAPIError, BreezeBlueAuthenticationError, BreezeBlueBadRequestError, BreezeBlueConfigurationError, BreezeBlueConflictError, BreezeBlueError, BreezeBlueForbiddenError, BreezeBlueGenerationNotReadyError, BreezeBlueInsufficientCreditsError, BreezeBlueNotFoundError, BreezeBlueRateLimitError, BreezeBlueServiceUnavailableError, BreezeBlueUpstreamError, BreezeBlueValidationError, } from "./errors.js";
+export { BreezeBlueClient } from "./client.js";
+export { SDK_NAME, SDK_VERSION } from "./version.js";
+export type * from "./types.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { AudioResponse } from "./audio.js";
+export { BreezeBlueAPIError, BreezeBlueAuthenticationError, BreezeBlueBadRequestError, BreezeBlueConfigurationError, BreezeBlueConflictError, BreezeBlueError, BreezeBlueForbiddenError, BreezeBlueGenerationNotReadyError, BreezeBlueInsufficientCreditsError, BreezeBlueNotFoundError, BreezeBlueRateLimitError, BreezeBlueServiceUnavailableError, BreezeBlueUpstreamError, BreezeBlueValidationError, } from "./errors.js";
+export { BreezeBlueClient } from "./client.js";
+export { SDK_NAME, SDK_VERSION } from "./version.js";

package/dist/node.d.ts

@@ -0,0 +1,5 @@
+import { type AudioResponse, type PlayOptions, type StreamOptions, selectAudioPlaybackCommand, selectStreamPlaybackCommand } from "./audio.js";
+export declare function save(audio: AudioResponse, path: string): Promise<void>;
+export declare function play(audio: AudioResponse, options?: PlayOptions): Promise<void>;
+export declare function stream(audio: AudioResponse, options?: StreamOptions): Promise<void>;
+export { selectAudioPlaybackCommand, selectStreamPlaybackCommand };

package/dist/node.js

@@ -0,0 +1,74 @@
+import { spawn, spawnSync } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Readable } from "node:stream";
+import { extensionForContentType, selectAudioPlaybackCommand, selectStreamPlaybackCommand, } from "./audio.js";
+export async function save(audio, path) {
+    await writeFile(path, Buffer.from(await audio.arrayBuffer()));
+}
+export async function play(audio, options = {}) {
+    const command = options.command
+        ? { command: options.command, args: options.args ?? [], mode: "stdin" }
+        : selectAudioPlaybackCommand({
+            availability: options.availability ?? systemCommandAvailability,
+            platform: options.platform ?? process.platform,
+        });
+    if (command.mode === "file") {
+        const dir = await mkdtemp(join(tmpdir(), "breeze-blue-audio-"));
+        const file = join(dir, audio.filename || `audio${extensionForContentType(audio.contentType)}`);
+        await writeFile(file, Buffer.from(await audio.arrayBuffer()));
+        try {
+            await spawnAndWait(command.command, [...command.args, file]);
+        }
+        finally {
+            await rm(dir, { force: true, recursive: true });
+        }
+        return;
+    }
+    await spawnAndPipeBytes(command.command, command.args, await audio.bytes());
+}
+export async function stream(audio, options = {}) {
+    const selected = selectStreamPlaybackCommand();
+    const command = options.command ?? selected.command;
+    const args = options.args ?? selected.args;
+    await spawnAndPipeReadable(command, args, audio.response.body);
+}
+export { selectAudioPlaybackCommand, selectStreamPlaybackCommand };
+const systemCommandAvailability = {
+    has(command) {
+        const result = spawnSync(process.platform === "win32" ? "where" : "command", process.platform === "win32" ? [command] : ["-v", command], {
+            stdio: "ignore",
+            shell: process.platform !== "win32",
+        });
+        return result.status === 0;
+    },
+};
+async function spawnAndPipeBytes(command, args, bytes) {
+    const child = spawn(command, args, { stdio: ["pipe", "ignore", "inherit"] });
+    child.stdin.end(Buffer.from(bytes));
+    await waitForChild(child);
+}
+async function spawnAndPipeReadable(command, args, body) {
+    if (!body) {
+        throw new Error("Audio response has no stream body.");
+    }
+    const child = spawn(command, args, { stdio: ["pipe", "ignore", "inherit"] });
+    Readable.fromWeb(body).pipe(child.stdin);
+    await waitForChild(child);
+}
+async function spawnAndWait(command, args) {
+    await waitForChild(spawn(command, args, { stdio: "inherit" }));
+}
+async function waitForChild(child) {
+    await new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("exit", (code, signal) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`Audio player exited with ${signal || code}.`));
+        });
+    });
+}