@nodaro/sdk 2.29.0 → 2.32.0

package/dist/entries/errors.d.ts

@@ -0,0 +1,338 @@
+import { x as StudioOpsResponse } from '../studio-productions-vbCNSbtf.js';
+import '../developer-apps-zSQXWmEG.js';
+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 };

package/dist/entries/errors.js

@@ -0,0 +1,4 @@
+import '../chunk-CJFIOVBA.js';
+export { AlreadyRunningError, AppRunVersionChangedError, ContinuationPreviewPendingError, ContinuationRefusedError, ForbiddenError, InsufficientCreditsError, JobAbortedError, JobBlockedError, JobFailedError, JobHeldError, JobTimeoutError, NodaroError, NotFoundError, RateLimitedError, StorageExceededError, StudioOpError, StudioPreviewAppliedError, StudioPreviewUnavailable, UnauthorizedError, WorkflowConflictError, throwFromResponse } from '../chunk-JGS6YBDW.js';
+//# sourceMappingURL=errors.js.map
+//# sourceMappingURL=errors.js.map

package/dist/entries/errors.js.map

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

package/dist/entries/executions.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+require('../chunk-YOJ2XNQX.cjs');
+var chunkSBV5MWEL_cjs = require('../chunk-SBV5MWEL.cjs');
+
+
+
+Object.defineProperty(exports, "ExecutionsResource", {
+  enumerable: true,
+  get: function () { return chunkSBV5MWEL_cjs.ExecutionsResource; }
+});
+Object.defineProperty(exports, "OUTPUT_BEARING_NODE_STATUSES", {
+  enumerable: true,
+  get: function () { return chunkSBV5MWEL_cjs.OUTPUT_BEARING_NODE_STATUSES; }
+});
+Object.defineProperty(exports, "nodeStateMayCarryOutput", {
+  enumerable: true,
+  get: function () { return chunkSBV5MWEL_cjs.nodeStateMayCarryOutput; }
+});
+//# sourceMappingURL=executions.cjs.map
+//# sourceMappingURL=executions.cjs.map

package/dist/entries/executions.cjs.map

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

package/dist/entries/executions.d.cts

@@ -0,0 +1,120 @@
+import { N as NodaroClientCore } from '../developer-apps-zSQXWmEG.cjs';
+import { ExecutionOutcome, NodeExecutionStateWire } from '@nodaro/shared/workflow';
+export { ExecutionOutcome, NodeExecutionStatus, NodeSkipReason, OUTPUT_BEARING_NODE_STATUSES, nodeStateMayCarryOutput } from '@nodaro/shared/workflow';
+import '@nodaro/shared/apps';
+import '@nodaro/shared/organizations';
+
+type ExecutionStatus = "pending" | "running" | "completed" | "failed" | "cancelled" | "stopping" | "timed_out" | "discarded";
+type ExecutionTriggerType = "manual" | "webhook" | "schedule" | "app_run" | "single-node" | "telegram" | "telegram_account" | "api" | "mcp";
+/**
+ * Per-node state inside an execution's `nodeStates` map. Keys are node IDs.
+ *
+ * Extends the published wire contract in `@nodaro/shared`, which is what the
+ * orchestrator writes and the editor reads — so a field added there reaches
+ * SDK consumers as a typed field rather than through the index signature. The
+ * synthetic single-node-job shape from `routes/workflow-execution.ts` fits the
+ * same contract.
+ */
+interface NodeExecutionState extends NodeExecutionStateWire {
+    [key: string]: unknown;
+}
+
+/**
+ * Workflow execution record. Returned by `get()` and `cancel()` (the cancel
+ * endpoint returns `{ success: true }`, not the execution itself).
+ */
+interface WorkflowExecution {
+    id: string;
+    /**
+     * `"execution"` for an orchestrator run; `"job"` for a single-node job the
+     * list shows beside the runs (its `triggerType` is the lane that started it,
+     * `"mcp"` for an MCP client's one-node job). Absent on an older server.
+     */
+    kind?: "execution" | "job";
+    workflowId: string | null;
+    userId: string;
+    status: ExecutionStatus;
+    /**
+     * How a `completed` run ended: `"nothing_new"` when at least one node was
+     * skipped for want of input (its `nodeStates` entry carries
+     * `skipReason: "empty_input"` — a feed that found no new posts, a writer with
+     * nothing to write), `"succeeded"` otherwise. Absent until the run completes
+     * and on an older server. Derived by `executionOutcome()` (exported).
+     */
+    outcome?: ExecutionOutcome;
+    triggerType: ExecutionTriggerType;
+    triggerData?: unknown;
+    nodeStates: Record<string, NodeExecutionState>;
+    /**
+     * What a continue-from-failed of this run (`continueMode: "from-failed"`)
+     * sent no `nodeIds` considers, besides every node the run left failed or
+     * held back: the nodes the first run of its chain was started on (`nodeIds`
+     * on `/run` — Run selected, an API subset, a Render final). `null`: every
+     * node — a run of every node, one started before the nodes were recorded,
+     * or one a trigger started. Absent on an older server (= every node).
+     */
+    nodeScope?: string[] | null;
+    totalNodes: number;
+    completedNodes: number;
+    failedNodes: number;
+    totalCreditsUsed: number;
+    errorMessage: string | null;
+    startedAt: string | null;
+    completedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Summary returned by `listForWorkflow()`. Excludes per-row `triggerData`/`updatedAt`. */
+interface WorkflowExecutionSummary {
+    id: string;
+    /** See {@link WorkflowExecution.kind}. */
+    kind?: "execution" | "job";
+    status: ExecutionStatus;
+    /** See {@link WorkflowExecution.outcome}. */
+    outcome?: ExecutionOutcome;
+    triggerType: ExecutionTriggerType;
+    nodeStates: Record<string, NodeExecutionState>;
+    totalNodes: number;
+    completedNodes: number;
+    failedNodes: number;
+    totalCreditsUsed: number;
+    errorMessage: string | null;
+    startedAt: string | null;
+    completedAt: string | null;
+    createdAt: string;
+}
+interface ListExecutionsForWorkflowParams {
+    limit?: number;
+    cursor?: string;
+    /** Comma-separated list of statuses, e.g. "pending,running". */
+    status?: string;
+    /** "editor" excludes app_run / component / webhook / schedule executions. */
+    source?: "editor" | "all";
+}
+interface ListExecutionsPage<T> {
+    data: T[];
+    nextCursor?: string;
+}
+interface CancelExecutionParams {
+    /**
+     * "after_current" sets the execution to "stopping" (let in-flight nodes
+     * finish, then stop). Default behavior cancels immediately.
+     */
+    mode?: "after_current" | "discard";
+}
+declare class ExecutionsResource {
+    private client;
+    constructor(client: NodaroClientCore);
+    /** Get an execution by ID. Falls back to standalone single-node jobs server-side. */
+    get(id: string): Promise<{
+        data: WorkflowExecution;
+    }>;
+    /** List executions for a workflow. Merges workflow_executions + standalone single-node jobs. */
+    listForWorkflow(workflowId: string, params?: ListExecutionsForWorkflowParams): Promise<ListExecutionsPage<WorkflowExecutionSummary>>;
+    /** Cancel an execution. Returns `{ success: true }`. */
+    cancel(id: string, params?: CancelExecutionParams): Promise<{
+        success: true;
+    }>;
+}
+
+export { type CancelExecutionParams, type ExecutionStatus, type ExecutionTriggerType, ExecutionsResource, type ListExecutionsForWorkflowParams, type ListExecutionsPage, type NodeExecutionState, type WorkflowExecution, type WorkflowExecutionSummary };

package/dist/entries/executions.d.ts

@@ -0,0 +1,120 @@
+import { N as NodaroClientCore } from '../developer-apps-zSQXWmEG.js';
+import { ExecutionOutcome, NodeExecutionStateWire } from '@nodaro/shared/workflow';
+export { ExecutionOutcome, NodeExecutionStatus, NodeSkipReason, OUTPUT_BEARING_NODE_STATUSES, nodeStateMayCarryOutput } from '@nodaro/shared/workflow';
+import '@nodaro/shared/apps';
+import '@nodaro/shared/organizations';
+
+type ExecutionStatus = "pending" | "running" | "completed" | "failed" | "cancelled" | "stopping" | "timed_out" | "discarded";
+type ExecutionTriggerType = "manual" | "webhook" | "schedule" | "app_run" | "single-node" | "telegram" | "telegram_account" | "api" | "mcp";
+/**
+ * Per-node state inside an execution's `nodeStates` map. Keys are node IDs.
+ *
+ * Extends the published wire contract in `@nodaro/shared`, which is what the
+ * orchestrator writes and the editor reads — so a field added there reaches
+ * SDK consumers as a typed field rather than through the index signature. The
+ * synthetic single-node-job shape from `routes/workflow-execution.ts` fits the
+ * same contract.
+ */
+interface NodeExecutionState extends NodeExecutionStateWire {
+    [key: string]: unknown;
+}
+
+/**
+ * Workflow execution record. Returned by `get()` and `cancel()` (the cancel
+ * endpoint returns `{ success: true }`, not the execution itself).
+ */
+interface WorkflowExecution {
+    id: string;
+    /**
+     * `"execution"` for an orchestrator run; `"job"` for a single-node job the
+     * list shows beside the runs (its `triggerType` is the lane that started it,
+     * `"mcp"` for an MCP client's one-node job). Absent on an older server.
+     */
+    kind?: "execution" | "job";
+    workflowId: string | null;
+    userId: string;
+    status: ExecutionStatus;
+    /**
+     * How a `completed` run ended: `"nothing_new"` when at least one node was
+     * skipped for want of input (its `nodeStates` entry carries
+     * `skipReason: "empty_input"` — a feed that found no new posts, a writer with
+     * nothing to write), `"succeeded"` otherwise. Absent until the run completes
+     * and on an older server. Derived by `executionOutcome()` (exported).
+     */
+    outcome?: ExecutionOutcome;
+    triggerType: ExecutionTriggerType;
+    triggerData?: unknown;
+    nodeStates: Record<string, NodeExecutionState>;
+    /**
+     * What a continue-from-failed of this run (`continueMode: "from-failed"`)
+     * sent no `nodeIds` considers, besides every node the run left failed or
+     * held back: the nodes the first run of its chain was started on (`nodeIds`
+     * on `/run` — Run selected, an API subset, a Render final). `null`: every
+     * node — a run of every node, one started before the nodes were recorded,
+     * or one a trigger started. Absent on an older server (= every node).
+     */
+    nodeScope?: string[] | null;
+    totalNodes: number;
+    completedNodes: number;
+    failedNodes: number;
+    totalCreditsUsed: number;
+    errorMessage: string | null;
+    startedAt: string | null;
+    completedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Summary returned by `listForWorkflow()`. Excludes per-row `triggerData`/`updatedAt`. */
+interface WorkflowExecutionSummary {
+    id: string;
+    /** See {@link WorkflowExecution.kind}. */
+    kind?: "execution" | "job";
+    status: ExecutionStatus;
+    /** See {@link WorkflowExecution.outcome}. */
+    outcome?: ExecutionOutcome;
+    triggerType: ExecutionTriggerType;
+    nodeStates: Record<string, NodeExecutionState>;
+    totalNodes: number;
+    completedNodes: number;
+    failedNodes: number;
+    totalCreditsUsed: number;
+    errorMessage: string | null;
+    startedAt: string | null;
+    completedAt: string | null;
+    createdAt: string;
+}
+interface ListExecutionsForWorkflowParams {
+    limit?: number;
+    cursor?: string;
+    /** Comma-separated list of statuses, e.g. "pending,running". */
+    status?: string;
+    /** "editor" excludes app_run / component / webhook / schedule executions. */
+    source?: "editor" | "all";
+}
+interface ListExecutionsPage<T> {
+    data: T[];
+    nextCursor?: string;
+}
+interface CancelExecutionParams {
+    /**
+     * "after_current" sets the execution to "stopping" (let in-flight nodes
+     * finish, then stop). Default behavior cancels immediately.
+     */
+    mode?: "after_current" | "discard";
+}
+declare class ExecutionsResource {
+    private client;
+    constructor(client: NodaroClientCore);
+    /** Get an execution by ID. Falls back to standalone single-node jobs server-side. */
+    get(id: string): Promise<{
+        data: WorkflowExecution;
+    }>;
+    /** List executions for a workflow. Merges workflow_executions + standalone single-node jobs. */
+    listForWorkflow(workflowId: string, params?: ListExecutionsForWorkflowParams): Promise<ListExecutionsPage<WorkflowExecutionSummary>>;
+    /** Cancel an execution. Returns `{ success: true }`. */
+    cancel(id: string, params?: CancelExecutionParams): Promise<{
+        success: true;
+    }>;
+}
+
+export { type CancelExecutionParams, type ExecutionStatus, type ExecutionTriggerType, ExecutionsResource, type ListExecutionsForWorkflowParams, type ListExecutionsPage, type NodeExecutionState, type WorkflowExecution, type WorkflowExecutionSummary };

package/dist/entries/executions.js

@@ -0,0 +1,4 @@
+import '../chunk-OPR4TULG.js';
+export { ExecutionsResource, OUTPUT_BEARING_NODE_STATUSES, nodeStateMayCarryOutput } from '../chunk-Z3ZKFI2M.js';
+//# sourceMappingURL=executions.js.map
+//# sourceMappingURL=executions.js.map

package/dist/entries/executions.js.map

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

package/dist/entries/gallery.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+require('../chunk-KAIE6WJB.cjs');
+var chunkWUKIJJG2_cjs = require('../chunk-WUKIJJG2.cjs');
+
+
+
+Object.defineProperty(exports, "GalleryResource", {
+  enumerable: true,
+  get: function () { return chunkWUKIJJG2_cjs.GalleryResource; }
+});
+//# sourceMappingURL=gallery.cjs.map
+//# sourceMappingURL=gallery.cjs.map

package/dist/entries/gallery.cjs.map

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