@lumavox/server 0.0.0-stage → 0.2.2

package/dist/resources/templates.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `client.templates`: the platform's frozen generations — `/v1/templates*`.
+ * Every tenant sees the same ones; a template fixes every parameter but
+ * the ones it `exposed`, so its price is known up front.
+ *
+ * - **`create(id, body)` is the route** (`POST …/generate`, 202, a
+ *   `gen_…`), and **`generate(id, body)` waits** for the result, as
+ *   `images.generate` does — one name, one meaning, across the SDK. The
+ *   wait reads `/v1/generations/{id}`: a template makes an image, a video
+ *   or a skybox, and the key that made it may read it.
+ * - **`file(id, name)` needs no key** and answers the bytes; a template's
+ *   URLs already name each file and its `v`, which makes it cacheable.
+ */
+import type { GenerationInfo, TemplateGenerateRequest, TemplateInfo, TemplateList } from "../gen/index.js";
+import { type RequestOptions, type Transport } from "../transport.js";
+import type { Generations } from "./generations.js";
+import { Readable } from "./resource.js";
+/** A template's picture, as stored. */
+export interface TemplateFile {
+    body: ArrayBuffer;
+    contentType: string;
+}
+/** `get(id)` answers one with its inputs, frozen parameters and price. */
+export declare class Templates extends Readable<TemplateInfo> {
+    private readonly generations;
+    constructor(api: Transport, base: string, generations: Generations);
+    /** Every template this organisation may generate from. */
+    list(options?: RequestOptions): Promise<TemplateList>;
+    /** Generates from it, charged when accepted: the `gen_…` at once. */
+    create(id: string, body?: TemplateGenerateRequest, options?: RequestOptions): Promise<GenerationInfo>;
+    /** Generates from it and waits: the generation once it is final. */
+    generate(id: string, body?: TemplateGenerateRequest, options?: RequestOptions): Promise<GenerationInfo>;
+    /** A template's picture — `example`, or `input-<slot>` — with no key. */
+    file(id: string, name: string, params?: {
+        v?: string | null;
+    }, options?: RequestOptions): Promise<TemplateFile>;
+}

package/dist/resources/templates.js

@@ -0,0 +1,50 @@
+/**
+ * `client.templates`: the platform's frozen generations — `/v1/templates*`.
+ * Every tenant sees the same ones; a template fixes every parameter but
+ * the ones it `exposed`, so its price is known up front.
+ *
+ * - **`create(id, body)` is the route** (`POST …/generate`, 202, a
+ *   `gen_…`), and **`generate(id, body)` waits** for the result, as
+ *   `images.generate` does — one name, one meaning, across the SDK. The
+ *   wait reads `/v1/generations/{id}`: a template makes an image, a video
+ *   or a skybox, and the key that made it may read it.
+ * - **`file(id, name)` needs no key** and answers the bytes; a template's
+ *   URLs already name each file and its `v`, which makes it cacheable.
+ */
+import { segment } from "../transport.js";
+import { poll } from "../wait.js";
+import { Readable } from "./resource.js";
+/** `get(id)` answers one with its inputs, frozen parameters and price. */
+export class Templates extends Readable {
+    constructor(api, base, generations) {
+        super(api, base);
+        this.generations = generations;
+    }
+    /** Every template this organisation may generate from. */
+    list(options) {
+        return this.send("GET", "", options);
+    }
+    /** Generates from it, charged when accepted: the `gen_…` at once. */
+    create(id, body = {}, options) {
+        return this.send("POST", this.at(id, "/generate"), options, body);
+    }
+    /** Generates from it and waits: the generation once it is final. */
+    async generate(id, body = {}, options) {
+        const job = await this.create(id, body, options);
+        return poll(() => this.generations.get(job.id, options), options, job);
+    }
+    /** A template's picture — `example`, or `input-<slot>` — with no key. */
+    async file(id, name, params = {}, options) {
+        const answer = await this.api.request({
+            method: "GET",
+            path: this.base + this.at(id, `/files/${segment(name)}`),
+            query: params,
+            read: "bytes",
+            open: true,
+        }, options);
+        return {
+            body: answer.data,
+            contentType: answer.headers.get("content-type") ?? "",
+        };
+    }
+}

package/dist/resources/usage.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `client.usage`: what this organisation spent — `GET /v1/usage` over a
+ * window of days, and `GET /v1/plan`, its plan and balance (`null` with
+ * no subscription). Read-only, unmetered.
+ */
+import type { OrgPlan, UsageData, UsageResponse } from "../gen/index.js";
+import type { RequestOptions } from "../transport.js";
+import { Resource } from "./resource.js";
+export type UsageParams = NonNullable<UsageData["query"]>;
+export declare class Usage extends Resource {
+    /** Requests and seconds by capability, by day and by key: 30 days by default. */
+    get(params?: UsageParams, options?: RequestOptions): Promise<UsageResponse>;
+    /** The plan and the credits left; `null` on no plan. */
+    plan(options?: RequestOptions): Promise<OrgPlan | null>;
+}

package/dist/resources/usage.js

@@ -0,0 +1,16 @@
+/**
+ * `client.usage`: what this organisation spent — `GET /v1/usage` over a
+ * window of days, and `GET /v1/plan`, its plan and balance (`null` with
+ * no subscription). Read-only, unmetered.
+ */
+import { Resource } from "./resource.js";
+export class Usage extends Resource {
+    /** Requests and seconds by capability, by day and by key: 30 days by default. */
+    get(params = {}, options) {
+        return this.send("GET", "/usage", options, params);
+    }
+    /** The plan and the credits left; `null` on no plan. */
+    plan(options) {
+        return this.send("GET", "/plan", options);
+    }
+}

package/dist/resources/voices.d.ts

@@ -0,0 +1,41 @@
+/**
+ * `client.voices`: the voices this organisation may speak with —
+ * `/v1/voices*` — the built-in one, the platform's, and its own, cloned
+ * from a recording or designed from a description.
+ *
+ * - **A voice of its own is a job**: `create`, `saveDesign` and `upload`
+ *   answer it `pending`; `wait(id)` reads it until `ready` or `failed`.
+ * - **`upload(recording, fields)`** is the ticket, the `PUT` and the
+ *   create in one (`upload.ts`); `consent: true` says you may clone it.
+ * - **`design(body)` answers previews, not a voice**: keep one with
+ *   `saveDesign`. It is a provider call held open, and charged.
+ * - **`delete` answers `false` when there was no such voice**: done.
+ */
+import type { VoiceDesignRequest, VoiceDesignResult, VoiceDesignSaveRequest, VoiceDetail, VoiceInfo, VoiceUpdate, VoiceUpload, VoiceUploadRequest, VoiceUploadTicket } from "../gen/index.js";
+import type { RequestOptions } from "../transport.js";
+import { type UploadData, type UploadOptions } from "../upload.js";
+import { Waitable } from "./resource.js";
+/** A recording's voice: the create's fields, and the recording's type. */
+export type VoiceUploadFields = Omit<VoiceUpload, "upload_id"> & {
+    /** A Blob's own type by default: `audio/wav`, `audio/mpeg`, … */
+    content_type?: string;
+};
+/** `update` renames a voice, or changes its description or defaults. */
+export declare class Voices extends Waitable<VoiceDetail, VoiceUpdate, VoiceDetail, boolean> {
+    /** Every voice this organisation may speak with. */
+    list(options?: RequestOptions): Promise<VoiceInfo[]>;
+    /** Clones a recording already `PUT` to its ticket: `pending` at once. */
+    create(body: VoiceUpload, options?: RequestOptions): Promise<VoiceDetail>;
+    /** A signed URL to `PUT` a recording to, with exactly this type. */
+    uploadUrl(body: VoiceUploadRequest, options?: RequestOptions): Promise<VoiceUploadTicket>;
+    /** Uploads a recording and clones it: `uploadUrl`, the `PUT`, `create`. */
+    upload(recording: UploadData, fields: VoiceUploadFields, options?: UploadOptions): Promise<VoiceDetail>;
+    /** Deletes it: `true`, or `false` when there was none by that id (a 204 has no body). */
+    delete(id: string, options?: RequestOptions): Promise<boolean>;
+    /** Speaks its samples again, one per model. */
+    resample(id: string, options?: RequestOptions): Promise<VoiceDetail>;
+    /** Previews of a voice made from a description; charged. */
+    design(body: VoiceDesignRequest, options?: RequestOptions): Promise<VoiceDesignResult>;
+    /** Keeps one preview as a voice: `pending` at once. */
+    saveDesign(body: VoiceDesignSaveRequest, options?: RequestOptions): Promise<VoiceDetail>;
+}

package/dist/resources/voices.js

@@ -0,0 +1,53 @@
+/**
+ * `client.voices`: the voices this organisation may speak with —
+ * `/v1/voices*` — the built-in one, the platform's, and its own, cloned
+ * from a recording or designed from a description.
+ *
+ * - **A voice of its own is a job**: `create`, `saveDesign` and `upload`
+ *   answer it `pending`; `wait(id)` reads it until `ready` or `failed`.
+ * - **`upload(recording, fields)`** is the ticket, the `PUT` and the
+ *   create in one (`upload.ts`); `consent: true` says you may clone it.
+ * - **`design(body)` answers previews, not a voice**: keep one with
+ *   `saveDesign`. It is a provider call held open, and charged.
+ * - **`delete` answers `false` when there was no such voice**: done.
+ */
+import { needType, put, } from "../upload.js";
+import { Waitable } from "./resource.js";
+/** `update` renames a voice, or changes its description or defaults. */
+export class Voices extends Waitable {
+    /** Every voice this organisation may speak with. */
+    list(options) {
+        return this.send("GET", "", options);
+    }
+    /** Clones a recording already `PUT` to its ticket: `pending` at once. */
+    create(body, options) {
+        return this.send("POST", "", options, body);
+    }
+    /** A signed URL to `PUT` a recording to, with exactly this type. */
+    uploadUrl(body, options) {
+        return this.send("POST", "/upload-url", options, body);
+    }
+    /** Uploads a recording and clones it: `uploadUrl`, the `PUT`, `create`. */
+    async upload(recording, fields, options = {}) {
+        const { content_type, ...body } = fields;
+        const ticket = await this.uploadUrl({ content_type: needType(recording, content_type) }, options);
+        await put(this.api, ticket, recording, ticket.content_type, options);
+        return this.settled(await this.create({ ...body, upload_id: ticket.upload_id }, options), options);
+    }
+    /** Deletes it: `true`, or `false` when there was none by that id (a 204 has no body). */
+    async delete(id, options) {
+        return (await super.delete(id, options)) !== null;
+    }
+    /** Speaks its samples again, one per model. */
+    resample(id, options) {
+        return this.send("POST", this.at(id, "/sample"), options);
+    }
+    /** Previews of a voice made from a description; charged. */
+    design(body, options) {
+        return this.send("POST", "/design", options, body);
+    }
+    /** Keeps one preview as a voice: `pending` at once. */
+    saveDesign(body, options) {
+        return this.send("POST", "/design/save", options, body);
+    }
+}

package/dist/runtime.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Where this SDK refuses to run: anywhere an end user's device holds it.
+ *
+ * It carries the organisation's API key, which spends the whole balance
+ * and reads every end user. **The API cannot be the wall**: its CORS
+ * allows every origin (`apps/api/src/http/cors.ts`) and the console sends
+ * an org's key from the browser itself. So the SDK is: the package's
+ * `browser` and `react-native` export conditions resolve to `refuse.js`
+ * (a bundler fails), and `createClient` checks again here for a bundle
+ * that took the plain file anyway. **No escape hatch** — a device talks to
+ * agents with an ephemeral key, through `@lumavox/client`.
+ */
+export declare const REFUSAL: string;
+interface Globals {
+    document?: unknown;
+    navigator?: {
+        product?: unknown;
+    };
+}
+/** Why this runtime may not hold an API key — `null` on a server. */
+export declare function refusedHere(globals?: Globals): string | null;
+export {};

package/dist/runtime.js

@@ -0,0 +1,24 @@
+/**
+ * Where this SDK refuses to run: anywhere an end user's device holds it.
+ *
+ * It carries the organisation's API key, which spends the whole balance
+ * and reads every end user. **The API cannot be the wall**: its CORS
+ * allows every origin (`apps/api/src/http/cors.ts`) and the console sends
+ * an org's key from the browser itself. So the SDK is: the package's
+ * `browser` and `react-native` export conditions resolve to `refuse.js`
+ * (a bundler fails), and `createClient` checks again here for a bundle
+ * that took the plain file anyway. **No escape hatch** — a device talks to
+ * agents with an ephemeral key, through `@lumavox/client`.
+ */
+export const REFUSAL = "@lumavox/server holds your organisation's API key, so it runs only on " +
+    "your server: never in a browser or a React Native app. Mint an end " +
+    "user an ephemeral key on your server (ephemeralKeys.create) and use " +
+    "@lumavox/client on the device.";
+/** Why this runtime may not hold an API key — `null` on a server. */
+export function refusedHere(globals = globalThis) {
+    if (typeof globals.document !== "undefined")
+        return "a browser";
+    if (globals.navigator?.product === "ReactNative")
+        return "React Native";
+    return null;
+}

package/dist/stream.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Every line of `body`, parsed, as it arrives. Its chunks are typed as the
+ * decoder takes them — the DOM's types and Workers' disagree on what a
+ * `TextDecoderStream` writes from, and a `Uint8Array` is both.
+ */
+export declare function ndjson<T>(body: ReadableStream<BufferSource>, requestId: string): AsyncGenerator<T, void, undefined>;

package/dist/stream.js

@@ -0,0 +1,37 @@
+/**
+ * Newline-delimited JSON, as `POST /v1/stt` with `stream=true` answers it:
+ * one event a line, read as the lines arrive — a `segment` as each piece
+ * is cut, its `transcript` (or `error`) in order, and a `done` with the
+ * whole text.
+ *
+ * **An iterator left early hangs up**: `break` cancels the body, so the
+ * API sees its caller go, as it does any stream abandoned half way.
+ */
+import { parsed } from "./transport.js";
+/**
+ * Every line of `body`, parsed, as it arrives. Its chunks are typed as the
+ * decoder takes them — the DOM's types and Workers' disagree on what a
+ * `TextDecoderStream` writes from, and a `Uint8Array` is both.
+ */
+export async function* ndjson(body, requestId) {
+    const reader = body.pipeThrough(new TextDecoderStream()).getReader();
+    let rest = "";
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            const lines = (rest + (value ?? "")).split("\n");
+            rest = done ? "" : lines.pop();
+            for (const line of lines) {
+                if (line.trim())
+                    yield parsed(line, 200, requestId);
+            }
+            if (done)
+                return;
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => {
+            // swallowed: a body already ended or failed has nothing to cancel.
+        });
+    }
+}

package/dist/transport.d.ts

@@ -0,0 +1,83 @@
+/** What `fetch` the client calls: the global one, or the caller's. */
+export type Fetch = (url: string, init: RequestInit) => Promise<Response>;
+/** Options any call takes, in its last argument. */
+export interface RequestOptions {
+    /** Per attempt; the client's `timeoutMs` (30 s) by default. */
+    timeoutMs?: number;
+    /** Aborts the call, its retries and their waits. */
+    signal?: AbortSignal;
+    /** The client's `maxRetries` (2) by default; `0` sends once. */
+    maxRetries?: number;
+    /** Sent as `X-Request-Id` on every attempt; one is made when absent. */
+    requestId?: string;
+}
+export interface TransportConfig {
+    apiKey: string;
+    baseUrl: string;
+    timeoutMs: number;
+    maxRetries: number;
+    fetch: Fetch;
+}
+export type Query = Record<string, string | number | boolean | null | undefined>;
+export type Method = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+/** One call, as a method describes it. */
+export interface Call {
+    method: Method;
+    /** With its parameters already encoded (`segment`); or a whole URL. */
+    path: string;
+    query?: Query;
+    /** A JSON body. */
+    body?: unknown;
+    /** A body sent as it is, with `type` as its `Content-Type`. */
+    raw?: BodyInit;
+    type?: string;
+    headers?: Record<string, string>;
+    /** The answer's bytes, or its body unread; JSON by default. */
+    read?: "bytes" | "stream";
+    /** No credential: the open routes, and object storage's signed URLs. */
+    open?: boolean;
+    /** A POST that may be sent twice with the same effect. */
+    idempotent?: boolean;
+    /** Another bearer for this call: an end user's ephemeral key. */
+    token?: string;
+}
+export interface Answer<T> {
+    data: T;
+    status: number;
+    headers: Headers;
+    requestId: string;
+}
+/** The longest `Retry-After` slept through; past it the 429 is thrown. */
+export declare const MAX_RETRY_AFTER_S = 60;
+/** A path parameter or a query's value, encoded: an `external_id` may hold `/` or `?`. */
+export declare const segment: (value: string | number | boolean) => string;
+/**
+ * A request id of the API's own shape: 16 hex. From `Math.random`, not
+ * `crypto`, which React Native lacks (this file is the client SDK's too):
+ * an id names a call in the logs and is no secret.
+ */
+export declare const newRequestId: () => string;
+/**
+ * How long to wait before retry `attempt` (1, 2, …): the doubling backoff
+ * less up to a quarter, or `Retry-After`'s seconds when the API sent one.
+ */
+export declare function retryDelayMs(attempt: number, retryAfter: number | null, random?: () => number): number;
+/** Waits `ms`, or rejects with the signal's reason when it aborts first. */
+export declare function sleep(ms: number, signal: AbortSignal | undefined): Promise<void>;
+/** A 2xx body: JSON, or nothing. Anything else is not the API answering. */
+export declare function parsed<T>(text: string, status: number, requestId: string): T;
+/** `promise`'s value, or `null` when it is a 404: what is not there is done. */
+export declare const orNull: <T>(promise: Promise<T>) => Promise<T | null>;
+export declare class Transport {
+    private readonly config;
+    constructor(config: TransportConfig);
+    /** A JSON call's answer: `data` is a GET's query and any other's body. */
+    send<T>(method: Method, path: string, options?: RequestOptions, data?: unknown): Promise<T>;
+    request<T>(call: Call, options?: RequestOptions): Promise<Answer<T>>;
+    private url;
+    /**
+     * One send and its body read, under this attempt's timer — which stops
+     * at the headers of a stream the caller reads (and of nothing else).
+     */
+    private attempt;
+}

package/dist/transport.js

@@ -0,0 +1,236 @@
+/**
+ * One HTTP call to the API, with everything every method shares: the
+ * credential, the request id, the timeout, the retries and the errors.
+ *
+ * - **One request id per call** (16 hex, as the API mints its own), sent
+ *   as `X-Request-Id` and **reused on every retry**: the API keeps a valid
+ *   one (`apps/api/src/http/request-id.ts`), so every attempt of a call
+ *   shares one id in Workers Logs and in the error the caller sees.
+ * - **The timeout is per attempt**, a timer joined with the caller's
+ *   `signal`, and it covers reading the body — **except a stream's**,
+ *   whose timer stops at the headers: a transcript streamed for minutes
+ *   is not a call that timed out. The caller's abort is theirs: it is
+ *   thrown as their reason and never retried, and it still ends a stream.
+ * - **Not every body is JSON**: speech is bytes or a stream, `/v1/stt`
+ *   takes the audio raw, and an upload's `PUT` goes to object storage's
+ *   own URL with no credential (`open`) — the same attempts, retries and
+ *   errors. A body that is a stream is sent once: it cannot be read twice.
+ * - **What is retried is what cannot have done anything twice.** GET, PUT,
+ *   PATCH and DELETE: a connection that failed, a timeout, 429, 502, 503,
+ *   504. A POST: only a 429, which the API answers at admission before any
+ *   work — unless the method says the POST is idempotent
+ *   (`POST /v1/end-users` with an `external_id`). Never a 500: whatever
+ *   failed may have half-happened.
+ * - **The wait** doubles from 0.5 s to 8 s, less up to a quarter at random
+ *   so callers refused together do not return together; `Retry-After`
+ *   wins, up to a minute. A longer one is thrown at once as a
+ *   `RateLimitError` with its `retryAfter`: a call that sleeps for an hour
+ *   is not one a caller can reason about.
+ * - **The client SDK runs this file too** (`sdks/client/src/transport.ts`,
+ *   a copy its `test/copies.test.ts` holds identical), on React Native's
+ *   Hermes as well: so no `crypto`, `URLSearchParams`, `AbortSignal.any`
+ *   or global `ReadableStream` taken for granted, each of which it lacks.
+ */
+import { ConnectionError, errorFromResponse, NotFoundError, PlatformError, TimeoutError, } from "./errors.js";
+const RETRIED_STATUS = new Set([429, 502, 503, 504]);
+const BASE_DELAY_MS = 500;
+const MAX_DELAY_MS = 8_000;
+/** The longest `Retry-After` slept through; past it the 429 is thrown. */
+export const MAX_RETRY_AFTER_S = 60;
+/** A path parameter or a query's value, encoded: an `external_id` may hold `/` or `?`. */
+export const segment = (value) => encodeURIComponent(value);
+/**
+ * A request id of the API's own shape: 16 hex. From `Math.random`, not
+ * `crypto`, which React Native lacks (this file is the client SDK's too):
+ * an id names a call in the logs and is no secret.
+ */
+export const newRequestId = () => "x".repeat(16).replace(/x/g, () => ((Math.random() * 16) | 0).toString(16));
+/**
+ * How long to wait before retry `attempt` (1, 2, …): the doubling backoff
+ * less up to a quarter, or `Retry-After`'s seconds when the API sent one.
+ */
+export function retryDelayMs(attempt, retryAfter, random = Math.random) {
+    if (retryAfter !== null)
+        return Math.ceil(retryAfter * 1000);
+    const full = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * 2 ** (attempt - 1));
+    return Math.round(full * (1 - 0.25 * random()));
+}
+/** Waits `ms`, or rejects with the signal's reason when it aborts first. */
+export function sleep(ms, signal) {
+    if (ms <= 0)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted)
+            return reject(signal.reason);
+        const done = () => {
+            signal?.removeEventListener("abort", stop);
+            resolve();
+        };
+        const timer = setTimeout(done, ms);
+        const stop = () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        };
+        signal?.addEventListener("abort", stop, { once: true });
+    });
+}
+/** A 2xx body: JSON, or nothing. Anything else is not the API answering. */
+export function parsed(text, status, requestId) {
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch (cause) {
+        throw new PlatformError({
+            status,
+            type: "invalid_response",
+            message: `HTTP ${status} with a body that is not JSON.`,
+            requestId,
+            cause,
+        });
+    }
+}
+/** `promise`'s value, or `null` when it is a 404: what is not there is done. */
+export const orNull = (promise) => promise.catch((error) => {
+    if (error instanceof NotFoundError)
+        return null;
+    throw error;
+});
+export class Transport {
+    constructor(config) {
+        this.config = config;
+    }
+    /** A JSON call's answer: `data` is a GET's query and any other's body. */
+    send(method, path, options, data) {
+        return this.request(method === "GET"
+            ? { method, path, query: data }
+            : { method, path, body: data }, options).then((answer) => answer.data);
+    }
+    async request(call, options = {}) {
+        const requestId = options.requestId ?? newRequestId();
+        // A stream by its shape: not every runtime has a global `ReadableStream`.
+        const once = "getReader" in Object(call.raw);
+        const maxRetries = once
+            ? 0
+            : (options.maxRetries ?? this.config.maxRetries);
+        const retriesAll = call.method !== "POST" || call.idempotent === true;
+        const url = this.url(call);
+        const headers = {
+            Accept: call.read ? "*/*" : "application/json",
+            "X-Request-Id": requestId,
+            ...call.headers,
+        };
+        if (!call.open) {
+            headers.Authorization = `Bearer ${call.token ?? this.config.apiKey}`;
+        }
+        let body = call.raw;
+        if (call.type)
+            headers["Content-Type"] = call.type;
+        if (call.body !== undefined) {
+            headers["Content-Type"] = "application/json";
+            body = JSON.stringify(call.body);
+        }
+        const init = { method: call.method, headers, body };
+        // Node's fetch sends a stream only when told it is one-way.
+        if (once)
+            Object.assign(init, { duplex: "half" });
+        for (let attempt = 0;; attempt++) {
+            const outcome = await this.attempt(url, init, call.read, options);
+            const last = attempt >= maxRetries;
+            if (outcome.kind === "response") {
+                const { response, body: read } = outcome;
+                if (response.ok) {
+                    return {
+                        data: call.read
+                            ? read
+                            : parsed(read, response.status, requestId),
+                        status: response.status,
+                        headers: response.headers,
+                        requestId,
+                    };
+                }
+                const error = errorFromResponse(response.status, response.headers, read, requestId);
+                const retried = response.status === 429 ||
+                    (retriesAll && RETRIED_STATUS.has(response.status));
+                if (last || !retried || (error.retryAfter ?? 0) > MAX_RETRY_AFTER_S) {
+                    throw error;
+                }
+                await sleep(retryDelayMs(attempt + 1, error.retryAfter), options.signal);
+                continue;
+            }
+            if (last || !retriesAll) {
+                throw outcome.kind === "timeout"
+                    ? new TimeoutError({
+                        status: 0,
+                        type: "timeout",
+                        message: "The API did not answer in time.",
+                        requestId,
+                    })
+                    : new ConnectionError({
+                        status: 0,
+                        type: "connection_error",
+                        message: "Could not reach the API.",
+                        requestId,
+                        cause: outcome.error,
+                    });
+            }
+            await sleep(retryDelayMs(attempt + 1, null), options.signal);
+        }
+    }
+    url(call) {
+        // By hand: React Native's `URLSearchParams` is partial.
+        let query = "";
+        for (const [key, value] of Object.entries(call.query ?? {})) {
+            if (value != null) {
+                query += `${query ? "&" : "?"}${key}=${segment(value)}`;
+            }
+        }
+        const base = /^https?:/.test(call.path) ? "" : this.config.baseUrl;
+        return base + call.path + query;
+    }
+    /**
+     * One send and its body read, under this attempt's timer — which stops
+     * at the headers of a stream the caller reads (and of nothing else).
+     */
+    async attempt(url, init, read, options) {
+        // The caller's signal joined to the timer by hand, its reason carried
+        // over: `AbortSignal.any` is not React Native's. Left joined for a
+        // stream, whose body the caller's abort still ends.
+        const { signal } = options;
+        const timer = new AbortController();
+        const stop = () => timer.abort(signal?.reason);
+        const clock = setTimeout(stop, options.timeoutMs ?? this.config.timeoutMs);
+        signal?.addEventListener("abort", stop);
+        // Already aborted: no event will come, and `fetch` sends nothing.
+        if (signal?.aborted)
+            stop();
+        try {
+            const response = await this.config.fetch(url, {
+                ...init,
+                signal: timer.signal,
+            });
+            const body = !response.ok
+                ? await response.text()
+                : read === "stream"
+                    ? response.body
+                    : read === "bytes"
+                        ? await response.arrayBuffer()
+                        : await response.text();
+            return { kind: "response", response, body };
+        }
+        catch (error) {
+            // The caller's abort is the caller's, whatever else happened.
+            if (signal?.aborted)
+                throw signal.reason;
+            if (timer.signal.aborted)
+                return { kind: "timeout" };
+            return { kind: "network", error };
+        }
+        finally {
+            clearTimeout(clock);
+            if (read !== "stream")
+                signal?.removeEventListener("abort", stop);
+        }
+    }
+}