@oeave/bakery3 0.0.0-stage → 0.1.0

package/dist/node/index.js

@@ -0,0 +1,1279 @@
+import { warnIfKeyIsExposed, Bakery3Client, quoteKey, testSettings, sampleOf, Batch } from '../chunk-25ZXSVQ3.js';
+import { RenderSet, emptyRecorded } from '../chunk-ZEBVAIJJ.js';
+import { QUALITY, isClipFormat, isVideoFormat, protocolVersionFor, SDK_VERSION } from '../chunk-APBOWWSV.js';
+import { HDRI_PRESETS, PRESETS_VERSION, PEDESTAL_PRESETS } from '../chunk-6NYR73Y7.js';
+import { ROOM_PRESETS } from '../chunk-MD2U6S4N.js';
+import { Bakery3Error } from '../chunk-3G5QL4F4.js';
+export { Bakery3Error, BatchPageRefused } from '../chunk-3G5QL4F4.js';
+
+// src/frame.ts
+var VIEW_WORDS = {
+  front: { azimuthDeg: 0, elevationDeg: 6 },
+  "three-quarter": { azimuthDeg: 35, elevationDeg: 14 },
+  side: { azimuthDeg: 90, elevationDeg: 6 },
+  back: { azimuthDeg: 180, elevationDeg: 6 },
+  "three-quarter-back": { azimuthDeg: 145, elevationDeg: 14 },
+  top: { azimuthDeg: 0, elevationDeg: 88 }
+};
+function angleOf(view) {
+  if (typeof view === "string")
+    return view in VIEW_WORDS ? { ...VIEW_WORDS[view] } : null;
+  if (view && typeof view === "object" && typeof view.azimuthDeg === "number") {
+    const { azimuthDeg, elevationDeg } = view;
+    return {
+      azimuthDeg,
+      ...elevationDeg !== void 0 ? { elevationDeg } : {}
+    };
+  }
+  return null;
+}
+function angleBetween(from, to, t) {
+  const fromEl = from.elevationDeg ?? 12;
+  const toEl = to.elevationDeg ?? 12;
+  return {
+    azimuthDeg: from.azimuthDeg + (to.azimuthDeg - from.azimuthDeg) * t,
+    elevationDeg: fromEl + (toEl - fromEl) * t
+  };
+}
+function directionOf(angle) {
+  const azimuth = angle.azimuthDeg * Math.PI / 180;
+  const elevation = (angle.elevationDeg ?? 12) * Math.PI / 180;
+  return [
+    Math.sin(azimuth) * Math.cos(elevation),
+    Math.sin(elevation),
+    Math.cos(azimuth) * Math.cos(elevation)
+  ];
+}
+function framedDistance(radius, fov, aspect, margin) {
+  const vertical = fov * Math.PI / 180;
+  const horizontal = 2 * Math.atan(Math.tan(vertical / 2) * aspect);
+  return radius * (1 + margin) / Math.sin(Math.min(vertical, horizontal) / 2);
+}
+function radiusOf(bounds) {
+  return Math.hypot(
+    bounds.max[0] - bounds.min[0],
+    bounds.max[1] - bounds.min[1],
+    bounds.max[2] - bounds.min[2]
+  ) / 2 || 0.5;
+}
+function centerOf(bounds) {
+  return [
+    (bounds.min[0] + bounds.max[0]) / 2,
+    (bounds.min[1] + bounds.max[1]) / 2,
+    (bounds.min[2] + bounds.max[2]) / 2
+  ];
+}
+function framedCamera(bounds, view, aspect) {
+  const fov = view.fov ?? 30;
+  if (!(fov > 1 && fov < 120))
+    throw badView(view.id, `fov ${fov} is outside 1 to 120 degrees`);
+  const center = centerOf(bounds);
+  const radius = radiusOf(bounds);
+  const distance = framedDistance(radius, fov, aspect, view.margin ?? 0.12);
+  return cameraAt(
+    center,
+    radius,
+    directionOf(view),
+    distance,
+    fov,
+    aspect,
+    view.id
+  );
+}
+function cameraAt(center, radius, direction, distance, fov, aspect, name) {
+  const position = [
+    center[0] + direction[0] * distance,
+    center[1] + direction[1] * distance,
+    center[2] + direction[2] * distance
+  ];
+  return {
+    type: "perspective",
+    fov,
+    aspect,
+    near: Math.max(1e-3, (distance - radius) / 10),
+    far: (distance + radius) * 10,
+    position,
+    quaternion: lookAt(position, center),
+    name
+  };
+}
+function lookAt(position, target) {
+  let z = normalize([
+    position[0] - target[0],
+    position[1] - target[1],
+    position[2] - target[2]
+  ]);
+  if (!z) z = [0, 0, 1];
+  const up = Math.abs(z[0]) < 1e-9 && Math.abs(z[2]) < 1e-9 ? [0, 0, -1] : [0, 1, 0];
+  const x = normalize(cross(up, z)) ?? [1, 0, 0];
+  const y = cross(z, x);
+  return quaternionOf(x, y, z);
+}
+function quaternionOf(x, y, z) {
+  const m00 = x[0], m10 = x[1], m20 = x[2];
+  const m01 = y[0], m11 = y[1], m21 = y[2];
+  const m02 = z[0], m12 = z[1], m22 = z[2];
+  const trace = m00 + m11 + m22;
+  if (trace > 0) {
+    const s2 = 0.5 / Math.sqrt(trace + 1);
+    return [(m21 - m12) * s2, (m02 - m20) * s2, (m10 - m01) * s2, 0.25 / s2];
+  }
+  if (m00 > m11 && m00 > m22) {
+    const s2 = 2 * Math.sqrt(1 + m00 - m11 - m22);
+    return [0.25 * s2, (m01 + m10) / s2, (m02 + m20) / s2, (m21 - m12) / s2];
+  }
+  if (m11 > m22) {
+    const s2 = 2 * Math.sqrt(1 + m11 - m00 - m22);
+    return [(m01 + m10) / s2, 0.25 * s2, (m12 + m21) / s2, (m02 - m20) / s2];
+  }
+  const s = 2 * Math.sqrt(1 + m22 - m00 - m11);
+  return [(m02 + m20) / s, (m12 + m21) / s, 0.25 * s, (m10 - m01) / s];
+}
+function cross(a, b) {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}
+function normalize(v) {
+  const length = Math.hypot(v[0], v[1], v[2]);
+  return length > 1e-12 ? [v[0] / length, v[1] / length, v[2] / length] : null;
+}
+function badView(id, what) {
+  return new Bakery3Error({
+    code: "InvalidRequest",
+    message: `Camera "${id}": ${what}.`,
+    docs: "https://bakery3.com/docs/catalog#angles"
+  });
+}
+
+// src/node/renderBatch.ts
+var DOCS = "https://bakery3.com/docs/catalog";
+var PRESET_LIBRARY = "https://cdn.bakery3.com/presets";
+var SKIPS_KEPT = 50;
+var BREAKER_AFTER = 8;
+var BREAKER_SHARE = 0.5;
+var MAX_SECONDS = 30;
+var MAX_FPS = 60;
+async function recordBatch(host, batch, options, { dryRun = false, force } = {}) {
+  validateShots(options.shots ?? [], "the run");
+  const environments = new EnvironmentCache(host);
+  const tally = {
+    ...emptyRecorded(),
+    skipped: 0,
+    skips: [],
+    estimated: 0,
+    maximum: 0
+  };
+  const seen = /* @__PURE__ */ new Set();
+  let attempted = 0;
+  const one = async (product) => {
+    let items;
+    try {
+      if (product.shots)
+        validateShots(product.shots, `product "${product.id}"`);
+      const imported = await host.importAsset({
+        url: product.url,
+        kind: "scene"
+      });
+      items = await itemsOf(product, imported, options, environments, force);
+    } catch (error) {
+      if (!(error instanceof Bakery3Error) || error.code !== "ImportFailed" && error.code !== "ImportRefused")
+        throw error;
+      attempted++;
+      tally.skipped++;
+      if (tally.skips.length < SKIPS_KEPT)
+        tally.skips.push({ id: product.id, url: product.url, error });
+      if (attempted >= BREAKER_AFTER && tally.skipped / attempted > BREAKER_SHARE)
+        throw mostlyFailing(tally, attempted);
+      report(product.id);
+      return;
+    }
+    attempted++;
+    let outcomes;
+    if (dryRun) {
+      outcomes = await batch.quote(items);
+    } else {
+      for (const item of items) batch.add(item);
+      outcomes = await batch.flush();
+    }
+    tally.variants++;
+    tally.images += items.length;
+    for (const outcome of outcomes) {
+      if (outcome.error) {
+        tally.refused++;
+        if (tally.refusals.length < SKIPS_KEPT)
+          tally.refusals.push({ key: outcome.key, error: outcome.error });
+      } else if (outcome.adopted) tally.adopted++;
+      else {
+        tally.estimated += outcome.estimatedCost;
+        tally.maximum += outcome.maximumCost;
+      }
+    }
+    report(product.id);
+  };
+  const report = (product) => options.onProgress?.({
+    ...batch.progress(),
+    product,
+    products: tally.variants,
+    images: tally.images,
+    skipped: tally.skipped
+  });
+  const limit = Math.max(1, Math.min(16, Math.floor(options.concurrency ?? 4)));
+  const flying = /* @__PURE__ */ new Set();
+  let failure;
+  for await (const product of options.products) {
+    if (failure) break;
+    if (options.signal?.aborted) {
+      failure = options.signal.reason ?? abortError();
+      break;
+    }
+    validateProduct(product, seen);
+    const task = one(product).catch((error) => {
+      failure ??= error;
+    }).finally(() => flying.delete(task));
+    flying.add(task);
+    if (flying.size >= limit) await Promise.race(flying);
+  }
+  await Promise.all(flying);
+  if (failure) throw failure;
+  tally.estimated = Math.round(tally.estimated * 1e4) / 1e4;
+  tally.maximum = Math.round(tally.maximum * 1e4) / 1e4;
+  return tally;
+}
+async function itemsOf(product, imported, run, environments, force) {
+  const facts = imported.facts;
+  if (!facts)
+    throw unreadable(product, "The import returned no facts about the model.");
+  const blocking = facts.issues.find((issue) => issue.severity === "error");
+  if (blocking) throw unreadable(product, blocking.message);
+  if (!facts.bounds)
+    throw unreadable(
+      product,
+      "The model has no geometry with bounds, so there is nowhere to point a camera."
+    );
+  const bounds = facts.bounds;
+  const runSettings = settingsOf(run);
+  const productSettings = settingsOf(product);
+  const shots = (product.shots ?? run.shots ?? []).map(
+    (shot) => resolveShot(shot, runSettings, productSettings, force)
+  );
+  if (!shots.length) {
+    const inRoom = layered("room", runSettings, productSettings, force) != null;
+    shots.push(
+      resolveShot(
+        inRoom ? "room" : "three-quarter",
+        runSettings,
+        productSettings,
+        force
+      )
+    );
+  }
+  const counts = { info: 0, warning: 0, error: 0 };
+  for (const issue of facts.issues) counts[issue.severity]++;
+  const version = force?.version ?? run.version;
+  const items = [];
+  for (const shot of shots) {
+    const quality = shot.quality ?? "studio";
+    const edge = QUALITY[quality].defaultLongEdge;
+    const video = shot.kind === "video";
+    const output = {
+      width: shot.width ?? edge,
+      height: shot.height ?? edge,
+      format: shot.format ?? (video ? "mp4" : "png"),
+      ...shot.imageQuality !== void 0 ? { quality: shot.imageQuality } : {}
+    };
+    if (video !== isClipFormat(output.format)) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: `Shot "${shot.id}" of ${product.id} is ${video ? "a video in a still" : "an image in a video"} format (${output.format}).`,
+        fix: "A video is mp4, webm or png-sequence; an image is png, jpeg or webp. Leave `format` out for the default.",
+        path: `${product.id}/${shot.id}`,
+        docs: `${DOCS}#shots`
+      });
+    }
+    const aspect = output.width / output.height;
+    const room = shot.room ? roomFor(shot.room, bounds) : void 0;
+    const background = isVideoFormat(output.format) && (shot.background ?? "transparent") === "transparent" ? CLIP_BACKDROP : shot.background;
+    const environment = room ? roomBackground() : await environments.get(shot.environment, background);
+    const color = {
+      outputColorSpace: "srgb",
+      toneMapping: "aces-filmic",
+      toneMappingExposure: room ? room.exposure : 1,
+      ...shot.color
+    };
+    const lens = { fov: shot.fov, margin: shot.margin };
+    let camera;
+    let animation;
+    if (video) {
+      const from = angleFor(shot.from, room, product, shot.id);
+      const to = angleFor(shot.to, room, product, shot.id);
+      const fps = Math.min(MAX_FPS, Math.max(1, Math.round(shot.fps ?? 30)));
+      const seconds = Math.min(MAX_SECONDS, shot.seconds ?? 4);
+      const frameCount = Math.max(2, Math.round(seconds * fps));
+      const positions = [];
+      const quaternions = [];
+      let first;
+      for (let frame = 0; frame < frameCount; frame++) {
+        const at = angleBetween(from, to, frame / (frameCount - 1));
+        const spec = cameraForAngle(at, bounds, aspect, lens, room, shot.id);
+        first ??= spec;
+        positions.push(...spec.position);
+        quaternions.push(...spec.quaternion);
+      }
+      camera = first;
+      animation = {
+        fps,
+        frameCount,
+        channels: [
+          {
+            target: { type: "camera" },
+            property: "position",
+            size: 3,
+            values: positions
+          },
+          {
+            target: { type: "camera" },
+            property: "quaternion",
+            size: 4,
+            values: quaternions
+          }
+        ]
+      };
+    } else if (shot.camera) {
+      camera = ownCamera(shot.camera, facts, aspect, product, shot.id);
+    } else {
+      camera = cameraForAngle(
+        angleFor(
+          shot.view ?? (room ? "room" : "three-quarter"),
+          room,
+          product,
+          shot.id
+        ),
+        bounds,
+        aspect,
+        lens,
+        room,
+        shot.id
+      );
+    }
+    const manifest = {
+      protocolVersion: protocolVersionFor({
+        ...room ? { room: room.spec } : {},
+        ...animation ? { animation } : {}
+      }),
+      sdkVersion: SDK_VERSION,
+      sceneAsset: imported.hash,
+      camera,
+      environment,
+      color,
+      ...room ? { room: room.spec } : {},
+      ...animation ? { animation } : {},
+      compatibility: { score: 1, issues: facts.issues, counts },
+      stats: {
+        triangles: facts.triangles + (room?.triangles ?? 0),
+        // A room is priced by how enclosed and how full it is, measured when
+        // it was published; the product adds one object to it. Without a room
+        // the shot is an open set, which needs saying nothing.
+        ...room?.complexity ? {
+          enclosure: room.complexity.enclosure,
+          objects: room.complexity.objects + 1
+        } : {}
+      },
+      source: { renderer: "catalog" }
+    };
+    const key = `${product.id}/${shot.id}${version ? `@${version}` : ""}`;
+    if (key.length > 200)
+      throw unreadable(
+        product,
+        `The key "${key.slice(0, 40)}\u2026" is over 200 characters. Use shorter ids.`
+      );
+    items.push({
+      key,
+      spec: {
+        manifest,
+        quality,
+        output,
+        ...shot.advanced ? { advanced: shot.advanced } : {},
+        ...video ? { preview: false } : {}
+      },
+      metadata: {
+        ...product.metadata,
+        variant: product.id,
+        shot: shot.id,
+        kind: shot.kind
+      },
+      ...run.maxCostPerImage !== void 0 ? { maxCost: run.maxCostPerImage } : {}
+    });
+  }
+  return items;
+}
+var SETTING_KEYS = [
+  "room",
+  "environment",
+  "background",
+  "quality",
+  "width",
+  "height",
+  "format",
+  "imageQuality",
+  "fov",
+  "margin",
+  "fps",
+  "advanced",
+  "color"
+];
+function settingsOf(source) {
+  const out = {};
+  for (const key of SETTING_KEYS)
+    if (source[key] !== void 0)
+      out[key] = source[key];
+  return out;
+}
+function layered(key, ...layers) {
+  for (let i = layers.length - 1; i >= 0; i--) {
+    const value = layers[i]?.[key];
+    if (value !== void 0) return value;
+  }
+  return void 0;
+}
+function shotOf(shot) {
+  if (typeof shot === "string") return { view: shot };
+  if (shot && typeof shot === "object" && "azimuthDeg" in shot && !("view" in shot) && !("kind" in shot) && !("camera" in shot)) {
+    const { azimuthDeg, elevationDeg, ...rest } = shot;
+    return {
+      ...rest,
+      view: {
+        azimuthDeg,
+        ...elevationDeg !== void 0 ? { elevationDeg } : {}
+      }
+    };
+  }
+  return shot;
+}
+function resolveShot(shot, run, product, force) {
+  const own = shotOf(shot);
+  const settings = {};
+  for (const key of SETTING_KEYS) {
+    const value = layered(key, run, product, settingsOf(own), force);
+    if (value !== void 0) settings[key] = value;
+  }
+  if (own.kind === "video") {
+    return {
+      ...settings,
+      kind: "video",
+      id: own.id ?? `orbit-${viewName(own.from)}-${viewName(own.to)}`,
+      from: own.from,
+      to: own.to,
+      seconds: force?.seconds !== void 0 ? Math.min(force.seconds, own.seconds ?? 4) : own.seconds
+    };
+  }
+  const image = own;
+  return {
+    ...settings,
+    kind: "image",
+    id: image.id ?? (image.camera ? image.camera : viewName(image.view ?? (settings.room ? "room" : "three-quarter"))),
+    ...image.view !== void 0 ? { view: image.view } : {},
+    ...image.camera !== void 0 ? { camera: image.camera } : {}
+  };
+}
+function viewName(view) {
+  if (typeof view === "string") return view;
+  const el = view.elevationDeg;
+  return `az${Math.round(view.azimuthDeg)}${el !== void 0 ? `-el${Math.round(el)}` : ""}`.replace(
+    "--",
+    "-neg"
+  );
+}
+function angleFor(view, room, product, shot) {
+  if (view === "room") {
+    if (!room) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: `Shot "${shot}" of ${product.id} looks from 'room', but has no room.`,
+        fix: "Set `room: { preset: \u2026 }` on the run, the product or the shot, or use a view such as 'three-quarter'.",
+        path: `${product.id}/${shot}`,
+        docs: `${DOCS}#angles`
+      });
+    }
+    return room.published;
+  }
+  const angle = angleOf(view);
+  if (angle) return angle;
+  throw new Bakery3Error({
+    code: "InvalidRequest",
+    message: `Shot "${shot}" of ${product.id}: "${typeof view === "string" ? view : JSON.stringify(view)}" is not a view.`,
+    fix: `A view is one of ${Object.keys(VIEW_WORDS).join(", ")}, room, or \`{ azimuthDeg, elevationDeg? }\`. For a camera inside the model, use \`camera: '<node name>'\`.`,
+    path: `${product.id}/${shot}`,
+    docs: `${DOCS}#angles`
+  });
+}
+function cameraForAngle(angle, bounds, aspect, lens, room, name) {
+  if (room) return room.camera(angle, aspect, lens, name);
+  return framedCamera(
+    bounds,
+    {
+      id: name,
+      ...angle,
+      ...lens.fov !== void 0 ? { fov: lens.fov } : {},
+      ...lens.margin !== void 0 ? { margin: lens.margin } : {}
+    },
+    aspect
+  );
+}
+function ownCamera(name, facts, aspect, product, shot) {
+  const own = facts.cameras.find((camera) => camera.name === name);
+  if (own)
+    return {
+      ...own.camera,
+      ...own.camera.type === "perspective" ? { aspect } : {},
+      name: shot
+    };
+  const names = facts.cameras.map((camera) => camera.name);
+  throw new Bakery3Error({
+    code: "ImportFailed",
+    message: `Shot "${shot}": ${product.id}'s model has no camera named "${name}".`,
+    fix: names.length ? `Its cameras are: ${names.slice(0, 8).join(", ")}.` : "It carries no cameras. Use a view instead: an angle is framed from the model itself.",
+    path: `${product.id}/${shot}`,
+    docs: `${DOCS}#angles`
+  });
+}
+var DEFAULT_ENVIRONMENT = {
+  preset: "studio_small_03",
+  intensity: 0.6
+};
+var CLIP_BACKDROP = "#f4f4f5";
+var EnvironmentCache = class {
+  constructor(host) {
+    this.host = host;
+  }
+  host;
+  hashes = /* @__PURE__ */ new Map();
+  async get(chosen, background) {
+    const environment = chosen ?? DEFAULT_ENVIRONMENT;
+    if (environment.preset && environment.url) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: "environment takes a `preset` or a `url`, not both.",
+        docs: `${DOCS}#light`
+      });
+    }
+    let hdri;
+    if (environment.url) {
+      const url = environment.url;
+      let pending = this.hashes.get(url);
+      if (!pending) {
+        pending = this.host.importAsset({ url, kind: "hdri" }).then((imported) => imported.hash);
+        this.hashes.set(url, pending);
+        pending.catch(() => this.hashes.delete(url));
+      }
+      hdri = await pending;
+    } else {
+      const name = environment.preset ?? "studio_small_03";
+      if (!(name in HDRI_PRESETS)) {
+        throw new Bakery3Error({
+          code: "InvalidRequest",
+          message: `There is no environment preset "${name}".`,
+          fix: `The presets are: ${Object.keys(HDRI_PRESETS).join(", ")}.`,
+          docs: `${DOCS}#light`
+        });
+      }
+      hdri = `${PRESET_LIBRARY}/v${PRESETS_VERSION}/hdri/${name}/render.exr`;
+    }
+    return {
+      hdri,
+      ...environment.intensity !== void 0 ? { intensity: environment.intensity } : {},
+      ...environment.rotationDeg ? {
+        rotation: [0, environment.rotationDeg * Math.PI / 180, 0]
+      } : {},
+      background: backgroundOf(background)
+    };
+  }
+};
+function backgroundOf(background) {
+  const chosen = background ?? "transparent";
+  if (chosen === "transparent") return { type: "transparent" };
+  if (chosen === "environment") return { type: "environment" };
+  if (!/^#[0-9a-f]{6}$/i.test(chosen)) {
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: `background "${chosen}" is not 'transparent', 'environment' or a #rrggbb color.`,
+      docs: `${DOCS}#light`
+    });
+  }
+  return { type: "color", color: chosen };
+}
+function roomBackground() {
+  return { background: { type: "transparent" } };
+}
+var STAND_RULES = {
+  fit: 0.85,
+  tallFrom: 0.6,
+  smallHeight: 0.6,
+  plinthHeight: 1
+};
+var PLINTH = "pedestal_plinth";
+var ROOM_MARGIN = 0.9;
+var WALL_CLEARANCE = 0.3;
+var FIT_MARGIN = 0.12;
+var MAX_ROOM_FOV = 100;
+var ROOM_MIN_ELEVATION_DEG = 0;
+function fovToFit(radius, distance, aspect) {
+  const half = Math.asin(Math.min(1, radius / distance));
+  const vertical = aspect >= 1 ? half : Math.atan(Math.tan(half) / aspect);
+  return 2 * vertical * 180 / Math.PI;
+}
+function standFor(room, info, bounds) {
+  const footprint = Math.max(
+    bounds.max[0] - bounds.min[0],
+    bounds.max[2] - bounds.min[2]
+  );
+  const height = bounds.max[1] - bounds.min[1];
+  const fits = (size) => {
+    if (!size) return false;
+    if (footprint > STAND_RULES.fit * Math.min(size.x, size.z)) return false;
+    return height <= (size.y >= STAND_RULES.tallFrom ? STAND_RULES.smallHeight : STAND_RULES.plinthHeight);
+  };
+  const choice = room.stand ?? "auto";
+  if (choice === "own" || choice === "auto" && fits(info.stand.size))
+    return { top: info.stand.top };
+  if (choice === "auto" && fits(PEDESTAL_PRESETS[PLINTH].size))
+    return { pedestal: { type: PLINTH }, top: PEDESTAL_PRESETS[PLINTH].size.y };
+  return { pedestal: null, top: 0 };
+}
+function roomFor(room, bounds) {
+  const info = ROOM_PRESETS[room.preset];
+  if (!info) {
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: `There is no room preset "${room.preset}".`,
+      fix: `The rooms are: ${Object.keys(ROOM_PRESETS).join(", ")}.`,
+      docs: `${DOCS}#light`
+    });
+  }
+  const lighting = room.mode ?? info.lighting;
+  const standing = standFor(room, info, bounds);
+  const stand = [info.stand.x, standing.top, info.stand.z];
+  const base = [
+    (bounds.min[0] + bounds.max[0]) / 2,
+    bounds.min[1],
+    (bounds.min[2] + bounds.max[2]) / 2
+  ];
+  const size = [
+    bounds.max[0] - bounds.min[0],
+    bounds.max[1] - bounds.min[1],
+    bounds.max[2] - bounds.min[2]
+  ];
+  const radius = radiusOf(bounds);
+  const line = [
+    info.camera.position[0] - info.camera.target[0],
+    info.camera.position[1] - info.camera.target[1],
+    info.camera.position[2] - info.camera.target[2]
+  ];
+  const designed = Math.hypot(line[0], line[1], line[2]);
+  const publishedAzimuth = Math.atan2(line[0], line[2]);
+  const viewFrom = (room.viewFromDeg ?? 30) * Math.PI / 180;
+  const theta = viewFrom - publishedAzimuth;
+  const c = Math.cos(theta);
+  const s = Math.sin(theta);
+  const place = ([x, y, z]) => {
+    const dx = x - stand[0];
+    const dz = z - stand[2];
+    return [
+      base[0] + dx * c + dz * s,
+      base[1] + (y - stand[1]),
+      base[2] - dx * s + dz * c
+    ];
+  };
+  const origin = place([0, 0, 0]);
+  const matrix = [
+    c,
+    0,
+    -s,
+    0,
+    0,
+    1,
+    0,
+    0,
+    s,
+    0,
+    c,
+    0,
+    origin[0],
+    origin[1],
+    origin[2],
+    1
+  ];
+  const spec = {
+    name: room.preset,
+    build: info.build,
+    lighting,
+    ...standing.pedestal !== void 0 ? { pedestal: standing.pedestal } : {},
+    matrix
+  };
+  const published = {
+    azimuthDeg: viewFrom * 180 / Math.PI,
+    elevationDeg: Math.max(
+      ROOM_MIN_ELEVATION_DEG,
+      Math.atan2(line[1], Math.hypot(line[0], line[2])) * 180 / Math.PI
+    )
+  };
+  const lensFov = (aspect) => 2 * Math.atan((aspect >= 1 ? 36 / aspect : 36) / (2 * info.camera.lensMm)) * 180 / Math.PI;
+  return {
+    spec,
+    triangles: info.preview.triangles,
+    complexity: info.complexity,
+    exposure: info.exposure[lighting],
+    published,
+    /**
+     * A camera in the room from any angle: framed as in the open, from as
+     * far as the published camera stood when that is the view, and never
+     * behind a wall, the floor or the ceiling.
+     */
+    camera(angle, aspect, lens, name) {
+      const fov = lens.fov ?? lensFov(aspect);
+      const center = centerOf(bounds);
+      const direction = directionOf(angle);
+      const framed = framedDistance(
+        radius,
+        fov,
+        aspect,
+        lens.margin ?? ROOM_MARGIN
+      );
+      const isPublished = Math.abs(angle.azimuthDeg - published.azimuthDeg) < 1e-6 && Math.abs((angle.elevationDeg ?? 12) - published.elevationDeg) < 1e-6;
+      const rx = direction[0] * c - direction[2] * s;
+      const rz = direction[0] * s + direction[2] * c;
+      const ry = direction[1];
+      const from = [stand[0], stand[1] + size[1] / 2, stand[2]];
+      const half = [
+        info.size.width / 2 - WALL_CLEARANCE,
+        info.size.depth / 2 - WALL_CLEARANCE
+      ];
+      let reach = Infinity;
+      if (rx !== 0)
+        reach = Math.min(
+          reach,
+          ((rx > 0 ? half[0] : -half[0]) - from[0]) / rx
+        );
+      if (rz !== 0)
+        reach = Math.min(
+          reach,
+          ((rz > 0 ? half[1] : -half[1]) - from[2]) / rz
+        );
+      if (ry > 0)
+        reach = Math.min(
+          reach,
+          (info.size.height - WALL_CLEARANCE - from[1]) / ry
+        );
+      if (ry < 0) reach = Math.min(reach, (WALL_CLEARANCE - from[1]) / ry);
+      const wanted = Math.max(isPublished ? designed : 0, framed);
+      const distance = Math.max(radius * 1.2, Math.min(wanted, reach));
+      const lensFit = distance < framed ? fovToFit(radius * (1 + FIT_MARGIN), distance, aspect) : fov;
+      return cameraAt(
+        center,
+        radius,
+        direction,
+        distance,
+        Math.min(MAX_ROOM_FOV, Math.max(fov, lensFit)),
+        aspect,
+        name
+      );
+    }
+  };
+}
+function validateShots(shots, where) {
+  const ids = /* @__PURE__ */ new Set();
+  shots.forEach((shot, index) => {
+    if (!shot || typeof shot !== "string" && typeof shot !== "object")
+      throw badShot(where, index, "is not a shot");
+    const own = shotOf(shot);
+    if (own.kind === "video") {
+      if (angleOf(own.from) === null && own.from !== "room")
+        throw badShot(where, index, "`from` is not a view");
+      if (angleOf(own.to) === null && own.to !== "room")
+        throw badShot(where, index, "`to` is not a view");
+      if (own.seconds !== void 0 && !(own.seconds > 0 && own.seconds <= MAX_SECONDS))
+        throw badShot(
+          where,
+          index,
+          `\`seconds\` is outside 0 to ${MAX_SECONDS}`
+        );
+    } else if (own.kind !== void 0 && own.kind !== "image") {
+      throw badShot(
+        where,
+        index,
+        `kind "${String(own.kind)}" is not 'image' or 'video'`
+      );
+    } else if (own.view !== void 0 && own.camera !== void 0) {
+      throw badShot(where, index, "has both a `view` and a `camera`");
+    }
+    const id = own.id ?? (own.kind === "video" ? `orbit-${viewName(own.from)}-${viewName(own.to)}` : own.camera ?? (own.view !== void 0 ? viewName(own.view) : void 0));
+    if (id !== void 0) {
+      if (!/^[A-Za-z0-9_.-]{1,60}$/.test(id))
+        throw badShot(
+          where,
+          index,
+          `id "${id}" is not 1 to 60 letters, digits, dots, dashes or underscores`
+        );
+      if (ids.has(id)) throw badShot(where, index, `id "${id}" is used twice`);
+      ids.add(id);
+    }
+  });
+}
+function badShot(where, index, what) {
+  return new Bakery3Error({
+    code: "InvalidRequest",
+    message: `Shot ${index + 1} of ${where} ${what}.`,
+    why: 'A shot is a word, `{ view }`, or `{ kind: "video", from, to }`, plus settings, and its id ends the picture\u2019s key.',
+    docs: `${DOCS}#shots`
+  });
+}
+function validateProduct(product, seen) {
+  if (!product || typeof product.id !== "string" || !product.id || typeof product.url !== "string" || !product.url) {
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: "Every product needs an `id` and a `url`.",
+      why: "The id starts every shot\u2019s key: it is what a re-run adopts by and what a failure is reported under.",
+      docs: DOCS
+    });
+  }
+  if (seen.has(product.id)) {
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: `Two products are called "${product.id}".`,
+      why: "The second would be adopted as the first: same key, same picture.",
+      fix: "Make the ids unique.",
+      path: product.id,
+      docs: DOCS
+    });
+  }
+  seen.add(product.id);
+}
+function unreadable(product, message) {
+  return new Bakery3Error({
+    code: "ImportFailed",
+    message,
+    path: product.id,
+    docs: `${DOCS}#what-a-model-can-use`
+  });
+}
+function mostlyFailing(tally, attempted) {
+  const first = tally.skips[0];
+  return new Bakery3Error({
+    code: "ImportFailed",
+    message: `${tally.skipped} of the first ${attempted} models could not be imported. The first: ${first.id}: ${first.error.message}`,
+    why: "One bad model is skipped and listed. Most of them failing is something wrong with all of them: a base URL, a bucket that is not public, a format.",
+    fix: "Open one of the URLs in a private browser window. It has to download a .glb there. What was recorded stays admitted; call again with the same key to go on.",
+    docs: `${DOCS}#importing-by-url`
+  });
+}
+function abortError() {
+  const error = new Error("The recording was aborted.");
+  error.name = "AbortError";
+  return error;
+}
+
+// src/node/webhook.ts
+var TOLERANCE_MS = 5 * 60 * 1e3;
+async function verifyWebhook(input) {
+  const { body, signature, secret } = input;
+  const now = input.now ?? Date.now();
+  if (typeof secret !== "string" || !secret) {
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: "verifyWebhook() was given no secret.",
+      fix: "Pass the signing secret from your webhook settings, from a server-only environment variable: secret: process.env.BAKERY3_WEBHOOK_SECRET!",
+      docs: "https://bakery3.com/docs/webhooks"
+    });
+  }
+  if (typeof signature !== "string" || !signature) {
+    throw invalid(
+      'The request has no bakery3-signature header. Pass request.headers.get("bakery3-signature").'
+    );
+  }
+  const parts = Object.fromEntries(
+    signature.split(",").map((piece) => {
+      const index = piece.indexOf("=");
+      return [piece.slice(0, index).trim(), piece.slice(index + 1).trim()];
+    })
+  );
+  const timestamp = Number(parts.t);
+  const provided = parts.v1;
+  if (!timestamp || !provided) {
+    throw invalid('Signature header is malformed. Expected "t=\u2026,v1=\u2026".');
+  }
+  if (Math.abs(now - timestamp) > TOLERANCE_MS) {
+    throw invalid("Signature timestamp is outside the five-minute tolerance.");
+  }
+  const key = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const mac = await crypto.subtle.sign(
+    "HMAC",
+    key,
+    new TextEncoder().encode(`${timestamp}.${body}`)
+  );
+  if (!timingSafeEqual(toHex(new Uint8Array(mac)), provided)) {
+    throw invalid("Signature does not match the body.");
+  }
+  return JSON.parse(body);
+}
+function invalid(message) {
+  return new Bakery3Error({
+    code: "Unauthorized",
+    message,
+    why: "The request did not carry a valid Bakery3 signature, so it may not have come from us.",
+    fix: "Pass the raw request body (not a re-serialized object) and the secret from your webhook settings.",
+    docs: "https://bakery3.com/docs/webhooks"
+  });
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+function toHex(bytes) {
+  let out = "";
+  for (const byte of bytes) out += byte.toString(16).padStart(2, "0");
+  return out;
+}
+
+// src/node/index.ts
+var Bakery3Server = class {
+  tokens;
+  renders;
+  batches;
+  assets;
+  secretKey;
+  options;
+  transport;
+  /**
+   * @param secretKey Your `bk_sk_` key, as a string, from a server-only
+   *   environment variable. Not the browser SDK's `{ apiKey }` object.
+   *
+   * The key is checked on the first request, not here. A route module that
+   * builds its client at the top level is evaluated by `next build`, often
+   * where the server's secrets are not set, and a constructor that threw
+   * there would fail the build over a key the build never uses.
+   */
+  constructor(secretKey, options = {}) {
+    if (secretKey != null && typeof secretKey !== "string") {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: "new Bakery3Server() takes the secret key as a string, not an options object.",
+        fix: "new Bakery3Server(process.env.BAKERY3_SECRET_KEY!, options)",
+        docs: "https://bakery3.com/docs/auth"
+      });
+    }
+    this.secretKey = secretKey || void 0;
+    this.options = options;
+    if (this.secretKey) warnIfKeyIsExposed(this.secretKey, { source: "node" });
+    const client = () => this.client();
+    const request = async (method, path, body) => client().request(method, path, body);
+    this.tokens = new TokensApi(request);
+    this.renders = new RendersApi(request, client);
+    this.batches = new BatchesApi(client);
+    this.assets = new AssetsApi(client);
+  }
+  /**
+   * The same transport the browser SDK uses (one error shape, the same
+   * 429/503 backoff) with the secret key as the bearer. It has nothing to
+   * re-mint, so a 401 here is a 401. Made on first use, after the key is
+   * checked.
+   */
+  client() {
+    if (this.transport) return this.transport;
+    const secretKey = this.secretKey;
+    if (!secretKey) {
+      throw new Bakery3Error({
+        code: "Unauthorized",
+        message: "A secret key is required. Create one at https://bakery3.com/keys, then pass it: new Bakery3Server(process.env.BAKERY3_SECRET_KEY!).",
+        docs: "https://bakery3.com/docs/auth"
+      });
+    }
+    if (secretKey.startsWith("bk_pt_")) {
+      throw new Bakery3Error({
+        code: "Unauthorized",
+        message: "That is a browser token, not a secret key.",
+        why: "Browser tokens (bk_pt_\u2026) are minted by this SDK. Secret keys (bk_sk_\u2026) create them.",
+        fix: "Use your bk_sk_ key from https://bakery3.com/keys, kept in a server-only environment variable.",
+        docs: "https://bakery3.com/docs/auth"
+      });
+    }
+    if (!secretKey.startsWith("bk_sk_")) {
+      throw new Bakery3Error({
+        code: "Unauthorized",
+        message: "That is not a secret key. Secret keys start with bk_sk_. Create one at https://bakery3.com/keys.",
+        docs: "https://bakery3.com/docs/auth"
+      });
+    }
+    this.transport = new Bakery3Client({
+      apiKey: secretKey,
+      ...this.options.baseUrl ? { baseUrl: this.options.baseUrl } : {},
+      ...this.options.fetch ? { fetch: this.options.fetch } : {},
+      ...this.options.retry ? { retry: this.options.retry } : {}
+    });
+    return this.transport;
+  }
+  /**
+   * Render a catalog of models that already sit on a CDN: one call, no
+   * browser, and none of the models' bytes through this process. Needs a
+   * plan that includes imports (see https://bakery3.com/docs/catalog#plans).
+   *
+   *     const run = await api.renderBatch({
+   *       key: 'fall-2026',
+   *       products: [{ id: 'chair-aria', url: 'https://cdn.shop.com/models/chair-aria.glb' }],
+   *       shots: ['three-quarter', 'front', { kind: 'video', from: 'front', to: 'back', seconds: 4 }],
+   *       room: { preset: 'loft_golden' },
+   *       maxCost: 600,
+   *     });
+   *     await run.wait();          // or let a webhook tell you, and exit now
+   *
+   * Resolves once every product is recorded and the run is sealed. The
+   * shots render on from there; this process does not have to stay up.
+   * A product whose model cannot be imported is skipped and listed in
+   * `run.recorded.skips`, and the run goes on. Calling it again with the
+   * same `key` resumes a recording that stopped, re-downloads no model that
+   * did not change, and adopts every shot that already rendered.
+   *
+   * What a model by URL cannot carry (node materials, a shader-lit set) is
+   * recorded where that code runs; see `renderVariants()` in `@oeave/bakery3`.
+   */
+  async renderBatch(options) {
+    if (!(options.maxCost > 0)) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: "renderBatch() needs a maxCost.",
+        why: "A run is as many renders as products times shots, 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 quoteBatch() with the same options for the real number, or testBatch() to look at three products first.",
+        docs: "https://bakery3.com/docs/catalog#what-it-will-cost"
+      });
+    }
+    const batch = await this.openRun(options);
+    const recorded = await recordBatch(this.client(), batch, options);
+    await batch.close();
+    return new RenderSet(batch, recorded);
+  }
+  /**
+   * What `renderBatch()` would cost. The models are imported (that is how
+   * they are priced); nothing is rendered or charged.
+   */
+  async quoteBatch(options) {
+    const batch = await this.openRun({
+      key: options.key && quoteKey(options.key),
+      name: `${options.name ?? options.key} (quote)`,
+      ...options.lane ? { lane: options.lane } : {}
+    });
+    try {
+      return await recordBatch(this.client(), batch, options, {
+        dryRun: true
+      });
+    } finally {
+      await batch.cancel().catch(() => {
+      });
+    }
+  }
+  /**
+   * Look before paying: three products (the first, the middle and the last
+   * of an array; the first three of anything else), every shot, at preview
+   * quality and a small size, in the ordinary lane so they come back in
+   * about a minute. A clip is cut to two seconds at twelve frames. Same
+   * options as `renderBatch()`. The test run has keys of its own, so the
+   * real run never adopts these previews as finished shots.
+   *
+   *     const test = await api.testBatch(options);
+   *     for (const shot of await test.result()) console.log(shot.variant, shot.shot, shot.url);
+   */
+  async testBatch(options, test = {}) {
+    const edge = QUALITY[options.quality ?? "studio"].defaultLongEdge;
+    const settings = testSettings(
+      {
+        key: options.key,
+        width: options.width ?? edge,
+        height: options.height ?? edge
+      },
+      test
+    );
+    const run = {
+      ...options,
+      key: settings.key,
+      lane: settings.lane,
+      maxCost: settings.maxCost,
+      products: sampleOf(options.products, test.products),
+      name: `${options.name ?? options.key} (test)`
+    };
+    const batch = await this.openRun(run);
+    const recorded = await recordBatch(this.client(), batch, run, {
+      force: {
+        version: settings.version,
+        quality: settings.quality,
+        width: settings.width,
+        height: settings.height,
+        fps: 12,
+        seconds: 2
+      }
+    });
+    await batch.close();
+    return new RenderSet(batch, recorded);
+  }
+  /**
+   * A run by id, from another process, a webhook handler, or tomorrow
+   * morning.
+   */
+  async getRenderSet(id) {
+    const client = this.client();
+    return new RenderSet(new Batch(client, await client.getBatch(id)));
+  }
+  async openRun(options) {
+    if (!options.key) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: "A run 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/catalog"
+      });
+    }
+    const client = this.client();
+    return new Batch(
+      client,
+      await client.openBatch({
+        key: options.key,
+        ...options.name ? { name: options.name } : {},
+        ...options.maxCost !== void 0 ? { maxCost: options.maxCost } : {},
+        lane: options.lane ?? "batch",
+        ...options.maxParallel !== void 0 ? { maxParallel: options.maxParallel } : {}
+      })
+    );
+  }
+};
+var AssetsApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Have the service fetch a public https URL into the project's assets,
+   * and say what it found: the hash to put in a manifest, and for a model
+   * its triangles, bounds, cameras and anything the renderer cannot read.
+   *
+   * Secret key only, which is why it is here and not in the browser SDK.
+   * What is fetched is fenced on the service's side: https, public
+   * addresses only, no credentials, a size limit, and the file must be a
+   * model or an HDRI. An unchanged URL is answered without a download
+   * (`unchanged: true`).
+   */
+  async import(url, options = {}) {
+    return this.client().importAsset({
+      url,
+      ...options.kind ? { kind: options.kind } : {}
+    });
+  }
+};
+var TokensApi = class {
+  constructor(request) {
+    this.request = request;
+  }
+  request;
+  /**
+   * Mint a browser token.
+   *
+   * Everything about it is a ceiling rather than a grant: it cannot outlive
+   * its expiry, cannot start more renders than `maxRenders`, cannot spend past
+   * `maxCost`, cannot be used from an origin outside `allowedOrigins`, and
+   * cannot perform a single billing or admin operation. That last one is not
+   * a policy: those routes require a `bk_sk_` key and this is not one.
+   */
+  create(options = {}) {
+    return this.request("POST", "/v1/tokens", {
+      expiresInSeconds: options.expiresInSeconds ?? 300,
+      maxRenders: options.maxRenders ?? 5,
+      maxCost: options.maxCost ?? 2,
+      ...options.allowedOrigins ? { allowedOrigins: options.allowedOrigins } : {},
+      ...options.subject ? { subject: options.subject } : {}
+    });
+  }
+  /** Revoke a token before its expiry. */
+  revoke(token) {
+    return this.request("POST", "/v1/tokens/revoke", { token });
+  }
+};
+var RendersApi = class {
+  constructor(request, client) {
+    this.request = request;
+    this.client = client;
+  }
+  request;
+  client;
+  /**
+   * Render from a manifest you already have: a batch job, a re-render, a
+   * queued webhook. The browser flow is `@oeave/bakery3`; this is the API.
+   * Repeated on a 429/503 only when `spec.idempotencyKey` makes that safe.
+   */
+  async create(spec) {
+    return this.client().createRender(spec);
+  }
+  /** A render's record, with its state, cost and result URLs. */
+  get(id) {
+    return this.request("GET", `/v1/renders/${id}`);
+  }
+  /** Cancel a render that has not finished. Already terminal is a no-op. */
+  cancel(id) {
+    return this.request("POST", `/v1/renders/${id}/cancel`, {});
+  }
+  /**
+   * One more attempt for a render that failed with `attemptsExhausted`.
+   * Returns the new render, linked to the old one; a render that is not in
+   * that state answers 409.
+   */
+  async retry(id) {
+    return this.client().retryRender(id);
+  }
+  /**
+   * Delete a render now rather than when retention would: the result, the
+   * preview, and every signed URL that pointed at them. The record survives
+   * as `expired`, so the receipt is still readable. A live render is
+   * cancelled first.
+   */
+  delete(id) {
+    return this.request("DELETE", `/v1/renders/${id}`);
+  }
+  /** The project's renders, newest first, a page at a time. */
+  list(options = {}) {
+    const query = new URLSearchParams();
+    if (options.limit) query.set("limit", String(options.limit));
+    if (options.cursor) query.set("cursor", options.cursor);
+    const suffix = query.toString() ? `?${query}` : "";
+    return this.request("GET", `/v1/renders${suffix}`);
+  }
+  /** The quote for a spec: a likely cost and a maximum, in USD. */
+  estimate(spec) {
+    return this.request("POST", "/v1/estimate", spec);
+  }
+};
+var BatchesApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Open, or re-open by key. */
+  async open(request) {
+    const client = this.client();
+    return new Batch(client, await client.openBatch(request));
+  }
+  /** A batch by id, with its latest counts. */
+  async get(id) {
+    const client = this.client();
+    return new Batch(client, await client.getBatch(id));
+  }
+};
+
+export { Bakery3Server, verifyWebhook };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map