@oeave/bakery3 0.0.0-stage → 0.1.0

package/dist/chunk-ARMTTZXZ.js

@@ -0,0 +1,1157 @@
+import { record, defaultVariantId } from './chunk-WBIAFIHV.js';
+import { Bakery3Client, Batch, quoteKey, sampleOf, testSettings, PollFailures } from './chunk-25ZXSVQ3.js';
+import { RenderSet } from './chunk-ZEBVAIJJ.js';
+import { captureScene, bindTimelineContext, createTimeline, prepareBake, bakeQuoteOf, quoteBake, analyzeScene, resolveOutput, sceneComplexity, tracedTriangles } from './chunk-CX4WTVGH.js';
+import { SDK_VERSION, protocolVersionFor } from './chunk-APBOWWSV.js';
+import { findPresetRooms } from './chunk-AF5BIELI.js';
+import { shouldExclude, idOf, captureFog } from './chunk-HQTUFVMM.js';
+import { Bakery3Error, RenderBudgetExceeded } from './chunk-3G5QL4F4.js';
+
+// src/protocol/job.ts
+var TERMINAL_STATES = [
+  "completed",
+  "failed",
+  "cancelled",
+  "expired"
+];
+function isTerminal(state) {
+  return TERMINAL_STATES.includes(state);
+}
+
+// src/job.ts
+var POLL_SCHEDULE = [400, 400, 600, 800, 1e3, 1500, 2e3, 3e3];
+var PolledJob = class {
+  id;
+  record;
+  client;
+  subscribers = /* @__PURE__ */ new Map();
+  /** The last payload of each replayed event, for a listener added late. */
+  lastPayloads = /* @__PURE__ */ new Map();
+  pending = null;
+  /** `result()` calls still waiting. */
+  waiting = 0;
+  /** The running poll loop's switch, or null when no loop runs. */
+  poller = null;
+  /** Set once the job has settled, for good: a terminal state or a verdict. */
+  hasEnded = false;
+  constructor(client, record2) {
+    this.client = client;
+    this.record = record2;
+    this.id = record2.id;
+  }
+  get status() {
+    return this.record.state;
+  }
+  get progress() {
+    return this.record.progress;
+  }
+  /**
+   * Listen for an event. Starts polling if nothing has yet.
+   *
+   * A listener added after an event already fired is called with the latest
+   * one, on the next microtask: the latest `preview` and `progress`, and
+   * `complete`, `failed` or `cancelled` once the job has ended. Returns the
+   * unsubscribe function, so a React effect can clean up without a second
+   * API.
+   */
+  on(event, listener) {
+    const set = this.subscribers.get(event) ?? /* @__PURE__ */ new Set();
+    this.subscribers.set(event, set);
+    const entry = {
+      fn: listener,
+      heard: false
+    };
+    set.add(entry);
+    if (this.lastPayloads.has(event)) {
+      queueMicrotask(() => {
+        if (!set.has(entry) || entry.heard) return;
+        entry.heard = true;
+        call(event, entry, this.lastPayloads.get(event));
+      });
+    }
+    this.startPolling();
+    return () => {
+      set.delete(entry);
+    };
+  }
+  /**
+   * The finished output. Starts polling if nothing has yet.
+   *
+   * Several callers may await the same job (a component, a devtools panel,
+   * an analytics hook) and share one polling loop. Rejects with a
+   * `Bakery3Error` when the job fails (after `failed` is emitted), with code
+   * `Cancelled` when it was cancelled, and with an `AbortError` when the wait
+   * was stopped by `stop()` or by `signal`.
+   */
+  result(options = {}) {
+    const outcome = this.pendingOutcome();
+    if (this.hasEnded) return outcome.promise;
+    const { signal } = options;
+    if (signal?.aborted) return Promise.reject(signal.reason);
+    this.waiting++;
+    this.startPolling();
+    return new Promise((resolve, reject) => {
+      let waiting = true;
+      const done = () => {
+        if (!waiting) return false;
+        waiting = false;
+        this.waiting--;
+        signal?.removeEventListener("abort", onAbort);
+        return true;
+      };
+      const onAbort = () => {
+        if (done()) reject(signal.reason);
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      outcome.promise.then(
+        (value) => {
+          if (done()) resolve(value);
+        },
+        (error) => {
+          if (done()) reject(error);
+        }
+      );
+    });
+  }
+  /**
+   * Stop polling, here, now. The job is NOT cancelled on the server: it
+   * keeps running and is still charged, and `getRender(id)` or `getBake(id)`
+   * reads it later. A pending `result()` rejects with an `AbortError`, and a
+   * later `on()` or `result()` starts polling again.
+   *
+   * `cancel()` is the other one: it asks the server to stop the job, which
+   * then ends as `cancelled`.
+   */
+  stop() {
+    this.poller?.abort();
+    this.poller = null;
+    if (this.hasEnded || !this.pending) return;
+    const stopped = this.pending;
+    this.pending = null;
+    stopped.reject(
+      abortError(
+        `Stopped watching ${this.jobNoun} ${this.id}. It still runs on the server.`
+      )
+    );
+  }
+  /** Apply a record read from the API, and settle if it is the last one. */
+  applyRecord(record2) {
+    this.record = record2;
+    this.observeRecord(record2);
+    if (isTerminal(record2.state)) void this.settleEnd();
+  }
+  emitEvent(event, payload) {
+    if (this.replayedEvents.includes(event))
+      this.lastPayloads.set(event, payload);
+    for (const entry of this.subscribers.get(event) ?? []) {
+      entry.heard = true;
+      call(event, entry, payload);
+    }
+  }
+  pendingOutcome() {
+    if (this.pending) return this.pending;
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    promise.catch(() => {
+    });
+    this.pending = { promise, resolve, reject };
+    return this.pending;
+  }
+  isWatched() {
+    if (this.waiting > 0) return true;
+    for (const set of this.subscribers.values()) if (set.size > 0) return true;
+    return false;
+  }
+  startPolling() {
+    if (this.poller || this.hasEnded) return;
+    const loop = new AbortController();
+    this.poller = loop;
+    queueMicrotask(() => void this.pollLoop(loop));
+  }
+  async pollLoop(loop) {
+    const { signal } = loop;
+    const failures = new PollFailures();
+    try {
+      for (let step = 0; ; step++) {
+        if (signal.aborted || this.hasEnded) return;
+        if (isTerminal(this.record.state)) return void await this.settleEnd();
+        if (!this.isWatched()) return;
+        const wait = this.pollSchedule[Math.min(step, this.pollSchedule.length - 1)];
+        if (!await pause(wait, signal)) return;
+        try {
+          const record2 = await this.readRecord(signal);
+          if (signal.aborted) return;
+          this.applyRecord(record2);
+          failures.succeeded();
+        } catch (error) {
+          if (signal.aborted) return;
+          if (error instanceof Bakery3Error && !error.retryable)
+            return this.settleFailure(error);
+          if (failures.exhausted()) return this.settleFailure(error);
+        }
+      }
+    } finally {
+      if (this.poller === loop) this.poller = null;
+    }
+  }
+  /** Settle on the record's terminal state. Once. */
+  async settleEnd() {
+    if (this.hasEnded) return;
+    this.hasEnded = true;
+    this.poller?.abort();
+    this.poller = null;
+    const record2 = this.record;
+    const outcome = this.pendingOutcome();
+    if (record2.state === "cancelled") {
+      this.emitEvent("cancelled", this.recordPayload(record2));
+      outcome.reject(
+        new Bakery3Error({
+          code: "Cancelled",
+          message: `${capitalize(this.jobNoun)} ${this.id} was cancelled.`,
+          retryable: false
+        })
+      );
+      return;
+    }
+    if (record2.state === "completed" && record2.result) {
+      try {
+        outcome.resolve(await this.completeRecord(record2));
+      } catch (error) {
+        this.settleFailure(error);
+      }
+      return;
+    }
+    if (record2.state === "expired")
+      return this.settleFailure(this.expiredError());
+    this.settleFailure(
+      record2.error ? Bakery3Error.from(record2.error) : new Bakery3Error({
+        code: "WorkerFailure",
+        message: `${capitalize(this.jobNoun)} ended in state "${record2.state}" with no result.`,
+        retryable: true
+      })
+    );
+  }
+  /** Emit `failed`, then reject. Every failure goes through here. */
+  settleFailure(cause) {
+    this.hasEnded = true;
+    this.poller?.abort();
+    this.poller = null;
+    const error = cause instanceof Bakery3Error ? cause : new Bakery3Error({
+      code: "NetworkError",
+      message: `Could not read ${this.jobNoun} ${this.id}: ${cause instanceof Error ? cause.message : String(cause)}`,
+      retryable: true
+    });
+    this.emitEvent("failed", {
+      error,
+      ...this.recordPayload(this.record)
+    });
+    this.pendingOutcome().reject(error);
+  }
+  expiredError() {
+    const files = this.jobNoun === "bake" ? "lightmaps" : "image";
+    return new Bakery3Error({
+      code: "Expired",
+      message: `${capitalize(this.jobNoun)} ${this.id} has expired, so its ${files} can no longer be downloaded.`,
+      why: `A ${this.jobNoun} expires when the project's retention ends or someone deletes it. The record stays, with its cost, but the files are gone.`,
+      fix: `${this.jobNoun === "bake" ? "Bake" : "Render"} again. To keep a result, copy its files into your own storage when the ${this.jobNoun} completes.`,
+      docs: "https://bakery3.com/docs/limits#retention",
+      retryable: false
+    });
+  }
+};
+var RenderJob = class extends PolledJob {
+  jobNoun = "render";
+  pollSchedule = POLL_SCHEDULE;
+  replayedEvents = [
+    "preview",
+    "progress",
+    "complete",
+    "failed",
+    "cancelled"
+  ];
+  previewSeen = false;
+  lastState = null;
+  constructor(client, record2) {
+    super(client, record2);
+  }
+  get previewUrl() {
+    return this.record.previewUrl;
+  }
+  /** The estimate this render was accepted under. */
+  get estimate() {
+    return this.record.estimate;
+  }
+  /**
+   * Ask the server to stop the render. It ends as `cancelled`: `cancelled`
+   * is emitted and `result()` rejects with code `Cancelled`. To stop
+   * watching without stopping the render, call `stop()`.
+   */
+  async cancel() {
+    this.applyRecord(await this.client.cancelRender(this.id));
+  }
+  readRecord(signal) {
+    return this.client.getRender(this.id, { signal });
+  }
+  observeRecord(record2) {
+    if (record2.previewUrl && !this.previewSeen) {
+      this.previewSeen = true;
+      this.emitEvent("preview", { url: record2.previewUrl, render: record2 });
+    }
+    if (record2.state !== this.lastState) {
+      this.lastState = record2.state;
+      if (record2.state === "queued")
+        this.emitEvent("queued", { render: record2 });
+      if (record2.state === "preparing")
+        this.emitEvent("preparing", { render: record2 });
+    }
+    this.emitEvent("progress", {
+      percent: Math.round(record2.progress * 100),
+      state: record2.state,
+      render: record2
+    });
+  }
+  async completeRecord(record2) {
+    const result = record2.result;
+    this.emitEvent("complete", { result, render: record2 });
+    return result;
+  }
+  recordPayload(record2) {
+    return { render: record2 };
+  }
+};
+function call(event, entry, payload) {
+  try {
+    entry.fn(payload);
+  } catch (error) {
+    console.error(`[bakery3] listener for "${String(event)}" threw:`, error);
+  }
+}
+function pause(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted) return resolve(false);
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve(true);
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      resolve(false);
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function abortError(message) {
+  if (typeof DOMException === "function")
+    return new DOMException(message, "AbortError");
+  const error = new Error(message);
+  error.name = "AbortError";
+  return error;
+}
+function capitalize(word) {
+  return word.charAt(0).toUpperCase() + word.slice(1);
+}
+
+// src/capture/exported.ts
+var GLB_MAGIC = 1179937895;
+var CHUNK_JSON = 1313821514;
+function exportedObjectIds(glb) {
+  const ids = /* @__PURE__ */ new Set();
+  const view = new DataView(glb);
+  if (view.byteLength < 20 || view.getUint32(0, true) !== GLB_MAGIC) return ids;
+  let offset = 12;
+  while (offset + 8 <= view.byteLength) {
+    const length = view.getUint32(offset, true);
+    const type = view.getUint32(offset + 4, true);
+    const start = offset + 8;
+    if (type === CHUNK_JSON) {
+      const text = new TextDecoder().decode(new Uint8Array(glb, start, length));
+      let document2;
+      try {
+        document2 = JSON.parse(text);
+      } catch {
+        return ids;
+      }
+      for (const node of document2.nodes ?? []) {
+        const id = node.extras?.bakery3Id;
+        if (typeof id === "string" && id) ids.add(id);
+      }
+      return ids;
+    }
+    offset = start + length + (4 - length % 4) % 4;
+  }
+  return ids;
+}
+function addressableIds(manifest, glb) {
+  const ids = exportedObjectIds(glb);
+  for (const light of manifest.lights ?? []) ids.add(light.objectId);
+  return ids;
+}
+function assertAnimationTargets(animation, manifest, glb, names) {
+  const addressable = addressableIds(manifest, glb);
+  if (addressable.size === 0) return;
+  for (const channel of animation.channels) {
+    if (channel.target.type !== "object") continue;
+    const id = channel.target.objectId;
+    if (addressable.has(id)) continue;
+    const name = names?.get(id);
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: `The timeline animates "${channel.property}" on ${name ? `"${name}"` : `an object (${id.slice(0, 8)}\u2026)`}, which did not make it into the exported scene.`,
+      why: "The channel would arrive at the renderer with an id that matches nothing in the GLB, and the render would refuse after the upload rather than here.",
+      fix: `Check that the object is still in the scene and is exportable: it must not be a helper, a gizmo, or marked userData.bakery3.exclude. Otherwise drop the track with timeline.removeTrack().`,
+      docs: "https://bakery3.com/docs/animation"
+    });
+  }
+}
+
+// src/bake/job.ts
+var POLL_SCHEDULE2 = [800, 800, 1e3, 1500, 2e3, 3e3];
+var BakeJob = class extends PolledJob {
+  jobNoun = "bake";
+  pollSchedule = POLL_SCHEDULE2;
+  replayedEvents = [
+    "progress",
+    "complete",
+    "failed",
+    "cancelled"
+  ];
+  fetchImpl;
+  lastState = null;
+  constructor(client, record2, fetchImpl) {
+    super(client, record2);
+    this.fetchImpl = fetchImpl ?? client.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  /** The estimate this bake was accepted under. */
+  get estimate() {
+    return this.record.estimate;
+  }
+  /**
+   * Ask the server to stop the bake. It ends as `cancelled`: `cancelled` is
+   * emitted and `result()` rejects with code `Cancelled`. To stop watching
+   * without stopping the bake, call `stop()`.
+   */
+  async cancel() {
+    this.applyRecord(await this.client.cancelBake(this.id));
+  }
+  readRecord(signal) {
+    return this.client.getBake(this.id, { signal });
+  }
+  observeRecord(record2) {
+    if (record2.state !== this.lastState) {
+      this.lastState = record2.state;
+      if (record2.state === "queued") this.emitEvent("queued", { bake: record2 });
+    }
+    this.emitEvent("progress", {
+      percent: Math.round(record2.progress * 100),
+      state: record2.state,
+      bake: record2
+    });
+  }
+  async completeRecord(record2) {
+    const output = await this.resolve(record2.result);
+    this.emitEvent("complete", { output, bake: record2 });
+    return output;
+  }
+  recordPayload(record2) {
+    return { bake: record2 };
+  }
+  /**
+   * bundle.json from storage, every uri replaced by its signed URL.
+   *
+   * A name the bundle uses that the control plane signed nothing for is a
+   * refusal here, with the name: never a bundle that quietly points at a
+   * texture the browser will 403 on ten seconds later.
+   */
+  async resolve(result) {
+    const response = await this.fetchImpl(result.bundleUrl).catch(
+      (cause) => {
+        throw new Bakery3Error({
+          code: "NetworkError",
+          message: `Could not fetch the bake bundle: ${cause.message}`,
+          retryable: true
+        });
+      }
+    );
+    if (!response.ok) {
+      throw new Bakery3Error({
+        code: "WorkerFailure",
+        message: `The bake bundle could not be read from storage (${response.status}).`,
+        why: "The signed URL was refused. These expire after 24 hours.",
+        fix: "Fetch the bake again with bakery3.getBake(id) for fresh URLs.",
+        docs: "https://bakery3.com/docs/bake",
+        retryable: true
+      });
+    }
+    const bundle = await response.json();
+    const url = (uri, what) => {
+      const signed = result.files[uri];
+      if (!signed) {
+        throw new Bakery3Error({
+          code: "WorkerFailure",
+          message: `The bake bundle names ${what} "${uri}" that storage has no signed URL for.`,
+          why: "The render worker wrote a file the control plane did not sign, or the upload of that file failed.",
+          fix: "Bake again. If it repeats, this is a bug on our side: write to hello@bakery3.com with the bake id.",
+          docs: "https://bakery3.com/docs/bake",
+          retryable: true
+        });
+      }
+      return signed;
+    };
+    const resolved = {
+      ...bundle,
+      objects: bundle.objects.map((object) => ({
+        ...object,
+        lightmap: {
+          ...object.lightmap,
+          uri: url(object.lightmap.uri, "a lightmap")
+        },
+        ...object.preview ? { preview: { uri: url(object.preview.uri, "a preview") } } : {}
+      })),
+      ...bundle.atlas ? {
+        atlas: {
+          ...bundle.atlas,
+          uri: url(bundle.atlas.uri, "the atlas"),
+          ...bundle.atlas.preview ? {
+            preview: {
+              uri: url(bundle.atlas.preview.uri, "the atlas preview")
+            }
+          } : {}
+        }
+      } : {},
+      ...bundle.proxies ? {
+        proxies: bundle.proxies.map(
+          (proxy) => proxy.kind === "billboard" ? {
+            ...proxy,
+            map: {
+              ...proxy.map,
+              uri: url(proxy.map.uri, "a billboard")
+            }
+          } : proxy.kind === "decimated" ? {
+            ...proxy,
+            lightmap: {
+              ...proxy.lightmap,
+              uri: url(
+                proxy.lightmap.uri,
+                "a decimated object's lightmap"
+              )
+            }
+          } : {
+            ...proxy,
+            color: {
+              uri: url(proxy.color.uri, "a stand-in's color map")
+            },
+            normal: {
+              uri: url(proxy.normal.uri, "a stand-in's normal map")
+            },
+            lightmap: {
+              ...proxy.lightmap,
+              uri: url(proxy.lightmap.uri, "a stand-in's lightmap")
+            }
+          }
+        )
+      } : {},
+      ...bundle.shadow ? {
+        shadow: {
+          ...bundle.shadow,
+          uri: url(bundle.shadow.uri, "the shadow plane")
+        }
+      } : {},
+      ...bundle.glb ? { glb: { uri: url(bundle.glb.uri, "the GLB") } } : {},
+      ...bundle.probe ? {
+        probe: {
+          ...bundle.probe,
+          uri: url(bundle.probe.uri, "the reflection probe"),
+          ...bundle.probe.preview ? {
+            preview: {
+              ...bundle.probe.preview,
+              uri: url(bundle.probe.preview.uri, "the probe preview")
+            }
+          } : {}
+        }
+      } : {}
+    };
+    const { summary: _summary, ...rest } = result;
+    return { ...rest, bundle: resolved };
+  }
+};
+
+// src/upload.ts
+var CONCURRENCY = 4;
+var ATTEMPTS = 3;
+async function uploadMissingAssets(client, assets, onProgress) {
+  const check = await client.checkAssets({
+    assets: assets.map(({ data: _data, ...descriptor }) => descriptor)
+  });
+  const fetchImpl = client.fetch ?? globalThis.fetch.bind(globalThis);
+  const targets = new Map(check.uploads.map((upload) => [upload.hash, upload]));
+  const missing = assets.filter((asset) => targets.has(asset.hash));
+  const progress = {
+    cached: assets.length - missing.length,
+    uploaded: 0,
+    bytesUploaded: 0,
+    bytesTotal: missing.reduce((sum, asset) => sum + asset.bytes, 0)
+  };
+  onProgress?.(progress);
+  const queue = [...missing];
+  const workers = Array.from(
+    { length: Math.min(CONCURRENCY, queue.length) },
+    async () => {
+      for (; ; ) {
+        const asset = queue.shift();
+        if (!asset) return;
+        const target = targets.get(asset.hash);
+        await put(asset, target, fetchImpl);
+        progress.uploaded++;
+        progress.bytesUploaded += asset.bytes;
+        onProgress?.({ ...progress });
+      }
+    }
+  );
+  await Promise.all(workers);
+  return progress;
+}
+async function put(asset, target, fetchImpl) {
+  let last = "";
+  for (let attempt = 1; attempt <= ATTEMPTS; attempt++) {
+    try {
+      const response = await fetchImpl(target.url, {
+        method: "PUT",
+        // Verbatim. A presigned PUT is signed over an exact header set, so an
+        // extra or missing header is a 403 that reads like an auth bug.
+        headers: { ...target.headers },
+        body: asset.data
+      });
+      if (response.ok) return;
+      last = `${response.status} ${response.statusText}`;
+      if (response.status < 500 && response.status !== 429) break;
+    } catch (error) {
+      last = error instanceof Error ? error.message : String(error);
+    }
+    if (attempt < ATTEMPTS) {
+      await new Promise((resolve) => setTimeout(resolve, attempt * 500));
+    }
+  }
+  throw new Bakery3Error({
+    code: "AssetUploadIncomplete",
+    message: `Could not upload ${asset.name ?? asset.kind} (${formatBytes(asset.bytes)}): ${last}`,
+    why: "The presigned upload URL was rejected. These expire, and they are signed over an exact set of headers.",
+    fix: "Retry the render. If it keeps failing, check for a service worker or proxy that rewrites request headers.",
+    docs: "https://bakery3.com/docs/uploads",
+    retryable: true
+  });
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+
+// src/index.ts
+function createBakery3(options = {}) {
+  const client = new Bakery3Client(options);
+  const defaults = options.defaults ?? {};
+  const clientFetch = options.fetch;
+  let attached = null;
+  function resolveScene(explicit, method) {
+    const scene = explicit ?? attached?.scene;
+    if (!scene) throw missingContext(method, "scene");
+    return scene;
+  }
+  function resolveCamera(explicit, method) {
+    const camera = explicit ?? attached?.camera;
+    if (!camera) throw missingContext(method, "camera");
+    return camera;
+  }
+  let warnedRenderer = false;
+  function rendererFor(explicit) {
+    const renderer = explicit ?? attached?.renderer;
+    if (!renderer && !warnedRenderer && inBrowser()) {
+      warnedRenderer = true;
+      console.warn(
+        "Bakery3: no renderer was given, so this render uses no tone mapping and an exposure of 1, and can look darker or flatter than your viewport. Pass renderer to render(), or call bakery3.attach({ scene, camera, renderer }) once. https://bakery3.com/docs/troubleshooting#the-render-is-darker-or-flatter-than-my-viewport"
+      );
+    }
+    return renderer;
+  }
+  function outputFor(call2, quality, camera, renderer, even = false) {
+    return resolveOutput(call2, defaults.output, {
+      quality,
+      camera: camera ?? null,
+      renderer,
+      even
+    });
+  }
+  function renderQuote(input) {
+    return {
+      quality: input.quality,
+      // Only the size is priced. The format is left out of the quote so that
+      // `estimate({ frames })` and the clip it precedes send the same body.
+      output: {
+        width: input.output.width,
+        height: input.output.height,
+        format: "png"
+      },
+      ...input.advanced ? { advanced: input.advanced } : {},
+      scene: estimateScene(input.scene, input.camera),
+      ...input.frames ? { frames: input.frames } : {}
+    };
+  }
+  async function capture(options2, method) {
+    return captureScene({
+      scene: resolveScene(options2.scene, method),
+      camera: resolveCamera(options2.camera, method),
+      renderer: rendererFor(options2.renderer),
+      environment: options2.environment,
+      productState: options2.productState,
+      background: options2.background
+    });
+  }
+  function recorderHost(options2, method) {
+    return {
+      async capture({ scene, camera }) {
+        const captured = await capture({ ...options2, scene, camera }, method);
+        return { ...captured, objects: objectIdsByName(scene) };
+      },
+      uploadAssets: (captured, onProgress) => uploadMissingAssets(client, captured.assets, onProgress)
+    };
+  }
+  function setOutput(options2, cameras, scene) {
+    const quality = options2.quality ?? defaults.quality ?? "studio";
+    return outputFor(
+      options2,
+      quality,
+      firstCamera(cameras, scene) ?? attached?.camera,
+      options2.renderer ?? attached?.renderer
+    );
+  }
+  function pictures(options2, cameras, method) {
+    const quality = options2.quality ?? defaults.quality ?? "studio";
+    const scene = resolveScene(options2.scene, method);
+    const output = setOutput(options2, cameras, scene);
+    return {
+      host: recorderHost(options2, method),
+      scene,
+      output,
+      spec: (manifest) => ({
+        manifest,
+        quality,
+        output,
+        ...options2.advanced ? { advanced: options2.advanced } : {},
+        ...options2.preview !== void 0 ? { preview: options2.preview } : {}
+      })
+    };
+  }
+  async function renderCameras(options2) {
+    const maxCost = options2.maxCost ?? defaults.maxCost;
+    const key = options2.idempotencyKey ?? `set_${randomId()}`;
+    const plan = pictures(options2, options2.cameras, "render");
+    const batch = new Batch(
+      client,
+      await client.openBatch({
+        key,
+        lane: "normal",
+        ...maxCost !== void 0 ? { maxCost } : {}
+      })
+    );
+    const keys = [];
+    const recorded = await record({
+      ...plan,
+      batch,
+      variants: [key],
+      idOf: () => key,
+      cameras: options2.cameras,
+      metadataOf: (_set, ids) => ({ ...options2.metadata, camera: ids.camera }),
+      keys,
+      onVariant: ({ upload }) => upload && options2.onUpload?.(upload)
+    });
+    await batch.close();
+    return new RenderSet(batch, recorded).ordered(keys);
+  }
+  function variantsRecording(options2, batch, method) {
+    const cameras = options2.cameras ?? [resolveCamera(void 0, method)];
+    return {
+      ...pictures(options2, cameras, method),
+      batch,
+      variants: options2.variants,
+      idOf: options2.id ?? defaultVariantId,
+      ...options2.apply ? { apply: options2.apply } : {},
+      ...options2.finishes ? { finishesOf: options2.finishes } : {},
+      cameras,
+      metadataOf: (variant, ids) => ({
+        ...options2.metadata?.(variant),
+        ...ids
+      }),
+      ...options2.version ? { version: options2.version } : {},
+      ...options2.maxCostPerImage !== void 0 ? { maxCostPerImage: options2.maxCostPerImage } : {},
+      ...options2.signal ? { signal: options2.signal } : {},
+      ...options2.onProgress ? { onVariant: options2.onProgress } : {}
+    };
+  }
+  function openVariants(options2, method) {
+    requireRunKey(options2.key, method);
+    return client.openBatch({
+      key: options2.key,
+      ...options2.name ? { name: options2.name } : {},
+      ...options2.maxCost !== void 0 ? { maxCost: options2.maxCost } : {},
+      lane: options2.lane ?? "batch",
+      ...options2.maxParallel !== void 0 ? { maxParallel: options2.maxParallel } : {}
+    });
+  }
+  async function renderVariants(options2) {
+    if (!(options2.maxCost > 0)) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: "renderVariants() needs a maxCost.",
+        why: "A run is as many renders as the variants multiply out to, and a ceiling is what makes that number safe to be wrong about: a page that would cross it is refused, never charged.",
+        fix: "Call quoteVariants() with the same options for the real number, then set `maxCost` a little above its `maximum`.",
+        docs: "https://bakery3.com/docs/batches#estimating-the-whole-catalog"
+      });
+    }
+    const batch = new Batch(
+      client,
+      await openVariants(options2, "renderVariants")
+    );
+    const recorded = await record(
+      variantsRecording(options2, batch, "renderVariants")
+    );
+    await batch.close();
+    return new RenderSet(batch, recorded);
+  }
+  return {
+    version: SDK_VERSION,
+    attach(context) {
+      attached = context;
+    },
+    check(scene) {
+      const { score, issues, counts } = analyzeScene(
+        resolveScene(scene, "check")
+      );
+      return { score, issues, counts };
+    },
+    async inspect(options2 = {}) {
+      return (await capture(options2, "inspect")).manifest;
+    },
+    async capture(options2 = {}) {
+      const captured = await capture(options2, "capture");
+      return {
+        ...captured,
+        objects: objectIdsByName(resolveScene(options2.scene, "capture"))
+      };
+    },
+    uploadAssets(captured, onProgress) {
+      return uploadMissingAssets(client, captured.assets, onProgress);
+    },
+    batches: {
+      async open(request) {
+        return new Batch(client, await client.openBatch(request));
+      },
+      async get(id) {
+        return new Batch(client, await client.getBatch(id));
+      }
+    },
+    async estimate(options2 = {}) {
+      const scene = resolveScene(options2.scene, "estimate");
+      if (options2.bake) {
+        return client.estimate(
+          quoteBake(scene, options2.camera ?? attached?.camera, options2.bake)
+        );
+      }
+      const camera = resolveCamera(options2.camera, "estimate");
+      const quality = options2.quality ?? defaults.quality ?? "studio";
+      return client.estimate(
+        renderQuote({
+          quality,
+          // A clip's derived side is even, as `renderVideo()` rounds it.
+          output: outputFor(
+            options2,
+            quality,
+            camera,
+            attached?.renderer,
+            Boolean(options2.frames)
+          ),
+          advanced: options2.advanced,
+          scene,
+          camera,
+          ...options2.frames ? { frames: options2.frames } : {}
+        })
+      );
+    },
+    renderVariants,
+    async testVariants(options2, test = {}) {
+      const scene = resolveScene(options2.scene, "testVariants");
+      const output = setOutput(
+        options2,
+        options2.cameras ?? [resolveCamera(void 0, "testVariants")],
+        scene
+      );
+      return renderVariants({
+        ...options2,
+        ...testSettings(
+          { key: options2.key, width: output.width, height: output.height },
+          test
+        ),
+        name: `${options2.name ?? options2.key} (test)`,
+        variants: sampleOf(options2.variants, test.products)
+      });
+    },
+    async quoteVariants(options2) {
+      requireRunKey(options2.key, "quoteVariants");
+      const batch = new Batch(
+        client,
+        await openVariants(
+          {
+            key: quoteKey(options2.key),
+            name: `${options2.name ?? options2.key} (quote)`,
+            lane: options2.lane ?? "batch"
+          },
+          "quoteVariants"
+        )
+      );
+      try {
+        return await record({
+          ...variantsRecording(options2, batch, "quoteVariants"),
+          dryRun: true
+        });
+      } finally {
+        await batch.cancel().catch(() => {
+        });
+      }
+    },
+    async getRenderSet(id) {
+      return new RenderSet(new Batch(client, await client.getBatch(id)));
+    },
+    async getRender(id) {
+      return new RenderJob(client, await client.getRender(id));
+    },
+    render: (async (options2 = {}) => {
+      if (hasCameras(options2)) return renderCameras(options2);
+      const scene = resolveScene(options2.scene, "render");
+      const camera = resolveCamera(options2.camera, "render");
+      const renderer = rendererFor(options2.renderer);
+      const quality = options2.quality ?? defaults.quality ?? "studio";
+      const output = outputFor(options2, quality, camera, renderer);
+      const maxCost = options2.maxCost ?? defaults.maxCost;
+      const { manifest, assets } = await captureScene({
+        scene,
+        camera,
+        renderer,
+        environment: options2.environment,
+        productState: options2.productState,
+        background: options2.background
+      });
+      if (maxCost !== void 0) {
+        const estimate = await client.estimate(
+          renderQuote({
+            quality,
+            output,
+            advanced: options2.advanced,
+            scene,
+            camera
+          })
+        );
+        if (estimate.maximumCost > maxCost) {
+          throw new RenderBudgetExceeded(maxCost, estimate, "render");
+        }
+      }
+      await uploadMissingAssets(client, assets, options2.onUpload);
+      const created = await client.createRender({
+        manifest,
+        quality,
+        output,
+        ...options2.advanced ? { advanced: options2.advanced } : {},
+        ...maxCost !== void 0 ? { maxCost } : {},
+        ...options2.preview !== void 0 ? { preview: options2.preview } : {},
+        ...options2.metadata ? { metadata: options2.metadata } : {},
+        ...options2.idempotencyKey ? { idempotencyKey: options2.idempotencyKey } : {},
+        ...options2.priority ? { priority: options2.priority } : {}
+      });
+      return new RenderJob(client, created);
+    }),
+    async bake(options2 = {}) {
+      const scene = resolveScene(options2.scene, "bake");
+      const camera = resolveCamera(options2.camera, "bake");
+      const maxCost = options2.maxCost ?? defaults.maxCost;
+      const { spec, assets } = await prepareBake({
+        scene,
+        camera,
+        renderer: rendererFor(options2.renderer),
+        environment: options2.environment,
+        productState: options2.productState,
+        background: options2.background,
+        ...options2.settings ? { settings: options2.settings } : {},
+        ...maxCost !== void 0 ? { maxCost } : {},
+        ...options2.metadata ? { metadata: options2.metadata } : {},
+        ...options2.idempotencyKey ? { idempotencyKey: options2.idempotencyKey } : {}
+      });
+      if (maxCost !== void 0) {
+        const quote = await client.estimate(bakeQuoteOf(spec));
+        if (quote.maximumCost > maxCost) {
+          throw new RenderBudgetExceeded(maxCost, quote, "bake");
+        }
+      }
+      await uploadMissingAssets(client, assets, options2.onUpload);
+      const record2 = await client.createBake(spec);
+      return new BakeJob(client, record2, clientFetch);
+    },
+    async getBake(id) {
+      return new BakeJob(client, await client.getBake(id), clientFetch);
+    },
+    timeline(options2 = {}) {
+      return bindTimelineContext(createTimeline(options2), () => attached);
+    },
+    async renderVideo(options2) {
+      const scene = resolveScene(options2.scene, "renderVideo");
+      const camera = resolveCamera(options2.camera, "renderVideo");
+      const renderer = rendererFor(options2.renderer);
+      const quality = options2.quality ?? defaults.quality ?? "studio";
+      const preferred = defaults.output?.format;
+      const format = options2.format ?? (preferred === "mp4" || preferred === "webm" || preferred === "png-sequence" ? preferred : "mp4");
+      const sequence = format === "png-sequence";
+      const { quality: _imageQuality, ...size } = outputFor(
+        { ...options2, format },
+        quality,
+        camera,
+        renderer,
+        !sequence
+      );
+      const output = {
+        ...size,
+        format,
+        ...sequence && options2.bitDepth !== void 0 ? { bitDepth: options2.bitDepth } : {}
+      };
+      const maxCost = options2.maxCost ?? defaults.maxCost;
+      const animation = options2.timeline.bake({
+        scene,
+        ...options2.fps !== void 0 ? { fps: options2.fps } : {}
+      });
+      const { manifest, assets } = await captureScene({
+        scene,
+        camera,
+        renderer,
+        environment: options2.environment,
+        productState: options2.productState,
+        background: options2.background
+      });
+      const animated = { ...manifest, animation };
+      animated.protocolVersion = protocolVersionFor(animated);
+      assertAnimationTargets(
+        animation,
+        animated,
+        assets[0].data,
+        namesByObjectId(options2.timeline)
+      );
+      if (maxCost !== void 0) {
+        const quote = await client.estimate(
+          renderQuote({
+            quality,
+            output,
+            advanced: options2.advanced,
+            scene,
+            camera,
+            frames: animation.frameCount
+          })
+        );
+        if (quote.maximumCost > maxCost) {
+          throw new RenderBudgetExceeded(maxCost, quote, "video");
+        }
+      }
+      await uploadMissingAssets(client, assets, options2.onUpload);
+      const record2 = await client.createRender({
+        manifest: animated,
+        quality,
+        output,
+        ...options2.advanced ? { advanced: options2.advanced } : {},
+        ...maxCost !== void 0 ? { maxCost } : {},
+        // No mid-render preview for a video: a low-sample still of frame one
+        // answers none of the questions somebody waiting on a clip is asking.
+        preview: false,
+        ...options2.metadata ? { metadata: options2.metadata } : {},
+        ...options2.idempotencyKey ? { idempotencyKey: options2.idempotencyKey } : {},
+        ...options2.priority ? { priority: options2.priority } : {}
+      });
+      return new RenderJob(client, record2);
+    }
+  };
+}
+function estimateScene(scene, camera) {
+  return {
+    // Every triangle traced, a preset room's published count included, as
+    // `manifest.stats.triangles` counts them for the price it is accepted at.
+    triangles: tracedTriangles(scene),
+    ...captureFog(scene).fog ? { fog: true } : {},
+    ...findPresetRooms(scene).length ? { room: true } : {},
+    ...sceneComplexity(scene, camera)
+  };
+}
+function hasCameras(options) {
+  return Array.isArray(options.cameras);
+}
+function randomId() {
+  const bytes = new Uint8Array(9);
+  globalThis.crypto.getRandomValues(bytes);
+  return Array.from(bytes, (byte) => byte.toString(36).padStart(2, "0")).join(
+    ""
+  );
+}
+function objectIdsByName(scene) {
+  const ids = {};
+  scene.traverse((object) => {
+    if (!object.name || object.name in ids || shouldExclude(object)) return;
+    ids[object.name] = idOf(object);
+  });
+  return ids;
+}
+function namesByObjectId(timeline) {
+  const names = /* @__PURE__ */ new Map();
+  for (const track of timeline.tracks) {
+    if (track.target === "camera") continue;
+    names.set(idOf(track.target), track.target.name || track.target.type);
+  }
+  return names;
+}
+function missingContext(method, what) {
+  const pass = method === "check" ? "pass your scene to check(scene)" : `pass { scene, camera } to ${method}()`;
+  return new Bakery3Error({
+    code: "InvalidRequest",
+    message: `No ${what} for ${method}().`,
+    why: `${method}() was called with no ${what}, and none has been attached.`,
+    fix: `In plain three.js, ${pass}, or call bakery3.attach({ scene, camera, renderer }) once. In React Three Fiber, use useBakery3() inside or beside <Canvas>.`,
+    docs: "https://bakery3.com/docs/troubleshooting#no-scene-to-render"
+  });
+}
+function requireRunKey(key, method) {
+  if (key) return;
+  throw new Bakery3Error({
+    code: "InvalidRequest",
+    message: `${method}() needs a key.`,
+    why: "The key names the run. It is what lets the same call resume a recording that stopped, instead of starting a second one.",
+    fix: "Give it something stable that names this body of work: `key: 'fall-2026'`.",
+    docs: "https://bakery3.com/docs/batches"
+  });
+}
+function firstCamera(cameras, scene) {
+  for (const camera of cameras ?? []) {
+    if (typeof camera === "string") {
+      let found;
+      scene.traverse((object) => {
+        if (!found && object.isCamera && object.name === camera)
+          found = object;
+      });
+      if (found) return found;
+    } else if (camera.isCamera) {
+      return camera;
+    }
+  }
+  return void 0;
+}
+function inBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+
+export { BakeJob, RenderJob, createBakery3 };
+//# sourceMappingURL=chunk-ARMTTZXZ.js.map
+//# sourceMappingURL=chunk-ARMTTZXZ.js.map