@nodaro/sdk 2.29.0 → 2.31.0

package/dist/entries/edit.js

@@ -0,0 +1,5 @@
+export { unwrapEditPlanOutput } from '../chunk-ZH4F2P2G.js';
+export { CLIP_PACK_MAX_TARGET_SEC, CLIP_PACK_MIN_TARGET_SEC, EditResource, TRAILER_FORMATS, USE_CASE_NODE_TYPES } from '../chunk-I4A5VJRL.js';
+import '../chunk-JGS6YBDW.js';
+//# sourceMappingURL=edit.js.map
+//# sourceMappingURL=edit.js.map

package/dist/entries/edit.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"edit.js"}

package/dist/entries/errors.cjs

@@ -0,0 +1,93 @@
+'use strict';
+
+require('../chunk-A2ZAFAWC.cjs');
+var chunkN6GLZOE4_cjs = require('../chunk-N6GLZOE4.cjs');
+
+
+
+Object.defineProperty(exports, "AlreadyRunningError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.AlreadyRunningError; }
+});
+Object.defineProperty(exports, "AppRunVersionChangedError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.AppRunVersionChangedError; }
+});
+Object.defineProperty(exports, "ContinuationPreviewPendingError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.ContinuationPreviewPendingError; }
+});
+Object.defineProperty(exports, "ContinuationRefusedError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.ContinuationRefusedError; }
+});
+Object.defineProperty(exports, "ForbiddenError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.ForbiddenError; }
+});
+Object.defineProperty(exports, "InsufficientCreditsError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.InsufficientCreditsError; }
+});
+Object.defineProperty(exports, "JobAbortedError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.JobAbortedError; }
+});
+Object.defineProperty(exports, "JobBlockedError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.JobBlockedError; }
+});
+Object.defineProperty(exports, "JobFailedError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.JobFailedError; }
+});
+Object.defineProperty(exports, "JobHeldError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.JobHeldError; }
+});
+Object.defineProperty(exports, "JobTimeoutError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.JobTimeoutError; }
+});
+Object.defineProperty(exports, "NodaroError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.NodaroError; }
+});
+Object.defineProperty(exports, "NotFoundError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.NotFoundError; }
+});
+Object.defineProperty(exports, "RateLimitedError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.RateLimitedError; }
+});
+Object.defineProperty(exports, "StorageExceededError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.StorageExceededError; }
+});
+Object.defineProperty(exports, "StudioOpError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.StudioOpError; }
+});
+Object.defineProperty(exports, "StudioPreviewAppliedError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.StudioPreviewAppliedError; }
+});
+Object.defineProperty(exports, "StudioPreviewUnavailable", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.StudioPreviewUnavailable; }
+});
+Object.defineProperty(exports, "UnauthorizedError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.UnauthorizedError; }
+});
+Object.defineProperty(exports, "WorkflowConflictError", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.WorkflowConflictError; }
+});
+Object.defineProperty(exports, "throwFromResponse", {
+  enumerable: true,
+  get: function () { return chunkN6GLZOE4_cjs.throwFromResponse; }
+});
+//# sourceMappingURL=errors.cjs.map
+//# sourceMappingURL=errors.cjs.map

package/dist/entries/errors.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"errors.cjs"}

package/dist/entries/errors.d.cts

@@ -0,0 +1,338 @@
+import { x as StudioOpsResponse } from '../studio-productions-DUHvdSvk.cjs';
+import '../developer-apps-zSQXWmEG.cjs';
+import '@nodaro/shared/apps';
+import '@nodaro/shared/organizations';
+
+declare class NodaroError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(message: string, code: string, status: number);
+}
+declare class UnauthorizedError extends NodaroError {
+    constructor(message?: string);
+}
+declare class ForbiddenError extends NodaroError {
+    readonly missingScope?: string | undefined;
+    constructor(message?: string, missingScope?: string | undefined);
+}
+declare class NotFoundError extends NodaroError {
+    constructor(message?: string);
+}
+declare class RateLimitedError extends NodaroError {
+    constructor(message?: string);
+}
+declare class InsufficientCreditsError extends NodaroError {
+    readonly required?: number | undefined;
+    readonly available?: number | undefined;
+    constructor(message?: string, required?: number | undefined, available?: number | undefined);
+}
+declare class StorageExceededError extends NodaroError {
+    readonly limitBytes?: number | undefined;
+    constructor(message?: string, limitBytes?: number | undefined);
+}
+/**
+ * Optimistic-concurrency rejection (HTTP 409 `workflow_conflict`): the workflow
+ * was written by another tab/device after the state carried in
+ * `expectedUpdatedAt`/`expectedVersion` was read. `currentRecord` — when the
+ * server includes it — is the full current workflow: merge your changes onto it
+ * and retry with its fresh `updatedAt`, no follow-up GET needed.
+ */
+declare class WorkflowConflictError extends NodaroError {
+    readonly currentUpdatedAt?: string | undefined;
+    readonly currentVersion?: number | undefined;
+    readonly currentRecord?: Record<string, unknown> | undefined;
+    constructor(message?: string, currentUpdatedAt?: string | undefined, currentVersion?: number | undefined, currentRecord?: Record<string, unknown> | undefined, 
+    /**
+     * The wire code this conflict actually arrived with.
+     *
+     * `production_busy` is the studio production routes' own 409: the row
+     * changed under a read-modify-write and the server exhausted its retries.
+     * It is the same situation and the same remedy — re-read and apply again —
+     * so it is the same ERROR, and a caller catching `WorkflowConflictError`
+     * handles both. The code stays truthful because a caller that logs or
+     * branches on it should see what the server said, not what the class is
+     * usually called.
+     */
+    code?: WorkflowConflictCode);
+}
+/** The 409 codes that mean "somebody else wrote first; re-read and retry". */
+type WorkflowConflictCode = "workflow_conflict" | "production_busy";
+/**
+ * A studio operation batch was refused, and the error names WHICH operation
+ * (`opIndex`, zero-based) was wrong. Nothing in the batch was written: a batch
+ * applies atomically or not at all, so fix that one operation and send the
+ * whole batch again.
+ *
+ * Selected by SHAPE — any 4xx carrying a numeric `opIndex` — not by a list of
+ * codes, so a new refusal reason (`op_invalid`, `op_target_missing`, whatever
+ * the server adds next) reaches the caller as this error without an SDK
+ * release. `code` is whatever the server sent.
+ */
+declare class StudioOpError extends NodaroError {
+    /** Zero-based index into the `ops` array that was sent. */
+    readonly opIndex: number;
+    constructor(message: string, code: string, status: number, 
+    /** Zero-based index into the `ops` array that was sent. */
+    opIndex: number);
+}
+/**
+ * A 409 that names the job to turn to instead: continuing a use-case run
+ * (`client.edit.continueUseCase`) answers `already_running` (a continuation is
+ * under way, or one that already completed — follow `jobId`),
+ * `continuation_superseded` (a later continuation failed too — continue
+ * `jobId` instead) or `render_final_already_rendered` (a Render final with this
+ * very edit already completed — `jobId` holds the result). `code` and `status`
+ * are what the server sent. Selected for exactly those three codes when the
+ * answer carries a top-level `jobId`; every other 409 stays a plain
+ * `NodaroError`.
+ */
+declare class ContinuationRefusedError extends NodaroError {
+    /** The job the refusal names. */
+    readonly jobId: string;
+    constructor(message: string, code: string, 
+    /** The job the refusal names. */
+    jobId: string);
+}
+/**
+ * The one run that finishes a continuation held at a Preview review (the
+ * `next` of {@link ContinuationPreviewPendingError}): pass these three fields
+ * to `client.workflows.run`. It continues that execution, runs each held render
+ * at Final and each held Tighten Episode continuing the run that made its
+ * Preview, then every node after them.
+ */
+interface HeldFinalRun {
+    continueFromExecutionId: string;
+    /** The nodes it runs, in canvas order. */
+    nodeIds: string[];
+    /** For this run only: each held render at Final, each held use-case node's `useCaseContinue`. */
+    inputOverrides: Record<string, Record<string, unknown>>;
+}
+/**
+ * HTTP 409 `continuation_preview_pending`: a continue-from-failed
+ * (`client.workflows.run` with `continueMode: "from-failed"`) whose run's
+ * newest later continuation completed by stopping at a Preview review, so
+ * continuing again would stop there too. `executionId` is that continuation;
+ * `renderNodeIds` the Apply EDL renders and `reviewNodeIds` the Tighten Episode
+ * nodes holding it; `next` the run that finishes them — send it first
+ * (`client.workflows.run(workflowId, error.next)`), then continue. Absent only
+ * when the server could not name it. For a single held render, `next` is that
+ * render's `client.workflows.renderFinal`.
+ */
+declare class ContinuationPreviewPendingError extends NodaroError {
+    readonly executionId: string;
+    readonly renderNodeIds: readonly string[];
+    readonly reviewNodeIds: readonly string[];
+    readonly next?: HeldFinalRun | undefined;
+    constructor(message: string, executionId: string, renderNodeIds: readonly string[], reviewNodeIds: readonly string[], next?: HeldFinalRun | undefined);
+}
+/**
+ * HTTP 409 `already_running` that names the execution under way (a top-level
+ * `executionId`): the run you asked to start or continue is still running —
+ * follow `executionId` (`client.executions.get`) instead of starting it again.
+ * Sent by the workflow run route and by an app run's Retry
+ * (`client.apps.resume`). An `already_running` that names a job instead stays
+ * {@link ContinuationRefusedError}; one that names nothing, a plain
+ * `NodaroError`.
+ */
+declare class AlreadyRunningError extends NodaroError {
+    /** The execution under way. */
+    readonly executionId: string;
+    constructor(message: string, 
+    /** The execution under way. */
+    executionId: string);
+}
+/**
+ * HTTP 409 `app_run_version_changed`: a Retry of a failed app run
+ * (`client.apps.resume`) refused because the app is on another version than
+ * the one the run ran — continuing would mix them. `runVersion` is the run's
+ * version, `appVersion` the one you are on (the `version` you sent, else the
+ * app's latest). Start the run over (`client.apps.run`) to run `appVersion`,
+ * or send `{ version: runVersion }` to continue on the run's own version.
+ * Nothing was written or billed. Selected by code; the two numbers are
+ * `undefined` when the answer does not carry them.
+ */
+declare class AppRunVersionChangedError extends NodaroError {
+    readonly runVersion?: number | undefined;
+    readonly appVersion?: number | undefined;
+    constructor(message: string, runVersion?: number | undefined, appVersion?: number | undefined);
+}
+/**
+ * HTTP 422 `job_blocked`. A job policy registered by this deployment refused
+ * the generation **before it ran** — no job was created, nothing was reserved
+ * and nothing was charged. `message` is the policy's user-safe text: show it
+ * as-is. Do not retry the identical request; whether the same input would be
+ * judged differently is the deployment's policy's business.
+ *
+ * Only occurs on deployments that register a job policy. Selected by `code`,
+ * not by status, the same way `workflow_conflict` narrows a 409 above — any
+ * other 422 stays a plain `NodaroError`.
+ */
+declare class JobBlockedError extends NodaroError {
+    constructor(message?: string);
+}
+/**
+ * A job reached a terminal `failed`/`cancelled` status while being awaited by
+ * `nodes.runAndWait` / `nodes.runMany`. Not an HTTP-level error (the polls
+ * themselves succeeded), so `status` is 0 — distinguish it by type/`code`.
+ * Carries the job's own `error_message` (as the message) and `jobId`.
+ */
+declare class JobFailedError extends NodaroError {
+    readonly jobId: string;
+    /** The terminal status that triggered the failure (`failed` | `cancelled`). */
+    readonly jobStatus: "failed" | "cancelled";
+    constructor(message: string, jobId: string, 
+    /** The terminal status that triggered the failure (`failed` | `cancelled`). */
+    jobStatus?: "failed" | "cancelled");
+}
+/**
+ * `nodes.runAndWait` polled past its `maxMs` deadline without the job reaching
+ * a terminal status. Not an HTTP error — `status` is 0; catch by type/`code`.
+ */
+declare class JobTimeoutError extends NodaroError {
+    readonly jobId: string;
+    /** The wall-clock deadline (ms) that was exceeded. */
+    readonly timeoutMs: number;
+    constructor(message: string, jobId: string, 
+    /** The wall-clock deadline (ms) that was exceeded. */
+    timeoutMs: number);
+}
+/**
+ * The caller's `AbortSignal` fired while `nodes.runAndWait` was polling (or it
+ * was already aborted on entry). Polling stops and this rejects. Not an HTTP
+ * error — `status` is 0; catch by type/`code`.
+ */
+declare class JobAbortedError extends NodaroError {
+    readonly jobId?: string | undefined;
+    constructor(message?: string, jobId?: string | undefined);
+}
+/**
+ * A batch preview was asked for and this deployment cannot give one, so
+ * NOTHING was sent: the batch is still unapplied and the production untouched.
+ *
+ * A preview is two requests because the route's body is parsed in strip mode —
+ * a deployment that predates the preview silently DROPS the flag and APPLIES
+ * the batch. So the SDK asks with an EMPTY batch first and sends the real one
+ * only when that answer carries the `dryRun` marker. This is what it throws
+ * when the answer does not: whatever the older deployment made of an empty
+ * batch, the caller's batch never left.
+ *
+ * The remedy is a deployment that serves the preview — there is nothing to
+ * retry here. To apply the batch instead, send it without the flag.
+ *
+ * A deployment that REFUSES the empty batch outright throws its own error
+ * instead of this one, which is the right way round: the route's message says
+ * more than "unavailable" does.
+ *
+ * Not an HTTP error: the request itself succeeded and answered the older shape.
+ * `status` is 0; catch by type/`code`.
+ */
+declare class StudioPreviewUnavailable extends NodaroError {
+    constructor(message?: string);
+}
+/**
+ * A batch preview was asked for and the batch was APPLIED instead. The
+ * production is written; this is the opposite of {@link
+ * StudioPreviewUnavailable}, where nothing was sent.
+ *
+ * How it happens: the preview's proving ping and the batch are two requests,
+ * and a fleet mid-rollout can serve them from different deployments. The ping
+ * answers the marker, the batch reaches a deployment that predates the preview,
+ * parses in strip mode, drops the flag and writes. The SDK cannot recall that
+ * request — by the time the answer comes back the change has landed — so it
+ * refuses to call the result a preview, which is the only thing still in its
+ * gift. `receipts` and `warnings` are on both shapes, so an unchecked reply
+ * would have shown a person what ALREADY happened under the heading of what
+ * would.
+ *
+ * `applied` is what the route answered: the ordinary apply reply, whose
+ * `production` and `version` are now the truth. Adopt them the way a plain
+ * apply's caller does — do NOT re-send the batch, and do not present it for
+ * approval.
+ *
+ * Not an HTTP error: the request succeeded, at the wrong thing. `status` is 0.
+ */
+declare class StudioPreviewAppliedError extends NodaroError {
+    /**
+     * The apply reply the route sent back, as it sent it. An answer this
+     * package does not recognise arrives here unchanged rather than being
+     * dressed up: it is what the deployment said about a batch it took.
+     *
+     * `undefined` when the answer carried no body at all — a 204, an empty
+     * envelope. The refusal still fires, because a non-preview answer is never
+     * handed back as a preview, but there is nothing to report and the SDK will
+     * not invent it: whether the batch was applied is unknown from here, and
+     * the caller settles it by re-reading the production.
+     */
+    readonly applied: StudioOpsResponse | undefined;
+    constructor(
+    /**
+     * The apply reply the route sent back, as it sent it. An answer this
+     * package does not recognise arrives here unchanged rather than being
+     * dressed up: it is what the deployment said about a batch it took.
+     *
+     * `undefined` when the answer carried no body at all — a 204, an empty
+     * envelope. The refusal still fires, because a non-preview answer is never
+     * handed back as a preview, but there is nothing to report and the SDK will
+     * not invent it: whether the batch was applied is unknown from here, and
+     * the caller settles it by re-reading the production.
+     */
+    applied: StudioOpsResponse | undefined, message?: string);
+}
+/**
+ * The awaited job entered `pending_review`: a job policy registered by this
+ * deployment held its output for a human reviewer. `pending_review` is
+ * IN-FLIGHT, not terminal, so `nodes.runAndWait` / `nodes.runMany` end the
+ * poll on the first tick they observe it rather than burning `maxMs` on a
+ * status that no longer moves on its own.
+ *
+ * This does NOT cancel the job — the output exists, a human is reviewing it,
+ * and the credit reservation stays `reserved` for the whole hold. Do not
+ * re-run the request (a duplicate would be held too): re-fetch with
+ * `jobs.get(jobId)` later, or surface "awaiting review" to your user and poll
+ * `jobs.getStatus()` yourself. It resolves to `completed` (approved), `failed`
+ * (rejected, with `error_hint.kind === "policy-block"`) or `cancelled`.
+ *
+ * Not an HTTP error — `status` is 0; catch by type/`code`.
+ */
+declare class JobHeldError extends NodaroError {
+    readonly jobId: string;
+    constructor(message: string, jobId: string);
+}
+/** The `{ error: { code, message, … } }` envelope every current route sends. */
+interface ApiErrorEnvelope {
+    code?: string;
+    message?: string;
+    missingScope?: string;
+    required?: number;
+    available?: number;
+    limitBytes?: number;
+    opIndex?: number;
+    [key: string]: unknown;
+}
+interface ApiErrorBody {
+    /** The envelope — or, on an older route, a bare string (see {@link readErrorBody}). */
+    error?: ApiErrorEnvelope | string;
+    /** A top-level message: an older route's, a bare validation answer's, or the server framework's own. */
+    message?: unknown;
+    /** OAuth's human text (RFC 6749 §5.2), beside a bare-string `error`. */
+    error_description?: unknown;
+    /** A bare validation answer's per-field issues (`{ message, issues }`). */
+    issues?: unknown;
+    /** A refusal that names another job (see {@link ContinuationRefusedError}). */
+    jobId?: unknown;
+    /** `continuation_preview_pending`: the held continuation, what holds it, and the run that finishes it. */
+    executionId?: unknown;
+    renderNodeIds?: unknown;
+    reviewNodeIds?: unknown;
+    next?: unknown;
+    /** The credit guard's 402 sends its figures beside the envelope: what the run needs… */
+    required?: unknown;
+    /** …and what the caller has (withheld on a deployment-paid instance). */
+    balance?: unknown;
+    /** `app_run_version_changed`: the version the run ran, and the one the caller is on. */
+    runVersion?: unknown;
+    appVersion?: unknown;
+}
+declare function throwFromResponse(status: number, body: ApiErrorBody): never;
+
+export { AlreadyRunningError, AppRunVersionChangedError, ContinuationPreviewPendingError, ContinuationRefusedError, ForbiddenError, type HeldFinalRun, InsufficientCreditsError, JobAbortedError, JobBlockedError, JobFailedError, JobHeldError, JobTimeoutError, NodaroError, NotFoundError, RateLimitedError, StorageExceededError, StudioOpError, StudioPreviewAppliedError, StudioPreviewUnavailable, UnauthorizedError, type WorkflowConflictCode, WorkflowConflictError, throwFromResponse };