videodubber 0.2.2

package/README.md

@@ -0,0 +1,35 @@
+# videodubber (npm)
+
+Official JavaScript/TypeScript client for the [VideoDubber.ai](https://videodubber.ai) video translation API.
+
+```bash
+npm install videodubber
+```
+
+Full documentation: [videodubber_client.md](../videodubber_client.md) · [Developer portal](https://videodubber.ai/developers/)
+
+## Quick example
+
+```javascript
+import { VideoDubberClient } from "videodubber";
+
+const client = new VideoDubberClient({ apiKey: process.env.VIDEODUBBER_API_KEY });
+const status = await client.translateFromUrl({
+  fileUrl: "https://example.com/video.mp4",
+  targetLanguage: "Spanish",
+  selectedVoices: ["Elvira"],
+  speakers: ["Speaker 1"],
+  filetype: "mp4",
+});
+
+console.log(status.translatedMediaUrl);
+```
+
+## Development
+
+```bash
+npm install
+npm run build
+```
+
+Version is synced from the repo root [`VERSION`](../VERSION) file on build.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function runCli(argv?: string[]): Promise<number>;

package/dist/cli.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { DEFAULT_BASE_URL } from "./constants.js";
+import { VideoDubberClient } from "./client.js";
+import { ApiError, RateLimitError } from "./errors.js";
+import { formatApiError } from "./format-api-error.js";
+function inferFiletype(fileUrl) {
+    const pathname = fileUrl.split("?")[0] ?? fileUrl;
+    const ext = path.extname(pathname).replace(/^\./, "").toLowerCase();
+    return ext || "mp4";
+}
+function parseArgs(argv) {
+    const options = {
+        voices: [],
+        speakers: [],
+        apiKey: process.env.VIDEODUBBER_API_KEY ?? "",
+        baseUrl: process.env.VIDEODUBBER_API_BASE ?? DEFAULT_BASE_URL,
+        originalLanguage: "unknown",
+        numSpeakers: "1",
+        projectName: "API Project",
+        voiceCloning: false,
+        filetype: "",
+        audioshift: "0",
+        translator: "auto",
+        glossaryId: "",
+        bg1: "Auto (Not recommended)",
+        pollInterval: 15,
+        maxWait: 3600,
+        json: false,
+        quiet: false,
+        debug: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        const next = argv[i + 1];
+        switch (arg) {
+            case "--file-url":
+                options.fileUrl = next;
+                i += 1;
+                break;
+            case "--api-key":
+                options.apiKey = next ?? "";
+                i += 1;
+                break;
+            case "--base-url":
+                options.baseUrl = next ?? DEFAULT_BASE_URL;
+                i += 1;
+                break;
+            case "--original-language":
+                options.originalLanguage = next ?? "unknown";
+                i += 1;
+                break;
+            case "--target-language":
+                options.targetLanguage = next ?? "";
+                i += 1;
+                break;
+            case "--num-speakers":
+                options.numSpeakers = next ?? "1";
+                i += 1;
+                break;
+            case "--project-name":
+                options.projectName = next ?? "API Project";
+                i += 1;
+                break;
+            case "--voice":
+                options.voices.push(next ?? "");
+                i += 1;
+                break;
+            case "--speaker":
+                options.speakers.push(next ?? "");
+                i += 1;
+                break;
+            case "--voice-cloning":
+                options.voiceCloning = true;
+                break;
+            case "--filetype":
+                options.filetype = next ?? "";
+                i += 1;
+                break;
+            case "--audioshift":
+                options.audioshift = next ?? "0";
+                i += 1;
+                break;
+            case "--translator":
+                options.translator = next ?? "auto";
+                i += 1;
+                break;
+            case "--glossary-id":
+                options.glossaryId = next ?? "";
+                i += 1;
+                break;
+            case "--bg1":
+                options.bg1 = next ?? "Auto (Not recommended)";
+                i += 1;
+                break;
+            case "--poll-interval":
+                options.pollInterval = Number(next ?? 15);
+                i += 1;
+                break;
+            case "--max-wait":
+                options.maxWait = Number(next ?? 3600);
+                i += 1;
+                break;
+            case "--output":
+                options.output = next;
+                i += 1;
+                break;
+            case "--json":
+                options.json = true;
+                break;
+            case "--quiet":
+                options.quiet = true;
+                break;
+            case "--debug":
+                options.debug = true;
+                break;
+            case "-h":
+            case "--help":
+                printHelp();
+                process.exit(0);
+                break;
+            default:
+                throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    if (!options.fileUrl) {
+        throw new Error("--file-url is required");
+    }
+    if (!options.targetLanguage) {
+        throw new Error("--target-language is required");
+    }
+    if (!options.voices.length) {
+        throw new Error("At least one --voice is required");
+    }
+    if (!options.apiKey) {
+        throw new Error("Set --api-key or VIDEODUBBER_API_KEY");
+    }
+    const speakers = options.speakers.length > 0
+        ? options.speakers
+        : options.voices.map((_, index) => `Speaker ${index + 1}`);
+    if (speakers.length !== options.voices.length) {
+        throw new Error("Provide the same number of --voice and --speaker values");
+    }
+    return {
+        ...options,
+        speakers,
+        filetype: options.filetype || inferFiletype(options.fileUrl),
+    };
+}
+function printHelp() {
+    console.log(`Translate video/audio with the VideoDubber API.
+
+Usage:
+  videodubber --file-url URL --target-language LANG --voice NAME [options]
+
+Environment:
+  VIDEODUBBER_API_KEY   API key (required unless --api-key)
+  VIDEODUBBER_API_BASE  Override base URL (default: ${DEFAULT_BASE_URL})
+`);
+}
+async function downloadFile(url, dest, quiet) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Download failed: HTTP ${response.status}`);
+    }
+    await mkdir(path.dirname(dest), { recursive: true });
+    const buffer = Buffer.from(await response.arrayBuffer());
+    await writeFile(dest, buffer);
+    if (!quiet) {
+        console.error(`Saved ${dest} (${(buffer.length / (1024 * 1024)).toFixed(1)} MiB)`);
+    }
+}
+export async function runCli(argv = process.argv.slice(2)) {
+    const args = parseArgs(argv);
+    const params = {
+        fileUrl: args.fileUrl,
+        targetLanguage: args.targetLanguage,
+        originalLanguage: args.originalLanguage,
+        numSpeakers: args.numSpeakers,
+        projectName: args.projectName,
+        filetype: args.filetype,
+        selectedVoices: args.voices,
+        speakers: args.speakers,
+        audioshift: args.audioshift,
+        translator: args.translator,
+        glossaryId: args.glossaryId,
+        bg1: args.bg1,
+        voiceCloning: args.voiceCloning,
+    };
+    const client = new VideoDubberClient({
+        apiKey: args.apiKey,
+        baseUrl: args.baseUrl,
+        verbose: !args.quiet,
+        debug: args.debug,
+    });
+    try {
+        if (!args.quiet) {
+            console.error(`VideoDubber translate: ${args.originalLanguage} → ${args.targetLanguage}`);
+        }
+        const status = await client.translateFromUrl(params, {
+            pollInterval: args.pollInterval,
+            maxWait: args.maxWait,
+        });
+        if (args.json) {
+            console.log(JSON.stringify(status.raw, null, 2));
+        }
+        else if (!args.quiet) {
+            console.log(`status=${status.status} pid=${status.pid}`);
+            if (status.translatedMediaUrl) {
+                console.log(`translated_media=${status.translatedMediaUrl}`);
+            }
+            if (status.availableMinutes !== undefined) {
+                console.log(`available_minutes=${status.availableMinutes}`);
+            }
+        }
+        if (args.output && status.translatedMediaUrl) {
+            await downloadFile(status.translatedMediaUrl, args.output, args.quiet);
+            if (!args.quiet && !args.json) {
+                console.log(`saved=${args.output}`);
+            }
+        }
+        if (!args.quiet) {
+            console.error("Done.");
+        }
+        return status.isComplete ? 0 : 1;
+    }
+    catch (error) {
+        if (error instanceof RateLimitError) {
+            const suffix = error.retryAfter !== undefined ? ` (retry after ~${error.retryAfter}s)` : "";
+            console.error(`rate limit: ${error.message}${suffix}`);
+            return 1;
+        }
+        if (error instanceof ApiError) {
+            console.error(formatApiError(error.body));
+            return 1;
+        }
+        console.error(`error: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+    }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    runCli().then((code) => {
+        process.exit(code);
+    });
+}

package/dist/client.d.ts

@@ -0,0 +1,26 @@
+import { CreateJobResponse, JobStatus, TranslationJobParams, VideoDubberClientOptions, WaitForJobOptions } from "./types.js";
+export declare class VideoDubberClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly rateLimitMaxRetries;
+    private readonly rateLimitBackoffBase;
+    private readonly partnerMinInterval;
+    private readonly verbose;
+    private readonly debug;
+    private readonly fetchFn;
+    private lastPartnerRequestAt;
+    constructor(options: VideoDubberClientOptions);
+    private progress;
+    private debugStatusRaw;
+    private throttleBeforeRequest;
+    private markRequestSent;
+    private parseRetryAfter;
+    private request;
+    private raiseApiError;
+    health(): Promise<Record<string, unknown>>;
+    createJobFromUrl(params: TranslationJobParams): Promise<CreateJobResponse>;
+    getJobStatus(pid: string): Promise<JobStatus>;
+    waitForJob(pid: string, options?: WaitForJobOptions): Promise<JobStatus>;
+    translateFromUrl(params: TranslationJobParams, options?: WaitForJobOptions): Promise<JobStatus>;
+}

package/dist/client.js

@@ -0,0 +1,227 @@
+import { DEFAULT_BASE_URL, DEFAULT_PARTNER_POLL_INTERVAL, DEFAULT_RATE_LIMIT_BACKOFF_BASE, DEFAULT_RATE_LIMIT_MAX_RETRIES, PARTNER_MIN_REQUEST_INTERVAL, } from "./constants.js";
+import { ApiError, JobFailedError, JobTimeoutError, RateLimitError } from "./errors.js";
+import { parseJobStatus, toJobPayload, } from "./types.js";
+function sleep(seconds) {
+    return new Promise((resolve) => setTimeout(resolve, seconds * 1000));
+}
+function joinUrl(baseUrl, path) {
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    return new URL(normalizedPath, `${baseUrl.replace(/\/$/, "")}/`).toString();
+}
+export class VideoDubberClient {
+    apiKey;
+    baseUrl;
+    timeoutMs;
+    rateLimitMaxRetries;
+    rateLimitBackoffBase;
+    partnerMinInterval;
+    verbose;
+    debug;
+    fetchFn;
+    lastPartnerRequestAt = 0;
+    constructor(options) {
+        if (!options.apiKey) {
+            throw new Error("apiKey is required");
+        }
+        this.apiKey = options.apiKey;
+        this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+        this.timeoutMs = options.timeoutMs ?? 120_000;
+        this.rateLimitMaxRetries =
+            options.rateLimitMaxRetries ?? DEFAULT_RATE_LIMIT_MAX_RETRIES;
+        this.rateLimitBackoffBase =
+            options.rateLimitBackoffBase ?? DEFAULT_RATE_LIMIT_BACKOFF_BASE;
+        this.partnerMinInterval =
+            options.partnerMinInterval ?? PARTNER_MIN_REQUEST_INTERVAL;
+        this.verbose = options.verbose ?? true;
+        this.debug = options.debug ?? false;
+        this.fetchFn = options.fetch ?? fetch;
+    }
+    progress(message) {
+        if (this.verbose) {
+            console.error(message);
+        }
+    }
+    debugStatusRaw(status) {
+        if (!this.debug) {
+            return;
+        }
+        this.progress("  raw status JSON:");
+        for (const line of JSON.stringify(status.raw, null, 2).split("\n")) {
+            this.progress(`    ${line}`);
+        }
+    }
+    async throttleBeforeRequest(path) {
+        if (!path.includes("/api/p/")) {
+            return;
+        }
+        const elapsed = (performance.now() - this.lastPartnerRequestAt) / 1000;
+        if (elapsed < this.partnerMinInterval) {
+            await sleep(this.partnerMinInterval - elapsed);
+        }
+    }
+    markRequestSent(path) {
+        if (path.includes("/api/p/")) {
+            this.lastPartnerRequestAt = performance.now();
+        }
+    }
+    async parseRetryAfter(response, attempt) {
+        const header = response.headers.get("Retry-After");
+        if (header) {
+            const parsed = Number(header);
+            if (!Number.isNaN(parsed)) {
+                return Math.max(parsed, 0.5);
+            }
+        }
+        try {
+            const body = (await response.clone().json());
+            for (const key of ["retry_after", "retryAfter", "Retry-After"]) {
+                const value = body[key];
+                if (value !== undefined) {
+                    return Math.max(Number(value), 0.5);
+                }
+            }
+        }
+        catch {
+            // ignore JSON parse errors
+        }
+        return Math.min(this.rateLimitBackoffBase * 2 ** attempt, 120);
+    }
+    async request(method, path, jsonBody) {
+        const url = joinUrl(this.baseUrl, path);
+        let lastResponse = null;
+        for (let attempt = 0; attempt <= this.rateLimitMaxRetries; attempt += 1) {
+            await this.throttleBeforeRequest(path);
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+            try {
+                lastResponse = await this.fetchFn(url, {
+                    method,
+                    headers: {
+                        "x-api-key": this.apiKey,
+                        ...(jsonBody ? { "Content-Type": "application/json" } : {}),
+                    },
+                    body: jsonBody ? JSON.stringify(jsonBody) : undefined,
+                    signal: controller.signal,
+                });
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+            this.markRequestSent(path);
+            if (lastResponse.status !== 429) {
+                return lastResponse;
+            }
+            if (attempt >= this.rateLimitMaxRetries) {
+                break;
+            }
+            const wait = await this.parseRetryAfter(lastResponse, attempt);
+            this.progress(`Rate limited on ${method} ${path}; retrying in ${wait.toFixed(1)}s ` +
+                `(attempt ${attempt + 1}/${this.rateLimitMaxRetries})`);
+            await sleep(wait);
+        }
+        if (!lastResponse) {
+            throw new RateLimitError(`Rate limited on ${method} ${path}`);
+        }
+        throw new RateLimitError(`Rate limited on ${method} ${path} after ${this.rateLimitMaxRetries} retries`, {
+            retryAfter: await this.parseRetryAfter(lastResponse, this.rateLimitMaxRetries),
+            statusCode: 429,
+            body: await lastResponse.text(),
+        });
+    }
+    async raiseApiError(response) {
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch {
+            body = await response.text();
+        }
+        if (response.status === 429) {
+            throw new RateLimitError(`HTTP 429: ${JSON.stringify(body)}`, {
+                statusCode: 429,
+                body,
+            });
+        }
+        throw new ApiError(response.status, body);
+    }
+    async health() {
+        const response = await this.fetchFn(joinUrl(this.baseUrl, "/"), {
+            headers: { "x-api-key": this.apiKey },
+            signal: AbortSignal.timeout(this.timeoutMs),
+        });
+        if (!response.ok) {
+            await this.raiseApiError(response);
+        }
+        return (await response.json());
+    }
+    async createJobFromUrl(params) {
+        if (!params.fileUrl) {
+            throw new Error("fileUrl is required");
+        }
+        if (!params.selectedVoices?.length) {
+            throw new Error("selectedVoices is required (voice display names for target language)");
+        }
+        this.progress("Submitting job (POST /api/p/jobs) …");
+        this.progress(`  source: ${params.fileUrl}`);
+        this.progress(`  ${params.originalLanguage ?? "unknown"} → ${params.targetLanguage}, ` +
+            `voices=${JSON.stringify(params.selectedVoices)}`);
+        const response = await this.request("POST", "/api/p/jobs", toJobPayload(params));
+        if (response.status >= 400) {
+            await this.raiseApiError(response);
+        }
+        const data = (await response.json());
+        const pid = String(data.pid ?? "?");
+        this.progress(`Job accepted — pid=${pid} (server is downloading media and starting job0)`);
+        return data;
+    }
+    async getJobStatus(pid) {
+        const response = await this.request("GET", `/api/p/jobs/${pid}/status`);
+        let data = {};
+        try {
+            data = (await response.json());
+        }
+        catch {
+            data = {};
+        }
+        return parseJobStatus(pid, response.status, data);
+    }
+    async waitForJob(pid, options = {}) {
+        const pollInterval = Math.max(options.pollInterval ?? DEFAULT_PARTNER_POLL_INTERVAL, this.partnerMinInterval);
+        const maxWait = options.maxWait ?? 3600;
+        const deadline = Date.now() + maxWait * 1000;
+        const started = Date.now();
+        let pollNum = 0;
+        let last = null;
+        this.progress(`Waiting for job ${pid} — polling every ${pollInterval.toFixed(0)}s ` +
+            `(timeout ${maxWait.toFixed(0)}s)`);
+        while (Date.now() < deadline) {
+            pollNum += 1;
+            last = await this.getJobStatus(pid);
+            const elapsed = (Date.now() - started) / 1000;
+            const extra = last.availableMinutes !== undefined
+                ? `, available_minutes=${last.availableMinutes.toFixed(1)}`
+                : "";
+            this.progress(`  [${elapsed.toFixed(0)}s] poll #${pollNum}: status=${last.status}${extra}`);
+            this.debugStatusRaw(last);
+            if (last.isComplete) {
+                this.progress(`Job ${pid} complete in ${elapsed.toFixed(0)}s`);
+                if (last.translatedMediaUrl) {
+                    this.progress(`  translated_media=${last.translatedMediaUrl}`);
+                }
+                return last;
+            }
+            if (last.status === "failed") {
+                throw new JobFailedError(pid, last.raw);
+            }
+            if (!last.isProcessing && last.httpStatus >= 500) {
+                throw new Error(`Job ${pid} error: ${JSON.stringify(last.raw)}`);
+            }
+            await sleep(pollInterval);
+        }
+        throw new JobTimeoutError(pid, maxWait, last?.raw ?? null);
+    }
+    async translateFromUrl(params, options = {}) {
+        const created = await this.createJobFromUrl(params);
+        return this.waitForJob(String(created.pid), options);
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_BASE_URL = "https://api.videodubber.ai";
+export declare const PARTNER_MIN_REQUEST_INTERVAL = 12;
+export declare const DEFAULT_PARTNER_POLL_INTERVAL = 15;
+export declare const DEFAULT_RATE_LIMIT_MAX_RETRIES = 8;
+export declare const DEFAULT_RATE_LIMIT_BACKOFF_BASE = 2;
+export declare const VERSION = "0.2.2";

package/dist/constants.js

@@ -0,0 +1,6 @@
+export const DEFAULT_BASE_URL = "https://api.videodubber.ai";
+export const PARTNER_MIN_REQUEST_INTERVAL = 12.0;
+export const DEFAULT_PARTNER_POLL_INTERVAL = 15.0;
+export const DEFAULT_RATE_LIMIT_MAX_RETRIES = 8;
+export const DEFAULT_RATE_LIMIT_BACKOFF_BASE = 2.0;
+export const VERSION = "0.2.2";

package/dist/errors.d.ts

@@ -0,0 +1,25 @@
+export declare class RateLimitError extends Error {
+    readonly retryAfter?: number;
+    readonly statusCode: number;
+    readonly body: unknown;
+    constructor(message: string, options?: {
+        retryAfter?: number;
+        statusCode?: number;
+        body?: unknown;
+    });
+}
+export declare class ApiError extends Error {
+    readonly statusCode: number;
+    readonly body: unknown;
+    constructor(statusCode: number, body: unknown);
+}
+export declare class JobFailedError extends Error {
+    readonly pid: string;
+    readonly raw: Record<string, unknown>;
+    constructor(pid: string, raw: Record<string, unknown>);
+}
+export declare class JobTimeoutError extends Error {
+    readonly pid: string;
+    readonly last: Record<string, unknown> | null;
+    constructor(pid: string, maxWait: number, last: Record<string, unknown> | null);
+}

package/dist/errors.js

@@ -0,0 +1,42 @@
+export class RateLimitError extends Error {
+    retryAfter;
+    statusCode;
+    body;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = "RateLimitError";
+        this.retryAfter = options.retryAfter;
+        this.statusCode = options.statusCode ?? 429;
+        this.body = options.body;
+    }
+}
+export class ApiError extends Error {
+    statusCode;
+    body;
+    constructor(statusCode, body) {
+        super(`HTTP ${statusCode}`);
+        this.name = "ApiError";
+        this.statusCode = statusCode;
+        this.body = body;
+    }
+}
+export class JobFailedError extends Error {
+    pid;
+    raw;
+    constructor(pid, raw) {
+        super(`Job ${pid} failed: ${JSON.stringify(raw)}`);
+        this.name = "JobFailedError";
+        this.pid = pid;
+        this.raw = raw;
+    }
+}
+export class JobTimeoutError extends Error {
+    pid;
+    last;
+    constructor(pid, maxWait, last) {
+        super(`Job ${pid} did not complete within ${maxWait}s`);
+        this.name = "JobTimeoutError";
+        this.pid = pid;
+        this.last = last;
+    }
+}

package/dist/format-api-error.d.ts

@@ -0,0 +1 @@
+export declare function formatApiError(body: unknown): string;

package/dist/format-api-error.js

@@ -0,0 +1,92 @@
+export function formatApiError(body) {
+    if (!body || typeof body !== "object") {
+        return String(body);
+    }
+    const record = body;
+    const lines = [];
+    const error = record.error ?? record.alert;
+    if (error) {
+        lines.push(`error: ${String(error)}`);
+    }
+    if (record.received !== undefined) {
+        lines.push(`received: ${String(record.received)}`);
+    }
+    const details = Array.isArray(record.details) ? record.details : [];
+    if (details.length) {
+        if (lines.length) {
+            lines.push("");
+        }
+        for (const detail of details) {
+            lines.push(`  - ${String(detail)}`);
+        }
+    }
+    const acceptedLangs = Array.isArray(record.accepted_target_languages)
+        ? record.accepted_target_languages
+        : [];
+    if (acceptedLangs.length) {
+        if (lines.length) {
+            lines.push("");
+        }
+        lines.push(`accepted target languages (${acceptedLangs.length}):`);
+        lines.push("");
+        for (const lang of acceptedLangs) {
+            lines.push(`  - ${String(lang)}`);
+        }
+    }
+    const acceptedVoices = Array.isArray(record.accepted_voices)
+        ? record.accepted_voices
+        : [];
+    if (acceptedVoices.length) {
+        const targetLanguage = record.target_language ?? "target language";
+        if (lines.length) {
+            lines.push("");
+        }
+        lines.push(`accepted voices for ${String(targetLanguage)} (${acceptedVoices.length}):`);
+        const byGender = { MALE: [], FEMALE: [] };
+        const other = [];
+        for (const voice of acceptedVoices) {
+            if (voice && typeof voice === "object") {
+                const voiceRecord = voice;
+                const name = String(voiceRecord.name ?? "");
+                const gender = String(voiceRecord.gender ?? "").toUpperCase();
+                if (gender === "MALE" || gender === "FEMALE") {
+                    byGender[gender].push(name);
+                }
+                else {
+                    other.push(name);
+                }
+            }
+            else {
+                other.push(String(voice));
+            }
+        }
+        for (const [genderKey, title] of [
+            ["MALE", "male voices"],
+            ["FEMALE", "female voices"],
+        ]) {
+            const names = byGender[genderKey];
+            if (names.length) {
+                lines.push("");
+                lines.push(`${title}:`);
+                for (const name of names) {
+                    lines.push(`  - ${name}`);
+                }
+            }
+        }
+        if (other.length) {
+            lines.push("");
+            lines.push("other voices:");
+            for (const name of other) {
+                lines.push(`  - ${name}`);
+            }
+        }
+    }
+    if (lines.length === 1 && error) {
+        const extra = Object.fromEntries(Object.entries(record).filter(([key]) => key !== "error" && key !== "alert"));
+        if (Object.keys(extra).length) {
+            lines.push("");
+            lines.push(JSON.stringify(extra, null, 2));
+        }
+    }
+    return lines.join("\n");
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { VERSION } from "./constants.js";
+export { DEFAULT_BASE_URL, DEFAULT_PARTNER_POLL_INTERVAL, DEFAULT_RATE_LIMIT_BACKOFF_BASE, DEFAULT_RATE_LIMIT_MAX_RETRIES, PARTNER_MIN_REQUEST_INTERVAL, } from "./constants.js";
+export { VideoDubberClient } from "./client.js";
+export { ApiError, JobFailedError, JobTimeoutError, RateLimitError, } from "./errors.js";
+export { formatApiError } from "./format-api-error.js";
+export type { CreateJobResponse, JobStatus, TranslationJobParams, VideoDubberClientOptions, WaitForJobOptions, } from "./types.js";
+export { parseJobStatus, toJobPayload } from "./types.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export { VERSION } from "./constants.js";
+export { DEFAULT_BASE_URL, DEFAULT_PARTNER_POLL_INTERVAL, DEFAULT_RATE_LIMIT_BACKOFF_BASE, DEFAULT_RATE_LIMIT_MAX_RETRIES, PARTNER_MIN_REQUEST_INTERVAL, } from "./constants.js";
+export { VideoDubberClient } from "./client.js";
+export { ApiError, JobFailedError, JobTimeoutError, RateLimitError, } from "./errors.js";
+export { formatApiError } from "./format-api-error.js";
+export { parseJobStatus, toJobPayload } from "./types.js";

package/dist/types.d.ts

@@ -0,0 +1,52 @@
+export interface TranslationJobParams {
+    fileUrl: string;
+    targetLanguage: string;
+    numSpeakers?: string;
+    projectName?: string;
+    filetype?: string;
+    originalLanguage?: string;
+    selectedVoices: string[];
+    speakers?: string[];
+    audioshift?: string;
+    translator?: string;
+    hasSubtitleFile?: boolean;
+    subtitleLanguageType?: string;
+    glossaryId?: string;
+    bg1?: string;
+    bg2?: string;
+    voiceCloning?: boolean;
+}
+export interface JobStatus {
+    pid: string;
+    status: string;
+    httpStatus: number;
+    raw: Record<string, unknown>;
+    outputUrls: Record<string, unknown>;
+    availableMinutes?: number;
+    isComplete: boolean;
+    isProcessing: boolean;
+    translatedMediaUrl?: string;
+}
+export interface VideoDubberClientOptions {
+    apiKey: string;
+    baseUrl?: string;
+    timeoutMs?: number;
+    rateLimitMaxRetries?: number;
+    rateLimitBackoffBase?: number;
+    partnerMinInterval?: number;
+    verbose?: boolean;
+    debug?: boolean;
+    fetch?: typeof fetch;
+}
+export interface WaitForJobOptions {
+    pollInterval?: number;
+    maxWait?: number;
+}
+export interface CreateJobResponse {
+    status: string;
+    pid: string;
+    project_path?: string;
+    [key: string]: unknown;
+}
+export declare function toJobPayload(params: TranslationJobParams): Record<string, unknown>;
+export declare function parseJobStatus(pid: string, httpStatus: number, data: Record<string, unknown>): JobStatus;

package/dist/types.js

@@ -0,0 +1,40 @@
+export function toJobPayload(params) {
+    return {
+        file_url: params.fileUrl,
+        filetype: params.filetype ?? "mp4",
+        OriginalLanguage: params.originalLanguage ?? "unknown",
+        TargetLanguage: params.targetLanguage,
+        NumSpeakers: params.numSpeakers ?? "1",
+        projectname: params.projectName ?? "API Project",
+        selectedvoices: params.selectedVoices,
+        speakers: params.speakers ?? ["Speaker 1"],
+        audioshift: params.audioshift ?? "0",
+        translator: params.translator ?? "auto",
+        has_subtitle_file: String(params.hasSubtitleFile ?? false).toLowerCase(),
+        subtitle_language_type: params.subtitleLanguageType ?? "source",
+        glossary_id: params.glossaryId ?? "",
+        bg1: params.bg1 ?? "Auto (Not recommended)",
+        bg2: params.bg2 ?? "0",
+        voice_cloning: params.voiceCloning ?? false,
+    };
+}
+export function parseJobStatus(pid, httpStatus, data) {
+    const status = String(data.status ?? "unknown");
+    const outputUrls = data.output_urls ?? {};
+    const translatedMediaUrl = typeof outputUrls.translated_media === "string"
+        ? outputUrls.translated_media
+        : undefined;
+    return {
+        pid,
+        status,
+        httpStatus,
+        raw: data,
+        outputUrls,
+        availableMinutes: typeof data.available_minutes === "number"
+            ? data.available_minutes
+            : undefined,
+        isComplete: status === "complete",
+        isProcessing: ["processing", "Need", "Taken_up"].includes(status),
+        translatedMediaUrl,
+    };
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "videodubber",
+  "version": "0.2.2",
+  "description": "Official JavaScript/TypeScript client for the VideoDubber.ai video translation API",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "videodubber": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "sync-version": "node scripts/sync-version.mjs",
+    "build": "npm run sync-version && tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "videodubber",
+    "videodubber.ai",
+    "video",
+    "translation",
+    "dubbing",
+    "voice-cloning",
+    "api",
+    "api-client"
+  ],
+  "author": "VideoDubber <contact@videodubber.ai>",
+  "license": "GPL-3.0-or-later",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Souvic/VideoDubber.git",
+    "directory": "js"
+  },
+  "bugs": {
+    "url": "https://github.com/Souvic/VideoDubber/issues"
+  },
+  "homepage": "https://videodubber.ai/developers/",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.21",
+    "typescript": "^5.8.3"
+  }
+}