@oeave/bakery3 0.0.0-stage → 0.1.0

package/dist/chunk-HQTUFVMM.js

@@ -0,0 +1,1412 @@
+import { Bakery3Error } from './chunk-3G5QL4F4.js';
+import { Box3, Vector3, LinearSRGBColorSpace, BufferAttribute, BufferGeometry, PlaneGeometry, MeshBasicMaterial, DoubleSide, Mesh, MeshStandardMaterial, Vector2, MultiplyBlending } from 'three';
+
+// src/capture/ids.ts
+var ID_KEY = "bakery3Id";
+function idOf(target) {
+  const declared = target.userData?.[ID_KEY];
+  return typeof declared === "string" && declared.length > 0 ? declared : target.uuid;
+}
+var clonedFrom = /* @__PURE__ */ new WeakMap();
+function markClone(clone, source) {
+  clonedFrom.set(clone, clonedFrom.get(source) ?? source);
+}
+var sourceOf = (material) => clonedFrom.get(material) ?? material;
+function isDeclared(target) {
+  const declared = target.userData?.[ID_KEY];
+  return typeof declared === "string" && declared.length > 0 && declared !== target.uuid;
+}
+function assertUniqueIds(root) {
+  const objects = /* @__PURE__ */ new Map();
+  const materials = /* @__PURE__ */ new Map();
+  root.traverse((object) => {
+    if (isDeclared(object)) {
+      const id = idOf(object);
+      const first = objects.get(id);
+      if (first && first !== object)
+        throw duplicate("object", id, [scenePath(first), scenePath(object)]);
+      objects.set(id, object);
+    }
+    const mesh = object;
+    if (!mesh.isMesh || !mesh.material) return;
+    const list = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+    for (const material of list) {
+      if (!material || !isDeclared(material)) continue;
+      const id = idOf(material);
+      const first = materials.get(id);
+      if (first && sourceOf(first.material) !== sourceOf(material)) {
+        throw duplicate("material", id, [
+          `${scenePath(first.owner)} \u2192 ${first.material.name || first.material.type}`,
+          `${scenePath(object)} \u2192 ${material.name || material.type}`
+        ]);
+      }
+      materials.set(id, { material, owner: object });
+    }
+  });
+}
+function scenePath(object) {
+  const parts = [];
+  let current = object;
+  while (current && current.parent) {
+    parts.unshift(`<${current.name || current.type}>`);
+    current = current.parent;
+  }
+  return parts.join("/");
+}
+function duplicate(kind, id, where) {
+  return new Bakery3Error({
+    code: "InvalidRequest",
+    message: `Two ${kind}s declare userData.bakery3Id "${id}".`,
+    why: `Ids are how the renderer matches your live ${kind}s to the ones in the exported scene. With two claiming "${id}", one of them would silently take the other's transform, visibility or lightmap.`,
+    fix: "Give one of them a different userData.bakery3Id, or remove it and let the SDK use the uuid.",
+    path: where.join("  and  ")
+  });
+}
+
+// src/capture/scene.ts
+function readUserData(object) {
+  const data = object.userData?.bakery3;
+  return data && typeof data === "object" ? data : {};
+}
+function stampIds(root) {
+  assertUniqueIds(root);
+  const touched = [];
+  const stamp = (target) => {
+    if (target.userData?.[ID_KEY] !== void 0) return;
+    target.userData = target.userData ?? {};
+    target.userData[ID_KEY] = target.uuid;
+    touched.push(target);
+  };
+  root.traverse((object) => {
+    stamp(object);
+    const mesh = object;
+    if (!mesh.isMesh || !mesh.material) return;
+    const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+    for (const material of materials) if (material) stamp(material);
+  });
+  return () => {
+    for (const target of touched) delete target.userData[ID_KEY];
+  };
+}
+function shouldExclude(object) {
+  for (let node = object; node; node = node.parent) {
+    if (excludedItself(node)) return true;
+  }
+  return false;
+}
+function excludedItself(object) {
+  if (readUserData(object).exclude) return true;
+  const roomPreset = object.userData?.bakery3Preset?.roomPreset;
+  if (roomPreset) return !roomPreset.standIn;
+  if (/Helper$/.test(object.type)) return true;
+  if (object.type === "TransformControls") return true;
+  return false;
+}
+function captureRuntime(root, productState) {
+  const hiddenObjectIds = [];
+  const instances = [];
+  const morphs = [];
+  const poses = [];
+  root.traverse((object) => {
+    if (shouldExclude(object)) return;
+    if (!object.visible && !readUserData(object).renderOnly) {
+      hiddenObjectIds.push(idOf(object));
+      return;
+    }
+    const mesh = object;
+    if (mesh.isInstancedMesh) {
+      instances.push({
+        objectId: idOf(object),
+        count: mesh.count,
+        matrices: Array.from(mesh.instanceMatrix.array)
+      });
+    }
+    if (mesh.isMesh && mesh.morphTargetInfluences?.length) {
+      if (mesh.morphTargetInfluences.some((v) => v > 1e-6)) {
+        morphs.push({
+          objectId: idOf(object),
+          influences: Array.from(mesh.morphTargetInfluences)
+        });
+      }
+    }
+    if (mesh.isSkinnedMesh && mesh.skeleton) {
+      poses.push({
+        objectId: idOf(object),
+        boneMatrices: mesh.skeleton.bones.map((bone) => {
+          bone.updateMatrixWorld();
+          return Array.from(bone.matrixWorld.elements);
+        })
+      });
+    }
+  });
+  return {
+    ...hiddenObjectIds.length ? { hiddenObjectIds } : {},
+    ...instances.length ? { instances } : {},
+    ...morphs.length ? { morphs } : {},
+    ...poses.length ? { poses } : {},
+    ...productState ? { productState } : {}
+  };
+}
+function captureLights(root) {
+  const lights = [];
+  root.traverse((object) => {
+    const light = object;
+    if (!light.isLight || shouldExclude(object) || !object.visible && !readUserData(object).renderOnly)
+      return;
+    light.updateMatrixWorld();
+    const position = worldPosition(light);
+    const color = `#${light.color.getHexString()}`;
+    const base = {
+      objectId: idOf(object),
+      color,
+      intensity: light.intensity,
+      castShadow: light.castShadow ?? false
+    };
+    if (light.isAmbientLight) {
+      return;
+    }
+    if (light.isDirectionalLight) {
+      light.target?.updateMatrixWorld();
+      const angleDeg = readUserData(object).angleDeg;
+      lights.push({
+        ...base,
+        type: "directional",
+        position,
+        target: light.target ? worldPosition(light.target) : [0, 0, 0],
+        ...typeof angleDeg === "number" && angleDeg > 0 ? { angleDeg } : {}
+      });
+      return;
+    }
+    if (light.isSpotLight) {
+      light.target?.updateMatrixWorld();
+      lights.push({
+        ...base,
+        type: "spot",
+        position,
+        target: light.target ? worldPosition(light.target) : [0, 0, 0],
+        angle: light.angle,
+        penumbra: light.penumbra,
+        distance: light.distance,
+        decay: light.decay
+      });
+      return;
+    }
+    if (light.isPointLight) {
+      lights.push({
+        ...base,
+        type: "point",
+        position,
+        distance: light.distance,
+        decay: light.decay
+      });
+      return;
+    }
+    if (light.isRectAreaLight) {
+      const facing = worldZ(light);
+      lights.push({
+        ...base,
+        type: "area",
+        position,
+        target: [
+          position[0] - facing[0],
+          position[1] - facing[1],
+          position[2] - facing[2]
+        ],
+        // three's RectAreaLight defaults are 10x10. Falling back to 1x1 would
+        // silently make it a hundred times dimmer than the browser drew it.
+        size: { width: light.width ?? 10, height: light.height ?? 10 }
+      });
+      return;
+    }
+    if (light.isHemisphereLight) {
+      lights.push({
+        ...base,
+        type: "hemisphere",
+        position,
+        groundColor: `#${light.groundColor?.getHexString() ?? "000000"}`
+      });
+    }
+  });
+  return lights;
+}
+function captureEnvironmentSettings(scene) {
+  const anyScene = scene;
+  return {
+    ...anyScene.environmentIntensity !== void 0 ? { intensity: anyScene.environmentIntensity } : {},
+    ...anyScene.environmentRotation ? {
+      rotation: [
+        anyScene.environmentRotation.x,
+        anyScene.environmentRotation.y,
+        anyScene.environmentRotation.z
+      ]
+    } : {}
+  };
+}
+function captureFog(scene) {
+  const fog = scene.fog;
+  if (!fog) return {};
+  if (fog.isFogExp2) {
+    const density = fog.density ?? 0;
+    if (!(density > 0) || !Number.isFinite(density)) return {};
+    return {
+      fog: { color: `#${fog.color?.getHexString() ?? "ffffff"}`, density },
+      issue: {
+        code: "fog_traced_as_volume",
+        severity: "info",
+        message: "The scene has fog. The render traces it as a volume that scatters light, so lights glow and throw beams in it; the viewport only fades surfaces with distance.",
+        docs: "https://bakery3.com/docs/environment#fog"
+      }
+    };
+  }
+  if (fog.isFog) {
+    return {
+      issue: {
+        code: "fog_linear_unsupported",
+        severity: "warning",
+        message: "The scene has a linear `Fog`, which is not rendered: a near and a far plane describe no volume. Use `FogExp2` to have the fog in the render.",
+        docs: "https://bakery3.com/docs/environment#fog"
+      }
+    };
+  }
+  return {};
+}
+function worldPosition(object) {
+  const e = object.matrixWorld.elements;
+  return [e[12], e[13], e[14]];
+}
+function worldZ(object) {
+  const e = object.matrixWorld.elements;
+  const length = Math.hypot(e[8], e[9], e[10]) || 1;
+  return [e[8] / length, e[9] / length, e[10] / length];
+}
+
+// src/bake/candidates.ts
+function bakeCandidates(options) {
+  const candidates = [];
+  options.scene.traverse((object) => {
+    if (shouldExclude(object)) return;
+    const mesh = object;
+    if (!mesh.isMesh) return;
+    const base = {
+      objectId: idOf(object),
+      object: mesh,
+      name: object.name || object.type,
+      path: scenePath(object)
+    };
+    const refusal = refuse(mesh);
+    if (refusal) {
+      candidates.push({
+        ...base,
+        bakeable: false,
+        reason: refusal,
+        defaultInclude: false
+      });
+      return;
+    }
+    const advisory = advise(mesh);
+    candidates.push({
+      ...base,
+      bakeable: true,
+      ...advisory ? { reason: advisory } : {},
+      defaultInclude: !advisory
+    });
+  });
+  return candidates;
+}
+function defaultIncludeIds(candidates) {
+  return candidates.filter((candidate) => candidate.bakeable && candidate.defaultInclude).map((candidate) => candidate.objectId);
+}
+function hasLightMapSlot(material) {
+  return "lightMap" in material;
+}
+function materialsOf(mesh) {
+  const material = mesh.material;
+  if (!material) return [];
+  return (Array.isArray(material) ? material : [material]).filter(Boolean);
+}
+function refuse(mesh) {
+  if (mesh.isInstancedMesh) {
+    return {
+      code: "BakeInstancedMesh",
+      message: `"${mesh.name || mesh.type}" is an InstancedMesh, so it cannot take a lightmap.`,
+      why: "Every instance shares one geometry and one material, so it would also share one lightmap: the chair in the corner would be lit like the chair by the window.",
+      fix: "Convert the instances you want baked into individual meshes, or leave them lit in realtime on top of the baked room."
+    };
+  }
+  if (mesh.isBatchedMesh) {
+    return {
+      code: "BakeBatchedMesh",
+      message: `"${mesh.name || mesh.type}" is a BatchedMesh, so it cannot take a lightmap.`,
+      why: "A BatchedMesh packs many objects into one draw with one material; a per-object lightmap has nowhere to attach.",
+      fix: "Bake the geometries as individual meshes, or leave this one lit in realtime."
+    };
+  }
+  if (mesh.isSkinnedMesh) {
+    return {
+      code: "BakeSkinnedMesh",
+      message: `"${mesh.name || mesh.type}" is skinned, so its lighting cannot be baked.`,
+      why: "A lightmap is fixed to the surface in its bind pose. The moment the skeleton moves, the baked shadows stay where the mesh used to be.",
+      fix: "Leave animated characters lit in realtime. They will still receive the baked room through your own lights."
+    };
+  }
+  const materials = materialsOf(mesh);
+  if (!materials.length) {
+    return {
+      code: "BakeNoMaterial",
+      message: `"${mesh.name || mesh.type}" has no material.`,
+      why: "A lightmap is a material slot; without a material there is nothing to set.",
+      fix: "Give the mesh a MeshStandardMaterial (or any material with a lightMap slot)."
+    };
+  }
+  const unsupported = materials.filter(
+    (material) => !hasLightMapSlot(material)
+  );
+  if (unsupported.length) {
+    const names = unsupported.map((material) => `${material.name || material.type}`).join(", ");
+    return {
+      code: "BakeNoLightMapSlot",
+      message: `"${mesh.name || mesh.type}" uses ${names}, which has no lightMap slot.`,
+      why: "three multiplies a lightmap into irradiance inside its own shading model. A raw ShaderMaterial writes its own color, so there is nothing to multiply into.",
+      fix: "Use MeshStandardMaterial / MeshPhysicalMaterial (or their Node variants), or sample the lightmap yourself in your shader."
+    };
+  }
+  return void 0;
+}
+function advise(mesh) {
+  const userData = mesh.userData?.bakery3 ?? {};
+  if (userData.bake === false) {
+    return {
+      code: "BakeOptedOut",
+      message: `"${mesh.name || mesh.type}" is marked userData.bakery3.bake = false.`,
+      why: "You asked for this one to stay out of bakes.",
+      fix: "Remove the flag, or tick the box to include it this once."
+    };
+  }
+  if (!mesh.visible || hasHiddenAncestor(mesh)) {
+    return {
+      code: "BakeObjectHidden",
+      message: `"${mesh.name || mesh.type}" is hidden right now.`,
+      why: "Hidden objects are hidden in the bake too, so its lightmap would come back black, and the render it is hidden from does not need one.",
+      fix: "Make it visible before baking if this variant is one you ship."
+    };
+  }
+  const glassy = materialsOf(mesh).filter(isTransmissive);
+  if (glassy.length) {
+    return {
+      code: "BakeTransmissiveMaterial",
+      message: `"${mesh.name || mesh.type}" is transparent or transmissive.`,
+      why: "A lightmap only modulates diffuse irradiance. Glass is almost entirely refraction and specular, so the baked map costs texels and changes nothing you can see.",
+      fix: "Leave it out: it will still refract the baked room around it. Tick the box if it is a frosted surface with real diffuse."
+    };
+  }
+  return void 0;
+}
+function hasHiddenAncestor(object) {
+  for (let node = object.parent; node; node = node.parent) {
+    if (!node.visible) return true;
+  }
+  return false;
+}
+function isTransmissive(material) {
+  const surface = material;
+  if ((surface.transmission ?? 0) > 0) return true;
+  if (material.transparent && (surface.opacity ?? 1) < 1) return true;
+  return false;
+}
+function shadowMesh(shadow, texture) {
+  const geometry = new PlaneGeometry(shadow.width, shadow.height);
+  geometry.rotateX(-Math.PI / 2);
+  const material = new MeshBasicMaterial({
+    map: texture,
+    blending: MultiplyBlending,
+    // Required: both renderers refuse MultiplyBlending without it and draw
+    // the plane opaque instead, so the ratio, near 1 almost everywhere, lands
+    // as a white square. With it the blend is `src·dst + dst·(1 − a)`, and
+    // the ratio has no alpha channel (a = 1), so it is exactly
+    // `floor · ratio`.
+    premultipliedAlpha: true,
+    transparent: true,
+    // It contributes nothing to depth: it is a mark on a surface that is
+    // already there, and writing depth would make it occlude the product
+    // standing on it.
+    depthWrite: false,
+    // Lit by nothing, tone mapped by nothing: see the header.
+    toneMapped: false,
+    side: DoubleSide
+  });
+  const mesh = new Mesh(geometry, material);
+  mesh.position.set(
+    shadow.center[0],
+    shadow.center[1] + shadow.lift,
+    shadow.center[2]
+  );
+  mesh.renderOrder = 1;
+  mesh.castShadow = false;
+  mesh.receiveShadow = false;
+  mesh.name = "bakery3 shadow";
+  mesh.userData.bakery3 = { exclude: true, shadow: true };
+  return mesh;
+}
+function configureShadow(texture) {
+  texture.colorSpace = LinearSRGBColorSpace;
+  texture.flipY = false;
+  texture.generateMipmaps = false;
+  texture.needsUpdate = true;
+  return texture;
+}
+function shadowTouch(scene, shadow, texture) {
+  const mesh = shadowMesh(shadow, texture);
+  return {
+    mesh,
+    on() {
+      scene.add(mesh);
+    },
+    off() {
+      scene.remove(mesh);
+    },
+    dispose() {
+      mesh.geometry.dispose();
+      mesh.material.dispose();
+    }
+  };
+}
+
+// src/bake/shading.ts
+var HOOKS = [
+  "onBeforeCompile",
+  "customProgramCacheKey",
+  "setupLightMap",
+  "setupLightingModel",
+  "_bakery3LightMapNode"
+];
+function bakedShadingTouch(material) {
+  const previous = /* @__PURE__ */ new Map();
+  let installed = false;
+  const target = material;
+  return {
+    on() {
+      if (installed) return;
+      for (const key of HOOKS)
+        previous.set(key, Object.getOwnPropertyDescriptor(target, key));
+      installBakedShading(material);
+      installed = true;
+    },
+    off() {
+      if (!installed) return;
+      for (const key of HOOKS) {
+        const descriptor = previous.get(key);
+        if (descriptor) Object.defineProperty(target, key, descriptor);
+        else delete target[key];
+      }
+      installed = false;
+    }
+  };
+}
+var ANCHOR = "#include <lights_fragment_maps>";
+var FALLBACK_ANCHOR = "#include <lights_fragment_end>";
+var REPLACE_DIFFUSE_GLSL = `
+#if defined( USE_LIGHTMAP ) && defined( RE_IndirectDiffuse )
+	// Bakery3: the lightmap is the whole diffuse irradiance (direct, ambient
+	// and environment included), so nothing else may add diffuse. Specular from
+	// the lamps and the environment stays live.
+	{
+		vec3 bakery3Irradiance = texture2D( lightMap, vLightMapUv ).rgb * lightMapIntensity;
+		reflectedLight.directDiffuse = vec3( 0.0 );
+		#if defined( STANDARD )
+			irradiance = vec3( 0.0 );
+			iblIrradiance = bakery3Irradiance;
+		#else
+			irradiance = bakery3Irradiance;
+		#endif
+	}
+#endif
+`;
+function patchFragmentShader(source) {
+  if (source.includes(ANCHOR))
+    return source.replace(ANCHOR, `${ANCHOR}
+${REPLACE_DIFFUSE_GLSL}`);
+  if (source.includes(FALLBACK_ANCHOR)) {
+    return source.replace(
+      FALLBACK_ANCHOR,
+      `${REPLACE_DIFFUSE_GLSL}
+${FALLBACK_ANCHOR}`
+    );
+  }
+  return source;
+}
+var CACHE_KEY_TAG = "|bakery3:lightmap-replace";
+function installBakedShading(material) {
+  const target = material;
+  const previousCompile = target.onBeforeCompile;
+  const ownCacheKey = Object.prototype.hasOwnProperty.call(
+    material,
+    "customProgramCacheKey"
+  ) ? target.customProgramCacheKey : null;
+  target.onBeforeCompile = function(shader, renderer) {
+    previousCompile.call(this, shader, renderer);
+    shader.fragmentShader = patchFragmentShader(shader.fragmentShader);
+  };
+  target.customProgramCacheKey = function() {
+    const base = ownCacheKey ? ownCacheKey.call(this) : previousCompile.toString();
+    return `${base}${CACHE_KEY_TAG}`;
+  };
+  const node = material;
+  node.setupLightMap = function(builder) {
+    const proto = Object.getPrototypeOf(this);
+    const irradianceNode = proto.setupLightMap ? proto.setupLightMap.call(this, builder) : null;
+    this._bakery3LightMapNode = irradianceNode?.node ?? null;
+    return irradianceNode;
+  };
+  node.setupLightingModel = function(builder) {
+    const proto = Object.getPrototypeOf(this);
+    const model = proto.setupLightingModel ? proto.setupLightingModel.call(this, builder) : null;
+    if (!model) return model;
+    return bakedLightingModel(model, this._bakery3LightMapNode ?? null);
+  };
+}
+function bakedLightingModel(model, lightMap) {
+  const wrapped = Object.create(model);
+  if (model.direct) {
+    const direct = model.direct;
+    wrapped.direct = function(input, builder) {
+      return direct.call(
+        this,
+        { ...input, reflectedLight: withoutDiffuse(input.reflectedLight) },
+        builder
+      );
+    };
+  }
+  if (model.directRectArea) {
+    const directRectArea = model.directRectArea;
+    wrapped.directRectArea = function(input, builder) {
+      return directRectArea.call(
+        this,
+        { ...input, reflectedLight: withoutDiffuse(input.reflectedLight) },
+        builder
+      );
+    };
+  }
+  if (model.indirect) {
+    const indirect = model.indirect;
+    wrapped.indirect = function(builder) {
+      const context = builder.context;
+      if (lightMap && context.irradiance && context.iblIrradiance) {
+        const zero = context.irradiance.mul(0);
+        if (typeof model.computeMultiscattering === "function") {
+          context.iblIrradiance.assign(lightMap);
+          context.irradiance.assign(zero);
+        } else {
+          context.irradiance.assign(lightMap);
+        }
+      }
+      return indirect.call(this, builder);
+    };
+  }
+  return wrapped;
+}
+function withoutDiffuse(reflectedLight) {
+  return {
+    ...reflectedLight,
+    directDiffuse: reflectedLight.directDiffuse.mul(0).toVar()
+  };
+}
+
+// src/bake/proxies.ts
+function buildProxyTouches(options) {
+  const touches = [];
+  const applied = [];
+  const replaced = [];
+  const skipped = [];
+  for (const { proxy, textures } of options.proxies) {
+    const stoodFor = proxy.replaces.flatMap((id) => options.byId.get(id) ?? []);
+    if (!stoodFor.length) {
+      skipped.push({
+        objectId: `simplify[${proxy.index}]`,
+        ...proxy.name ? { name: proxy.name } : {},
+        code: "BakeStandInUnmatched",
+        message: `None of the objects "${proxy.name ?? `stand-in ${proxy.index}`}" replaces are in the scene.`,
+        why: "A stand-in goes in where the objects it was made from come out, and they are gone.",
+        fix: "Bake again against the scene as it stands."
+      });
+      continue;
+    }
+    const mesh = proxy.kind === "billboard" && textures.kind === "billboard" ? billboardMesh(proxy, textures.map) : proxy.kind === "mesh" && textures.kind === "mesh" ? standInMesh(proxy, textures, options.intensity, options.shading) : proxy.kind === "decimated" && textures.kind === "decimated" ? decimatedMesh(proxy, textures.light, stoodFor[0], options) : null;
+    if (!mesh) continue;
+    mesh.name = `bakery3 stand-in ${proxy.index}${proxy.name ? ` (${proxy.name})` : ""}`;
+    mesh.userData.bakery3 = { exclude: true, standIn: proxy.index };
+    touches.push(swapTouch(options.scene, mesh, stoodFor));
+    applied.push(proxy.index);
+    replaced.push(...proxy.replaces.filter((id) => options.byId.has(id)));
+  }
+  return { touches, applied, replaced, skipped };
+}
+function standInMesh(proxy, textures, intensity, shading) {
+  const geometry = new BufferGeometry();
+  const source = proxy.geometry;
+  geometry.setAttribute(
+    "position",
+    new BufferAttribute(new Float32Array(source.position), 3)
+  );
+  geometry.setAttribute(
+    "normal",
+    new BufferAttribute(new Float32Array(source.normal), 3)
+  );
+  const uv = new Float32Array(source.uv);
+  geometry.setAttribute("uv", new BufferAttribute(uv, 2));
+  geometry.setAttribute("uv1", new BufferAttribute(uv, 2));
+  if (source.tangent)
+    geometry.setAttribute(
+      "tangent",
+      new BufferAttribute(new Float32Array(source.tangent), 4)
+    );
+  const count = source.position.length / 3;
+  geometry.setIndex(
+    new BufferAttribute(
+      count > 65535 ? new Uint32Array(source.index) : new Uint16Array(source.index),
+      1
+    )
+  );
+  geometry.computeBoundingSphere();
+  geometry.computeBoundingBox();
+  const material = new MeshStandardMaterial({
+    map: textures.color,
+    normalMap: textures.normal,
+    normalScale: new Vector2(1, 1),
+    roughness: proxy.roughness,
+    metalness: proxy.metalness,
+    lightMap: textures.light,
+    lightMapIntensity: intensity
+  });
+  if (shading === "replace") bakedShadingTouch(material).on();
+  return new Mesh(geometry, material);
+}
+function decimatedMesh(proxy, light, replaced, options) {
+  const geometry = new BufferGeometry();
+  const source = proxy.geometry;
+  geometry.setAttribute(
+    "position",
+    new BufferAttribute(new Float32Array(source.position), 3)
+  );
+  geometry.setAttribute(
+    "normal",
+    new BufferAttribute(new Float32Array(source.normal), 3)
+  );
+  geometry.setAttribute(
+    "uv",
+    new BufferAttribute(new Float32Array(source.uv), 2)
+  );
+  if (source.uv1)
+    geometry.setAttribute(
+      "uv1",
+      new BufferAttribute(new Float32Array(source.uv1), 2)
+    );
+  if (source.color)
+    geometry.setAttribute(
+      "color",
+      new BufferAttribute(new Float32Array(source.color), 3)
+    );
+  const count = source.position.length / 3;
+  geometry.setIndex(
+    new BufferAttribute(
+      count > 65535 ? new Uint32Array(source.index) : new Uint16Array(source.index),
+      1
+    )
+  );
+  for (const group of source.groups ?? [])
+    geometry.addGroup(group.start, group.count, group.materialIndex);
+  geometry.computeBoundingSphere();
+  geometry.computeBoundingBox();
+  let lightmap = light;
+  if (proxy.lightmapChannel !== light.channel) {
+    lightmap = light.clone();
+    lightmap.channel = proxy.lightmapChannel;
+    lightmap.needsUpdate = true;
+  }
+  const probed = options.probe && options.probe.meshes.has(replaced) ? options.probe.texture : void 0;
+  const dress = (material2) => {
+    const clone = material2.clone();
+    if (clone.vertexColors && !source.color) {
+      clone.vertexColors = false;
+    }
+    if ("lightMap" in clone) {
+      clone.lightMap = lightmap;
+      clone.lightMapIntensity = options.intensity;
+      if (probed && "envMap" in clone) clone.envMap = probed;
+      if (options.shading === "replace")
+        bakedShadingTouch(clone).on();
+    }
+    return clone;
+  };
+  const material = Array.isArray(replaced.material) ? replaced.material.map(dress) : dress(replaced.material);
+  const mesh = new Mesh(geometry, material);
+  mesh.userData.bakery3LightmapView = lightmap === light ? void 0 : lightmap;
+  return mesh;
+}
+function billboardMesh(proxy, map) {
+  const geometry = new PlaneGeometry(proxy.width, proxy.height);
+  const material = new MeshBasicMaterial({
+    map,
+    // A cutout, not a blend: a blended plant sorts against the glass behind
+    // it and loses, and the edge of a leaf is a hard edge anyway.
+    alphaTest: 0.5,
+    side: DoubleSide
+  });
+  const mesh = new Mesh(geometry, material);
+  mesh.position.set(proxy.center[0], proxy.center[1], proxy.center[2]);
+  mesh.castShadow = false;
+  mesh.receiveShadow = false;
+  mesh.frustumCulled = false;
+  const eye = new Vector3();
+  const here = new Vector3();
+  mesh.onBeforeRender = (_renderer, _scene, camera) => {
+    eye.setFromMatrixPosition(camera.matrixWorld);
+    here.setFromMatrixPosition(mesh.matrixWorld);
+    const turn = Math.atan2(eye.x - here.x, eye.z - here.z);
+    if (Math.abs(turn - mesh.rotation.y) < 1e-4) return;
+    mesh.rotation.set(0, turn, 0);
+    mesh.updateMatrix();
+    mesh.updateMatrixWorld(true);
+  };
+  return mesh;
+}
+function swapTouch(scene, mesh, stoodFor) {
+  const was = /* @__PURE__ */ new Map();
+  return {
+    on() {
+      for (const object of stoodFor) {
+        was.set(object, object.visible);
+        object.visible = false;
+      }
+      scene.add(mesh);
+    },
+    off() {
+      scene.remove(mesh);
+      for (const [object, visible] of was) object.visible = visible;
+      was.clear();
+    },
+    dispose() {
+      mesh.geometry.dispose();
+      for (const material of Array.isArray(mesh.material) ? mesh.material : [mesh.material])
+        material.dispose();
+      mesh.userData.bakery3LightmapView?.dispose();
+    }
+  };
+}
+
+// src/bake/apply.ts
+var bakeWritten = /* @__PURE__ */ new WeakSet();
+function isBakeWrittenUv(attribute) {
+  return Boolean(attribute && bakeWritten.has(attribute));
+}
+function buildPatch(options) {
+  const { scene, intensity } = options;
+  const shading = options.shading ?? "replace";
+  const byId = indexObjects(scene);
+  const geometryUsers = /* @__PURE__ */ new Map();
+  const materialUsers = /* @__PURE__ */ new Map();
+  scene.traverse((object) => {
+    const mesh = object;
+    if (!mesh.isMesh) return;
+    if (mesh.geometry) {
+      const users = geometryUsers.get(mesh.geometry) ?? [];
+      users.push(mesh);
+      geometryUsers.set(mesh.geometry, users);
+    }
+    for (const material of materialsOf(mesh)) {
+      const users = materialUsers.get(material) ?? /* @__PURE__ */ new Set();
+      users.add(mesh);
+      materialUsers.set(material, users);
+    }
+  });
+  const uvById = /* @__PURE__ */ new Map();
+  for (const entry of options.objects)
+    uvById.set(entry.baked.objectId, entry.baked.uv);
+  const touches = [];
+  const uvWrites = /* @__PURE__ */ new Map();
+  const applied = [];
+  const unmatched = [];
+  const skipped = [];
+  const meshes = /* @__PURE__ */ new Set();
+  for (const { baked, texture } of options.objects) {
+    const found = byId.get(baked.objectId);
+    if (!found || found.length === 0) {
+      unmatched.push(baked.objectId);
+      continue;
+    }
+    if (found.length > 1) {
+      skipped.push({
+        objectId: baked.objectId,
+        ...baked.name ? { name: baked.name } : {},
+        code: "BakeAmbiguousObjectId",
+        message: `${found.length} objects in the scene answer to the id "${baked.objectId}".`,
+        why: "Applying the lightmap to one of them would be a coin toss, and applying it to all of them would light the wrong surfaces.",
+        fix: "Give each object a distinct userData.bakery3Id."
+      });
+      continue;
+    }
+    const object = found[0];
+    const mesh = object;
+    if (!mesh.isMesh || mesh.isInstancedMesh || mesh.isSkinnedMesh) {
+      skipped.push({
+        objectId: baked.objectId,
+        ...baked.name ? { name: baked.name } : {},
+        code: "BakeObjectChanged",
+        message: `"${baked.name ?? baked.objectId}" is a ${object.type} now, not a plain mesh.`,
+        why: "The bake was made against a mesh that could take a lightmap. Whatever is under that id today cannot.",
+        fix: "Bake again against the scene as it stands."
+      });
+      continue;
+    }
+    const plan = planGeometry({
+      mesh,
+      uv: baked.uv,
+      geometryUsers,
+      uvById,
+      objectId: baked.objectId,
+      ...baked.name !== void 0 ? { name: baked.name } : {}
+    });
+    if ("skip" in plan) {
+      skipped.push(plan.skip);
+      continue;
+    }
+    let lightmap = texture;
+    if (plan.kind === "in-place") {
+      if (!uvWrites.has(mesh.geometry)) {
+        uvWrites.set(mesh.geometry, true);
+        touches.push(uvAttributeTouch(mesh.geometry, plan.attribute));
+      }
+    } else if (plan.kind === "channel") {
+      lightmap = onChannel(texture, plan.channel, touches);
+    } else {
+      touches.push(geometrySwapTouch(mesh, plan.geometry));
+    }
+    touches.push(
+      ...materialTouches(mesh, lightmap, intensity, materialUsers, shading)
+    );
+    meshes.add(mesh);
+    applied.push(baked.objectId);
+  }
+  const probed = [];
+  if (options.probe) {
+    const targets = new Set(options.probe.meshes);
+    const written = /* @__PURE__ */ new Set();
+    for (const mesh of options.probe.meshes) {
+      const probeTouchesFor = probeTouches(
+        mesh,
+        options.probe.texture,
+        materialUsers,
+        targets,
+        written
+      );
+      if (!probeTouchesFor.length) continue;
+      touches.push(...probeTouchesFor);
+      meshes.add(mesh);
+      probed.push(idOf(mesh));
+    }
+  }
+  const standIns = buildProxyTouches({
+    scene,
+    proxies: options.proxies ?? [],
+    byId,
+    intensity,
+    shading,
+    ...options.probe ? {
+      probe: {
+        texture: options.probe.texture,
+        meshes: new Set(options.probe.meshes)
+      }
+    } : {}
+  });
+  touches.push(...standIns.touches);
+  skipped.push(...standIns.skipped);
+  if (options.shadow) {
+    touches.push(
+      shadowTouch(scene, options.shadow.shadow, options.shadow.texture)
+    );
+  }
+  return {
+    patch: makePatch(touches, meshes.size + standIns.applied.length),
+    applied,
+    unmatched,
+    skipped,
+    probed,
+    standIns: standIns.applied,
+    replaced: standIns.replaced,
+    shadow: Boolean(options.shadow)
+  };
+}
+function probeTouches(mesh, texture, materialUsers, targets, written) {
+  const original = mesh.material;
+  const slots = materialsOf(mesh).filter((material) => "envMap" in material);
+  if (!slots.length) return [];
+  const touches = [];
+  const clones = [];
+  const mapped = /* @__PURE__ */ new Map();
+  let swapped = false;
+  for (const material of slots) {
+    if (mapped.has(material)) continue;
+    const users = materialUsers.get(material) ?? /* @__PURE__ */ new Set([mesh]);
+    const allTargets = [...users].every((user) => targets.has(user));
+    if (allTargets) {
+      mapped.set(material, material);
+      if (!written.has(material)) {
+        written.add(material);
+        touches.push(inPlaceProbeTouch(material, texture));
+      }
+      continue;
+    }
+    const clone = material.clone();
+    markClone(clone, material);
+    clone.envMap = texture;
+    clone.needsUpdate = true;
+    mapped.set(material, clone);
+    clones.push(clone);
+    swapped = true;
+  }
+  if (swapped) {
+    const applied = Array.isArray(original) ? original.map((material) => mapped.get(material) ?? material) : mapped.get(original) ?? original;
+    touches.push(materialSwapTouch(mesh, applied, clones));
+  }
+  return touches;
+}
+function inPlaceProbeTouch(material, texture) {
+  const previous = material.envMap;
+  return {
+    on() {
+      material.envMap = texture;
+      material.needsUpdate = true;
+    },
+    off() {
+      material.envMap = previous;
+      material.needsUpdate = true;
+    },
+    dispose() {
+    }
+  };
+}
+function makePatch(touches, meshes) {
+  let active = false;
+  let disposed = false;
+  return {
+    get active() {
+      return active;
+    },
+    get meshes() {
+      return meshes;
+    },
+    on() {
+      if (active || disposed) return;
+      for (const touch of touches) touch.on();
+      active = true;
+    },
+    off() {
+      if (!active) return;
+      for (let i = touches.length - 1; i >= 0; i--) touches[i].off();
+      active = false;
+    },
+    dispose() {
+      if (disposed) return;
+      if (active) {
+        for (let i = touches.length - 1; i >= 0; i--) touches[i].off();
+        active = false;
+      }
+      for (const touch of touches) touch.dispose();
+      disposed = true;
+    }
+  };
+}
+function uvAttributeTouch(geometry, attribute) {
+  const previous = geometry.getAttribute("uv1");
+  return {
+    on() {
+      geometry.setAttribute("uv1", attribute);
+    },
+    off() {
+      if (previous) geometry.setAttribute("uv1", previous);
+      else geometry.deleteAttribute("uv1");
+    },
+    dispose() {
+    }
+  };
+}
+function geometrySwapTouch(mesh, rebuilt) {
+  const previous = mesh.geometry;
+  return {
+    on() {
+      mesh.geometry = rebuilt;
+    },
+    off() {
+      mesh.geometry = previous;
+    },
+    dispose() {
+      rebuilt.dispose();
+    }
+  };
+}
+function onChannel(texture, channel, touches) {
+  if (texture.channel === channel) return texture;
+  const view = texture.clone();
+  view.channel = channel;
+  view.needsUpdate = true;
+  touches.push({ on() {
+  }, off() {
+  }, dispose: () => view.dispose() });
+  return view;
+}
+function materialTouches(mesh, texture, intensity, materialUsers, shading) {
+  const original = mesh.material;
+  const slots = materialsOf(mesh);
+  const touches = [];
+  const clones = [];
+  const mapped = /* @__PURE__ */ new Map();
+  let swapped = false;
+  for (const material of slots) {
+    if (mapped.has(material)) continue;
+    const shared = (materialUsers.get(material)?.size ?? 1) > 1;
+    if (!shared) {
+      mapped.set(material, material);
+      touches.push(
+        inPlaceMaterialTouch(
+          material,
+          texture,
+          intensity,
+          shading
+        )
+      );
+      continue;
+    }
+    const clone = material.clone();
+    markClone(clone, material);
+    clone.lightMap = texture;
+    clone.lightMapIntensity = intensity;
+    if (shading === "replace") bakedShadingTouch(clone).on();
+    clone.needsUpdate = true;
+    mapped.set(material, clone);
+    clones.push(clone);
+    swapped = true;
+  }
+  if (swapped) {
+    const applied = Array.isArray(original) ? original.map((material) => mapped.get(material) ?? material) : mapped.get(original) ?? original;
+    touches.push(materialSwapTouch(mesh, applied, clones));
+  }
+  return touches;
+}
+function inPlaceMaterialTouch(material, texture, intensity, shading) {
+  const previousMap = material.lightMap;
+  const previousIntensity = material.lightMapIntensity;
+  const shadingTouch = shading === "replace" ? bakedShadingTouch(material) : null;
+  return {
+    on() {
+      material.lightMap = texture;
+      material.lightMapIntensity = intensity;
+      shadingTouch?.on();
+      material.needsUpdate = true;
+    },
+    off() {
+      shadingTouch?.off();
+      material.lightMap = previousMap;
+      material.lightMapIntensity = previousIntensity;
+      material.needsUpdate = true;
+    },
+    dispose() {
+    }
+  };
+}
+function materialSwapTouch(mesh, applied, clones) {
+  const previous = mesh.material;
+  return {
+    on() {
+      mesh.material = applied;
+    },
+    off() {
+      mesh.material = previous;
+    },
+    dispose() {
+      for (const clone of clones) clone.dispose();
+    }
+  };
+}
+function planGeometry(input) {
+  const { mesh, uv, objectId } = input;
+  const geometry = mesh.geometry;
+  const skip = (code, message, why, fix) => ({
+    skip: {
+      objectId,
+      ...input.name !== void 0 ? { name: input.name } : {},
+      code,
+      message,
+      why,
+      fix
+    }
+  });
+  if (!geometry) {
+    return skip(
+      "BakeNoGeometry",
+      `"${input.name ?? objectId}" has no geometry to put a second UV set on.`,
+      "The mesh that was baked is not the mesh that is in the scene now.",
+      "Bake again against the scene as it stands."
+    );
+  }
+  const position = geometry.getAttribute("position");
+  if (!position) {
+    return skip(
+      "BakeNoPosition",
+      `"${input.name ?? objectId}" has no position attribute.`,
+      "Without vertices there is nothing for the unwrap to index.",
+      "Bake again against the scene as it stands."
+    );
+  }
+  if ("channel" in uv) {
+    const name = uv.channel === 0 ? "uv" : "uv1";
+    const attribute2 = geometry.getAttribute(name);
+    if (!attribute2 || attribute2.count !== position.count) {
+      return skip(
+        "BakeUvChannelMissing",
+        `The lightmap for "${input.name ?? objectId}" is laid on its own \`${name}\`, and the mesh ${attribute2 ? "has a different number of them now" : "no longer has one"}.`,
+        "The bake reused the uv set the mesh was captured with instead of unwrapping it, so that set is what the lightmap lines up with.",
+        "Bake again against the scene as it stands."
+      );
+    }
+    return { kind: "channel", channel: uv.channel };
+  }
+  if ("topology" in uv) {
+    const { vertexSource, index, values: values2 } = uv.topology;
+    if (values2.length !== vertexSource.length * 2) {
+      return skip(
+        "BakeUvLengthMismatch",
+        `The unwrap for "${input.name ?? objectId}" has ${values2.length / 2} UVs for ${vertexSource.length} vertices.`,
+        "The bundle is internally inconsistent, which means the render worker and this SDK disagree about the format.",
+        "Update @oeave/bakery3, or bake again."
+      );
+    }
+    for (const source of vertexSource) {
+      if (!Number.isInteger(source) || source < 0 || source >= position.count) {
+        return skip(
+          "BakeTopologyOutOfRange",
+          `The rebuild for "${input.name ?? objectId}" refers to vertex ${source}, and the live geometry has ${position.count}.`,
+          "The geometry changed between the bake and now: a different subdivision, a different loader, or an edit.",
+          "Bake again against the scene as it stands."
+        );
+      }
+    }
+    if (Array.isArray(mesh.material) && geometry.groups.length > 1) {
+      return skip(
+        "BakeTopologyGroupsUnsupported",
+        `"${input.name ?? objectId}" needs a geometry rebuild and has ${geometry.groups.length} material groups.`,
+        "A rebuild renumbers the triangle index, and this version cannot prove which of your groups each new triangle belongs to. Guessing would assign the wrong material to part of the surface.",
+        "Split the mesh into one mesh per material, or bake it at a size whose unwrap does not need vertex splits."
+      );
+    }
+    if (geometry.drawRange.start !== 0 || Number.isFinite(geometry.drawRange.count)) {
+      return skip(
+        "BakeDrawRangeUnsupported",
+        `"${input.name ?? objectId}" needs a geometry rebuild and draws only part of its index.`,
+        "The rebuild renumbers the index, so the partial draw range would point at different triangles.",
+        "Clear setDrawRange() before baking, or split the mesh."
+      );
+    }
+    return {
+      kind: "rebuild",
+      geometry: rebuildGeometry(geometry, uv.topology)
+    };
+  }
+  const values = uv.values;
+  if (values.length !== position.count * 2) {
+    return skip(
+      "BakeVertexCountMismatch",
+      `The bake has ${values.length / 2} UVs for "${input.name ?? objectId}", and the live geometry has ${position.count} vertices.`,
+      "The geometry changed between baking and applying, so the unwrap no longer describes this surface.",
+      "Bake again against the scene as it stands."
+    );
+  }
+  const attribute = new BufferAttribute(new Float32Array(values), 2);
+  bakeWritten.add(attribute);
+  const sharers = (input.geometryUsers.get(geometry) ?? []).filter(
+    (other) => other !== mesh
+  );
+  const conflicted = sharers.some((other) => {
+    const otherUv = input.uvById.get(idOf(other));
+    if (!otherUv) return false;
+    if ("channel" in otherUv) return otherUv.channel === 1;
+    if ("topology" in otherUv) return true;
+    return !sameValues(otherUv.values, values);
+  });
+  if (!conflicted) return { kind: "in-place", attribute };
+  const copy = geometry.clone();
+  copy.setAttribute("uv1", attribute);
+  return { kind: "rebuild", geometry: copy };
+}
+function sameValues(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+function rebuildGeometry(source, topology) {
+  const { vertexSource, index, values } = topology;
+  const target = new BufferGeometry();
+  target.name = source.name;
+  target.userData = { ...source.userData };
+  for (const [name, attribute] of Object.entries(source.attributes)) {
+    target.setAttribute(
+      name,
+      gather(attribute, vertexSource)
+    );
+  }
+  const morphs = target.morphAttributes;
+  for (const [name, list] of Object.entries(
+    source.morphAttributes
+  )) {
+    morphs[name] = list.map((attribute) => gather(attribute, vertexSource));
+  }
+  target.morphTargetsRelative = source.morphTargetsRelative;
+  const lightmapUv = new BufferAttribute(new Float32Array(values), 2);
+  bakeWritten.add(lightmapUv);
+  target.setAttribute("uv1", lightmapUv);
+  const IndexArray = vertexSource.length > 65535 ? Uint32Array : Uint16Array;
+  target.setIndex(new BufferAttribute(IndexArray.from(index), 1));
+  const group = source.groups[0];
+  if (group) target.addGroup(0, index.length, group.materialIndex);
+  return target;
+}
+function gather(attribute, vertexSource) {
+  const itemSize = attribute.itemSize;
+  const SourceArray = attribute.array.constructor;
+  const aligned = SourceArray.BYTES_PER_ELEMENT * itemSize % 4 === 0;
+  const ArrayType = aligned ? SourceArray : Float32Array;
+  const out = new BufferAttribute(
+    new ArrayType(vertexSource.length * itemSize),
+    itemSize,
+    aligned && attribute.normalized
+  );
+  out.name = attribute.name;
+  for (let i = 0; i < vertexSource.length; i++) {
+    const source = vertexSource[i];
+    for (let component = 0; component < itemSize; component++) {
+      out.setComponent(i, component, attribute.getComponent(source, component));
+    }
+  }
+  return out;
+}
+function indexObjects(scene) {
+  const byId = /* @__PURE__ */ new Map();
+  scene.traverse((object) => {
+    const id = idOf(object);
+    const list = byId.get(id);
+    if (list) list.push(object);
+    else byId.set(id, [object]);
+  });
+  return byId;
+}
+var BAKE_VIEW_ANGLE_STEP = 30;
+var OCTAVE_MIN = -3;
+var OCTAVE_MAX = 8;
+var scratchBox = new Box3();
+var scratchCenter = new Vector3();
+var scratchSize = new Vector3();
+var scratchCamera = new Vector3();
+var scratchDirection = new Vector3();
+function bakeBounds(objects) {
+  const bounds = new Box3();
+  for (const object of objects) {
+    scratchBox.setFromObject(object);
+    if (!scratchBox.isEmpty()) bounds.union(scratchBox);
+  }
+  return bounds;
+}
+function quantizeBakeView(camera, bounds) {
+  const center = bounds.isEmpty() ? scratchCenter.set(0, 0, 0) : bounds.getCenter(scratchCenter);
+  const radius = bounds.isEmpty() ? 1 : Math.max(1e-3, bounds.getSize(scratchSize).length() / 2);
+  camera.updateWorldMatrix(true, false);
+  const position = camera.getWorldPosition(scratchCamera);
+  const offset = scratchDirection.subVectors(position, center);
+  let distance = offset.length();
+  if (distance < 1e-6) {
+    camera.getWorldDirection(offset).negate();
+    distance = radius;
+  } else {
+    offset.divideScalar(distance);
+  }
+  const elevation = toDegrees(Math.asin(clamp(offset.y, -1, 1)));
+  const azimuth = toDegrees(Math.atan2(offset.x, offset.z));
+  const step = BAKE_VIEW_ANGLE_STEP;
+  const elevationBin = clamp(
+    binCenter(elevation, step),
+    -90 + step / 2,
+    90 - step / 2
+  );
+  const azimuthBin = binCenter(azimuth, step);
+  const octave = clamp(
+    Math.round(Math.log2(distance / radius)),
+    OCTAVE_MIN,
+    OCTAVE_MAX
+  );
+  const snappedDistance = radius * 2 ** octave;
+  const el = toRadians(elevationBin);
+  const az = toRadians(azimuthBin);
+  const direction = scratchDirection.set(
+    Math.cos(el) * Math.sin(az),
+    Math.sin(el),
+    Math.cos(el) * Math.cos(az)
+  );
+  const snapped = direction.multiplyScalar(snappedDistance).add(center);
+  return {
+    position: [round(snapped.x), round(snapped.y), round(snapped.z)]
+  };
+}
+function binCenter(value, step) {
+  return (Math.floor(value / step) + 0.5) * step;
+}
+function round(value) {
+  const rounded = Math.round(value * 1e4) / 1e4;
+  return Object.is(rounded, -0) ? 0 : rounded;
+}
+var clamp = (value, low, high) => Math.min(high, Math.max(low, value));
+var toDegrees = (radians) => radians * 180 / Math.PI;
+var toRadians = (degrees) => degrees * Math.PI / 180;
+
+// src/bake/probe.ts
+var PROBE_SCENERY_FACTOR = 4;
+var SCENERY_REASONS = /* @__PURE__ */ new Set([
+  "BakeTransmissiveMaterial",
+  "BakeObjectHidden"
+]);
+var scratchBox2 = new Box3();
+var scratchSize2 = new Vector3();
+var scratchCenter2 = new Vector3();
+function resolveProbe(candidates, include) {
+  const included = new Set(include);
+  const keptLive = candidates.filter(
+    (candidate) => candidate.bakeable && !included.has(candidate.objectId) && !SCENERY_REASONS.has(candidate.reason?.code ?? "")
+  );
+  const subject = withoutScenery(keptLive);
+  const anchor = subject.length ? subject : candidates.filter((candidate) => included.has(candidate.objectId));
+  const bounds = bakeBounds(anchor.map((candidate) => candidate.object));
+  const center = bounds.isEmpty() ? scratchCenter2.set(0, 0, 0) : bounds.getCenter(scratchCenter2);
+  return {
+    position: [round2(center.x), round2(center.y), round2(center.z)],
+    hide: subject.map((candidate) => candidate.objectId)
+  };
+}
+function probeTargets(candidates, bakedIds) {
+  return candidates.filter((candidate) => !bakedIds.has(candidate.objectId)).map((candidate) => candidate.object);
+}
+function withoutScenery(keptLive) {
+  if (keptLive.length < 2) return keptLive;
+  const diagonals = keptLive.map((candidate) => {
+    scratchBox2.setFromObject(candidate.object);
+    return scratchBox2.isEmpty() ? 0 : scratchBox2.getSize(scratchSize2).length();
+  });
+  const sorted = [...diagonals].sort((a, b) => a - b);
+  const median = sorted[Math.floor(sorted.length / 2)];
+  if (median <= 0) return keptLive;
+  return keptLive.filter(
+    (_candidate, i) => diagonals[i] <= median * PROBE_SCENERY_FACTOR
+  );
+}
+function round2(value) {
+  return Math.round(value * 1e4) / 1e4;
+}
+
+export { bakeBounds, bakeCandidates, buildPatch, captureEnvironmentSettings, captureFog, captureLights, captureRuntime, configureShadow, defaultIncludeIds, excludedItself, idOf, isBakeWrittenUv, probeTargets, quantizeBakeView, readUserData, resolveProbe, scenePath, shouldExclude, stampIds };
+//# sourceMappingURL=chunk-HQTUFVMM.js.map
+//# sourceMappingURL=chunk-HQTUFVMM.js.map