@lumavox/server 0.2.1 → 0.4.0

package/dist/resources/generations.d.ts

@@ -15,7 +15,7 @@
  * - **Each read sees its own capability**: an image's id is a 404 on
  *   `videos.get`. `generations.get` reads any the key may generate.
  */
-import type { GenerationInfo, GenerationPage, ListGenerationsData, SkyboxStyle } from "../gen/index.js";
+import type { GenerationInfo, GenerationPage, ListGenerationsData, SkyboxStylePage } from "../gen/index.js";
 import type { RequestOptions } from "../transport.js";
 import { Polled } from "./resource.js";
 export type GenerationListParams = NonNullable<ListGenerationsData["query"]>;
@@ -28,8 +28,8 @@ export declare class Jobs<Body> extends Polled<GenerationInfo> {
 }
 /** `/v1/skybox`, and the provider's styles. */
 export declare class Skybox<Body> extends Jobs<Body> {
-    /** The styles available now, each with its `style_id`; empty when the provider is unreachable. */
-    styles(options?: RequestOptions): Promise<SkyboxStyle[]>;
+    /** The styles available now, in one page: each `id` is a `style_id`; none when the provider is unreachable. */
+    styles(options?: RequestOptions): Promise<SkyboxStylePage>;
 }
 /** Every generation the key may make, read-only. */
 export declare class Generations extends Polled<GenerationInfo> {

package/dist/resources/generations.js

@@ -15,10 +15,9 @@
  * - **Each read sees its own capability**: an image's id is a 404 on
  *   `videos.get`. `generations.get` reads any the key may generate.
  */
-import { byCursor } from "../paging.js";
 import { poll } from "../wait.js";
 import { Polled } from "./resource.js";
-/** The route's own page bound. */
+/** The route's largest page. */
 const PAGE = 100;
 /** One capability's queue: `/v1/images`, `/v1/videos`, … */
 export class Jobs extends Polled {
@@ -34,7 +33,7 @@ export class Jobs extends Polled {
 }
 /** `/v1/skybox`, and the provider's styles. */
 export class Skybox extends Jobs {
-    /** The styles available now, each with its `style_id`; empty when the provider is unreachable. */
+    /** The styles available now, in one page: each `id` is a `style_id`; none when the provider is unreachable. */
     styles(options) {
         return this.send("GET", "/styles", options);
     }
@@ -47,9 +46,6 @@ export class Generations extends Polled {
     }
     /** Every generation, newest first, page after page (100 a page by default). */
     list(params = {}, options) {
-        return byCursor(async (cursor) => {
-            const page = await this.page({ limit: PAGE, ...params, cursor }, options);
-            return { items: page.generations, next: page.next_cursor };
-        });
+        return this.each("", params, options, PAGE);
     }
 }

package/dist/resources/knowledge.d.ts

@@ -10,27 +10,26 @@
  * - **`upload(file, fields)`** is the ticket, the `PUT` and `fromFile` in
  *   one (`upload.ts`); the file's extension says how it is read, 10 MB at
  *   most.
- * - **`list()` pages by offset**, 200 a page, with the `total` the filter
- *   matches.
+ * - **`list()` pages by cursor**, 200 a page.
  * - **`update` with `expected_version`** refuses an edit made over
- *   somebody else's (409); `delete` answers the entry as it was, and
- *   `null` for one already gone.
+ *   somebody else's (409); `delete` answers `true`, and `false` for one
+ *   already gone.
  */
-import type { KnowledgeAssigned, KnowledgeAssignment, KnowledgeBulk, KnowledgeBulkResult, KnowledgeCategories, KnowledgeCreate, KnowledgeFileCreate, KnowledgeInfo, KnowledgeInsights, KnowledgeInsightsData, KnowledgeSearchList, KnowledgeSearchRequest, KnowledgeSearchResult, KnowledgeUpdate, KnowledgeUploadRequest, KnowledgeUploadTicket, KnowledgeUrlCreate, ListKnowledgeData } from "../gen/index.js";
+import type { GetKnowledgeInsightsData, KnowledgeAgentsUpdate, KnowledgeAssigned, KnowledgeBulk, KnowledgeBulkResult, KnowledgeCategoryPage, KnowledgeCreate, KnowledgeFileCreate, KnowledgeInfo, KnowledgeInsights, KnowledgePage, KnowledgeSearchRequest, KnowledgeSearchResult, KnowledgeUpdate, KnowledgeUploadRequest, KnowledgeUploadTicket, KnowledgeUrlCreate, ListKnowledgeData } from "../gen/index.js";
 import type { RequestOptions } from "../transport.js";
 import { type UploadData, type UploadOptions } from "../upload.js";
 import { Waitable } from "./resource.js";
 export type KnowledgeListParams = NonNullable<ListKnowledgeData["query"]>;
-export type KnowledgeInsightsParams = NonNullable<KnowledgeInsightsData["query"]>;
+export type KnowledgeInsightsParams = NonNullable<GetKnowledgeInsightsData["query"]>;
 /** A file's entry: `fromFile`'s fields, and its type when not its extension's. */
 export type KnowledgeUploadFields = Omit<KnowledgeFileCreate, "upload_id"> & {
     content_type?: string | null;
 };
 export declare class Knowledge extends Waitable<KnowledgeInfo, KnowledgeUpdate> {
-    /** One page, with the `total` the filter matches. */
-    page(params?: KnowledgeListParams, options?: RequestOptions): Promise<KnowledgeSearchList>;
+    /** One page, with the `next_cursor` of the next. */
+    page(params?: KnowledgeListParams, options?: RequestOptions): Promise<KnowledgePage>;
     /** Every entry the filter matches, page after page (200 a page by default). */
-    list(params?: Omit<KnowledgeListParams, "offset">, options?: RequestOptions): AsyncGenerator<KnowledgeInfo, void, undefined>;
+    list(params?: Omit<KnowledgeListParams, "cursor">, options?: RequestOptions): AsyncGenerator<KnowledgeInfo, void, undefined>;
     /** A written entry, indexed after it is saved. */
     create(body: KnowledgeCreate, options?: RequestOptions): Promise<KnowledgeInfo>;
     /** Many written entries at once: what was made, and what was refused. */
@@ -48,11 +47,11 @@ export declare class Knowledge extends Waitable<KnowledgeInfo, KnowledgeUpdate>
     /** Reads its page again now. */
     refresh(id: string, options?: RequestOptions): Promise<KnowledgeInfo>;
     /** Replaces the agents that may look it up. */
-    setAgents(id: string, body: KnowledgeAssignment, options?: RequestOptions): Promise<KnowledgeAssigned>;
+    setAgents(id: string, body: KnowledgeAgentsUpdate, options?: RequestOptions): Promise<KnowledgeAssigned>;
     /** What an agent would find for a question. */
     search(body: KnowledgeSearchRequest, options?: RequestOptions): Promise<KnowledgeSearchResult>;
-    /** The categories in use. */
-    categories(options?: RequestOptions): Promise<KnowledgeCategories>;
+    /** The categories in use, in one page. */
+    categories(options?: RequestOptions): Promise<KnowledgeCategoryPage>;
     /** What was looked up, and what went unanswered: 7 days by default. */
     insights(params?: KnowledgeInsightsParams, options?: RequestOptions): Promise<KnowledgeInsights>;
 }

package/dist/resources/knowledge.js

@@ -10,28 +10,23 @@
  * - **`upload(file, fields)`** is the ticket, the `PUT` and `fromFile` in
  *   one (`upload.ts`); the file's extension says how it is read, 10 MB at
  *   most.
- * - **`list()` pages by offset**, 200 a page, with the `total` the filter
- *   matches.
+ * - **`list()` pages by cursor**, 200 a page.
  * - **`update` with `expected_version`** refuses an edit made over
- *   somebody else's (409); `delete` answers the entry as it was, and
- *   `null` for one already gone.
+ *   somebody else's (409); `delete` answers `true`, and `false` for one
+ *   already gone.
  */
-import { byOffset } from "../paging.js";
 import { put, sizeOf, typeOf, } from "../upload.js";
 import { Waitable } from "./resource.js";
-/** The route's own page bound. */
+/** The route's largest page. */
 const PAGE = 200;
 export class Knowledge extends Waitable {
-    /** One page, with the `total` the filter matches. */
+    /** One page, with the `next_cursor` of the next. */
     page(params = {}, options) {
         return this.send("GET", "", options, params);
     }
     /** Every entry the filter matches, page after page (200 a page by default). */
     list(params = {}, options) {
-        return byOffset(async (offset, limit) => {
-            const page = await this.page({ ...params, offset, limit }, options);
-            return { items: page.entries, total: page.total };
-        }, params.limit ?? PAGE);
+        return this.each("", params, options, PAGE);
     }
     /** A written entry, indexed after it is saved. */
     create(body, options) {
@@ -58,7 +53,7 @@ export class Knowledge extends Waitable {
         const { content_type, ...body } = fields;
         const ticket = await this.uploadUrl({
             filename: body.filename,
-            size: sizeOf(file, options.size) ?? null,
+            size_bytes: sizeOf(file, options.size) ?? null,
             content_type: typeOf(file, content_type) || null,
         }, options);
         await put(this.api, ticket, file, ticket.content_type, options);
@@ -80,7 +75,7 @@ export class Knowledge extends Waitable {
     search(body, options) {
         return this.send("POST", "/search", options, body);
     }
-    /** The categories in use. */
+    /** The categories in use, in one page. */
     categories(options) {
         return this.send("GET", "/categories", options);
     }

package/dist/resources/resource.d.ts

@@ -1,21 +1,3 @@
-/**
- * What every resource shares, as a ladder of bases each method is written
- * once in — the SDK's size is a budget (`test/dist.test.ts`):
- *
- * - **`Resource`**: the transport, and the path its routes start with.
- *   `send` takes the rest of the path, and `at(id)` is one item's, the id
- *   encoded (an id the caller holds may carry `/` or `?`).
- * - **`Readable`**: `get(id)`; **`Polled`** adds `wait(id)` (`wait.ts`),
- *   for a generation, which is read and waited on and nothing else.
- * - **`Editable`**: `update(id, body)` (`PATCH`) and `delete(id)`, which
- *   answers `null` when there is nothing by that id — already done.
- * - **`Waitable`**: an editable whose items are jobs — a voice, an asset,
- *   a knowledge entry — with `wait(id)` and `settled`, which an upload
- *   answers through.
- *
- * Fields are `declare`d, not defined: each is assigned in a constructor,
- * and a definition is bytes in every customer's bundle.
- */
 import { type Method, type RequestOptions, type Transport } from "../transport.js";
 import type { UploadOptions } from "../upload.js";
 import { type Job } from "../wait.js";
@@ -27,6 +9,12 @@ export declare class Resource {
     protected send<T>(method: Method, rest: string, options?: RequestOptions, data?: unknown): Promise<T>;
     /** The rest of item `id`'s path, and of what follows it. */
     protected at(id: string, rest?: string): string;
+    /**
+     * Every item of the list at `base` + `rest`, page after page: `query`,
+     * then each page's cursor. `limit` is the route's largest page unless
+     * the query names one — fewer calls for a long list.
+     */
+    protected each<T>(rest: string, query?: object, options?: RequestOptions, limit?: number): AsyncGenerator<T, void, undefined>;
 }
 export declare class Readable<Item> extends Resource {
     /** One of them. A `NotFoundError` when there is none. */
@@ -36,15 +24,17 @@ export declare class Polled<Item extends Job> extends Readable<Item> {
     /** Reads it until its `status` is final (`wait.ts`). */
     wait(id: string, options?: RequestOptions): Promise<Item>;
 }
-export declare class Editable<Item, Update, Updated = Item, Deleted = Item> extends Readable<Item> {
+export declare class Editable<Item, Update, Updated = Item, Deleted = boolean> extends Readable<Item> {
     /** Changes what `body` gives; absent fields are untouched. */
     update(id: string, body: Update, options?: RequestOptions): Promise<Updated>;
-    /** Deletes it; `null` when there is none by that id — already done. */
-    delete(id: string, options?: RequestOptions): Promise<Deleted | null>;
+    /** Deletes it: `true`, or `false` when there is none by that id — already done. */
+    delete(id: string, options?: RequestOptions): Promise<Deleted>;
+    /** The `DELETE` itself: its answer, `undefined` for a 204, `null` for a 404. */
+    protected drop<T>(id: string, options?: RequestOptions): Promise<T | null>;
 }
 export declare class Waitable<Item extends Job & {
     id: string;
-}, Update, Updated = Item, Deleted = Item> extends Editable<Item, Update, Updated, Deleted> {
+}, Update, Updated = Item> extends Editable<Item, Update, Updated> {
     /** Reads it until its `status` is final (`wait.ts`). */
     wait(id: string, options?: RequestOptions): Promise<Item>;
     /** `item` as made, or as it ended when `options.wait` says to wait. */

package/dist/resources/resource.js

@@ -4,11 +4,15 @@
  *
  * - **`Resource`**: the transport, and the path its routes start with.
  *   `send` takes the rest of the path, and `at(id)` is one item's, the id
- *   encoded (an id the caller holds may carry `/` or `?`).
+ *   encoded (an id the caller holds may carry `/` or `?`). `each` is a
+ *   list's every item, page after page (`paging.ts`).
  * - **`Readable`**: `get(id)`; **`Polled`** adds `wait(id)` (`wait.ts`),
  *   for a generation, which is read and waited on and nothing else.
- * - **`Editable`**: `update(id, body)` (`PATCH`) and `delete(id)`, which
- *   answers `null` when there is nothing by that id — already done.
+ * - **`Editable`**: `update(id, body)` (`PATCH`) and `delete(id)`. A
+ *   delete of one thing is a 204 with no body, so it answers `true`, and
+ *   `false` when there is nothing by that id — already done. One that
+ *   reports what went with it (an end user's, a folder's) answers those
+ *   counts, and `null` for nothing by that id: the same rule, with a body.
  * - **`Waitable`**: an editable whose items are jobs — a voice, an asset,
  *   a knowledge entry — with `wait(id)` and `settled`, which an upload
  *   answers through.
@@ -16,6 +20,7 @@
  * Fields are `declare`d, not defined: each is assigned in a constructor,
  * and a definition is bytes in every customer's bundle.
  */
+import { pages } from "../paging.js";
 import { orNull, segment, } from "../transport.js";
 import { poll } from "../wait.js";
 export class Resource {
@@ -31,6 +36,14 @@ export class Resource {
     at(id, rest = "") {
         return `/${segment(id)}${rest}`;
     }
+    /**
+     * Every item of the list at `base` + `rest`, page after page: `query`,
+     * then each page's cursor. `limit` is the route's largest page unless
+     * the query names one — fewer calls for a long list.
+     */
+    each(rest, query, options, limit) {
+        return pages((cursor) => this.send("GET", rest, options, { limit, ...query, cursor }));
+    }
 }
 export class Readable extends Resource {
     /** One of them. A `NotFoundError` when there is none. */
@@ -49,8 +62,12 @@ export class Editable extends Readable {
     update(id, body, options) {
         return this.send("PATCH", this.at(id), options, body);
     }
-    /** Deletes it; `null` when there is none by that id — already done. */
+    /** Deletes it: `true`, or `false` when there is none by that id — already done. */
     delete(id, options) {
+        return this.drop(id, options).then((gone) => gone !== null);
+    }
+    /** The `DELETE` itself: its answer, `undefined` for a 204, `null` for a 404. */
+    drop(id, options) {
         return orNull(this.send("DELETE", this.at(id), options));
     }
 }

package/dist/resources/speech.d.ts

@@ -6,10 +6,10 @@
  *
  * - **`tts.create(body)` answers the audio whole** (an `ArrayBuffer`, WAV
  *   or raw `pcm`) **or, with `stream: true`, as it is made** (a
- *   `ReadableStream` of `pcm`), beside what its headers say. A whole
- *   answer names its sample rate (`X-Sample-Rate`); a stream names none,
- *   so its rate is the one asked for, 24 000 Hz unset (the API's default,
- *   `@ino/core/speech/catalog`; left-overs #111).
+ *   `ReadableStream` of `pcm`), beside what its headers say. Both name
+ *   their sample rate (`X-Sample-Rate`); a stream from an API before
+ *   0.31.10 named none, so without the header its rate is the one asked
+ *   for, 24 000 Hz unset (the API's default, `@ino/core/speech/catalog`).
  * - **`stt.create(audio, params)` sends the audio as the body**, the
  *   options as the query — the route's raw form, which a stream can be
  *   sent as, unlike a multipart one. It answers the transcript, or with
@@ -17,7 +17,7 @@
  *   only). Up to 25 MB.
  * - **A stream's timeout ends at its headers**; `signal` still ends it.
  */
-import type { StreamDone, StreamError, StreamSegment, StreamTranscript, TranscribeData, TranscriptWord, TtsRequest } from "../gen/index.js";
+import type { TranscribeData, Transcription, TranscriptionStreamLine, TtsRequest } from "../gen/index.js";
 import type { RequestOptions } from "../transport.js";
 import { type UploadData } from "../upload.js";
 import { Resource } from "./resource.js";
@@ -51,23 +51,12 @@ export type SttParams = Omit<TranscribeData["body"], "file"> & {
     content_type?: string;
 };
 /**
- * `POST /v1/stt`'s whole answer. The document declares no schema for it
- * (left-overs #112), so this is the route's own (`transcript()` in
- * `apps/api/src/routes/stt.ts`), written out; `apps/api/test/sdk.test.ts`
- * holds the two together.
+ * `POST /v1/stt`'s whole answer, as the document declares it since api
+ * 0.31.10 (`Transcription`). The name the SDK has always exported.
  */
-export interface Transcript {
-    text: string;
-    language_code: string | null;
-    language_probability: number | null;
-    /** What was charged, per minute. */
-    duration_seconds: number;
-    model: string;
-    /** With `timestamps: true`; `null` otherwise. */
-    words: TranscriptWord[] | null;
-}
-/** One line of a streamed transcript. */
-export type SttEvent = StreamSegment | StreamTranscript | StreamError | StreamDone;
+export type Transcript = Transcription;
+/** One line of a streamed transcript: a `segment`, its `transcript` or `error`, and the `done`. */
+export type SttEvent = TranscriptionStreamLine;
 export declare class Stt extends Resource {
     /** The transcript as it is made: an iterator of its events. */
     create(audio: UploadData, params: SttParams & {

package/dist/resources/speech.js

@@ -6,10 +6,10 @@
  *
  * - **`tts.create(body)` answers the audio whole** (an `ArrayBuffer`, WAV
  *   or raw `pcm`) **or, with `stream: true`, as it is made** (a
- *   `ReadableStream` of `pcm`), beside what its headers say. A whole
- *   answer names its sample rate (`X-Sample-Rate`); a stream names none,
- *   so its rate is the one asked for, 24 000 Hz unset (the API's default,
- *   `@ino/core/speech/catalog`; left-overs #111).
+ *   `ReadableStream` of `pcm`), beside what its headers say. Both name
+ *   their sample rate (`X-Sample-Rate`); a stream from an API before
+ *   0.31.10 named none, so without the header its rate is the one asked
+ *   for, 24 000 Hz unset (the API's default, `@ino/core/speech/catalog`).
  * - **`stt.create(audio, params)` sends the audio as the body**, the
  *   options as the query — the route's raw form, which a stream can be
  *   sent as, unlike a multipart one. It answers the transcript, or with

package/dist/resources/templates.d.ts

@@ -11,7 +11,7 @@
  * - **`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 { GenerationInfo, TemplateGenerateRequest, TemplateInfo, TemplatePage } from "../gen/index.js";
 import { type RequestOptions, type Transport } from "../transport.js";
 import type { Generations } from "./generations.js";
 import { Readable } from "./resource.js";
@@ -24,8 +24,10 @@ export interface TemplateFile {
 export declare class Templates extends Readable<TemplateInfo> {
     private readonly generations;
     constructor(api: Transport, base: string, generations: Generations);
+    /** The page of templates, as the route answers it: all of them, `next_cursor` `null`. */
+    page(options?: RequestOptions): Promise<TemplatePage>;
     /** Every template this organisation may generate from. */
-    list(options?: RequestOptions): Promise<TemplateList>;
+    list(options?: RequestOptions): AsyncGenerator<TemplateInfo, void, undefined>;
     /** 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. */

package/dist/resources/templates.js

@@ -20,9 +20,13 @@ export class Templates extends Readable {
         super(api, base);
         this.generations = generations;
     }
+    /** The page of templates, as the route answers it: all of them, `next_cursor` `null`. */
+    page(options) {
+        return this.send("GET", "", options);
+    }
     /** Every template this organisation may generate from. */
     list(options) {
-        return this.send("GET", "", options);
+        return this.each("", {}, options);
     }
     /** Generates from it, charged when accepted: the `gen_…` at once. */
     create(id, body = {}, options) {

package/dist/resources/usage.d.ts

@@ -3,10 +3,10 @@
  * 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 { GetUsageData, OrgPlan, UsageResponse } from "../gen/index.js";
 import type { RequestOptions } from "../transport.js";
 import { Resource } from "./resource.js";
-export type UsageParams = NonNullable<UsageData["query"]>;
+export type UsageParams = NonNullable<GetUsageData["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>;

package/dist/resources/voices.d.ts

@@ -9,9 +9,11 @@
  *   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.
+ * - **`delete` answers `true`**, and `false` when there was no such
+ *   voice: done.
+ * - **`list()` reads one page**: the route answers every voice in it.
  */
-import type { VoiceDesignRequest, VoiceDesignResult, VoiceDesignSaveRequest, VoiceDetail, VoiceInfo, VoiceUpdate, VoiceUpload, VoiceUploadRequest, VoiceUploadTicket } from "../gen/index.js";
+import type { VoiceDesignRequest, VoiceDesignResult, VoiceDesignSaveRequest, VoiceDetail, VoiceInfo, VoiceInfoPage, 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";
@@ -21,17 +23,17 @@ export type VoiceUploadFields = Omit<VoiceUpload, "upload_id"> & {
     content_type?: string;
 };
 /** `update` renames a voice, or changes its description or defaults. */
-export declare class Voices extends Waitable<VoiceDetail, VoiceUpdate, VoiceDetail, boolean> {
+export declare class Voices extends Waitable<VoiceDetail, VoiceUpdate> {
+    /** The page of voices, as the route answers it: all of them, `next_cursor` `null`. */
+    page(options?: RequestOptions): Promise<VoiceInfoPage>;
     /** Every voice this organisation may speak with. */
-    list(options?: RequestOptions): Promise<VoiceInfo[]>;
+    list(options?: RequestOptions): AsyncGenerator<VoiceInfo, void, undefined>;
     /** 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. */

package/dist/resources/voices.js

@@ -9,15 +9,21 @@
  *   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.
+ * - **`delete` answers `true`**, and `false` when there was no such
+ *   voice: done.
+ * - **`list()` reads one page**: the route answers every voice in it.
  */
 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 {
+    /** The page of voices, as the route answers it: all of them, `next_cursor` `null`. */
+    page(options) {
+        return this.send("GET", "", options);
+    }
     /** Every voice this organisation may speak with. */
     list(options) {
-        return this.send("GET", "", options);
+        return this.each("", {}, options);
     }
     /** Clones a recording already `PUT` to its ticket: `pending` at once. */
     create(body, options) {
@@ -34,10 +40,6 @@ export class Voices extends Waitable {
         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);

package/dist/transport.d.ts

@@ -49,9 +49,13 @@ export interface Answer<T> {
 }
 /** The longest `Retry-After` slept through; past it the 429 is thrown. */
 export declare const MAX_RETRY_AFTER_S = 60;
-/** A path parameter, encoded: an `external_id` may hold `/` or `?`. */
-export declare const segment: (value: string) => string;
-/** A request id of the API's own shape: 16 hex. */
+/** 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

package/dist/transport.js

@@ -26,6 +26,10 @@
  *   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]);
@@ -33,10 +37,14 @@ 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, encoded: an `external_id` may hold `/` or `?`. */
+/** 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. */
-export const newRequestId = () => crypto.randomUUID().replaceAll("-", "").slice(0, 16);
+/**
+ * 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.
@@ -76,7 +84,7 @@ export function parsed(text, status, requestId) {
     catch (cause) {
         throw new PlatformError({
             status,
-            type: "invalid_response",
+            code: "invalid_response",
             message: `HTTP ${status} with a body that is not JSON.`,
             requestId,
             cause,
@@ -101,7 +109,8 @@ export class Transport {
     }
     async request(call, options = {}) {
         const requestId = options.requestId ?? newRequestId();
-        const once = call.raw instanceof ReadableStream;
+        // 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);
@@ -154,13 +163,13 @@ export class Transport {
                 throw outcome.kind === "timeout"
                     ? new TimeoutError({
                         status: 0,
-                        type: "timeout",
+                        code: "timeout",
                         message: "The API did not answer in time.",
                         requestId,
                     })
                     : new ConnectionError({
                         status: 0,
-                        type: "connection_error",
+                        code: "connection_error",
                         message: "Could not reach the API.",
                         requestId,
                         cause: outcome.error,
@@ -170,27 +179,37 @@ export class Transport {
         }
     }
     url(call) {
-        const params = new URLSearchParams();
+        // By hand: React Native's `URLSearchParams` is partial.
+        let query = "";
         for (const [key, value] of Object.entries(call.query ?? {})) {
-            if (value !== undefined && value !== null)
-                params.set(key, String(value));
+            if (value != null) {
+                query += `${query ? "&" : "?"}${key}=${segment(value)}`;
+            }
         }
-        const query = params.toString();
         const base = /^https?:/.test(call.path) ? "" : this.config.baseUrl;
-        return `${base}${call.path}${query ? `?${query}` : ""}`;
+        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 clock = setTimeout(() => timer.abort(), options.timeoutMs ?? this.config.timeoutMs);
-        const signal = options.signal
-            ? AbortSignal.any([options.signal, timer.signal])
-            : timer.signal;
+        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 });
+            const response = await this.config.fetch(url, {
+                ...init,
+                signal: timer.signal,
+            });
             const body = !response.ok
                 ? await response.text()
                 : read === "stream"
@@ -202,14 +221,16 @@ export class Transport {
         }
         catch (error) {
             // The caller's abort is the caller's, whatever else happened.
-            if (options.signal?.aborted)
-                throw options.signal.reason;
+            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);
         }
     }
 }