@oeave/bakery3 0.1.0 → 0.2.0

package/dist/{chunk-CX4WTVGH.js → chunk-Z7IYVH22.js}

@@ -1,11 +1,11 @@
-import { captureCamera } from './chunk-V3QINEEG.js';
-import { protocolVersionFor, SDK_VERSION, QUALITY } from './chunk-APBOWWSV.js';
+import { captureCamera } from './chunk-62M6XXNX.js';
+import { protocolVersionFor, SDK_VERSION, QUALITY } from './chunk-UWBP7B54.js';
 import { BAKERY_NODE_MARKER, builtinFor, tslRuntimeRegistered, toNodeObject } from './chunk-S4AJTLLN.js';
-import { findPresetRooms, sha256, environmentSourceFor, isPresetEnvironment, roomPresetSpecOf, roomPresetFactsOf, roomPresetAssetsOf } from './chunk-AF5BIELI.js';
-import { idOf, shouldExclude, captureFog, readUserData, scenePath, captureLights, captureRuntime, stampIds, captureEnvironmentSettings, excludedItself, bakeCandidates, resolveProbe, defaultIncludeIds, quantizeBakeView, bakeBounds, isBakeWrittenUv } from './chunk-HQTUFVMM.js';
-import { MAX_BAKE_OBJECTS, MAX_BAKE_TEXELS, roomIsPrebaked, roomPrebakeChanges, MAX_BAKE_SIMPLIFY, BAKE_TEXTURE_SIZES, MAX_BAKE_SIMPLIFY_TRIANGLES, BAKE_ATLAS_SIZES } from './chunk-W6WQ5UP7.js';
+import { sha256, environmentSourceFor, isPresetEnvironment } from './chunk-KZLVTSBI.js';
+import { idOf, shouldExclude, captureFog, scenePath, captureLights, captureRuntime, stampIds, captureEnvironmentSettings, excludedItself, readUserData, bakeCandidates, resolveProbe, defaultIncludeIds, quantizeBakeView, bakeBounds, isBakeWrittenUv, ID_KEY } from './chunk-JFYUDERE.js';
+import { findPresetRooms, roomShownBaked, roomPresetFactsOf, roomPresetSpecOf, roomPresetAssetsOf, MAX_BAKE_OBJECTS, MAX_BAKE_TEXELS, roomIsPrebaked, roomPrebakeChanges, MAX_BAKE_SIMPLIFY, BAKE_TEXTURE_SIZES, MAX_BAKE_SIMPLIFY_TRIANGLES, BAKE_ATLAS_SIZES } from './chunk-APWUCEEB.js';
 import { Bakery3Error } from './chunk-3G5QL4F4.js';
-import { Vector3, Vector2, Matrix4, Quaternion } from 'three';
+import { Vector3, Vector2, Matrix4, Quaternion, Color, MeshPhysicalMaterial, MeshStandardMaterial, LinearSRGBColorSpace } from 'three';
 import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter.js';
 
 // src/timeline/easing.ts
@@ -3024,6 +3024,175 @@ function describeNodeType(type) {
   };
   return KNOWN[type] ?? `A "${type}"`;
 }
+function fallbackFor(material, object) {
+  const own = material.userData?.bakery3?.fallback;
+  if (isRecord(own)) return { values: own, declaredOn: "material" };
+  const objects = readUserData(object).fallback;
+  if (isRecord(objects)) return { values: objects, declaredOn: "object" };
+  return null;
+}
+function objectFallbackId(material, object) {
+  return `${idOf(material)}@${idOf(object)}`;
+}
+function fallbackMaterialId(material, object, fallback) {
+  return fallback.declaredOn === "object" ? objectFallbackId(material, object) : idOf(material);
+}
+function exporterCannotWrite(material) {
+  const m = material;
+  if (m.isShaderMaterial) return true;
+  return typeof m.color?.toArray !== "function";
+}
+function fallbackEmits(values) {
+  if (values.emissive === void 0) return false;
+  const intensity = typeof values.emissiveIntensity === "number" ? values.emissiveIntensity : 1;
+  if (!(intensity > 0)) return false;
+  const color = toColor(values.emissive);
+  return Boolean(color && color.r + color.g + color.b > 0);
+}
+function materialStandIns(root) {
+  const shared = /* @__PURE__ */ new Map();
+  const standIns = /* @__PURE__ */ new Map();
+  root.traverse((object) => {
+    if (shouldExclude(object)) return;
+    const drawable = object;
+    if (!(drawable.isMesh || drawable.isLine || drawable.isPoints)) return;
+    if (!drawable.material) return;
+    const list = Array.isArray(drawable.material) ? drawable.material : [drawable.material];
+    const own = /* @__PURE__ */ new Map();
+    let changed = false;
+    const written = list.map((material) => {
+      if (!material) return material;
+      const standIn2 = standInFor(material, object, shared, own);
+      if (standIn2 !== material) changed = true;
+      return standIn2;
+    });
+    if (!changed) return;
+    standIns.set(
+      object,
+      Array.isArray(drawable.material) ? written : written[0]
+    );
+  });
+  return standIns;
+}
+function standInFor(material, object, shared, own) {
+  const fallback = fallbackFor(material, object);
+  if (fallback?.declaredOn === "object") {
+    let copy2 = own.get(material);
+    if (!copy2) {
+      copy2 = standIn(
+        material,
+        fallback.values,
+        objectFallbackId(material, object)
+      );
+      own.set(material, copy2);
+    }
+    return copy2;
+  }
+  if (!fallback && !exporterCannotWrite(material)) return material;
+  let copy = shared.get(material);
+  if (!copy) {
+    copy = standIn(material, fallback?.values ?? null, idOf(material));
+    shared.set(material, copy);
+  }
+  return copy;
+}
+function standIn(material, fallback, id) {
+  const out = fallback ? fromFallback(fallback) : flatGray();
+  out.name = material.name;
+  out.side = material.side;
+  const userData = {
+    ...material.userData,
+    [ID_KEY]: id
+  };
+  if (fallback) {
+    const bakery3 = isRecord(userData.bakery3) ? userData.bakery3 : {};
+    userData.bakery3 = { ...bakery3, fallback };
+  }
+  out.userData = userData;
+  return out;
+}
+function flatGray() {
+  const material = new MeshStandardMaterial({ roughness: 1, metalness: 0 });
+  material.color.setRGB(0.8, 0.8, 0.8, LinearSRGBColorSpace);
+  return material;
+}
+var NUMBER_FIELDS = [
+  "metalness",
+  "roughness",
+  "clearcoat",
+  "clearcoatRoughness",
+  "transmission",
+  "thickness",
+  "ior",
+  "emissiveIntensity",
+  "opacity",
+  "sheen",
+  "iridescence",
+  "anisotropy"
+];
+function fromFallback(values) {
+  const material = new MeshPhysicalMaterial();
+  const color = toColor(values.color);
+  if (color) material.color.copy(color);
+  const emissive = toColor(values.emissive);
+  if (emissive) material.emissive.copy(emissive);
+  const sheenColor = toColor(values.sheenColor);
+  if (sheenColor) material.sheenColor.copy(sheenColor);
+  const target = material;
+  for (const field of NUMBER_FIELDS) {
+    const value = values[field];
+    if (typeof value === "number" && Number.isFinite(value))
+      target[field] = value;
+  }
+  if (material.opacity < 1) material.transparent = true;
+  return material;
+}
+function toColor(value) {
+  if (typeof value !== "string" && typeof value !== "number" && !value?.isColor)
+    return null;
+  return new Color(value);
+}
+function substituteMaterials(exporter, standIns) {
+  let undo = () => {
+  };
+  if (standIns.size === 0) return undo;
+  exporter.register((writer) => {
+    const steps = writer;
+    const name = ["processMeshAsync", "processMesh"].find(
+      (key) => typeof steps[key] === "function"
+    );
+    if (name) {
+      const original = steps[name];
+      steps[name] = function(mesh) {
+        const material = standIns.get(mesh);
+        return original.call(
+          this,
+          material ? Object.create(mesh, {
+            material: { value: material, enumerable: true }
+          }) : mesh
+        );
+      };
+    } else {
+      undo = swapOnScene(standIns);
+    }
+    return {};
+  });
+  return () => undo();
+}
+function swapOnScene(standIns) {
+  const originals = [];
+  for (const [object, material] of standIns) {
+    const drawable = object;
+    originals.push({ object: drawable, material: drawable.material });
+    drawable.material = material;
+  }
+  return () => {
+    for (const { object, material } of originals) object.material = material;
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
 // src/compat/analyze.ts
 var DOCS2 = "https://bakery3.com/docs";
@@ -3031,15 +3200,46 @@ var LARGE_TEXTURE_PX = 4096;
 var LARGE_TRIANGLE_COUNT = 1e7;
 var TRANSLATABLE = /* @__PURE__ */ new Set(["MeshStandardMaterial", "MeshPhysicalMaterial"]);
 var APPROXIMATED = {
-  MeshBasicMaterial: "Rendered as an emissive surface, since a path tracer has no unlit shading model.",
-  MeshLambertMaterial: "Rendered as a rough physically based material. Lambert has no specular term, so highlights will differ.",
-  MeshPhongMaterial: "Converted to roughness/metalness. Phong shininess is not a physical parameter, so the specular falloff is an approximation.",
-  MeshToonMaterial: "Rendered as flat diffuse. Cel shading is a screen-space stylization with no path-traced equivalent.",
-  MeshMatcapMaterial: "Rendered as diffuse using the matcap average. A matcap encodes lighting into a texture, which is exactly what path tracing replaces.",
-  MeshNormalMaterial: "Rendered as flat gray. Normal visualization is a debug view, not a surface.",
-  MeshDepthMaterial: "Rendered as flat gray. Depth output is a debug view.",
-  MeshDistanceMaterial: "Rendered as flat gray. Distance output is a debug view."
+  MeshBasicMaterial: "It shows its color and map unlit, as in the viewport, but it does not light the scene, cast a shadow, or show in reflections or through glass.",
+  MeshLambertMaterial: "It renders as a fully rough, non-metal surface in its color and map.",
+  MeshPhongMaterial: "It renders as a fully rough, non-metal surface in its color and map, like Lambert. Its `shininess` and `specular` are not used, so it has no sharp highlights.",
+  MeshToonMaterial: "It renders as a fully rough, non-metal surface in its color and map, without the cel shading of its `gradientMap`.",
+  MeshMatcapMaterial: "It renders as a fully rough, non-metal surface in its color and map, lit by the scene. The `matcap` texture is not used.",
+  MeshNormalMaterial: "It renders flat gray. It colors a surface by its normals, which is a debug view, not a look.",
+  MeshDepthMaterial: "It renders flat gray. It shows depth, which is a debug view, not a look.",
+  MeshDistanceMaterial: "It renders flat gray. It is made for shadow maps, not for a visible surface."
 };
+var IGNORED = [
+  {
+    name: "alphaMap",
+    used: (m) => isTexture(m.alphaMap) && Boolean(m.transparent || m.alphaTest > 0 || m.alphaHash),
+    fix: "For a cutout, use the alpha channel of `map`."
+  },
+  {
+    name: "bumpMap",
+    used: (m) => isTexture(m.bumpMap) && m.bumpScale !== 0,
+    fix: "Bake bump detail into a `normalMap`."
+  },
+  {
+    name: "displacementMap",
+    used: (m) => isTexture(m.displacementMap) && m.displacementScale !== 0,
+    fix: "Model the shape, or bake the detail into a `normalMap`."
+  },
+  { name: "specularMap", used: (m) => isTexture(m.specularMap) },
+  { name: "iridescence", used: (m) => m.iridescence > 0 },
+  {
+    name: "iridescenceMap",
+    used: (m) => m.iridescence > 0 && isTexture(m.iridescenceMap)
+  },
+  {
+    name: "iridescenceThicknessMap",
+    used: (m) => m.iridescence > 0 && isTexture(m.iridescenceThicknessMap)
+  },
+  {
+    name: "dispersion",
+    used: (m) => m.dispersion > 0 && m.transmission > 0
+  }
+];
 function emitsLight(material) {
   const m = material;
   if (m.isMeshBasicMaterial) return true;
@@ -3052,6 +3252,7 @@ function emitsLight(material) {
 function analyzeScene(root) {
   const issues = [];
   const seenMaterials = /* @__PURE__ */ new Set();
+  const unfaithful = /* @__PURE__ */ new Set();
   const seenTextures = /* @__PURE__ */ new Set();
   let triangles = 0;
   let faithfulTriangles = 0;
@@ -3085,12 +3286,21 @@ function analyzeScene(root) {
           });
         }
       }
-      if (seenMaterials.has(material.uuid)) continue;
-      seenMaterials.add(material.uuid);
-      if (emitsLight(material)) emitters++;
-      for (const issue of classifyMaterial(material, object)) {
+      const fallback = fallbackFor(material, object);
+      const key = fallback?.declaredOn === "object" ? `${object.uuid}:${material.uuid}` : material.uuid;
+      if (seenMaterials.has(key)) {
+        if (unfaithful.has(key)) objectIsFaithful = false;
+        continue;
+      }
+      seenMaterials.add(key);
+      if (fallback ? fallbackEmits(fallback.values) : emitsLight(material))
+        emitters++;
+      for (const issue of classifyMaterial(material, object, fallback)) {
         issues.push(issue);
-        if (issue.severity === "error") objectIsFaithful = false;
+        if (issue.severity === "error") {
+          objectIsFaithful = false;
+          unfaithful.add(key);
+        }
       }
     }
     if (objectIsFaithful) faithfulTriangles += count;
@@ -3123,98 +3333,142 @@ function collectFallbacks(root) {
   const fallbacks = [];
   const seen = /* @__PURE__ */ new Set();
   root.traverse((object) => {
+    if (shouldExclude(object)) return;
     const mesh = object;
     if (!mesh.isMesh) return;
     const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
     for (const material of materials) {
-      if (!material || seen.has(material.uuid)) continue;
-      const declared = material.userData?.bakery3?.fallback ?? readUserData(object).fallback;
-      if (!declared) continue;
-      seen.add(material.uuid);
+      if (!material) continue;
+      const fallback = fallbackFor(material, object);
+      if (!fallback) continue;
+      const materialId = fallbackMaterialId(material, object, fallback);
+      if (seen.has(materialId)) continue;
+      seen.add(materialId);
       fallbacks.push({
-        ...declared,
-        materialId: idOf(material),
+        ...fallback.values,
+        materialId,
         type: "physical"
       });
     }
   });
   return fallbacks;
 }
-function classifyMaterial(material, object) {
-  const hasFallback = Boolean(
-    material.userData?.bakery3?.fallback ?? readUserData(object).fallback
-  );
-  if (isNodeMaterial(material) && !hasFallback) {
+function classifyMaterial(material, object, fallback) {
+  if (fallback) {
+    return [
+      {
+        code: "material_fallback_used",
+        severity: "info",
+        message: `${labelOf(material)} renders with your declared fallback.`,
+        path: pathOf(object),
+        materialId: fallbackMaterialId(material, object, fallback),
+        materialName: material.name,
+        materialType: material.type,
+        docs: `${DOCS2}/material-fallbacks`
+      }
+    ];
+  }
+  if (isNodeMaterial(material)) {
     const extracted = extractMaterialShader(material);
-    return extracted.issues.map((issue) => ({
+    const issues = extracted.issues.map((issue) => ({
       ...issue,
       path: pathOf(object),
       materialId: idOf(material),
       materialName: material.name,
       materialType: material.type
     }));
+    if (!extracted.spec)
+      issues.push(...classicIssues(material, object, classicType(material)));
+    return issues;
   }
-  const verdict = classify(material, object, hasFallback);
-  return verdict ? [verdict.issue] : [];
+  return classicIssues(material, object, material.type);
 }
-function classify(material, object, hasFallback) {
-  if (TRANSLATABLE.has(material.type)) return null;
-  if (hasFallback) {
-    return {
-      issue: {
-        code: "material_fallback_used",
-        severity: "info",
-        message: `${material.type} "${material.name || "unnamed"}" renders with your declared fallback.`,
-        path: pathOf(object),
-        materialId: idOf(material),
-        materialName: material.name,
-        materialType: material.type,
-        docs: `${DOCS2}/material-fallbacks`
-      }
-    };
-  }
-  if (material.type === "ShaderMaterial" || material.type === "RawShaderMaterial") {
+function classicIssues(material, object, type) {
+  const issues = [];
+  const verdict = classify(material, object, type);
+  if (verdict) issues.push(verdict);
+  if (!exporterCannotWrite(material)) {
+    const ignored = ignoredSlots(material, object);
+    if (ignored) issues.push(ignored);
+  }
+  return issues;
+}
+function classify(material, object, type) {
+  if (TRANSLATABLE.has(type)) return null;
+  const about = {
+    path: pathOf(object),
+    materialId: idOf(material),
+    materialName: material.name,
+    materialType: material.type
+  };
+  if (material.isShaderMaterial) {
     return {
-      issue: {
-        code: "material_custom_shader",
-        severity: "error",
-        message: `Unsupported material: ${material.name || material.type}`,
-        path: pathOf(object),
-        materialId: idOf(material),
-        materialName: material.name,
-        materialType: material.type,
-        docs: `${DOCS2}/material-fallbacks`
-      }
+      code: "material_custom_shader",
+      severity: "error",
+      message: `${labelOf(material)} renders flat gray, because the render cannot run GLSL. Declare a fallback, or port it to TSL.`,
+      ...about,
+      docs: `${DOCS2}/material-fallbacks`
     };
   }
-  const approximation = APPROXIMATED[material.type];
+  const approximation = APPROXIMATED[type];
   if (approximation) {
     return {
-      issue: {
-        code: "material_approximated",
-        severity: "warning",
-        message: `${material.type} "${material.name || "unnamed"}" is approximated. ${approximation}`,
-        path: pathOf(object),
-        materialId: idOf(material),
-        materialName: material.name,
-        materialType: material.type,
-        docs: `${DOCS2}/materials`
-      }
+      code: "material_approximated",
+      severity: "warning",
+      message: `${labelOf(material)} is approximated. ${approximation}${emissiveNote(material)}`,
+      ...about,
+      docs: `${DOCS2}/materials`
     };
   }
+  const looks = exporterCannotWrite(material) ? "flat gray" : "as a fully rough, non-metal surface in its color";
   return {
-    issue: {
-      code: "material_unknown",
-      severity: "error",
-      message: `Unsupported material: ${material.name || material.type}`,
-      path: pathOf(object),
-      materialId: idOf(material),
-      materialName: material.name,
-      materialType: material.type,
-      docs: `${DOCS2}/materials`
-    }
+    code: "material_unknown",
+    severity: "error",
+    message: `${labelOf(material)} renders ${looks}, because the render does not support this material. Use MeshStandardMaterial or MeshPhysicalMaterial, or declare a fallback.`,
+    ...about,
+    docs: `${DOCS2}/materials`
+  };
+}
+function emissiveNote(material) {
+  const m = material;
+  if (m.isMeshStandardMaterial || !m.emissive) return "";
+  if (m.emissiveIntensity === void 0 || m.emissiveIntensity === 1) return "";
+  if (m.emissive.r + m.emissive.g + m.emissive.b <= 0) return "";
+  return " Its `emissiveIntensity` is not used, so it glows at intensity 1.";
+}
+function ignoredSlots(material, object) {
+  const record2 = material;
+  const ignored = IGNORED.filter((slot) => slot.used(record2));
+  if (!ignored.length) return null;
+  const names = ignored.map((slot) => `\`${slot.name}\``);
+  const list = names.length === 1 ? names[0] : `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+  const fixes = ignored.flatMap((slot) => slot.fix ? [slot.fix] : []);
+  return {
+    code: "material_map_ignored",
+    severity: "warning",
+    message: [
+      `${labelOf(material)} uses ${list}, which the render ignores.`,
+      ...fixes
+    ].join(" "),
+    path: pathOf(object),
+    materialId: idOf(material),
+    materialName: material.name,
+    materialType: material.type,
+    docs: `${DOCS2}/materials#slots-the-render-ignores`
   };
 }
+function classicType(material) {
+  const m = material;
+  if (m.isMeshPhysicalMaterial) return "MeshPhysicalMaterial";
+  if (m.isMeshStandardMaterial) return "MeshStandardMaterial";
+  return material.type.replace(/NodeMaterial$/, "Material");
+}
+function labelOf(material) {
+  return `${material.type} "${material.name || "unnamed"}"`;
+}
+function isTexture(value) {
+  return Boolean(value?.isTexture);
+}
 var TEXTURE_SLOTS = [
   "map",
   "normalMap",
@@ -3268,7 +3522,8 @@ function sceneComplexity(scene, camera) {
   let objects = 0;
   const visit = (object) => {
     if (!object.visible) return;
-    if (excludedItself(object) && !rooms.has(object)) return;
+    const shell = Boolean(object.userData?.bakery3RoomShell);
+    if (excludedItself(object) && !rooms.has(object) && !shell) return;
     const mesh = object;
     if (mesh.isMesh && mesh.geometry?.attributes?.position) {
       const position = mesh.geometry.attributes.position;
@@ -3279,7 +3534,7 @@ function sceneComplexity(scene, camera) {
         (_, i) => i % 3 === 0 ? position.getX(i / 3 | 0) : i % 3 === 1 ? position.getY(i / 3 | 0) : position.getZ(i / 3 | 0)
       );
       const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
-      const emitter = materials.length > 0 && materials.every((material) => material && emitsLight(material));
+      const emitter = !shell && materials.length > 0 && materials.every((material) => material && emitsLight(material));
       const base = {
         positions,
         indices: index?.array ?? null,
@@ -3297,13 +3552,17 @@ function sceneComplexity(scene, camera) {
           });
         }
       } else {
-        objects += 1;
+        if (!shell) objects += 1;
         meshes.push({ ...base, matrix: mesh.matrixWorld.elements });
       }
     }
     for (const child of object.children) visit(child);
   };
   visit(scene);
+  for (const room of rooms) {
+    if (room.visible && roomShownBaked(room))
+      objects += roomPresetFactsOf(room)?.objects ?? 0;
+  }
   const eye = camera.getWorldPosition(new Vector3());
   return complexityOf(meshes, [eye.x, eye.y, eye.z], objects);
 }
@@ -3354,13 +3613,10 @@ async function captureShaders(root) {
     const list = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
     for (const material of list) {
       if (!material || seen.has(material.uuid)) continue;
+      if (!isNodeMaterial(material)) continue;
+      if (fallbackFor(material, object)) continue;
       seen.add(material.uuid);
-      const hasFallback = Boolean(
-        material.userData?.bakery3?.fallback ?? readUserData(object).fallback
-      );
-      if (isNodeMaterial(material) && !hasFallback) {
-        materials.push({ material, path: pathOf2(object) });
-      }
+      materials.push({ material, path: pathOf2(object) });
     }
   });
   for (const { material, path } of materials) {
@@ -3674,8 +3930,10 @@ async function captureScene(options) {
 }
 function exportGLB(scene) {
   const exporter = new GLTFExporter();
+  const standIns = materialStandIns(scene);
   const reattach = detachExcluded(scene);
   const unmute = muteLightWarnings();
+  const unswap = substituteMaterials(exporter, standIns);
   return new Promise((resolve, reject) => {
     exporter.parse(
       scene,
@@ -3709,6 +3967,7 @@ function exportGLB(scene) {
       }
     );
   }).finally(() => {
+    unswap();
     unmute();
     reattach();
   });
@@ -3925,7 +4184,7 @@ function presetRoomBake(scene, candidates, include) {
   const group = rooms[0];
   const room = roomPresetSpecOf(group);
   if (!room) return null;
-  if (!roomIsPrebaked(room.name, room.lighting)) {
+  if (!roomShownBaked(group) && !roomIsPrebaked(room.name, room.lighting)) {
     return {
       refused: {
         code: "BakeRoomNotPrebaked",
@@ -4009,15 +4268,31 @@ function isUnder(object, root) {
 function planBake(scene, camera, settings = {}) {
   const quality = settings.quality ?? "standard";
   const textureSize = settings.textureSize ?? 1024;
-  const candidates = bakeCandidates({ scene });
+  let candidates = bakeCandidates({ scene });
   let include = resolveInclude(candidates, settings);
   let preset;
   if (settings.room !== "full") {
-    const verdict = presetRoomBake(scene, candidates, include);
+    const hide = revealBakedStands(scene);
+    let seen = candidates;
+    let seenInclude = include;
+    if (hide.length) {
+      try {
+        seen = bakeCandidates({ scene });
+        seenInclude = resolveInclude(seen, settings);
+      } finally {
+        for (const undo of hide) undo();
+      }
+    }
+    const verdict = presetRoomBake(scene, seen, seenInclude);
     if (verdict && "ok" in verdict) {
       preset = verdict.ok;
+      candidates = seen;
       const keep = /* @__PURE__ */ new Set([...preset.spanIds]);
-      include = include.filter((id) => keep.has(id));
+      include = seenInclude.filter((id) => keep.has(id));
+      if (hide.length) {
+        for (const id of preset.standIds)
+          if (!include.includes(id)) include.push(id);
+      }
     }
   }
   const standIns = resolveSimplify(scene, candidates, settings);
@@ -4202,7 +4477,8 @@ async function prepareBake(options) {
 function holdRoomBack(preset, include) {
   const undo = [];
   const state = preset.group.userData?.bakery3Preset?.roomPreset;
-  if (!state?.standIn) return undo;
+  if (!state) return undo;
+  if (!state.standIn && !roomShownBaked(preset.group)) return undo;
   const shipping = new Set(
     include.filter((id) => preset.standIds.includes(id))
   );
@@ -4224,6 +4500,19 @@ function holdRoomBack(preset, include) {
   });
   return undo;
 }
+function revealBakedStands(scene) {
+  const undo = [];
+  for (const group of findPresetRooms(scene)) {
+    if (!roomShownBaked(group)) continue;
+    const state = group.userData?.bakery3Preset?.roomPreset;
+    if (!state || state.standIn) continue;
+    state.standIn = "stand";
+    undo.push(() => {
+      state.standIn = void 0;
+    });
+  }
+  return undo;
+}
 function developerUv1(candidates, include) {
   const wanted = new Set(include);
   return candidates.filter((candidate) => {
@@ -4488,5 +4777,5 @@ function resolveInclude(candidates, settings) {
 }
 
 export { OBJECT_PROPERTIES, Timeline, analyzeScene, aspectOf, bakeQuoteOf, bindTimelineContext, captureScene, createTimeline, extractMaterialShader, isNodeMaterial, linearToSrgbHex, outputSize, prepareBake, quoteBake, resolveOutput, sceneComplexity, timelineFromGsap, timelineFromTheatre, tracedTriangles };
-//# sourceMappingURL=chunk-CX4WTVGH.js.map
-//# sourceMappingURL=chunk-CX4WTVGH.js.map
+//# sourceMappingURL=chunk-Z7IYVH22.js.map
+//# sourceMappingURL=chunk-Z7IYVH22.js.map