@nodaro/sdk 2.28.0 → 2.31.0

package/dist/chunk-VT237QF2.js.map

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

package/dist/chunk-VV4TZG5S.js

@@ -0,0 +1,321 @@
+import { StudioPreviewUnavailable, StudioPreviewAppliedError } from './chunk-JGS6YBDW.js';
+
+// src/resources/studio-productions.ts
+function isStudioGenerateEstimate(result) {
+  return result.dryRun === true;
+}
+var StudioProductionsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  path(productionId, suffix = "") {
+    return `/v1/studio/productions/${encodeURIComponent(productionId)}${suffix}`;
+  }
+  // ── reads ────────────────────────────────────────────────────────────────
+  /**
+   * The authoring guide, the full catalog, the plan's JSON Schema and the
+   * operating guide — rendered server-side from the version that is live, so
+   * they describe the platform you are actually talking to. Free.
+   */
+  async skill() {
+    const res = await this.client.request(
+      "GET",
+      "/v1/studio/productions/skill"
+    );
+    return res.data;
+  }
+  /**
+   * Check a plan before it becomes anything. Free, persists nothing, and
+   * resolves cast names against YOUR library — loop on `errors` until
+   * `valid: true`, then `create({ plan })`.
+   */
+  async validatePlan(plan) {
+    const res = await this.client.request(
+      "POST",
+      "/v1/studio/productions/validate",
+      { body: { plan } }
+    );
+    return res.data;
+  }
+  /** Your productions, newest first. Archived rows are hidden unless asked for. */
+  async list(opts = {}) {
+    const res = await this.client.request(
+      "GET",
+      "/v1/studio/productions",
+      {
+        query: {
+          limit: opts.limit,
+          cursor: opts.cursor,
+          includeArchived: opts.includeArchived
+        }
+      }
+    );
+    return res.data;
+  }
+  /**
+   * One production. A pure read — it never lands a finished job, so call
+   * {@link reconcile} first if you are waiting on one.
+   */
+  async get(productionId, opts = {}) {
+    const res = await this.client.request(
+      "GET",
+      this.path(productionId),
+      { query: { detail: opts.detail, shot_id: opts.shotId } }
+    );
+    return res.data.production;
+  }
+  /**
+   * The ordered steps that assemble the film, with what they will cost. Run
+   * them yourself with the ordinary verbs — nothing here blocks for minutes,
+   * and nothing here spends.
+   */
+  async exportPlan(productionId, opts = {}) {
+    const res = await this.client.request(
+      "GET",
+      this.path(productionId, "/export-plan"),
+      { query: { upscale: opts.upscale } }
+    );
+    return res.data;
+  }
+  // ── writes ───────────────────────────────────────────────────────────────
+  /** A new production, optionally landed from a plan in the same call. */
+  async create(input = {}) {
+    const res = await this.client.request(
+      "POST",
+      "/v1/studio/productions",
+      { body: input }
+    );
+    return res.data;
+  }
+  async ops(productionId, input) {
+    if (input.dryRun !== true) {
+      const res2 = await this.client.request(
+        "POST",
+        this.path(productionId, "/ops"),
+        { body: input }
+      );
+      return res2.data;
+    }
+    const ping = await this.client.request(
+      "POST",
+      this.path(productionId, "/ops"),
+      { body: { ops: [], dryRun: true } }
+    );
+    if (ping?.data?.dryRun !== true) throw new StudioPreviewUnavailable();
+    const res = await this.client.request("POST", this.path(productionId, "/ops"), { body: input });
+    const data = res?.data;
+    if (data?.dryRun !== true) {
+      throw new StudioPreviewAppliedError(data);
+    }
+    return data;
+  }
+  /**
+   * Land every generation that has finished since you last looked, and report
+   * what is still running. The one call that turns finished jobs into results
+   * without a browser open. It writes only when something actually landed.
+   */
+  async reconcile(productionId) {
+    const res = await this.client.request(
+      "POST",
+      this.path(productionId, "/reconcile")
+    );
+    return res.data;
+  }
+  /** Add a plan's scenes to a production that already exists. */
+  async importPlan(productionId, plan, opts = {}) {
+    const res = await this.client.request(
+      "POST",
+      this.path(productionId, "/import"),
+      { body: { plan, mode: opts.mode ?? "append" } }
+    );
+    return res.data;
+  }
+  /**
+   * Turn a brief into scenes. The run is a platform job: poll it, and its
+   * scenes land through {@link reconcile}. The production comes back with the
+   * run recorded on it as a pending draft.
+   */
+  async describe(productionId, input) {
+    const res = await this.client.request(
+      "POST",
+      this.path(productionId, "/describe"),
+      { body: input }
+    );
+    return res.data;
+  }
+  async generate(productionId, input) {
+    const res = await this.client.request(
+      "POST",
+      this.path(productionId, "/generate"),
+      { body: input }
+    );
+    return res.data;
+  }
+  generateStill(productionId, shotId, opts = {}) {
+    return this.generate(productionId, { ...opts, kind: "still", shotId });
+  }
+  generateClip(productionId, shotId, opts = {}) {
+    return this.generate(productionId, { ...opts, kind: "clip", shotId });
+  }
+  // ── media on one shot ────────────────────────────────────────────────────
+  /**
+   * Extract a frame from a shot's active clip and put it where `target` says —
+   * a new shot after this one (the default), this shot's sticky start or end
+   * frame, or another still of the same shot. Seconds, not minutes: this one
+   * waits for the job and answers with the changed production.
+   */
+  async frame(productionId, input) {
+    const res = await this.client.request(
+      "POST",
+      this.path(productionId, "/frame"),
+      { body: input }
+    );
+    return res.data;
+  }
+  /** Synthesize a shot's spoken line and record it. Waits for the job. */
+  async voice(productionId, input) {
+    const res = await this.client.request(
+      "POST",
+      this.path(productionId, "/voice"),
+      { body: input }
+    );
+    return res.data;
+  }
+  /**
+   * Recast the voices of a shot's active clip. Minutes of work, so it answers
+   * `jobId` and the new clip lands as a result through its own marker.
+   */
+  async revoice(productionId, input) {
+    const res = await this.client.request(
+      "POST",
+      this.path(productionId, "/revoice"),
+      { body: input }
+    );
+    return res.data;
+  }
+  /** Score the film. The finished track lands through its pending marker. */
+  async music(productionId, input) {
+    const res = await this.client.request(
+      "POST",
+      this.path(productionId, "/music"),
+      { body: input }
+    );
+    return res.data;
+  }
+  // ── audience and copies ──────────────────────────────────────────────────
+  /**
+   * Open the share-by-link read. Deliberately its own route rather than an
+   * operation: who may see the work is decided by the owner, never as a side
+   * effect of a batch that was editing something else.
+   */
+  async share(productionId) {
+    const res = await this.client.request(
+      "POST",
+      this.path(productionId, "/share"),
+      { body: { shared: true } }
+    );
+    return res.data.production;
+  }
+  /** Close it again. Sharing is opt-in AND reversible. */
+  async unshare(productionId) {
+    const res = await this.client.request(
+      "POST",
+      this.path(productionId, "/unshare")
+    );
+    return res.data.production;
+  }
+  /**
+   * Copy a production you own or can see into your own Studio project. The
+   * copy starts PRIVATE and visible — sharing and archiving never travel — and
+   * it is copied through YOUR view of the source, so somebody else's bin does
+   * not come with it.
+   */
+  async clone(productionId, input = {}) {
+    const res = await this.client.request(
+      "POST",
+      this.path(productionId, "/clone"),
+      { body: input }
+    );
+    return res.data.production;
+  }
+};
+
+// src/resources/studio.ts
+var root = "/v1/studio/productions";
+var path = (id) => `${root}/${encodeURIComponent(id)}`;
+var StudioResource = class {
+  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: {} });
+  }
+};
+
+export { StudioProductionsResource, StudioResource, isStudioGenerateEstimate };
+//# sourceMappingURL=chunk-VV4TZG5S.js.map
+//# sourceMappingURL=chunk-VV4TZG5S.js.map

package/dist/chunk-VV4TZG5S.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/resources/studio-productions.ts","../src/resources/studio.ts"],"names":["res"],"mappings":"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","file":"chunk-VV4TZG5S.js","sourcesContent":["import type { NodaroClientCore } from \"../core.js\"\nimport { StudioPreviewAppliedError, StudioPreviewUnavailable } from \"../errors.js\"\n\n/**\n * Studio productions — `/v1/studio/productions`.\n *\n * A production is a Nodaro workflow whose `settings.studio` holds the shots:\n * each shot a framed still, an optional animated clip, and the plan, looks,\n * cast bindings and voice that made them. These routes are the platform's own\n * reader and writer of that document, so an agent, a script and the studio app\n * are looking at ONE production rather than three opinions about one row.\n *\n * Two rules run through the whole surface:\n *\n * - **Every change is an OPERATION** ({@link StudioProductionsResource.ops}),\n *   addressed by stable key — a shot id, a role slug, a result's job id or url\n *   — and never by position. That is what lets two writers hold the same\n *   production open: a batch composed against a slightly older version still\n *   applies correctly to the newest one, and the response says whether it was\n *   rebased.\n * - **Generation is run-then-poll.** A still or clip run returns job ids and\n *   records a marker on the production; the results land when anyone — your\n *   poll, the app, a later {@link StudioProductionsResource.reconcile} —\n *   reports the finished job. Nothing waits minutes inside a request.\n *\n * Reads are `detail: \"summary\"` by default (counts and the active urls);\n * `detail: \"full\"` adds every result with the context that regenerates it.\n *\n * **The ENVELOPES are typed here; the production DOCUMENT is not.** A view, a\n * summary, a shot and an operation are open JSON on this surface\n * ({@link StudioProduction}, `ops: unknown[]`) — their field-level types ship\n * with the studio app, which is the one consumer that narrows them, and a\n * second spelling of that vocabulary in the SDK would drift from it the first\n * time either grew. Everything a caller branches on — `version`, `rebased`,\n * `receipts`, `warnings`, a quote's `credits`, a run's `jobIds` — is typed.\n *\n * Cloud edition only: these routes 404 on deployments that do not serve them.\n * Feature-detect once with `list()` — a deployment without them 404s that too,\n * where a deployment with them answers an empty page.\n */\n\n/**\n * A production, a summary, a shot, a receipt's target: open JSON.\n *\n * Deliberately not narrowed here — see the note at the top of this module.\n */\nexport type StudioProduction = Record<string, unknown>\n\n/** How much of a production a read returns. */\nexport type StudioProductionDetail = \"summary\" | \"full\"\n\n/** One thing wrong with a plan, addressed at the field that is wrong. */\nexport interface StudioPlanIssue {\n  path: string\n  message: string\n  hint?: string\n}\n\n/** `GET …/skill` — the authoring skill, rendered at request time from what is live. */\nexport interface StudioSkillResponse {\n  /** The authoring guide. */\n  skill: string\n  /** Every picker, model and enum, in full. */\n  catalog: string\n  /** The strict JSON Schema a plan is validated against. */\n  schema: Record<string, unknown>\n  /** The operating guide: the tool map, the loops, the rules. */\n  operating: string\n  /** The versions the three were rendered from — bare semver, no package names. */\n  generatedFrom: { prompts: string; shared: string; codec: string }\n}\n\nexport interface StudioValidatePlanResponse {\n  valid: boolean\n  errors: StudioPlanIssue[]\n  warnings: StudioPlanIssue[]\n  summary?: {\n    name?: string\n    scenes: number\n    shots: number\n    cast: number\n    /** Cast entries that matched a row in the caller's library. */\n    bound: number\n  }\n}\n\nexport interface StudioListProductionsResponse {\n  data: StudioProduction[]\n  nextCursor?: string\n}\n\n/** What a create or an import did, in the words a receipt would use. */\nexport interface StudioImportSummary {\n  shotsAdded: number\n  castEnrolled: number\n  /** Cast entries that resolved to a row in the caller's library. */\n  castBound: number\n}\n\nexport interface StudioProductionResponse {\n  production: StudioProduction\n  warnings?: StudioPlanIssue[]\n  summary?: StudioImportSummary\n}\n\nexport interface StudioCreateProductionRequest {\n  name?: string\n  plan?: Record<string, unknown>\n}\n\n/** The caller's own retry token — 8–128 chars of `A-Za-z0-9_.:-`, never derived. */\nexport type StudioClientRequestId = string\n\n/**\n * A batch of operations, applied atomically.\n *\n * `ops` is `unknown[]`: the operation union is the studio app's vocabulary and\n * the route validates it, refusing the whole batch with the offending index.\n * The served operating guide is the runtime reference for what an operation\n * looks like.\n */\nexport interface StudioOpsRequest {\n  /** Applied in order. At most 100 per request. */\n  ops: unknown[]\n  /**\n   * The version the batch was composed against. INFORMATIONAL by default: the\n   * operations address by stable KEY, so a batch built on a slightly older\n   * document still applies exactly to the newest one, and the response says\n   * `rebased: true`. Omitting it means \"apply to whatever is there\".\n   */\n  baseVersion?: number\n  /**\n   * Refuse to rebase. With `strict: true` a `baseVersion` older than the stored\n   * one is a 409 `workflow_conflict` carrying the current production, instead\n   * of a rebased apply — for the rare \"replace exactly what I read\" intent.\n   */\n  strict?: boolean\n  /** Your own token for this batch, so a transport retry is not applied twice. */\n  clientRequestId?: StudioClientRequestId\n}\n\n/**\n * What else an operation touched — the work that now has to follow it.\n *\n * Reported by the operations whose effect reaches past the thing they name: a\n * frame review re-opens every frame derived from it and every shot bound to\n * those, a sequence fork mints a whole parallel set. Both lists are always\n * present and either may be empty; ids, never counts, because the caller's job\n * is to go and refresh THOSE.\n */\nexport interface StudioOpsImpact {\n  /** Planned frames the operation reaches, the named one first. */\n  keyframeIds: string[]\n  /** Shots bound to any of those frames. */\n  shotIds: string[]\n}\n\n/**\n * One line of what an operation did, in the words a change log would use.\n *\n * Past tense, the target named the way the user sees it, the side effect in a\n * trailing parenthetical: `Deleted take 2 of Shot 1 (in the bin).`\n */\nexport interface StudioOpsReceipt {\n  /** The operation this line reports, by name. */\n  op: string\n  /** Past tense, naming the target the way a person would. */\n  summary: string\n  /** Ids the operation MINTED — never ids the caller supplied. */\n  ids?: string[]\n  /**\n   * The dependency scope, where the operation reports one — absent for the\n   * many that touch only what they name. The route projects a receipt ONCE for\n   * both answers, so this reads the same on an apply and on a preview.\n   */\n  impact?: StudioOpsImpact\n}\n\n/** What a batch produced. Adopt `production` whole; do not merge into it. */\nexport interface StudioOpsResponse {\n  /** The canonical production AFTER the batch. */\n  production: StudioProduction\n  /** The version the batch produced. Carry it as the next `baseVersion`. */\n  version: number\n  /** True when the batch was applied to a newer document than it named. */\n  rebased: boolean\n  /** One per operation, in order. */\n  receipts: StudioOpsReceipt[]\n  /**\n   * Things worth saying that are not failures — an operation that changed\n   * nothing, a rename that rewrote four prompts. A warning never rejects a\n   * batch; a refusal does.\n   */\n  warnings: string[]\n}\n\n/**\n * An operation's confirmation class — the vocabulary's own four letters.\n *\n * `S` safe · `D` delete · `P` changes who can reach the work · `$` spends\n * credits. The table that assigns them ships with the production codec and is\n * pinned complete over the operation union there; this is the wire's spelling\n * of its values, not a second table.\n */\nexport type StudioOpClass = \"S\" | \"D\" | \"P\" | \"$\"\n\n/**\n * One line of what an operation WOULD do, for a person deciding whether to let\n * it. Everything {@link StudioOpsReceipt} says — the same summary, the same ids\n * and the same {@link StudioOpsImpact}, read in the conditional — plus the two\n * things the decision turns on and only a preview needs: which kind of change\n * it is, and whether it can be taken back.\n */\nexport interface StudioOpsDryRunReceipt extends StudioOpsReceipt {\n  /**\n   * The confirmation class, read out of the operation vocabulary's own table:\n   * `S` safe, `D` deletes, `P` changes who can reach the work, `$` spends\n   * credits. Narrow rather than open, because it is what a caller branches on\n   * — a rule like \"never a `D` without asking\" is only writable if the\n   * compiler knows the letters.\n   */\n  class: StudioOpClass\n  /**\n   * Present, and always `true`, when this operation put something in the bin\n   * that can be brought back. ABSENT is the honest answer for everything else,\n   * including a delete that destroys: there is no entry to name, so there is no\n   * promise to make. Read it as `restorable ?? false`, never as `!restorable`\n   * meaning \"kept\".\n   */\n  restorable?: true\n}\n\n/**\n * What a batch WOULD do. Nothing was written: there is no production here and\n * no new version, because none was produced.\n */\nexport interface StudioOpsDryRunResponse {\n  /** Always present, and the marker the two-request protocol reads. */\n  dryRun: true\n  /** The version the preview was computed against. */\n  version: number\n  /** One per operation, in order. */\n  receipts: StudioOpsDryRunReceipt[]\n  /** The same things an apply would have said. */\n  warnings: string[]\n}\n\n/** What landing the finished jobs did. */\nexport interface StudioReconcileResponse {\n  /** Job ids whose media is now on the production. */\n  landed: string[]\n  /** Job ids still running — their markers stay; call again later. */\n  pending: string[]\n  /** Job ids that failed or were cancelled; their markers are cleared. */\n  failed: string[]\n  /** One line per landing that had something to say. */\n  warnings: string[]\n  /** The production after the landings. */\n  production: StudioProduction\n  /** Its version — unchanged when nothing landed. */\n  version: number\n}\n\n/** `POST …/:id/describe` — a Director run that will land as scenes. */\nexport interface StudioDescribeRequest {\n  brief: string\n  llmModel: string\n  /** `\"append\"` adds the drafted scenes; `\"replace\"` rewrites the film. */\n  mode?: \"append\" | \"replace\"\n  label?: string\n  clientRequestId?: StudioClientRequestId\n}\n\n/**\n * `POST …/:id/generate` — one framing or directing run for one shot.\n *\n * `overrides` is what the CALL owns over what the shot's plan says: the model,\n * the prose, the aspect, the direction ids. Open JSON, because the request\n * builders' own option types are the contract and they ship with the studio.\n */\nexport interface StudioGenerateRequest {\n  kind: \"still\" | \"clip\"\n  shotId: string\n  /** Candidates to fan out (stills); the builder clamps it to the catalog's range. */\n  count?: number\n  /**\n   * The directing input mode for a clip; absent ⇒ derived from the scene's saved\n   * inputs (a pinned end frame included). `start` sends ONLY the start frame;\n   * `start-end` sends the start and the end frame.\n   */\n  mode?: \"start\" | \"start-end\" | \"references\"\n  /** Price the run and return; nothing is submitted and nothing is written. */\n  dryRun?: boolean\n  clientRequestId?: StudioClientRequestId\n  overrides?: Record<string, unknown>\n}\n\n/** Which video route a directing run went to — chosen from the inputs, never asked for. */\nexport type StudioVideoLane = \"generate-video\" | \"text-to-video\"\n\n/** `dryRun: true` — what this run would cost, and nothing else. */\nexport interface StudioGenerateEstimate {\n  dryRun: true\n  provider: string\n  count: number\n  /** `null` when the model is unpriced or the instance runs without credits. */\n  credits: number | null\n  lane?: StudioVideoLane\n}\n\n/**\n * A started (or already-started) run.\n *\n * `deduped` means the same `clientRequestId` came back and the job ids were\n * answered from the production's own markers — nothing was submitted and\n * nothing was charged, so `production` is absent.\n */\nexport interface StudioGenerateResponse {\n  jobIds: string[]\n  lane?: StudioVideoLane\n  deduped?: true\n  production?: StudioProduction\n  receipts?: StudioOpsReceipt[]\n  warnings?: string[]\n}\n\n/** `POST …/:id/frame` — a still pulled out of the shot's clip. */\nexport interface StudioFrameRequest {\n  shotId: string\n  mode?: \"first\" | \"last\" | \"timestamp\"\n  /** Seconds, when `mode` is `\"timestamp\"`. */\n  timestamp?: number\n  /** Where the grabbed image lands. `\"new-shot\"` inserts a shot after this one. */\n  target?: \"new-shot\" | \"start-frame\" | \"end-frame\" | \"still\"\n  clientRequestId?: StudioClientRequestId\n}\n\n/** `POST …/:id/voice` — synthesize a shot's spoken line and record it. */\nexport interface StudioVoiceRequest {\n  shotId: string\n  text: string\n  voiceId?: string\n  voiceType?: \"premade\" | \"custom\" | \"library\"\n  ttsProvider?: string\n  /** The delivery levers; the text-to-speech route owns their bounds. */\n  delivery?: Record<string, number>\n  clientRequestId?: StudioClientRequestId\n}\n\n/** `POST …/:id/revoice` — recast the voices of the shot's active clip. */\nexport interface StudioRevoiceRequest {\n  shotId: string\n  /** The speaker-ordered recast plan, forwarded to the voice route verbatim. */\n  plan: Record<string, unknown>\n  clientRequestId?: StudioClientRequestId\n}\n\n/** `POST …/:id/music` — the film's soundtrack. */\nexport interface StudioMusicRequest {\n  prompt: string\n  duration?: number\n  instrumental?: boolean\n  vocalGender?: string\n  model?: string\n  clientRequestId?: StudioClientRequestId\n}\n\n/**\n * What a route that finished its work answers with: the production as it now\n * stands, plus whatever that route produced.\n *\n * `jobId` is present on the routes that only STARTED something (a revoice, a\n * soundtrack, a draft) — the result lands through its marker.\n */\nexport interface StudioMediaResponse {\n  production: StudioProduction\n  /** The grabbed frame's url, on the frame route. */\n  url?: string\n  jobId?: string\n  receipts?: StudioOpsReceipt[]\n  warnings?: string[]\n}\n\n/**\n * `GET …/:id/export-plan` — the ordered steps an export would run.\n *\n * The caller runs them with the verbs that already exist; a route that chained\n * three minutes-long jobs is the long-lived request every client times out on.\n */\nexport interface StudioExportPlanResponse {\n  /** False when the production has fewer than two clips — nothing to stitch. */\n  canExport: boolean\n  steps: StudioExportStep[]\n  /** The step whose output IS the film, or `null` when nothing can run. */\n  resultStepId: string | null\n  /** Total credits, or `null` when ANY step is unpriced (a partial sum understates). */\n  estimate: number | null\n  /** The credit models with no price, each named once, in step order. */\n  unpriced: string[]\n}\n\nexport interface StudioExportStep {\n  /** Stable within one plan and derived from the production, never minted. */\n  id: string\n  label: string\n  /** The node this step runs — `merge-video-audio`, `combine-videos`, `video-upscale`. */\n  node: string\n  creditModel: string\n  credits: number | null\n  params: Record<string, unknown>\n}\n\n/** `POST …/:id/clone` — a copy, which always starts private and visible. */\nexport interface StudioCloneRequest {\n  name?: string\n}\n\n/** Either arm of a generation reply: the quote, or the run that started. */\nexport type StudioGenerateResult = StudioGenerateEstimate | StudioGenerateResponse\n\n/** True when a generation reply is the `dryRun` QUOTE rather than a started run. */\nexport function isStudioGenerateEstimate(\n  result: StudioGenerateResult,\n): result is StudioGenerateEstimate {\n  return (result as StudioGenerateEstimate).dryRun === true\n}\n\n/** What a `generateStill` / `generateClip` call decides, beyond `kind` and the shot. */\nexport type StudioGenerateOptions = Omit<StudioGenerateRequest, \"kind\" | \"shotId\">\n\n/**\n * A route that only STARTED something — a draft, a revoice, a soundtrack. Its\n * `jobId` is always there, which is what makes `const { jobId } = await …` and\n * a poll the honest next line.\n *\n * `StudioMediaResponse` leaves `jobId` optional because the routes that FINISH\n * their work (a frame, a voiceover) share the shape and have no job to name.\n */\nexport type StudioJobStartedResponse = StudioMediaResponse & { jobId: string }\n\nexport interface ListStudioProductionsOptions {\n  limit?: number\n  /** From a previous page's `nextCursor`. */\n  cursor?: string\n  /** Include the rows the dashboard hides. Off by default. */\n  includeArchived?: boolean\n}\n\nexport interface GetProductionOptions {\n  detail?: StudioProductionDetail\n  /** Read ONE shot — the cheap way to re-read after a generation. */\n  shotId?: string\n}\n\nexport interface StudioExportPlanOptions {\n  /** Plan the 4K finish too. Expensive, so it is always explicit. */\n  upscale?: boolean\n}\n\n/** `client.studio.productions` — see the note at the top of this module. */\nexport class StudioProductionsResource {\n  constructor(private client: NodaroClientCore) {}\n\n  private path(productionId: string, suffix = \"\"): string {\n    return `/v1/studio/productions/${encodeURIComponent(productionId)}${suffix}`\n  }\n\n  // ── reads ────────────────────────────────────────────────────────────────\n\n  /**\n   * The authoring guide, the full catalog, the plan's JSON Schema and the\n   * operating guide — rendered server-side from the version that is live, so\n   * they describe the platform you are actually talking to. Free.\n   */\n  async skill(): Promise<StudioSkillResponse> {\n    const res = await this.client.request<{ data: StudioSkillResponse }>(\n      \"GET\",\n      \"/v1/studio/productions/skill\",\n    )\n    return res.data\n  }\n\n  /**\n   * Check a plan before it becomes anything. Free, persists nothing, and\n   * resolves cast names against YOUR library — loop on `errors` until\n   * `valid: true`, then `create({ plan })`.\n   */\n  async validatePlan(plan: Record<string, unknown>): Promise<StudioValidatePlanResponse> {\n    const res = await this.client.request<{ data: StudioValidatePlanResponse }>(\n      \"POST\",\n      \"/v1/studio/productions/validate\",\n      { body: { plan } },\n    )\n    return res.data\n  }\n\n  /** Your productions, newest first. Archived rows are hidden unless asked for. */\n  async list(opts: ListStudioProductionsOptions = {}): Promise<StudioListProductionsResponse> {\n    const res = await this.client.request<{ data: StudioListProductionsResponse }>(\n      \"GET\",\n      \"/v1/studio/productions\",\n      {\n        query: {\n          limit: opts.limit,\n          cursor: opts.cursor,\n          includeArchived: opts.includeArchived,\n        },\n      },\n    )\n    return res.data\n  }\n\n  /**\n   * One production. A pure read — it never lands a finished job, so call\n   * {@link reconcile} first if you are waiting on one.\n   */\n  async get(\n    productionId: string,\n    opts: GetProductionOptions = {},\n  ): Promise<StudioProduction> {\n    const res = await this.client.request<{ data: { production: StudioProduction } }>(\n      \"GET\",\n      this.path(productionId),\n      { query: { detail: opts.detail, shot_id: opts.shotId } },\n    )\n    return res.data.production\n  }\n\n  /**\n   * The ordered steps that assemble the film, with what they will cost. Run\n   * them yourself with the ordinary verbs — nothing here blocks for minutes,\n   * and nothing here spends.\n   */\n  async exportPlan(\n    productionId: string,\n    opts: StudioExportPlanOptions = {},\n  ): Promise<StudioExportPlanResponse> {\n    const res = await this.client.request<{ data: StudioExportPlanResponse }>(\n      \"GET\",\n      this.path(productionId, \"/export-plan\"),\n      { query: { upscale: opts.upscale } },\n    )\n    return res.data\n  }\n\n  // ── writes ───────────────────────────────────────────────────────────────\n\n  /** A new production, optionally landed from a plan in the same call. */\n  async create(input: StudioCreateProductionRequest = {}): Promise<StudioProductionResponse> {\n    const res = await this.client.request<{ data: StudioProductionResponse }>(\n      \"POST\",\n      \"/v1/studio/productions\",\n      { body: input },\n    )\n    return res.data\n  }\n\n  /**\n   * Apply a batch of operations. Atomic: one bad operation refuses the whole\n   * batch with a `StudioOpError` naming its index, and nothing is written. On\n   * success adopt `production` wholesale and carry `version` forward as the\n   * next `baseVersion`.\n   *\n   * `dryRun: true` — the LITERAL, which is what selects the preview reply —\n   * asks what the batch would do, so a person can approve an assistant's edits\n   * before they land. Spell it in THIS call's own object literal: a flag passed\n   * through a variable widens `true` to `boolean`, which selects the apply\n   * overload while the runtime still takes the preview path.\n   *\n   * A preview is TWO requests, deliberately. The route's body is parsed in\n   * strip mode, so a deployment that predates the preview drops the flag and\n   * APPLIES the batch: a caller that sent its batch and read the answer\n   * afterwards would already have written it. So the flag is proved on an EMPTY\n   * batch first and the real batch goes only when that answer carries the\n   * marker. An older deployment either answers the apply shape — this throws\n   * `StudioPreviewUnavailable`, and the batch never leaves — or refuses the\n   * empty batch with its own error, which is passed through as it stands.\n   *\n   * The ping proves the deployment that answered IT, and a fleet mid-rollout\n   * can serve the second request from another one. So the second answer is\n   * checked too: when the batch came back APPLIED, this throws\n   * `StudioPreviewAppliedError`, which carries that write. The SDK cannot\n   * un-send a request; what it can do is refuse to call the result a preview.\n   *\n   * An apply stays exactly one request.\n   */\n  ops(\n    productionId: string,\n    input: StudioOpsRequest & { dryRun: true },\n  ): Promise<StudioOpsDryRunResponse>\n  ops(productionId: string, input: StudioOpsRequest): Promise<StudioOpsResponse>\n  async ops(\n    productionId: string,\n    input: StudioOpsRequest & { dryRun?: true },\n  ): Promise<StudioOpsResponse | StudioOpsDryRunResponse> {\n    if (input.dryRun !== true) {\n      const res = await this.client.request<{ data: StudioOpsResponse }>(\n        \"POST\",\n        this.path(productionId, \"/ops\"),\n        { body: input },\n      )\n      return res.data\n    }\n\n    // The ping carries nothing of the caller's batch, because an old deployment\n    // takes whatever it is sent at face value; an empty batch with no\n    // `clientRequestId` spends neither the caller's operations nor the retry\n    // token that would make a real batch unrepeatable.\n    const ping = await this.client.request<{ data?: { dryRun?: unknown } } | undefined>(\n      \"POST\",\n      this.path(productionId, \"/ops\"),\n      { body: { ops: [], dryRun: true } },\n    )\n    // Read through: an older deployment can answer no envelope at all, or a 204\n    // that `request` reads as `undefined`. Absent is a \"no\" like any other, and\n    // the caller who catches `NodaroError` should not get a `TypeError`.\n    if (ping?.data?.dryRun !== true) throw new StudioPreviewUnavailable()\n\n    const res = await this.client.request<\n      { data?: StudioOpsDryRunResponse | StudioOpsResponse } | undefined\n    >(\"POST\", this.path(productionId, \"/ops\"), { body: input })\n    // The answer that matters most: this request may have landed on a different\n    // deployment from the ping, and an applied batch is not a preview.\n    const data = res?.data\n    if ((data as { dryRun?: unknown } | undefined)?.dryRun !== true) {\n      throw new StudioPreviewAppliedError(data as StudioOpsResponse)\n    }\n    return data as StudioOpsDryRunResponse\n  }\n\n  /**\n   * Land every generation that has finished since you last looked, and report\n   * what is still running. The one call that turns finished jobs into results\n   * without a browser open. It writes only when something actually landed.\n   */\n  async reconcile(productionId: string): Promise<StudioReconcileResponse> {\n    const res = await this.client.request<{ data: StudioReconcileResponse }>(\n      \"POST\",\n      this.path(productionId, \"/reconcile\"),\n    )\n    return res.data\n  }\n\n  /** Add a plan's scenes to a production that already exists. */\n  async importPlan(\n    productionId: string,\n    plan: Record<string, unknown>,\n    opts: { mode?: \"append\" } = {},\n  ): Promise<StudioProductionResponse> {\n    const res = await this.client.request<{ data: StudioProductionResponse }>(\n      \"POST\",\n      this.path(productionId, \"/import\"),\n      { body: { plan, mode: opts.mode ?? \"append\" } },\n    )\n    return res.data\n  }\n\n  /**\n   * Turn a brief into scenes. The run is a platform job: poll it, and its\n   * scenes land through {@link reconcile}. The production comes back with the\n   * run recorded on it as a pending draft.\n   */\n  async describe(\n    productionId: string,\n    input: StudioDescribeRequest,\n  ): Promise<StudioJobStartedResponse> {\n    const res = await this.client.request<{ data: StudioJobStartedResponse }>(\n      \"POST\",\n      this.path(productionId, \"/describe\"),\n      { body: input },\n    )\n    return res.data\n  }\n\n  // ── generation ───────────────────────────────────────────────────────────\n\n  /**\n   * Frame or animate one shot.\n   *\n   * The request is assembled server-side from the shot's own plan, looks and\n   * bound references, so a scripted run and a press of the button in the app\n   * produce the same media; `overrides` changes THIS run without changing the\n   * shot. Prefer {@link generateStill} / {@link generateClip}, which say which\n   * kind they mean.\n   *\n   * `dryRun: true` returns the quote and writes nothing — narrow the reply with\n   * {@link isStudioGenerateEstimate}.\n   */\n  generate(\n    productionId: string,\n    input: StudioGenerateRequest & { dryRun: true },\n  ): Promise<StudioGenerateEstimate>\n  generate(\n    productionId: string,\n    input: StudioGenerateRequest,\n  ): Promise<StudioGenerateResult>\n  async generate(\n    productionId: string,\n    input: StudioGenerateRequest,\n  ): Promise<StudioGenerateResult> {\n    const res = await this.client.request<{ data: StudioGenerateResult }>(\n      \"POST\",\n      this.path(productionId, \"/generate\"),\n      { body: input },\n    )\n    return res.data\n  }\n\n  /**\n   * Frame a shot: submit `count` candidates and record a pending marker for\n   * each. Results ACCUMULATE — a generate never replaces what is there.\n   *\n   * `clientRequestId` makes a retry safe: the same token answers with the jobs\n   * the first call started (`deduped: true`) and submits nothing. Never retry a\n   * spend without it.\n   */\n  generateStill(\n    productionId: string,\n    shotId: string,\n    opts: StudioGenerateOptions & { dryRun: true },\n  ): Promise<StudioGenerateEstimate>\n  generateStill(\n    productionId: string,\n    shotId: string,\n    opts?: StudioGenerateOptions,\n  ): Promise<StudioGenerateResult>\n  generateStill(\n    productionId: string,\n    shotId: string,\n    opts: StudioGenerateOptions = {},\n  ): Promise<StudioGenerateResult> {\n    return this.generate(productionId, { ...opts, kind: \"still\", shotId })\n  }\n\n  /**\n   * Animate a shot. The LANE is chosen from the shot's inputs (a start frame,\n   * references, a prompt) — never passed in — and reported back as `lane`.\n   */\n  generateClip(\n    productionId: string,\n    shotId: string,\n    opts: StudioGenerateOptions & { dryRun: true },\n  ): Promise<StudioGenerateEstimate>\n  generateClip(\n    productionId: string,\n    shotId: string,\n    opts?: StudioGenerateOptions,\n  ): Promise<StudioGenerateResult>\n  generateClip(\n    productionId: string,\n    shotId: string,\n    opts: StudioGenerateOptions = {},\n  ): Promise<StudioGenerateResult> {\n    return this.generate(productionId, { ...opts, kind: \"clip\", shotId })\n  }\n\n  // ── media on one shot ────────────────────────────────────────────────────\n\n  /**\n   * Extract a frame from a shot's active clip and put it where `target` says —\n   * a new shot after this one (the default), this shot's sticky start or end\n   * frame, or another still of the same shot. Seconds, not minutes: this one\n   * waits for the job and answers with the changed production.\n   */\n  async frame(\n    productionId: string,\n    input: StudioFrameRequest,\n  ): Promise<StudioMediaResponse> {\n    const res = await this.client.request<{ data: StudioMediaResponse }>(\n      \"POST\",\n      this.path(productionId, \"/frame\"),\n      { body: input },\n    )\n    return res.data\n  }\n\n  /** Synthesize a shot's spoken line and record it. Waits for the job. */\n  async voice(\n    productionId: string,\n    input: StudioVoiceRequest,\n  ): Promise<StudioMediaResponse> {\n    const res = await this.client.request<{ data: StudioMediaResponse }>(\n      \"POST\",\n      this.path(productionId, \"/voice\"),\n      { body: input },\n    )\n    return res.data\n  }\n\n  /**\n   * Recast the voices of a shot's active clip. Minutes of work, so it answers\n   * `jobId` and the new clip lands as a result through its own marker.\n   */\n  async revoice(\n    productionId: string,\n    input: StudioRevoiceRequest,\n  ): Promise<StudioJobStartedResponse> {\n    const res = await this.client.request<{ data: StudioJobStartedResponse }>(\n      \"POST\",\n      this.path(productionId, \"/revoice\"),\n      { body: input },\n    )\n    return res.data\n  }\n\n  /** Score the film. The finished track lands through its pending marker. */\n  async music(\n    productionId: string,\n    input: StudioMusicRequest,\n  ): Promise<StudioJobStartedResponse> {\n    const res = await this.client.request<{ data: StudioJobStartedResponse }>(\n      \"POST\",\n      this.path(productionId, \"/music\"),\n      { body: input },\n    )\n    return res.data\n  }\n\n  // ── audience and copies ──────────────────────────────────────────────────\n\n  /**\n   * Open the share-by-link read. Deliberately its own route rather than an\n   * operation: who may see the work is decided by the owner, never as a side\n   * effect of a batch that was editing something else.\n   */\n  async share(productionId: string): Promise<StudioProduction> {\n    const res = await this.client.request<{ data: StudioMediaResponse }>(\n      \"POST\",\n      this.path(productionId, \"/share\"),\n      { body: { shared: true } },\n    )\n    return res.data.production\n  }\n\n  /** Close it again. Sharing is opt-in AND reversible. */\n  async unshare(productionId: string): Promise<StudioProduction> {\n    const res = await this.client.request<{ data: StudioMediaResponse }>(\n      \"POST\",\n      this.path(productionId, \"/unshare\"),\n    )\n    return res.data.production\n  }\n\n  /**\n   * Copy a production you own or can see into your own Studio project. The\n   * copy starts PRIVATE and visible — sharing and archiving never travel — and\n   * it is copied through YOUR view of the source, so somebody else's bin does\n   * not come with it.\n   */\n  async clone(\n    productionId: string,\n    input: StudioCloneRequest = {},\n  ): Promise<StudioProduction> {\n    const res = await this.client.request<{ data: { production: StudioProduction } }>(\n      \"POST\",\n      this.path(productionId, \"/clone\"),\n      { body: input },\n    )\n    return res.data.production\n  }\n}\n\n","import type { NodaroClientCore } from \"../core.js\"\nimport { StudioProductionsResource } from \"./studio-productions.js\"\nexport * from \"./studio-productions.js\"\n\n/** Public response/transport contracts only; document validation and planning\n * remain in the private Studio codec on the server. */\nexport type StudioDocumentJson = Record<string, unknown>\n\nexport interface StudioProductionCapabilities {\n  planVersions: number[]\n  operations: {\n    readKeyframes: boolean\n    saveEditorState?: boolean\n    editableSharedCopies?: boolean\n    revisionedSharing?: boolean\n    cloneLinkedProductions?: boolean\n    importPlannedBundles?: boolean\n    importLinkedBundles?: boolean\n    appendPlannedBundles?: boolean\n    appendLinkedBundles?: boolean\n    editKeyframes: boolean\n    generateKeyframes: boolean\n    acceptKeyframes: boolean\n    rejectKeyframes?: boolean\n    editSequencePlans?: boolean\n    generateLinkedClips: boolean\n    retakeLinkedClips?: boolean\n    /** The host keeps a scene's empty media slots. */\n    mediaSlots?: boolean\n    /** The host keeps a clip's inputs on its clip slot. */\n    clipSlotInputs?: boolean\n  }\n  sourceFrameReferences: boolean\n  automaticAcceptance: false\n  unattendedGeneration: false\n}\n\nexport interface StudioKeyframeRecord {\n  id: string\n  label: string\n  revision: number\n  nodeId: string\n  parentKeyframeId?: string\n  previewResultKey: string | null\n  previewUrl: string | null\n  acceptedResultKey: string | null\n  acceptedUrl: string | null\n  count: number\n  pending: Array<{ jobId: string; startedAt: string }>\n  /** Owner-only working state. Recorded acceptance is not an execution grant. */\n  plan?: StudioDocumentJson\n  acceptance?: StudioDocumentJson\n  results?: StudioDocumentJson[]\n}\n\nexport interface StudioProductionRecord {\n  id: string\n  name: string\n  version: number\n  updatedAt: string\n  thumbnailUrl: string | null\n  shared: boolean\n  archived: boolean\n  requiredCapabilities?: string[]\n  keyframes?: StudioKeyframeRecord[]\n  sequences?: StudioDocumentJson[]\n  shots: StudioDocumentJson[]\n  pending: { stills: number; clips: number; keyframes?: number; music: boolean; draft: StudioDocumentJson | null }\n  [field: string]: unknown\n}\n\nexport interface StudioProductionReply {\n  production: StudioProductionRecord\n  capabilities?: StudioProductionCapabilities\n  warnings?: unknown[]\n  [field: string]: unknown\n}\n\nexport interface StudioEditInput {\n  ops: ReadonlyArray<{ op: string; [field: string]: unknown }>\n  baseVersion?: number\n  strict?: boolean\n  clientRequestId?: string\n}\n\nexport interface StudioKeyframeGenerationInput {\n  keyframeId: string\n  expectedRevision: number\n  clientRequestId?: string\n  overrides?: StudioDocumentJson\n}\n\nexport interface StudioKeyframeAcceptanceInput {\n  keyframeId: string\n  expectedRevision: number\n  resultKey: string\n  expectedAcceptedResultKey: string | null\n  requirementChecks: Array<{ requirementId: string; outcome: \"pass\" | \"waived\" }>\n  waivedReason?: string\n}\n\nexport interface StudioShotGenerationInput {\n  kind: \"still\" | \"clip\"\n  shotId: string\n  clientRequestId?: string\n  count?: number\n  mode?: \"start\" | \"start-end\" | \"references\"\n  dryRun?: boolean\n  /** Linked clips only: require the exact inputs returned by a reviewed quote. */\n  expectedInputHash?: string\n  /** Retake a native linked take using its original request and retained endpoints. */\n  retakeResultKey?: string\n  overrides?: StudioDocumentJson\n}\n\nexport type StudioGenerationReply = {\n  jobIds: string[]\n  production?: StudioProductionRecord\n  deduped?: true\n  lane?: string\n  [field: string]: unknown\n} | {\n  dryRun: true; provider: string; count: number; credits: number | null; lane?: string\n  /** Linked-clip quotes include normalized settings and accepted endpoint pins. */\n  inputHash?: string\n  endpointPins?: StudioDocumentJson\n  creditIdentifier?: string\n  duration?: number\n  resolution?: string\n  aspectRatio?: string\n  sound?: boolean\n}\n\nconst root = \"/v1/studio/productions\"\nconst path = (id: string) => `${root}/${encodeURIComponent(id)}`\n\n/** Cloud plugin routes. Check capabilities before exposing dependency controls.\n * Reads do not reconcile jobs, submit media or accept generated candidates. */\nexport class StudioResource {\n  readonly productions: StudioProductionsResource\n\n  constructor(private readonly client: NodaroClientCore) {\n    this.productions = new StudioProductionsResource(client)\n  }\n\n  capabilities(): Promise<{ data: StudioProductionCapabilities }> {\n    return this.client.request(\"GET\", `${root}/capabilities`)\n  }\n\n  skill(): Promise<{ data: StudioDocumentJson }> {\n    return this.client.request(\"GET\", `${root}/skill`)\n  }\n\n  list(options: { limit?: number; cursor?: string; includeArchived?: boolean } = {}): Promise<{ data: {\n    data: Array<{ id: string; name: string; version: number; updatedAt: string; thumbnailUrl: string | null; shared: boolean; archived: boolean; shotCount: number }>\n    nextCursor?: string\n  } }> {\n    return this.client.request(\"GET\", root, { query: options })\n  }\n\n  get(id: string, options: { detail?: \"summary\" | \"full\"; shotId?: string } = {}): Promise<{ data: StudioProductionReply }> {\n    return this.client.request(\"GET\", path(id), { query: { detail: options.detail, shot_id: options.shotId } })\n  }\n\n  validatePlan(plan: StudioDocumentJson): Promise<{ data: { valid: boolean; errors: StudioDocumentJson[]; warnings: StudioDocumentJson[]; summary?: StudioDocumentJson } }> {\n    return this.client.request(\"POST\", `${root}/validate`, { body: { plan } })\n  }\n\n  create(input: { name?: string; plan?: StudioDocumentJson }): Promise<{ data: StudioProductionReply }> {\n    return this.client.request(\"POST\", root, { body: input })\n  }\n\n  /** Import a portable document through the compatible server writer.\n   * Retained frame media requires an authorized source; acceptance never transfers. */\n  importBundle(input: { bundle: StudioDocumentJson; projectId?: string }): Promise<{ data: StudioProductionReply }> {\n    return this.client.request(\"POST\", `${root}/import-bundle`, { body: input })\n  }\n\n  /** Append a bundle's scenes and frame closure under an exact destination revision. */\n  appendBundle(id: string, input: { bundle: StudioDocumentJson; expectedVersion: number;\n    afterShotId?: string; applyFilm?: boolean }): Promise<{ data: {\n      production: StudioProductionRecord; importedShotIds: string[]; importedKeyframeIds: string[];\n    } }> {\n    return this.client.request(\"POST\", `${path(id)}/import-bundle`, { body: input })\n  }\n\n  /** Copy a saved production. Linked copies retain verified inputs, remap\n   * dependencies and require fresh frame acceptance; they start no media jobs. */\n  clone(id: string, input: { name?: string; projectId?: string; expectedVersion?: number } = {}): Promise<{ data: StudioProductionReply }> {\n    return this.client.request(\"POST\", `${path(id)}/clone`, { body: input })\n  }\n\n  edit(id: string, input: StudioEditInput): Promise<{ data: StudioProductionReply & { version: number; rebased: boolean; receipts: StudioDocumentJson[] } }> {\n    return this.client.request(\"POST\", `${path(id)}/ops`, { body: input })\n  }\n\n  /** Audience-authorized sharing; an expected revision prevents publication\n   * of concurrent edits the caller has not reviewed. */\n  setShared(id: string, input: { shared: boolean; allowEditableCopy?: boolean; expectedVersion?: number }): Promise<{ data: StudioProductionReply }> {\n    return this.client.request(\"POST\", `${path(id)}/share`, { body: input })\n  }\n\n  /** Save ordinary editor fields against the loaded revision. Protected frame\n   * and job state can only change through their dedicated semantic actions. */\n  saveEditorState(id: string, input: { expectedVersion: number; graph: object; clientRequestId?: string }) {\n    return this.edit(id, {\n      baseVersion: input.expectedVersion, strict: true,\n      ...(input.clientRequestId ? { clientRequestId: input.clientRequestId } : {}),\n      ops: [{ op: \"save_editor_state\", expectedVersion: input.expectedVersion, graph: input.graph }],\n    })\n  }\n\n  generateKeyframe(id: string, input: StudioKeyframeGenerationInput): Promise<{ data: Exclude<StudioGenerationReply, { dryRun: true }> }> {\n    return this.client.request(\"POST\", `${path(id)}/generate`, { body: { ...input, kind: \"keyframe\" } })\n  }\n\n  generateShot(id: string, input: StudioShotGenerationInput): Promise<{ data: StudioGenerationReply }> {\n    return this.client.request(\"POST\", `${path(id)}/generate`, { body: input })\n  }\n\n  /** A separate explicit review action; generation never calls this method. */\n  acceptKeyframe(id: string, input: StudioKeyframeAcceptanceInput,\n    concurrency: Pick<StudioEditInput, \"baseVersion\" | \"strict\" | \"clientRequestId\"> = {}) {\n    return this.edit(id, { ...concurrency, ops: [{ ...input, op: \"accept_keyframe_result\" }] })\n  }\n\n  reconcile(id: string): Promise<{ data: StudioProductionReply & { landed: string[]; pending: string[]; failed: string[]; version: number } }> {\n    return this.client.request(\"POST\", `${path(id)}/reconcile`, { body: {} })\n  }\n}\n"]}

package/dist/chunk-VYK6MBL4.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=chunk-VYK6MBL4.cjs.map
+//# sourceMappingURL=chunk-VYK6MBL4.cjs.map

package/dist/chunk-VYK6MBL4.cjs.map

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

package/dist/chunk-W33CKW6Q.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=chunk-W33CKW6Q.cjs.map
+//# sourceMappingURL=chunk-W33CKW6Q.cjs.map

package/dist/chunk-W33CKW6Q.cjs.map

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

package/dist/chunk-W5VHATSR.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+// src/resources/video-pro.ts
+var VideoProResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Gracefully stop a running generate-video-pro job (keep + deliver the
+   *  completed segments; refund the rest). */
+  stop(jobId) {
+    return this.client.request(
+      "POST",
+      `/v1/generate-video-pro/${encodeURIComponent(jobId)}/stop`
+    );
+  }
+  /** Continue a stopped/failed/completed run from a segment (a NEW job).
+   *  Named `continueRun` because `continue` is a reserved word. */
+  continueRun(jobId, opts) {
+    return this.client.request("POST", "/v1/generate-video-pro/continue", {
+      body: {
+        fromJobId: jobId,
+        ...opts?.fromSegment !== void 0 ? { fromSegment: opts.fromSegment } : {}
+      }
+    });
+  }
+};
+
+exports.VideoProResource = VideoProResource;
+//# sourceMappingURL=chunk-W5VHATSR.cjs.map
+//# sourceMappingURL=chunk-W5VHATSR.cjs.map

package/dist/chunk-W5VHATSR.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/resources/video-pro.ts"],"names":[],"mappings":";;;AA8CO,IAAM,mBAAN,MAAuB;AAAA,EAC5B,YAAoB,MAAA,EAA0B;AAA1B,IAAA,IAAA,CAAA,MAAA,GAAA,MAAA;AAAA,EAA2B;AAAA,EAA3B,MAAA;AAAA;AAAA;AAAA,EAIpB,KAAK,KAAA,EAA4C;AAC/C,IAAA,OAAO,KAAK,MAAA,CAAO,OAAA;AAAA,MACjB,MAAA;AAAA,MACA,CAAA,uBAAA,EAA0B,kBAAA,CAAmB,KAAK,CAAC,CAAA,KAAA;AAAA,KACrD;AAAA,EACF;AAAA;AAAA;AAAA,EAIA,WAAA,CACE,OACA,IAAA,EACiC;AACjC,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,OAAA,CAAQ,MAAA,EAAQ,iCAAA,EAAmC;AAAA,MACpE,IAAA,EAAM;AAAA,QACJ,SAAA,EAAW,KAAA;AAAA,QACX,GAAI,MAAM,WAAA,KAAgB,MAAA,GAAY,EAAE,WAAA,EAAa,IAAA,CAAK,WAAA,EAAY,GAAI;AAAC;AAC7E,KACD,CAAA;AAAA,EACH;AACF","file":"chunk-W5VHATSR.cjs","sourcesContent":["import type { NodaroClientCore } from \"../core.js\"\n\n/**\n * Generate Video Pro control surface (Cloud edition) — the checkpointed\n * long-video engine's stop/continue operations. The generation itself is\n * dispatched like any other node (`POST /v1/generate-video-pro`); these\n * endpoints act on an EXISTING run:\n *\n * - `stop(jobId)` — graceful stop: the engine abandons the in-flight segment\n *   generation (that segment is still billed — the provider keeps rendering\n *   it), skips all remaining segments, stitches everything completed so far\n *   into the job's FINAL video, and refunds the untouched remainder of the\n *   reserve. A job that hasn't started yet is cancelled with a full refund\n *   instead. Poll the job as usual: it completes with `output_data.pro\n *   .stopped === true` and `stoppedAtSegment`.\n *\n * - `continueRun(jobId, opts?)` — a NEW job that resumes from\n *   `opts.fromSegment` (1-based; omitted → the first not-yet-delivered\n *   segment). Segments before it are reused from the parent; everything from\n *   it on is regenerated (overriding the parent's takes). Charged only for\n *   the regenerated segments plus the flat pro fee. Works on stopped, failed\n *   (with ≥1 delivered segment), and fully completed runs (tail re-roll via\n *   an explicit `fromSegment`).\n */\nexport interface StopVideoProResult {\n  jobId: string\n  /** Present when the run was processing — the engine finalizes within\n   *  seconds; keep polling the job. */\n  stopping?: boolean\n  /** Present when the job had not started — the generic cancel ran instead\n   *  (full refund). */\n  success?: boolean\n  cancelled?: number\n}\n\nexport interface ContinueVideoProResult {\n  /** The NEW job to poll — the continuation run. */\n  jobId: string\n  continuedFromJobId?: string\n  /** 1-based first regenerated segment. */\n  fromSegment?: number\n  segmentCount?: number\n  /** Present when an idempotency key matched an existing continuation. */\n  deduped?: boolean\n}\n\nexport class VideoProResource {\n  constructor(private client: NodaroClientCore) {}\n\n  /** Gracefully stop a running generate-video-pro job (keep + deliver the\n   *  completed segments; refund the rest). */\n  stop(jobId: string): Promise<StopVideoProResult> {\n    return this.client.request(\n      \"POST\",\n      `/v1/generate-video-pro/${encodeURIComponent(jobId)}/stop`,\n    )\n  }\n\n  /** Continue a stopped/failed/completed run from a segment (a NEW job).\n   *  Named `continueRun` because `continue` is a reserved word. */\n  continueRun(\n    jobId: string,\n    opts?: { fromSegment?: number },\n  ): Promise<ContinueVideoProResult> {\n    return this.client.request(\"POST\", \"/v1/generate-video-pro/continue\", {\n      body: {\n        fromJobId: jobId,\n        ...(opts?.fromSegment !== undefined ? { fromSegment: opts.fromSegment } : {}),\n      },\n    })\n  }\n}\n"]}

package/dist/chunk-W7YI5UT3.js

@@ -0,0 +1,3 @@
+export { PROMPT_PREFIX_KEY, PROMPT_SUFFIX_KEY } from '@nodaro/shared/nodes';
+//# sourceMappingURL=chunk-W7YI5UT3.js.map
+//# sourceMappingURL=chunk-W7YI5UT3.js.map

package/dist/chunk-W7YI5UT3.js.map

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

package/dist/chunk-WEQWU2IC.js

@@ -0,0 +1,34 @@
+// src/resources/palettes.ts
+var PALETTE_DIRECTION_PREFIX = "palette:";
+function paletteDirectionId(id) {
+  return `${PALETTE_DIRECTION_PREFIX}${id}`;
+}
+var PalettesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Your palettes, newest first. Page with `nextCursor`. */
+  list(params = {}) {
+    return this.client.request("GET", "/v1/palettes", {
+      query: { limit: params.limit, cursor: params.cursor }
+    });
+  }
+  get(id) {
+    return this.client.request("GET", `/v1/palettes/${encodeURIComponent(id)}`);
+  }
+  create(input) {
+    return this.client.request("POST", "/v1/palettes", { body: input });
+  }
+  update(id, input) {
+    return this.client.request("PATCH", `/v1/palettes/${encodeURIComponent(id)}`, { body: input });
+  }
+  /** A run that still names the palette answers 404 `direction_not_found`. */
+  async delete(id) {
+    await this.client.request("DELETE", `/v1/palettes/${encodeURIComponent(id)}`);
+  }
+};
+
+export { PALETTE_DIRECTION_PREFIX, PalettesResource, paletteDirectionId };
+//# sourceMappingURL=chunk-WEQWU2IC.js.map
+//# sourceMappingURL=chunk-WEQWU2IC.js.map

package/dist/chunk-WEQWU2IC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/resources/palettes.ts"],"names":[],"mappings":";AA4CO,IAAM,wBAAA,GAA2B;AAQjC,SAAS,mBAAmB,EAAA,EAAiC;AAClE,EAAA,OAAO,CAAA,EAAG,wBAAwB,CAAA,EAAG,EAAE,CAAA,CAAA;AACzC;AASO,IAAM,mBAAN,MAAuB;AAAA,EAC5B,YAAoB,MAAA,EAA0B;AAA1B,IAAA,IAAA,CAAA,MAAA,GAAA,MAAA;AAAA,EAA2B;AAAA,EAA3B,MAAA;AAAA;AAAA,EAGpB,IAAA,CAAK,MAAA,GAA6B,EAAC,EAAyB;AAC1D,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,OAAA,CAAqB,KAAA,EAAO,cAAA,EAAgB;AAAA,MAC7D,OAAO,EAAE,KAAA,EAAO,OAAO,KAAA,EAAO,MAAA,EAAQ,OAAO,MAAA;AAAO,KACrD,CAAA;AAAA,EACH;AAAA,EAEA,IAAI,EAAA,EAAmC;AACrC,IAAA,OAAO,IAAA,CAAK,OAAO,OAAA,CAAsB,KAAA,EAAO,gBAAgB,kBAAA,CAAmB,EAAE,CAAC,CAAA,CAAE,CAAA;AAAA,EAC1F;AAAA,EAEA,OAAO,KAAA,EAAkD;AACvD,IAAA,OAAO,IAAA,CAAK,OAAO,OAAA,CAAsB,MAAA,EAAQ,gBAAgB,EAAE,IAAA,EAAM,OAAO,CAAA;AAAA,EAClF;AAAA,EAEA,MAAA,CAAO,IAAY,KAAA,EAAkD;AACnE,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,OAAA,CAAsB,OAAA,EAAS,CAAA,aAAA,EAAgB,kBAAA,CAAmB,EAAE,CAAC,CAAA,CAAA,EAAI,EAAE,IAAA,EAAM,KAAA,EAAO,CAAA;AAAA,EAC7G;AAAA;AAAA,EAGA,MAAM,OAAO,EAAA,EAA2B;AACtC,IAAA,MAAM,IAAA,CAAK,OAAO,OAAA,CAA2B,QAAA,EAAU,gBAAgB,kBAAA,CAAmB,EAAE,CAAC,CAAA,CAAE,CAAA;AAAA,EACjG;AACF","file":"chunk-WEQWU2IC.js","sourcesContent":["import type { NodaroClientCore } from \"../core.js\"\n\n/** One of your colour palettes. */\nexport interface ColorPalette {\n  id: string\n  name: string\n  /** 2–12 colours, `#RRGGBB`, upper case. */\n  colors: string[]\n  /** Your own note. It is not put into the prompt. */\n  description: string | null\n  createdAt: string\n  updatedAt: string\n}\n\nexport interface CreatePaletteInput {\n  /** 1–80 characters. */\n  name: string\n  /** 2–12 colours, `#RRGGBB` (any case; stored upper case). */\n  colors: string[]\n  /** Up to 500 characters. */\n  description?: string | null\n}\n\n/** Only the fields you send are written; `description: null` clears it. */\nexport interface UpdatePaletteInput {\n  name?: string\n  colors?: string[]\n  description?: string | null\n}\n\nexport interface ListPalettesParams {\n  /** Page size, 1–100 (server default 50). */\n  limit?: number\n  /** The previous page's `nextCursor`. */\n  cursor?: string\n}\n\nexport interface PalettePage {\n  data: ColorPalette[]\n  /** Pass back as `cursor` for the next page; `null` on the last one. */\n  nextCursor: string | null\n}\n\n/** The prefix of a palette's generate-image direction id (`direction.colorLook`). */\nexport const PALETTE_DIRECTION_PREFIX = \"palette:\" as const\n\n/**\n * A palette as a generate-image direction value — put it on\n * `direction.colorLook`. The run names each colour (an everyday name and its\n * hex) in the prompt; the job keeps the id, so a re-run uses the palette as it\n * is then.\n */\nexport function paletteDirectionId(id: string): `palette:${string}` {\n  return `${PALETTE_DIRECTION_PREFIX}${id}`\n}\n\n/**\n * Colour palettes — `GET/POST /v1/palettes`, `GET/PATCH/DELETE /v1/palettes/:id`.\n *\n * Yours only (another person's id answers 404). Use one on generate-image as\n * `direction: { colorLook: paletteDirectionId(id) }`. OAuth app tokens need\n * `assets:read` for reads and `assets:write` for writes.\n */\nexport class PalettesResource {\n  constructor(private client: NodaroClientCore) {}\n\n  /** Your palettes, newest first. Page with `nextCursor`. */\n  list(params: ListPalettesParams = {}): Promise<PalettePage> {\n    return this.client.request<PalettePage>(\"GET\", \"/v1/palettes\", {\n      query: { limit: params.limit, cursor: params.cursor },\n    })\n  }\n\n  get(id: string): Promise<ColorPalette> {\n    return this.client.request<ColorPalette>(\"GET\", `/v1/palettes/${encodeURIComponent(id)}`)\n  }\n\n  create(input: CreatePaletteInput): Promise<ColorPalette> {\n    return this.client.request<ColorPalette>(\"POST\", \"/v1/palettes\", { body: input })\n  }\n\n  update(id: string, input: UpdatePaletteInput): Promise<ColorPalette> {\n    return this.client.request<ColorPalette>(\"PATCH\", `/v1/palettes/${encodeURIComponent(id)}`, { body: input })\n  }\n\n  /** A run that still names the palette answers 404 `direction_not_found`. */\n  async delete(id: string): Promise<void> {\n    await this.client.request<{ success: true }>(\"DELETE\", `/v1/palettes/${encodeURIComponent(id)}`)\n  }\n}\n"]}