@videxo/sdk 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BEO TECHNOLOGY sp. z o.o.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,80 @@
-# Temporary Holding Version
+# @videxo/sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The TypeScript client of the [Videxo](https://videxo.io) API: hosted ffmpeg jobs over HTTP,
+described as JSON operations or as an ffmpeg command. Types are generated from the API's OpenAPI
+3.1 document; requests go through `fetch` and webhooks are verified with WebCrypto, so the package
+has one small dependency and no Node built-ins.
+
+```bash
+npm i @videxo/sdk
+# or: pnpm add @videxo/sdk, yarn add @videxo/sdk, bun add @videxo/sdk
+```
+
+It is an ES module with its own type declarations. It runs on Node 20 or newer, Bun, Deno and
+Cloudflare Workers. In a browser, use only `sendUpload()` with a `File`, `Blob` or bytes.
+
+## Keep the API key on a server
+
+The API key gives full access to your account. Use it only in server code (a route handler, a
+worker, a job queue), never in code that runs in a browser or an app. An app or a web page uses
+`@videxo/sdk/client` with a [client token](https://videxo.io/docs/client-tokens) your server mints,
+or sends files to an upload URL your server created, with `sendUpload()`, which needs no key.
+
+## Use it
+
+```ts
+import { Videxo, VidexoError } from '@videxo/sdk';
+
+const videxo = new Videxo({ apiKey: process.env.VIDEXO_API_KEY });
+
+const job = await videxo.transcode({ input: 'https://example.com/talk.mp4', preset: 'web-720p' });
+const done = await videxo.jobs.wait(job.id);
+if (done.state === 'succeeded') {
+  const response = await videxo.outputs.download(done.id, 'video');
+  // response.body is the file
+}
+```
+
+| Call | API |
+|---|---|
+| `new Videxo({ apiKey, baseUrl?, fetch?, maxRetries?, timeoutMs? })` | `baseUrl` is `https://api.videxo.io` by default; throws without a key |
+| `jobs.create(body, { idempotencyKey? })` | `POST /v1/jobs`, a command body or an operations body |
+| `transcode`, `thumbnails`, `storyboard`, `gif`, `audio`, `concat`, `slideshow`, `scenes` | `POST /v1/<operation>` |
+| `jobs.get(id)`, `jobs.cancel(id)`, `jobs.deleteFiles(id)` | `GET /v1/jobs/{id}`, `POST .../cancel`, `DELETE .../files` |
+| `jobs.list(params)`, `jobs.page(params)` | `GET /v1/jobs`: every job as an async iterator, or one page |
+| `jobs.wait(id, { timeoutMs?, intervalMs?, signal? })` | polls until `succeeded`, `failed` or `cancelled` |
+| `jobs.compile(body)` | `POST /v1/jobs/compile` |
+| `presets.list()` | `GET /v1/presets` |
+| `fonts.list()` | `GET /v1/fonts` |
+| `uploads.create(params)`, `uploads.upload(data, { filename, contentType?, size? })` | `POST /v1/uploads`, then the PUT to its URL |
+| `outputs.url(jobId, output)`, `outputs.download(jobId, output)` | `GET /v1/jobs/{id}/outputs/{alias}`: a fresh signed link, or the file |
+| `webhooks.verify(body, headers, secret)`, `verifyWebhook(...)` | Standard Webhooks signature check; answers the event |
+| `sendUpload(uploadUrl, data, { contentType? })` | the PUT alone, without a key |
+| `clientTokens.create(grant)`, `clientTokens.forUpload(...)`, `clientTokens.forJob(jobId, ...)` | `POST /v1/client-tokens`: answers `id` and `token` for the app |
+| `clientTokens.revoke(id)`, `clientTokens.revokeSubject(subject)` | ends a chain, or every chain of an end user |
+
+`@videxo/sdk/client` is a separate entry point for apps and web pages, without the keyed client:
+`new VidexoClient({ token, tokenId?, baseUrl?, getToken? })` with `uploads.create`,
+`uploads.upload(file, { filename, onProgress })`, `jobs.get`, `jobs.list`, `jobs.wait` and `token()`.
+`getToken({ tokenId })` asks your server for a continuation when the token is about to expire or is
+refused as expired or superseded. The constructor refuses a value shaped like an API key.
+
+The docs page [TypeScript SDK](https://videxo.io/docs/sdk) covers each call with examples.
+
+## Errors
+
+Every failed call throws a `VidexoError` with `status`, `code`, `title`, `detail`, `type`,
+`errors`, `problems`, `retryAfter` and the raw `body` of the API's problem details answer; programs
+branch on `code` ([error codes](https://videxo.io/docs/errors)). Without such an answer `code` is
+one of the SDK's own, listed in `SDK_ERROR_CODES`: `network_error`, `timeout`, `aborted`,
+`wait_timeout`, `http_error`, `invalid_response`, `output_not_found` and `output_ambiguous`. An
+error's message never holds the API key. A webhook that fails verification throws a
+`VidexoWebhookError`.
+
+## Retries and idempotency
+
+Every creation sends an `Idempotency-Key` (a random UUID unless you pass `idempotencyKey`) and
+reuses it on retries. A request is retried after `429`, `502`, `503`, `504`, a timeout or a network
+error, at most `maxRetries` times (2 by default), with backoff and jitter or after its
+`Retry-After`. Other answers are not retried. `POST /v1/uploads` takes no Idempotency-Key, so it is
+retried only after a `429`; bytes sent to an upload URL are never sent twice.

package/dist/app-client.d.ts

@@ -0,0 +1,112 @@
+import { type RetryPolicy, type Transport } from './transport.ts';
+import type { ClientJob, ClientTokenInfo, CompletedUpload, CreateUploadRequest, Upload } from './types.ts';
+import { type UploadData, type UploadProgress } from './uploads.ts';
+export { DEFAULT_BASE_URL } from './defaults.ts';
+export { VidexoError, type VidexoErrorCode } from './errors.ts';
+export { sendUpload, type SendUploadOptions, type UploadData, type UploadProgress } from './uploads.ts';
+export type { ClientJob, ClientJobList, ClientJobOutput, ClientTokenInfo, CompletedUpload, CreateUploadRequest, Upload } from './types.ts';
+/** The token a `getToken` callback answers: the string, or with its id as your backend got it. */
+export type FreshToken = string | {
+    token: string;
+    id?: string;
+};
+export type VidexoClientOptions = {
+    /** A client token your backend minted (`vdx_ct_...`); never an API key. */
+    token: string;
+    /** The token's id. Without it the id is read from `GET /v1/client/token` on first use. */
+    tokenId?: string;
+    /** `https://api.videxo.io` by default. */
+    baseUrl?: string;
+    /**
+     * Asks your backend for a continuation of the token (`continues: tokenId`), when it is about to
+     * expire or is refused as expired or superseded, so long flows keep their uploads and jobs. A
+     * failed refresh is asked again with the same id on the next call.
+     */
+    getToken?(request: {
+        tokenId: string | null;
+    }): Promise<FreshToken>;
+    fetch?(input: Request, init?: RequestInit): Promise<Response>;
+    maxRetries?: number;
+    timeoutMs?: number;
+};
+export type ClientRequestOptions = {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+};
+export type ClientCreateOptions = ClientRequestOptions & {
+    /** Makes the creation safe to retry for 24 hours; the SDK makes one and reuses it on its own retries. */
+    idempotencyKey?: string;
+};
+export type ClientUploadOptions = ClientCreateOptions & {
+    /** A plain file name: letters, digits, dots, underscores and hyphens. */
+    filename: string;
+    /** The declared type; the blob's own type or `application/octet-stream` by default. */
+    contentType?: string;
+    /** The exact byte length; needed for a stream, read from the data otherwise. */
+    size?: number;
+    /** Called as the bytes are sent. In a browser this uses `XMLHttpRequest`, as `fetch` reports no upload progress. */
+    onProgress?(progress: UploadProgress): void;
+    /** For sending the bytes; no timeout by default, as a large file may take a while. */
+    uploadTimeoutMs?: number;
+};
+export type ClientWaitOptions = {
+    timeoutMs?: number;
+    intervalMs?: number;
+    signal?: AbortSignal;
+};
+/**
+ * The client of `/v1/client/*` for an app or a web page.
+ *
+ * ```ts
+ * const videxo = new VidexoClient({ token, tokenId, getToken: ({ tokenId }) => myBackend.refresh(tokenId) });
+ * const upload = await videxo.uploads.upload(file, { filename: 'clip.mp4', onProgress: (p) => show(p.loaded / p.total) });
+ * ```
+ */
+export declare class VidexoClient {
+    #private;
+    readonly baseUrl: string;
+    readonly uploads: ClientUploads;
+    readonly jobs: ClientJobs;
+    /** @internal */
+    readonly transport: Transport;
+    constructor(options: VidexoClientOptions);
+    /** `GET /v1/client/token`: the token's id, chain and expiry, the uploads used and the jobs it may read. */
+    token(options?: ClientRequestOptions): Promise<ClientTokenInfo>;
+    /** The id of the current token, once known. */
+    get tokenId(): string | null;
+    /** @internal One call: a token that is about to end is refreshed first, one refused as ended is refreshed and the call sent again once. */
+    request<T>(method: string, path: string, options: {
+        retry: RetryPolicy;
+        body?: unknown;
+        headers?: Record<string, string>;
+        remember?: boolean;
+    } & ClientRequestOptions): Promise<T>;
+}
+export declare class ClientUploads {
+    #private;
+    constructor(client: VidexoClient);
+    /**
+     * `POST /v1/client/uploads`: a one-time upload URL within the token's grant. It sends an
+     * Idempotency-Key of its own, kept for its retries and a refresh, so a lost answer spends nothing.
+     */
+    create(params: CreateUploadRequest, options?: ClientCreateOptions): Promise<Upload>;
+    /**
+     * Creates an upload and sends the bytes; answers the completed upload. Hand its `input_url` to your
+     * backend, which creates the job with its API key.
+     */
+    upload(data: UploadData, options: ClientUploadOptions): Promise<CompletedUpload>;
+}
+export declare class ClientJobs {
+    #private;
+    constructor(client: VidexoClient);
+    /** `GET /v1/client/jobs/{id}`: a job the token may read. Any other job is `not_found`. */
+    get(id: string, options?: ClientRequestOptions): Promise<ClientJob>;
+    /** `GET /v1/client/jobs`: the jobs the token may read, newest first. */
+    list(options?: ClientRequestOptions): Promise<ClientJob[]>;
+    /**
+     * Reads the job until it is `succeeded`, `failed` or `cancelled`, and answers it (a failed job is
+     * answered, not thrown). Waits out a 429 by its `Retry-After`. Throws `wait_timeout` when the job
+     * has not ended within `timeoutMs`, `aborted` when `signal` fires.
+     */
+    wait(id: string, options?: ClientWaitOptions): Promise<ClientJob>;
+}

package/dist/app-client.js

@@ -0,0 +1,311 @@
+import { DEFAULT_BASE_URL, DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT_MS, DEFAULT_WAIT } from "./defaults.js";
+import { VidexoError, errorFromResponse, sdkError } from "./errors.js";
+import { abortableSleep, redacted, runtimeFetch, send } from "./transport.js";
+import { sendUpload, sendUploadWithProgress, sizeOf } from "./uploads.js";
+// `@videxo/sdk/client`: the client for apps and web pages, which hold a short-lived client token
+// (ADR 016), never an API key. It imports nothing of the keyed client, so a bundle stays small and
+// cannot reach a keyed route by accident.
+export { DEFAULT_BASE_URL } from "./defaults.js";
+export { VidexoError } from "./errors.js";
+export { sendUpload } from "./uploads.js";
+const CLIENT_TOKEN_PREFIX = 'vdx_ct_';
+const API_KEY_SHAPE = /^vdx_[A-Za-z]{64}$/;
+/** Refresh a token this close to its expiry, before the request would be refused. */
+const REFRESH_BEFORE_EXPIRY_MS = 30_000;
+const TERMINAL = new Set(['succeeded', 'failed', 'cancelled']);
+/** The refusals a new token of the chain answers. */
+const REFRESHABLE = new Set(['client_token_expired', 'client_token_superseded']);
+/** A value that must be a client token: an API key in an app is a published key, so it stops here. */
+function checkedToken(value) {
+    const token = typeof value === 'string' ? value.trim() : '';
+    // The messages do not repeat the value: it may be a real key.
+    if (API_KEY_SHAPE.test(token))
+        throw new TypeError('VidexoClient takes a client token, never an API key. Keep the API key on your server and mint client tokens there.');
+    if (!token.startsWith(CLIENT_TOKEN_PREFIX) || !/^[\x21-\x7e]+$/.test(token))
+        throw new TypeError('VidexoClient needs a client token (vdx_ct_...) your server minted with POST /v1/client-tokens.');
+    return token;
+}
+/**
+ * The client of `/v1/client/*` for an app or a web page.
+ *
+ * ```ts
+ * const videxo = new VidexoClient({ token, tokenId, getToken: ({ tokenId }) => myBackend.refresh(tokenId) });
+ * const upload = await videxo.uploads.upload(file, { filename: 'clip.mp4', onProgress: (p) => show(p.loaded / p.total) });
+ * ```
+ */
+export class VidexoClient {
+    baseUrl;
+    uploads;
+    jobs;
+    /** @internal */
+    transport;
+    #token;
+    #tokens = new Set();
+    #tokenId;
+    /** Milliseconds; null until the token has been read. */
+    #expiresAt = null;
+    #read = false;
+    #refreshed = false;
+    #clockAhead = false;
+    #refreshing = null;
+    #getToken;
+    constructor(options) {
+        this.#token = checkedToken(options?.token);
+        this.#tokens.add(this.#token);
+        this.#tokenId = options.tokenId ?? null;
+        this.#getToken = options.getToken;
+        const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        if (!/^https?:\/\//.test(baseUrl))
+            throw new TypeError('baseUrl must be an http or https URL.');
+        this.baseUrl = baseUrl;
+        const userFetch = options.fetch;
+        this.transport = {
+            fetch: userFetch ? (input, init) => userFetch(input, init) : runtimeFetch,
+            maxRetries: Math.max(0, Math.floor(options.maxRetries ?? DEFAULT_MAX_RETRIES)),
+            timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            // Every token of this client: a request under way when its token was replaced can still fail with it.
+            redact: (text) => [...this.#tokens].reduce((clean, token) => clean.replaceAll(token, '[client token]'), text),
+        };
+        this.uploads = new ClientUploads(this);
+        this.jobs = new ClientJobs(this);
+    }
+    /** `GET /v1/client/token`: the token's id, chain and expiry, the uploads used and the jobs it may read. */
+    async token(options = {}) {
+        return this.request('GET', '/v1/client/token', { retry: 'safe', remember: true, ...options });
+    }
+    /** The id of the current token, once known. */
+    get tokenId() {
+        return this.#tokenId;
+    }
+    /** What a read of the token `used` answered, unless the token was replaced while it was on its way. */
+    #remember(info, used) {
+        if (used !== this.#token)
+            return;
+        this.#tokenId = info.id;
+        this.#expiresAt = Date.parse(info.expires_at);
+        this.#read = true;
+        // A token just refreshed cannot be about to end, so this device's clock runs ahead. Asking for a new
+        // one before every call would not help: from here on only the API's own refusal starts a refresh.
+        if (this.#refreshed && this.#expiresAt - Date.now() < REFRESH_BEFORE_EXPIRY_MS)
+            this.#clockAhead = true;
+        this.#refreshed = false;
+    }
+    /** The current token is replaced by what `getToken` answers; concurrent calls share one refresh. */
+    #refresh() {
+        if (!this.#refreshing) {
+            this.#refreshing = (async () => {
+                const fresh = await this.#getToken({ tokenId: this.#tokenId });
+                const token = checkedToken(typeof fresh === 'string' ? fresh : fresh?.token);
+                // The old id stays until the new one is known, so a failed refresh asks with the same id.
+                this.#token = token;
+                this.#tokens.add(token);
+                if (typeof fresh !== 'string' && fresh.id)
+                    this.#tokenId = fresh.id;
+                this.#expiresAt = null;
+                this.#read = false;
+                this.#refreshed = true;
+            })().finally(() => {
+                this.#refreshing = null;
+            });
+        }
+        return this.#refreshing;
+    }
+    /**
+     * After `used` was refused as ended: a refresh, unless another call already replaced that token. A
+     * refusal that arrives late must not mint a third token, whose first use would end the second while
+     * a call with it is under way.
+     */
+    async #replace(used, signal) {
+        if (this.#refreshing)
+            await settled(this.#refreshing, signal);
+        if (this.#token === used)
+            await settled(this.#refresh(), signal);
+    }
+    /** Before a request: learns the token's id and expiry while it still works, and refreshes it when it is about to end. */
+    async #prepare(path, options) {
+        if (!this.#getToken)
+            return;
+        if (this.#refreshing)
+            await settled(this.#refreshing, options.signal);
+        if (!this.#read && path !== '/v1/client/token') {
+            // Only the call's signal and timeout: its body and headers are not this request's.
+            const { signal, timeoutMs } = options;
+            const used = this.#token;
+            const response = await this.#send('GET', '/v1/client/token', {
+                retry: 'safe',
+                ...(signal ? { signal } : {}),
+                ...(timeoutMs === undefined ? {} : { timeoutMs }),
+            });
+            const body = await readBody(response);
+            if (response.ok)
+                this.#remember(body, used);
+            else if (refreshable(response, body))
+                return this.#replace(used, signal);
+            // Any other refusal is left to the call itself, which answers it.
+        }
+        if (!this.#clockAhead && this.#expiresAt !== null && this.#expiresAt - Date.now() < REFRESH_BEFORE_EXPIRY_MS)
+            await settled(this.#refresh(), options.signal);
+    }
+    #send(method, path, options) {
+        const request = new Request(`${this.baseUrl}${path}`, {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.#token}`,
+                ...(options.body === undefined ? {} : { 'Content-Type': 'application/json' }),
+                ...options.headers,
+            },
+            ...(options.body === undefined ? {} : { body: JSON.stringify(options.body) }),
+        });
+        return send(this.transport, request, { retry: options.retry, signal: options.signal, timeoutMs: options.timeoutMs, buffer: true });
+    }
+    /** @internal One call: a token that is about to end is refreshed first, one refused as ended is refreshed and the call sent again once. */
+    async request(method, path, options) {
+        try {
+            await this.#prepare(path, options);
+            let used = this.#token;
+            let response = await this.#send(method, path, options);
+            let body = await readBody(response);
+            if (this.#getToken && refreshable(response, body)) {
+                await this.#replace(used, options.signal);
+                used = this.#token;
+                response = await this.#send(method, path, options);
+                body = await readBody(response);
+            }
+            if (!response.ok)
+                throw errorFromResponse(response, body);
+            if (typeof body !== 'object' || body === null)
+                throw sdkError('invalid_response', 'The API answered without a JSON body.', { status: response.status, body });
+            if (options.remember)
+                this.#remember(body, used);
+            return body;
+        }
+        catch (error) {
+            throw redacted(this.transport, error);
+        }
+    }
+}
+/**
+ * Waits for the shared refresh as long as this call still wants it: its signal ends this call's wait
+ * and nothing else, so the refresh goes on for the calls still waiting.
+ */
+function settled(refresh, signal) {
+    if (!signal)
+        return refresh;
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(sdkError('aborted', 'The request was aborted while its token was refreshed.', { cause: signal.reason }));
+        if (signal.aborted)
+            return onAbort();
+        signal.addEventListener('abort', onAbort, { once: true });
+        refresh.then(resolve, reject).finally(() => signal.removeEventListener('abort', onAbort));
+    });
+}
+const refreshable = (response, body) => response.status === 401 && REFRESHABLE.has(body?.reason ?? '');
+async function readBody(response) {
+    const text = await response.text();
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+export class ClientUploads {
+    #client;
+    constructor(client) {
+        this.#client = client;
+    }
+    /**
+     * `POST /v1/client/uploads`: a one-time upload URL within the token's grant. It sends an
+     * Idempotency-Key of its own, kept for its retries and a refresh, so a lost answer spends nothing.
+     */
+    create(params, options = {}) {
+        return this.#client.request('POST', '/v1/client/uploads', {
+            retry: 'safe',
+            body: params,
+            headers: { 'Idempotency-Key': options.idempotencyKey ?? crypto.randomUUID() },
+            ...(options.signal ? { signal: options.signal } : {}),
+            ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+        });
+    }
+    /**
+     * Creates an upload and sends the bytes; answers the completed upload. Hand its `input_url` to your
+     * backend, which creates the job with its API key.
+     */
+    async upload(data, options) {
+        const size = options.size ?? sizeOf(data);
+        if (size === null)
+            throw new TypeError('uploads.upload() needs options.size for a stream.');
+        const blobType = typeof Blob !== 'undefined' && data instanceof Blob ? data.type : '';
+        const contentType = options.contentType ?? (blobType || 'application/octet-stream');
+        const upload = await this.create({ filename: options.filename, size_bytes: size, content_type: contentType }, options);
+        const sending = {
+            contentType,
+            fetch: this.#client.transport.fetch,
+            ...(options.signal ? { signal: options.signal } : {}),
+            ...(options.uploadTimeoutMs === undefined ? {} : { timeoutMs: options.uploadTimeoutMs }),
+        };
+        return options.onProgress
+            ? sendUploadWithProgress(upload.upload_url, data, size, { ...sending, onProgress: options.onProgress })
+            : sendUpload(upload.upload_url, data, sending);
+    }
+}
+export class ClientJobs {
+    #client;
+    constructor(client) {
+        this.#client = client;
+    }
+    /** `GET /v1/client/jobs/{id}`: a job the token may read. Any other job is `not_found`. */
+    get(id, options = {}) {
+        return this.#client.request('GET', `/v1/client/jobs/${encodeURIComponent(id)}`, { retry: 'safe', ...options });
+    }
+    /** `GET /v1/client/jobs`: the jobs the token may read, newest first. */
+    async list(options = {}) {
+        const list = await this.#client.request('GET', '/v1/client/jobs', { retry: 'safe', ...options });
+        return list.data;
+    }
+    /**
+     * Reads the job until it is `succeeded`, `failed` or `cancelled`, and answers it (a failed job is
+     * answered, not thrown). Waits out a 429 by its `Retry-After`. Throws `wait_timeout` when the job
+     * has not ended within `timeoutMs`, `aborted` when `signal` fires.
+     */
+    async wait(id, options = {}) {
+        const timeoutMs = options.timeoutMs ?? DEFAULT_WAIT.timeoutMs;
+        const intervalMs = options.intervalMs ?? DEFAULT_WAIT.intervalMs;
+        const sleep = this.#client.transport.sleep ?? abortableSleep;
+        const deadline = new AbortController();
+        const onAbort = () => deadline.abort(options.signal?.reason);
+        if (options.signal?.aborted)
+            onAbort();
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+        const timer = setTimeout(() => deadline.abort(), timeoutMs);
+        let job;
+        const timedOut = () => sdkError('wait_timeout', `Job ${id} did not end within ${timeoutMs} ms.`, { body: job });
+        try {
+            for (;;) {
+                let pause = intervalMs;
+                try {
+                    job = await this.get(id, { signal: deadline.signal });
+                    if (TERMINAL.has(job.state))
+                        return job;
+                }
+                catch (error) {
+                    if (!(error instanceof VidexoError && error.status === 429))
+                        throw error;
+                    pause = Math.max(intervalMs, (error.retryAfter ?? 0) * 1000);
+                }
+                if (deadline.signal.aborted)
+                    throw timedOut();
+                await sleep(pause, deadline.signal);
+            }
+        }
+        catch (error) {
+            if (error instanceof VidexoError && error.code === 'aborted' && !options.signal?.aborted)
+                throw timedOut();
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+            options.signal?.removeEventListener('abort', onAbort);
+        }
+    }
+}