@nodaro/sdk 2.1.0 → 2.4.0

package/dist/index.cjs

@@ -538,13 +538,19 @@ var NodesResource = class {
   get(type) {
     return this.client.request("GET", `/v1/nodes/${encodeURIComponent(type)}`);
   }
-  run(type, params = {}) {
+  run(type, params = {}, options = {}) {
     const route = type === "generate-3d-scene" ? "/v1/3d-scene/generate" : type === "edit-3d-scene" ? "/v1/3d-scene/edit" : type === "render-video" && typeof params.planType === "string" ? "/v1/render-video/plan" : `/v1/${encodeURIComponent(type)}`;
-    return this.client.request("POST", route, { body: params });
+    return this.client.request("POST", route, {
+      body: params,
+      // Transport-level retry safety, opt-in per call. The platform reads the
+      // standard header, so a caller that reuses a key on a retry gets the
+      // same run back instead of a second charge.
+      ...options.idempotencyKey ? { headers: { "Idempotency-Key": options.idempotencyKey } } : {}
+    });
   }
   async runAndWait(type, params = {}, opts = {}) {
     if (opts.signal?.aborted) throw new JobAbortedError();
-    const result = await this.run(type, params);
+    const result = await this.run(type, params, { idempotencyKey: opts.idempotencyKey });
     const jobId = extractJobId(result, type);
     return this.pollJob(jobId, type, opts);
   }
@@ -605,6 +611,10 @@ var NodesResource = class {
     }
   }
 };
+function newIdempotencyKey() {
+  const random = globalThis.crypto?.randomUUID?.();
+  return `sdk-pro3d-${random ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`}`;
+}
 var Scene3DResource = class {
   constructor(client) {
     this.client = client;
@@ -613,6 +623,22 @@ var Scene3DResource = class {
   capabilities() {
     return this.client.request("GET", "/v1/3d-scene/capabilities");
   }
+  /** Current access to both the delivery and its source is required on every read. */
+  getDelivery(jobId) {
+    return this.client.request("GET", `/v1/3d-scene/deliveries/${encodeURIComponent(jobId)}`);
+  }
+  deliveryAssetBytes(jobId, asset, options) {
+    if (asset.kind !== "poster" && asset.kind !== "validation-report" || asset.usage !== (asset.kind === "poster" ? "poster" : "validation")) {
+      throw new Error("This asset is not available through the delivery endpoint");
+    }
+    if (!Number.isSafeInteger(asset.byteLength) || asset.byteLength < 1 || asset.byteLength > shared.SCENE3D_V2_LIMITS.maxRendererAssetBytes) {
+      throw new Error("Invalid scene delivery asset byte length");
+    }
+    return this.client.requestBytes("GET", `/v1/3d-scene/deliveries/${encodeURIComponent(jobId)}/assets/${encodeURIComponent(asset.assetId)}`, {
+      signal: options?.signal,
+      maxBytes: asset.byteLength
+    });
+  }
   /** Persist deterministic overlays without an LLM or a generation charge. */
   applyEdits(revisionId, params) {
     return this.client.request("POST", `/v1/3d-scene/revisions/${encodeURIComponent(revisionId)}/edits`, { body: params });
@@ -649,6 +675,53 @@ var Scene3DResource = class {
   editAndWait(params, options) {
     return this.client.nodes.runAndWait("edit-3d-scene", params, options);
   }
+  /**
+   * Price a 3D Render Pro request WITHOUT starting it.
+   *
+   * Takes the same body a run takes, minus the `quoteId`, and answers a
+   * ceiling (`maxCredits`), a `breakdown` to show, and the
+   * `normalizedInputHash` admission re-checks. It reserves nothing and spends
+   * nothing — a quote is a price, not a purchase.
+   */
+  quotePro(params) {
+    return this.client.request("POST", "/v1/pro-3d-render/quote", { body: params });
+  }
+  /**
+   * Submit a quoted 3D Render Pro run.
+   *
+   * Requires the `quoteId` from {@link quotePro}: no run starts at a price
+   * nobody showed. Sends an `Idempotency-Key` — a fresh one per call unless you
+   * supply your own, which you should when retrying a call that timed out.
+   *
+   * Availability is a property of the deployment: `capabilities().pro` says
+   * whether this install can serve it, and which controls you may offer.
+   */
+  runPro(params, options) {
+    return this.client.nodes.run("pro-3d-render", params, {
+      idempotencyKey: options?.idempotencyKey ?? newIdempotencyKey()
+    });
+  }
+  /**
+   * Quote if needed, run, and wait — the whole operation in one call.
+   *
+   * Two HTTP requests at most, still ONE paid job: when `quoteId` is absent
+   * this quotes the identical body first, so the run is admitted against a
+   * hash of exactly what was priced. Pass a `quoteId` to run against a quote
+   * you already showed the user.
+   *
+   * Resolves with the settled result — `videoUrl` (the MP4) and `scenePlan`
+   * (the exact composition it was rendered from), plus the revision, poster,
+   * validation and renderer metadata. Re-render that same `scenePlan` later
+   * with {@link render}, or with a `{kind:'scene'}` source; that costs no
+   * authoring.
+   */
+  async renderProAndWait(params, options) {
+    const quoteId = typeof params.quoteId === "string" ? params.quoteId : (await this.quotePro(params)).quoteId;
+    return this.client.nodes.runAndWait("pro-3d-render", { ...params, quoteId }, {
+      ...options,
+      idempotencyKey: options?.idempotencyKey ?? newIdempotencyKey()
+    });
+  }
   /** Uses the supplied immutable revision; never starts authoring or a rebuild. */
   render(params) {
     return this.client.nodes.run("render-video", params);
@@ -2470,7 +2543,7 @@ var RecastResource = class {
   }
 };
 
-// src/resources/studio.ts
+// src/resources/studio-productions.ts
 function isStudioGenerateEstimate(result) {
   return result.dryRun === true;
 }
@@ -2702,11 +2775,80 @@ var StudioProductionsResource = class {
     return res.data.production;
   }
 };
+
+// src/resources/studio.ts
+var root = "/v1/studio/productions";
+var path = (id) => `${root}/${encodeURIComponent(id)}`;
 var StudioResource = class {
-  productions;
   constructor(client) {
+    this.client = client;
     this.productions = new StudioProductionsResource(client);
   }
+  client;
+  productions;
+  capabilities() {
+    return this.client.request("GET", `${root}/capabilities`);
+  }
+  skill() {
+    return this.client.request("GET", `${root}/skill`);
+  }
+  list(options = {}) {
+    return this.client.request("GET", root, { query: options });
+  }
+  get(id, options = {}) {
+    return this.client.request("GET", path(id), { query: { detail: options.detail, shot_id: options.shotId } });
+  }
+  validatePlan(plan) {
+    return this.client.request("POST", `${root}/validate`, { body: { plan } });
+  }
+  create(input) {
+    return this.client.request("POST", root, { body: input });
+  }
+  /** Import a portable document through the compatible server writer.
+   * Retained frame media requires an authorized source; acceptance never transfers. */
+  importBundle(input) {
+    return this.client.request("POST", `${root}/import-bundle`, { body: input });
+  }
+  /** Append a bundle's scenes and frame closure under an exact destination revision. */
+  appendBundle(id, input) {
+    return this.client.request("POST", `${path(id)}/import-bundle`, { body: input });
+  }
+  /** Copy a saved production. Linked copies retain verified inputs, remap
+   * dependencies and require fresh frame acceptance; they start no media jobs. */
+  clone(id, input = {}) {
+    return this.client.request("POST", `${path(id)}/clone`, { body: input });
+  }
+  edit(id, input) {
+    return this.client.request("POST", `${path(id)}/ops`, { body: input });
+  }
+  /** Audience-authorized sharing; an expected revision prevents publication
+   * of concurrent edits the caller has not reviewed. */
+  setShared(id, input) {
+    return this.client.request("POST", `${path(id)}/share`, { body: input });
+  }
+  /** Save ordinary editor fields against the loaded revision. Protected frame
+   * and job state can only change through their dedicated semantic actions. */
+  saveEditorState(id, input) {
+    return this.edit(id, {
+      baseVersion: input.expectedVersion,
+      strict: true,
+      ...input.clientRequestId ? { clientRequestId: input.clientRequestId } : {},
+      ops: [{ op: "save_editor_state", expectedVersion: input.expectedVersion, graph: input.graph }]
+    });
+  }
+  generateKeyframe(id, input) {
+    return this.client.request("POST", `${path(id)}/generate`, { body: { ...input, kind: "keyframe" } });
+  }
+  generateShot(id, input) {
+    return this.client.request("POST", `${path(id)}/generate`, { body: input });
+  }
+  /** A separate explicit review action; generation never calls this method. */
+  acceptKeyframe(id, input, concurrency = {}) {
+    return this.edit(id, { ...concurrency, ops: [{ ...input, op: "accept_keyframe_result" }] });
+  }
+  reconcile(id) {
+    return this.client.request("POST", `${path(id)}/reconcile`, { body: {} });
+  }
 };
 
 // src/resources/community.ts
@@ -3090,7 +3232,7 @@ var WorkspacesResource = class {
     return this.client.requestText("GET", `/v1/workspaces/${encodeURIComponent(id)}/usage`, { query: { ...opts, format: "csv" } });
   }
 };
-var SDK_VERSION = "2.1.0" ;
+var SDK_VERSION = "2.4.0" ;
 var CLIENT_HEADER = "X-Nodaro-Client";
 var isBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined";
 var NodaroClient = class _NodaroClient {
@@ -3222,8 +3364,8 @@ var NodaroClient = class _NodaroClient {
    * stalled CSV stream aborts, it does not hang forever). Both the JSON path
    * ({@link request}) and the text path ({@link requestText}) go through here.
    */
-  async send(method, path, options, read) {
-    const url = this.buildUrl(path, options.query);
+  async send(method, path2, options, read) {
+    const url = this.buildUrl(path2, options.query);
     const token = await this.auth.getToken();
     const isFormData = typeof FormData !== "undefined" && options.body instanceof FormData;
     const headers = {
@@ -3263,14 +3405,14 @@ var NodaroClient = class _NodaroClient {
     }
   }
   /** Authenticated, bounded binary reads through the normal timeout/error transport. */
-  async requestBytes(method, path, options) {
+  async requestBytes(method, path2, options) {
     if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 1) throw new Error("maxBytes must be a positive integer");
-    return this.send(method, path, options, (response) => readBinaryResponse(response, options.maxBytes));
+    return this.send(method, path2, options, (response) => readBinaryResponse(response, options.maxBytes));
   }
-  async request(method, path, options = {}) {
+  async request(method, path2, options = {}) {
     return this.send(
       method,
-      path,
+      path2,
       options,
       async (res) => (
         // 204 No Content
@@ -3283,8 +3425,8 @@ var NodaroClient = class _NodaroClient {
    * are still the JSON envelope and throw the same typed errors, and the read is
    * bounded by the same timeout as the request.
    */
-  async requestText(method, path, options = {}) {
-    return this.send(method, path, options, (res) => res.text());
+  async requestText(method, path2, options = {}) {
+    return this.send(method, path2, options, (res) => res.text());
   }
   /**
    * `GET /v1/me` → the authenticated user's identity (see {@link UserIdentity}).
@@ -3303,9 +3445,9 @@ var NodaroClient = class _NodaroClient {
     const res = await this.request("GET", "/v1/me");
     return res.data;
   }
-  buildUrl(path, query) {
+  buildUrl(path2, query) {
     const base = this.baseUrl || (typeof window !== "undefined" ? window.location.origin : "http://placeholder");
-    const url = new URL(path, base);
+    const url = new URL(path2, base);
     const fullUrl = this.baseUrl ? url.toString() : url.pathname + url.search;
     if (query) {
       const u = new URL(this.baseUrl ? fullUrl : fullUrl, base);