@oeave/bakery3 0.0.0-stage → 0.2.0

package/dist/chunk-NXBAZGNB.js

@@ -0,0 +1,1107 @@
+import { SDK_VERSION } from './chunk-UWBP7B54.js';
+import { Bakery3Error, RenderBudgetExceeded, BatchPageRefused } from './chunk-3G5QL4F4.js';
+
+// src/warn.ts
+var warned = /* @__PURE__ */ new Set();
+var BROWSER_TOKEN_PREFIX = "bk_pt_";
+function isBrowserLike(scope = globalThis) {
+  const global = scope;
+  if (typeof global.window === "object" && global.window !== null) {
+    if (global.window.document !== void 0) return true;
+  }
+  if (typeof global.importScripts === "function") return true;
+  if (global.navigator?.product === "ReactNative") return true;
+  return false;
+}
+function isProductionBuild(scope = globalThis) {
+  const env = scope.process?.env;
+  return env?.NODE_ENV === "production";
+}
+function redact(key) {
+  const prefix = /^bk_[a-z]{2}_/.exec(key)?.[0] ?? "";
+  const secret = key.slice(prefix.length);
+  return secret.length < 16 ? `${prefix}\u2026` : `${key.slice(0, 12)}\u2026`;
+}
+function warnIfKeyIsExposed(key, { source, scope = globalThis, log }) {
+  if (!key || key.startsWith(BROWSER_TOKEN_PREFIX)) return false;
+  if (!isBrowserLike(scope)) return false;
+  if (warned.has(key)) return false;
+  warned.add(key);
+  const warn = log ?? (typeof console !== "undefined" && typeof console.warn === "function" ? (message2) => console.warn(message2) : () => {
+  });
+  warn(message(key, source, isProductionBuild(scope)));
+  return true;
+}
+function message(key, source, production) {
+  const lines = [
+    production ? `[bakery3] A secret API key is in a PRODUCTION browser bundle: ${redact(key)}` : `[bakery3] Your secret API key is in browser JavaScript: ${redact(key)}`,
+    "",
+    "Anyone who opens the network tab on this page can read it, and a bk_sk_ key",
+    "can start renders, read every render on the account, and reach billing. It",
+    "cannot be origin-restricted, spend-capped or revoked without replacing it.",
+    "",
+    production ? "This build has NODE_ENV=production. Do not ship it. Mint a browser token" : "Fine while you are testing. Before you deploy, mint a browser token",
+    "on your own server instead:",
+    "",
+    "    // app/api/bakery3-token/route.ts (server only)",
+    "    import { Bakery3Server } from '@oeave/bakery3/node';",
+    "    const bakery3 = new Bakery3Server(process.env.BAKERY3_SECRET_KEY!);",
+    "    export const POST = async () =>",
+    "      Response.json(await bakery3.tokens.create({",
+    "        expiresInSeconds: 300, maxCost: 1,",
+    "        allowedOrigins: ['https://shop.example.com'],",
+    "      }));",
+    ""
+  ];
+  if (source === "apiKey") {
+    lines.push(
+      "    // browser: token instead of apiKey",
+      "    createBakery3({",
+      "      token: () => fetch('/api/bakery3-token', { method: 'POST' }).then((r) => r.json()),",
+      "    });",
+      ""
+    );
+  } else {
+    lines.push(
+      "@oeave/bakery3/node is a server module. Importing it into a component that",
+      "runs in the browser puts the key in the bundle. Keep it behind a route",
+      "handler, a server action, or a file with 'use server'.",
+      ""
+    );
+  }
+  lines.push("https://bakery3.com/docs/auth");
+  return lines.join("\n");
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.bakery3.com";
+var SDK_VERSION_HEADER = "bakery3-sdk";
+var VERSION_HEADER_IN_BROWSERS = true;
+var DEFAULT_RETRY = {
+  maxTries: 5,
+  baseDelayMs: 500,
+  maxDelayMs: 3e4
+};
+var CHARGING_ROUTES = /* @__PURE__ */ new Set(["/v1/renders", "/v1/bakes"]);
+var MAX_OWNERS = 1e3;
+var AUTH_DOCS = "https://bakery3.com/docs/auth";
+var TOKEN_ROUTE_DOCS = "https://bakery3.com/docs/auth#the-token-endpoint";
+var KEYS_URL = "https://bakery3.com/keys";
+var Bakery3Client = class {
+  baseUrl;
+  auth;
+  /**
+   * The fetch this client sends with: the one passed in `options.fetch`, or
+   * the global. Uploads and bundle reads use it too, so a test, a proxy or a
+   * runtime with its own fetch sees every request the SDK makes.
+   */
+  fetch;
+  /** Cached until it expires. Re-minting per render would add a round trip to
+   *  the developer's own server on the critical path of every click. */
+  cached = null;
+  /** One token fetch at a time. React's StrictMode mounts twice, and two
+   *  renders at once both find the cache empty: they share this one. */
+  minting = null;
+  /**
+   * The browser token each render, bake and batch was created with, by id.
+   *
+   * A token can only read the rows it created. Once it has spent its
+   * allowance or expired, the API still lets it read and cancel those rows
+   * (for 24 hours past expiry) but not create more, and a freshly minted
+   * token cannot read them at all. So a job polls with the token that
+   * started it, whatever the local cache thinks of that token's expiry.
+   */
+  owners = /* @__PURE__ */ new Map();
+  retry;
+  sendVersion;
+  constructor(options = {}) {
+    const given = options ?? {};
+    const { token, apiKey } = given;
+    if (token && apiKey) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: "Pass either token or apiKey, not both.",
+        why: "They are two different integrations, and the SDK will not guess which one you meant.",
+        fix: "Keep `token` for anything you deploy; `apiKey` is for local testing only.",
+        docs: AUTH_DOCS
+      });
+    }
+    this.auth = authOf(token, apiKey, "apiKey" in given);
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.retry = { ...DEFAULT_RETRY, ...options.retry };
+    this.sendVersion = VERSION_HEADER_IN_BROWSERS;
+    if (this.auth.kind === "key")
+      warnIfKeyIsExposed(this.auth.key, { source: "apiKey" });
+  }
+  /**
+   * Why this client cannot make a request, or null when it can. The same
+   * error its first request would throw, for a panel or a status line that
+   * wants to say so before anyone presses Render.
+   */
+  credentialError() {
+    return this.auth.kind === "missing" ? this.auth.refusal() : null;
+  }
+  async token(force = false) {
+    const auth = this.auth;
+    if (auth.kind === "key") return auth.key;
+    if (auth.kind === "missing") throw auth.refusal();
+    if (!force && this.cached && this.cached.expiresAt - 1e4 > Date.now()) {
+      return this.cached.token;
+    }
+    this.minting ??= this.mint(auth.provider).finally(() => {
+      this.minting = null;
+    });
+    return this.minting;
+  }
+  async mint(provider) {
+    let result;
+    try {
+      result = await provider();
+    } catch (cause) {
+      throw providerThrew(cause);
+    }
+    const { token, expiresAt } = readMinted(result);
+    this.cached = {
+      token,
+      expiresAt: expiresAt ?? // Unknown expiry: hold it for a minute rather than for the session,
+      // so a stale one self-heals without a failed render to prompt it.
+      Date.now() + 6e4
+    };
+    return token;
+  }
+  async checkAssets(body) {
+    return this.post("/v1/assets/check", body);
+  }
+  /**
+   * `POST /v1/assets/import`: have the service fetch a public URL into the
+   * project's assets. Secret key only. Safe to repeat: the same bytes are the
+   * same asset, and an unchanged URL is answered without a download.
+   */
+  async importAsset(body) {
+    return this.post("/v1/assets/import", body);
+  }
+  async estimate(body) {
+    return this.post("/v1/estimate", body);
+  }
+  async createRender(body) {
+    const { value, credential } = await this.call(
+      "POST",
+      "/v1/renders",
+      body,
+      { retry: Boolean(body.idempotencyKey) }
+    );
+    this.remember("render", value.id, credential);
+    return value;
+  }
+  /**
+   * A render's record, with fresh signed URLs for its result and preview.
+   * Read with the token that created it, when this client created it.
+   */
+  async getRender(id, options = {}) {
+    return this.read("GET", `/v1/renders/${segment(id)}`, {
+      owner: `render:${id}`,
+      signal: options.signal
+    });
+  }
+  async cancelRender(id) {
+    return this.read(
+      "POST",
+      `/v1/renders/${segment(id)}/cancel`,
+      { owner: `render:${id}` },
+      {}
+    );
+  }
+  /**
+   * `POST /v1/renders/:id/retry`: one more attempt for a dead-lettered render.
+   * Answers 201 with a new render linked to the old one, or 409 when the
+   * render is not dead-lettered. Not repeated on a 429/503: it creates a
+   * render, and a duplicate would be a duplicate charge.
+   */
+  async retryRender(id) {
+    const { value, credential } = await this.call(
+      "POST",
+      `/v1/renders/${segment(id)}/retry`,
+      {},
+      { retry: false, owner: `render:${id}` }
+    );
+    this.remember("render", value.id, credential);
+    return value;
+  }
+  async createBake(body) {
+    const { value, credential } = await this.call(
+      "POST",
+      "/v1/bakes",
+      body,
+      { retry: Boolean(body.idempotencyKey) }
+    );
+    this.remember("bake", value.id, credential);
+    return value;
+  }
+  async getBake(id, options = {}) {
+    return this.read("GET", `/v1/bakes/${segment(id)}`, {
+      owner: `bake:${id}`,
+      signal: options.signal
+    });
+  }
+  async cancelBake(id) {
+    return this.read(
+      "POST",
+      `/v1/bakes/${segment(id)}/cancel`,
+      { owner: `bake:${id}` },
+      {}
+    );
+  }
+  // -------------------------------------------------------------------------
+  // Batches
+  // -------------------------------------------------------------------------
+  /** `POST /v1/batches`. The key is the idempotency key: the same key
+   *  re-opens the same batch (200) while it is not terminal. */
+  async openBatch(body) {
+    const { value, credential } = await this.call(
+      "POST",
+      "/v1/batches",
+      body,
+      {}
+    );
+    this.remember("batch", value.id, credential);
+    return value;
+  }
+  /**
+   * `GET /v1/batches/:id`. With `wait`, long-polls for up to that many
+   * seconds (at most 25) until the counts change: the one poll a batch needs.
+   */
+  async getBatch(id, options = {}) {
+    const wait = options.wait === void 0 ? void 0 : Math.min(25, Math.max(0, options.wait));
+    const suffix = wait ? `?wait=${wait}` : "";
+    return this.read(
+      "GET",
+      `/v1/batches/${segment(id)}${suffix}`,
+      {
+        owner: `batch:${id}`,
+        signal: options.signal
+      }
+    );
+  }
+  /**
+   * `POST /v1/batches/:id/items`: one page, at most `BATCH_PAGE_SIZE`.
+   *
+   * Every item carries its own key, so the page is safe to send twice: the
+   * second copy adopts what the first admitted. A refusal of the whole page
+   * (402 InsufficientBalance / BatchBudgetExceeded, 409 BatchClosed) throws;
+   * a problem with one item comes back inside `items[i].error` with a 200.
+   */
+  async addBatchItems(id, body) {
+    return this.read(
+      "POST",
+      `/v1/batches/${segment(id)}/items`,
+      { owner: `batch:${id}` },
+      body
+    );
+  }
+  /** `GET /v1/batches/:id/items?state=&cursor=&limit=`. */
+  async listBatchItems(id, options = {}) {
+    const query = new URLSearchParams();
+    if (options.state) query.set("state", options.state);
+    if (options.cursor) query.set("cursor", options.cursor);
+    if (options.limit) query.set("limit", String(options.limit));
+    const suffix = query.toString() ? `?${query}` : "";
+    return this.read(
+      "GET",
+      `/v1/batches/${segment(id)}/items${suffix}`,
+      { owner: `batch:${id}` }
+    );
+  }
+  /**
+   * `GET /v1/batches/:id/export`: the ledger as NDJSON, one line per item,
+   * yielded as it streams so a ten-thousand-item batch is never one string.
+   */
+  async *exportBatch(id) {
+    const { response } = await this.send(
+      "GET",
+      `/v1/batches/${segment(id)}/export`,
+      void 0,
+      { retry: true, owner: `batch:${id}` }
+    );
+    yield* ndjson(response);
+  }
+  /** `POST /v1/batches/:id/{close,pause,resume,cancel,retry}`. Every one is a
+   *  state transition the control plane treats idempotently, so all repeat. */
+  async batchAction(id, action) {
+    return this.read(
+      "POST",
+      `/v1/batches/${segment(id)}/${action}`,
+      { owner: `batch:${id}` },
+      {}
+    );
+  }
+  post(path, body, options) {
+    return this.request("POST", path, body, options);
+  }
+  /** A request about a row this client may have created, with its token. */
+  async read(method, path, options, body) {
+    return (await this.call(method, path, body, options)).value;
+  }
+  /** Remember which token created a row, so the row is read with it. */
+  remember(kind, id, credential) {
+    if (this.auth.kind !== "token" || !id) return;
+    const owner = `${kind}:${id}`;
+    this.owners.delete(owner);
+    this.owners.set(owner, credential);
+    if (this.owners.size > MAX_OWNERS) {
+      const oldest = this.owners.keys().next().value;
+      if (oldest !== void 0) this.owners.delete(oldest);
+    }
+  }
+  /**
+   * One authenticated JSON request, with the 401 re-mint and the 429/503
+   * backoff. Public for the server SDK, which shares the transport; the
+   * typed methods above are the API.
+   */
+  async request(method, path, body, options = {}) {
+    return (await this.call(method, path, body, options)).value;
+  }
+  /** A JSON request, and the credential that got the answer. */
+  async call(method, path, body, options) {
+    const { response, credential, url } = await this.send(
+      method,
+      path,
+      body,
+      options
+    );
+    if (response.status === 204) return { value: void 0, credential };
+    const text = await response.text();
+    if (!text.trim()) return { value: void 0, credential };
+    try {
+      return { value: JSON.parse(text), credential };
+    } catch {
+      throw notOurs(response.status, url, void 0, text, this.baseUrl);
+    }
+  }
+  async send(method, path, body, options) {
+    const retry = options.retry ?? isSafeToRepeat(method, path);
+    const maxTries = retry ? this.retry.maxTries : 1;
+    const url = `${this.baseUrl}${path}`;
+    const pinned = options.owner ? this.owners.get(options.owner) : void 0;
+    let credential = pinned ?? await this.token();
+    let reminted = false;
+    let leftPin = false;
+    for (let attempt = 1; ; attempt++) {
+      const response = await this.fetchOnce(
+        method,
+        url,
+        body,
+        credential,
+        options.signal
+      );
+      if (response.ok) {
+        if (leftPin && options.owner) {
+          const [kind, ...rest] = options.owner.split(":");
+          this.remember(kind, rest.join(":"), credential);
+        }
+        return { response, credential, url };
+      }
+      if (response.status === 401 && !reminted && this.auth.kind === "token") {
+        await response.body?.cancel().catch(() => {
+        });
+        reminted = true;
+        leftPin = pinned !== void 0;
+        credential = await this.token(
+          !pinned || this.cached?.token === credential
+        );
+        continue;
+      }
+      if (leftPin && response.status === 404 && options.owner) {
+        await response.body?.cancel().catch(() => {
+        });
+        throw lostOwner(options.owner);
+      }
+      if (response.status === 401 && this.auth.kind === "key" && this.auth.key.startsWith("bk_pt_")) {
+        await response.body?.cancel().catch(() => {
+        });
+        throw browserTokenAsKey();
+      }
+      if ((response.status === 429 || response.status === 503) && attempt < maxTries) {
+        await response.body?.cancel().catch(() => {
+        });
+        await sleep(
+          this.delayFor(attempt, response.headers.get("retry-after")),
+          options.signal
+        );
+        continue;
+      }
+      throw await toError(response, url, path, this.baseUrl);
+    }
+  }
+  async fetchOnce(method, url, body, credential, signal) {
+    try {
+      return await this.fetch(url, {
+        method,
+        headers: {
+          authorization: `Bearer ${credential}`,
+          ...this.sendVersion ? { [SDK_VERSION_HEADER]: SDK_VERSION } : {},
+          ...body === void 0 ? {} : { "content-type": "application/json" }
+        },
+        ...body === void 0 ? {} : { body: JSON.stringify(body) },
+        ...signal ? { signal } : {}
+      });
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      throw new Bakery3Error({
+        code: "NetworkError",
+        message: `Could not reach the Bakery3 API: ${error instanceof Error ? error.message : String(error)}`,
+        fix: "Check the browser network tab. If you set a custom baseUrl, confirm it allows your origin.",
+        retryable: true
+      });
+    }
+  }
+  /**
+   * Exponential with full jitter, or the server's own `Retry-After` when it
+   * sent one: a server that says "in 3 s" knows more than a formula does.
+   * Both are capped, so a header naming next Tuesday does not hang a page.
+   */
+  delayFor(attempt, retryAfter) {
+    const { baseDelayMs, maxDelayMs } = this.retry;
+    const advised = parseRetryAfter(retryAfter);
+    if (advised !== null) return Math.min(maxDelayMs, advised);
+    const ceiling = Math.min(maxDelayMs, baseDelayMs * 2 ** (attempt - 1));
+    return Math.random() * ceiling;
+  }
+};
+function segment(id) {
+  return encodeURIComponent(id);
+}
+function authOf(token, apiKey, keyNamed) {
+  if (token !== void 0 && token !== null) {
+    if (typeof token === "function")
+      return { kind: "token", provider: token };
+    return { kind: "missing", refusal: tokenNotAFunction };
+  }
+  if (typeof apiKey === "string" && apiKey.trim()) {
+    const key = apiKey.trim();
+    if (isPlaceholder(key))
+      return { kind: "missing", refusal: () => placeholderKey(key) };
+    return { kind: "key", key };
+  }
+  if (keyNamed || apiKey !== void 0)
+    return { kind: "missing", refusal: emptyKey };
+  return { kind: "missing", refusal: noCredentials };
+}
+function isPlaceholder(key) {
+  return key.includes("...") || key.includes("\u2026");
+}
+function noCredentials() {
+  return new Bakery3Error({
+    code: "Unauthorized",
+    message: `No API key or token. Create a key at ${KEYS_URL} (sign up there first if you have no account).`,
+    why: "`apiKey` is a secret key (bk_sk_) you pass directly, for testing and for servers. `token` is a function that fetches a short-lived browser token from your own server, which is what you deploy, because it keeps the key out of the page.",
+    fix: "While testing: createBakery3({ apiKey: 'bk_sk_...' }). Before you deploy: createBakery3({ token: getToken }).",
+    docs: AUTH_DOCS
+  });
+}
+function emptyKey() {
+  return new Bakery3Error({
+    code: "Unauthorized",
+    message: "apiKey is empty. Check that the environment variable holding your key is set.",
+    why: "createBakery3({ apiKey }) was given undefined or an empty string, which is what an environment variable that is not set reads as. In a browser bundle, only variables with your framework's public prefix (NEXT_PUBLIC_, VITE_) are set.",
+    fix: `Set the variable and restart the dev server. You can copy a key from ${KEYS_URL}.`,
+    docs: AUTH_DOCS
+  });
+}
+function placeholderKey(key) {
+  return new Bakery3Error({
+    code: "Unauthorized",
+    message: `Replace the placeholder with your key from ${KEYS_URL}.`,
+    why: `apiKey is ${redact(key)}, which looks like the example from the docs rather than a real key.`,
+    fix: `Copy a secret key (bk_sk_) from ${KEYS_URL} into apiKey while testing, and switch to token before you deploy.`,
+    docs: AUTH_DOCS
+  });
+}
+function tokenNotAFunction() {
+  return new Bakery3Error({
+    code: "Unauthorized",
+    message: "token must be a function that fetches a browser token, not the token itself.",
+    why: "Browser tokens expire after minutes, so the SDK calls your function again for a new one when it needs to.",
+    fix: "createBakery3({ token: () => fetch('/api/bakery3-token', { method: 'POST' }).then((r) => r.json()) })",
+    docs: TOKEN_ROUTE_DOCS
+  });
+}
+function browserTokenAsKey() {
+  return new Bakery3Error({
+    code: "TokenExpired",
+    message: "apiKey holds a browser token (bk_pt_), and the API refused it. It has most likely expired.",
+    why: "Browser tokens last minutes. Passed as apiKey, the SDK has no way to fetch a new one when it runs out.",
+    fix: "Pass it as token instead, as a function that fetches a fresh one: createBakery3({ token: () => fetch('/api/bakery3-token', { method: 'POST' }).then((r) => r.json()) }).",
+    docs: TOKEN_ROUTE_DOCS
+  });
+}
+function lostOwner(owner) {
+  const kind = owner.slice(0, owner.indexOf(":"));
+  const started = kind === "batch" ? "opened" : "started";
+  return new Bakery3Error({
+    code: "TokenExpired",
+    message: `This ${kind} was ${started} with a browser token that can no longer read it. Mint tokens with a longer expiresInSeconds, or read the ${kind} from your server with the secret key.`,
+    why: `A browser token can only read the ${kind}s it ${started}. That token was refused, and a new token cannot read a ${kind} it did not start.`,
+    fix: "Pass a longer expiresInSeconds to tokens.create() on your server, or read it there with new Bakery3Server(process.env.BAKERY3_SECRET_KEY!).",
+    docs: AUTH_DOCS
+  });
+}
+function providerThrew(cause) {
+  const said = cause instanceof Error ? cause.message : String(cause);
+  if (cause instanceof SyntaxError || cause?.name === "SyntaxError") {
+    return new Bakery3Error({
+      code: "Unauthorized",
+      message: "Your token endpoint did not return JSON. It probably answered 404 or 500 with an HTML page.",
+      why: `Reading its answer as JSON failed: ${said}`,
+      fix: "Open your token route in the network tab. It must answer 200 with the JSON from tokens.create(). On a 500, check your server log: BAKERY3_SECRET_KEY may be unset.",
+      docs: TOKEN_ROUTE_DOCS
+    });
+  }
+  return new Bakery3Error({
+    code: "Unauthorized",
+    message: `The token provider threw: ${said}`,
+    why: "createBakery3({ token }) calls your function for a browser token before each request that needs one, and it rejected.",
+    fix: "Check your /api/bakery3-token route in the network tab: it should answer 200 with the JSON from tokens.create().",
+    docs: TOKEN_ROUTE_DOCS,
+    retryable: true
+  });
+}
+function readMinted(result) {
+  if (isFetchResponse(result)) {
+    const status = result.ok ? "" : ` (it answered ${result.status})`;
+    throw new Bakery3Error({
+      code: "Unauthorized",
+      message: `Your token function returned a fetch Response, not the token${status}. Add .then((r) => r.json()).`,
+      why: "createBakery3({ token }) needs the token itself: a string, or the JSON from tokens.create().",
+      fix: "token: () => fetch('/api/bakery3-token', { method: 'POST' }).then((r) => r.json())",
+      docs: TOKEN_ROUTE_DOCS
+    });
+  }
+  if (typeof result === "string" && result) return { token: result };
+  if (isRecord(result) && typeof result.token === "string" && result.token) {
+    return {
+      token: result.token,
+      ...typeof result.expiresAt === "number" && result.expiresAt > 0 ? { expiresAt: result.expiresAt } : {}
+    };
+  }
+  const reported = isRecord(result) ? errorText(result) : void 0;
+  if (reported) {
+    throw new Bakery3Error({
+      code: "Unauthorized",
+      message: `Your token endpoint answered with an error instead of a token: ${reported}`,
+      why: "createBakery3({ token }) needs { token } from your route, and the JSON it got has an error in its place.",
+      fix: "Check your server log for the request to your token route. BAKERY3_SECRET_KEY may be unset or wrong.",
+      docs: TOKEN_ROUTE_DOCS
+    });
+  }
+  throw new Bakery3Error({
+    code: "Unauthorized",
+    message: "The token provider returned nothing.",
+    why: "createBakery3({ token }) must resolve to a string, or to { token }.",
+    fix: "Check that your /api/bakery3-token route returns the JSON from tokens.create().",
+    docs: TOKEN_ROUTE_DOCS
+  });
+}
+function isFetchResponse(value) {
+  if (typeof Response !== "undefined" && value instanceof Response) return true;
+  return isRecord(value) && typeof value.json === "function" && typeof value.status === "number" && "headers" in value;
+}
+function errorText(body) {
+  const error = body.error;
+  if (typeof error === "string" && error) return error;
+  if (isRecord(error)) {
+    const message2 = typeof error.message === "string" ? error.message : "";
+    const code = typeof error.code === "string" ? error.code : "";
+    if (message2 || code)
+      return code && message2 ? `${code}: ${message2}` : message2 || code;
+    return snippet(JSON.stringify(error));
+  }
+  if (typeof body.message === "string" && body.message) return body.message;
+  return void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isSafeToRepeat(method, path) {
+  if (method === "GET" || method === "HEAD") return true;
+  return !CHARGING_ROUTES.has(path.split("?")[0]);
+}
+function parseRetryAfter(header, now = Date.now()) {
+  if (!header) return null;
+  const trimmed = header.trim();
+  if (/^\d+$/.test(trimmed)) return Number(trimmed) * 1e3;
+  const date = Date.parse(trimmed);
+  if (Number.isNaN(date)) return null;
+  return Math.max(0, date - now);
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(signal.reason);
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      reject(signal.reason);
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function* ndjson(response) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const emit = function* (chunk, flush = false) {
+    buffer += chunk;
+    const lines = buffer.split("\n");
+    buffer = flush ? "" : lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed) yield JSON.parse(trimmed);
+    }
+  };
+  if (!response.body) {
+    yield* emit(await response.text(), true);
+    return;
+  }
+  const reader = response.body.getReader();
+  for (; ; ) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    yield* emit(decoder.decode(value, { stream: true }));
+  }
+  yield* emit(decoder.decode(), true);
+}
+async function toError(response, url, path, baseUrl) {
+  const text = await response.text().catch(() => "");
+  let payload;
+  try {
+    payload = text ? JSON.parse(text) : void 0;
+  } catch {
+    payload = void 0;
+  }
+  const error = isRecord(payload) ? isRecord(payload.error) ? payload.error : payload : void 0;
+  if (!error || typeof error.code !== "string" || !error.code) {
+    return notOurs(response.status, url, error, text, baseUrl);
+  }
+  const str = (value) => typeof value === "string" && value ? value : void 0;
+  const num = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+  const message2 = str(error.message) ?? `${response.status} ${response.statusText}`.trim();
+  if (error.code === "RenderBudgetExceeded") {
+    return new RenderBudgetExceeded({
+      message: message2,
+      why: str(error.why),
+      fix: str(error.fix),
+      docs: str(error.docs),
+      maxCost: num(error.maxCost),
+      estimatedCost: num(error.estimatedCost),
+      maximumCost: num(error.maximumCost),
+      kind: budgetedKind(error.kind, path)
+    });
+  }
+  return new Bakery3Error({
+    code: error.code,
+    message: message2,
+    why: str(error.why),
+    fix: str(error.fix),
+    docs: str(error.docs),
+    path: str(error.path),
+    retryable: response.status >= 500 || response.status === 429
+  });
+}
+function budgetedKind(kind, path) {
+  if (kind === "render" || kind === "video" || kind === "bake") return kind;
+  return path.startsWith("/v1/bakes") ? "bake" : "render";
+}
+function notOurs(status, url, body, text, baseUrl) {
+  const where = `${status} from ${url.split("?")[0]}`;
+  const said = body && errorText(body) || snippet(text);
+  const answered = said ? ` It answered: ${said}` : "";
+  if (status >= 500) {
+    return new Bakery3Error({
+      code: "NetworkError",
+      message: `${where}: the server failed before the Bakery3 API could answer.`,
+      why: `The answer has no Bakery3 error in it, so a gateway or proxy in between answered.${answered}`,
+      fix: `Try again in a moment. If it keeps happening, check that baseUrl (${baseUrl}) points at the Bakery3 API.`,
+      retryable: true
+    });
+  }
+  return new Bakery3Error({
+    code: status === 401 || status === 403 ? "Unauthorized" : status === 429 ? "RateLimited" : "InvalidRequest",
+    message: `${where}: not the Bakery3 API. Check baseUrl.`,
+    why: `The answer has no Bakery3 error in it, so another server answered: a wrong baseUrl, a proxy, or a page of your own app.${answered}`,
+    fix: `Leave baseUrl out to use ${DEFAULT_BASE_URL}, or point it at a proxy that forwards /v1/ requests unchanged.`,
+    retryable: status === 429
+  });
+}
+function snippet(text) {
+  const flat = text.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+  return flat.length > 160 ? `${flat.slice(0, 160)}\u2026` : flat;
+}
+
+// src/protocol/batch.ts
+var BATCH_PAGE_SIZE = 100;
+var BATCH_PAGE_BYTES = 4 * 1024 * 1024;
+var BATCH_ITEM_BYTES = 900 * 1024;
+
+// src/pollFailures.ts
+var POLL_GIVE_UP_MS = 5 * 6e4;
+var PollFailures = class {
+  constructor(now = Date.now) {
+    this.now = now;
+  }
+  now;
+  since = null;
+  /** A poll got through: whatever was failing has cleared. */
+  succeeded() {
+    this.since = null;
+  }
+  /** A poll failed. True once they have all been failing for the whole window. */
+  exhausted() {
+    this.since ??= this.now();
+    return this.now() - this.since >= POLL_GIVE_UP_MS;
+  }
+};
+
+// src/batch.ts
+var LONG_POLL_SECONDS = 25;
+var WAIT_RETRY_MS = { first: 1e3, ceiling: 3e4 };
+var LIST_PAGE_SIZE = 100;
+var Batch = class {
+  id;
+  key;
+  latest;
+  /** The flush in flight, or the last one, settled either way. */
+  flushing = Promise.resolve();
+  buffer = [];
+  /** `buffer[i]` as JSON is about `sizes[i]` bytes. Kept beside it so a
+   *  page can be closed on bytes without serializing anything twice. */
+  sizes = [];
+  bytes = 0;
+  client;
+  /** The clock `wait()` measures its patience with. A test turns it. */
+  clock = {
+    now: () => Date.now(),
+    sleep: pause
+  };
+  /** @internal `bakery3.batches.open()` and `.get()` make these. */
+  constructor(client, record) {
+    this.client = client;
+    this.latest = record;
+    this.id = record.id;
+    this.key = record.key;
+  }
+  /** Buffer an item. Nothing is sent until `flush()`. */
+  add(item) {
+    if (!item.key) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: "A batch item needs a key.",
+        why: "The key is what lets a re-run adopt the item instead of rendering it twice, and what a failed item is reported under.",
+        fix: "Use something stable that names the picture: `${sku}/${finish}/${camera}`.",
+        docs: "https://bakery3.com/docs/api"
+      });
+    }
+    const size = jsonBytes(item);
+    if (size > BATCH_ITEM_BYTES) throw itemTooLarge(item.key, size);
+    this.buffer.push(item);
+    this.sizes.push(size);
+    this.bytes += size;
+    return this;
+  }
+  /**
+   * `add`, and send a page when one is full. Awaiting it is the
+   * backpressure: a loop over a file, a cursor or a generator of any length
+   * holds one page at most.
+   *
+   *     for await (const item of source) await batch.write(item);
+   *     await batch.close();
+   */
+  async write(item) {
+    this.add(item);
+    if (this.buffer.length >= BATCH_PAGE_SIZE || this.bytes >= BATCH_PAGE_BYTES)
+      await this.flush();
+  }
+  /** Items added and not yet sent. */
+  get buffered() {
+    return this.buffer.length;
+  }
+  /** About how many bytes of JSON those items are. */
+  get bufferedBytes() {
+    return this.bytes;
+  }
+  /**
+   * Price items without buffering or admitting them: the estimate, the
+   * maximum and any refusal, per item, in the order given. Paged like a
+   * flush. An item already completed under its key is quoted as adopted, at
+   * nothing, which makes this the price of a re-run too.
+   */
+  async quote(items) {
+    const outcomes = [];
+    const sizes = items.map(jsonBytes);
+    let offset = 0;
+    while (offset < items.length) {
+      const count = pageLength(sizes, offset);
+      const response = await this.client.addBatchItems(this.id, {
+        items: items.slice(offset, offset + count),
+        dryRun: true
+      });
+      outcomes.push(...response.items);
+      offset += count;
+    }
+    return outcomes;
+  }
+  /**
+   * Send the buffer in pages: `BATCH_PAGE_SIZE` items or `BATCH_PAGE_BYTES`
+   * of JSON, whichever a page reaches first.
+   *
+   * Returns one outcome per item sent: admitted, adopted, or refused alone
+   * (`outcome.error`). A page refused whole throws `BatchPageRefused` and
+   * leaves that page and everything behind it in the buffer, so the caller
+   * can top up and call `flush()` again; the error carries the outcomes of
+   * the pages that did get through.
+   */
+  flush(options = {}) {
+    const run = this.flushing.then(() => this.flushNow(options));
+    this.flushing = run.catch(() => {
+    });
+    return run;
+  }
+  async flushNow(options) {
+    const outcomes = [];
+    let offset = 0;
+    while (offset < this.buffer.length) {
+      const page = this.buffer.slice(
+        offset,
+        offset + pageLength(this.sizes, offset)
+      );
+      let response;
+      try {
+        response = await this.client.addBatchItems(this.id, {
+          items: page,
+          ...options.dryRun ? { dryRun: true } : {}
+        });
+      } catch (error) {
+        if (error instanceof Bakery3Error)
+          throw new BatchPageRefused(error, page, outcomes);
+        throw error;
+      }
+      this.latest = response.batch;
+      outcomes.push(...response.items);
+      if (options.dryRun) {
+        offset += page.length;
+      } else {
+        this.buffer.splice(offset, page.length);
+        for (const size of this.sizes.splice(offset, page.length))
+          this.bytes -= size;
+      }
+    }
+    return outcomes;
+  }
+  /** Seal: no more items. `completed` fires once the last one is terminal.
+   *  Anything still buffered is flushed first, because closing over unsent
+   *  items would quietly drop the tail of a catalog. */
+  async close() {
+    if (this.buffer.length) await this.flush();
+    return this.apply(await this.client.batchAction(this.id, "close"));
+  }
+  /** Stop feeding the queue; running items finish. */
+  async pause() {
+    return this.apply(await this.client.batchAction(this.id, "pause"));
+  }
+  async resume() {
+    return this.apply(await this.client.batchAction(this.id, "resume"));
+  }
+  /** Cancel every non-terminal item. What completed stays completed: it rendered. */
+  async cancel() {
+    return this.apply(await this.client.batchAction(this.id, "cancel"));
+  }
+  /** Re-queue every dead-lettered item, one new attempt each. */
+  async retry() {
+    return this.apply(await this.client.batchAction(this.id, "retry"));
+  }
+  /** The latest record this batch has seen. No request. */
+  record() {
+    return this.latest;
+  }
+  /** Fetch the record now. */
+  async refresh() {
+    return this.apply(await this.client.getBatch(this.id));
+  }
+  /** Counts and cost from the latest record. No request. */
+  progress() {
+    return progressOf(this.latest);
+  }
+  /**
+   * Wait for the batch to finish: one long-poll loop on the batch record
+   * until it is `completed` or `cancelled` (or sealed with every item
+   * terminal). Never a poll per render.
+   *
+   * A paused batch is waited on, not given up on (someone may resume it from
+   * the console), and `onProgress` sees `pausedReason` meanwhile. Pass
+   * `signal` to stop waiting; the batch itself is untouched.
+   *
+   * A fault that clears is ridden out. One that does not (five minutes with
+   * not one poll through) rejects with an error that says so and carries the
+   * last fault's code. The batch renders on regardless, and `wait()` can be
+   * called again.
+   */
+  async wait(options = {}) {
+    const { onProgress, signal } = options;
+    const failures = new PollFailures(this.clock.now);
+    let failed = 0;
+    for (; ; ) {
+      if (signal?.aborted) throw signal.reason ?? abortError();
+      if (isFinished(this.latest)) return this.latest;
+      try {
+        this.apply(
+          await this.client.getBatch(this.id, {
+            wait: LONG_POLL_SECONDS,
+            signal
+          })
+        );
+        failed = 0;
+        failures.succeeded();
+      } catch (error) {
+        if (signal?.aborted) throw signal.reason ?? abortError();
+        if (error instanceof Bakery3Error && !error.retryable) throw error;
+        if (failures.exhausted()) throw lostContact(this.id, error);
+        await this.clock.sleep(
+          Math.min(WAIT_RETRY_MS.ceiling, WAIT_RETRY_MS.first * 2 ** failed++),
+          signal
+        );
+        continue;
+      }
+      onProgress?.(this.progress());
+    }
+  }
+  /** Every item, or every item in one state, walked with the cursor. */
+  async *items(options = {}) {
+    let cursor;
+    do {
+      const page = await this.client.listBatchItems(this.id, {
+        ...options.state ? { state: options.state } : {},
+        ...cursor ? { cursor } : {},
+        limit: LIST_PAGE_SIZE
+      });
+      yield* page.items;
+      cursor = page.cursor ?? void 0;
+    } while (cursor);
+  }
+  /** The ledger, line by line, as the server streams it. */
+  export() {
+    return this.client.exportBatch(this.id);
+  }
+  apply(record) {
+    this.latest = record;
+    return record;
+  }
+};
+function progressOf(record) {
+  return {
+    ...record.counts,
+    id: record.id,
+    state: record.state,
+    total: record.total,
+    done: record.done,
+    cost: record.cost,
+    ...record.pausedReason ? { pausedReason: record.pausedReason } : {}
+  };
+}
+function isFinished(record) {
+  if (record.state === "completed" || record.state === "cancelled") return true;
+  return record.state === "sealed" && record.done >= record.total;
+}
+function pageLength(sizes, offset) {
+  let count = 0;
+  let bytes = 0;
+  while (offset + count < sizes.length && count < BATCH_PAGE_SIZE) {
+    bytes += sizes[offset + count];
+    if (count > 0 && bytes > BATCH_PAGE_BYTES) break;
+    count++;
+  }
+  return count;
+}
+function jsonBytes(item) {
+  return JSON.stringify(item).length;
+}
+function itemTooLarge(key, size) {
+  return new Bakery3Error({
+    code: "InvalidRequest",
+    message: `Item "${key}" is ${(size / 1024).toFixed(0)} KB of JSON; an item holds at most ${BATCH_ITEM_BYTES / 1024} KB.`,
+    why: "An item is a manifest: cameras, lights and ids, a few KB. The heavy bytes are assets, uploaded once by hash and named from the manifest.",
+    fix: "Look for something large inline in the spec or its metadata (a data: URL, a geometry, a long array) and ship it as an asset, or leave it out of `metadata`.",
+    path: key,
+    docs: "https://bakery3.com/docs/batches#errors"
+  });
+}
+function lostContact(id, cause) {
+  const last = cause instanceof Error ? cause.message : String(cause);
+  return new Bakery3Error({
+    code: cause instanceof Bakery3Error ? cause.code : "NetworkError",
+    message: `Stopped waiting for batch ${id}: no poll has got through for ${POLL_GIVE_UP_MS / 6e4} minutes. The last error was: ${last}`,
+    why: "The batch keeps rendering on the server whether or not this page can reach it, so wait() rides out a dropped connection. A fault that lasts this long (a token route that is gone, a base URL that stopped resolving) will not clear by itself.",
+    fix: "Fix what the last error names, then call wait() again, or read the set later with getRenderSet(id). Nothing was lost.",
+    docs: "https://bakery3.com/docs/batches#errors",
+    retryable: true
+  });
+}
+function pause(ms, signal) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(done, ms);
+    function done() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    }
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+function abortError() {
+  const error = new Error("The wait was aborted.");
+  error.name = "AbortError";
+  return error;
+}
+
+// src/testRun.ts
+var TEST_DEFAULTS = { products: 3, size: 512, maxCost: 5 };
+function testSettings(run, options = {}, now = Date.now()) {
+  const size = Math.max(64, Math.round(options.size ?? TEST_DEFAULTS.size));
+  const scale = size / Math.max(run.width, run.height);
+  const stamp = now.toString(36);
+  return {
+    key: `${run.key}:test:${stamp}`,
+    version: `test-${stamp}`,
+    quality: "preview",
+    // Even, because an encoder somewhere always wants that.
+    width: Math.max(2, Math.round(run.width * scale / 2) * 2),
+    height: Math.max(2, Math.round(run.height * scale / 2) * 2),
+    maxCost: options.maxCost ?? TEST_DEFAULTS.maxCost,
+    lane: "normal"
+  };
+}
+function quoteKey(runKey) {
+  return `${runKey}:quote`;
+}
+async function* sampleOf(variants, count = TEST_DEFAULTS.products) {
+  const wanted = Math.max(1, Math.floor(count));
+  if (Array.isArray(variants)) {
+    const length = variants.length;
+    if (length <= wanted) return yield* variants;
+    const picked = /* @__PURE__ */ new Set();
+    for (let i = 0; i < wanted; i++)
+      picked.add(Math.round(i * (length - 1) / (wanted - 1 || 1)));
+    for (const index of [...picked].sort((a, b) => a - b))
+      yield variants[index];
+    return;
+  }
+  let taken = 0;
+  for await (const variant of variants) {
+    yield variant;
+    if (++taken >= wanted) return;
+  }
+}
+
+export { Bakery3Client, Batch, PollFailures, quoteKey, sampleOf, testSettings, warnIfKeyIsExposed };
+//# sourceMappingURL=chunk-NXBAZGNB.js.map
+//# sourceMappingURL=chunk-NXBAZGNB.js.map