@oeave/bakery3 0.0.0-stage → 0.2.0

package/dist/node/index.d.cts

@@ -0,0 +1,4927 @@
+/**
+ * Animation: authored as keyframes, shipped as baked frames.
+ *
+ * The SDK's `Timeline` is keyframes, easings and orbit segments; this is
+ * not. What travels is one exact value per output frame, and the renderer
+ * sets one keyframe per frame with linear interpolation, so there is nothing
+ * left for it to interpolate and nothing for the two sides to disagree
+ * about. Easing curves and orbit math exist in one implementation, and the
+ * browser preview and the traced frame agree on where everything is at
+ * frame N. It costs little: 10 s at 30 fps of camera motion is 300 frames of
+ * 7 floats.
+ */
+/**
+ * What a channel drives. The camera is not an object id: it may never have
+ * been in the scene graph at all (see `CameraSpec`). Neither is the
+ * environment: `scene.environment`, its intensity and rotation, and the
+ * scene's ambient light are scene state, not objects (see `EnvironmentSpec`).
+ */
+type AnimationTarget = {
+    type: 'camera';
+} | {
+    type: 'object';
+    objectId: string;
+} | {
+    type: 'environment';
+};
+/**
+ * One animated property, sampled at every frame.
+ *
+ * `values` is flat: `frameCount * size` numbers, row-major, frame 0's
+ * components and then frame 1's. Nested arrays would cost two bytes of JSON
+ * per frame per channel, which for a long sequence is the larger part of
+ * the manifest.
+ */
+type AnimationChannel = {
+    target: AnimationTarget;
+    /**
+     * `position` | `quaternion` | `scale` | `fov` | `color` | `emissive` |
+     * `emissiveIntensity` | `roughness` | `metalness` | `opacity` | `intensity`
+     * | `target` | `groundColor`, and on the environment target the four in
+     * `ENVIRONMENT_CHANNEL_PROPERTIES`.
+     *
+     * `target` is a directional or spot light's aim, a WORLD point, as three's
+     * `light.target` holds it. Such a light is aimed from its position to its
+     * target at every frame, as three aims it, so animating either one turns
+     * the beam; `quaternion` on one is refused, because three ignores a
+     * directional or spot light's rotation.
+     *
+     * A property the renderer does not implement is refused with the name,
+     * the object's path and a fix, never dropped.
+     */
+    property: string;
+    /** Components per frame: 3 position/scale/color, 4 quaternion, 1 scalar. */
+    size: number;
+    values: number[];
+};
+/**
+ * The baked sequence.
+ *
+ * Frame `i` is sampled at `i / fps` seconds, so a `frameCount / fps` second
+ * clip never repeats its first pose at the end, which is what makes a 360
+ * degree orbit loop without a duplicated frame.
+ */
+type AnimationSpec = {
+    fps: number;
+    frameCount: number;
+    channels: AnimationChannel[];
+    /**
+     * Where the browser actually put things: see `WorldCheck`. Optional on the
+     * wire so an older worker reads straight through it; a worker that
+     * implements it refuses a clip whose frames disagree with the browser's.
+     */
+    checks?: WorldCheck[];
+};
+/**
+ * A target's world matrix at a few of the clip's frames, straight off three
+ * (`Object3D.matrixWorld` after a seek; the camera's pose composed), in
+ * three's own Y-up frame, column-major, sixteen numbers per frame.
+ *
+ * The channels say what the browser did; this says where it ended up. The
+ * worker rebuilds every animated object from the channels through its own
+ * up-axis conversion and parent chain, then sets each of these frames, reads
+ * its own world matrices back, and refuses the job if they do not match the
+ * browser's: a refusal instead of a plausible clip with the motion in the
+ * wrong place. Five frames are enough (a convention error shows on the
+ * first, an axis error on any, a drift on the last) and cost eighty numbers
+ * per target.
+ */
+type WorldCheck = {
+    target: AnimationTarget;
+    /** Frame indices, ascending, each in `[0, frameCount)`. */
+    frames: number[];
+    /** `frames.length * 16` numbers. */
+    matrices: number[];
+};
+
+/**
+ * Room presets: a staged interior the renderer rebuilds by itself.
+ *
+ * A room preset is a whole set: walls with windows, a floor, a pedestal,
+ * the furniture along the walls, the foliage outside the glass that dapples
+ * the sunlight, a designed lighting rig per mode. The browser shows a
+ * compressed stand-in of it (one small GLB from the preset library) so the
+ * developer can frame their product inside it; none of that geometry is
+ * captured. The manifest carries only this record (which room, which build
+ * of it, which lighting, which surfaces, which stand, where it sits), and
+ * the worker rebuilds the room from its own full-resolution copy of the
+ * definition. A room render uploads exactly what a bare product render
+ * uploads: the product.
+ *
+ * Two versions guard the pixels. `build` is the content hash of the
+ * published room definition the SDK previewed; a worker whose copy hashes
+ * differently refuses rather than rendering a room that is not the one on
+ * screen. `ROOM_PRESET_VERSION` covers the worker's room builder.
+ */
+
+declare const ROOM_LIGHTING_MODES: readonly ["day", "golden", "overcast", "night"];
+type RoomLightingMode = (typeof ROOM_LIGHTING_MODES)[number];
+/** A preset material plus an optional sRGB hex tint multiplied into albedo. */
+type RoomSurfaceChoice = {
+    material: string;
+    /** `#rrggbb`. Plaster and paint take a tint well; a plank floor less so. */
+    color?: string;
+};
+/**
+ * What the manifest says about the room. Every field except `name`, `build`,
+ * `lighting` and `matrix` is an override on the published defaults; absent
+ * means "the room's own".
+ */
+type RoomPresetSpec = {
+    /** The published room, e.g. `loft_golden`. */
+    name: string;
+    /** Content hash (12 hex) of the published definition. See above. */
+    build: string;
+    lighting: RoomLightingMode;
+    surfaces?: {
+        floor?: RoomSurfaceChoice;
+        walls?: RoomSurfaceChoice;
+        ceiling?: RoomSurfaceChoice;
+        /** Window sills: stone or timber. No tint; sills are never painted. */
+        sill?: {
+            material: string;
+        };
+    };
+    /**
+     * What the product stands on. `null` puts nothing under it (the developer
+     * placed their own stand, or the product sits on the floor); absent keeps
+     * the room's stand. `material` applies to a baked pedestal only; a table
+     * used as a stand keeps the finish it came with.
+     */
+    pedestal?: {
+        type: string;
+        material?: string;
+    } | null;
+    /**
+     * How much of the room the browser shipped, so the worker does not build
+     * it twice. Normally none of the room's geometry crosses the wire.
+     *
+     * `true`: the whole stand-in is in the GLB, the shell, the stand and the
+     * furniture. A bake can then lightmap the room's own surfaces, because a
+     * lightmap has to land on a mesh the page holds. The worker builds only
+     * what the stand-in cannot carry: the sky, the sun, the portals, the
+     * foliage outside the glass, the fixtures' light and the panes.
+     *
+     * `'stand'`: only the stand is in the GLB, and the worker builds the room
+     * around it at full quality. This is what a bake into a prebaked room
+     * asks for: that bake lightmaps nothing of the room but the stand, so the
+     * light bouncing around the product should come off the real room, not
+     * off the browser's compressed preview of it.
+     */
+    standIn?: boolean | 'stand';
+    /**
+     * The HDRI outside the windows: an `HDRI_PRESETS` name to put another map
+     * there than the room's published one for this mode, turned so its sun
+     * sits where the room's sun is; `null` for nothing outside (the mode's
+     * plain sky); absent keeps the room's own. In day and golden the room's
+     * sun lamp still casts the direct light; the map is the sky's light and
+     * the view, projected onto the ground.
+     */
+    hdri?: string | null;
+    /**
+     * Pictures of the developer's own in the room's frames, one entry per
+     * picture the room hangs, in the order it hangs them. A `sha256:` asset
+     * hash puts that image in that frame; `null` or a short list leaves the
+     * rest as published.
+     *
+     * The frame does not move. A picture's moulding, its passepartout and the
+     * opening they leave were built to the published image's shape, and the
+     * browser shows that geometry while the developer frames the shot, so a
+     * replacement is cropped to fill the opening (the way `object-fit: cover`
+     * fills a box) rather than resizing the frame around it.
+     */
+    pictures?: (string | null)[];
+    /** The room group's world matrix, three.js column-major. */
+    matrix: Matrix4;
+};
+
+/**
+ * One node. `inputs` are ids of earlier nodes: the array arrives
+ * topologically sorted, so the worker builds it in one pass. Constants are
+ * nodes too, so every input is a reference and nothing is written twice.
+ */
+type ShaderGraphNode = {
+    id: string;
+    op: string;
+    inputs?: string[];
+    params?: Record<string, number | string | boolean | number[]>;
+};
+/**
+ * Which BSDF slot a graph output drives. Everything not listed here falls
+ * back to the material's static properties.
+ */
+type ShaderSlot = 'color' | 'opacity' | 'alphaTest' | 'roughness' | 'metalness' | 'normal' | 'emissive' | 'ao' | 'clearcoat' | 'clearcoatRoughness' | 'sheen' | 'sheenRoughness' | 'iridescence' | 'iridescenceIOR' | 'iridescenceThickness' | 'transmission' | 'thickness' | 'ior' | 'specularIntensity' | 'specularColor' | 'anisotropy';
+type ShaderGraph = {
+    version: number;
+    /** Topologically sorted: a node's inputs always precede it. */
+    nodes: ShaderGraphNode[];
+    /** Which node feeds which BSDF slot. */
+    outputs: Partial<Record<ShaderSlot, string>>;
+};
+/**
+ * The static, non-graph half of the material: plain PBR values for every
+ * slot no node drives. Captured in full because the glTF exporter does not
+ * understand node materials, so the worker rebuilds this material from
+ * scratch rather than patching whatever the exporter guessed.
+ */
+type ShaderMaterialProperties = {
+    color?: string;
+    roughness?: number;
+    metalness?: number;
+    emissive?: string;
+    emissiveIntensity?: number;
+    opacity?: number;
+    transparent?: boolean;
+    alphaTest?: number;
+    ior?: number;
+    transmission?: number;
+    thickness?: number;
+    attenuationColor?: string;
+    attenuationDistance?: number;
+    clearcoat?: number;
+    clearcoatRoughness?: number;
+    sheen?: number;
+    sheenColor?: string;
+    sheenRoughness?: number;
+    specularIntensity?: number;
+    specularColor?: string;
+    iridescence?: number;
+    iridescenceIOR?: number;
+    anisotropy?: number;
+    doubleSided?: boolean;
+};
+/**
+ * One node material, ready to rebuild. Matched to the mesh by the material's
+ * uuid, which the SDK stamps through the exporter the same way object ids
+ * are.
+ */
+type MaterialShaderSpec = {
+    materialId: string;
+    name?: string;
+    /** Which BSDF family the material declared. */
+    base: 'standard' | 'physical' | 'basic';
+    properties?: ShaderMaterialProperties;
+    graph: ShaderGraph;
+};
+
+/**
+ * The scene manifest: a GLB plus a versioned sidecar.
+ *
+ * glTF carries geometry, materials, textures, cameras, lights, skins and
+ * morph targets well. What it does not carry is the state the running
+ * application was in at the moment somebody pressed Render: which objects
+ * were hidden, which of four cameras was live, what the renderer's tone
+ * mapping was set to, which materials the SDK could not translate and what
+ * the developer wants done about them. So the GLB is an asset and this is
+ * the contract. `protocolVersion` is versioned independently of the SDK, of
+ * the renderer and of the material translator, which is what makes a render
+ * from six months ago reproducible.
+ *
+ * Everything here is JSON (no class instances, no functions) because it
+ * travels from the browser through the control plane to the render worker
+ * and is stored verbatim for replay.
+ */
+
+/** `sha256:<64 hex>`: how every immutable blob is named. See asset.ts. */
+type AssetHash = string;
+type Vec3 = [number, number, number];
+/** glTF order: x, y, z, w. Any conversion to another order happens in the worker. */
+type Quat = [number, number, number, number];
+type Matrix4 = number[];
+/**
+ * The active camera.
+ *
+ * Written out in full rather than referenced into the GLB by name: a live
+ * R3F camera is frequently not in the scene graph the exporter walked (it
+ * is held by `useThree`, or by drei's controls), so it travels as data.
+ */
+type CameraSpec = {
+    type: 'perspective';
+    /** Vertical FOV in degrees, matching three's `PerspectiveCamera.fov`. */
+    fov: number;
+    /**
+     * The viewport's aspect ratio at capture time.
+     *
+     * The render matches vertical fov, so a wider output shows more at the
+     * sides rather than cropping the top and bottom. Recorded so the
+     * control plane can default the output to the viewport's own shape.
+     */
+    aspect?: number;
+    near: number;
+    far: number;
+    position: Vec3;
+    quaternion: Quat;
+    /** three's `.zoom`, which scales the projection and is easy to forget. */
+    zoom?: number;
+    /** Present when the developer named a camera; only ever a label. */
+    name?: string;
+    /**
+     * Depth of field, off unless present. `fStop` is a full-frame f-number
+     * at this `fov`; `focalDistance` is in metres along the view axis.
+     * `target` is the world point it was measured to: a worker that reads
+     * it keeps that point sharp on every frame of a clip, and one that
+     * does not still focuses the first frame right.
+     */
+    focus?: {
+        fStop: number;
+        focalDistance: number;
+        target?: Vec3;
+    };
+} | {
+    type: 'orthographic';
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    near: number;
+    far: number;
+    position: Vec3;
+    quaternion: Quat;
+    zoom?: number;
+    name?: string;
+};
+/**
+ * What the application had done to the scene by render time.
+ *
+ * Visibility is an explicit hidden list rather than "export only what is
+ * visible" on purpose: the GLB is content-addressed and cached, and a
+ * configurator that toggles one part between renders would otherwise miss
+ * the cache every time. Ship one GLB with every variant in it, then hide
+ * per render: the first render uploads the model, the next one uploads a
+ * few KB.
+ */
+type RuntimeState = {
+    /** Object ids (see `objectId` in capture) the SDK found with `visible === false`. */
+    hiddenObjectIds?: string[];
+    /**
+     * Transform overrides, for objects the application moved after export or
+     * that were exported from a shared cached GLB.
+     */
+    transforms?: Array<{
+        objectId: string;
+        position?: Vec3;
+        quaternion?: Quat;
+        scale?: Vec3;
+    }>;
+    /** Morph target influences, by object. */
+    morphs?: Array<{
+        objectId: string;
+        influences: number[];
+    }>;
+    /** Current skeletal pose as bone-local matrices. */
+    poses?: Array<{
+        objectId: string;
+        boneMatrices: Matrix4[];
+    }>;
+    /**
+     * `InstancedMesh` transforms. Written here rather than baked into the GLB
+     * so changing a layout does not re-upload the geometry.
+     *
+     * `matrices` is flat: `count * 16` numbers, column-major, exactly as three
+     * stores `instanceMatrix.array`. Nested arrays would add two bytes of JSON
+     * per instance, which for a large scatter is a measurable part of the
+     * manifest.
+     */
+    instances?: Array<{
+        objectId: string;
+        count: number;
+        matrices: number[];
+    }>;
+    /**
+     * Opaque application state, echoed back on the render record. Never read
+     * by the renderer; it exists so a stored render can say which sofa.
+     */
+    productState?: Record<string, unknown>;
+};
+type EnvironmentSpec = {
+    /** An HDRI/EXR the SDK found on `scene.environment`, content-addressed. */
+    hdri?: AssetHash;
+    /** three's `Scene.environmentIntensity`. */
+    intensity?: number;
+    /** three's `Scene.environmentRotation`, radians, XYZ euler. */
+    rotation?: Vec3;
+    /**
+     * The scene's `AmbientLight`s as one flat term. It ADDS to the HDRI, as it
+     * does in three, and like three's it lights diffuse surfaces only: a
+     * mirror reflects the environment and nothing of this.
+     */
+    ambient?: {
+        color: string;
+        intensity: number;
+    };
+    /**
+     * Background. `transparent` is the default: a still that composites is
+     * worth more to a catalog pipeline than one with a baked backdrop.
+     */
+    background?: {
+        type: 'transparent';
+    } | {
+        type: 'color';
+        color: string;
+    } | {
+        type: 'environment';
+        blurriness?: number;
+    };
+    /** The scene's fog, when it has one the renderer can trace. */
+    fog?: FogSpec;
+};
+/**
+ * three's `FogExp2`, which the renderer traces as a volume filling the scene:
+ * air that scatters the light passing through it, so a lamp or an emissive
+ * mesh sits in a glow and throws visible beams.
+ *
+ * `density` is three's own number. three fades a surface by
+ * `exp(-(density · d)²)`; a real volume thins light by `exp(-σ · d)`. The
+ * two cannot agree at every distance, so the renderer uses σ = `density`,
+ * which makes them agree where three's fog has taken all but 1/e of the
+ * surface: nearer than that the render is a little foggier than the
+ * viewport, further a little clearer.
+ *
+ * `color` is the fog's TINT (`#rrggbb`, as three holds it): its hue colors
+ * the scattered light, its brightness is ignored. How bright traced fog
+ * looks is decided by the light in it, which a rasterizer's fog color has to
+ * guess. A linear `Fog` has no volume it corresponds to and is not carried;
+ * the compatibility report says so.
+ */
+type FogSpec = {
+    color: string;
+    density: number;
+};
+/**
+ * Lights the SDK lifted out of the scene graph.
+ *
+ * Exported here as well as in the GLB because glTF's punctual-lights
+ * extension has no notion of three's intensity-unit drift, no area lights
+ * and no IES. The sidecar is where the good version lives and the GLB copy
+ * is the fallback.
+ */
+type LightSpec = {
+    objectId: string;
+    type: 'directional' | 'point' | 'spot' | 'area' | 'hemisphere';
+    color: string;
+    /**
+     * three's own value, unconverted. The worker owns the unit conversion so
+     * the physics is written down in one place.
+     */
+    intensity: number;
+    /**
+     * World position. A hemisphere light's is its up axis instead (three
+     * normalizes it; absent is `[0, 1, 0]`).
+     */
+    position?: Vec3;
+    /**
+     * World point a directional, spot or area light aims at, as three's
+     * `light.target` (or `lookAt`) does. Absent aims a directional or spot
+     * light at the origin and leaves an area light facing straight down.
+     */
+    target?: Vec3;
+    /**
+     * Hemisphere lights only: the color from below (`groundColor`). `color` is
+     * the sky. Absent is black, a sky with no ground bounce.
+     */
+    groundColor?: string;
+    distance?: number;
+    decay?: number;
+    angle?: number;
+    penumbra?: number;
+    /** Area lights only, in world units. */
+    size?: {
+        width: number;
+        height: number;
+    };
+    /** Angular diameter in degrees: the shadow-softness dial for a sun. */
+    angleDeg?: number;
+    /** An IES profile, content-addressed. */
+    ies?: AssetHash;
+    castShadow?: boolean;
+};
+/**
+ * The renderer's own color settings, copied verbatim.
+ *
+ * This is the difference between a render that looks like the developer's
+ * app and one that is subtly, unfixably wrong. three's defaults changed in
+ * r152 and again in r155; reading the live renderer beats assuming any of
+ * them.
+ */
+type ColorSpec = {
+    outputColorSpace: 'srgb' | 'srgb-linear' | 'display-p3';
+    toneMapping: 'none' | 'linear' | 'reinhard' | 'cineon' | 'aces-filmic' | 'agx' | 'neutral';
+    toneMappingExposure: number;
+};
+/**
+ * What to do with a material the renderer cannot be given honestly.
+ *
+ * Arbitrary GLSL does not translate, and the answer is to say so rather
+ * than quietly render gray. A fallback is the developer's explicit
+ * override, from `<Bakery3Material render={...}>` or from
+ * `material.userData.bakery3.fallback`.
+ */
+type MaterialFallback = {
+    /** The material's uuid in the exported GLB. */
+    materialId: string;
+    type: 'physical';
+    color?: string;
+    metalness?: number;
+    roughness?: number;
+    clearcoat?: number;
+    clearcoatRoughness?: number;
+    transmission?: number;
+    thickness?: number;
+    ior?: number;
+    emissive?: string;
+    emissiveIntensity?: number;
+    opacity?: number;
+    sheen?: number;
+    sheenColor?: string;
+    iridescence?: number;
+    anisotropy?: number;
+};
+type CompatibilitySeverity = 'info' | 'warning' | 'error';
+/**
+ * One thing the SDK could not promise to reproduce: what it is, where it
+ * lives in the tree, why, and the fix, without opening a debugger.
+ */
+type CompatibilityIssue = {
+    code: string;
+    severity: CompatibilitySeverity;
+    message: string;
+    /** `<Car>/<Body>/<Paint>`: the path a developer can actually find. */
+    path?: string;
+    objectId?: string;
+    materialId?: string;
+    materialName?: string;
+    materialType?: string;
+    /** Deep link into the docs. */
+    docs?: string;
+};
+type CompatibilityReport = {
+    /** 0 to 1. Objects that will render faithfully, weighted by triangle count. */
+    score: number;
+    issues: CompatibilityIssue[];
+    /** Rolled up for the devtools panel and the render record. */
+    counts: {
+        info: number;
+        warning: number;
+        error: number;
+    };
+};
+/** Presets, not raw renderer settings. Most scenes need only these. */
+type QualityPreset = 'preview' | 'studio' | 'ultra';
+type OutputFormat = 'png' | 'jpeg' | 'webp' | 'exr' | 'mp4' | 'webm' | 'png-sequence';
+/** `frames.json`, at the head of a `png-sequence` tar. */
+type FrameSequenceIndex = {
+    fps: number;
+    frameCount: number;
+    width: number;
+    height: number;
+    bitDepth: 8 | 16;
+    /** In frame order, one per frame: `frameFileName(0)` onwards. */
+    files: string[];
+};
+type OutputSpec = {
+    width: number;
+    height: number;
+    format: OutputFormat;
+    /** JPEG/WebP only, 1 to 100. */
+    quality?: number;
+    /**
+     * PNG and `png-sequence` only: bits per channel, 16 unless 8 is asked
+     * for (`PNG_BIT_DEPTH_DEFAULT`).
+     */
+    bitDepth?: 8 | 16;
+    /** Force an opaque background even when the environment is transparent. */
+    opaque?: boolean;
+};
+/**
+ * Escape hatch under the presets. Present so an expert is never blocked,
+ * absent from the quickstart so a beginner is never asked to become a
+ * rendering expert to get one image.
+ */
+type AdvancedRenderSettings = {
+    samples?: number;
+    maxBounces?: number;
+    diffuseBounces?: number;
+    glossyBounces?: number;
+    transmissionBounces?: number;
+    /** Adaptive sampling noise floor: the real cost dial once denoising is on. */
+    adaptiveThreshold?: number;
+    denoise?: boolean;
+    denoiser?: 'OPTIX' | 'OPENIMAGEDENOISE';
+    /** Pays for itself with many emitters, costs overhead with few. */
+    lightTree?: boolean;
+    /**
+     * Light that reaches a surface through glass: the bright pool under a
+     * tumbler, the focus line beneath a lens. Off by default: with no caustic
+     * paths a transmissive object casts a solid shadow, which is also what the
+     * viewport's shadow maps draw, and tracing them costs samples a product
+     * shot rarely needs.
+     *
+     * `'soft'` lets the path tracer find caustic paths itself, with the glossy
+     * filter and the indirect clamp (both of which exist to hide caustics)
+     * switched off. Unbiased, and slow to converge: a hard light through
+     * curved glass stays grainy at studio samples.
+     *
+     * `'sharp'` adds a dedicated shadow-caustic solver on top: every scene
+     * lamp casts caustics, every transmissive mesh is a caster, and every
+     * other mesh (the shadow catcher included) receives them. This is what
+     * makes a glass on a table converge at normal sample counts. It handles a
+     * single refractive object between a lamp and a surface; light from an
+     * HDRI or an emissive mesh still goes the `'soft'` way.
+     *
+     * The solver takes over lamp light through a caster rather than adding to
+     * the traced paths, and it only follows light that goes straight through.
+     * A faceted stone, whose light leaves after internal reflections, comes
+     * back under `'sharp'` with no caustic at all. Cut gems want `'soft'`.
+     *
+     * Absent is off. There is no boolean on purpose: `caustics: true` would
+     * have to mean one of the two. Changes pixels, so it is in the cache key.
+     */
+    caustics?: 'soft' | 'sharp';
+    /**
+     * A ceiling on how bright one indirect sample may be, in scene radiance.
+     * Absent is the renderer's own default, which `caustics` switches off: a
+     * caustic's focus is a very bright indirect sample, and capping it dims
+     * the focus. That is right for a still and wrong for a clip, because the
+     * rare uncapped hit lands on different pixels every frame, the denoiser
+     * smears each one into a soft patch, and the patches boil. For caustics
+     * in motion, start at 30 (the pool under a lens is still its full
+     * brightness there) and trace larger than you publish.
+     *
+     * Set, it wins over what `caustics` would have chosen. Changes pixels, so
+     * it is in the cache key, present only when set.
+     */
+    clampIndirect?: number;
+    /**
+     * Multiplies the converted energy of every light lifted from the scene
+     * graph (directional, point, spot, area and the ambient dome) and leaves
+     * the HDRI environment alone. The worker's unit table is physics and stays
+     * fixed; this dial is for the residual gap, where a viewport (legacy-lights
+     * intensities, usually) reads brighter than the physically converted lamps
+     * do. One scalar, so the ratio between the scene's lights is preserved.
+     * Default 1. Changes pixels, so it is in the cache key.
+     */
+    lightScale?: number;
+    /**
+     * Ground the product with a traced shadow catcher. Defaults on for
+     * transparent/solid output and off for a visible environment background.
+     */
+    shadowCatcher?: boolean;
+    /** Catcher size, as a multiple of the model's largest dimension. */
+    shadowPad?: number;
+    /**
+     * The renderer's view transform override. Changes pixels, so it is in the
+     * cache key. Pinning one also switches off `toneCurveEmulation`: an
+     * explicit name is a statement about what the render should look like.
+     */
+    viewTransform?: string;
+    /**
+     * Reproduce three's tone mapping exactly instead of substituting the
+     * nearest native view transform. On by default, and it is what makes a
+     * traced frame the same color as the viewport it came from.
+     *
+     * Turn it off to get the substitution: a wider, more forgiving curve for a
+     * scene whose viewport was never the reference. Changes pixels, so it is
+     * in the cache key.
+     */
+    toneCurveEmulation?: boolean;
+    /** Seconds. The worker stops the render rather than billing an unbounded job. */
+    timeoutSeconds?: number;
+};
+/**
+ * Everything one render needs, minus the bytes.
+ *
+ * Typically a few KB. The heavy things (the GLB, textures, the HDRI) are
+ * `sha256:` references that the control plane resolves against storage the
+ * SDK already filled (see asset.ts).
+ */
+type SceneManifest = {
+    protocolVersion: string;
+    sdkVersion: string;
+    /** The exported GLB. */
+    sceneAsset: AssetHash;
+    /**
+     * Extra blobs this scene needs that are not inside the GLB: an HDRI, an
+     * IES profile, a texture the SDK stripped out to keep the GLB cacheable.
+     */
+    assets?: AssetHash[];
+    camera: CameraSpec;
+    runtime?: RuntimeState;
+    environment?: EnvironmentSpec;
+    lights?: LightSpec[];
+    color: ColorSpec;
+    fallbacks?: MaterialFallback[];
+    /**
+     * Node materials, as portable shader graphs (see shader.ts). The GLB still
+     * carries the mesh; the material the exporter wrote for it is a stand-in
+     * that the worker replaces wholesale with the rebuilt graph.
+     */
+    shaders?: MaterialShaderSpec[];
+    /**
+     * Baked per-frame motion (see animation.ts). Present only for a video,
+     * and its presence is what makes this a 3.0 manifest.
+     *
+     * Not inside `runtime` on purpose: runtime is the one state the
+     * application was in when Render was pressed, and every field in it is a
+     * single value. A sequence is a different kind of thing.
+     */
+    animation?: AnimationSpec;
+    /**
+     * A room preset around the product (see room.ts). Its geometry, lights
+     * and sky are not in the GLB or in `lights`: the worker rebuilds all of it
+     * from the published definition, so a product in a room uploads only the
+     * product. Presence makes this a 4.0 manifest.
+     */
+    room?: RoomPresetSpec;
+    compatibility?: CompatibilityReport;
+    /**
+     * What the scene weighs, measured by the SDK at capture. The control plane
+     * prices with it (a dense scene traces slower per pixel and unwraps slower
+     * per object), so the quote a job is accepted under is the same one
+     * `estimate()` gave with the same numbers. Operational, not visual: it is
+     * outside every cache key.
+     */
+    stats?: {
+        triangles: number;
+        /** Bytes of texture the manifest's shader graphs sample, when known. */
+        textureBytes?: number;
+        /**
+         * Distinct materials that emit light: a standard material with a
+         * non-black emissive color, an unlit material (rendered as emission), or
+         * a node material with an emission graph. The worker turns its light
+         * tree on from this. Only the SDK can count them, since the GLB's
+         * materials are opaque to the control plane.
+         */
+        emitters?: number;
+        /**
+         * How much of the sky above the camera the scene's geometry hides, 0 for
+         * an open set and 1 inside a closed room (`SceneComplexity`). Walls keep
+         * light bouncing, which is most of what makes an interior slow to render,
+         * so the quote reads it. A preset room's stand-in counts, though it is not
+         * uploaded: it stands for the room the renderer builds.
+         */
+        enclosure?: number;
+        /** Meshes the scene draws, instances counted: how full it is. */
+        objects?: number;
+    };
+    /**
+     * Where the scene came from. Diagnostics only, but "which three version"
+     * is the first question every support conversation starts with.
+     */
+    source?: {
+        three?: string;
+        r3f?: string;
+        renderer?: string;
+        userAgent?: string;
+    };
+};
+/** A manifest plus what to make from it. This is the render request body. */
+type RenderSpec = {
+    manifest: SceneManifest;
+    quality: QualityPreset;
+    output: OutputSpec;
+    advanced?: AdvancedRenderSettings;
+    /**
+     * Hard ceiling in USD. Exceeded at estimate time means the job is refused
+     * before it is admitted: `RenderBudgetExceeded`, not a surprise bill.
+     */
+    maxCost?: number;
+    /** Emit a low-sample preview partway through. On by default for `studio`. */
+    preview?: boolean;
+    /** Echoed on the render record and every webhook. */
+    metadata?: Record<string, unknown>;
+    /**
+     * A resubmit with the same key returns the existing render while it is
+     * running or once it has completed, never a second charge. This is what
+     * makes the SDK's own retries safe. A key whose render failed, was
+     * cancelled or expired is free again: nothing was charged, and the
+     * resubmit renders.
+     */
+    idempotencyKey?: string;
+    /**
+     * `high` puts this render ahead of the account's other waiting work in
+     * the same lane: the hero shot before the rest of the queue. It never
+     * jumps a lane; a person waiting still goes first.
+     */
+    priority?: 'normal' | 'high';
+};
+
+/**
+ * How good a bake should be. The worker chooses sample counts and margins
+ * from this, the way `QualityPreset` maps to `QualitySettings`.
+ */
+type BakeQuality = 'preview' | 'standard' | 'high';
+/** The sides a lightmap or a stand-in texture may have, in texels. */
+declare const BAKE_TEXTURE_SIZES: readonly [256, 512, 1024, 2048];
+type BakeTextureSize = (typeof BAKE_TEXTURE_SIZES)[number];
+/** Atlas sides. 4096² is 16.8M texels, inside the texel ceiling on its own. */
+declare const BAKE_ATLAS_SIZES: readonly [1024, 2048, 4096];
+type BakeAtlasSize = (typeof BAKE_ATLAS_SIZES)[number];
+/**
+ * One lightmap for every baked object, rather than one each.
+ *
+ * A room of sixty objects lit from sixty textures is sixty texture binds and
+ * sixty downloads; lit from one atlas it is one of each, which is what an
+ * interactive scene wants. The atlas holds the same texels the separate maps
+ * would, and is priced as they are.
+ *
+ * Every object is baked into a square of its own: the side its world-space
+ * surface earns, capped by `textureSize` and `sizes` as usual, times the
+ * square root of its `weight`, rounded to a power of two. The squares are
+ * laid into the map with no waste, and the map is filled: when the squares
+ * would cover under a quarter of it every side doubles, and when they would
+ * not fit the largest are halved until they do. So `textureSize`, `sizes`
+ * and `weights` set relative shares, kept to within a power of two, and
+ * `size` sets the texels there are to share.
+ *
+ * A hero product is `weights: { [heroId]: 4 }`: twice the side and four times
+ * the area its surface alone would earn. Weights round to the nearest power
+ * of two in side: 1.5 to 2.8 doubles it, 2.9 to 5.6 quadruples it.
+ */
+type BakeAtlas = {
+    size: BakeAtlasSize;
+    /** Per-object density multipliers, keyed by objectId. Default 1. */
+    weights?: Record<string, number>;
+};
+/**
+ * What a group of objects is replaced with in the baked scene.
+ *
+ * A lightmap keeps the developer's geometry and changes its light. That is
+ * right for a product and wrong for a bookcase of forty books at the back of
+ * the room: forty draw calls, forty lightmaps and forty unwraps to light
+ * something the viewer reads as one lit shape. A stand-in is that one shape,
+ * with the detail it lost baked on: the color of the surface it replaces, a
+ * normal map for the relief it no longer has, and the irradiance traced at
+ * the real surface. The real objects stay in the traced scene, so they still
+ * cast their shadows and bounce their light onto everything else; they are
+ * only absent from what is delivered.
+ *
+ *   `'lowpoly'`    the objects, shrink-wrapped into one skin and reduced to
+ *                  `triangles`. The default.
+ *   `'box'`        the box round them, turned about the vertical to fit.
+ *                  Right for anything that reads as a box from where it is
+ *                  seen: a bookcase, a cabinet, a radiator.
+ *   `'billboard'`  one upright picture of them that turns to face the
+ *                  camera. For a potted plant: half a million triangles of
+ *                  leaves that no lightmap suits and no box resembles.
+ *   `{ objectId }` a mesh of the developer's own, in the captured scene and
+ *                  hidden (so nothing traces it), used as the stand-in's
+ *                  shape exactly as authored.
+ *   `'decimate'`   one object, the same object with fewer triangles: its own
+ *                  parts, silhouette, texture uvs and materials kept, reduced
+ *                  to `triangles` by collapsing edges. For the product itself
+ *                  (a 146k-triangle shoe), where a skin would melt laces and
+ *                  eyelets together and a baked color would turn metal and
+ *                  gloss into paint. Only its light is baked, in one pass at
+ *                  the real surface; the stand-in wears the replaced object's
+ *                  own materials at their own resolution. One entry per
+ *                  object.
+ */
+type BakeSimplifyTo = 'lowpoly' | 'box' | 'billboard' | 'decimate' | {
+    objectId: string;
+};
+type BakeSimplify = {
+    /**
+     * objectIds the stand-in replaces. They are not in `include`: a replaced
+     * object gets no lightmap of its own, which is where the saving is.
+     */
+    objects: string[];
+    to: BakeSimplifyTo;
+    /** `'lowpoly'` only: the triangle budget. Default `BAKE_SIMPLIFY_TRIANGLES`. */
+    triangles?: number;
+    /** The stand-in's texture side. Default `textureSize`. */
+    textureSize?: BakeTextureSize;
+};
+/**
+ * A plane under the baked objects carrying the difference they make to the
+ * light on it, and nothing else.
+ *
+ * A preset room is the same room for every customer, so its lightmaps are a
+ * library asset, baked once and served from the preset library
+ * (`BakeBundle.room`). What that prebaked room cannot know is the product
+ * standing in it: the contact shadow under a vase is what makes it look like
+ * it is in the room rather than pasted over it.
+ *
+ * So the bake traces one small plane just above the floor twice, with the
+ * product and its stand present and again with them hidden, and ships the
+ * ratio: 1 where they changed nothing, darker where they blocked light. The
+ * viewer lays it over the floor and multiplies. A ratio, not irradiance,
+ * because it has to compose with a floor lightmap traced at another time and
+ * another resolution.
+ *
+ * It only darkens. Light the product throws onto the floor (a red vase's
+ * bounce) is in neither the prebaked room nor this plane; that is the
+ * approximation this mode makes.
+ */
+type BakeShadow = {
+    /**
+     * Scene units, Y-up: the plane's centre, on the surface it lies over.
+     *
+     * Absent is the usual case: the worker measures the footprint of whatever
+     * casts, then finds the surface beneath with rays cast straight down and
+     * the casters hidden. A plinth is often modelled a centimetre into the
+     * floor, so the bottom of its bounds is inside the slab, where a plane
+     * would be lit in neither trace.
+     */
+    center?: [number, number, number];
+    /**
+     * Metres. Absent takes the casters' footprint plus the room a shadow needs
+     * to spread into.
+     */
+    width?: number;
+    height?: number;
+    /**
+     * How far above the surface the plane sits, in metres. Small enough to
+     * read as contact, large enough that nothing z-fights with the floor.
+     */
+    lift?: number;
+    /** Texels a side. Default `BAKE_SHADOW_SIZE`. */
+    textureSize?: BakeTextureSize;
+    /**
+     * objectIds whose shadow this is: hidden for the second trace. Absent
+     * means every object the bake includes.
+     */
+    cast?: string[];
+    /**
+     * objectIds the plane is placed beneath and sized to cover. Absent means
+     * the casters, which is the usual case.
+     *
+     * The two lists come apart when a product stands on something this bake is
+     * lightmapping anyway. A vase on a plinth casts on the plinth's top, and
+     * the plinth's own lightmap carries that. What the plinth must not do is
+     * cast into this plane: the prebaked room was lit with the plinth standing
+     * in it, so its shadow is already on that floor, and casting it again
+     * would lay it down twice.
+     *
+     * So the plinth spans but does not cast. It is present in both traces and
+     * divides out of the ratio exactly, leaving only what the vase adds; and
+     * because it is hidden while the surface beneath is looked for, the plane
+     * still lands on the floor rather than on the plinth's top.
+     */
+    spans?: string[];
+};
+/**
+ * What the bake produced for `BakeSettings.shadow`.
+ *
+ * `uri` is a ratio in 0..1 per channel, linear, one value per texel: what
+ * fraction of the light still arrives with the product there. Lay the plane
+ * at `center` + `lift` on its up axis, map this across it, and multiply.
+ */
+type BakedShadow = {
+    uri: string;
+    format: 'exr' | 'png';
+    size: number;
+    center: [number, number, number];
+    width: number;
+    height: number;
+    lift: number;
+    /**
+     * The darkest ratio in the map, for a panel and for a sanity check: a
+     * shadow that came out 1.0 everywhere means nothing was cast.
+     */
+    darkest: number;
+};
+/**
+ * What to bake and how well.
+ *
+ * `include` is explicit and authoritative: the SDK decides which objects can
+ * take a lightmap (it can see the live materials; the worker cannot) and the
+ * worker bakes exactly that list. An id the worker cannot find is a refusal
+ * with the id and a fix, never a silent skip.
+ */
+type BakeSettings = {
+    quality: BakeQuality;
+    /**
+     * Per-object resolution ceiling. The worker may choose a smaller size for
+     * a small object (by world-space surface area) so a screw does not cost
+     * what a wall costs. It never chooses larger.
+     */
+    textureSize: BakeTextureSize;
+    /** objectIds to bake, from the same id space as `RuntimeState`. */
+    include: string[];
+    /** Per-object override of `textureSize`, keyed by objectId. */
+    sizes?: Record<string, BakeTextureSize>;
+    /**
+     * Bake every object into one shared lightmap of `atlas.size`² texels
+     * instead of one texture each: see `BakeAtlas`. `textureSize` and `sizes`
+     * then set each object's relative share of the map rather than its own
+     * texture.
+     */
+    atlas?: BakeAtlas;
+    /** Seam dilation in pixels. Default 4. */
+    margin?: number;
+    /**
+     * Also produce the portable baked GLB: every baked object with an unlit
+     * material (`KHR_materials_unlit`) whose one texture is the finished
+     * surface (color, direct and bounced light, reflections as seen from
+     * `view`, through the scene's tone curve). Loads anywhere with no lights
+     * and no SDK. A second bake pass per object, so it roughly doubles GPU
+     * time and is opt-in.
+     */
+    deliverGlb?: boolean;
+    /**
+     * Objects whose `uv1` is the developer's own layout, not one a previous
+     * bake wrote. Present, the worker may use an object's own layout instead
+     * of unwrapping it: its `uv1` when listed here, its texture `uv` when the
+     * mesh is too fragmented or too dense to unwrap well. Either is used only
+     * when it passes the worker's test (inside the unit square, no stacked
+     * islands, enough texels an island, an even density), and the result says
+     * so with `BakeUv` `channel`. Absent, every object is unwrapped.
+     */
+    existingUv?: {
+        uv1: string[];
+    };
+    /**
+     * Where the scene is looked at from, for seam placement only.
+     *
+     * The unwrap puts island boundaries on the side of each object that faces
+     * away from this point, on its underside, or where it is hidden behind
+     * other geometry, never across the surface this viewpoint sees. Nothing
+     * about the lighting depends on it.
+     *
+     * It is not the manifest camera. The camera is excluded from the bake
+     * cache key so that orbiting and baking again is free, and a seam layout
+     * that followed the exact camera would make every orbit a re-cut. The SDK
+     * sends the camera quantized (`quantizeBakeView`): direction in 30° steps,
+     * distance in octaves around the baked objects, so nearby viewpoints share
+     * a bake and only a real change of side re-cuts.
+     *
+     * Absent: seams prefer the underside and hard edges alone.
+     */
+    view?: BakeView;
+    /**
+     * Where the reflection probe is taken, and what is hidden from it.
+     *
+     * Every bake delivers one. The lightmap replaces a baked surface's
+     * diffuse, but the objects the bake is for (the product kept live on its
+     * plinth, so it can turn and change finish) still reflect the scene's own
+     * environment map, which in a baked room is not the room. The probe is the
+     * room as seen from where those objects stand, with those objects hidden
+     * so they do not reflect themselves, and the SDK puts it on their
+     * materials as `envMap`.
+     *
+     * The SDK decides both fields: the objects it hides are the ones that
+     * could have been baked and were deliberately left out. An object that
+     * cannot take a lightmap at all (a glass sphere, an instanced hedge) is
+     * scenery and stays in the map, so the product reflects the glass beside
+     * it. Absent, the worker takes the probe from the center of the baked
+     * objects and hides nothing.
+     */
+    probe?: BakeProbe;
+    /**
+     * Groups of objects to deliver as a stand-in rather than light as they
+     * are: see `BakeSimplify`. In request order; stand-in `n` of the bundle is
+     * entry `n` here.
+     */
+    simplify?: BakeSimplify[];
+    /**
+     * Trace a shadow plane under the baked objects: see `BakeShadow`. What a
+     * bake of a product standing in a prebaked room needs, and the only part
+     * of that room the bake has to pay for.
+     */
+    shadow?: BakeShadow;
+    /**
+     * How a preset room in the scene is lit.
+     *
+     * `'full'` (the default) bakes the room's own surfaces along with
+     * everything else.
+     *
+     * `'preset'` says the room is unmodified, so its lightmaps are a library
+     * asset and this bake covers only what the library cannot know: the
+     * product, the stand it is on, and the shadow it casts. The SDK only asks
+     * for it when the room really is unmodified, and the worker records which
+     * room the result stands on (`BakeBundle.room`).
+     */
+    room?: 'full' | 'preset';
+};
+/** A viewpoint, in the scene's own (Y-up, meters) coordinates. */
+type BakeView = {
+    position: [number, number, number];
+};
+/** The reflection probe's request: where, and what not to see. */
+type BakeProbe = {
+    /** Scene units, Y-up: the center of the objects the probe is for. */
+    position: [number, number, number];
+    /** objectIds hidden from the probe: the objects it will be applied to. */
+    hide: string[];
+};
+/**
+ * A manifest plus what to bake from it: the bake request body. The manifest
+ * is the ordinary capture, camera included but unused by the bake itself, so
+ * two captures that differ only by viewpoint hit the same bake cache entry.
+ */
+type BakeSpec = {
+    manifest: SceneManifest;
+    bake: BakeSettings;
+    advanced?: {
+        timeoutSeconds?: number;
+    };
+    /**
+     * Triangles in the objects `bake.include` names, for the quote only.
+     *
+     * The estimate has two triangle terms: syncing the whole scene (priced from
+     * the manifest's own count) and unwrapping the objects being baked (priced
+     * from this). Without it the unwrap term is priced against the whole
+     * scene, which over-quotes a partial bake of a big room. The SDK sends it;
+     * a request without it is quoted the higher way.
+     *
+     * Deliberately not inside `bake`: that object is the bake cache key, and a
+     * number that only moves a price must not move what is cached.
+     */
+    bakedTriangles?: number;
+    /**
+     * Hard ceiling in USD, refused at estimate time. The same contract as
+     * `RenderSpec.maxCost`.
+     */
+    maxCost?: number;
+    metadata?: Record<string, unknown>;
+    idempotencyKey?: string;
+};
+/**
+ * The second UV set for one object, in the live geometry's own vertex order.
+ *
+ * `values` alone: `2 * vertexCount` floats, writable straight into a `uv1`
+ * BufferAttribute on the existing geometry. The common case, and the one
+ * that leaves the developer's geometry object untouched.
+ *
+ * `topology`: the unwrap needed vertex splits. `vertexSource[i]` names the
+ * original vertex that new vertex `i` was copied from, so every original
+ * attribute (custom ones included) can be gathered through it and nothing
+ * the developer authored is lost in the rebuild. `index` is the new triangle
+ * list over the new vertices.
+ */
+type BakeUv = {
+    values: number[];
+} | {
+    topology: {
+        vertexSource: number[];
+        index: number[];
+        values: number[];
+    };
+}
+/**
+ * The lightmap is laid on a uv set the mesh already has: `0` is its
+ * texture uv (three's `uv`, glTF `TEXCOORD_0`), `1` its second set (`uv1`,
+ * `TEXCOORD_1`). Nothing is shipped and nothing is rebuilt: the SDK points
+ * the lightmap at that attribute (`texture.channel`). Such a lightmap is
+ * written in the glTF orientation (v = 0 at the top), the one the
+ * attribute is in; every unwrap the worker ships itself is bottom-up.
+ * Only sent to an SDK that asked for it (`BakeSettings.existingUv`).
+ */
+ | {
+    channel: 0 | 1;
+};
+/**
+ * One baked object. `uri` is resolved against the bundle's own location: a
+ * relative path on disk, an absolute URL from a server.
+ */
+type BakedObject = {
+    objectId: string;
+    /** The object's name at capture time, for humans reading a bundle. */
+    name?: string;
+    /** HDR diffuse irradiance (direct + indirect, no albedo), linear. */
+    lightmap: {
+        uri: string;
+        format: 'exr' | 'png';
+        size: number;
+    };
+    /** Small LDR thumbnail for pickers and panels. */
+    preview?: {
+        uri: string;
+    };
+    uv: BakeUv;
+    /**
+     * How the surface was cut, measured by the worker, so a panel can say
+     * "2 islands, seams out of view" and mean it.
+     *
+     * `cut: 'hidden'` is the viewpoint-aware layout; `'angle'` is the plain
+     * angle-limited fallback, used when the hidden-seam layout failed its
+     * checks for this object (the job log says so too). `seamsInView` is the
+     * fraction of seam length across smooth surface whose both sides face
+     * `BakeSettings.view`; 0 is the goal. Seams on creases are not counted,
+     * because they do not show.
+     */
+    layout?: {
+        islands: number;
+        seamsInView?: number;
+        /**
+         * `'uv0'`/`'uv1'`: the object's own uv set, chosen over an unwrap
+         * because it passed the worker's layout test.
+         */
+        cut: 'hidden' | 'angle' | 'uv0' | 'uv1';
+    };
+    /**
+     * In an atlas bake: the fraction of the shared map this object's islands
+     * cover, which is what its budget and weight actually bought it.
+     */
+    atlasShare?: number;
+};
+/**
+ * One stand-in, ready to be put in the scene: see `BakeSimplify`.
+ *
+ * A mesh carries its geometry inline, in the scene's own coordinates (world
+ * space, Y-up, meters), because it is a few hundred vertices and a loader
+ * for it would weigh more than it does. `uv` is the one unwrap every map
+ * uses. `tangent` (xyzw) is the frame the normal map was baked in; a viewer
+ * that derives tangents from uv derivatives instead will be close, not
+ * exact. `color` is an sRGB PNG and `normal` a linear one, both the right
+ * way up for an ordinary image loader (`flipY` on); `lightmap` follows the
+ * lightmap contract above.
+ *
+ * A billboard is an upright rectangle `width` by `height` centered on
+ * `center`, to be turned about the vertical to face the camera, and `map` is
+ * linear radiance with alpha: the objects as traced from `BakeSettings.view`'s
+ * side, lit by the whole scene, with everything else cut away. It goes
+ * through the viewer's own tone mapping like everything around it.
+ */
+type BakedProxy = {
+    kind: 'mesh';
+    /** Index into `settings.simplify`. */
+    index: number;
+    replaces: string[];
+    name?: string;
+    geometry: {
+        position: number[];
+        normal: number[];
+        uv: number[];
+        tangent?: number[];
+        index: number[];
+    };
+    color: {
+        uri: string;
+    };
+    normal: {
+        uri: string;
+    };
+    lightmap: {
+        uri: string;
+        format: 'exr';
+        size: number;
+    };
+    /** The replaced surfaces' roughness and metalness, area weighted. */
+    roughness: number;
+    metalness: number;
+    layout?: BakedObject['layout'];
+} | {
+    /** `to: 'decimate'`: the replaced object with fewer triangles. */
+    kind: 'decimated';
+    index: number;
+    /** The one object it replaces, whose materials it wears. */
+    replaces: [string];
+    name?: string;
+    /**
+     * In the scene's frame, like a mesh stand-in's. `uv` is the object's
+     * own texture uv, carried through the decimation, in the glTF
+     * orientation its texture maps expect; `uv1` is present when the
+     * lightmap needed an unwrap of its own. `groups` are its material
+     * slots, in the order of the replaced mesh's materials.
+     */
+    geometry: {
+        position: number[];
+        normal: number[];
+        uv: number[];
+        uv1?: number[];
+        /** Its vertex colors (glTF COLOR_0), linear RGB, when it had them. */
+        color?: number[];
+        index: number[];
+        groups?: Array<{
+            start: number;
+            count: number;
+            materialIndex: number;
+        }>;
+    };
+    lightmap: {
+        uri: string;
+        format: 'exr';
+        size: number;
+    };
+    /** The uv set the lightmap reads: 0 is `uv`, 1 is `uv1`. */
+    lightmapChannel: 0 | 1;
+    triangles: {
+        from: number;
+        to: number;
+    };
+    layout?: BakedObject['layout'];
+} | {
+    kind: 'billboard';
+    index: number;
+    replaces: string[];
+    name?: string;
+    center: [number, number, number];
+    width: number;
+    height: number;
+    map: {
+        uri: string;
+        format: 'exr';
+        width: number;
+        height: number;
+    };
+};
+/**
+ * An object the bake did not produce, with the reason and the fix, per
+ * object: "the bake finished" must never quietly mean "except for the glass
+ * and the instanced chairs".
+ */
+type BakeSkip = {
+    objectId: string;
+    name?: string;
+    code: string;
+    message: string;
+    why?: string;
+    fix?: string;
+    /**
+     * The object was baked; this is a complaint about how well.
+     *
+     * An ordinary entry here means a lightmap was not made and the object is
+     * still lit the way it was. A `warning` means one was made and is worse
+     * than it should be. `BakeCoarseUnwrap` is the case: a surface whose
+     * geometry is far finer than the map it earns cuts into more islands than
+     * the map has room for, and the result is padding with a little light in
+     * it.
+     */
+    warning?: true;
+};
+/**
+ * Everything one bake produced. The bundle file is written last, so an
+ * interrupted bake never looks finished.
+ */
+type BakeBundle = {
+    bundleVersion: 1;
+    /** The `BAKE_VERSION` that produced this. */
+    bakeVersion: number;
+    settings: BakeSettings;
+    objects: BakedObject[];
+    skipped: BakeSkip[];
+    /**
+     * When `settings.atlas` was set: the one lightmap every object's
+     * `lightmap.uri` names, so a loader can fetch it once and share it. Each
+     * object's `uv` is already in the atlas's space.
+     */
+    atlas?: {
+        uri: string;
+        format: 'exr' | 'png';
+        size: number;
+        preview?: {
+            uri: string;
+        };
+        /** Fraction of the map's texels some island maps to: packing efficiency. */
+        coverage?: number;
+    };
+    /**
+     * The stand-ins `settings.simplify` asked for. One that could not be built
+     * is in `skipped` under the id `simplify[n]`, and the objects it would have
+     * replaced are left as they were.
+     */
+    proxies?: BakedProxy[];
+    /** The shadow plane `settings.shadow` asked for. */
+    shadow?: BakedShadow;
+    /**
+     * The prebaked room this bake stands its objects in: an unmodified preset
+     * room whose own lightmaps are a library asset, not something this bake
+     * paid for. The SDK fetches that bundle and applies it underneath this
+     * one. Absent from an ordinary bake, which lights everything it covers.
+     */
+    room?: {
+        /** The preset and the lighting it was baked under. */
+        name: string;
+        lighting: string;
+        /**
+         * The published room's build hash, which is what makes the prebake this
+         * room and not a later edit of it.
+         */
+        build: string;
+        /** Where the prebaked bundle is, on the preset library. */
+        uri: string;
+    };
+    /** The portable unlit GLB, when `deliverGlb` was set. */
+    glb?: {
+        uri: string;
+    };
+    /**
+     * The reflection probe: a linear HDR equirectangular map of the scene from
+     * `position`, in three's own equirect convention (load it, set
+     * `EquirectangularReflectionMapping`, and it is an `envMap`). `hidden` are
+     * the objects it was taken without, which are the ones to put it on.
+     */
+    probe?: {
+        uri: string;
+        format: 'exr';
+        width: number;
+        height: number;
+        position: [number, number, number];
+        hidden: string[];
+        /**
+         * The probe as an LDR picture, for a panel, a drawer or a figure: the
+         * same map through `exposure` (chosen by the worker to put its mean at
+         * middle gray), Reinhard and sRGB. A label on the file, not something to
+         * light with.
+         */
+        preview?: {
+            uri: string;
+            exposure?: number;
+        };
+    };
+    stats?: {
+        texels: number;
+        gpuSeconds?: number;
+        /**
+         * Where those seconds went, by step (`scene`, `probe`, `unwrap`,
+         * `trace`, `repair`, `denoise`, `export`, `standIns`), summed over the
+         * objects.
+         */
+        seconds?: Record<string, number>;
+    };
+};
+/**
+ * A bundle without its uv arrays and stand-in geometry: what a job result
+ * carries once the files are in storage. The arrays are the bulk of a bundle
+ * (a dense room's are megabytes) and belong in `bundle.json`, which the SDK
+ * reads from storage.
+ */
+type BakeBundleSummary = Omit<BakeBundle, 'objects' | 'proxies'> & {
+    objects: Array<Omit<BakedObject, 'uv'>>;
+    /** Stand-ins without their geometry, for the same reason. */
+    proxies?: Array<DistributiveOmit<BakedProxy, 'geometry'>>;
+};
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+
+/**
+ * A batch: a customer's declared body of work.
+ *
+ * A catalog is products x finishes x cameras, a few thousand stills. The
+ * customer opens a batch, adds items in pages, closes it, and reads one
+ * ledger back. On the control plane every item is a render row with a
+ * `batchId`, staged behind the queue proper and fed into it a page at a
+ * time, so everything that holds for a render (the claim, the reservation,
+ * single billing, webhooks, retention) holds for an item because it is one.
+ */
+
+declare const BATCH_STATES: readonly ["open", "sealed", "paused", "completed", "cancelled"];
+type BatchState = (typeof BATCH_STATES)[number];
+/**
+ * How many items are in each state. `staged` items are admitted: priced,
+ * reserved, waiting behind the queue proper. `queued` are in the queue and
+ * `running` hold a worker. `refused` failed for a reason a retry would not
+ * change (the scene's fault, or ours to explain); `failed` ran out of
+ * attempts on an infrastructure failure. `adopted` were already completed
+ * under the same key when they were added and cost nothing.
+ */
+type BatchCounts = {
+    staged: number;
+    queued: number;
+    running: number;
+    completed: number;
+    failed: number;
+    refused: number;
+    cancelled: number;
+    adopted: number;
+};
+type BatchCost = {
+    /** Sum of estimatedCost over admitted items. */
+    estimated: number;
+    /** Sum of maximumCost over admitted items: what admission reserved. */
+    maximum: number;
+    /** Sum of what completed items actually cost, so far. */
+    actual: number;
+};
+type BatchRecord = {
+    id: string;
+    key: string;
+    name?: string;
+    kind: 'render' | 'bake';
+    state: BatchState;
+    lane: 'batch' | 'normal';
+    maxParallel?: number;
+    /** The customer's ceiling for the whole batch. */
+    maxCost?: number;
+    counts: BatchCounts;
+    /** Every item ever admitted, adopted included. */
+    total: number;
+    /** How many are terminal. `done === total` once sealed is `completed`. */
+    done: number;
+    cost: BatchCost;
+    /** Why it is paused, when it is: the breaker names the top refusal codes. */
+    pausedReason?: string;
+    createdAt: number;
+    sealedAt?: number;
+    finishedAt?: number;
+};
+type BatchOpenRequest = {
+    /**
+     * Stable across re-runs: the same key re-opens the same batch while it is
+     * not terminal, and items already completed under their keys are adopted
+     * rather than rendered again.
+     */
+    key: string;
+    name?: string;
+    kind?: 'render' | 'bake';
+    /**
+     * The ceiling for the whole batch, in dollars. A page that would take the
+     * batch's maximum past it is refused whole.
+     */
+    maxCost?: number;
+    /**
+     * `batch` (the default) never runs ahead of a person in a configurator;
+     * `normal` is the API's ordinary lane.
+     */
+    lane?: 'batch' | 'normal';
+    /** Fewer parallel items than the plan allows, for a gentler budget. */
+    maxParallel?: number;
+};
+type BatchItemRequest = {
+    /**
+     * The item's idempotency key, scoped to the project like every other
+     * render's. `sku/finish/camera@v3` is the shape the docs suggest.
+     */
+    key: string;
+    spec: RenderSpec | BakeSpec;
+    metadata?: Record<string, unknown>;
+    /** A ceiling for this one item, under the batch's. */
+    maxCost?: number;
+};
+type BatchAddRequest = {
+    items: BatchItemRequest[];
+    /**
+     * Price everything, admit nothing: the whole catalog's numbers before a
+     * dollar is reserved.
+     */
+    dryRun?: boolean;
+};
+type BatchItemOutcome = {
+    key: string;
+    /** The render's id, when it was admitted or adopted. */
+    id?: string;
+    estimatedCost: number;
+    maximumCost: number;
+    /** Already completed under this key: attached at no cost. */
+    adopted?: boolean;
+    /**
+     * Why this item, alone, was not admitted (a bad spec, an item over its own
+     * maxCost). The page's other items are unaffected.
+     */
+    error?: RenderError;
+};
+type BatchAddResponse = {
+    batch: BatchRecord;
+    items: BatchItemOutcome[];
+};
+/** One line of `GET /v1/batches/:id/export`: the ledger, item by item. */
+type BatchExportLine = {
+    key: string;
+    id: string;
+    state: string;
+    resultUrl?: string;
+    error?: RenderError;
+    cost?: number;
+    versions?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+};
+
+/**
+ * Render job states and the events that carry them.
+ *
+ * Every transition is timestamped, idempotent and observable. Idempotent is
+ * the load-bearing word: a worker that retries a stage must not bill twice
+ * and must not emit `render.completed` twice, so the control plane treats a
+ * transition to a state it is already in as a no-op rather than an error.
+ */
+declare const RENDER_STATES: readonly ["created", "uploading", "validating", "queued", "starting", "preparing", "rendering_preview", "rendering", "encoding", "uploading_result", "completed", "failed", "cancelled", "expired"];
+type RenderState = (typeof RENDER_STATES)[number];
+type RenderResult = {
+    /**
+     * Signed, private, and only good until `expiresAt` (24 hours). Copy the
+     * bytes into your own storage if you keep them; `getRender(id)` hands out
+     * fresh URLs until the project's retention deletes the files.
+     */
+    url: string;
+    /**
+     * Millisecond epoch at which `url` (and `previewUrl`) stop working. The
+     * URLs are signed when the render is read, so reading it again with
+     * `getRender(id)` returns fresh ones. Absent from an API that predates it.
+     */
+    expiresAt?: number;
+    width: number;
+    height: number;
+    format: string;
+    bytes: number;
+    /** What was actually charged, in USD. Not the estimate. */
+    cost: number;
+    /** Everything needed to reproduce this exact image later. */
+    versions: {
+        protocol: string;
+        sdk: string;
+        translator: string;
+        qualityPreset: string;
+    };
+};
+/**
+ * Which queue a render waits in inside its account.
+ *
+ * `interactive` is a person waiting: every browser-token render, and the
+ * SDK's `render()` by default. `normal` is the API default. `batch` is an
+ * item of a batch. A lane above always dispatches before a lane below, so a
+ * configurator's visitor never waits behind an overnight catalog.
+ */
+declare const RENDER_LANES: readonly ["interactive", "normal", "batch"];
+type RenderLane = (typeof RENDER_LANES)[number];
+type RenderRecord = {
+    id: string;
+    state: RenderState;
+    progress: number;
+    /**
+     * A video's frames traced so far and in all, while it renders. Updated
+     * every ten seconds or so; absent for a still and once the render ends.
+     */
+    frames?: {
+        done: number;
+        total: number;
+    };
+    /** Which of the account's queues it waits in. */
+    lane?: RenderLane;
+    /**
+     * How many times a worker has been handed this render. 1 is the normal
+     * case; more means an infrastructure failure was retried for you.
+     */
+    attempts?: number;
+    /** The batch this render belongs to, and its key within it. */
+    batchId?: string;
+    batchKey?: string;
+    /** A low-sample image, available long before the final one. */
+    previewUrl?: string;
+    result?: RenderResult;
+    error?: RenderError;
+    estimate?: CostEstimate;
+    createdAt: number;
+    updatedAt: number;
+    metadata?: Record<string, unknown>;
+};
+/**
+ * A finished bake, as `GET /v1/bakes/:id` answers it.
+ *
+ * The bundle's uv arrays are behind `bundleUrl`, not here: a dense room's
+ * are megabytes, and the SDK reads them once from storage. `files` is every
+ * name the bundle uses, resolved to a signed URL, so a loader can take
+ * `bundle.objects[i].lightmap.uri` and look it up without knowing where the
+ * files live. All of them expire together, at `expiresAt`.
+ */
+type BakeResult = {
+    /** Signed GET for bundle.json: the BakeBundle, uv arrays and all. */
+    bundleUrl: string;
+    /** Every file the bundle names, by that name, as a signed GET. */
+    files: Record<string, string>;
+    /** Millisecond epoch at which the URLs stop working. */
+    expiresAt: number;
+    /**
+     * The bundle without its uv arrays: what a panel shows before it fetches
+     * anything.
+     */
+    summary: BakeBundleSummary;
+    /** Every file's size together, in bytes. */
+    bytes: number;
+    cost: number;
+    versions: Record<string, string | number>;
+};
+type BakeRecord = {
+    id: string;
+    state: RenderState;
+    progress: number;
+    result?: BakeResult;
+    error?: RenderError;
+    estimate?: CostEstimate;
+    createdAt: number;
+    updatedAt: number;
+    metadata?: Record<string, unknown>;
+};
+/**
+ * Cost, before anything expensive happens.
+ *
+ * `maximum` is what `maxCost` is compared against, so a developer who sets
+ * a ceiling gets a refusal rather than a bill somewhere between the two
+ * numbers.
+ */
+type CostEstimate = {
+    estimatedCost: number;
+    maximumCost: number;
+    estimatedSeconds: number;
+    compatibilityScore: number;
+};
+/**
+ * A failure a developer can act on.
+ *
+ * `code` is stable and machine-readable; `message`, `why` and `fix` are for
+ * the developer. A traceback is never any of them.
+ */
+type RenderError = {
+    code: RenderErrorCode;
+    message: string;
+    why?: string;
+    fix?: string;
+    docs?: string;
+    /** Where in the scene, when the failure has a location. */
+    path?: string;
+    /** Whether resubmitting unchanged could plausibly work. */
+    retryable: boolean;
+    /**
+     * The control plane tried this render again and gave up: every attempt
+     * failed the same retryable way. We have been told, and
+     * `POST /v1/renders/:id/retry` tries once more on request.
+     */
+    attemptsExhausted?: boolean;
+};
+declare const RENDER_ERROR_CODES: readonly ["RenderBudgetExceeded", "UnsupportedMaterial", "SceneTooLarge", "TextureTooLarge", "AssetNotFound", "AssetUploadIncomplete", "ProtocolVersionUnsupported", "RoomPresetUnknown", "RoomPresetBuildMismatch", "CompatibilityPreflightFailed", "OutOfVideoMemory", "RenderTimeout", "WorkerFailure", "WorkerLost", "RendererCrashed", "UploadFailed", "ResultLost", "CapacityUnavailable", "QueueFull", "QueueTimeout", "BatchBudgetExceeded", "BatchClosed", "ImportRefused", "ImportFailed", "PlanRequired", "StorageUnavailable", "InsufficientBalance", "QuotaExceeded", "ConcurrencyLimitReached", "RateLimited", "Unauthorized", "TokenExpired", "OriginNotAllowed", "InvalidRequest"];
+type RenderErrorCode = (typeof RENDER_ERROR_CODES)[number];
+/** Webhook event names. */
+declare const WEBHOOK_EVENTS: readonly ["render.created", "render.started", "render.preview", "render.completed", "render.failed", "render.cancelled", "render.retrying", "video.started", "video.frame.completed", "video.completed", "bake.created", "bake.started", "bake.completed", "bake.failed", "bake.cancelled", "bake.retrying", "batch.progress", "batch.completed", "batch.paused"];
+type WebhookEvent = (typeof WEBHOOK_EVENTS)[number];
+/**
+ * What a webhook carries. A `render.*` event has `render`; a `bake.*` event
+ * has `bake`. Never both: a receiver switches on `event` and reads the one
+ * record the event is about.
+ */
+type WebhookPayload = {
+    event: WebhookEvent;
+    /** Millisecond epoch. Signed together with the body; see the docs. */
+    sentAt: number;
+    render?: RenderRecord;
+    bake?: BakeRecord;
+    /** A `batch.*` event carries the batch's ledger instead. */
+    batch?: BatchRecord;
+};
+
+type AssetKind = 'scene' | 'texture' | 'hdri' | 'ies' | 'geometry' | 'animation';
+type AssetDescriptor = {
+    hash: string;
+    kind: AssetKind;
+    bytes: number;
+    contentType: string;
+    /** Diagnostics and the devtools' upload list; never used for addressing. */
+    name?: string;
+};
+/** Request body for "which of these do you already have?". */
+type AssetCheckRequest = {
+    assets: AssetDescriptor[];
+};
+/**
+ * The answer, plus a signed PUT for each miss.
+ *
+ * The presigned URL is a capability, not a credential: one object, one
+ * method, one expiry. It lets the browser upload straight to storage without
+ * the control plane ever touching the bytes.
+ */
+type AssetCheckResponse = {
+    /** Hashes already in storage. Do not upload these. */
+    present: string[];
+    /** One signed PUT per hash that is missing. */
+    uploads: Array<{
+        hash: string;
+        url: string;
+        /**
+         * Headers the signature covers. A presigned PUT is signed over an exact
+         * header set, so sending more or fewer than these is a 403. Pass them
+         * through verbatim.
+         */
+        headers?: Record<string, string>;
+        expiresAt: number;
+    }>;
+};
+/**
+ * `DELETE /v1/assets/:hash`. Secret key only. The stored file and its
+ * record are gone; the next render that needs it uploads it again.
+ */
+type AssetDeleteResponse = {
+    hash: string;
+    /** False when the project held no file with this hash: not an error. */
+    deleted: boolean;
+};
+
+/**
+ * What a GLB says about itself, read from its JSON chunk alone.
+ *
+ * A scene the SDK captured arrives with everything the control plane needs
+ * beside it: a triangle count to price with, a camera, a compatibility
+ * report. A model fetched by URL arrives with nothing, and the renderer is
+ * the wrong place to find out it cannot be read: that is a refusal at three
+ * in the morning, a thousand times. So the import reads the file's own
+ * table of contents, which is the first chunk and a few hundred KB at most,
+ * and answers before anything is admitted:
+ *
+ * - how heavy it is (triangles, per node instance, the way it will trace);
+ * - where it is (the world bounds, from accessor min/max through the node
+ *   transforms), which is what lets a camera be FRAMED instead of guessed;
+ * - which cameras it carries, by name;
+ * - what in it the renderer cannot read (a required extension its importer
+ *   does not implement), by name and with the fix.
+ *
+ * Pure, no dependencies, no binary chunk: nothing here decodes geometry.
+ */
+
+type GlbCamera = {
+    /** The node's name, or the camera's. What a caller asks for it by. */
+    name: string;
+    /** As it stands in the file, in world space. `aspect` is the file's own, when it gives one. */
+    camera: CameraSpec;
+};
+type GlbFacts = {
+    bytes: number;
+    /** Counted per node instance: a mesh two nodes show is traced twice. */
+    triangles: number;
+    meshes: number;
+    materials: number;
+    textures: number;
+    /** Punctual lights the file carries. They render as its author set them. */
+    lights: number;
+    animations: number;
+    /** World bounds of everything with geometry, or null for a file with none. */
+    bounds: {
+        min: Vec3;
+        max: Vec3;
+    } | null;
+    cameras: GlbCamera[];
+    /** Named nodes, in file order, bounded. */
+    objects: string[];
+    extensionsUsed: string[];
+    extensionsRequired: string[];
+    generator?: string;
+    /** `error` issues mean the renderer cannot read the file as authored. */
+    issues: CompatibilityIssue[];
+};
+
+/**
+ * Importing an asset by URL: `POST /v1/assets/import`.
+ *
+ * Every other asset is pushed: the browser hashes it and PUTs it on a
+ * presigned URL. A catalog that already sits on a CDN should not be pulled
+ * through somebody's laptop to be pushed again, so this one is pulled: the
+ * control plane fetches the public URL once, stores the bytes content
+ * addressed exactly as an upload would have, and answers with the hash and
+ * what the file says about itself. The result is an ordinary asset, and
+ * everything after it (the manifest, the cache keys, the render) is the
+ * ordinary path.
+ *
+ * Fetching a URL a customer names is the one thing here a stranger could aim
+ * somewhere else, so the route takes a secret key only (never a browser
+ * token), and the fetch is fenced: https, public addresses only, no
+ * credentials in the URL, and a size limit.
+ */
+
+type AssetImportKind = 'scene' | 'hdri';
+type AssetImportRequest = {
+    /** `https://`, public, no credentials in it. */
+    url: string;
+    /** `scene` (a GLB, the default) or `hdri` (a Radiance .hdr or an OpenEXR). */
+    kind?: AssetImportKind;
+};
+type AssetImportResponse = {
+    hash: AssetHash;
+    kind: AssetImportKind;
+    bytes: number;
+    /**
+     * True when nothing was downloaded: the URL answered 304 to the validator
+     * kept from the last import, so the stored bytes are still what it serves.
+     */
+    unchanged: boolean;
+    /** For a `scene`: what the GLB says about itself. */
+    facts?: GlbFacts;
+};
+
+/**
+ * Errors a developer can act on.
+ *
+ * "Render failed" is a bad error. A traceback is a worse one. Every failure
+ * that reaches the developer carries what went wrong, where, why, and what to
+ * do about it, and `code` stays stable so the failure can also be branched on
+ * in code.
+ */
+
+/**
+ * Codes the SDK can raise that the render protocol does not: a fault on the
+ * way (`NetworkError`), a fault before anything left the browser
+ * (`CaptureFailed`), the two refusals a batch page can meet as a whole (over
+ * the batch's own ceiling, or after it was sealed), and the two ends of a job
+ * that are not faults in the scene: it was cancelled (`Cancelled`), or its
+ * files were deleted before it was read (`Expired`).
+ */
+type Bakery3ErrorCode = RenderErrorCode | 'NetworkError' | 'CaptureFailed' | 'BatchBudgetExceeded' | 'BatchClosed' | 'Cancelled' | 'Expired';
+declare class Bakery3Error extends Error {
+    readonly code: Bakery3ErrorCode;
+    readonly why?: string;
+    readonly fix?: string;
+    readonly docs?: string;
+    readonly path?: string;
+    readonly retryable: boolean;
+    constructor(init: {
+        code: Bakery3ErrorCode;
+        message: string;
+        why?: string;
+        fix?: string;
+        docs?: string;
+        path?: string;
+        retryable?: boolean;
+    });
+    static from(error: RenderError): Bakery3Error;
+    /**
+     * The multi-line form, for a console or a devtools panel.
+     *
+     * `Error.message` stays one line so it reads correctly everywhere a message
+     * is expected to be one: a log aggregator, a toast, a test name. `stack`
+     * starts with this form, so an uncaught error prints its fix.
+     */
+    toDisplayString(): string;
+}
+/**
+ * A whole page of batch items was refused.
+ *
+ * Admission is per page: the control plane prices the page, checks it against
+ * the account's balance and the batch's own `maxCost`, and either admits
+ * every item or none. A `402 InsufficientBalance`, a `402 BatchBudgetExceeded`
+ * or a `409 BatchClosed` means nothing in the page was admitted. The `Batch`
+ * keeps those items buffered, so after a top-up (or a higher ceiling)
+ * `flush()` sends exactly the same page again.
+ *
+ * `admitted` is what earlier pages of the same flush already got through:
+ * those items are the server's now, and this error carries their outcomes so
+ * a caller does not lose them because a later page was refused.
+ */
+declare class BatchPageRefused extends Bakery3Error {
+    /** The page that was refused whole, still in the batch's buffer. */
+    readonly page: BatchItemRequest[];
+    /** Outcomes of the pages this flush admitted before the refusal. */
+    readonly admitted: BatchItemOutcome[];
+    constructor(cause: Bakery3Error, page: BatchItemRequest[], admitted: BatchItemOutcome[]);
+}
+
+/**
+ * The HTTP client for the control plane.
+ *
+ * Small on purpose: a handful of endpoints, one auth header, one error shape.
+ * The interesting work happens in the browser (capture, hashing) and on the
+ * render workers; this is the thin part in between.
+ *
+ * The one piece of policy it carries is the retry: a 429 or a 503 is the
+ * control plane saying "not now", and it is answered with a bounded, jittered
+ * wait rather than an error the developer has to write a loop around. Only
+ * requests that are safe to repeat are repeated (see `RequestOptions.retry`).
+ *
+ * In production no secret key reaches this file. The browser holds a
+ * short-lived, project-scoped, origin-restricted, spend-capped token minted by
+ * the developer's own server. `token` is a function rather than a string so
+ * it can be fetched again when one expires, which for a five-minute token in
+ * a long configurator session is routine.
+ *
+ * `apiKey` is the other door, and it is open on purpose: a key works from the
+ * browser so the first render is one paste away, and `warnIfKeyIsExposed`
+ * says once, with the replacement code, why it must not stay there.
+ *
+ * Neither is needed to construct a client: `check()` and `inspect()` never
+ * touch the network, and a React tree whose environment variable is unset
+ * must still mount. A missing credential is refused at the first request,
+ * with what to pass instead.
+ */
+
+/** What `/v1/estimate` prices: a still or a clip, or a bake. */
+type EstimateRequest = (Pick<RenderSpec, 'quality' | 'output' | 'advanced'> & {
+    /** Triangle count and texture footprint, so an estimate can be given
+     *  before anything has been uploaded. `room` says the scene stands in a
+     *  preset room, which the renderer builds around it; `enclosure` and
+     *  `objects` say how walled in and how full it is from the camera
+     *  (`SceneComplexity`), which is what makes an interior cost more. */
+    scene?: {
+        triangles?: number;
+        textureBytes?: number;
+        fog?: boolean;
+        room?: boolean;
+        enclosure?: number;
+        objects?: number;
+    };
+    /** Frames in a clip; the control plane prices a video per frame. */
+    frames?: number;
+}) | {
+    /** The settings a bake request would carry. Texels (objects × size²)
+     *  are what the control plane prices. */
+    bake: Pick<BakeSettings, 'quality' | 'textureSize' | 'include' | 'sizes' | 'atlas' | 'deliverGlb' | 'simplify' | 'shadow'> & {
+        /** The scene is a room interior: a ray that misses keeps going,
+         *  which is most of what such a bake costs. */
+        enclosed?: boolean;
+    };
+    /** Triangles in the objects the bake would cover: what the unwrap runs
+     *  over, and priced separately from the scene's own count. */
+    bakedTriangles?: number;
+    scene?: {
+        triangles?: number;
+        textureBytes?: number;
+        fog?: boolean;
+    };
+};
+/** A browser token: the string, or the JSON `tokens.create()` answers with. */
+type MintedToken = string | {
+    token: string;
+    expiresAt?: number;
+};
+type TokenProvider = () => MintedToken | Promise<MintedToken>;
+/**
+ * One of the two, never both. Neither is allowed too, for a client that only
+ * checks scenes; its first request is refused with what to pass.
+ *
+ * The `?: never` arms turn passing both into a type error at the call site
+ * rather than a runtime throw later: the two are different integrations, and
+ * a codebase carrying both is one that has not finished moving off the key.
+ */
+type ClientAuth = {
+    /** Mints a browser token, usually from your own `/api/bakery3-token`. */
+    token: TokenProvider;
+    apiKey?: never;
+} | {
+    /**
+     * A `bk_sk_` key used directly, for local testing, a Node script, or a
+     * server-rendered call.
+     *
+     * From a browser this ships the key to every visitor. The SDK allows it
+     * so the first render is one paste away, warns about it in the console,
+     * and expects `token` by the time you deploy.
+     *
+     * `undefined` (an environment variable that is not set) is accepted
+     * here and refused at the first request, with that said.
+     */
+    apiKey: string | undefined;
+    token?: never;
+} | {
+    token?: undefined;
+    apiKey?: undefined;
+};
+/**
+ * How a 429 or a 503 is waited out. Bounded: after `maxTries` the error is
+ * the developer's. The defaults are the SDK's; a test shortens the delays.
+ */
+type RetryPolicy = {
+    /** Attempts in total, the first included. Default 5. */
+    maxTries?: number;
+    /** The first wait, before jitter and doubling. Default 500 ms. */
+    baseDelayMs?: number;
+    /** No single wait is longer than this, `Retry-After` included. Default 30 s. */
+    maxDelayMs?: number;
+};
+type ClientOptions = ClientAuth & {
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    retry?: RetryPolicy;
+};
+/** Per-request knobs, for the client's own methods. */
+type RequestOptions = {
+    /**
+     * Whether a 429/503 may be answered by sending the request again.
+     *
+     * Every GET is. A POST is only when repeating it cannot do a second thing:
+     * a batch page (its items carry keys), a batch action, a render that
+     * carries an `idempotencyKey`. `POST /v1/renders` without one is not: a
+     * second copy would be a second charge, which no amount of backoff is
+     * worth.
+     */
+    retry?: boolean;
+    /** Cuts a long-poll short. */
+    signal?: AbortSignal;
+};
+/** `GET /v1/batches/:id/items`: the render record plus the item's key. */
+type BatchItemRecord = RenderRecord & {
+    key: string;
+};
+type BatchItemsPage = {
+    items: BatchItemRecord[];
+    cursor: string | null;
+};
+type BatchAction = 'close' | 'pause' | 'resume' | 'cancel' | 'retry';
+declare class Bakery3Client {
+    private readonly baseUrl;
+    private readonly 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.
+     */
+    readonly fetch: typeof 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. */
+    private cached;
+    /** 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. */
+    private minting;
+    /**
+     * 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.
+     */
+    private readonly owners;
+    private readonly retry;
+    private readonly sendVersion;
+    constructor(options?: ClientOptions);
+    /**
+     * 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(): Bakery3Error | null;
+    token(force?: boolean): Promise<string>;
+    private mint;
+    checkAssets(body: AssetCheckRequest): Promise<AssetCheckResponse>;
+    /**
+     * `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.
+     */
+    importAsset(body: AssetImportRequest): Promise<AssetImportResponse>;
+    estimate(body: EstimateRequest): Promise<CostEstimate>;
+    createRender(body: RenderSpec): Promise<RenderRecord>;
+    /**
+     * 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.
+     */
+    getRender(id: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<RenderRecord>;
+    cancelRender(id: string): Promise<RenderRecord>;
+    /**
+     * `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.
+     */
+    retryRender(id: string): Promise<RenderRecord>;
+    createBake(body: BakeSpec): Promise<BakeRecord>;
+    getBake(id: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<BakeRecord>;
+    cancelBake(id: string): Promise<BakeRecord>;
+    /** `POST /v1/batches`. The key is the idempotency key: the same key
+     *  re-opens the same batch (200) while it is not terminal. */
+    openBatch(body: BatchOpenRequest): Promise<BatchRecord>;
+    /**
+     * `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.
+     */
+    getBatch(id: string, options?: {
+        wait?: number;
+        signal?: AbortSignal;
+    }): Promise<BatchRecord>;
+    /**
+     * `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.
+     */
+    addBatchItems(id: string, body: BatchAddRequest): Promise<BatchAddResponse>;
+    /** `GET /v1/batches/:id/items?state=&cursor=&limit=`. */
+    listBatchItems(id: string, options?: {
+        state?: RenderState;
+        cursor?: string;
+        limit?: number;
+    }): Promise<BatchItemsPage>;
+    /**
+     * `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.
+     */
+    exportBatch(id: string): AsyncIterable<BatchExportLine>;
+    /** `POST /v1/batches/:id/{close,pause,resume,cancel,retry}`. Every one is a
+     *  state transition the control plane treats idempotently, so all repeat. */
+    batchAction(id: string, action: BatchAction): Promise<BatchRecord>;
+    private post;
+    /** A request about a row this client may have created, with its token. */
+    private read;
+    /** Remember which token created a row, so the row is read with it. */
+    private remember;
+    /**
+     * 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.
+     */
+    request<T>(method: string, path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /** A JSON request, and the credential that got the answer. */
+    private call;
+    private send;
+    private fetchOnce;
+    /**
+     * 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.
+     */
+    private delayFor;
+}
+
+/**
+ * A batch, from the customer's side.
+ *
+ *     const batch = await bakery3.batches.open({ key: 'fall-2026-v3', maxCost: 600 });
+ *     for await (const item of source) await batch.write(item);   // a full page sends itself
+ *     await batch.close();            // the tail is flushed, then sealed: the total is known
+ *     await batch.wait({ onProgress: (p) => console.log(`${p.completed}/${p.total}`) });
+ *     for await (const item of batch.items({ state: 'failed' })) console.error(item.key);
+ *
+ * Two things this class is careful about, because they are the whole reason
+ * the batch exists rather than a loop over `render()`:
+ *
+ * - Memory. `write` buffers a few KB of manifest per item and sends a page
+ *   the moment one is full, by count or by bytes, so awaiting it is the
+ *   backpressure and nothing here ever holds the catalog. (`add` and
+ *   `flush` are the same two steps taken by hand.) A refused page stays
+ *   buffered: the caller tops up and flushes again, and the same items go,
+ *   under the same keys.
+ * - One poll loop. `wait` long-polls the batch record; it never polls a
+ *   render. Items are read by state with a cursor when they are wanted.
+ */
+
+/** The slice of the client a batch drives: what a mock has to provide. */
+type BatchTransport = {
+    getBatch(id: string, options?: {
+        wait?: number;
+        signal?: AbortSignal;
+    }): Promise<BatchRecord>;
+    addBatchItems(id: string, body: BatchAddRequest): Promise<{
+        batch: BatchRecord;
+        items: BatchItemOutcome[];
+    }>;
+    listBatchItems(id: string, options?: {
+        state?: RenderState;
+        cursor?: string;
+        limit?: number;
+    }): Promise<BatchItemsPage>;
+    exportBatch(id: string): AsyncIterable<BatchExportLine>;
+    batchAction(id: string, action: 'close' | 'pause' | 'resume' | 'cancel' | 'retry'): Promise<BatchRecord>;
+};
+/**
+ * The counts, the cost and where the batch stands: what a status line
+ * prints. Flat on purpose (`p.completed`, not `p.counts.completed`).
+ */
+type BatchProgress = BatchCounts & {
+    id: string;
+    state: BatchState;
+    /** Every item ever admitted, adopted included. Final once sealed. */
+    total: number;
+    /** How many are terminal. */
+    done: number;
+    cost: BatchCost;
+    pausedReason?: string;
+};
+type FlushOptions = {
+    /** Price the pages, admit nothing: the buffer stays for a real flush. */
+    dryRun?: boolean;
+};
+type WaitOptions = {
+    /** Called after every poll that returned, whether or not the counts moved. */
+    onProgress?: (progress: BatchProgress) => void;
+    signal?: AbortSignal;
+};
+declare class Batch {
+    readonly id: string;
+    readonly key: string;
+    private latest;
+    /** The flush in flight, or the last one, settled either way. */
+    private flushing;
+    private readonly 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. */
+    private readonly sizes;
+    private bytes;
+    private readonly client;
+    /** The clock `wait()` measures its patience with. A test turns it. */
+    private clock;
+    /** @internal `bakery3.batches.open()` and `.get()` make these. */
+    constructor(client: BatchTransport, record: BatchRecord);
+    /** Buffer an item. Nothing is sent until `flush()`. */
+    add(item: BatchItemRequest): 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();
+     */
+    write(item: BatchItemRequest): Promise<void>;
+    /** Items added and not yet sent. */
+    get buffered(): number;
+    /** About how many bytes of JSON those items are. */
+    get bufferedBytes(): number;
+    /**
+     * 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.
+     */
+    quote(items: BatchItemRequest[]): Promise<BatchItemOutcome[]>;
+    /**
+     * 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?: FlushOptions): Promise<BatchItemOutcome[]>;
+    private flushNow;
+    /** 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. */
+    close(): Promise<BatchRecord>;
+    /** Stop feeding the queue; running items finish. */
+    pause(): Promise<BatchRecord>;
+    resume(): Promise<BatchRecord>;
+    /** Cancel every non-terminal item. What completed stays completed: it rendered. */
+    cancel(): Promise<BatchRecord>;
+    /** Re-queue every dead-lettered item, one new attempt each. */
+    retry(): Promise<BatchRecord>;
+    /** The latest record this batch has seen. No request. */
+    record(): BatchRecord;
+    /** Fetch the record now. */
+    refresh(): Promise<BatchRecord>;
+    /** Counts and cost from the latest record. No request. */
+    progress(): BatchProgress;
+    /**
+     * 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.
+     */
+    wait(options?: WaitOptions): Promise<BatchRecord>;
+    /** Every item, or every item in one state, walked with the cursor. */
+    items(options?: {
+        state?: RenderState;
+    }): AsyncIterable<BatchItemRecord>;
+    /** The ledger, line by line, as the server streams it. */
+    export(): AsyncIterable<BatchExportLine>;
+    private apply;
+}
+
+/**
+ * A set of pictures: what every many-pictures call hands back.
+ *
+ * `render({ cameras })` and `renderVariants()` in the browser, and
+ * `renderBatch()` from Node, all record into a batch and return one of
+ * these, so a set of three and a catalog of six thousand are the same object
+ * with the same guarantees: one ceiling for all of it, one poll for all of
+ * it, results walked a page at a time and never held.
+ *
+ * No three.js here: the server entry imports this file.
+ */
+
+/** One finished picture of a set. */
+type RenderSetImage = {
+    /** The item's key: `variant/finish/camera`, as recorded. */
+    key: string;
+    /** The render's id. */
+    id: string;
+    variant?: string;
+    finish?: string;
+    camera?: string;
+    /** The shot this is, for a set recorded with shots. */
+    shot?: string;
+    /** `'video'` when the url is a clip. */
+    kind?: 'image' | 'video';
+    /** Signed and expiring. Copy the bytes; do not serve from it. */
+    url: string;
+    width: number;
+    height: number;
+    /** What this picture cost. Nothing, when it was adopted from an earlier run. */
+    cost: number;
+    metadata?: Record<string, unknown>;
+    result: RenderResult;
+};
+/** One picture that did not render, and why. */
+type RenderSetFailure = {
+    key: string;
+    id: string;
+    variant?: string;
+    finish?: string;
+    camera?: string;
+    shot?: string;
+    error: Bakery3Error;
+    metadata?: Record<string, unknown>;
+};
+/** One picture turned down when it was submitted: it has no render and never will. */
+type RenderSetRefusal = {
+    key: string;
+    variant?: string;
+    finish?: string;
+    camera?: string;
+    shot?: string;
+    error: RenderError;
+};
+/** What a recording did, in numbers small enough to keep. */
+type Recorded = {
+    variants: number;
+    images: number;
+    /** Already rendered under their keys in an earlier run. Cost nothing. */
+    adopted: number;
+    /** Turned down alone at admission (a spec that does not parse, an item over its own ceiling). */
+    refused: number;
+    /** The first of those, with their reasons. Capped, because a broken pipeline refuses every item. */
+    refusals: RenderSetRefusal[];
+};
+declare class RenderSet {
+    /** The batch underneath: pause, resume, retry, the export. */
+    readonly batch: Batch;
+    readonly id: string;
+    readonly key: string;
+    /** What the call that made this set recorded. Empty for a set fetched by id. */
+    readonly recorded: Recorded;
+    /** Item key → position, for a set small enough to have asked for an order. */
+    private order?;
+    constructor(batch: Batch, recorded?: Recorded);
+    /** Counts and cost from the latest record. No request. */
+    progress(): BatchProgress;
+    /**
+     * Until every picture is terminal. One long-poll on the set, however many
+     * pictures it has. Resolves with the final counts: pictures that failed
+     * are in `failures()`, they do not reject the wait.
+     */
+    wait(options?: WaitOptions): Promise<BatchProgress>;
+    /**
+     * Every finished picture, a page at a time. Safe on a set of any size,
+     * and safe to call before the set is done: it walks what has completed
+     * so far.
+     */
+    images(): AsyncIterable<RenderSetImage>;
+    /**
+     * Every picture that did not render, with the reason and the fix.
+     * `error.retryable` tells the two kinds apart: false is a refusal, the
+     * scene's fault and the same next time; true ran out of attempts on a
+     * fault of ours, and `set.batch.retry()` queues it again.
+     */
+    failures(): AsyncIterable<RenderSetFailure>;
+    /**
+     * Wait, then every picture in one array, in camera order for a
+     * `render({ cameras })`: one picture per camera, or a rejection. Rejects
+     * with `RenderSetRefused` when a picture was turned down at submission
+     * (it has no render, and the array would be one short with every later
+     * picture in the wrong place), and otherwise with the first failure, as
+     * `job.result()` does. The pictures that did render are still there:
+     * walk `images()`, each named by its `camera`.
+     *
+     * It collects, so it is for a handful of pictures. For a catalog, walk
+     * `images()`.
+     */
+    result(options?: WaitOptions): Promise<RenderSetImage[]>;
+    /** Cancel every picture that has not finished. What completed, completed. */
+    cancel(): Promise<void>;
+    /** @internal */
+    ordered(keys: string[]): this;
+}
+
+/**
+ * The test run: a few products, every camera, small and fast.
+ *
+ * Before six thousand pictures are paid for, three products are worth
+ * looking at: are the cameras where they were meant to be, is the room the
+ * right way round, does the finish list hide what it should. A test run is
+ * the real run's own options with three changes, made here so the browser
+ * and the server make the same ones:
+ *
+ * - A sample of the products. From an array: the first, the middle and the
+ *   last, because a catalog is usually sorted and its ends differ most.
+ *   From anything else (a generator, a cursor): the first three, since a
+ *   list that is never collected has no middle to ask for.
+ * - Preview quality at a small size, the long edge 512 unless told
+ *   otherwise, the aspect kept, so the framing is the real run's framing.
+ * - Its own keys. A test is looked at and thrown away; if it shared the real
+ *   run's keys, the real run would adopt these little previews as finished
+ *   pictures. Every test also differs from the last one, so a test after a
+ *   fix shows the fix and not yesterday's frame.
+ *
+ * No three.js here: the server entry imports this file.
+ */
+
+type TestRunOptions = {
+    /** How many products. Default 3. */
+    products?: number;
+    /** The long edge of each picture, in pixels. Default 512. */
+    size?: number;
+    /** The ceiling for the test, in dollars. Default 5. */
+    maxCost?: number;
+};
+
+/**
+ * Cameras without a scene graph: where to stand to photograph a box.
+ *
+ * In the browser a camera is an object the developer placed. From a server
+ * there is a model's bounds (`GlbFacts.bounds`, read at import) and nothing
+ * else, so a view is described the way a photographer would: from which
+ * side, how high, how tight. `framedCamera` turns that into the same
+ * `CameraSpec` a captured camera becomes.
+ *
+ * No three.js here: the server entry imports this file.
+ */
+
+/** Where to look from: degrees around the model from its front (+Z, where glTF says a model faces) toward its right (+X), and degrees above the horizon. */
+type Angle = {
+    azimuthDeg: number;
+    elevationDeg?: number;
+};
+/** The framings with names. */
+declare const VIEW_WORDS: {
+    readonly front: {
+        readonly azimuthDeg: 0;
+        readonly elevationDeg: 6;
+    };
+    readonly 'three-quarter': {
+        readonly azimuthDeg: 35;
+        readonly elevationDeg: 14;
+    };
+    readonly side: {
+        readonly azimuthDeg: 90;
+        readonly elevationDeg: 6;
+    };
+    readonly back: {
+        readonly azimuthDeg: 180;
+        readonly elevationDeg: 6;
+    };
+    readonly 'three-quarter-back': {
+        readonly azimuthDeg: 145;
+        readonly elevationDeg: 14;
+    };
+    readonly top: {
+        readonly azimuthDeg: 0;
+        readonly elevationDeg: 88;
+    };
+};
+type ViewWord = keyof typeof VIEW_WORDS;
+
+declare const HDRI_PRESETS: {
+    readonly pergola_walkway: {
+        readonly label: "Pergola Walkway";
+        readonly description: "A garden walkway under a vine-covered pergola, high sun, greenery on every side.";
+        readonly category: "day";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 1.7631801999999999;
+        readonly preview: {
+            readonly file: "pergola_walkway_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "pergola_walkway_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly sunny_country_road: {
+        readonly label: "Sunny Country Road";
+        readonly description: "A dirt road between fields under a high midday sun.";
+        readonly category: "day";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 1.0989418;
+        readonly preview: {
+            readonly file: "sunny_country_road_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "sunny_country_road_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly "horn-koppe_spring": {
+        readonly label: "Horn-Koppe Spring";
+        readonly description: "Alpine meadow in spring, snow on the peaks, a high clear sun.";
+        readonly category: "day";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 1.4612264;
+        readonly preview: {
+            readonly file: "horn-koppe_spring_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "horn-koppe_spring_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly grasslands_sunset: {
+        readonly label: "Grasslands Late Sun";
+        readonly description: "Open grassland with the sun low but still white, a long afternoon.";
+        readonly category: "day";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 3.9029496;
+        readonly preview: {
+            readonly file: "grasslands_sunset_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "grasslands_sunset_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly je_gray_02: {
+        readonly label: "Grey Park";
+        readonly description: "A shaded park path, the sun low behind trees, a soft, cool day.";
+        readonly category: "day";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 0.21612759999999998;
+        readonly preview: {
+            readonly file: "je_gray_02_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "je_gray_02_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly qwantani_sunset: {
+        readonly label: "Qwantani Sunset";
+        readonly description: "Sunset over the veld: a warm horizon and a clear deep sky above.";
+        readonly category: "golden";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 2.3187784;
+        readonly preview: {
+            readonly file: "qwantani_sunset_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "qwantani_sunset_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly venice_sunset: {
+        readonly label: "Venice Sunset";
+        readonly description: "The lagoon at sunset, water and sky both gold.";
+        readonly category: "golden";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 2.1780174;
+        readonly preview: {
+            readonly file: "venice_sunset_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "venice_sunset_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly bambanani_sunset: {
+        readonly label: "Bambanani Sunset";
+        readonly description: "A township street at sunset, the sun red and low.";
+        readonly category: "golden";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 3.300283399999999;
+        readonly preview: {
+            readonly file: "bambanani_sunset_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "bambanani_sunset_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly umhlanga_sunrise: {
+        readonly label: "Umhlanga Sunrise";
+        readonly description: "Sunrise over the sea, the sun just clear of the horizon.";
+        readonly category: "golden";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 3.3150258000000004;
+        readonly preview: {
+            readonly file: "umhlanga_sunrise_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "umhlanga_sunrise_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly flamingo_pan: {
+        readonly label: "Flamingo Pan";
+        readonly description: "A salt pan at sunset, the sun on the horizon and a violet sky.";
+        readonly category: "golden";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 3.1940932;
+        readonly preview: {
+            readonly file: "flamingo_pan_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "flamingo_pan_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly minedump_flats: {
+        readonly label: "Minedump Flats";
+        readonly description: "Flat scrub at sunset under a hazy, dusty sky.";
+        readonly category: "golden";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 2.9883286;
+        readonly preview: {
+            readonly file: "minedump_flats_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "minedump_flats_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly sunset_fairway: {
+        readonly label: "Sunset Fairway";
+        readonly description: "A golf fairway at dusk, the sun already down and the sky lit from below.";
+        readonly category: "golden";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 2.7264117999999997;
+        readonly preview: {
+            readonly file: "sunset_fairway_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "sunset_fairway_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly the_sky_is_on_fire: {
+        readonly label: "Sky on Fire";
+        readonly description: "A blazing red-orange sunset over open country.";
+        readonly category: "golden";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 2.4784194;
+        readonly preview: {
+            readonly file: "the_sky_is_on_fire_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "the_sky_is_on_fire_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly dalkey_view: {
+        readonly label: "Dalkey View";
+        readonly description: "A coastal hillside under a bright overcast sky.";
+        readonly category: "overcast";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 4.501861400000001;
+        readonly preview: {
+            readonly file: "dalkey_view_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "dalkey_view_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly afrikaans_church_exterior: {
+        readonly label: "Church Square";
+        readonly description: "A quiet square under heavy cloud, a white church across it.";
+        readonly category: "overcast";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 4.194848599999999;
+        readonly preview: {
+            readonly file: "afrikaans_church_exterior_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "afrikaans_church_exterior_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly quarry_cloudy: {
+        readonly label: "Cloudy Quarry";
+        readonly description: "A stone quarry under an even grey sky.";
+        readonly category: "overcast";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 3.9304787999999995;
+        readonly preview: {
+            readonly file: "quarry_cloudy_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "quarry_cloudy_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly moonless_golf: {
+        readonly label: "Moonless Golf Course";
+        readonly description: "A moonless night over a golf course, a faint glow from the town.";
+        readonly category: "night";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 0.5007998;
+        readonly preview: {
+            readonly file: "moonless_golf_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "moonless_golf_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly preller_drive: {
+        readonly label: "Preller Drive";
+        readonly description: "A suburban street at night, sodium street lamps and dark trees.";
+        readonly category: "night";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 0.5283702;
+        readonly preview: {
+            readonly file: "preller_drive_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "preller_drive_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly satara_night: {
+        readonly label: "Satara Night";
+        readonly description: "A bush camp at night, a few lamps and a starry sky.";
+        readonly category: "night";
+        readonly groundHeight: 1.6;
+        readonly skyIrradiance: 0.25447;
+        readonly preview: {
+            readonly file: "satara_night_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "satara_night_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly ferndale_studio_11: {
+        readonly label: "Ferndale Studio 11";
+        readonly description: "High-contrast studio environment with broad soft sources.";
+        readonly category: "studio";
+        readonly groundHeight: 1.2;
+        readonly skyIrradiance: 1.2286402;
+        readonly preview: {
+            readonly file: "ferndale_studio_11_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "ferndale_studio_11_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly ferndale_studio_12: {
+        readonly label: "Ferndale Studio 12";
+        readonly description: "Balanced product studio with shaped highlights.";
+        readonly category: "studio";
+        readonly groundHeight: 1.2;
+        readonly skyIrradiance: 1.2324262000000001;
+        readonly preview: {
+            readonly file: "ferndale_studio_12_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "ferndale_studio_12_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly monochrome_studio_02: {
+        readonly label: "Monochrome Studio 02";
+        readonly description: "Neutral monochrome studio for material-focused renders.";
+        readonly category: "studio";
+        readonly groundHeight: 1.2;
+        readonly skyIrradiance: 0.9193722;
+        readonly preview: {
+            readonly file: "monochrome_studio_02_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "monochrome_studio_02_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly studio_kontrast_04: {
+        readonly label: "Studio Kontrast 04";
+        readonly description: "Directional studio contrast with crisp reflections.";
+        readonly category: "studio";
+        readonly groundHeight: 1.2;
+        readonly skyIrradiance: 2.9173432;
+        readonly preview: {
+            readonly file: "studio_kontrast_04_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "studio_kontrast_04_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+    readonly studio_small_03: {
+        readonly label: "Small Studio 03";
+        readonly description: "Compact studio environment with close softboxes.";
+        readonly category: "studio";
+        readonly groundHeight: 1.2;
+        readonly skyIrradiance: 13.877922599999998;
+        readonly preview: {
+            readonly file: "studio_small_03_1k.hdr";
+            readonly resolution: 1024;
+        };
+        readonly render: {
+            readonly file: "studio_small_03_4k.exr";
+            readonly resolution: 4096;
+        };
+    };
+};
+type HdriPresetName = keyof typeof HDRI_PRESETS;
+
+/**
+ * Generated by the preset library's sync script and by every room publish.
+ * Do not edit.
+ *
+ * The rooms the SDK can offer. `build` is the content hash of the published
+ * room definition; the manifest repeats it and the renderer refuses any
+ * other, so what was framed in the browser is what gets traced.
+ */
+type RoomPresetLighting = 'day' | 'golden' | 'overcast' | 'night';
+declare const ROOM_PRESETS: {
+    readonly atelier_skylight: {
+        readonly label: "Skylight Atelier";
+        readonly description: "Concrete floor, tall plaster walls and two roof lights pouring foliage-broken sun straight down onto a low plinth.";
+        readonly build: "6d26daeb0abb";
+        readonly presetsVersion: 1;
+        readonly size: {
+            readonly width: 5.5;
+            readonly height: 3.4;
+            readonly depth: 5.5;
+        };
+        readonly lighting: "day";
+        readonly surfaces: {
+            readonly floor: {
+                readonly material: "polished_concrete";
+                readonly color: "#ffffff";
+            };
+            readonly walls: {
+                readonly material: "white_plaster";
+                readonly color: "#f2efe8";
+            };
+            readonly ceiling: {
+                readonly material: "matte_paint";
+                readonly color: "#f5f4f0";
+            };
+            readonly sill: {
+                readonly material: "travertine";
+            };
+        };
+        readonly stand: {
+            readonly type: "pedestal_plinth";
+            readonly material: "carrara_marble";
+            readonly x: 0;
+            readonly z: -0.2;
+            readonly rotationDeg: 0;
+            readonly top: 0.3;
+            readonly size: {
+                readonly x: 0.9;
+                readonly y: 0.3;
+                readonly z: 0.9;
+            };
+        };
+        readonly camera: {
+            readonly position: readonly [-1.7918, 1.38, 1.4709];
+            readonly target: readonly [0, 0.55, -0.2];
+            readonly lensMm: 38;
+            readonly fstop: 2.4000000953674316;
+        };
+        readonly preview: {
+            readonly glb: "rooms/atelier_skylight/room.glb";
+            readonly bytes: 1609624;
+            readonly triangles: 71936;
+            readonly textures: 21;
+        };
+        readonly complexity: {
+            readonly enclosure: 1;
+            readonly objects: 64;
+        };
+        readonly prebaked: readonly [];
+        readonly baked: readonly ["day", "golden", "night"];
+        readonly standGlb: "rooms/atelier_skylight/stand.glb";
+        readonly plants: readonly ["potted_dracaena_01", "potted_monstera_01"];
+        readonly pictures: readonly [];
+        readonly previewBrightness: {
+            readonly day: 0.775;
+            readonly golden: 0.543;
+            readonly overcast: 0.723;
+            readonly night: 0.243;
+        };
+        readonly previewFill: {
+            readonly day: {
+                readonly sky: readonly [0.861, 1.012, 1.285];
+                readonly ground: readonly [0.861, 1.012, 1.285];
+            };
+            readonly golden: {
+                readonly sky: readonly [1.154, 0.972, 0.825];
+                readonly ground: readonly [1.154, 0.972, 0.825];
+            };
+            readonly overcast: {
+                readonly sky: readonly [0.997, 0.997, 1.041];
+                readonly ground: readonly [0.997, 0.997, 1.041];
+            };
+            readonly night: {
+                readonly sky: readonly [1.488, 0.894, 0.616];
+                readonly ground: readonly [1.488, 0.894, 0.616];
+            };
+        };
+        readonly exposure: {
+            readonly day: 1.741;
+            readonly golden: 1.741;
+            readonly overcast: 1.866;
+            readonly night: 2.144;
+        };
+        readonly hdri: {
+            readonly day: null;
+            readonly golden: null;
+            readonly overcast: null;
+            readonly night: {
+                readonly name: "moonless_golf";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+        };
+        readonly skyIrradiance: {
+            readonly day: 8.595;
+            readonly golden: 5.273;
+            readonly overcast: 3.286;
+            readonly night: 0.011;
+        };
+    };
+    readonly beam_loft: {
+        readonly label: "Beam Loft";
+        readonly description: "A tall plaster room under oak beams: three paned windows on the east side over a slatted oak ledge, dark boards, a pale modular sofa, a leather lounge chair and an opal globe on a long cord.";
+        readonly build: "306f502d2191";
+        readonly presetsVersion: 1;
+        readonly size: {
+            readonly width: 9;
+            readonly height: 3.7;
+            readonly depth: 7.6;
+        };
+        readonly lighting: "day";
+        readonly surfaces: {
+            readonly floor: {
+                readonly material: "plank_flooring_04";
+                readonly color: "#b7aea4";
+            };
+            readonly walls: {
+                readonly material: "white_plaster";
+                readonly color: "#eeebe5";
+            };
+            readonly ceiling: {
+                readonly material: "white_plaster";
+                readonly color: "#f2f0eb";
+            };
+            readonly sill: {
+                readonly material: "coated_pine";
+            };
+        };
+        readonly stand: {
+            readonly type: "coffee_table_round_01";
+            readonly material: null;
+            readonly x: 0.2;
+            readonly z: -1.5;
+            readonly rotationDeg: 0;
+            readonly top: 0.491;
+            readonly size: {
+                readonly x: 1.3013;
+                readonly y: 0.491;
+                readonly z: 1.3013;
+            };
+        };
+        readonly camera: {
+            readonly position: readonly [-1.7117, 1.3, 2.7937];
+            readonly target: readonly [0.2, 0.741, -1.5];
+            readonly lensMm: 21;
+            readonly fstop: 5.599999904632568;
+        };
+        readonly preview: {
+            readonly glb: "rooms/beam_loft/room.glb";
+            readonly bytes: 2350456;
+            readonly triangles: 102810;
+            readonly textures: 37;
+        };
+        readonly complexity: {
+            readonly enclosure: 1;
+            readonly objects: 51;
+        };
+        readonly prebaked: readonly [];
+        readonly baked: readonly ["day", "golden", "night"];
+        readonly standGlb: "rooms/beam_loft/stand.glb";
+        readonly plants: readonly ["potted_dracaena_01", "potted_plant_01"];
+        readonly pictures: readonly [];
+        readonly previewBrightness: {
+            readonly day: 1.877;
+            readonly golden: 2.176;
+            readonly overcast: 0.381;
+            readonly night: 0.191;
+        };
+        readonly previewFill: {
+            readonly day: {
+                readonly sky: readonly [0.976, 1.001, 1.058];
+                readonly ground: readonly [1.076, 0.986, 0.914];
+            };
+            readonly golden: {
+                readonly sky: readonly [1.242, 0.96, 0.686];
+                readonly ground: readonly [1.355, 0.936, 0.586];
+            };
+            readonly overcast: {
+                readonly sky: readonly [0.964, 1.004, 1.071];
+                readonly ground: readonly [1.062, 0.989, 0.925];
+            };
+            readonly night: {
+                readonly sky: readonly [1.466, 0.899, 0.627];
+                readonly ground: readonly [1.59, 0.872, 0.533];
+            };
+        };
+        readonly exposure: {
+            readonly day: 1.741;
+            readonly golden: 1.741;
+            readonly overcast: 1.866;
+            readonly night: 2.144;
+        };
+        readonly hdri: {
+            readonly day: {
+                readonly name: "horn-koppe_spring";
+                readonly rotationDeg: 352;
+                readonly groundHeight: 1.6;
+            };
+            readonly golden: {
+                readonly name: "umhlanga_sunrise";
+                readonly rotationDeg: 330;
+                readonly groundHeight: 1.6;
+            };
+            readonly overcast: {
+                readonly name: "dalkey_view";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+            readonly night: {
+                readonly name: "preller_drive";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+        };
+        readonly skyIrradiance: {
+            readonly day: 8.707;
+            readonly golden: 5.273;
+            readonly overcast: 3.286;
+            readonly night: 0.011;
+        };
+    };
+    readonly conservatory_day: {
+        readonly label: "Conservatory";
+        readonly description: "Travertine and white plaster under a foliage-broken roof light, three east windows of morning sun, and all five plants of the set standing around a vase on a marble cylinder.";
+        readonly build: "37c1bf94d793";
+        readonly presetsVersion: 1;
+        readonly size: {
+            readonly width: 5.6;
+            readonly height: 3.4;
+            readonly depth: 5.6;
+        };
+        readonly lighting: "day";
+        readonly surfaces: {
+            readonly floor: {
+                readonly material: "travertine";
+                readonly color: "#ffffff";
+            };
+            readonly walls: {
+                readonly material: "white_plaster";
+                readonly color: "#f9f3fa";
+            };
+            readonly ceiling: {
+                readonly material: "matte_paint";
+                readonly color: "#f5f4f0";
+            };
+            readonly sill: {
+                readonly material: "travertine";
+            };
+        };
+        readonly stand: {
+            readonly type: "pedestal_cylinder";
+            readonly material: "carrara_marble";
+            readonly x: 0;
+            readonly z: -0.15;
+            readonly rotationDeg: 0;
+            readonly top: 0.95;
+            readonly size: {
+                readonly x: 0.42;
+                readonly y: 0.95;
+                readonly z: 0.42;
+            };
+        };
+        readonly camera: {
+            readonly position: readonly [-0.2066, 1.3, -0.9848];
+            readonly target: readonly [0, 1.2, -0.15];
+            readonly lensMm: 26;
+            readonly fstop: 4;
+        };
+        readonly preview: {
+            readonly glb: "rooms/conservatory_day/room.glb";
+            readonly bytes: 3089392;
+            readonly triangles: 171145;
+            readonly textures: 35;
+        };
+        readonly complexity: {
+            readonly enclosure: 1;
+            readonly objects: 60;
+        };
+        readonly prebaked: readonly [];
+        readonly baked: readonly ["day", "golden", "night"];
+        readonly standGlb: "rooms/conservatory_day/stand.glb";
+        readonly plants: readonly ["potted_bird_of_paradise_01", "potted_monstera_01", "potted_monstera_02", "potted_plant_04"];
+        readonly pictures: readonly [];
+        readonly previewBrightness: {
+            readonly day: 1.551;
+            readonly golden: 1.292;
+            readonly overcast: 1.447;
+            readonly night: 0.196;
+        };
+        readonly previewFill: {
+            readonly day: {
+                readonly sky: readonly [0.966, 1, 1.104];
+                readonly ground: readonly [0.966, 1, 1.104];
+            };
+            readonly golden: {
+                readonly sky: readonly [1.22, 0.961, 0.738];
+                readonly ground: readonly [1.22, 0.961, 0.738];
+            };
+            readonly overcast: {
+                readonly sky: readonly [1.001, 0.996, 1.036];
+                readonly ground: readonly [1.001, 0.996, 1.036];
+            };
+            readonly night: {
+                readonly sky: readonly [1.486, 0.894, 0.619];
+                readonly ground: readonly [1.486, 0.894, 0.619];
+            };
+        };
+        readonly exposure: {
+            readonly day: 1.741;
+            readonly golden: 1.741;
+            readonly overcast: 1.866;
+            readonly night: 2.144;
+        };
+        readonly hdri: {
+            readonly day: {
+                readonly name: "grasslands_sunset";
+                readonly rotationDeg: 299.3;
+                readonly groundHeight: 1.6;
+            };
+            readonly golden: {
+                readonly name: "qwantani_sunset";
+                readonly rotationDeg: 304;
+                readonly groundHeight: 1.6;
+            };
+            readonly overcast: {
+                readonly name: "dalkey_view";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+            readonly night: {
+                readonly name: "moonless_golf";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+        };
+        readonly skyIrradiance: {
+            readonly day: 8.707;
+            readonly golden: 5.273;
+            readonly overcast: 3.286;
+            readonly night: 0.011;
+        };
+    };
+    readonly dining_golden: {
+        readonly label: "Golden Hour Dining";
+        readonly description: "Painted brick and dark planks, low sun through rippled cast glass, a walnut table set for four off to one side and a bird of paradise holding the light.";
+        readonly build: "aaf9e73a653b";
+        readonly presetsVersion: 1;
+        readonly size: {
+            readonly width: 7;
+            readonly height: 3.3;
+            readonly depth: 5.2;
+        };
+        readonly lighting: "golden";
+        readonly surfaces: {
+            readonly floor: {
+                readonly material: "oak_veneer_05";
+                readonly color: "#ffffff";
+            };
+            readonly walls: {
+                readonly material: "matte_paint";
+                readonly color: "#efe6d9";
+            };
+            readonly ceiling: {
+                readonly material: "matte_paint";
+                readonly color: "#f5f4f0";
+            };
+            readonly sill: {
+                readonly material: "polished_concrete";
+            };
+        };
+        readonly stand: {
+            readonly type: "round_wooden_table_01";
+            readonly material: null;
+            readonly x: 0.69;
+            readonly z: -0.38;
+            readonly rotationDeg: 0;
+            readonly top: 1.005;
+            readonly size: {
+                readonly x: 1.3993;
+                readonly y: 1.005;
+                readonly z: 1.3993;
+            };
+        };
+        readonly camera: {
+            readonly position: readonly [0.9851, 1.21, -0.0142];
+            readonly target: readonly [0.69, 1.255, -0.38];
+            readonly lensMm: 24;
+            readonly fstop: 4;
+        };
+        readonly preview: {
+            readonly glb: "rooms/dining_golden/room.glb";
+            readonly bytes: 1020424;
+            readonly triangles: 29323;
+            readonly textures: 24;
+        };
+        readonly complexity: {
+            readonly enclosure: 1;
+            readonly objects: 60;
+        };
+        readonly prebaked: readonly [];
+        readonly baked: readonly ["day", "golden", "night"];
+        readonly standGlb: "rooms/dining_golden/stand.glb";
+        readonly plants: readonly ["potted_bird_of_paradise_01", "potted_plant_04"];
+        readonly pictures: readonly [];
+        readonly previewBrightness: {
+            readonly day: 0.196;
+            readonly golden: 0.31;
+            readonly overcast: 0.289;
+            readonly night: 0.154;
+        };
+        readonly previewFill: {
+            readonly day: {
+                readonly sky: readonly [1.074, 0.983, 0.948];
+                readonly ground: readonly [1.074, 0.983, 0.948];
+            };
+            readonly golden: {
+                readonly sky: readonly [1.338, 0.937, 0.63];
+                readonly ground: readonly [1.338, 0.937, 0.63];
+            };
+            readonly overcast: {
+                readonly sky: readonly [1.297, 0.934, 0.775];
+                readonly ground: readonly [1.297, 0.934, 0.775];
+            };
+            readonly night: {
+                readonly sky: readonly [1.487, 0.894, 0.617];
+                readonly ground: readonly [1.487, 0.894, 0.617];
+            };
+        };
+        readonly exposure: {
+            readonly day: 1.741;
+            readonly golden: 1.741;
+            readonly overcast: 1.866;
+            readonly night: 2.144;
+        };
+        readonly hdri: {
+            readonly day: {
+                readonly name: "pergola_walkway";
+                readonly rotationDeg: 79.7;
+                readonly groundHeight: 1.6;
+            };
+            readonly golden: {
+                readonly name: "bambanani_sunset";
+                readonly rotationDeg: 104;
+                readonly groundHeight: 1.6;
+            };
+            readonly overcast: {
+                readonly name: "dalkey_view";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+            readonly night: {
+                readonly name: "moonless_golf";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+        };
+        readonly skyIrradiance: {
+            readonly day: 8.468;
+            readonly golden: 5.273;
+            readonly overcast: 3.286;
+            readonly night: 0.011;
+        };
+    };
+    readonly gallery_day: {
+        readonly label: "Daylight Gallery";
+        readonly description: "White plaster and oak, three tall west windows with foliage-dappled midday sun, shelves of ceramics behind the centerpiece.";
+        readonly build: "4b9e7b77b32b";
+        readonly presetsVersion: 1;
+        readonly size: {
+            readonly width: 6;
+            readonly height: 3.2;
+            readonly depth: 5;
+        };
+        readonly lighting: "day";
+        readonly surfaces: {
+            readonly floor: {
+                readonly material: "oak_floor";
+                readonly color: "#ffffff";
+            };
+            readonly walls: {
+                readonly material: "white_plaster";
+                readonly color: "#f4f1ea";
+            };
+            readonly ceiling: {
+                readonly material: "matte_paint";
+                readonly color: "#f5f4f0";
+            };
+            readonly sill: {
+                readonly material: "travertine";
+            };
+        };
+        readonly stand: {
+            readonly type: "pedestal_block";
+            readonly material: "carrara_marble";
+            readonly x: 0.18;
+            readonly z: -0.36;
+            readonly rotationDeg: 0;
+            readonly top: 1;
+            readonly size: {
+                readonly x: 0.4;
+                readonly y: 1;
+                readonly z: 0.4;
+            };
+        };
+        readonly camera: {
+            readonly position: readonly [0.3653, 1.17, -0.0055];
+            readonly target: readonly [0.18, 1.25, -0.36];
+            readonly lensMm: 34;
+            readonly fstop: 4;
+        };
+        readonly preview: {
+            readonly glb: "rooms/gallery_day/room.glb";
+            readonly bytes: 2109044;
+            readonly triangles: 119502;
+            readonly textures: 21;
+        };
+        readonly complexity: {
+            readonly enclosure: 1;
+            readonly objects: 72;
+        };
+        readonly prebaked: readonly [];
+        readonly baked: readonly ["day", "golden", "night"];
+        readonly standGlb: "rooms/gallery_day/stand.glb";
+        readonly plants: readonly ["potted_plant_01", "potted_plant_04"];
+        readonly pictures: readonly [];
+        readonly previewBrightness: {
+            readonly day: 0.093;
+            readonly golden: 0.15;
+            readonly overcast: 0.043;
+            readonly night: 0.159;
+        };
+        readonly previewFill: {
+            readonly day: {
+                readonly sky: readonly [1.101, 0.978, 0.915];
+                readonly ground: readonly [1.101, 0.978, 0.915];
+            };
+            readonly golden: {
+                readonly sky: readonly [1.298, 0.947, 0.643];
+                readonly ground: readonly [1.298, 0.947, 0.643];
+            };
+            readonly overcast: {
+                readonly sky: readonly [1.266, 0.942, 0.791];
+                readonly ground: readonly [1.266, 0.942, 0.791];
+            };
+            readonly night: {
+                readonly sky: readonly [1.488, 0.894, 0.615];
+                readonly ground: readonly [1.488, 0.894, 0.615];
+            };
+        };
+        readonly exposure: {
+            readonly day: 1.741;
+            readonly golden: 1.741;
+            readonly overcast: 1.866;
+            readonly night: 2.144;
+        };
+        readonly hdri: {
+            readonly day: {
+                readonly name: "sunny_country_road";
+                readonly rotationDeg: 127;
+                readonly groundHeight: 1.6;
+            };
+            readonly golden: {
+                readonly name: "qwantani_sunset";
+                readonly rotationDeg: 124;
+                readonly groundHeight: 1.6;
+            };
+            readonly overcast: {
+                readonly name: "dalkey_view";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+            readonly night: {
+                readonly name: "moonless_golf";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+        };
+        readonly skyIrradiance: {
+            readonly day: 8.212;
+            readonly golden: 5.273;
+            readonly overcast: 3.286;
+            readonly night: 0.011;
+        };
+    };
+    readonly living_evening: {
+        readonly label: "Evening Living Room";
+        readonly description: "Warm greige and hardwood after dark: a channel-tufted sofa under a washed wall, a plaster console opposite, monstera and palm in the corners.";
+        readonly build: "204a81d87141";
+        readonly presetsVersion: 1;
+        readonly size: {
+            readonly width: 6.4;
+            readonly height: 3;
+            readonly depth: 5.4;
+        };
+        readonly lighting: "night";
+        readonly surfaces: {
+            readonly floor: {
+                readonly material: "wooden_floor_02";
+                readonly color: "#ffffff";
+            };
+            readonly walls: {
+                readonly material: "matte_paint";
+                readonly color: "#e5ded2";
+            };
+            readonly ceiling: {
+                readonly material: "matte_paint";
+                readonly color: "#f5f4f0";
+            };
+            readonly sill: {
+                readonly material: "travertine";
+            };
+        };
+        readonly stand: {
+            readonly type: "pedestal_cylinder";
+            readonly material: "carrara_marble";
+            readonly x: 0.75;
+            readonly z: -0.15;
+            readonly rotationDeg: 0;
+            readonly top: 0.95;
+            readonly size: {
+                readonly x: 0.42;
+                readonly y: 0.95;
+                readonly z: 0.42;
+            };
+        };
+        readonly camera: {
+            readonly position: readonly [1.8407, 0.78, 1.0613];
+            readonly target: readonly [0.75, 1.2, -0.15];
+            readonly lensMm: 32;
+            readonly fstop: 3.200000047683716;
+        };
+        readonly preview: {
+            readonly glb: "rooms/living_evening/room.glb";
+            readonly bytes: 4367688;
+            readonly triangles: 237432;
+            readonly textures: 21;
+        };
+        readonly complexity: {
+            readonly enclosure: 1;
+            readonly objects: 102;
+        };
+        readonly prebaked: readonly [];
+        readonly baked: readonly ["day", "golden", "night"];
+        readonly standGlb: "rooms/living_evening/stand.glb";
+        readonly plants: readonly ["potted_monstera_02", "potted_palm_01"];
+        readonly pictures: readonly [{
+            readonly wall: "north";
+            readonly size: 0.7;
+        }];
+        readonly previewBrightness: {
+            readonly day: 0.134;
+            readonly golden: 0.398;
+            readonly overcast: 0.106;
+            readonly night: 0.103;
+        };
+        readonly previewFill: {
+            readonly day: {
+                readonly sky: readonly [1.126, 0.972, 0.906];
+                readonly ground: readonly [1.126, 0.972, 0.906];
+            };
+            readonly golden: {
+                readonly sky: readonly [1.331, 0.938, 0.637];
+                readonly ground: readonly [1.331, 0.938, 0.637];
+            };
+            readonly overcast: {
+                readonly sky: readonly [1.404, 0.911, 0.688];
+                readonly ground: readonly [1.404, 0.911, 0.688];
+            };
+            readonly night: {
+                readonly sky: readonly [1.488, 0.894, 0.615];
+                readonly ground: readonly [1.488, 0.894, 0.615];
+            };
+        };
+        readonly exposure: {
+            readonly day: 1.741;
+            readonly golden: 1.741;
+            readonly overcast: 1.866;
+            readonly night: 2.144;
+        };
+        readonly hdri: {
+            readonly day: {
+                readonly name: "pergola_walkway";
+                readonly rotationDeg: 79.7;
+                readonly groundHeight: 1.6;
+            };
+            readonly golden: {
+                readonly name: "qwantani_sunset";
+                readonly rotationDeg: 124;
+                readonly groundHeight: 1.6;
+            };
+            readonly overcast: {
+                readonly name: "dalkey_view";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+            readonly night: {
+                readonly name: "moonless_golf";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+        };
+        readonly skyIrradiance: {
+            readonly day: 8.468;
+            readonly golden: 5.273;
+            readonly overcast: 3.286;
+            readonly night: 0.011;
+        };
+    };
+    readonly loft_golden: {
+        readonly label: "Golden Hour Loft";
+        readonly description: "Painted brick and dark planks, two big steel-framed windows of rippled cast glass, low warm sun and a hint of haze.";
+        readonly build: "6688f7d07182";
+        readonly presetsVersion: 1;
+        readonly size: {
+            readonly width: 7;
+            readonly height: 3.6;
+            readonly depth: 5.5;
+        };
+        readonly lighting: "golden";
+        readonly surfaces: {
+            readonly floor: {
+                readonly material: "plank_flooring_04";
+                readonly color: "#ffffff";
+            };
+            readonly walls: {
+                readonly material: "white_plaster";
+                readonly color: "#f0e7da";
+            };
+            readonly ceiling: {
+                readonly material: "matte_paint";
+                readonly color: "#f5f4f0";
+            };
+            readonly sill: {
+                readonly material: "polished_concrete";
+            };
+        };
+        readonly stand: {
+            readonly type: "pedestal_cylinder";
+            readonly material: "carrara_marble";
+            readonly x: 0.1;
+            readonly z: -0.3;
+            readonly rotationDeg: 0;
+            readonly top: 0.95;
+            readonly size: {
+                readonly x: 0.42;
+                readonly y: 0.95;
+                readonly z: 0.42;
+            };
+        };
+        readonly camera: {
+            readonly position: readonly [0.7923, 1.3, 0.6924];
+            readonly target: readonly [0.1, 1.2, -0.3];
+            readonly lensMm: 35;
+            readonly fstop: 2;
+        };
+        readonly preview: {
+            readonly glb: "rooms/loft_golden/room.glb";
+            readonly bytes: 3578328;
+            readonly triangles: 165919;
+            readonly textures: 23;
+        };
+        readonly complexity: {
+            readonly enclosure: 1;
+            readonly objects: 64;
+        };
+        readonly prebaked: readonly [];
+        readonly baked: readonly ["day", "golden", "night"];
+        readonly standGlb: "rooms/loft_golden/stand.glb";
+        readonly plants: readonly ["potted_monstera_01", "potted_palm_01"];
+        readonly pictures: readonly [];
+        readonly previewBrightness: {
+            readonly day: 0.584;
+            readonly golden: 1.034;
+            readonly overcast: 0.965;
+            readonly night: 0.205;
+        };
+        readonly previewFill: {
+            readonly day: {
+                readonly sky: readonly [1.056, 0.998, 0.852];
+                readonly ground: readonly [1.056, 0.998, 0.852];
+            };
+            readonly golden: {
+                readonly sky: readonly [1.414, 0.896, 0.816];
+                readonly ground: readonly [1.414, 0.896, 0.816];
+            };
+            readonly overcast: {
+                readonly sky: readonly [0.953, 1.019, 0.947];
+                readonly ground: readonly [0.953, 1.019, 0.947];
+            };
+            readonly night: {
+                readonly sky: readonly [1.485, 0.895, 0.614];
+                readonly ground: readonly [1.485, 0.895, 0.614];
+            };
+        };
+        readonly exposure: {
+            readonly day: 1.741;
+            readonly golden: 1.741;
+            readonly overcast: 1.866;
+            readonly night: 2.144;
+        };
+        readonly hdri: {
+            readonly day: {
+                readonly name: "pergola_walkway";
+                readonly rotationDeg: 79.7;
+                readonly groundHeight: 1.6;
+            };
+            readonly golden: {
+                readonly name: "the_sky_is_on_fire";
+                readonly rotationDeg: 45.4;
+                readonly groundHeight: 1.6;
+            };
+            readonly overcast: {
+                readonly name: "dalkey_view";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+            readonly night: {
+                readonly name: "moonless_golf";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+        };
+        readonly skyIrradiance: {
+            readonly day: 8.468;
+            readonly golden: 5.273;
+            readonly overcast: 3.286;
+            readonly night: 0.011;
+        };
+    };
+    readonly noir_parlour: {
+        readonly label: "Noir Parlour";
+        readonly description: "Charcoal walls in frame mouldings above a dado rail, a pale skirting, grey oak boards, two leather lounge chairs under a pair of white pendants and a print between them.";
+        readonly build: "c444e081de93";
+        readonly presetsVersion: 1;
+        readonly size: {
+            readonly width: 7.6;
+            readonly height: 3.4;
+            readonly depth: 6.2;
+        };
+        readonly lighting: "golden";
+        readonly surfaces: {
+            readonly floor: {
+                readonly material: "wooden_floor_02";
+                readonly color: "#7d7872";
+            };
+            readonly walls: {
+                readonly material: "matte_paint";
+                readonly color: "#2b2b2f";
+            };
+            readonly ceiling: {
+                readonly material: "matte_paint";
+                readonly color: "#3b3b40";
+            };
+            readonly sill: {
+                readonly material: "polished_concrete";
+            };
+        };
+        readonly stand: {
+            readonly type: "oval_side_table";
+            readonly material: null;
+            readonly x: 0;
+            readonly z: -1.9;
+            readonly rotationDeg: 0;
+            readonly top: 0.6048;
+            readonly size: {
+                readonly x: 0.562;
+                readonly y: 0.605;
+                readonly z: 0.34;
+            };
+        };
+        readonly camera: {
+            readonly position: readonly [0, 1.15, 2.5];
+            readonly target: readonly [0, 0.8548, -1.9];
+            readonly lensMm: 28;
+            readonly fstop: 4;
+        };
+        readonly preview: {
+            readonly glb: "rooms/noir_parlour/room.glb";
+            readonly bytes: 1399740;
+            readonly triangles: 55172;
+            readonly textures: 20;
+        };
+        readonly complexity: {
+            readonly enclosure: 1;
+            readonly objects: 55;
+        };
+        readonly prebaked: readonly [];
+        readonly baked: readonly ["day", "golden", "night"];
+        readonly standGlb: "rooms/noir_parlour/stand.glb";
+        readonly plants: readonly ["potted_dracaena_01"];
+        readonly pictures: readonly [{
+            readonly wall: "north";
+            readonly size: 1.25;
+        }];
+        readonly previewBrightness: {
+            readonly day: 0.362;
+            readonly golden: 0.367;
+            readonly overcast: 0.111;
+            readonly night: 0.168;
+        };
+        readonly previewFill: {
+            readonly day: {
+                readonly sky: readonly [1.021, 0.994, 0.999];
+                readonly ground: readonly [1.101, 0.982, 0.884];
+            };
+            readonly golden: {
+                readonly sky: readonly [1.22, 0.963, 0.723];
+                readonly ground: readonly [1.308, 0.945, 0.636];
+            };
+            readonly overcast: {
+                readonly sky: readonly [1.083, 0.979, 0.964];
+                readonly ground: readonly [1.167, 0.965, 0.852];
+            };
+            readonly night: {
+                readonly sky: readonly [1.486, 0.894, 0.618];
+                readonly ground: readonly [1.584, 0.873, 0.54];
+            };
+        };
+        readonly exposure: {
+            readonly day: 1.741;
+            readonly golden: 1.741;
+            readonly overcast: 1.866;
+            readonly night: 2.144;
+        };
+        readonly hdri: {
+            readonly day: {
+                readonly name: "horn-koppe_spring";
+                readonly rotationDeg: 114;
+                readonly groundHeight: 1.6;
+            };
+            readonly golden: {
+                readonly name: "bambanani_sunset";
+                readonly rotationDeg: 136;
+                readonly groundHeight: 1.6;
+            };
+            readonly overcast: {
+                readonly name: "dalkey_view";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+            readonly night: {
+                readonly name: "satara_night";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+        };
+        readonly skyIrradiance: {
+            readonly day: 8.34;
+            readonly golden: 5.529;
+            readonly overcast: 3.286;
+            readonly night: 0.011;
+        };
+    };
+    readonly plaster_atelier: {
+        readonly label: "Plaster Atelier";
+        readonly description: "Raw plaster, a concrete floor and one tall opening on the west side that lays a slab of sun across the room. A low white sofa against a travertine wall, a dome pendant, a palm in the corner.";
+        readonly build: "6ee46115fa42";
+        readonly presetsVersion: 1;
+        readonly size: {
+            readonly width: 10;
+            readonly height: 3.8;
+            readonly depth: 7.6;
+        };
+        readonly lighting: "day";
+        readonly surfaces: {
+            readonly floor: {
+                readonly material: "polished_concrete";
+                readonly color: "#e2e0dc";
+            };
+            readonly walls: {
+                readonly material: "white_plaster";
+                readonly color: "#dcd7ce";
+            };
+            readonly ceiling: {
+                readonly material: "white_plaster";
+                readonly color: "#f1efea";
+            };
+            readonly sill: {
+                readonly material: "polished_concrete";
+            };
+        };
+        readonly stand: {
+            readonly type: "pedestal_cylinder";
+            readonly material: "travertine";
+            readonly x: -1.7;
+            readonly z: -1;
+            readonly rotationDeg: 0;
+            readonly top: 0.95;
+            readonly size: {
+                readonly x: 0.42;
+                readonly y: 0.95;
+                readonly z: 0.42;
+            };
+        };
+        readonly camera: {
+            readonly position: readonly [-2.6356, 1.2, 3.4017];
+            readonly target: readonly [-1.7, 1.2, -1];
+            readonly lensMm: 24;
+            readonly fstop: 5.599999904632568;
+        };
+        readonly preview: {
+            readonly glb: "rooms/plaster_atelier/room.glb";
+            readonly bytes: 3991680;
+            readonly triangles: 187489;
+            readonly textures: 30;
+        };
+        readonly complexity: {
+            readonly enclosure: 1;
+            readonly objects: 37;
+        };
+        readonly prebaked: readonly [];
+        readonly baked: readonly ["day", "golden", "night"];
+        readonly standGlb: "rooms/plaster_atelier/stand.glb";
+        readonly plants: readonly ["potted_palm_01", "potted_plant_01"];
+        readonly pictures: readonly [];
+        readonly previewBrightness: {
+            readonly day: 1.478;
+            readonly golden: 1.742;
+            readonly overcast: 0.314;
+            readonly night: 0.182;
+        };
+        readonly previewFill: {
+            readonly day: {
+                readonly sky: readonly [0.975, 1.002, 1.058];
+                readonly ground: readonly [0.993, 1.001, 1.015];
+            };
+            readonly golden: {
+                readonly sky: readonly [1.223, 0.964, 0.704];
+                readonly ground: readonly [1.244, 0.961, 0.674];
+            };
+            readonly overcast: {
+                readonly sky: readonly [0.964, 1.004, 1.071];
+                readonly ground: readonly [0.982, 1.003, 1.027];
+            };
+            readonly night: {
+                readonly sky: readonly [1.427, 0.909, 0.647];
+                readonly ground: readonly [1.449, 0.905, 0.618];
+            };
+        };
+        readonly exposure: {
+            readonly day: 1.741;
+            readonly golden: 1.741;
+            readonly overcast: 1.866;
+            readonly night: 2.144;
+        };
+        readonly hdri: {
+            readonly day: {
+                readonly name: "sunny_country_road";
+                readonly rotationDeg: 122;
+                readonly groundHeight: 1.6;
+            };
+            readonly golden: {
+                readonly name: "venice_sunset";
+                readonly rotationDeg: 136;
+                readonly groundHeight: 1.6;
+            };
+            readonly overcast: {
+                readonly name: "dalkey_view";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+            readonly night: {
+                readonly name: "preller_drive";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+        };
+        readonly skyIrradiance: {
+            readonly day: 8.633;
+            readonly golden: 5.273;
+            readonly overcast: 3.286;
+            readonly night: 0.011;
+        };
+    };
+    readonly slat_lounge: {
+        readonly label: "Oak Slat Lounge";
+        readonly description: "Oak battens either side of a charcoal wall, a low sofa under a large print, and tall windows behind sheers on the east side.";
+        readonly build: "d4b3a554137d";
+        readonly presetsVersion: 1;
+        readonly size: {
+            readonly width: 8.4;
+            readonly height: 3;
+            readonly depth: 6.4;
+        };
+        readonly lighting: "day";
+        readonly surfaces: {
+            readonly floor: {
+                readonly material: "wooden_floor_02";
+                readonly color: "#e6e2dc";
+            };
+            readonly walls: {
+                readonly material: "matte_paint";
+                readonly color: "#e9e6e0";
+            };
+            readonly ceiling: {
+                readonly material: "matte_paint";
+                readonly color: "#f5f4f0";
+            };
+            readonly sill: {
+                readonly material: "polished_concrete";
+            };
+        };
+        readonly stand: {
+            readonly type: "coffee_table_round_01";
+            readonly material: null;
+            readonly x: -0.7;
+            readonly z: -0.7;
+            readonly rotationDeg: 0;
+            readonly top: 0.491;
+            readonly size: {
+                readonly x: 1.3013;
+                readonly y: 0.491;
+                readonly z: 1.3013;
+            };
+        };
+        readonly camera: {
+            readonly position: readonly [-2.75, 1.2, 2.8507];
+            readonly target: readonly [-0.7, 0.741, -0.7];
+            readonly lensMm: 24;
+            readonly fstop: 5.599999904632568;
+        };
+        readonly preview: {
+            readonly glb: "rooms/slat_lounge/room.glb";
+            readonly bytes: 2042948;
+            readonly triangles: 122153;
+            readonly textures: 30;
+        };
+        readonly complexity: {
+            readonly enclosure: 1;
+            readonly objects: 77;
+        };
+        readonly prebaked: readonly [];
+        readonly baked: readonly ["day", "golden", "night"];
+        readonly standGlb: "rooms/slat_lounge/stand.glb";
+        readonly plants: readonly ["potted_bird_of_paradise_01", "potted_monstera_02"];
+        readonly pictures: readonly [{
+            readonly wall: "north";
+            readonly size: 1.25;
+        }];
+        readonly previewBrightness: {
+            readonly day: 0.346;
+            readonly golden: 0.383;
+            readonly overcast: 0.121;
+            readonly night: 0.191;
+        };
+        readonly previewFill: {
+            readonly day: {
+                readonly sky: readonly [1.05, 0.987, 0.978];
+                readonly ground: readonly [1.088, 0.982, 0.915];
+            };
+            readonly golden: {
+                readonly sky: readonly [1.273, 0.952, 0.672];
+                readonly ground: readonly [1.314, 0.944, 0.628];
+            };
+            readonly overcast: {
+                readonly sky: readonly [1.213, 0.952, 0.844];
+                readonly ground: readonly [1.254, 0.946, 0.789];
+            };
+            readonly night: {
+                readonly sky: readonly [1.46, 0.901, 0.63];
+                readonly ground: readonly [1.504, 0.892, 0.587];
+            };
+        };
+        readonly exposure: {
+            readonly day: 1.741;
+            readonly golden: 1.741;
+            readonly overcast: 1.866;
+            readonly night: 2.144;
+        };
+        readonly hdri: {
+            readonly day: {
+                readonly name: "pergola_walkway";
+                readonly rotationDeg: 317.7;
+                readonly groundHeight: 1.6;
+            };
+            readonly golden: {
+                readonly name: "qwantani_sunset";
+                readonly rotationDeg: 332;
+                readonly groundHeight: 1.6;
+            };
+            readonly overcast: {
+                readonly name: "dalkey_view";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+            readonly night: {
+                readonly name: "moonless_golf";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+        };
+        readonly skyIrradiance: {
+            readonly day: 8.468;
+            readonly golden: 5.273;
+            readonly overcast: 3.286;
+            readonly night: 0.011;
+        };
+    };
+    readonly studio_night: {
+        readonly label: "Night Studio";
+        readonly description: "Warm greige walls after dark: IES downlights, a lit cove channel round the ceiling and one accent spot carrying the centerpiece.";
+        readonly build: "a62ba8b9dc1f";
+        readonly presetsVersion: 1;
+        readonly size: {
+            readonly width: 5;
+            readonly height: 3;
+            readonly depth: 4.4;
+        };
+        readonly lighting: "night";
+        readonly surfaces: {
+            readonly floor: {
+                readonly material: "polished_concrete";
+                readonly color: "#ffffff";
+            };
+            readonly walls: {
+                readonly material: "matte_paint";
+                readonly color: "#e6dfd3";
+            };
+            readonly ceiling: {
+                readonly material: "matte_paint";
+                readonly color: "#f5f4f0";
+            };
+            readonly sill: {
+                readonly material: "carrara_marble";
+            };
+        };
+        readonly stand: {
+            readonly type: null;
+            readonly material: null;
+            readonly x: 0;
+            readonly z: 0;
+            readonly rotationDeg: 0;
+            readonly top: 0;
+            readonly size: null;
+        };
+        readonly camera: {
+            readonly position: readonly [-1.5455, 0.83, 1.2695];
+            readonly target: readonly [0, 0.25, 0];
+            readonly lensMm: 38;
+            readonly fstop: 2;
+        };
+        readonly preview: {
+            readonly glb: "rooms/studio_night/room.glb";
+            readonly bytes: 4251684;
+            readonly triangles: 185457;
+            readonly textures: 21;
+        };
+        readonly complexity: {
+            readonly enclosure: 1;
+            readonly objects: 63;
+        };
+        readonly prebaked: readonly [];
+        readonly baked: readonly ["day", "golden", "night"];
+        readonly standGlb: null;
+        readonly plants: readonly ["potted_palm_01", "potted_plant_04"];
+        readonly pictures: readonly [];
+        readonly previewBrightness: {
+            readonly day: 0.222;
+            readonly golden: 0.636;
+            readonly overcast: 0.482;
+            readonly night: 0.466;
+        };
+        readonly previewFill: {
+            readonly day: {
+                readonly sky: readonly [1.222, 0.951, 0.829];
+                readonly ground: readonly [1.222, 0.951, 0.829];
+            };
+            readonly golden: {
+                readonly sky: readonly [1.37, 0.927, 0.632];
+                readonly ground: readonly [1.37, 0.927, 0.632];
+            };
+            readonly overcast: {
+                readonly sky: readonly [1.439, 0.904, 0.657];
+                readonly ground: readonly [1.439, 0.904, 0.657];
+            };
+            readonly night: {
+                readonly sky: readonly [1.486, 0.894, 0.616];
+                readonly ground: readonly [1.486, 0.894, 0.616];
+            };
+        };
+        readonly exposure: {
+            readonly day: 1.741;
+            readonly golden: 1.741;
+            readonly overcast: 1.866;
+            readonly night: 2.144;
+        };
+        readonly hdri: {
+            readonly day: {
+                readonly name: "pergola_walkway";
+                readonly rotationDeg: 169.7;
+                readonly groundHeight: 1.6;
+            };
+            readonly golden: {
+                readonly name: "qwantani_sunset";
+                readonly rotationDeg: 214;
+                readonly groundHeight: 1.6;
+            };
+            readonly overcast: {
+                readonly name: "dalkey_view";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+            readonly night: {
+                readonly name: "satara_night";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+        };
+        readonly skyIrradiance: {
+            readonly day: 8.468;
+            readonly golden: 5.273;
+            readonly overcast: 3.286;
+            readonly night: 0.011;
+        };
+    };
+    readonly walnut_salon: {
+        readonly label: "Walnut Salon";
+        readonly description: "A long wall of walnut veneer and slatted bays under a lit cove, a pale modular sofa in front of it, three disc pendants at different heights and a charcoal wall with a print on the east side.";
+        readonly build: "ce8b1acc2907";
+        readonly presetsVersion: 1;
+        readonly size: {
+            readonly width: 10;
+            readonly height: 3.2;
+            readonly depth: 7;
+        };
+        readonly lighting: "night";
+        readonly surfaces: {
+            readonly floor: {
+                readonly material: "polished_concrete";
+                readonly color: "#cfccc6";
+            };
+            readonly walls: {
+                readonly material: "matte_paint";
+                readonly color: "#ddd7cd";
+            };
+            readonly ceiling: {
+                readonly material: "matte_paint";
+                readonly color: "#e4e1db";
+            };
+            readonly sill: {
+                readonly material: "polished_concrete";
+            };
+        };
+        readonly stand: {
+            readonly type: "coffee_table_round_01";
+            readonly material: null;
+            readonly x: 0.2;
+            readonly z: -1.2;
+            readonly rotationDeg: 0;
+            readonly top: 0.491;
+            readonly size: {
+                readonly x: 1.3013;
+                readonly y: 0.491;
+                readonly z: 1.3013;
+            };
+        };
+        readonly camera: {
+            readonly position: readonly [0.2, 1.45, 3.2];
+            readonly target: readonly [0.2, 0.741, -1.2];
+            readonly lensMm: 24;
+            readonly fstop: 5.599999904632568;
+        };
+        readonly preview: {
+            readonly glb: "rooms/walnut_salon/room.glb";
+            readonly bytes: 1958456;
+            readonly triangles: 121487;
+            readonly textures: 36;
+        };
+        readonly complexity: {
+            readonly enclosure: 1;
+            readonly objects: 117;
+        };
+        readonly prebaked: readonly [];
+        readonly baked: readonly ["day", "golden", "night"];
+        readonly standGlb: "rooms/walnut_salon/stand.glb";
+        readonly plants: readonly ["potted_bird_of_paradise_01", "potted_monstera_02"];
+        readonly pictures: readonly [{
+            readonly wall: "east";
+            readonly size: 1.3;
+        }];
+        readonly previewBrightness: {
+            readonly day: 0.295;
+            readonly golden: 0.295;
+            readonly overcast: 0.13;
+            readonly night: 0.313;
+        };
+        readonly previewFill: {
+            readonly day: {
+                readonly sky: readonly [1.112, 0.975, 0.922];
+                readonly ground: readonly [1.145, 0.971, 0.859];
+            };
+            readonly golden: {
+                readonly sky: readonly [1.301, 0.944, 0.67];
+                readonly ground: readonly [1.336, 0.938, 0.623];
+            };
+            readonly overcast: {
+                readonly sky: readonly [1.35, 0.925, 0.716];
+                readonly ground: readonly [1.386, 0.919, 0.665];
+            };
+            readonly night: {
+                readonly sky: readonly [1.427, 0.909, 0.645];
+                readonly ground: readonly [1.464, 0.902, 0.599];
+            };
+        };
+        readonly exposure: {
+            readonly day: 1.741;
+            readonly golden: 1.741;
+            readonly overcast: 1.866;
+            readonly night: 2.144;
+        };
+        readonly hdri: {
+            readonly day: {
+                readonly name: "pergola_walkway";
+                readonly rotationDeg: 59.7;
+                readonly groundHeight: 1.6;
+            };
+            readonly golden: {
+                readonly name: "qwantani_sunset";
+                readonly rotationDeg: 132;
+                readonly groundHeight: 1.6;
+            };
+            readonly overcast: {
+                readonly name: "dalkey_view";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+            readonly night: {
+                readonly name: "moonless_golf";
+                readonly rotationDeg: 0;
+                readonly groundHeight: 1.6;
+            };
+        };
+        readonly skyIrradiance: {
+            readonly day: 8.468;
+            readonly golden: 5.273;
+            readonly overcast: 3.286;
+            readonly night: 0.011;
+        };
+    };
+};
+type RoomPresetName = keyof typeof ROOM_PRESETS;
+
+/**
+ * A catalog from a server: models by URL, shots per product, no browser.
+ *
+ *     import { Bakery3Server } from '@oeave/bakery3/node';
+ *     const api = new Bakery3Server(process.env.BAKERY3_SECRET_KEY!);
+ *
+ *     const run = await api.renderBatch({
+ *       key: 'fall-2026',
+ *       products: [{ id: 'chair-aria', url: 'https://cdn.shop.com/models/chair-aria.glb' }],
+ *       shots: [
+ *         'three-quarter',
+ *         { kind: 'video', from: 'three-quarter', to: 'three-quarter-back', seconds: 4 },
+ *         { id: 'low', azimuthDeg: -30, elevationDeg: 4 },
+ *       ],
+ *       room: { preset: 'loft_golden' },
+ *       maxCost: 600,
+ *     });
+ *
+ * A shot is a picture or a clip of a product from an angle: degrees around
+ * the model from its front and degrees above the horizon, or a word for one.
+ * The camera is framed from the model's own bounds, read when the model is
+ * imported, so a vase and a sofa both fill the frame from the same word and
+ * nothing is asked of the file itself. A clip is the camera carried from one
+ * angle to another over `seconds`, one framed camera per frame.
+ *
+ * Settings come in three layers: the run's, then a product's, then a shot's,
+ * the nearer winning. So one `room` at the top is every shot's room, a
+ * product that wants the studio instead says `room: null, environment: {…}`,
+ * and one shot in it can still be a close-up at 2048² in a jpeg.
+ *
+ * The model's bytes never pass through this process. Each URL is handed to
+ * `POST /v1/assets/import`; the service fetches it once, stores it content
+ * addressed like any upload, and answers with the hash and what the GLB says
+ * about itself. A model that did not change since the last run is not
+ * downloaded again. What this process sends is a few KB of manifest per shot.
+ *
+ * A manifest built here describes a model, cameras and light. A scene whose
+ * look lives in code exists only where that code runs, so it is recorded
+ * there, with `renderVariants()` in the page. Both kinds of item can share a
+ * batch.
+ *
+ * No three.js here.
+ */
+
+/**
+ * Where to look from: a word, or degrees. `'room'` is the framing a preset
+ * room was published with, from level or above: never looking up at the
+ * product.
+ */
+type View = ViewWord | 'room' | Angle;
+type BatchEnvironment = {
+    /** A studio or a sky from the preset library. */
+    preset?: HdriPresetName;
+    /**
+     * Or an HDRI of your own: a public https URL of a .hdr or .exr, imported
+     * like the models.
+     */
+    url?: string;
+    /** How strongly it lights the product. Default 1 (0.6 for the default studio). */
+    intensity?: number;
+    /** Turn the environment about the vertical, in degrees. */
+    rotationDeg?: number;
+};
+type BatchRoom = {
+    /** A room from the preset library. */
+    preset: RoomPresetName;
+    /** Default: the mode the room was designed under. */
+    mode?: RoomPresetLighting;
+    /**
+     * What the product stands on. `'auto'` (the default) goes by its size: the
+     * room's own pedestal for a small thing, the low plinth for a mid-sized
+     * one, the floor for furniture and anything that would overhang. `'own'`
+     * and `'floor'` say so yourself.
+     */
+    stand?: 'auto' | 'own' | 'floor';
+    /**
+     * Where the room's own camera sees the product from, in degrees from the
+     * product's front. The room is turned about the product to make it so.
+     * Default 30: a three-quarter view from the side the room is open to.
+     */
+    viewFromDeg?: number;
+};
+/**
+ * What every shot can say about how it is taken. Set on the run for all of
+ * them, on a product for its own, on a shot for that one; the nearest wins.
+ */
+type ShotSettings = {
+    /**
+     * A preset room to stand in. `null` says no room, where a wider layer had
+     * one.
+     */
+    room?: BatchRoom | null;
+    /**
+     * The light and backdrop when there is no room. Default: the
+     * `studio_small_03` preset at 0.6.
+     */
+    environment?: BatchEnvironment;
+    /**
+     * `'transparent'` (the default, with a traced shadow), a `#rrggbb`, or
+     * `'environment'`. A video has no alpha: `'transparent'` is `#f4f4f5` there
+     * (a `png-sequence` keeps it).
+     */
+    background?: 'transparent' | 'environment' | `#${string}`;
+    /** Default `'studio'`. */
+    quality?: QualityPreset;
+    /** Pixels. Default: the quality preset's long edge, square. */
+    width?: number;
+    height?: number;
+    /**
+     * `png` (the default), `jpeg` or `webp` for an image; `mp4` (the default),
+     * `webm` or `png-sequence` (every frame a PNG with alpha, in one tar) for a
+     * video.
+     */
+    format?: OutputSpec['format'];
+    /** JPEG/WebP only, 1 to 100. */
+    imageQuality?: number;
+    /**
+     * Vertical field of view in degrees. Default 30, or the room's own lens in
+     * a room.
+     */
+    fov?: number;
+    /**
+     * Room around the model, as a share of its size. Default 0.12, or 0.9 in
+     * a room.
+     */
+    margin?: number;
+    /** Frames a second, for a video. Default 30, at most 60. */
+    fps?: number;
+    /** Renderer settings beyond the quality preset. */
+    advanced?: RenderSpec['advanced'];
+    /**
+     * How the pictures are developed. Default: sRGB, ACES filmic, exposure 1
+     * (a room's own exposure in a room).
+     */
+    color?: Partial<ColorSpec>;
+};
+type ImageShot = ShotSettings & {
+    kind?: 'image';
+    /** Default: the view's word, or `az35-el14` for degrees. Ends the item's key. */
+    id?: string;
+    /** Where from. Default `'three-quarter'`, or `'room'` in a room. */
+    view?: View;
+    /**
+     * Instead of a view: a camera inside the model, by its node name, as the
+     * file has it.
+     */
+    camera?: string;
+};
+type VideoShot = ShotSettings & {
+    kind: 'video';
+    /** Default `orbit-<from>-<to>`. */
+    id?: string;
+    /** The camera is carried from here. */
+    from: View;
+    /**
+     * To here, azimuth as written: `{ azimuthDeg: 395 }` from 35 is a full
+     * turn.
+     */
+    to: View;
+    /** Default 4. At most 30. */
+    seconds?: number;
+};
+/** A word or an angle is an image from that view. */
+type Shot = ViewWord | 'room' | Angle | ImageShot | VideoShot;
+type BatchProduct = ShotSettings & {
+    /** Starts every shot's key. Stable across re-runs. */
+    id: string;
+    /** A public https URL of a binary glTF (.glb). */
+    url: string;
+    /** This product's shots, instead of the run's. */
+    shots?: Shot[];
+    /** Echoed on every shot of this product, its webhooks and the ledger. */
+    metadata?: Record<string, unknown>;
+};
+type RenderBatchProgress = BatchProgress & {
+    /** The product just recorded, or skipped. */
+    product: string;
+    /** Products recorded so far. */
+    products: number;
+    /** Shots recorded so far, clips included. */
+    images: number;
+    /** Products skipped so far. */
+    skipped: number;
+};
+/** A product left out of a run, with the reason. */
+type ProductSkip = {
+    id: string;
+    url: string;
+    error: Bakery3Error;
+};
+type RenderBatchRecorded = Recorded & {
+    /**
+     * Products whose model could not be imported or read. The run went on
+     * without them.
+     */
+    skipped: number;
+    /** The first of those, with their reasons. */
+    skips: ProductSkip[];
+};
+type RenderBatchOptions = ShotSettings & {
+    /** Names the run. The same key re-opens it while it is unfinished. */
+    key: string;
+    /** A label for the console. Default: the key. */
+    name?: string;
+    /**
+     * An array, a generator, a database cursor. Pulled as it is needed, never
+     * collected.
+     */
+    products: Iterable<BatchProduct> | AsyncIterable<BatchProduct>;
+    /**
+     * Every product's shots, unless it has its own. Default: one image,
+     * `'three-quarter'` (`'room'` in a room).
+     */
+    shots?: Shot[];
+    /**
+     * Appended to every key as `@version`. Bump it to trace again what already
+     * rendered.
+     */
+    version?: string;
+    /** The ceiling for the whole run, in USD. */
+    maxCost: number;
+    /** A ceiling per shot, in USD. A shot quoted above it is refused. */
+    maxCostPerImage?: number;
+    /**
+     * `'batch'` (the default) never runs ahead of a person in a configurator;
+     * `'normal'` is the API's ordinary lane.
+     */
+    lane?: 'batch' | 'normal';
+    /** Fewer parallel shots than the plan allows, for a gentler budget. */
+    maxParallel?: number;
+    /** Imports in flight at once. Default 4, at most 16. */
+    concurrency?: number;
+    /** Called after each product is recorded or skipped. */
+    onProgress?: (progress: RenderBatchProgress) => void;
+    /**
+     * Stops between products. What was recorded stays admitted; call again to
+     * go on.
+     */
+    signal?: AbortSignal;
+};
+type RenderBatchRecording = RenderBatchRecorded & {
+    estimated: number;
+    maximum: number;
+};
+
+/**
+ * Webhook signature verification.
+ *
+ * A webhook endpoint is a public URL that causes writes in the developer's
+ * database. Verifying is not optional, so it is one function with no options
+ * and no way to get it subtly wrong.
+ *
+ *     const event = await verifyWebhook({
+ *       body: await request.text(),
+ *       signature: request.headers.get('bakery3-signature'),
+ *       secret: process.env.BAKERY3_WEBHOOK_SECRET!,
+ *     });
+ *
+ * Pass the raw body, not a parsed and re-stringified object. Re-serializing
+ * JSON changes key order and whitespace and therefore the signature, and it
+ * is the single most common reason a correct implementation fails.
+ */
+
+/**
+ * Verify a webhook request and return its payload. Throws a `Bakery3Error`
+ * (`Unauthorized`) when the header is missing, malformed, older than five
+ * minutes, or signed with another secret.
+ */
+declare function verifyWebhook(input: {
+    /** The request body exactly as received, as text. */
+    body: string;
+    /**
+     * The `bakery3-signature` header. `headers.get()` gives `null` when the
+     * request has none, and that is refused like a bad signature.
+     */
+    signature: string | null | undefined;
+    /** The signing secret from your webhook settings. */
+    secret: string;
+    /** Test seam. Never pass this in production. */
+    now?: number;
+}): Promise<WebhookPayload>;
+
+/**
+ * @oeave/bakery3/node: the server half.
+ *
+ * The secret key lives here and only here. It never reaches a browser and is
+ * never an argument to anything in `@oeave/bakery3`. This module mints the
+ * short-lived, narrow token that goes in its place, verifies webhooks, and
+ * calls the API with the secret key for the things a browser may not do.
+ *
+ *     import { Bakery3Server } from '@oeave/bakery3/node';
+ *
+ *     const bakery3 = new Bakery3Server(process.env.BAKERY3_SECRET_KEY!);
+ *
+ *     export async function POST() {
+ *       return Response.json(
+ *         await bakery3.tokens.create({
+ *           expiresInSeconds: 300,
+ *           maxRenders: 1,
+ *           maxCost: 1,
+ *           allowedOrigins: ['https://shop.example.com'],
+ *         })
+ *       );
+ *     }
+ *
+ * That endpoint is the entire server-side integration.
+ */
+
+type BrowserTokenOptions = {
+    /**
+     * How long the token lives, in seconds. Default 300. Keep it short: a
+     * browser token is a capability handed to a page, and the shorter its life
+     * the less a leaked one is worth. Five minutes is plenty, because the
+     * browser SDK re-mints on a 401 without the developer writing anything.
+     */
+    expiresInSeconds?: number;
+    /** Hard ceiling on renders this token can start. Default 5. */
+    maxRenders?: number;
+    /** Hard ceiling on spend across all of them, in USD. Default 2. */
+    maxCost?: number;
+    /**
+     * Origins allowed to spend it. Set this in production: it is what stops a
+     * token lifted out of one page's network tab from working anywhere else.
+     */
+    allowedOrigins?: string[];
+    /** Your own user/session id. Shows up in the usage ledger for attribution. */
+    subject?: string;
+};
+type BrowserToken = {
+    /** The token itself, a `bk_pt_` string. Hand it to the browser SDK. */
+    token: string;
+    /** When it stops working, as a Unix timestamp in milliseconds. */
+    expiresAt: number;
+    /** The project the token renders into. */
+    projectId: string;
+};
+type Bakery3ServerOptions = {
+    /** The API's base URL. Only for a self-hosted or test deployment. */
+    baseUrl?: string;
+    /** A `fetch` to use instead of the global one. */
+    fetch?: typeof fetch;
+    /** How a 429/503 is waited out. The browser SDK's defaults otherwise. */
+    retry?: RetryPolicy;
+};
+/** A run's pictures, plus which products were left out and why. */
+type RenderBatchRun = RenderSet & {
+    readonly recorded: RenderBatchRecorded;
+};
+declare class Bakery3Server {
+    readonly tokens: TokensApi;
+    readonly renders: RendersApi;
+    readonly batches: BatchesApi;
+    readonly assets: AssetsApi;
+    private readonly secretKey;
+    private readonly options;
+    private 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: string, options?: Bakery3ServerOptions);
+    /**
+     * 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.
+     */
+    private client;
+    /**
+     * 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`.
+     */
+    renderBatch(options: RenderBatchOptions): Promise<RenderBatchRun>;
+    /**
+     * What `renderBatch()` would cost. The models are imported (that is how
+     * they are priced); nothing is rendered or charged.
+     */
+    quoteBatch(options: Omit<RenderBatchOptions, 'maxCost'> & {
+        maxCost?: number;
+    }): Promise<RenderBatchRecording>;
+    /**
+     * 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);
+     */
+    testBatch(options: Omit<RenderBatchOptions, 'maxCost'> & {
+        maxCost?: number;
+    }, test?: TestRunOptions): Promise<RenderBatchRun>;
+    /**
+     * A run by id, from another process, a webhook handler, or tomorrow
+     * morning.
+     */
+    getRenderSet(id: string): Promise<RenderSet>;
+    private openRun;
+}
+declare class AssetsApi {
+    private readonly client;
+    constructor(client: () => Bakery3Client);
+    /**
+     * 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`).
+     */
+    import(url: string, options?: {
+        kind?: AssetImportKind;
+    }): Promise<AssetImportResponse>;
+    /**
+     * Delete one uploaded file from the project now, rather than when
+     * retention would. `deleted` is false when the project held no such file,
+     * so deleting twice is not an error. The next render that needs the file
+     * uploads it again; a render still queued that needs it can fail, and a
+     * failed render costs nothing.
+     *
+     *     await api.assets.delete('sha256:9f2b…');
+     *     // { hash: 'sha256:9f2b…', deleted: true }
+     */
+    delete(hash: string): Promise<AssetDeleteResponse>;
+    /**
+     * Delete every uploaded file in the project, a page per request until
+     * none is left. Resolves with how many were deleted.
+     *
+     *     await api.assets.deleteAll();
+     *     // { deleted: 240 }
+     */
+    deleteAll(): Promise<{
+        deleted: number;
+    }>;
+}
+type Request = <T>(method: string, path: string, body?: unknown) => Promise<T>;
+declare class TokensApi {
+    private readonly request;
+    constructor(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?: BrowserTokenOptions): Promise<BrowserToken>;
+    /** Revoke a token before its expiry. */
+    revoke(token: string): Promise<void>;
+}
+declare class RendersApi {
+    private readonly request;
+    private readonly client;
+    constructor(request: Request, client: () => Bakery3Client);
+    /**
+     * 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.
+     */
+    create(spec: RenderSpec): Promise<RenderRecord>;
+    /** A render's record, with its state, cost and result URLs. */
+    get(id: string): Promise<RenderRecord>;
+    /** Cancel a render that has not finished. Already terminal is a no-op. */
+    cancel(id: string): Promise<RenderRecord>;
+    /**
+     * 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.
+     */
+    retry(id: string): Promise<RenderRecord>;
+    /**
+     * 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: string): Promise<RenderRecord>;
+    /** The project's renders, newest first, a page at a time. */
+    list(options?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        renders: RenderRecord[];
+        cursor: string | null;
+    }>;
+    /** The quote for a spec: a likely cost and a maximum, in USD. */
+    estimate(spec: Pick<RenderSpec, 'quality' | 'output' | 'advanced'>): Promise<CostEstimate>;
+}
+/**
+ * Batches from a server: manifests you already have, added by the hundred
+ * and rendered behind one cost ceiling. `renderBatch()` builds on this.
+ *
+ *     const batch = await api.batches.open({ key: 'fall-2026-v3', lane: 'batch', maxCost: 600 });
+ *     for await (const line of readLines('manifests.jsonl')) {
+ *       const item = JSON.parse(line);
+ *       batch.add({ key: item.key, spec: item.spec, metadata: item.metadata });
+ *       if (batch.buffered >= 100) await batch.flush();
+ *     }
+ *     await batch.close();
+ *     await batch.wait({ onProgress: (p) => console.log(`${p.completed}/${p.total}`) });
+ */
+declare class BatchesApi {
+    private readonly client;
+    constructor(client: () => Bakery3Client);
+    /** Open, or re-open by key. */
+    open(request: BatchOpenRequest): Promise<Batch>;
+    /** A batch by id, with its latest counts. */
+    get(id: string): Promise<Batch>;
+}
+
+export { type Angle, type AssetDeleteResponse, Bakery3Error, Bakery3Server, type Bakery3ServerOptions, Batch, type BatchAddRequest, type BatchAddResponse, type BatchEnvironment, type BatchExportLine, type BatchItemOutcome, type BatchItemRecord, type BatchItemRequest, type BatchItemsPage, type BatchOpenRequest, BatchPageRefused, type BatchProduct, type BatchProgress, type BatchRecord, type BatchRoom, type BrowserToken, type BrowserTokenOptions, type CostEstimate, type FlushOptions, type FrameSequenceIndex, type ImageShot, type ProductSkip, type Recorded, type RenderBatchOptions, type RenderBatchProgress, type RenderBatchRecorded, type RenderBatchRun, type RenderRecord, RenderSet, type RenderSetFailure, type RenderSetImage, type RenderSpec, type RetryPolicy, type Shot, type ShotSettings, type TestRunOptions, type VideoShot, type View, type ViewWord, type WaitOptions, verifyWebhook };