@oeave/bakery3 0.0.0-stage → 0.1.0

package/dist/bake-DaOlenyx.d.ts

@@ -0,0 +1,1357 @@
+import { A as AnimationSpec } from './animation-B1h0Ryvj.js';
+
+/**
+ * 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;
+    /** Physical-camera extras. Depth of field is off unless `fStop` is set. */
+    focus?: {
+        fStop: number;
+        focalDistance: number;
+    };
+} | {
+    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';
+};
+
+/**
+ * The texel ceiling for one bake, enforced at estimate time before any GPU
+ * time is bought. Texels drive a bake's cost the way frames drive a video's;
+ * 32M texels is a full room at sensible resolutions.
+ */
+declare const MAX_BAKE_TEXELS: number;
+/**
+ * The object-count ceiling for one bake job. A request past it is refused,
+ * never sampled down.
+ */
+declare const MAX_BAKE_OBJECTS = 256;
+/**
+ * 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;
+
+export { type AssetHash as A, type BakeTextureSize as B, type ColorSpec as C, type EnvironmentSpec as E, type FrameSequenceIndex as F, type MaterialShaderSpec as M, type OutputSpec as O, type QualityPreset as Q, type RenderSpec as R, type SceneManifest as S, type Vec3 as V, type BakeQuality as a, type BakeAtlas as b, type BakeView as c, type CompatibilityReport as d, type BakeSpec as e, type BakeBundleSummary as f, type CameraSpec as g, type CompatibilityIssue as h, type BakeSettings as i, type BakeBundle as j, type ShaderSlot as k, type BakeSkip as l, type BakeUv as m, type BakedObject as n, type OutputFormat as o, type ShaderGraph as p, type ShaderGraphNode as q, BAKE_TEXTURE_SIZES as r, MAX_BAKE_OBJECTS as s, MAX_BAKE_TEXELS as t };