@nodaro/sdk 2.29.0 → 2.31.0

package/dist/chunk-TVENC6PH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/resources/locations.ts"],"names":[],"mappings":"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","file":"chunk-TVENC6PH.js","sourcesContent":["import type { CharacterAspectRatio, SurroundDirection, LocationAssetType, LocationAttachColumn } from \"@nodaro/shared/entities\"\nexport type { LocationAssetType, LocationAttachColumn, CharacterAspectRatio, SurroundDirection } from \"@nodaro/shared/entities\"\nexport { LOCATION_ASSET_TYPES, LOCATION_ATTACH_COLUMNS, SURROUND_DIRECTIONS } from \"@nodaro/shared/entities\"\nimport type { NodaroClientCore } from \"../core.js\"\nimport type { GenerationSessionParams } from \"./nodes.js\"\n\n/**\n * Re-export the shared `LocationAssetType` / `LocationAttachColumn` unions and\n * their runtime tuples so SDK consumers don't have to add `@nodaro/shared` as a\n * second dependency just to typecheck the `assetType` / `attachToColumn`\n * fields. Single source of truth lives in `@nodaro/shared/entity-prompts`.\n *\n * `CharacterAspectRatio` is re-exported alongside them — `generateMotion`'s\n * `aspectRatio` field reuses the same 4-value enum (1:1 / 3:4 / 16:9 / 9:16)\n * as characters; the route enforces this with `z.enum(CHARACTER_ASPECT_OPTIONS)`.\n */\n\n/**\n * Reference-photo kind discriminator — the mood-board roles a user can attach\n * to a location. Mirrors the `reference_photos.kind` Zod enum in\n * `backend/src/routes/locations.ts`. `other` is the free-form bucket.\n */\nexport type LocationReferencePhotoKind =\n  | \"wide\"\n  | \"interior\"\n  | \"exterior\"\n  | \"detail\"\n  | \"moodBoard\"\n  | \"other\"\n\nexport interface LocationReferencePhoto {\n  url: string\n  kind: LocationReferencePhotoKind\n}\n\n/**\n * A location record returned by Nodaro's REST API. Mirrors the camelCase\n * shape produced by `backend/src/routes/locations.ts::toCamel()`.\n *\n * Asset buckets (`timeOfDay`, `weather`, `angles`, `lighting`, `seasons`,\n * `atmosphereMotions`) are independent JSONB arrays keyed by a human-readable\n * variant name (e.g. `\"dawn\"`, `\"clear\"`, `\"wide\"`). Each entry's `url` points\n * at an R2-hosted asset.\n *\n * Identity-foundation fields:\n *   - `referencePhotos` — caller-supplied mood-board refs (cap 20).\n *   - `canonicalDescription` — ~80–120-word LLM-authored visual caption,\n *     populated by `approveMainImage()` / `recaption()`. The wire still sends\n *     `\"\"` on caption sub-failure (the breaking wire change is deferred to a\n *     major bump), but `get()` normalizes `\"\"` → `null` so consumers see the\n *     same `string | null` semantics as characters.\n *   - `styleLock` — whether asset gens should anchor to the canonical style\n *     captured at approval time. Defaults to `true` on new rows.\n */\nexport interface Location {\n  id: string\n  userId: string\n  nodeId: string\n  projectId: string | null\n  name: string\n  description: string | null\n  category: string | null\n  style: string | null\n  sourceImageUrl: string | null\n  /** MODEL_CATALOG image-model id the main image was generated with (or `null`).\n   *  Set on create + editable via the update route. */\n  imageProvider: string | null\n  timeOfDay: Array<{ name: string; url: string }>\n  weather: Array<{ name: string; url: string }>\n  angles: Array<{ name: string; url: string }>\n  lighting: Array<{ name: string; url: string }>\n  seasons: Array<{ name: string; url: string }>\n  atmosphereMotions: Array<{ name: string; url: string }>\n  /** Named Location Boards — dense reference sheets, one per variant/mood\n   *  (the `generate-image/location-board` factory preset rendered from the\n   *  location's images). A first-class bucket: community publish snapshots it\n   *  and clone hands the consumer their own copy to extend. Defaults to `[]`.\n   *  `type` marks an image-collage `\"identity\"` sheet vs a plain `\"looks\"`\n   *  board; `sourceImages` are the R2 URLs it was collaged from. Both optional\n   *  + backward-compatible (legacy boards have neither). */\n  boards?: Array<{ name: string; url: string; type?: \"looks\" | \"identity\"; sourceImages?: string[] }> | null\n  referencePhotos: LocationReferencePhoto[]\n  /** `null` when no caption is set (or the LLM caption sub-failed) — the wire\n   *  sends `\"\"`, normalized to `null` in `get()` to match character semantics. */\n  canonicalDescription: string | null\n  styleLock: boolean\n  /** The user's chosen DEFAULT asset take per variant (Studio version history).\n   *  OPAQUE map: key `\"<bucket>:<variant>\"` (e.g. `\"timeOfDay:dawn\"`) → the chosen\n   *  asset URL (one already present in that bucket). Stored verbatim — keys are\n   *  NOT normalized; soft-capped server-side at 200 keys / 2048-char values\n   *  (overflow dropped silently). Defaults to `{}`. */\n  selectedAssetByVariant?: Record<string, string> | null\n  deletedAt: string | null\n  createdAt: string\n  updatedAt: string\n}\n\n/**\n * GET /v1/locations/:id appends a `pendingJobs` bucket the studio uses to\n * rehydrate spinners after a reload. Optional on the SDK surface — it doesn't\n * appear on `list()` rows.\n */\nexport interface LocationDetail extends Location {\n  pendingJobs?: Array<{\n    jobId: string\n    assetType: string\n    name: string\n    status: string\n  }>\n  /**\n   * Completed candidate main images for this location whose URL differs from\n   * the current `sourceImageUrl`, newest first (max 5). Surfaced so a\n   * \"pick from N\" UI can offer alternatives the user can promote via\n   * `approveMainImage(id, jobId)`; until they pick, the current main image is\n   * left untouched. Mirrors `CharacterDetail.previousCandidates`. Optional -\n   * absent on `list()` rows, present (possibly empty) on `get()`.\n   */\n  previousCandidates?: Array<{\n    jobId: string\n    url: string\n    createdAt: string\n  }>\n}\n\n/**\n * Body for `client.locations.create()`. Mirrors the INSERT branch of\n * `upsertLocationBody` in `backend/src/routes/locations.ts`. `name` + `nodeId`\n * are required on create.\n */\nexport interface CreateLocationInput {\n  nodeId: string\n  name: string\n  description?: string\n  category?: string\n  style?: string\n  workflowId?: string\n  projectId?: string\n  sourceImageUrl?: string\n  /** Persistent image-model id (a MODEL_CATALOG image model). Validated\n   *  server-side — unknown / non-image / \"\" is stored as `null`. */\n  imageProvider?: string | null\n  referencePhotos?: LocationReferencePhoto[]\n  canonicalDescription?: string\n  styleLock?: boolean\n  /** The user's chosen DEFAULT asset take per variant. OPAQUE\n   *  `\"<bucket>:<variant>\"` → chosen-URL map; a write REPLACES the whole map.\n   *  Keys stored verbatim; soft-capped server-side at 200 keys / 2048-char values. */\n  selectedAssetByVariant?: Record<string, string>\n}\n\n/**\n * Body for `client.locations.update()`. Mirrors the UPDATE branch of\n * `upsertLocationBody` in `backend/src/routes/locations.ts`.\n *\n * Worker-owned asset buckets (`timeOfDay`/`weather`/`angles`/`lighting`/\n * `seasons`/`atmosphereMotions`) are deliberately omitted — the route drops\n * them on UPDATE so a Studio auto-save with a stale snapshot cannot clobber\n * the worker's atomic `append_location_asset()` writes.\n *\n * `expectedUpdatedAt` is the optimistic-concurrency token: when present, the\n * UPDATE only succeeds if the row's `updated_at` still matches; on mismatch\n * the route returns 409 so the studio can re-fetch + merge.\n */\nexport interface UpdateLocationInput {\n  name?: string\n  description?: string\n  category?: string\n  style?: string\n  sourceImageUrl?: string\n  /** Persistent image-model id (a MODEL_CATALOG image model). Validated\n   *  server-side — unknown / non-image / \"\" is stored as `null`. */\n  imageProvider?: string | null\n  referencePhotos?: LocationReferencePhoto[]\n  canonicalDescription?: string\n  styleLock?: boolean\n  /** The user's chosen DEFAULT asset take per variant. OPAQUE\n   *  `\"<bucket>:<variant>\"` → chosen-URL map; a write REPLACES the whole map\n   *  (omit to leave untouched). Keys stored verbatim; soft-capped server-side\n   *  at 200 keys / 2048-char values. */\n  selectedAssetByVariant?: Record<string, string>\n  /** Named Location Boards (see `Location.boards`) — whole-array replace,\n   *  USER-owned (unlike the worker-owned buckets it flows through UPDATE).\n   *  Server caps: 24 boards, 200-char names, 30 sourceImages per board. */\n  boards?: Array<{ name: string; url: string; type?: \"looks\" | \"identity\"; sourceImages?: string[] }>\n  /** ISO-8601 timestamp recording when PII consent was captured for this location. */\n  piiConsentAt?: string\n  expectedUpdatedAt?: string\n}\n\nexport interface UpdateLocationResult {\n  id: string\n  updatedAt: string\n}\n\nexport interface ListLocationsParams {\n  /** When true, return archived locations instead of active ones. */\n  archived?: boolean\n  /**\n   * Search words: only the locations whose name or description contains\n   * every word (split on spaces, the first 5), in any order, ignoring case.\n   * Each word is matched as written (`%`, `_` and `*` are not wildcards;\n   * punctuation is kept); blank means no search; up to 200 characters.\n   * Combines with the other filters and with `cursor` paging.\n   */\n  q?: string\n  /**\n   * Max rows to return (cap 500). OPT-IN: omitted, the server returns the\n   * full legacy listing with no `nextCursor`; supplied, the response is one\n   * page plus `nextCursor` — keep passing it back until it is `null`.\n   */\n  limit?: number\n  /** Opaque cursor from a prior page's `nextCursor` (fetches the next page). */\n  cursor?: string\n}\n\n/**\n * Input for `client.locations.generate()` — fires the\n * `POST /v1/generate-location` route. Produces 1–10 candidate\n * establishing shots; each lands as one `jobs` row in `pending` state and\n * is then enqueued for the worker.\n *\n * When `attachToLocationId` is set AND `count === 1`, the worker writes the\n * resulting URL directly to `locations.source_image_url` on completion —\n * caller doesn't need a separate `approveMainImage` call. Multi-candidate\n * batches MUST go through explicit approval so the user picks the winner.\n */\nexport interface GenerateLocationInput extends GenerationSessionParams {\n  name: string\n  description?: string\n  userPrompt?: string\n  category?: \"indoor\" | \"outdoor\" | \"urban\" | \"nature\" | \"fantasy\" | \"sci-fi\" | \"historical\" | \"futuristic\" | \"other\"\n  style?: \"realistic\" | \"anime\" | \"3d-pixar\" | \"illustration\"\n  sourceImageUrl?: string\n  provider?: string\n  /** Number of candidate images to generate (1–10; server-validated). */\n  count?: number\n  /** Auto-attach the result to this location row (single-candidate only). */\n  attachToLocationId?: string\n  /**\n   * Credit-affecting quality tier (e.g. `\"high\"` for gpt-image). Priced like\n   * generate-image (composite ids such as `gpt-image:high`); values the chosen\n   * model doesn't support are ignored server-side, never rejected.\n   */\n  quality?: string\n  /**\n   * Credit-affecting output resolution (e.g. `\"2K\"` / `\"4K\"` / `\"2 MP\"`).\n   * Priced like generate-image (composite ids such as `nano-banana-pro:4K`);\n   * values the chosen model doesn't support are ignored server-side, never\n   * rejected.\n   */\n  resolution?: string\n}\n\n/**\n * `generate()` response — `jobIds` is ALWAYS present (the harmonized contract,\n * matching characters). `jobId` is a deprecated back-compat alias populated only\n * on `count === 1`; prefer `jobIds`. (Will be removed on the next major.)\n */\nexport interface GenerateLocationResult {\n  jobIds: string[]\n  /** @deprecated count===1 back-compat alias — use `jobIds`. */\n  jobId?: string\n}\n\n/**\n * Input for `client.locations.generateAsset()` — fires the\n * `POST /v1/generate-location-asset` route. Produces a single\n * timeOfDay / weather / seasons / angles / lighting / custom variant.\n *\n * When all three studio-path fields are set (`attachToLocationId` +\n * `attachToColumn` + `attachName`), the worker appends\n * `{ name: attachName, url: <result> }` to the named JSONB array column on\n * the user's location row on completion. `attachToColumn` is REQUIRED for\n * `assetType === \"custom\"` — the worker can't infer the bucket from the\n * asset type.\n */\nexport interface GenerateLocationAssetInput extends GenerationSessionParams {\n  assetType: LocationAssetType\n  variant: string\n  name: string\n  description?: string\n  userPrompt?: string\n  category?: string\n  style?: \"realistic\" | \"anime\" | \"3d-pixar\" | \"illustration\"\n  sourceImageUrl?: string\n  provider?: string\n  /** Optional framing override (the same 4-value enum as `generateMotion`).\n   *  Absent = the image model's default. The studio's 360° surround path pins\n   *  `\"16:9\"` so every ring view matches the establishing shot's frame. */\n  aspectRatio?: CharacterAspectRatio\n  attachToLocationId?: string\n  attachToColumn?: LocationAttachColumn\n  attachName?: string\n  /**\n   * Credit-affecting quality tier (e.g. `\"high\"` for gpt-image). Values the\n   * chosen model doesn't support are ignored server-side, never rejected.\n   */\n  quality?: string\n  /**\n   * Credit-affecting output resolution (e.g. `\"2K\"` / `\"4K\"` / `\"2 MP\"`).\n   * Values the chosen model doesn't support are ignored server-side, never\n   * rejected.\n   */\n  resolution?: string\n}\n\n/**\n * Input for `client.locations.generateSurroundContinuation()` — fires the\n * `POST /v1/generate-surround-continuation` route. Generates one seamless 360°\n * ring view as an image-to-image continuation of `referenceImageUrl` (the\n * previous ring view, or the establishing shot for the first ring).\n *\n * The platform owns the whole pipeline: it builds the half-carry composite\n * server-side (carry the reference's trailing half into the new frame's leading\n * half per `direction`, gray the rest), paints the gray region, then\n * color-harmonizes the painted half to the carried half so there is no tonal\n * seam down the frame's center. The carried half stays pixel-exact, so a\n * panorama viewer stitching adjacent ring views stays geometrically seamless.\n *\n * When the studio path is set (`attachToLocationId` + `attachToColumn` +\n * `attachName`), the worker appends `{ name: attachName, url: <result> }` to the\n * location's bucket (studio uses `attachToColumn: \"angles\"`,\n * `attachName: \"Surround 45°\"`).\n */\nexport interface GenerateSurroundContinuationInput extends GenerationSessionParams {\n  /** The previous ring view to continue from (i2i anchor). */\n  referenceImageUrl: string\n  /** Carry/paint axis: turn right, turn left, tilt up, or tilt down. Tilts\n   *  render the sky/ground (a thin horizon strip), not a horizontal continuation. */\n  direction: SurroundDirection\n  /** Ring angle (45, 90, …) — stored on the result as metadata. */\n  degrees?: number\n  /** Fraction of the frame carried from the reference. Omitted ⇒ per-direction\n   *  default (0.5 for a pan, 0.12 thin strip for a tilt). */\n  carriedFraction?: number\n  /** Upscale/denoise the result before it's chained as the next reference, to\n   *  slow cumulative softening down a long ring chain. Default false. */\n  refine?: boolean\n  /** Refine model when `refine` is set. `recraft-upscale` (1 cr, default) or\n   *  `topaz-image-upscale` (3 cr). */\n  refineProvider?: \"recraft-upscale\" | \"topaz-image-upscale\"\n  /** Optional free-form scene hint woven into the fill prompt. */\n  userPrompt?: string\n  /** Image model. Defaults to the platform's general image model (`gpt-image-2`). */\n  provider?: string\n  /** Studio pins `\"16:9\"` so every ring view matches the establishing frame. */\n  aspectRatio?: CharacterAspectRatio\n  attachToLocationId?: string\n  attachToColumn?: LocationAttachColumn\n  attachName?: string\n}\n\n/**\n * Input for `client.locations.generateMotion()` — fires the\n * `POST /v1/generate-location-motion` route. Produces a single atmospheric\n * motion clip (drifting fog, snowfall, rolling waves, etc.) animated FROM a\n * static establishing-shot image.\n *\n * Mirrors `client.characters.generateMotion()` minus the character-specific\n * fields (gender / baseOutfit / realLifeRefs). The route hardcodes the attach\n * column to `atmosphere_motions` — callers supply `attachToLocationId` +\n * `attachName` only.\n *\n * `sourceImageUrl` is REQUIRED — image-to-video needs a source frame and the\n * route has no fallback (no `source_image_url` column to pull from on the\n * locations row; the studio path supplies the canonical establishing-shot URL\n * explicitly).\n *\n * When the studio path is set (`attachToLocationId` + `attachName`), the\n * worker appends `{ name: attachName, url: <result> }` to the location row's\n * `atmosphere_motions` JSONB column on completion.\n */\nexport interface GenerateLocationMotionInput extends GenerationSessionParams {\n  motionPrompt: string\n  sourceImageUrl: string\n  provider?: string\n  name: string\n  category?: string\n  style?: \"realistic\" | \"anime\" | \"3d-pixar\" | \"illustration\"\n  canonicalDescription?: string\n  attachToLocationId?: string\n  attachName?: string\n  /**\n   * Optional aspect ratio override. Defaults to 16:9 server-side via\n   * `resolveLocationAspectRatio` (locations are cinematic establishing shots).\n   * One of the 4-value `CharacterAspectRatio` union — locations reuse the\n   * character aspect enum since the supported ratios are identical.\n   */\n  aspectRatio?: CharacterAspectRatio\n}\n\nexport interface ApproveMainImageResult {\n  sourceImageUrl: string\n  /**\n   * LLM-authored caption. `null` when the LLM caption sub-failed — the wire\n   * sends `\"\"`, normalized to `null` here so consumers see the same\n   * `string | null` semantics as characters. The main image is still set; call\n   * `recaption()` to retry.\n   */\n  canonicalDescription: string | null\n}\n\nexport interface RecaptionLocationResult {\n  canonicalDescription: string\n}\n\nexport class LocationsResource {\n  constructor(private client: NodaroClientCore) {}\n\n  /**\n   * List the caller's locations. By default returns active locations only;\n   * pass `archived: true` to fetch soft-deleted rows for an \"archive\" view,\n   * and `q` to keep the ones whose name or description contains it.\n   */\n  list(params: ListLocationsParams = {}): Promise<{ locations: Location[]; nextCursor?: string | null }> {\n    const query: Record<string, string | undefined> = {}\n    if (params.archived) query.archived = \"true\"\n    if (params.q) query.q = params.q\n    if (params.limit !== undefined) query.limit = String(params.limit)\n    if (params.cursor) query.cursor = params.cursor\n    return this.client.request(\"GET\", \"/v1/locations\", { query })\n  }\n\n  /**\n   * Convenience wrapper for `list({ archived: true })`. Returns soft-deleted\n   * rows so callers can drive a UI \"Archived\" tab without re-encoding the\n   * query param. Mirrors `ObjectsResource.listArchived`.\n   *\n   * `archived` is omitted from the param type — it's always set to `true` here.\n   */\n  listArchived(params: Omit<ListLocationsParams, \"archived\"> = {}): Promise<{ locations: Location[]; nextCursor?: string | null }> {\n    return this.list({ ...params, archived: true })\n  }\n\n  /**\n   * Fetch a single location including in-flight asset job state. Soft-deleted\n   * (archived) rows are returned by id intentionally so canvas nodes that\n   * hold a stale `locationDbId` keep loading.\n   */\n  async get(id: string): Promise<LocationDetail> {\n    const res = await this.client.request<LocationDetail>(\n      \"GET\",\n      `/v1/locations/${encodeURIComponent(id)}`,\n    )\n    // Normalize the wire `\"\"` caption (DB null / LLM sub-failure) → null so\n    // consumers see the same `string | null` semantics as characters. New\n    // object — never mutate the response.\n    return { ...res, canonicalDescription: res.canonicalDescription || null }\n  }\n\n  /**\n   * Create a new location. `name` + `nodeId` are required — the route 400s\n   * otherwise. Returns the new row's id.\n   *\n   * Note: the underlying route is the same `POST /v1/locations` upsert that\n   * powers `update()`. This convenience wrapper enforces the INSERT-required\n   * fields at the type level and never sends an `id`.\n   */\n  create(data: CreateLocationInput): Promise<{ id: string }> {\n    return this.client.request(\"POST\", \"/v1/locations\", { body: data })\n  }\n\n  /**\n   * Update a location. Only the fields you pass are written — undefined keys\n   * are NOT touched on the row. Worker-owned asset buckets are intentionally\n   * not exposed on this surface (see `UpdateLocationInput` for the rationale).\n   *\n   * Optimistic-concurrency: pass `expectedUpdatedAt` to require the row's\n   * `updated_at` still matches; on mismatch the route returns 409\n   * `concurrent_modification`. The SDK surfaces that as a generic\n   * `NodaroError` with the same code.\n   */\n  update(id: string, data: UpdateLocationInput): Promise<UpdateLocationResult> {\n    return this.client.request(\"POST\", \"/v1/locations\", {\n      body: { id, ...data },\n    })\n  }\n\n  /**\n   * Soft-delete (archive) a location. The row is hidden from `list()` by\n   * default but still loadable via `get(id)` so canvas nodes pointing at it\n   * keep working. Restore with `restore(id)`.\n   */\n  delete(id: string): Promise<{ success: true; archived: true }> {\n    return this.client.request(\"DELETE\", `/v1/locations/${encodeURIComponent(id)}`)\n  }\n\n  /**\n   * Un-archive a location. If the original name now collides (case-\n   * insensitive) with an active row, the server auto-suffixes \"(restored)\"\n   * and returns the effective name.\n   */\n  restore(id: string): Promise<{ id: string; name: string }> {\n    return this.client.request(\"POST\", `/v1/locations/${encodeURIComponent(id)}/restore`)\n  }\n\n  /**\n   * Fire `POST /v1/generate-location` to produce one or more candidate main\n   * images. With `count > 1`, all jobs are reserved up-front before any\n   * is enqueued — mid-batch failures roll back atomically.\n   *\n   * When `attachToLocationId` is set AND `count === 1`, the worker writes\n   * the result directly to the row's `source_image_url`; otherwise you must\n   * call `approveMainImage()` after picking a candidate.\n   */\n  async generate(data: GenerateLocationInput): Promise<GenerateLocationResult> {\n    const res = await this.client.request<{ jobId?: string; jobIds?: string[] }>(\n      \"POST\", \"/v1/generate-location\", { body: data },\n    )\n    // Tolerate the legacy `{ jobId }`-only shape (older server): synthesize jobIds.\n    const jobIds = res.jobIds ?? (res.jobId ? [res.jobId] : [])\n    return res.jobId ? { jobIds, jobId: res.jobId } : { jobIds }\n  }\n\n  /**\n   * Fire `POST /v1/generate-location-asset` to produce a single variant.\n   * When the studio path is set (`attachToLocationId` + `attachToColumn` +\n   * `attachName`), the worker appends `{ name: attachName, url: <result> }`\n   * to the named JSONB array column on completion.\n   */\n  generateAsset(data: GenerateLocationAssetInput): Promise<{ jobId: string }> {\n    return this.client.request(\"POST\", \"/v1/generate-location-asset\", { body: data })\n  }\n\n  /**\n   * Fire `POST /v1/generate-surround-continuation` to produce one seamless 360°\n   * ring view as an i2i continuation of `referenceImageUrl`. The platform builds\n   * the half-carry composite, paints the missing half, and color-harmonizes it\n   * to the carried half (no tonal seam; carried half stays pixel-exact). When the\n   * studio path is set, the worker appends the result to the location's bucket.\n   */\n  generateSurroundContinuation(data: GenerateSurroundContinuationInput): Promise<{ jobId: string }> {\n    return this.client.request(\"POST\", \"/v1/generate-surround-continuation\", { body: data })\n  }\n\n  /**\n   * Fire `POST /v1/generate-location-motion` to animate the location's\n   * establishing shot into an atmospheric motion clip. Image-to-video, single\n   * clip per call; the attach column is hardcoded to `atmosphere_motions`\n   * server-side (locations have a single motion bucket so the caller doesn't\n   * supply `attachToColumn`). When the studio path is set\n   * (`attachToLocationId` + `attachName`), the worker appends\n   * `{ name: attachName, url: <result> }` to the row's `atmosphere_motions`\n   * column on completion.\n   */\n  generateMotion(data: GenerateLocationMotionInput): Promise<{ jobId: string }> {\n    return this.client.request(\"POST\", \"/v1/generate-location-motion\", { body: data })\n  }\n\n  /**\n   * Atomically remove ONE asset take (every entry matching `url`) from a\n   * worker-owned bucket column — `POST /v1/locations/:id/remove-asset`. The\n   * worker-owned buckets are deliberately not writable through `update()`\n   * (a stale snapshot would race concurrent worker appends), so deleting a\n   * take — e.g. a 360° surround view being regenerated — goes through this\n   * single-statement server-side filter instead. 404s (`NotFoundError`) when\n   * the url isn't in that bucket or the location isn't yours.\n   */\n  removeAsset(\n    id: string,\n    data: { column: LocationAttachColumn; url: string },\n  ): Promise<{ removed: true }> {\n    return this.client.request(\n      \"POST\",\n      `/v1/locations/${encodeURIComponent(id)}/remove-asset`,\n      { body: data },\n    )\n  }\n\n  /**\n   * Approve a completed `generate-location` job as the location's main image.\n   * Sets `source_image_url` and fires the LLM caption (Claude Sonnet vision)\n   * inline. Returns the new main-image URL plus the caption.\n   *\n   * Caption-failure semantics: the route still sends `\"\"` on LLM sub-failure,\n   * but the SDK normalizes `\"\"` → `null` here so `canonicalDescription` carries\n   * the same `string | null` semantics as characters. The main image is still\n   * set; call `recaption()` to retry.\n   */\n  async approveMainImage(id: string, candidateJobId: string): Promise<ApproveMainImageResult> {\n    const res = await this.client.request<{ sourceImageUrl: string; canonicalDescription: string | null }>(\n      \"POST\",\n      `/v1/locations/${encodeURIComponent(id)}/approve-main-image`,\n      { body: { candidateJobId } },\n    )\n    // Normalize the wire `\"\"` (LLM sub-failure) → null; build a new object\n    // rather than mutating the response.\n    return { sourceImageUrl: res.sourceImageUrl, canonicalDescription: res.canonicalDescription || null }\n  }\n\n  /**\n   * Re-fire the LLM caption against the location's current main image. 502s\n   * on LLM failure (unlike `approveMainImage` which preserves the side-effect\n   * and returns \"\"); returns 400 `no_source_image` if no main image is set\n   * yet.\n   */\n  recaption(id: string): Promise<RecaptionLocationResult> {\n    return this.client.request(\n      \"POST\",\n      `/v1/locations/${encodeURIComponent(id)}/llm-caption`,\n    )\n  }\n}\n"]}

package/dist/chunk-U4T3Z3K7.cjs

@@ -0,0 +1,325 @@
+'use strict';
+
+var chunkN6GLZOE4_cjs = require('./chunk-N6GLZOE4.cjs');
+
+// 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 chunkN6GLZOE4_cjs.StudioPreviewUnavailable();
+    const res = await this.client.request("POST", this.path(productionId, "/ops"), { body: input });
+    const data = res?.data;
+    if (data?.dryRun !== true) {
+      throw new chunkN6GLZOE4_cjs.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: {} });
+  }
+};
+
+exports.StudioProductionsResource = StudioProductionsResource;
+exports.StudioResource = StudioResource;
+exports.isStudioGenerateEstimate = isStudioGenerateEstimate;
+//# sourceMappingURL=chunk-U4T3Z3K7.cjs.map
+//# sourceMappingURL=chunk-U4T3Z3K7.cjs.map

package/dist/chunk-U4T3Z3K7.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/resources/studio-productions.ts","../src/resources/studio.ts"],"names":["res","StudioPreviewUnavailable","StudioPreviewAppliedError"],"mappings":"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","file":"chunk-U4T3Z3K7.cjs","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"]}