@nodaro/sdk 1.1.1

package/dist/index.cjs

@@ -0,0 +1,2085 @@
+'use strict';
+
+var prompts = require('@nodaro/prompts');
+var shared = require('@nodaro/shared');
+
+// src/errors.ts
+var NodaroError = class extends Error {
+  constructor(message, code, status) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "NodaroError";
+  }
+  code;
+  status;
+};
+var UnauthorizedError = class extends NodaroError {
+  constructor(message = "Authentication required") {
+    super(message, "unauthorized", 401);
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends NodaroError {
+  constructor(message = "Forbidden", missingScope) {
+    super(message, "forbidden", 403);
+    this.missingScope = missingScope;
+    this.name = "ForbiddenError";
+  }
+  missingScope;
+};
+var NotFoundError = class extends NodaroError {
+  constructor(message = "Not found") {
+    super(message, "not_found", 404);
+    this.name = "NotFoundError";
+  }
+};
+var RateLimitedError = class extends NodaroError {
+  constructor(message = "Rate limited") {
+    super(message, "rate_limited", 429);
+    this.name = "RateLimitedError";
+  }
+};
+var InsufficientCreditsError = class extends NodaroError {
+  constructor(message = "Insufficient credits", required, available) {
+    super(message, "insufficient_credits", 402);
+    this.required = required;
+    this.available = available;
+    this.name = "InsufficientCreditsError";
+  }
+  required;
+  available;
+};
+var StorageExceededError = class extends NodaroError {
+  constructor(message = "Storage exceeded", limitBytes) {
+    super(message, "storage_exceeded", 413);
+    this.limitBytes = limitBytes;
+    this.name = "StorageExceededError";
+  }
+  limitBytes;
+};
+var JobFailedError = class extends NodaroError {
+  constructor(message, jobId, jobStatus = "failed") {
+    super(message, "job_failed", 0);
+    this.jobId = jobId;
+    this.jobStatus = jobStatus;
+    this.name = "JobFailedError";
+  }
+  jobId;
+  jobStatus;
+};
+var JobTimeoutError = class extends NodaroError {
+  constructor(message, jobId, timeoutMs) {
+    super(message, "job_timeout", 0);
+    this.jobId = jobId;
+    this.timeoutMs = timeoutMs;
+    this.name = "JobTimeoutError";
+  }
+  jobId;
+  timeoutMs;
+};
+var JobAbortedError = class extends NodaroError {
+  constructor(message = "Aborted", jobId) {
+    super(message, "job_aborted", 0);
+    this.jobId = jobId;
+    this.name = "JobAbortedError";
+  }
+  jobId;
+};
+function throwFromResponse(status, body) {
+  const code = body.error?.code ?? "internal_error";
+  const message = body.error?.message ?? "Request failed";
+  if (status === 401) throw new UnauthorizedError(message);
+  if (status === 403 && code === "insufficient_scope") {
+    throw new ForbiddenError(message, body.error?.missingScope);
+  }
+  if (status === 403) throw new ForbiddenError(message);
+  if (status === 404) throw new NotFoundError(message);
+  if (status === 429) throw new RateLimitedError(message);
+  if (status === 402) {
+    throw new InsufficientCreditsError(message, body.error?.required, body.error?.available);
+  }
+  if (status === 413) throw new StorageExceededError(message, body.error?.limitBytes);
+  throw new NodaroError(message, code, status);
+}
+
+// src/resources/workflows.ts
+var WorkflowsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** List workflows for a project. Returns metadata only — `nodes`/`edges` are not included. */
+  list(params) {
+    return this.client.request(
+      "GET",
+      `/v1/projects/${encodeURIComponent(params.projectId)}/workflows`
+    );
+  }
+  /** Get a workflow including its full nodes/edges/settings. */
+  get(id) {
+    return this.client.request("GET", `/v1/workflows/${encodeURIComponent(id)}`);
+  }
+  /**
+   * Get a PUBLICLY-SHARED workflow by id (`GET /v1/public/workflows/:id`) — the
+   * unauthenticated share-by-link read. Returns the workflow's nodes/edges/
+   * settings ONLY when it's opted into sharing server-side (`settings.studio.shared
+   * === true`); otherwise the route 404s (→ `NotFoundError`). No auth required —
+   * a share viewer has no session; the SDK omits the bearer when no token exists.
+   */
+  getPublic(id) {
+    return this.client.request("GET", `/v1/public/workflows/${encodeURIComponent(id)}`);
+  }
+  /**
+   * Create a workflow under a project. Returns the full record.
+   * NOTE: server route is `POST /v1/projects/:projectId/workflows`.
+   */
+  create(input) {
+    const { projectId, ...body } = input;
+    return this.client.request(
+      "POST",
+      `/v1/projects/${encodeURIComponent(projectId)}/workflows`,
+      { body }
+    );
+  }
+  /** Patch a workflow. Returns the full updated record. */
+  update(id, input) {
+    return this.client.request(
+      "PATCH",
+      `/v1/workflows/${encodeURIComponent(id)}`,
+      { body: input }
+    );
+  }
+  /** Delete a workflow. Returns `{ success: true }`. */
+  delete(id) {
+    return this.client.request("DELETE", `/v1/workflows/${encodeURIComponent(id)}`);
+  }
+  /**
+   * Run a workflow. Returns the executionId for polling via
+   * `client.executions.get(executionId)`.
+   */
+  run(id, params = {}) {
+    return this.client.request(
+      "POST",
+      `/v1/workflows/${encodeURIComponent(id)}/run`,
+      { body: params }
+    );
+  }
+  /**
+   * Export a workflow as a portable JSON bundle.
+   * Pass `opts.assets = true` to include character/object/location entity data.
+   */
+  export(workflowId, opts) {
+    return this.client.request(
+      "GET",
+      `/v1/workflows/${encodeURIComponent(workflowId)}/export`,
+      { query: { assets: opts?.assets ?? false } }
+    );
+  }
+  /**
+   * Import a `WorkflowExport` bundle into the specified project.
+   * Re-creates any bundled assets (characters, objects, locations) under your account.
+   */
+  import(input) {
+    const { projectId, ...workflowJson } = input;
+    return this.client.request("POST", "/v1/workflows/import", {
+      body: { projectId, workflow_json: workflowJson }
+    });
+  }
+};
+
+// src/resources/projects.ts
+var ProjectsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** List the authenticated user's projects. */
+  list() {
+    return this.client.request("GET", "/v1/projects");
+  }
+  /** Get a project by ID. */
+  get(id) {
+    return this.client.request("GET", `/v1/projects/${encodeURIComponent(id)}`);
+  }
+  /** Create a new project. */
+  create(input) {
+    return this.client.request("POST", "/v1/projects", { body: input });
+  }
+  /** Update a project. At least one field must be provided. */
+  update(id, input) {
+    return this.client.request(
+      "PATCH",
+      `/v1/projects/${encodeURIComponent(id)}`,
+      { body: input }
+    );
+  }
+  /** Delete a project. Returns `{ success: true }`. */
+  delete(id) {
+    return this.client.request("DELETE", `/v1/projects/${encodeURIComponent(id)}`);
+  }
+};
+
+// src/resources/jobs.ts
+var JobsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Get a single job by ID. */
+  get(id) {
+    return this.client.request("GET", `/v1/jobs/${encodeURIComponent(id)}`);
+  }
+  /**
+   * Get the lean status of a single job (poll-loop friendly).
+   * Hits `GET /v1/jobs/:id/status` — returns only id/status/progress/
+   * output_data/error_message, with far less wire/CPU cost than `get()`.
+   * Same auth + ownership semantics as {@link get}.
+   */
+  getStatus(id) {
+    return this.client.request(
+      "GET",
+      `/v1/jobs/${encodeURIComponent(id)}/status`
+    );
+  }
+  /**
+   * Cancel a job. Server route is `POST /v1/jobs/:jobId/cancel`.
+   * Refunds any reserved credit holds.
+   */
+  cancel(id) {
+    return this.client.request(
+      "POST",
+      `/v1/jobs/${encodeURIComponent(id)}/cancel`
+    );
+  }
+};
+
+// src/resources/executions.ts
+var ExecutionsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Get an execution by ID. Falls back to standalone single-node jobs server-side. */
+  get(id) {
+    return this.client.request(
+      "GET",
+      `/v1/workflow-executions/${encodeURIComponent(id)}`
+    );
+  }
+  /** List executions for a workflow. Merges workflow_executions + standalone single-node jobs. */
+  listForWorkflow(workflowId, params = {}) {
+    return this.client.request(
+      "GET",
+      `/v1/workflows/${encodeURIComponent(workflowId)}/executions`,
+      {
+        query: {
+          limit: params.limit,
+          cursor: params.cursor,
+          status: params.status,
+          source: params.source
+        }
+      }
+    );
+  }
+  /** Cancel an execution. Returns `{ success: true }`. */
+  cancel(id, params = {}) {
+    return this.client.request(
+      "POST",
+      `/v1/workflow-executions/${encodeURIComponent(id)}/cancel`,
+      { body: params }
+    );
+  }
+};
+
+// src/resources/nodes.ts
+var DEFAULT_POLL_MS = 2e3;
+var DEFAULT_MAX_MS = 15 * 60 * 1e3;
+var sleep = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted) {
+    reject(new JobAbortedError());
+    return;
+  }
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms);
+  function onAbort() {
+    clearTimeout(timer);
+    reject(new JobAbortedError());
+  }
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+function extractJobId(result, label) {
+  if (result && typeof result === "object" && "jobId" in result) {
+    const jobId = result.jobId;
+    if (typeof jobId === "string") return jobId;
+  }
+  throw new JobFailedError(`${label} did not return a jobId`, "");
+}
+var NodesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** List all known node descriptors. Server caches publicly for 5 minutes. */
+  list() {
+    return this.client.request("GET", "/v1/nodes");
+  }
+  /** Get a single node descriptor by type slug (e.g. "generate-image"). */
+  get(type) {
+    return this.client.request("GET", `/v1/nodes/${encodeURIComponent(type)}`);
+  }
+  run(type, params = {}) {
+    return this.client.request("POST", `/v1/${encodeURIComponent(type)}`, { body: params });
+  }
+  async runAndWait(type, params = {}, opts = {}) {
+    if (opts.signal?.aborted) throw new JobAbortedError();
+    const result = await this.run(type, params);
+    const jobId = extractJobId(result, type);
+    return this.pollJob(jobId, type, opts);
+  }
+  /**
+   * Fan out N async runs of the same node `type` to completion concurrently —
+   * the candidate-grid path (generate N stills/clips in parallel). Each runs
+   * via {@link runAndWait}; resolves once ALL settle, to an array of
+   * `{ jobId, output }` in input order. Rejects (and the rejection wins) if any
+   * single run rejects — same typed errors as {@link runAndWait}. A shared
+   * `signal` aborts the whole batch.
+   *
+   * @param type        Node type slug, applied to every entry.
+   * @param paramsList  One request body per candidate.
+   * @param opts        Shared `signal` / `onProgress` / `pollMs` / `maxMs`.
+   */
+  async runMany(type, paramsList, opts = {}) {
+    if (opts.signal?.aborted) throw new JobAbortedError();
+    return Promise.all(
+      paramsList.map(async (params) => {
+        if (opts.signal?.aborted) throw new JobAbortedError();
+        const result = await this.run(type, params);
+        const jobId = extractJobId(result, type);
+        const output = await this.pollJob(jobId, type, opts);
+        return { jobId, output };
+      })
+    );
+  }
+  /** Poll an already-kicked job id until terminal; resolve output_data or throw. */
+  async pollJob(jobId, label, opts) {
+    const pollMs = opts.pollMs ?? DEFAULT_POLL_MS;
+    const maxMs = opts.maxMs ?? DEFAULT_MAX_MS;
+    const deadline = Date.now() + maxMs;
+    for (; ; ) {
+      if (opts.signal?.aborted) throw new JobAbortedError(void 0, jobId);
+      const { data } = await this.client.jobs.getStatus(jobId);
+      opts.onProgress?.(data);
+      if (data.status === "completed") {
+        return data.output_data ?? {};
+      }
+      if (data.status === "failed" || data.status === "cancelled") {
+        throw new JobFailedError(
+          data.error_message ?? `${label} ${data.status}`,
+          jobId,
+          data.status
+        );
+      }
+      if (Date.now() > deadline) {
+        throw new JobTimeoutError(`${label} timed out`, jobId, maxMs);
+      }
+      await sleep(pollMs, opts.signal);
+    }
+  }
+};
+
+// src/resources/developer-apps.ts
+var DeveloperAppsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** List the authenticated user's developer apps. */
+  list() {
+    return this.client.request("GET", "/v1/developer-apps");
+  }
+  /** Get a developer app by ID. */
+  get(id) {
+    return this.client.request("GET", `/v1/developer-apps/${encodeURIComponent(id)}`);
+  }
+  /**
+   * Create a new developer app. Returns the app PLUS a one-time `clientSecret`
+   * — store it now, the secret hash is the only copy kept server-side.
+   */
+  create(input) {
+    return this.client.request("POST", "/v1/developer-apps", { body: input });
+  }
+  /** Update a developer app's metadata, redirect URIs, origins, or requested scopes. */
+  update(id, input) {
+    return this.client.request(
+      "PATCH",
+      `/v1/developer-apps/${encodeURIComponent(id)}`,
+      { body: input }
+    );
+  }
+  /** Delete a developer app. Returns `{ success: true }`. */
+  delete(id) {
+    return this.client.request(
+      "DELETE",
+      `/v1/developer-apps/${encodeURIComponent(id)}`
+    );
+  }
+  /**
+   * Generate a new `clientSecret`. The previous secret is invalidated.
+   * Server returns ONLY the new secret, not the full app record.
+   */
+  rotateSecret(id) {
+    return this.client.request(
+      "POST",
+      `/v1/developer-apps/${encodeURIComponent(id)}/rotate-secret`
+    );
+  }
+};
+
+// src/resources/oauth.ts
+var OAuthResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Server-side authorization-code exchange. Sends the standard OAuth 2.0
+   * `application/json` body to `POST /v1/oauth/token`.
+   *
+   * NEVER call this from a browser — `client_secret` must stay on the server.
+   */
+  exchangeCode(input) {
+    return this.client.request("POST", "/v1/oauth/token", {
+      body: { grant_type: "authorization_code", ...input }
+    });
+  }
+  /**
+   * Revoke an access token (RFC 7009). Always returns `{ success: true }`,
+   * even for unknown tokens — the spec forbids leaking token validity.
+   */
+  revoke(token) {
+    return this.client.request("POST", "/v1/oauth/revoke", { body: { token } });
+  }
+  /**
+   * Get public app metadata for a consent screen.
+   * `GET /v1/oauth/app-info?client_id=<id>`. Public route — no auth needed.
+   */
+  getAppInfo(clientId) {
+    return this.client.request("GET", "/v1/oauth/app-info", {
+      query: { client_id: clientId }
+    });
+  }
+};
+
+// src/resources/apps.ts
+var AppsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** List published apps. Public — no auth required for community apps. */
+  list(params = {}) {
+    const qs = new URLSearchParams();
+    if (params.search) qs.set("search", params.search);
+    if (params.limit !== void 0) qs.set("limit", String(params.limit));
+    if (params.cursor) qs.set("cursor", params.cursor);
+    if (params.category) qs.set("category", params.category);
+    const query = qs.toString();
+    return this.client.request("GET", `/v1/apps/browse${query ? `?${query}` : ""}`);
+  }
+  /** Get one app's metadata + input schema by slug. */
+  get(slug) {
+    return this.client.request("GET", `/v1/app/${encodeURIComponent(slug)}`);
+  }
+  /**
+   * Trigger an app run with the given input values. The keys in `inputs` must
+   * match the app's input-schema field names (see `get(slug).inputSchema`).
+   * Returns the execution-id for status polling via client.executions.get().
+   */
+  run(slug, inputs = {}) {
+    return this.client.request("POST", `/v1/app/${encodeURIComponent(slug)}/run`, {
+      body: { inputs }
+    });
+  }
+  /** List past runs for an app (the caller must own the app or the runs). */
+  listRuns(slug, params = {}) {
+    const qs = new URLSearchParams();
+    if (params.limit !== void 0) qs.set("limit", String(params.limit));
+    if (params.cursor) qs.set("cursor", params.cursor);
+    const query = qs.toString();
+    return this.client.request(
+      "GET",
+      `/v1/app/${encodeURIComponent(slug)}/runs${query ? `?${query}` : ""}`
+    );
+  }
+  /** Get one app-run by id. */
+  getRun(slug, runId) {
+    return this.client.request(
+      "GET",
+      `/v1/app/${encodeURIComponent(slug)}/runs/${encodeURIComponent(runId)}`
+    );
+  }
+  /**
+   * Archive (soft-delete) a published-app run. The run is hidden from the
+   * default run list and can be restored or permanently deleted from the
+   * archive view at https://app.nodaro.ai/archived-runs.
+   *
+   * @param slug   The published app's slug (the last path segment of its URL).
+   * @param runId  The run's UUID.
+   */
+  deleteRun(slug, runId) {
+    return this.client.request(
+      "DELETE",
+      `/v1/app/${encodeURIComponent(slug)}/runs/${encodeURIComponent(runId)}`
+    );
+  }
+};
+var CharactersResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * List the caller's characters. By default returns active characters only;
+   * pass `archived: true` to fetch soft-deleted rows for an "archive" view.
+   * When `projectId` is set, only characters belonging to that project are
+   * returned.
+   */
+  list(params = {}) {
+    const query = {};
+    if (params.projectId) query.projectId = params.projectId;
+    if (params.archived) query.archived = "true";
+    if (params.limit !== void 0) query.limit = String(params.limit);
+    return this.client.request("GET", "/v1/characters", { query });
+  }
+  /**
+   * Fetch a single character including in-flight portrait / asset job state.
+   * Soft-deleted (archived) rows are returned by id intentionally so canvas
+   * nodes that hold a stale `characterDbId` keep loading.
+   */
+  get(id) {
+    return this.client.request("GET", `/v1/characters/${encodeURIComponent(id)}`);
+  }
+  /**
+   * Create or update a character. Omit `id` to create; supply it to update
+   * (only the fields you pass get written — undefined keys are untouched).
+   *
+   * If the caller-supplied `name` collides with an existing active character
+   * for this user, the request returns 409 `name_taken`. To auto-number a
+   * placeholder, pass the placeholder name from `@nodaro/shared` and the
+   * server will derive "Untitled character 2", "Untitled character 3", etc.
+   */
+  upsert(input) {
+    return this.client.request("POST", "/v1/characters", { body: input });
+  }
+  /**
+   * Convenience wrapper around `upsert()` for creating new characters.
+   * Equivalent to `upsert({ ...input, id: undefined })`. `name` is REQUIRED
+   * on create — the route 400s on INSERT-without-name; we narrow the type
+   * here so callers fail at compile-time rather than runtime.
+   */
+  create(input) {
+    return this.upsert(input);
+  }
+  /**
+   * Convenience wrapper around `upsert()` for updating an existing character.
+   * Equivalent to `upsert({ ...input, id })`.
+   */
+  update(id, input) {
+    return this.upsert({ ...input, id });
+  }
+  /**
+   * Soft-delete (archive) a character. The row is hidden from `list()` by
+   * default but still loadable via `get(id)` so canvas nodes pointing at it
+   * keep working. Restore with `restore(id)`.
+   */
+  delete(id) {
+    return this.client.request("DELETE", `/v1/characters/${encodeURIComponent(id)}`);
+  }
+  /**
+   * Un-archive a character. If the original name now collides with an
+   * active row, the server auto-suffixes "(restored)" and returns the
+   * effective name.
+   */
+  restore(id) {
+    return this.client.request("POST", `/v1/characters/${encodeURIComponent(id)}/restore`);
+  }
+  /**
+   * Duplicate (fork) a character to a new row with a `"(copy)"` suffix.
+   * Asset URLs are shared by reference — the new row can diverge by
+   * regenerating any of them.
+   */
+  duplicate(id, input = {}) {
+    return this.client.request(
+      "POST",
+      `/v1/characters/${encodeURIComponent(id)}/duplicate`,
+      { body: input }
+    );
+  }
+  /**
+   * Count of the caller's workflows that reference this character. Powers the
+   * library "Archive" confirmation modal in the editor.
+   */
+  usage(id) {
+    return this.client.request("GET", `/v1/characters/${encodeURIComponent(id)}/usage`);
+  }
+  /**
+   * Fire `POST /v1/generate-character` to produce one or more portrait
+   * candidates. With `count > 1`, all jobs are reserved up-front before any
+   * is enqueued — mid-batch failures roll back atomically.
+   *
+   * When `attachToCharacterId` is set, the worker writes the result directly
+   * to the row's `source_image_url`; otherwise you must call
+   * `approvePortrait()` after picking a candidate.
+   */
+  generate(input) {
+    return this.client.request("POST", "/v1/generate-character", { body: input });
+  }
+  /**
+   * Fire `POST /v1/generate-character-asset` to produce a single
+   * expression / pose / angle / lighting variant. When the studio path is
+   * set (`attachToCharacterId` + `attachToColumn` + `attachName`), the
+   * worker appends `{ name: attachName, url: <result> }` to the named
+   * JSONB array column on completion.
+   */
+  generateAsset(input) {
+    return this.client.request("POST", "/v1/generate-character-asset", { body: input });
+  }
+  /**
+   * Fire `POST /v1/generate-character-motion` to animate the character's
+   * portrait into a motion clip. The result is appended to the character's
+   * `motions[]` bucket when `attachToCharacterId` is set.
+   */
+  generateMotion(input) {
+    return this.client.request("POST", "/v1/generate-character-motion", { body: input });
+  }
+  /**
+   * Approve a completed `generate-character` job as the character's portrait.
+   * Sets `source_image_url` and fires the LLM caption (Claude Sonnet vision)
+   * inline. Returns the new portrait URL plus the caption — `canonicalDescription`
+   * is `null` if the LLM call sub-failed (portrait still set; retry via `recaption()`).
+   */
+  approvePortrait(id, candidateJobId) {
+    return this.client.request(
+      "POST",
+      `/v1/characters/${encodeURIComponent(id)}/approve-portrait`,
+      { body: { candidateJobId } }
+    );
+  }
+  /**
+   * Re-fire the LLM caption against the character's current portrait. 502s on
+   * LLM failure; returns 400 `no_portrait` if no portrait is set yet.
+   */
+  recaption(id) {
+    return this.client.request(
+      "POST",
+      `/v1/characters/${encodeURIComponent(id)}/llm-caption`
+    );
+  }
+};
+function buildPersonSeedPrompt(value) {
+  return prompts.buildPersonHints(value).join(", ");
+}
+var LocationsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * List the caller's locations. By default returns active locations only;
+   * pass `archived: true` to fetch soft-deleted rows for an "archive" view.
+   */
+  list(params = {}) {
+    const query = {};
+    if (params.archived) query.archived = "true";
+    return this.client.request("GET", "/v1/locations", { query });
+  }
+  /**
+   * Convenience wrapper for `list({ archived: true })`. Returns soft-deleted
+   * rows so callers can drive a UI "Archived" tab without re-encoding the
+   * query param. Mirrors `ObjectsResource.listArchived`.
+   *
+   * `archived` is omitted from the param type — it's always set to `true` here.
+   */
+  listArchived(params = {}) {
+    return this.list({ ...params, archived: true });
+  }
+  /**
+   * Fetch a single location including in-flight asset job state. Soft-deleted
+   * (archived) rows are returned by id intentionally so canvas nodes that
+   * hold a stale `locationDbId` keep loading.
+   */
+  async get(id) {
+    const res = await this.client.request(
+      "GET",
+      `/v1/locations/${encodeURIComponent(id)}`
+    );
+    return { ...res, canonicalDescription: res.canonicalDescription || null };
+  }
+  /**
+   * Create a new location. `name` + `nodeId` are required — the route 400s
+   * otherwise. Returns the new row's id.
+   *
+   * Note: the underlying route is the same `POST /v1/locations` upsert that
+   * powers `update()`. This convenience wrapper enforces the INSERT-required
+   * fields at the type level and never sends an `id`.
+   */
+  create(data) {
+    return this.client.request("POST", "/v1/locations", { body: data });
+  }
+  /**
+   * Update a location. Only the fields you pass are written — undefined keys
+   * are NOT touched on the row. Worker-owned asset buckets are intentionally
+   * not exposed on this surface (see `UpdateLocationInput` for the rationale).
+   *
+   * Optimistic-concurrency: pass `expectedUpdatedAt` to require the row's
+   * `updated_at` still matches; on mismatch the route returns 409
+   * `concurrent_modification`. The SDK surfaces that as a generic
+   * `NodaroError` with the same code.
+   */
+  update(id, data) {
+    return this.client.request("POST", "/v1/locations", {
+      body: { id, ...data }
+    });
+  }
+  /**
+   * Soft-delete (archive) a location. The row is hidden from `list()` by
+   * default but still loadable via `get(id)` so canvas nodes pointing at it
+   * keep working. Restore with `restore(id)`.
+   */
+  delete(id) {
+    return this.client.request("DELETE", `/v1/locations/${encodeURIComponent(id)}`);
+  }
+  /**
+   * Un-archive a location. If the original name now collides (case-
+   * insensitive) with an active row, the server auto-suffixes "(restored)"
+   * and returns the effective name.
+   */
+  restore(id) {
+    return this.client.request("POST", `/v1/locations/${encodeURIComponent(id)}/restore`);
+  }
+  /**
+   * Fire `POST /v1/generate-location` to produce one or more candidate main
+   * images. With `count > 1`, all jobs are reserved up-front before any
+   * is enqueued — mid-batch failures roll back atomically.
+   *
+   * When `attachToLocationId` is set AND `count === 1`, the worker writes
+   * the result directly to the row's `source_image_url`; otherwise you must
+   * call `approveMainImage()` after picking a candidate.
+   */
+  async generate(data) {
+    const res = await this.client.request(
+      "POST",
+      "/v1/generate-location",
+      { body: data }
+    );
+    const jobIds = res.jobIds ?? (res.jobId ? [res.jobId] : []);
+    return res.jobId ? { jobIds, jobId: res.jobId } : { jobIds };
+  }
+  /**
+   * Fire `POST /v1/generate-location-asset` to produce a single variant.
+   * When the studio path is set (`attachToLocationId` + `attachToColumn` +
+   * `attachName`), the worker appends `{ name: attachName, url: <result> }`
+   * to the named JSONB array column on completion.
+   */
+  generateAsset(data) {
+    return this.client.request("POST", "/v1/generate-location-asset", { body: data });
+  }
+  /**
+   * Fire `POST /v1/generate-surround-continuation` to produce one seamless 360°
+   * ring view as an i2i continuation of `referenceImageUrl`. The platform builds
+   * the half-carry composite, paints the missing half, and color-harmonizes it
+   * to the carried half (no tonal seam; carried half stays pixel-exact). When the
+   * studio path is set, the worker appends the result to the location's bucket.
+   */
+  generateSurroundContinuation(data) {
+    return this.client.request("POST", "/v1/generate-surround-continuation", { body: data });
+  }
+  /**
+   * Fire `POST /v1/generate-location-motion` to animate the location's
+   * establishing shot into an atmospheric motion clip. Image-to-video, single
+   * clip per call; the attach column is hardcoded to `atmosphere_motions`
+   * server-side (locations have a single motion bucket so the caller doesn't
+   * supply `attachToColumn`). When the studio path is set
+   * (`attachToLocationId` + `attachName`), the worker appends
+   * `{ name: attachName, url: <result> }` to the row's `atmosphere_motions`
+   * column on completion.
+   */
+  generateMotion(data) {
+    return this.client.request("POST", "/v1/generate-location-motion", { body: data });
+  }
+  /**
+   * Atomically remove ONE asset take (every entry matching `url`) from a
+   * worker-owned bucket column — `POST /v1/locations/:id/remove-asset`. The
+   * worker-owned buckets are deliberately not writable through `update()`
+   * (a stale snapshot would race concurrent worker appends), so deleting a
+   * take — e.g. a 360° surround view being regenerated — goes through this
+   * single-statement server-side filter instead. 404s (`NotFoundError`) when
+   * the url isn't in that bucket or the location isn't yours.
+   */
+  removeAsset(id, data) {
+    return this.client.request(
+      "POST",
+      `/v1/locations/${encodeURIComponent(id)}/remove-asset`,
+      { body: data }
+    );
+  }
+  /**
+   * Approve a completed `generate-location` job as the location's main image.
+   * Sets `source_image_url` and fires the LLM caption (Claude Sonnet vision)
+   * inline. Returns the new main-image URL plus the caption.
+   *
+   * Caption-failure semantics: the route still sends `""` on LLM sub-failure,
+   * but the SDK normalizes `""` → `null` here so `canonicalDescription` carries
+   * the same `string | null` semantics as characters. The main image is still
+   * set; call `recaption()` to retry.
+   */
+  async approveMainImage(id, candidateJobId) {
+    const res = await this.client.request(
+      "POST",
+      `/v1/locations/${encodeURIComponent(id)}/approve-main-image`,
+      { body: { candidateJobId } }
+    );
+    return { sourceImageUrl: res.sourceImageUrl, canonicalDescription: res.canonicalDescription || null };
+  }
+  /**
+   * Re-fire the LLM caption against the location's current main image. 502s
+   * on LLM failure (unlike `approveMainImage` which preserves the side-effect
+   * and returns ""); returns 400 `no_source_image` if no main image is set
+   * yet.
+   */
+  recaption(id) {
+    return this.client.request(
+      "POST",
+      `/v1/locations/${encodeURIComponent(id)}/llm-caption`
+    );
+  }
+};
+var ObjectsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * List the caller's objects. By default returns active objects only;
+   * pass `archived: true` to fetch soft-deleted rows for an "archive" view.
+   * Optional `projectId` scopes the result to a single project.
+   */
+  list(params = {}) {
+    const query = {};
+    if (params.archived) query.archived = "true";
+    if (params.projectId) query.projectId = params.projectId;
+    return this.client.request("GET", "/v1/objects", { query });
+  }
+  /**
+   * Convenience wrapper for `list({ archived: true })`. Returns soft-deleted
+   * rows so callers can drive a UI "Archived" tab without re-encoding the
+   * query param.
+   *
+   * `archived` is omitted from the param type — it's always set to `true` here.
+   */
+  listArchived(params = {}) {
+    return this.list({ ...params, archived: true });
+  }
+  /**
+   * Fetch a single object including in-flight asset job state. Soft-deleted
+   * (archived) rows are NOT returned by id — the route enforces
+   * `deleted_at IS NULL` so archived objects 404 (uniform Pass 10 F-90b
+   * "not_found" — does not leak the deleted vs non-existent distinction).
+   */
+  async get(id) {
+    const res = await this.client.request(
+      "GET",
+      `/v1/objects/${encodeURIComponent(id)}`
+    );
+    return { ...res, canonicalDescription: res.canonicalDescription || null };
+  }
+  /**
+   * Create a new object. `name` + `nodeId` are required — the route 400s
+   * otherwise. Returns the new row's id.
+   *
+   * Note: the underlying route is the same `POST /v1/objects` upsert that
+   * powers `update()`. This convenience wrapper enforces the INSERT-required
+   * fields at the type level and never sends an `id`.
+   */
+  create(data) {
+    return this.client.request("POST", "/v1/objects", { body: data });
+  }
+  /**
+   * Update an object. Only the fields you pass are written — undefined keys
+   * are NOT touched on the row. Worker-owned asset buckets are intentionally
+   * not exposed on this surface (see `UpdateObjectInput` for the rationale).
+   *
+   * Optimistic-concurrency: pass `expectedUpdatedAt` to require the row's
+   * `updated_at` still matches; on mismatch the route returns 409
+   * `concurrent_modification` carrying the fresh `updatedAt`. The SDK
+   * surfaces that as a generic `NodaroError` with the same code (per Phase
+   * E1 calibration finding — error centralization in `throwApiError`).
+   */
+  update(id, data) {
+    return this.client.request("POST", "/v1/objects", {
+      body: { id, ...data }
+    });
+  }
+  /**
+   * Soft-delete (archive) an object. The row is hidden from `list()` by
+   * default but recoverable via `restore(id)` or visible under
+   * `listArchived()`. Idempotent — repeating a delete on an already-archived
+   * row is a no-op.
+   */
+  delete(id) {
+    return this.client.request("DELETE", `/v1/objects/${encodeURIComponent(id)}`);
+  }
+  /**
+   * Hard-delete (permanent) an object — the row + every R2 asset it
+   * references. Archived rows ONLY: active objects return 400 `not_archived`.
+   * Call `delete()` first to archive, then `permanentDelete()` to destroy.
+   *
+   * Mirrors the `app_runs` permanent-delete pattern (archive-first) so a
+   * stray SDK / curl caller cannot bypass the studio's archive-first UI
+   * flow.
+   */
+  permanentDelete(id) {
+    return this.client.request("DELETE", `/v1/objects/${encodeURIComponent(id)}`, {
+      query: { permanent: "true" }
+    });
+  }
+  /**
+   * Un-archive an object. If the original name now collides (case-
+   * insensitive) with an active row, the server auto-suffixes "(restored)"
+   * and returns the effective name.
+   */
+  restore(id) {
+    return this.client.request("POST", `/v1/objects/${encodeURIComponent(id)}/restore`);
+  }
+  /**
+   * Fire `POST /v1/generate-object` to produce one or more candidate main
+   * images. With `count > 1`, all jobs are reserved up-front before any
+   * is enqueued — mid-batch failures roll back atomically.
+   *
+   * When `attachToObjectId` is set AND `count === 1`, the worker writes
+   * the result directly to the row's `source_image_url`; otherwise you must
+   * call `approveMainImage()` after picking a candidate.
+   */
+  async generate(data) {
+    const res = await this.client.request(
+      "POST",
+      "/v1/generate-object",
+      { body: data }
+    );
+    const jobIds = res.jobIds ?? (res.jobId ? [res.jobId] : []);
+    return res.jobId ? { jobIds, jobId: res.jobId } : { jobIds };
+  }
+  /**
+   * Fire `POST /v1/generate-object-asset` to produce a single variant.
+   * When the studio path is set (`attachToObjectId` + `attachToColumn` +
+   * `attachName`), the worker appends `{ name: attachName, url: <result> }`
+   * to the named JSONB array column on completion.
+   *
+   * Note: `attachToColumn` is REQUIRED for `assetType === "custom"` — the
+   * worker can't infer the bucket from the asset type. For canonical asset
+   * types (`angles` / `materials` / `variations` / `motion`), the column is
+   * derived automatically by the route.
+   */
+  generateAsset(data) {
+    return this.client.request("POST", "/v1/generate-object-asset", { body: data });
+  }
+  /**
+   * Fire `POST /v1/generate-object-motion` to animate the object's main
+   * image into a motion clip. Image-to-video, single clip per call; the
+   * attach column is hardcoded to `motion_clips` server-side (objects have a
+   * single motion bucket so the caller doesn't supply `attachToColumn`).
+   * When the studio path is set (`attachToObjectId` + `attachName`), the
+   * worker appends `{ name: attachName, url: <result> }` to the row's
+   * `motion_clips` column on completion.
+   *
+   * Defaults: `provider` → `"kling-turbo"`, `aspectRatio` → `"1:1"` (set
+   * server-side via `resolveObjectAspectRatio({ assetType: "motion" })`).
+   */
+  generateMotion(data) {
+    return this.client.request("POST", "/v1/generate-object-motion", { body: data });
+  }
+  /**
+   * Approve a completed `generate-object` job as the object's main image.
+   * Sets `source_image_url` and fires the LLM caption (Claude Sonnet vision)
+   * inline. Returns the new main-image URL plus the caption.
+   *
+   * Caption-failure semantics: the route still sends `""` on LLM sub-failure,
+   * but the SDK normalizes `""` → `null` here so `canonicalDescription` carries
+   * the same `string | null` semantics as characters. The main image is still
+   * set; call `recaption()` to retry.
+   *
+   * Optimistic-concurrency: pass `expectedUpdatedAt` to gate the update on
+   * the row's current `updated_at`; on mismatch the route returns 409
+   * `concurrent_modification` carrying the fresh token.
+   */
+  async approveMainImage(id, candidateJobId, expectedUpdatedAt) {
+    const res = await this.client.request(
+      "POST",
+      `/v1/objects/${encodeURIComponent(id)}/approve-main-image`,
+      { body: { candidateJobId, expectedUpdatedAt } }
+    );
+    return { sourceImageUrl: res.sourceImageUrl, canonicalDescription: res.canonicalDescription || null };
+  }
+  /**
+   * Re-fire the LLM caption against the object's current main image. 502s
+   * on LLM failure (unlike `approveMainImage` which preserves the side-effect
+   * and returns ""); returns 400 `main_image_required` if no main image is
+   * set yet.
+   *
+   * The route is a pure idempotent retry — it does NOT accept an
+   * `expectedUpdatedAt` token (per Phase E1 calibration finding: backend
+   * route is idempotent retry, not gated on optimistic-concurrency).
+   */
+  recaption(id) {
+    return this.client.request(
+      "POST",
+      `/v1/objects/${encodeURIComponent(id)}/llm-caption`
+    );
+  }
+};
+var CREATURE_ASSET_TYPES = ["angles", "poses", "variations", "custom"];
+var CreaturesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * List the caller's creatures. By default returns active creatures only;
+   * pass `archived: true` to fetch soft-deleted rows for an "archive" view.
+   * Optional `projectId` scopes the result to a single project.
+   */
+  list(params = {}) {
+    const query = {};
+    if (params.archived) query.archived = "true";
+    if (params.projectId) query.projectId = params.projectId;
+    return this.client.request("GET", "/v1/creatures", { query });
+  }
+  /**
+   * Convenience wrapper for `list({ archived: true })`. Returns soft-deleted
+   * rows so callers can drive a UI "Archived" tab without re-encoding the
+   * query param.
+   *
+   * `archived` is omitted from the param type — it's always set to `true` here.
+   */
+  listArchived(params = {}) {
+    return this.list({ ...params, archived: true });
+  }
+  /**
+   * Fetch a single creature including in-flight asset job state. Soft-deleted
+   * (archived) rows are NOT returned by id — the route enforces
+   * `deleted_at IS NULL` so archived creatures 404 (uniform "not_found" — does
+   * not leak the deleted vs non-existent distinction).
+   */
+  async get(id) {
+    const res = await this.client.request(
+      "GET",
+      `/v1/creatures/${encodeURIComponent(id)}`
+    );
+    return { ...res, canonicalDescription: res.canonicalDescription || null };
+  }
+  /**
+   * Create a new creature. `name` + `nodeId` are required — the route 400s
+   * otherwise. Returns the new row's id.
+   *
+   * Note: the underlying route is the same `POST /v1/creatures` upsert that
+   * powers `update()`. This convenience wrapper enforces the INSERT-required
+   * fields at the type level and never sends an `id`.
+   */
+  create(data) {
+    return this.client.request("POST", "/v1/creatures", { body: data });
+  }
+  /**
+   * Update a creature. Only the fields you pass are written — undefined keys
+   * are NOT touched on the row. Worker-owned asset buckets are intentionally
+   * not exposed on this surface (see `UpdateCreatureInput` for the rationale).
+   *
+   * Optimistic-concurrency: pass `expectedUpdatedAt` to require the row's
+   * `updated_at` still matches; on mismatch the route returns 409
+   * `concurrent_modification` carrying the fresh `updatedAt`. The SDK
+   * surfaces that as a generic `NodaroError` with the same code.
+   */
+  update(id, data) {
+    return this.client.request("POST", "/v1/creatures", {
+      body: { id, ...data }
+    });
+  }
+  /**
+   * Soft-delete (archive) a creature. The row is hidden from `list()` by
+   * default but recoverable via `restore(id)` or visible under
+   * `listArchived()`. Idempotent — repeating a delete on an already-archived
+   * row is a no-op.
+   */
+  delete(id) {
+    return this.client.request("DELETE", `/v1/creatures/${encodeURIComponent(id)}`);
+  }
+  /**
+   * Hard-delete (permanent) a creature — the row + every R2 asset it
+   * references. Archived rows ONLY: active creatures return 400 `not_archived`.
+   * Call `delete()` first to archive, then `permanentDelete()` to destroy.
+   *
+   * Mirrors the `app_runs` permanent-delete pattern (archive-first) so a
+   * stray SDK / curl caller cannot bypass the studio's archive-first UI
+   * flow.
+   */
+  permanentDelete(id) {
+    return this.client.request("DELETE", `/v1/creatures/${encodeURIComponent(id)}`, {
+      query: { permanent: "true" }
+    });
+  }
+  /**
+   * Un-archive a creature. If the original name now collides (case-
+   * insensitive) with an active row, the server auto-suffixes "(restored)"
+   * and returns the effective name.
+   */
+  restore(id) {
+    return this.client.request("POST", `/v1/creatures/${encodeURIComponent(id)}/restore`);
+  }
+  /**
+   * Fire `POST /v1/generate-creature` to produce one or more candidate main
+   * images. With `count > 1`, all jobs are reserved up-front before any
+   * is enqueued — mid-batch failures roll back atomically.
+   *
+   * When `attachToCreatureId` is set AND `count === 1`, the worker writes
+   * the result directly to the row's `source_image_url`; otherwise you must
+   * call `approveMainImage()` after picking a candidate.
+   */
+  async generate(data) {
+    const res = await this.client.request(
+      "POST",
+      "/v1/generate-creature",
+      { body: data }
+    );
+    const jobIds = res.jobIds ?? (res.jobId ? [res.jobId] : []);
+    return res.jobId ? { jobIds, jobId: res.jobId } : { jobIds };
+  }
+  /**
+   * Fire `POST /v1/generate-creature-asset` to produce a single variant.
+   * When the studio path is set (`attachToCreatureId` + `attachToColumn` +
+   * `attachName`), the worker appends `{ name: attachName, url: <result> }`
+   * to the named JSONB array column on completion.
+   *
+   * Note: `attachToColumn` is REQUIRED for `assetType === "custom"` — the
+   * worker can't infer the bucket from the asset type. For canonical asset
+   * types (`angles` / `poses` / `variations`), the column is derived
+   * automatically by the route.
+   */
+  generateAsset(data) {
+    return this.client.request("POST", "/v1/generate-creature-asset", { body: data });
+  }
+  /**
+   * Fire `POST /v1/generate-creature-motion` to animate the creature's main
+   * image into a motion clip. Image-to-video, single clip per call; the
+   * attach column is hardcoded to `motion_clips` server-side (creatures have a
+   * single motion bucket so the caller doesn't supply `attachToColumn`).
+   * When the studio path is set (`attachToCreatureId` + `attachName`), the
+   * worker appends `{ name: attachName, url: <result> }` to the row's
+   * `motion_clips` column on completion.
+   *
+   * Defaults: `provider` → `"kling-turbo"`, `aspectRatio` → `"1:1"` (set
+   * server-side via `resolveObjectAspectRatio({ assetType: "motion" })`).
+   */
+  generateMotion(data) {
+    return this.client.request("POST", "/v1/generate-creature-motion", { body: data });
+  }
+  /**
+   * Approve a completed `generate-creature` job as the creature's main image.
+   * Sets `source_image_url` and fires the LLM caption (Claude Sonnet vision)
+   * inline. Returns the new main-image URL plus the caption.
+   *
+   * Caption-failure semantics: the route still sends `""` on LLM sub-failure,
+   * but the SDK normalizes `""` → `null` here so `canonicalDescription` carries
+   * the same `string | null` semantics as characters. The main image is still
+   * set; call `recaption()` to retry.
+   *
+   * Optimistic-concurrency: pass `expectedUpdatedAt` to gate the update on
+   * the row's current `updated_at`; on mismatch the route returns 409
+   * `concurrent_modification` carrying the fresh token.
+   */
+  async approveMainImage(id, candidateJobId, expectedUpdatedAt) {
+    const res = await this.client.request(
+      "POST",
+      `/v1/creatures/${encodeURIComponent(id)}/approve-main-image`,
+      { body: { candidateJobId, expectedUpdatedAt } }
+    );
+    return { sourceImageUrl: res.sourceImageUrl, canonicalDescription: res.canonicalDescription || null };
+  }
+  /**
+   * Re-fire the LLM caption against the creature's current main image. 502s
+   * on LLM failure (unlike `approveMainImage` which preserves the side-effect
+   * and returns ""); returns 400 `main_image_required` if no main image is
+   * set yet.
+   *
+   * The route is a pure idempotent retry — it does NOT accept an
+   * `expectedUpdatedAt` token (backend route is idempotent retry, not gated on
+   * optimistic-concurrency).
+   */
+  recaption(id) {
+    return this.client.request(
+      "POST",
+      `/v1/creatures/${encodeURIComponent(id)}/llm-caption`
+    );
+  }
+};
+
+// src/resources/pipelines.ts
+var PipelinesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Start a new pipeline (headless film generation) — the programmatic
+   * equivalent of the studio's "Create film". In Auto mode the engine
+   * self-advances to completion; poll {@link get} for status and
+   * {@link getTimeline} for the assembled output. In manual/guided mode, drive
+   * it with {@link pendingApprovals} + {@link approveStage} /
+   * {@link approveSubGate}.
+   *
+   * Requires `pipelines:execute` scope. Returns the new pipeline id.
+   */
+  create(input) {
+    return this.client.request("POST", "/v1/pipelines", { body: input });
+  }
+  /**
+   * Fetch current pipeline state: `status`, `current_stage`, credit counters,
+   * `mode`, and `failure_reason` (set when `status='failed'`). Poll this to
+   * track a headless Auto run to completion. Requires `pipelines:read`.
+   */
+  get(id) {
+    return this.client.request(
+      "GET",
+      `/v1/pipelines/${encodeURIComponent(id)}`
+    );
+  }
+  /** List the caller's pipelines (most recent first). Requires `pipelines:read`. */
+  list() {
+    return this.client.request("GET", "/v1/pipelines");
+  }
+  /**
+   * Cancel a running pipeline. Unspent reserved credits refund. Idempotent on
+   * an already-terminal pipeline. Requires `pipelines:execute`.
+   */
+  cancel(id) {
+    return this.client.request(
+      "POST",
+      `/v1/pipelines/${encodeURIComponent(id)}/cancel`,
+      { body: {} }
+    );
+  }
+  /**
+   * Stages currently `awaiting_approval`. Empty in a clean Auto run (the engine
+   * self-approves); populated in manual/guided mode at each gate. Requires
+   * `pipelines:read`.
+   */
+  pendingApprovals(id) {
+    return this.client.request(
+      "GET",
+      `/v1/pipelines/${encodeURIComponent(id)}/pending-approvals`
+    );
+  }
+  /**
+   * Approve a stage so the engine advances to the next one. An optional `edits`
+   * JSON-Patch is applied to the stage output before approval. Requires
+   * `pipelines:approve`.
+   */
+  approveStage(id, stage, edits) {
+    return this.client.request(
+      "POST",
+      `/v1/pipelines/${encodeURIComponent(id)}/stages/${encodeURIComponent(stage)}/approve`,
+      { body: edits ? { edits } : {} }
+    );
+  }
+  /**
+   * Reject a stage with feedback; the engine re-runs it incorporating the note.
+   * Requires `pipelines:approve`.
+   */
+  rejectStage(id, stage, feedback) {
+    return this.client.request(
+      "POST",
+      `/v1/pipelines/${encodeURIComponent(id)}/stages/${encodeURIComponent(stage)}/reject`,
+      { body: { feedback } }
+    );
+  }
+  /**
+   * Approve a Stage-7 sub-gate (`dialogue_recheck` / `silent_cut`) so the
+   * orchestrator resumes from the next sub-step. Requires `pipelines:approve`.
+   */
+  approveSubGate(id, gate) {
+    return this.client.request(
+      "POST",
+      `/v1/pipelines/${encodeURIComponent(id)}/sub-gates/${encodeURIComponent(gate)}/approve`,
+      { body: {} }
+    );
+  }
+  /**
+   * Read a single stage's `status`, `output`, and `critic_feedback`. Useful for
+   * inspecting the script/plan before approving. Requires `pipelines:read`.
+   */
+  getStage(id, stage) {
+    return this.client.request(
+      "GET",
+      `/v1/pipelines/${encodeURIComponent(id)}/stages/${encodeURIComponent(stage)}`
+    );
+  }
+  /**
+   * Assembled timeline — ordered scene composites + durations + audio URLs +
+   * live animate progress. The output a headless caller renders or hands to a
+   * downstream editor. Requires `pipelines:read`.
+   */
+  getTimeline(id) {
+    return this.client.request(
+      "GET",
+      `/v1/pipelines/${encodeURIComponent(id)}/timeline`
+    );
+  }
+  /**
+   * Branch a completed pipeline into a new pipeline that re-runs from the
+   * given stage. The original pipeline's upstream stages and entities are
+   * cloned into the new pipeline; downstream stages are created by the
+   * orchestrator as it advances.
+   *
+   * Requires `pipelines:execute` scope.
+   * The source pipeline must have `status='completed'`.
+   *
+   * @returns 201 with `{ pipelineId, clonedStages, clonedEntities }`.
+   */
+  branch(id, input) {
+    return this.client.request(
+      "POST",
+      `/v1/pipelines/${encodeURIComponent(id)}/branch`,
+      { body: input }
+    );
+  }
+  /**
+   * Send a chat message to the Showrunner Refinement Director (Guided Mode).
+   * Persists user + assistant turns; returns the assistant's reply and an
+   * optional `proposed_change` the user can `applyChatProposal` to commit.
+   *
+   * Requires `pipelines:approve` scope. The pipeline must have
+   * `mode='guided'` and the stage must be `awaiting_approval`.
+   *
+   * Only the Script stage ships a wired specialist in Phase 1D.2b — the other
+   * chat-enabled stages (`shot_list`, `post_merge`) return 501 until 1D.2d.
+   */
+  chatStage(pipelineId, stage, message) {
+    return this.client.request(
+      "POST",
+      `/v1/pipelines/${encodeURIComponent(pipelineId)}/stages/${encodeURIComponent(stage)}/chat`,
+      { body: { message } }
+    );
+  }
+  /**
+   * Accept a proposed change from a prior assistant turn. Routes through
+   * `applyStageEdit` (validates JSON Patch + per-stage schema +
+   * reference-integrity, inserts a new pipeline_stage_attempts row, CAS-flips
+   * the stage to approved, emits `chat:proposal_applied` SSE).
+   *
+   * Requires `pipelines:approve` scope.
+   *
+   * Returns `{ applied: true, attemptId, newOutput }` on success, or
+   * `{ applied: false, error }` on recoverable failures (the backend already
+   * inserted a follow-up assistant turn with a hint). Hard failures
+   * (`patch_invalid`, `stage_not_awaiting`) throw via the standard error
+   * pipeline (HTTP 409).
+   */
+  applyChatProposal(pipelineId, stage, turnId) {
+    return this.client.request(
+      "POST",
+      `/v1/pipelines/${encodeURIComponent(pipelineId)}/stages/${encodeURIComponent(stage)}/chat/turns/${encodeURIComponent(turnId)}/apply`,
+      { body: {} }
+    );
+  }
+  /**
+   * Fetch the chat history for a stage. Returns an empty array when no turns
+   * exist yet (e.g., stage has not been started or the user hasn't sent any
+   * messages). Used by the frontend chat panel on initial mount; subsequent
+   * updates arrive via SSE (`chat:turn` events).
+   *
+   * Requires `pipelines:read` scope.
+   */
+  getStageChat(pipelineId, stage) {
+    return this.client.request(
+      "GET",
+      `/v1/pipelines/${encodeURIComponent(pipelineId)}/stages/${encodeURIComponent(stage)}/chat`
+    );
+  }
+};
+
+// src/resources/reduce.ts
+var ReduceResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Run the Reduce (fan-in) node directly — useful for scripted batch
+   * scoring, picking the best of N generations outside a workflow, or
+   * one-shot programmatic merges.
+   *
+   * Throws `NodaroError` on 4xx/5xx responses (e.g. `code: "no_valid_inputs"`
+   * with status 400 when every input is empty / whitespace; the underlying
+   * `EmptyInputError` is mapped to a 400 server-side).
+   */
+  run(input) {
+    return this.client.request("POST", "/v1/reduce", {
+      body: {
+        strategyId: input.strategyId,
+        strategyConfig: input.strategyConfig ?? {},
+        inputs: input.inputs,
+        ...input.workflowId !== void 0 ? { workflowId: input.workflowId } : {}
+      }
+    });
+  }
+};
+
+// src/resources/prompt-helper.ts
+var PromptHelperResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  analyze(input) {
+    return this.client.request("POST", "/v1/prompt-helper/wizard", { body: { action: "analyze", ...input } });
+  }
+  generate(input) {
+    return this.client.request("POST", "/v1/prompt-helper/wizard", { body: { action: "generate", ...input } });
+  }
+  enhance(input) {
+    return this.client.request("POST", "/v1/prompt-helper/wizard", { body: { action: "enhance", ...input } });
+  }
+};
+
+// src/resources/voices.ts
+var VoicesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * List the premade ElevenLabs voices (`GET /v1/voices`). Falls back to a
+   * curated set server-side when no ElevenLabs API key is configured.
+   */
+  async list() {
+    const res = await this.client.request("GET", "/v1/voices");
+    return res.voices;
+  }
+  /**
+   * Search the shared/community Voice Library (`GET /v1/voices/library`). All
+   * params are optional and forwarded as a querystring; `undefined` / `null` /
+   * empty-string values are omitted so the server defaults apply. `hasMore`
+   * drives "load more" pagination.
+   */
+  searchLibrary(params = {}) {
+    const query = {};
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== void 0 && v !== null && v !== "") query[k] = v;
+    }
+    return this.client.request("GET", "/v1/voices/library", { query });
+  }
+  /**
+   * List the signed-in user's voice clones (`GET /v1/voice-clones`). The route
+   * wraps the rows in `{ voiceClones }`; we unwrap to the bare array.
+   */
+  async listClones() {
+    const res = await this.client.request("GET", "/v1/voice-clones");
+    return res.voiceClones;
+  }
+  /**
+   * Clone a voice from an already-uploaded audio URL
+   * (`POST /v1/voice-clones/from-url`). Costs credits. Returns the create
+   * subset of `VoiceClone` (`elevenlabsVoiceId` is the id to use at
+   * text-to-speech time).
+   */
+  createClone(input) {
+    return this.client.request("POST", "/v1/voice-clones/from-url", { body: input });
+  }
+  /** Delete one of the user's voice clones (`DELETE /v1/voice-clones/:id`). */
+  async deleteClone(id) {
+    await this.client.request("DELETE", `/v1/voice-clones/${encodeURIComponent(id)}`);
+  }
+  /**
+   * Replace the voice in a recording — or in a whole talking video — with a
+   * different voice (`POST /v1/voice-changer`). Pass `audioUrl` to revoice
+   * audio→audio, or `videoUrl` to revoice an entire clip (the server demuxes
+   * the audio, runs speech-to-speech, and remuxes onto the original video,
+   * returning the video plus the new audio track). Exactly one of `audioUrl` /
+   * `videoUrl` is required; when both are sent, video wins. `removeBackgroundNoise`
+   * off keeps the music/SFX bed under the new voice; on yields a clean voice-only
+   * result. Costs credits and runs async — poll `jobs.get(jobId)` for the result
+   * (`output_data.videoUrl` + `output_data.audioUrl` in video mode).
+   */
+  change(input) {
+    return this.client.request("POST", "/v1/voice-changer", { body: input });
+  }
+  /**
+   * Recast each detected speaker in a multi-speaker recording to a different
+   * voice (`POST /v1/voice-changer-pro`). `orderedVoices` maps speaker positions to
+   * voices in detection order — speaker 0 → `orderedVoices[0]`, speaker 1 →
+   * `orderedVoices[1]`, etc. Speakers beyond the end of `orderedVoices` keep
+   * their original voice. Each entry is EITHER a bare voice id (premade name or
+   * ElevenLabs UUID) OR a {@link VoiceChangerProVoice} object carrying per-voice
+   * ElevenLabs speech-to-speech settings (stability / similarityBoost / style /
+   * useSpeakerBoost / `seed`) plus a loudness `volumeMode` (and a manual
+   * `volume`). A per-voice `seed` makes that speaker's recast reproducible.
+   *
+   * Pass `audioUrl` for audio-only recast or `videoUrl` to recast the audio
+   * track of a video clip (the server demuxes, recasts, and remuxes).
+   *
+   * Voice and music are ALWAYS separated first — ElevenLabs only ever sees the
+   * isolated vocal stem, never the music bed. `preserveBackground` (default
+   * `true`) only controls whether that music/instrumental stem is mixed back
+   * under the new voices; set it `false` for a clean voice-only result.
+   * `separationQuality` selects the demucs model used for that split: `"fast"`
+   * (default, htdemucs — preserves more of the voice) or `"best"` (htdemucs_ft —
+   * finer separation). `removeBackgroundNoise` additionally denoises the result.
+   * `musicVolumeMode` sets the level of that preserved background (only relevant
+   * when `preserveBackground` is on): `"match"` (default) keeps the original
+   * level, `"normalize"` loudnorms it, `"manual"` uses `musicVolume`%.
+   * `voiceFx` applies a reverb/echo to the COMBINED recast voices BEFORE the
+   * background is mixed back in (effect sits on the voices, not the music bed).
+   *
+   * Cloud-only — costs credits and runs async; poll `jobs.get(jobId)` for the
+   * result (`output_data.videoUrl` + `output_data.audioUrl` in video mode).
+   */
+  recast(input) {
+    return this.client.request("POST", "/v1/voice-changer-pro", { body: input });
+  }
+};
+
+// src/resources/credits.ts
+var MODEL_COSTS_LIMIT = 50;
+var CreditsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * `GET /v1/user/credits` → the authenticated user's credit balance and tier
+   * info. Throws `UnauthorizedError` (401) when signed out, and the SDK's
+   * other typed errors on the usual statuses.
+   */
+  async balance() {
+    const res = await this.client.request(
+      "GET",
+      "/v1/user/credits"
+    );
+    return res.data;
+  }
+  /**
+   * `POST /v1/credits/model-costs` → per-identifier credit cost, for editor
+   * cost previews. Capped at the first {@link MODEL_COSTS_LIMIT} identifiers
+   * (the route's request limit). Preserves the `{ data, missing, errors }`
+   * fault-isolation shape verbatim (see {@link ModelCostsResult}).
+   */
+  modelCosts(ids) {
+    return this.client.request("POST", "/v1/credits/model-costs", {
+      body: { models: ids.slice(0, MODEL_COSTS_LIMIT) }
+    });
+  }
+  // NOTE: no `estimate(...)` helper. The backend exposes
+  // `POST /v1/credits/estimate-workflow` (body `{ nodes }` → `{ data: {
+  // totalCredits, nodeCount } }`), but no consumer has a settled shape for it
+  // yet (studio pre-checks `balance >= Σ modelCosts` client-side rather than
+  // calling an estimate endpoint). Adding it now would be inventing an API
+  // surface ahead of a real caller, so it's deliberately omitted — add it when
+  // a consumer needs it, shaped to that need.
+};
+
+// src/resources/uploads.ts
+var UploadsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Upload one file (`POST /v1/upload`, multipart — the file rides the `file`
+   * field). The SDK's `request` detects the `FormData` body and lets the
+   * runtime set the multipart boundary. Returns the persisted asset's public
+   * URL + storage metadata (unwraps the `{ data }` envelope). Throws
+   * `StorageExceededError` (413) over the storage cap and the SDK's other typed
+   * errors on the usual statuses.
+   */
+  async upload(file) {
+    const form = new FormData();
+    form.append("file", file);
+    const res = await this.client.request(
+      "POST",
+      "/v1/upload",
+      { body: form }
+    );
+    return res.data;
+  }
+};
+
+// src/resources/library.ts
+var LibraryResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * `GET /v1/library` → a page of the caller's media assets (newest first) plus
+   * a `nextCursor`. Pass the returned `nextCursor` back as `cursor` for the next
+   * page. Filter by `type` and a filename `search`; `owned: true` returns the
+   * full Storage set (uploads + generations), the default only library-saved +
+   * shared items.
+   */
+  list(params = {}) {
+    const qs = new URLSearchParams();
+    if (params.type) qs.set("type", params.type);
+    if (params.search) qs.set("search", params.search);
+    if (params.limit !== void 0) qs.set("limit", String(params.limit));
+    if (params.cursor) qs.set("cursor", params.cursor);
+    if (params.owned !== void 0) qs.set("owned", String(params.owned));
+    const query = qs.toString();
+    return this.client.request("GET", `/v1/library${query ? `?${query}` : ""}`);
+  }
+};
+
+// src/resources/node-presets.ts
+var PresetsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * `GET /v1/node-presets` → your custom presets, newest first. Pass `nodeType`
+   * (e.g. `"generate-image"`) to filter to one node type.
+   */
+  async list(nodeType) {
+    const qs = nodeType ? `?nodeType=${encodeURIComponent(nodeType)}` : "";
+    const res = await this.client.request("GET", `/v1/node-presets${qs}`);
+    return res.data;
+  }
+  /**
+   * `GET /v1/node-preset-groups` → your preset folders/sections, in display
+   * order. Pass `nodeType` to filter to one node type.
+   */
+  async listGroups(nodeType) {
+    const qs = nodeType ? `?nodeType=${encodeURIComponent(nodeType)}` : "";
+    const res = await this.client.request("GET", `/v1/node-preset-groups${qs}`);
+    return res.data;
+  }
+  /**
+   * `GET /v1/node-presets/factory` → the built-in catalog for `nodeType`. These
+   * ship with the app (no account needed to exist), so they're a good starting
+   * point for "what configs are available".
+   */
+  listFactory(nodeType) {
+    return this.client.request(
+      "GET",
+      `/v1/node-presets/factory?nodeType=${encodeURIComponent(nodeType)}`
+    );
+  }
+};
+
+// src/resources/picker-catalogs.ts
+var PickerCatalogsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** List every parameter-picker node type + its option count. Cached publicly 5 min. */
+  list() {
+    return this.client.request("GET", "/v1/picker-catalogs");
+  }
+  /** Get one picker's catalog of valid values. */
+  get(nodeType, opts = {}) {
+    const qs = new URLSearchParams();
+    if (opts.detail) qs.set("detail", opts.detail);
+    if (opts.category) qs.set("category", opts.category);
+    if (opts.field) qs.set("field", opts.field);
+    const query = qs.toString();
+    return this.client.request(
+      "GET",
+      `/v1/picker-catalogs/${encodeURIComponent(nodeType)}${query ? `?${query}` : ""}`
+    );
+  }
+};
+
+// src/resources/community.ts
+var CommunityResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * `GET /v1/community/browse` → a page of public listings plus a `nextCursor`.
+   * Pass the returned `nextCursor` back as `cursor` to fetch the next page.
+   */
+  browse(params = {}) {
+    const qs = new URLSearchParams();
+    if (params.entityType) qs.set("entityType", params.entityType);
+    if (params.q) qs.set("q", params.q);
+    if (params.category) qs.set("category", params.category);
+    if (params.sort) qs.set("sort", params.sort);
+    if (params.cursor) qs.set("cursor", params.cursor);
+    if (params.limit !== void 0) qs.set("limit", String(params.limit));
+    const query = qs.toString();
+    return this.client.request(
+      "GET",
+      `/v1/community/browse${query ? `?${query}` : ""}`
+    );
+  }
+  /** `GET /v1/community/detail/:slug` → a single listing by its slug. */
+  get(slug) {
+    return this.client.request(
+      "GET",
+      `/v1/community/detail/${encodeURIComponent(slug)}`
+    );
+  }
+  /**
+   * `GET /v1/community/detail/:slug/full` → the full read-only detail (card
+   * identity + the stored public snapshot). Like {@link get}, but includes the
+   * snapshot asset/voice/text blob needed to render the full cross-user view.
+   */
+  getFull(slug) {
+    return this.client.request(
+      "GET",
+      `/v1/community/detail/${encodeURIComponent(slug)}/full`
+    );
+  }
+  /** `GET /v1/community/favorites` → the listings you've favorited. */
+  favorites() {
+    return this.client.request("GET", "/v1/community/favorites");
+  }
+  /**
+   * `POST /v1/community/listings/:id/clone` → copy a listing into your library.
+   * Returns the new asset's `entityType` and `id`. Requires the `assets:write`
+   * scope when called with an OAuth app token.
+   */
+  clone(id, entityType) {
+    return this.client.request(
+      "POST",
+      `/v1/community/listings/${encodeURIComponent(id)}/clone`,
+      { body: { entityType } }
+    );
+  }
+  /**
+   * `POST /v1/community/listings/:id/favorite` → toggle a favorite. Returns the
+   * resulting `favorited` state (`true` after adding, `false` after removing).
+   */
+  favorite(id) {
+    return this.client.request(
+      "POST",
+      `/v1/community/listings/${encodeURIComponent(id)}/favorite`
+    );
+  }
+  /**
+   * `POST /v1/community/listings/:id/report` → flag a listing for moderation.
+   * `reason` must be one of {@link CommunityReportReason}.
+   */
+  report(id, reason) {
+    return this.client.request(
+      "POST",
+      `/v1/community/listings/${encodeURIComponent(id)}/report`,
+      { body: { reason } }
+    );
+  }
+  /**
+   * `POST /v1/admin/community/:entityType/:id/publish` → share one of YOUR
+   * entities to the community, returning the new listing's `slug` + `id`.
+   *
+   * **Requires an admin token** (the route is `requireAdmin`) AND the caller
+   * must own the source entity. Personal/OAuth tokens without admin role get a
+   * 401. For `character` listings, `params.likenessAttestation` must be `true`.
+   */
+  publish(entityType, entityId, params) {
+    return this.client.request(
+      "POST",
+      `/v1/admin/community/${encodeURIComponent(entityType)}/${encodeURIComponent(entityId)}/publish`,
+      { body: params }
+    );
+  }
+  /**
+   * `DELETE /v1/admin/community/listings/:id` → unshare (deactivate) a listing
+   * you published. **Requires an admin token** (the route is `requireAdmin`).
+   */
+  unpublish(listingId) {
+    return this.client.request(
+      "DELETE",
+      `/v1/admin/community/listings/${encodeURIComponent(listingId)}`
+    );
+  }
+  /**
+   * `GET /v1/admin/community/by-source/:entityType/:sourceId` → look up YOUR
+   * existing listing (if any) for a source entity. Returns `{ data: null }`
+   * when the entity hasn't been shared. **Requires an admin token** (the route
+   * is `requireAdmin`); only returns listings created by the caller.
+   */
+  sharedListing(entityType, sourceId) {
+    return this.client.request(
+      "GET",
+      `/v1/admin/community/by-source/${encodeURIComponent(entityType)}/${encodeURIComponent(sourceId)}`
+    );
+  }
+};
+
+// src/client.ts
+var NodaroClient = class {
+  baseUrl;
+  auth;
+  timeoutMs;
+  fetchOverride;
+  /**
+   * Resolved lazily so consumers can swap `globalThis.fetch` after the
+   * client has been constructed (e.g. test mocks). Always rebound to the
+   * global object — native fetch throws "Illegal invocation" when its
+   * `this` is anything else.
+   */
+  get fetch() {
+    return this.fetchOverride ?? globalThis.fetch.bind(globalThis);
+  }
+  workflows;
+  projects;
+  jobs;
+  executions;
+  nodes;
+  developerApps;
+  oauth;
+  apps;
+  characters;
+  locations;
+  objects;
+  creatures;
+  pipelines;
+  reduce;
+  promptHelper;
+  voices;
+  credits;
+  uploads;
+  library;
+  presets;
+  pickerCatalogs;
+  community;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl.replace(/\/$/, "");
+    this.auth = opts.auth;
+    this.fetchOverride = opts.fetch;
+    this.timeoutMs = opts.timeoutMs ?? 6e4;
+    this.workflows = new WorkflowsResource(this);
+    this.projects = new ProjectsResource(this);
+    this.jobs = new JobsResource(this);
+    this.executions = new ExecutionsResource(this);
+    this.nodes = new NodesResource(this);
+    this.developerApps = new DeveloperAppsResource(this);
+    this.oauth = new OAuthResource(this);
+    this.apps = new AppsResource(this);
+    this.characters = new CharactersResource(this);
+    this.locations = new LocationsResource(this);
+    this.objects = new ObjectsResource(this);
+    this.creatures = new CreaturesResource(this);
+    this.pipelines = new PipelinesResource(this);
+    this.reduce = new ReduceResource(this);
+    this.promptHelper = new PromptHelperResource(this);
+    this.voices = new VoicesResource(this);
+    this.credits = new CreditsResource(this);
+    this.uploads = new UploadsResource(this);
+    this.library = new LibraryResource(this);
+    this.presets = new PresetsResource(this);
+    this.pickerCatalogs = new PickerCatalogsResource(this);
+    this.community = new CommunityResource(this);
+  }
+  async request(method, path, options = {}) {
+    const url = this.buildUrl(path, options.query);
+    const token = await this.auth.getToken();
+    const isFormData = typeof FormData !== "undefined" && options.body instanceof FormData;
+    const headers = {
+      ...isFormData ? {} : { "Content-Type": "application/json" },
+      ...options.headers ?? {}
+    };
+    if (token) headers["Authorization"] = `Bearer ${token}`;
+    const ac = new AbortController();
+    const timeoutId = setTimeout(() => ac.abort(), this.timeoutMs);
+    if (options.signal) {
+      options.signal.addEventListener("abort", () => ac.abort(), { once: true });
+    }
+    try {
+      const res = await this.fetch(url, {
+        method,
+        headers,
+        body: options.body === void 0 ? void 0 : isFormData ? options.body : JSON.stringify(options.body),
+        signal: ac.signal
+      });
+      if (!res.ok) {
+        let errBody = {};
+        try {
+          errBody = await res.json();
+        } catch {
+        }
+        throwFromResponse(res.status, errBody);
+      }
+      if (res.status === 204) return void 0;
+      return await res.json();
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * `GET /v1/me` → the authenticated user's identity (see {@link UserIdentity}).
+   * Unwraps the `{ data }` envelope. Throws `UnauthorizedError` (401) when the
+   * token is missing/invalid, and the SDK's other typed errors as usual.
+   */
+  async me() {
+    const res = await this.request("GET", "/v1/me");
+    return res.data;
+  }
+  buildUrl(path, query) {
+    const base = this.baseUrl || (typeof window !== "undefined" ? window.location.origin : "http://placeholder");
+    const url = new URL(path, base);
+    const fullUrl = this.baseUrl ? url.toString() : url.pathname + url.search;
+    if (query) {
+      const u = new URL(this.baseUrl ? fullUrl : fullUrl, base);
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== void 0) u.searchParams.set(k, String(v));
+      }
+      return this.baseUrl ? u.toString() : u.pathname + u.search;
+    }
+    return fullUrl;
+  }
+};
+function createClient(opts) {
+  return new NodaroClient(opts);
+}
+
+// src/auth.ts
+var StaticTokenAuth = class {
+  constructor(token) {
+    this.token = token;
+  }
+  token;
+  async getToken() {
+    return this.token;
+  }
+};
+var CallbackAuth = class {
+  constructor(fn) {
+    this.fn = fn;
+  }
+  fn;
+  async getToken() {
+    return this.fn();
+  }
+};
+function supabaseAuth(supabase) {
+  return {
+    async getToken() {
+      const { data } = await supabase.auth.getSession();
+      return data.session?.access_token ?? null;
+    }
+  };
+}
+
+Object.defineProperty(exports, "PEOPLE", {
+  enumerable: true,
+  get: function () { return prompts.PEOPLE; }
+});
+Object.defineProperty(exports, "PERSON_DIMENSION_LABELS", {
+  enumerable: true,
+  get: function () { return prompts.PERSON_DIMENSION_LABELS; }
+});
+Object.defineProperty(exports, "PERSON_DIMENSION_ORDER", {
+  enumerable: true,
+  get: function () { return prompts.PERSON_DIMENSION_ORDER; }
+});
+Object.defineProperty(exports, "buildPersonHints", {
+  enumerable: true,
+  get: function () { return prompts.buildPersonHints; }
+});
+Object.defineProperty(exports, "CHARACTER_ASPECT_DEFAULTS", {
+  enumerable: true,
+  get: function () { return shared.CHARACTER_ASPECT_DEFAULTS; }
+});
+Object.defineProperty(exports, "CHARACTER_ASPECT_OPTIONS", {
+  enumerable: true,
+  get: function () { return shared.CHARACTER_ASPECT_OPTIONS; }
+});
+Object.defineProperty(exports, "CHARACTER_STYLES", {
+  enumerable: true,
+  get: function () { return shared.CHARACTER_STYLES; }
+});
+Object.defineProperty(exports, "CREATURE_ASPECT_DEFAULTS", {
+  enumerable: true,
+  get: function () { return shared.OBJECT_ASPECT_DEFAULTS; }
+});
+Object.defineProperty(exports, "CREATURE_ASPECT_OPTIONS", {
+  enumerable: true,
+  get: function () { return shared.OBJECT_ASPECT_OPTIONS; }
+});
+Object.defineProperty(exports, "CREATURE_ATTACH_COLUMNS", {
+  enumerable: true,
+  get: function () { return shared.CREATURE_ATTACH_COLUMNS; }
+});
+Object.defineProperty(exports, "LOCATION_ASSET_TYPES", {
+  enumerable: true,
+  get: function () { return shared.LOCATION_ASSET_TYPES; }
+});
+Object.defineProperty(exports, "LOCATION_ATTACH_COLUMNS", {
+  enumerable: true,
+  get: function () { return shared.LOCATION_ATTACH_COLUMNS; }
+});
+Object.defineProperty(exports, "OBJECT_ASPECT_DEFAULTS", {
+  enumerable: true,
+  get: function () { return shared.OBJECT_ASPECT_DEFAULTS; }
+});
+Object.defineProperty(exports, "OBJECT_ASPECT_OPTIONS", {
+  enumerable: true,
+  get: function () { return shared.OBJECT_ASPECT_OPTIONS; }
+});
+Object.defineProperty(exports, "OBJECT_ASSET_TYPES", {
+  enumerable: true,
+  get: function () { return shared.OBJECT_ASSET_TYPES; }
+});
+Object.defineProperty(exports, "OBJECT_ATTACH_COLUMNS", {
+  enumerable: true,
+  get: function () { return shared.OBJECT_ATTACH_COLUMNS; }
+});
+Object.defineProperty(exports, "SURROUND_DIRECTIONS", {
+  enumerable: true,
+  get: function () { return shared.SURROUND_DIRECTIONS; }
+});
+exports.AppsResource = AppsResource;
+exports.CREATURE_ASSET_TYPES = CREATURE_ASSET_TYPES;
+exports.CallbackAuth = CallbackAuth;
+exports.CharactersResource = CharactersResource;
+exports.CommunityResource = CommunityResource;
+exports.CreaturesResource = CreaturesResource;
+exports.CreditsResource = CreditsResource;
+exports.DeveloperAppsResource = DeveloperAppsResource;
+exports.ExecutionsResource = ExecutionsResource;
+exports.ForbiddenError = ForbiddenError;
+exports.InsufficientCreditsError = InsufficientCreditsError;
+exports.JobAbortedError = JobAbortedError;
+exports.JobFailedError = JobFailedError;
+exports.JobTimeoutError = JobTimeoutError;
+exports.JobsResource = JobsResource;
+exports.LibraryResource = LibraryResource;
+exports.LocationsResource = LocationsResource;
+exports.NodaroClient = NodaroClient;
+exports.NodaroError = NodaroError;
+exports.NodesResource = NodesResource;
+exports.NotFoundError = NotFoundError;
+exports.OAuthResource = OAuthResource;
+exports.ObjectsResource = ObjectsResource;
+exports.PickerCatalogsResource = PickerCatalogsResource;
+exports.PipelinesResource = PipelinesResource;
+exports.PresetsResource = PresetsResource;
+exports.ProjectsResource = ProjectsResource;
+exports.PromptHelperResource = PromptHelperResource;
+exports.RateLimitedError = RateLimitedError;
+exports.ReduceResource = ReduceResource;
+exports.StaticTokenAuth = StaticTokenAuth;
+exports.StorageExceededError = StorageExceededError;
+exports.UnauthorizedError = UnauthorizedError;
+exports.UploadsResource = UploadsResource;
+exports.VoicesResource = VoicesResource;
+exports.WorkflowsResource = WorkflowsResource;
+exports.buildPersonSeedPrompt = buildPersonSeedPrompt;
+exports.createClient = createClient;
+exports.supabaseAuth = supabaseAuth;
+exports.throwFromResponse = throwFromResponse;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map