@cueframe/kernel 0.2.2 → 0.2.4

package/dist/chunk-VKATKWWR.js

@@ -0,0 +1,1462 @@
+import {
+  PHOTOGRAPHIC_STUDIO_EDGE_INTENSITY,
+  PHOTOGRAPHIC_STUDIO_EDGE_LIGHTS,
+  PHOTOGRAPHIC_STUDIO_GPU_BYTES,
+  PHOTOGRAPHIC_STUDIO_HDRI_BYTES,
+  PHOTOGRAPHIC_STUDIO_HDRI_PATH,
+  PHOTOGRAPHIC_STUDIO_HDRI_SHA256,
+  PHOTOGRAPHIC_STUDIO_RIG_FACTS,
+  PHOTOGRAPHIC_STUDIO_RIG_ID,
+  SCENE_PRESET_TRIANGLES,
+  SCENE_SLAB_BODY_TRIANGLES,
+  SCENE_SLAB_CONTENT_FACE_TRIANGLES,
+  STUDIO_SHADOW_MAP_BUDGET,
+  sceneDeviceDimensionsV1,
+  sceneFocusPreparationAllocationsV1,
+  sceneLaptopLayoutV1,
+  sceneLaptopScreenQuadV1,
+  sceneW5GeneratedRigAllocationsV1,
+  sceneW5PresetAllocationsV1,
+  sceneW5WorldTextAllocationsV1
+} from "./chunk-MH3UPKWR.js";
+
+// ../execution/animate/src/three/toneMapping.ts
+import {
+  ACESFilmicToneMapping,
+  AgXToneMapping,
+  CineonToneMapping,
+  LinearToneMapping,
+  NeutralToneMapping,
+  NoToneMapping,
+  ReinhardToneMapping,
+  ShaderChunk
+} from "three";
+var TONE_MAPPING_FUNCTIONS = /* @__PURE__ */ new Map([
+  [LinearToneMapping, "Linear"],
+  [ReinhardToneMapping, "Reinhard"],
+  [CineonToneMapping, "Cineon"],
+  [ACESFilmicToneMapping, "ACESFilmic"],
+  [AgXToneMapping, "AgX"],
+  [NeutralToneMapping, "Neutral"]
+]);
+function toneMappingPreamble(toneMapping) {
+  if (toneMapping === NoToneMapping) return "";
+  const name = TONE_MAPPING_FUNCTIONS.get(toneMapping);
+  if (name === void 0) {
+    throw new Error(
+      `this renderer's tone mapping (${toneMapping}) has no function in three's own table, so a lit material cannot apply it itself; scene shots render into a target, where three applies none`
+    );
+  }
+  return [
+    "#define TONE_MAPPING",
+    ShaderChunk.tonemapping_pars_fragment,
+    `vec3 toneMapping( vec3 color ) { return ${name}ToneMapping( color ); }`,
+    ""
+  ].join("\n");
+}
+function toneMapInTheMaterial(shader, renderer) {
+  shader.fragmentShader = toneMappingPreamble(renderer.toneMapping) + shader.fragmentShader;
+}
+var SELF_TONE_MAPPED = { toneMapped: false, onBeforeCompile: toneMapInTheMaterial };
+var UNLIT_COLOUR_MANAGED = { toneMapped: false };
+
+// ../execution/animate/src/scene/v2/runtimeAllocations.ts
+import { createContext, createElement, useCallback, useContext, useLayoutEffect, useState } from "react";
+var state = {
+  createdPlans: 0,
+  disposedPlans: 0,
+  livePlans: 0,
+  liveContextGlBytes: 0,
+  liveCpuBytes: 0,
+  peakGlBytesIncludingPreparation: 0,
+  peakDeclaredLiveBytes: 0,
+  actualCreatedResources: 0,
+  actualDisposedResources: 0,
+  actualLiveGlBytes: 0,
+  actualLiveCpuBytes: 0,
+  actualPeakLiveBytes: 0,
+  actualLiveRows: []
+};
+var liveObjects = /* @__PURE__ */ new WeakSet();
+var nextResourceId = 1;
+var nextMountId = 1;
+var resources = /* @__PURE__ */ new Map();
+var mounts = /* @__PURE__ */ new Map();
+var SceneRuntimeMountContextV1 = createContext(null);
+var RECEIPT_PREFIX = "__cueframe_scene_resource_v1__:";
+var runtimeInstanceId = globalThis.crypto?.randomUUID?.() ?? `runtime-${Date.now()}-${Math.random()}`;
+function emitReceipt(event) {
+  console.info(`${RECEIPT_PREFIX}${JSON.stringify({ runtimeInstanceId, ...event })}`);
+}
+function canonicalRowsForMount(mountId, rows) {
+  const mount = mounts.get(mountId);
+  if (!mount) throw new Error("scene_runtime_mount_missing");
+  return rows.map((row) => {
+    const owners = new Set(mount.plan.ledger.allocations.filter((candidate) => candidate.owner === row.owner || candidate.owner.endsWith(`:${row.owner}`)).map((candidate) => candidate.owner));
+    if (owners.size !== 1) throw new Error(`scene_runtime_resource_owner_unresolved: ${row.owner}`);
+    return { ...row, owner: [...owners][0] };
+  });
+}
+function sceneActualResourceRegistrarForMountV1(mountId) {
+  return (object, rows) => registerActualSceneResourcesV1(object, canonicalRowsForMount(mountId, rows), mountId);
+}
+function tokenRegistrar(token) {
+  return (object, rows) => {
+    const pending = { object, rows, cancelled: false };
+    token.pending.add(pending);
+    if (token.mountId !== void 0) pending.actualRelease = sceneActualResourceRegistrarForMountV1(token.mountId)(object, rows);
+    return () => {
+      if (pending.cancelled) return;
+      pending.cancelled = true;
+      pending.actualRelease?.();
+      token.pending.delete(pending);
+    };
+  };
+}
+function useSceneActualResourceRegistrarV1() {
+  const token = useContext(SceneRuntimeMountContextV1);
+  return useCallback(token === null ? registerActualSceneResourcesV1 : tokenRegistrar(token), [token]);
+}
+function CommittedSceneRuntimeBoundaryV1({ plan, children }) {
+  const [token] = useState(() => ({ plan, pending: /* @__PURE__ */ new Set() }));
+  useLayoutEffect(() => {
+    const lease = reserveSceneRuntimeAllocationV1(plan);
+    token.mountId = lease.mountId;
+    token.releaseMount = lease.release;
+    for (const pending of token.pending) if (!pending.cancelled && !pending.actualRelease) {
+      pending.actualRelease = sceneActualResourceRegistrarForMountV1(lease.mountId)(pending.object, pending.rows);
+    }
+    return () => {
+      token.releaseMount?.();
+      token.releaseMount = void 0;
+      token.mountId = void 0;
+    };
+  }, [plan, token]);
+  return createElement(SceneRuntimeMountContextV1.Provider, { value: token }, children);
+}
+function SceneRuntimeAllocationBoundaryV1({ plan, children }) {
+  return createElement(CommittedSceneRuntimeBoundaryV1, { key: plan.sealSha256, plan }, children);
+}
+function sceneRuntimeAllocationSnapshotV1() {
+  return Object.freeze({
+    ...state,
+    actualLiveRows: Object.freeze(state.actualLiveRows.map((row) => Object.freeze({ ...row })))
+  });
+}
+function resetSceneRuntimeAllocationCountersV1() {
+  if (state.livePlans !== 0 || state.actualCreatedResources !== state.actualDisposedResources) throw new Error("scene_runtime_allocation_reset_while_live");
+  Object.assign(state, {
+    createdPlans: 0,
+    disposedPlans: 0,
+    livePlans: 0,
+    liveContextGlBytes: 0,
+    liveCpuBytes: 0,
+    peakGlBytesIncludingPreparation: 0,
+    peakDeclaredLiveBytes: 0,
+    actualCreatedResources: 0,
+    actualDisposedResources: 0,
+    actualLiveGlBytes: 0,
+    actualLiveCpuBytes: 0,
+    actualPeakLiveBytes: 0,
+    actualLiveRows: []
+  });
+  nextResourceId = 1;
+  nextMountId = 1;
+  resources.clear();
+  mounts.clear();
+}
+function registerActualSceneResourcesV1(object, rows, mountId) {
+  if (liveObjects.has(object)) throw new Error("scene_runtime_resource_already_registered");
+  let gl = 0;
+  let cpu = 0;
+  for (const row of rows) {
+    if (!row.owner || !row.name || !Number.isSafeInteger(row.bytes) || row.bytes < 0) {
+      throw new Error("scene_runtime_resource_measurement_invalid");
+    }
+    for (const value of [row.width, row.height, row.samples, row.byteLength]) {
+      if (value !== void 0 && (!Number.isSafeInteger(value) || value < 0)) {
+        throw new Error("scene_runtime_resource_measurement_invalid");
+      }
+    }
+    if (row.domain === "gl") gl += row.bytes;
+    else if (row.domain === "cpu") cpu += row.bytes;
+    else throw new Error("scene_runtime_resource_domain_invalid");
+  }
+  const resourceId = nextResourceId++;
+  liveObjects.add(object);
+  state.actualCreatedResources += 1;
+  state.actualLiveGlBytes += gl;
+  state.actualLiveCpuBytes += cpu;
+  state.actualPeakLiveBytes = Math.max(state.actualPeakLiveBytes, state.actualLiveGlBytes + state.actualLiveCpuBytes);
+  state.actualLiveRows = [...state.actualLiveRows, ...rows.map((row) => ({ ...row, resourceId }))];
+  resources.set(resourceId, { rows, assignedMountId: mountId });
+  emitReceipt({ type: "resource-created", resourceId, rows, snapshot: sceneRuntimeAllocationSnapshotV1() });
+  if (mountId !== void 0) emitReceipt({ type: "resource-assigned", resourceId, mountId });
+  let disposed = false;
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    liveObjects.delete(object);
+    state.actualDisposedResources += 1;
+    state.actualLiveGlBytes -= gl;
+    state.actualLiveCpuBytes -= cpu;
+    state.actualLiveRows = state.actualLiveRows.filter((row) => row.resourceId !== resourceId);
+    emitReceipt({
+      type: "resource-disposed",
+      resourceId,
+      mountId: resources.get(resourceId)?.assignedMountId,
+      snapshot: sceneRuntimeAllocationSnapshotV1()
+    });
+    resources.delete(resourceId);
+  };
+}
+function reserveSceneRuntimeAllocationV1(plan) {
+  const { contextGlBytes, preparationPeakGlBytes, cpuBytes } = plan.ledger;
+  for (const [field, value] of Object.entries({ contextGlBytes, preparationPeakGlBytes, cpuBytes })) {
+    if (!Number.isSafeInteger(value) || value < 0) throw new Error(`scene_runtime_allocation_invalid: ${field}`);
+  }
+  state.createdPlans += 1;
+  state.livePlans += 1;
+  state.liveContextGlBytes += contextGlBytes;
+  state.liveCpuBytes += cpuBytes;
+  const glIncludingPreparation = state.liveContextGlBytes - contextGlBytes + preparationPeakGlBytes;
+  state.peakGlBytesIncludingPreparation = Math.max(state.peakGlBytesIncludingPreparation, glIncludingPreparation);
+  state.peakDeclaredLiveBytes = Math.max(state.peakDeclaredLiveBytes, glIncludingPreparation + state.liveCpuBytes);
+  const mountId = nextMountId++;
+  mounts.set(mountId, { plan });
+  emitReceipt({ type: "plan-mounted", mountId, sealSha256: plan.sealSha256, ledger: plan.ledger, snapshot: sceneRuntimeAllocationSnapshotV1() });
+  let released = false;
+  return { mountId, release: () => {
+    if (released) return;
+    released = true;
+    state.disposedPlans += 1;
+    state.livePlans -= 1;
+    state.liveContextGlBytes -= contextGlBytes;
+    state.liveCpuBytes -= cpuBytes;
+    emitReceipt({ type: "plan-unmounted", mountId, sealSha256: plan.sealSha256, snapshot: sceneRuntimeAllocationSnapshotV1() });
+    mounts.delete(mountId);
+  } };
+}
+function acquireSceneRuntimeAllocationV1(plan) {
+  return reserveSceneRuntimeAllocationV1(plan).release;
+}
+
+// ../execution/animate/src/three/StudioRig.tsx
+import { useLayoutEffect as useLayoutEffect2, useRef } from "react";
+import { useThree } from "@react-three/fiber";
+import { PMREMGenerator, Vector3 } from "three";
+import { RoomEnvironment } from "three/examples/jsm/environments/RoomEnvironment.js";
+
+// ../execution/animate/src/scene/v2/renderTargetObserver.ts
+var states = /* @__PURE__ */ new WeakMap();
+function subscribeSceneRenderTargetsV1(renderer, subscriber) {
+  let state2 = states.get(renderer);
+  if (!state2) {
+    const original = renderer.setRenderTarget;
+    state2 = { subscribers: /* @__PURE__ */ new Set(), original };
+    states.set(renderer, state2);
+    renderer.setRenderTarget = function observedSetRenderTarget(target, ...rest) {
+      const current = states.get(renderer);
+      if (current) for (const listener of [...current.subscribers]) listener(target);
+      return original.call(this, target, ...rest);
+    };
+  }
+  state2.subscribers.add(subscriber);
+  let closed = false;
+  return () => {
+    if (closed) return;
+    closed = true;
+    const current = states.get(renderer);
+    if (!current) return;
+    current.subscribers.delete(subscriber);
+    if (current.subscribers.size === 0) {
+      renderer.setRenderTarget = current.original;
+      states.delete(renderer);
+    }
+  };
+}
+
+// ../execution/animate/src/scene/v2/observePmremTargets.ts
+import { HalfFloatType } from "three";
+function withObservedPmremTargetsV1(renderer, owner, build, registerActual = registerActualSceneResourcesV1) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const unsubscribe = subscribeSceneRenderTargetsV1(renderer, (target) => {
+    if (target && !seen.has(target)) {
+      seen.add(target);
+      const texture = Array.isArray(target.texture) ? target.texture[0] : target.texture;
+      const colorBytes = target.width * target.height * (texture?.type === HalfFloatType ? 8 : 4) * Math.max(1, target.samples || 1);
+      const rows = [{
+        owner,
+        name: "pmrem-observed-color",
+        domain: "gl",
+        bytes: colorBytes,
+        width: target.width,
+        height: target.height,
+        samples: Math.max(1, target.samples || 1),
+        evidenceOnly: true
+      }];
+      if (target.depthBuffer) rows.push({
+        owner,
+        name: "pmrem-observed-depth",
+        domain: "gl",
+        bytes: target.width * target.height * 4 * Math.max(1, target.samples || 1),
+        width: target.width,
+        height: target.height,
+        samples: Math.max(1, target.samples || 1),
+        evidenceOnly: true
+      });
+      const release = registerActual(target, rows);
+      target.addEventListener("dispose", release);
+    }
+  });
+  try {
+    return build();
+  } finally {
+    unsubscribe();
+  }
+}
+
+// ../execution/animate/src/three/StudioRig.tsx
+var DEFAULT_LIGHTING_PROFILE = "studio";
+var LIGHTING_PROFILES = ["studio", "studio-edge"];
+var STUDIO_LIGHTS = [
+  { role: "key", position: [700, 1100, 1300], castShadow: false },
+  { role: "fill", position: [-1100, 400, 900], castShadow: false },
+  { role: "rim", position: [0, 1300, -1900], castShadow: true }
+];
+var STUDIO_EDGE_LIGHTS = [
+  [2e3, 350, -700],
+  [-2e3, 350, -700]
+];
+var STUDIO_EDGE_INTENSITY = 20;
+function studioEdgeLightCount(profile) {
+  return profile === "studio-edge" ? STUDIO_EDGE_LIGHTS.length : 0;
+}
+var STUDIO_SHADOW_FRUSTUM = { extent: 1600, near: 100, far: 6e3, mapSize: 2048 };
+var STUDIO_SHADOW_REACH_PAD = 1.25;
+var STUDIO_FLOOR_EXTENT = 12e3;
+function studioCasterBasis(worldScale) {
+  const caster = STUDIO_LIGHTS.find((l) => l.castShadow);
+  const eye = new Vector3(...studioLightPosition(caster, worldScale));
+  const back = eye.clone().normalize();
+  const right = new Vector3(0, 1, 0).cross(back).normalize();
+  const up = back.clone().cross(right);
+  return { eye, right, up, forward: back.clone().negate() };
+}
+function studioShadowFrustum(worldScale, bounds, floorY) {
+  const f = STUDIO_SHADOW_FRUSTUM;
+  const base = { extent: f.extent * worldScale, near: f.near * worldScale, far: f.far * worldScale, mapSize: f.mapSize };
+  if (!bounds) return base;
+  const { eye, right, up, forward } = studioCasterBasis(worldScale);
+  let reach = 0;
+  let nearest = Number.POSITIVE_INFINITY;
+  let farthest = Number.NEGATIVE_INFINITY;
+  const corner = new Vector3();
+  const offset = new Vector3();
+  for (const x of [bounds.minX, bounds.maxX]) for (const y of [bounds.minY, bounds.maxY]) for (const z of [bounds.minZ, bounds.maxZ]) {
+    corner.set(x, y, z);
+    reach = Math.max(reach, Math.abs(corner.dot(right)), Math.abs(corner.dot(up)));
+    const depth = offset.copy(corner).sub(eye).dot(forward);
+    nearest = Math.min(nearest, depth);
+    farthest = Math.max(farthest, depth);
+    if (floorY !== void 0 && forward.y < 0 && corner.y > floorY) {
+      farthest = Math.max(farthest, depth + (corner.y - floorY) / -forward.y);
+    }
+  }
+  const extent = Math.max(base.extent, reach * STUDIO_SHADOW_REACH_PAD);
+  let mapSize = base.mapSize;
+  while (mapSize < STUDIO_SHADOW_MAP_BUDGET && mapSize * base.extent < base.mapSize * extent) mapSize *= 2;
+  return {
+    extent,
+    near: Math.max(1, Math.min(base.near, nearest / STUDIO_SHADOW_REACH_PAD)),
+    far: Math.max(base.far, farthest * STUDIO_SHADOW_REACH_PAD),
+    mapSize
+  };
+}
+function studioLightPosition(light, worldScale) {
+  const [x, y, z] = light.position;
+  return [x * worldScale, y * worldScale, z * worldScale];
+}
+var STUDIO_PRESETS = {
+  soft: { hemi: 0.7, key: 1.6, fill: 0.9, rim: 1 },
+  key: { hemi: 0.4, key: 2.6, fill: 0.5, rim: 0.8 },
+  rim: { hemi: 0.35, key: 1.2, fill: 0.4, rim: 2.4 }
+};
+function MeasuredRimLight({ position, intensity, frustum }) {
+  const registerActual = useSceneActualResourceRegistrarV1();
+  const light = useRef(null);
+  const gl = useThree((state2) => state2.gl);
+  useLayoutEffect2(() => {
+    const current = light.current;
+    if (!current) return;
+    let observed = null;
+    const unsubscribe = subscribeSceneRenderTargetsV1(gl, (target) => {
+      if (target && target === current.shadow.map && observed !== target) {
+        observed = target;
+        const bytes = target.width * target.height * 4;
+        const release = registerActual(target, [
+          {
+            owner: "studio:rim",
+            name: "shadow-color",
+            domain: "gl",
+            bytes,
+            width: target.width,
+            height: target.height
+          },
+          {
+            owner: "studio:rim",
+            name: "shadow-depth",
+            domain: "gl",
+            bytes,
+            width: target.width,
+            height: target.height
+          }
+        ]);
+        target.addEventListener("dispose", release);
+      }
+    });
+    return () => {
+      unsubscribe();
+      current.shadow.dispose();
+    };
+  }, [frustum.mapSize, gl, registerActual]);
+  return /* @__PURE__ */ React.createElement(
+    "directionalLight",
+    {
+      ref: light,
+      position,
+      intensity,
+      castShadow: true,
+      "shadow-mapSize": [frustum.mapSize, frustum.mapSize],
+      "shadow-bias": -4e-4,
+      "shadow-camera-left": -frustum.extent,
+      "shadow-camera-right": frustum.extent,
+      "shadow-camera-top": frustum.extent,
+      "shadow-camera-bottom": -frustum.extent,
+      "shadow-camera-near": frustum.near,
+      "shadow-camera-far": frustum.far
+    }
+  );
+}
+function Environment() {
+  const registerActual = useSceneActualResourceRegistrarV1();
+  const gl = useThree((s) => s.gl);
+  const scene = useThree((s) => s.scene);
+  useLayoutEffect2(() => {
+    const pmrem = new PMREMGenerator(gl);
+    let target;
+    try {
+      target = withObservedPmremTargetsV1(gl, "studio:environment", () => pmrem.fromScene(new RoomEnvironment(), 0.04), registerActual);
+    } finally {
+      pmrem.dispose();
+    }
+    scene.environment = target.texture;
+    return () => {
+      scene.environment = null;
+      target.dispose();
+    };
+  }, [gl, scene, registerActual]);
+  return null;
+}
+function StudioRig({ lightingProfile = DEFAULT_LIGHTING_PROFILE, preset = "soft", intensity = 1, floorY = -420, shadowOpacity = 0.5, environment = true, worldScale = 1, shadowBounds }) {
+  const p = STUDIO_PRESETS[preset];
+  const frustum = studioShadowFrustum(worldScale, shadowBounds, floorY);
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, environment ? /* @__PURE__ */ React.createElement(Environment, null) : null, /* @__PURE__ */ React.createElement("hemisphereLight", { args: ["#ffffff", "#202024", p.hemi * intensity] }), STUDIO_LIGHTS.map((light) => light.castShadow ? /* @__PURE__ */ React.createElement(MeasuredRimLight, { key: light.role, position: studioLightPosition(light, worldScale), intensity: p[light.role] * intensity, frustum }) : /* @__PURE__ */ React.createElement("directionalLight", { key: light.role, position: studioLightPosition(light, worldScale), intensity: p[light.role] * intensity })), STUDIO_EDGE_LIGHTS.slice(0, studioEdgeLightCount(lightingProfile)).map(([x, y, z], i) => /* @__PURE__ */ React.createElement(
+    "directionalLight",
+    {
+      key: `edge-${i}`,
+      position: [x * worldScale, y * worldScale, z * worldScale],
+      intensity: STUDIO_EDGE_INTENSITY,
+      castShadow: false
+    }
+  )), /* @__PURE__ */ React.createElement("mesh", { rotation: [-Math.PI / 2, 0, 0], position: [0, floorY, 0], receiveShadow: true }, /* @__PURE__ */ React.createElement("planeGeometry", { args: [STUDIO_FLOOR_EXTENT * worldScale, STUDIO_FLOOR_EXTENT * worldScale] }), /* @__PURE__ */ React.createElement("shadowMaterial", { transparent: true, opacity: shadowOpacity, ...SELF_TONE_MAPPED })));
+}
+
+// ../execution/animate/src/three/DeviceMesh.tsx
+import { useLayoutEffect as useLayoutEffect4, useMemo } from "react";
+import { RoundedBoxGeometry } from "three/examples/jsm/geometries/RoundedBoxGeometry.js";
+import { ExtrudeGeometry, Shape } from "three";
+
+// ../execution/animate/src/scene/v2/MeasuredPlaneGeometry.tsx
+import { useLayoutEffect as useLayoutEffect3, useRef as useRef2 } from "react";
+function bufferBytes(geometry) {
+  let bytes = geometry.index?.array.byteLength ?? 0;
+  for (const attribute of Object.values(geometry.attributes)) bytes += attribute.array.byteLength;
+  return bytes;
+}
+function MeasuredPlaneGeometry({ width, height, owner, name }) {
+  const registerActual = useSceneActualResourceRegistrarV1();
+  const geometry = useRef2(null);
+  const observed = useRef2(null);
+  useLayoutEffect3(() => {
+    const current = geometry.current;
+    if (!current || observed.current === current) return;
+    observed.current = current;
+    const bytes = bufferBytes(current);
+    const release = registerActual(current, [
+      { owner, name, domain: "gl", bytes, byteLength: bytes },
+      { owner, name: `${name}-arrays`, domain: "cpu", bytes, byteLength: bytes }
+    ]);
+    current.addEventListener("dispose", release);
+  }, [name, owner, registerActual]);
+  return /* @__PURE__ */ React.createElement("planeGeometry", { ref: geometry, args: [width, height] });
+}
+
+// ../execution/animate/src/three/DeviceMesh.tsx
+function deviceDimensions(kind, width) {
+  return sceneDeviceDimensionsV1(kind, width);
+}
+function laptopLayout(dim) {
+  return sceneLaptopLayoutV1(dim);
+}
+var DEVICE_GLASS_OPACITY_ENCODED = 0.1;
+var DEVICE_GLASS_OPACITY_LINEAR = ((DEVICE_GLASS_OPACITY_ENCODED + 0.055) / 1.055) ** 2.4;
+var DEVICE_LIT_MATERIALS = {
+  /** The phone's shell: `meshPhysicalMaterial`, the caller's finish. */
+  phoneShell: { ...SELF_TONE_MAPPED, metalness: 0.85, roughness: 0.32, clearcoat: 0.5, clearcoatRoughness: 0.2 },
+  /** The laptop's base and its lid, which take the same finish and the same material. */
+  laptopShell: { ...SELF_TONE_MAPPED, metalness: 0.85, roughness: 0.35, clearcoat: 0.4 },
+  /** The keyboard well on the laptop's base: `meshStandardMaterial`. */
+  keyboard: { ...SELF_TONE_MAPPED, color: "#111114", roughness: 0.9, metalness: 0.1 },
+  /** The trackpad in front of it: `meshStandardMaterial`. */
+  trackpad: { ...SELF_TONE_MAPPED, color: "#1a1a1f", roughness: 0.6, metalness: 0.3 },
+  /** The dark bezel behind the lid's screen: `meshStandardMaterial`. */
+  bezel: { ...SELF_TONE_MAPPED, color: "#050507", roughness: 0.5 },
+  /**
+   * The screen's glass sheen: `meshPhysicalMaterial`, default albedo, per-pipeline opacity.
+   *
+   * `envMapIntensity` is the one number in this table that does not reach a frame on its own —
+   * it needs `takeSceneEnvironment` on the mesh that draws it. See that function.
+   */
+  glass: { ...SELF_TONE_MAPPED, transparent: true, roughness: 0.06, metalness: 0, envMapIntensity: 1.2 }
+};
+function takeSceneEnvironment(_renderer, scene, _camera, _geometry, material) {
+  const lit = material;
+  if (lit.envMap !== scene.environment) lit.envMap = scene.environment;
+}
+function lidRotationX(openAngle) {
+  return (90 - openAngle) * Math.PI / 180;
+}
+function roundedRectShape(w, h, radius) {
+  const r = Math.min(radius, w / 2, h / 2);
+  const x = w / 2;
+  const y = h / 2;
+  const shape = new Shape();
+  shape.moveTo(-x + r, -y);
+  shape.lineTo(x - r, -y);
+  shape.absarc(x - r, -y + r, r, -Math.PI / 2, 0, false);
+  shape.lineTo(x, y - r);
+  shape.absarc(x - r, y - r, r, 0, Math.PI / 2, false);
+  shape.lineTo(-x + r, y);
+  shape.absarc(-x + r, y - r, r, Math.PI / 2, Math.PI, false);
+  shape.lineTo(-x, -y + r);
+  shape.absarc(-x + r, -y + r, r, Math.PI, Math.PI * 1.5, false);
+  return shape;
+}
+function phoneShellGeometry(w, h, t, radius) {
+  const bevel = Math.min(t * 0.14, radius / 2, w / 4, h / 4);
+  const depth = t - bevel * 2;
+  const geometry = new ExtrudeGeometry(roundedRectShape(w - bevel * 2, h - bevel * 2, radius - bevel), {
+    depth,
+    bevelEnabled: true,
+    bevelThickness: bevel,
+    bevelSize: bevel,
+    bevelOffset: 0,
+    bevelSegments: 3,
+    curveSegments: 24
+  });
+  geometry.translate(0, 0, -depth / 2);
+  return geometry;
+}
+var DEVICE_PLANE_OFFSETS = {
+  /** The lid's dark bezel, behind the screenshot. */
+  bezel: 0.3,
+  /** The screenshot itself. */
+  screen: 0.6,
+  /** The glass sheen over it. */
+  glass: 1.2
+};
+function geometryBytes(geometry) {
+  let bytes = geometry.index?.array.byteLength ?? 0;
+  for (const attribute of Object.values(geometry.attributes)) bytes += attribute.array.byteLength;
+  return bytes;
+}
+function ownDeviceGeometryV1(geometry, owner, name, registerActual = registerActualSceneResourcesV1) {
+  const bytes = geometryBytes(geometry);
+  const release = registerActual(geometry, [
+    { owner, name, domain: "gl", bytes, byteLength: bytes },
+    { owner, name: `${name}-arrays`, domain: "cpu", bytes, byteLength: bytes }
+  ]);
+  return () => {
+    geometry.dispose();
+    release();
+  };
+}
+function useOwnedGeometry(geometry, owner, name, registerActual) {
+  useLayoutEffect4(() => {
+    if (!geometry) return;
+    return ownDeviceGeometryV1(geometry, owner, name, registerActual);
+  }, [geometry, owner, name, registerActual]);
+}
+function useShell(kind, w, h, t, r) {
+  return useMemo(
+    () => kind === "phone" ? phoneShellGeometry(w, h, t, r) : new RoundedBoxGeometry(w, h, t, 4, r),
+    [kind, w, h, t, r]
+  );
+}
+function materialProps(override) {
+  if (!override) return {};
+  const { role: _role, type: _type, ...props } = override;
+  return props;
+}
+function DeviceMesh({ kind, screen, screenColor, materialOverrides = {}, finish = "#2a2a30", glassOpacity = DEVICE_GLASS_OPACITY_ENCODED, openAngle = 100, width, position = [0, 0, 0], rotation = [0, 0, 0], resourceOwner = `device:${kind}:unscoped` }) {
+  const registerActual = useSceneActualResourceRegistrarV1();
+  const dim = deviceDimensions(kind, width ?? (kind === "phone" ? 380 : 1100));
+  const shell = useShell(kind, dim.w, dim.h, dim.t, dim.radius);
+  const base = useMemo(
+    () => kind === "laptop" ? new RoundedBoxGeometry(dim.w, dim.t, dim.d, 4, dim.radius) : null,
+    [kind, dim.w, dim.t, dim.d, dim.radius]
+  );
+  useOwnedGeometry(shell, resourceOwner, "shell-geometry", registerActual);
+  useOwnedGeometry(base, resourceOwner, "base-geometry", registerActual);
+  const screenW = dim.w - dim.screenInset * 2;
+  const screenH = dim.h - dim.screenInset * 2;
+  const screenPlane = /* @__PURE__ */ React.createElement("mesh", { position: [0, 0, dim.t / 2 + DEVICE_PLANE_OFFSETS.screen] }, /* @__PURE__ */ React.createElement(MeasuredPlaneGeometry, { width: screenW, height: screenH, owner: resourceOwner, name: "screen-geometry" }), screen ? /* @__PURE__ */ React.createElement("meshBasicMaterial", { map: screen, ...UNLIT_COLOUR_MANAGED, ...materialProps(materialOverrides.screen) }) : /* @__PURE__ */ React.createElement("meshBasicMaterial", { color: screenColor ?? "#000000", ...UNLIT_COLOUR_MANAGED, ...materialProps(materialOverrides.screen) }));
+  const glass = /* @__PURE__ */ React.createElement("mesh", { position: [0, 0, dim.t / 2 + DEVICE_PLANE_OFFSETS.glass], onBeforeRender: takeSceneEnvironment }, /* @__PURE__ */ React.createElement(MeasuredPlaneGeometry, { width: screenW, height: screenH, owner: resourceOwner, name: "glass-geometry" }), /* @__PURE__ */ React.createElement("meshPhysicalMaterial", { ...DEVICE_LIT_MATERIALS.glass, opacity: glassOpacity, ...materialProps(materialOverrides.glass) }));
+  if (kind === "phone") {
+    return /* @__PURE__ */ React.createElement("group", { position, rotation }, /* @__PURE__ */ React.createElement("mesh", { geometry: shell, castShadow: true, receiveShadow: true }, /* @__PURE__ */ React.createElement("meshPhysicalMaterial", { color: finish, ...DEVICE_LIT_MATERIALS.phoneShell, ...materialProps(materialOverrides.shell) })), screenPlane, glass);
+  }
+  const layout = laptopLayout(dim);
+  return /* @__PURE__ */ React.createElement("group", { position, rotation }, /* @__PURE__ */ React.createElement("group", { position: [0, layout.baseY, 0] }, /* @__PURE__ */ React.createElement("mesh", { geometry: base, position: [0, 0, 0], castShadow: true, receiveShadow: true }, /* @__PURE__ */ React.createElement("meshPhysicalMaterial", { color: finish, ...DEVICE_LIT_MATERIALS.laptopShell, ...materialProps(materialOverrides.shell) })), /* @__PURE__ */ React.createElement("mesh", { position: [0, dim.t / 2 + 0.4, dim.d * 0.05], rotation: [-Math.PI / 2, 0, 0] }, /* @__PURE__ */ React.createElement(MeasuredPlaneGeometry, { width: dim.w * 0.86, height: dim.d * 0.42, owner: resourceOwner, name: "keyboard-geometry" }), /* @__PURE__ */ React.createElement("meshPhysicalMaterial", { ...DEVICE_LIT_MATERIALS.keyboard, ...materialProps(materialOverrides.keyboard) })), /* @__PURE__ */ React.createElement("mesh", { position: [0, dim.t / 2 + 0.4, dim.d * 0.36], rotation: [-Math.PI / 2, 0, 0] }, /* @__PURE__ */ React.createElement(MeasuredPlaneGeometry, { width: dim.w * 0.3, height: dim.d * 0.18, owner: resourceOwner, name: "trackpad-geometry" }), /* @__PURE__ */ React.createElement("meshPhysicalMaterial", { ...DEVICE_LIT_MATERIALS.trackpad, ...materialProps(materialOverrides.trackpad) })), /* @__PURE__ */ React.createElement("group", { position: [0, layout.hingeFromBaseY, layout.hingeZ], rotation: [lidRotationX(openAngle), 0, 0] }, /* @__PURE__ */ React.createElement("group", { position: [0, layout.lidCentreY, 0] }, /* @__PURE__ */ React.createElement("mesh", { geometry: shell, castShadow: true }, /* @__PURE__ */ React.createElement("meshPhysicalMaterial", { color: finish, ...DEVICE_LIT_MATERIALS.laptopShell, ...materialProps(materialOverrides.shell) })), /* @__PURE__ */ React.createElement("mesh", { position: [0, 0, dim.t / 2 + DEVICE_PLANE_OFFSETS.bezel] }, /* @__PURE__ */ React.createElement(MeasuredPlaneGeometry, { width: dim.w - dim.screenInset * 0.6, height: dim.h - dim.screenInset * 0.6, owner: resourceOwner, name: "bezel-geometry" }), /* @__PURE__ */ React.createElement("meshPhysicalMaterial", { ...DEVICE_LIT_MATERIALS.bezel, ...materialProps(materialOverrides.bezel) })), screenPlane, glass))));
+}
+
+// ../execution/animate/src/scene/v2/PhotographicStudioRig.tsx
+import { useEffect, useRef as useRef3, useState as useState2 } from "react";
+import { useThree as useThree2 } from "@react-three/fiber";
+import { cancelRender, continueRender, delayRender, staticFile } from "remotion";
+import {
+  EquirectangularReflectionMapping,
+  DataTexture,
+  HalfFloatType as HalfFloatType2,
+  LinearFilter,
+  LinearSRGBColorSpace,
+  PMREMGenerator as PMREMGenerator2,
+  RGBAFormat
+} from "three";
+import { RGBELoader } from "three/examples/jsm/loaders/RGBELoader.js";
+var PhotographicStudioEnvironmentError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "PhotographicStudioEnvironmentError";
+    this.code = code;
+  }
+};
+var hex = (bytes) => Array.from(new Uint8Array(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+async function verifyPhotographicStudioHdr(bytes) {
+  const actual = hex(await globalThis.crypto.subtle.digest("SHA-256", Uint8Array.from(bytes)));
+  if (bytes.byteLength !== PHOTOGRAPHIC_STUDIO_HDRI_BYTES || actual !== PHOTOGRAPHIC_STUDIO_HDRI_SHA256) {
+    throw new PhotographicStudioEnvironmentError(
+      "scene_photographic_environment_digest_mismatch",
+      `photographic-studio-v1 HDRI identity mismatch: expected ${PHOTOGRAPHIC_STUDIO_HDRI_BYTES} bytes sha256 ${PHOTOGRAPHIC_STUDIO_HDRI_SHA256}, got ${bytes.byteLength} bytes sha256 ${actual}.`
+    );
+  }
+}
+function FixedEnvironment() {
+  const registerActual = useSceneActualResourceRegistrarV1();
+  const gl = useThree2((state2) => state2.gl);
+  const scene = useThree2((state2) => state2.scene);
+  const advance = useThree2((state2) => state2.advance);
+  const [handle] = useState2(() => delayRender("scene: photographic-studio-v1 environment"));
+  const lifecycle = useRef3({ generation: 0, settled: false });
+  useEffect(() => {
+    const generation = ++lifecycle.current.generation;
+    const abort = new AbortController();
+    const previousEnvironment = scene.environment;
+    const previousIntensity = scene.environmentIntensity;
+    let active = true;
+    let target = null;
+    const settle = (error) => {
+      if (lifecycle.current.settled) return;
+      lifecycle.current.settled = true;
+      if (error) cancelRender(error);
+      else continueRender(handle);
+    };
+    void (async () => {
+      let hdr = null;
+      let pmrem = null;
+      try {
+        let response;
+        let bytes;
+        try {
+          response = await fetch(staticFile(PHOTOGRAPHIC_STUDIO_HDRI_PATH), { signal: abort.signal });
+          if (!response.ok) throw new Error(`HTTP ${response.status}`);
+          bytes = new Uint8Array(await response.arrayBuffer());
+        } catch (error) {
+          if (!active || abort.signal.aborted) return;
+          throw new PhotographicStudioEnvironmentError(
+            "scene_photographic_environment_fetch_failed",
+            `photographic-studio-v1 HDRI fetch failed: ${error instanceof Error ? error.message : String(error)}.`
+          );
+        }
+        await verifyPhotographicStudioHdr(bytes);
+        if (!active) return;
+        try {
+          const parsed = new RGBELoader().parse(Uint8Array.from(bytes).buffer);
+          hdr = new DataTexture(parsed.data, parsed.width, parsed.height, RGBAFormat, parsed.type);
+          hdr.colorSpace = LinearSRGBColorSpace;
+          hdr.minFilter = LinearFilter;
+          hdr.magFilter = LinearFilter;
+          hdr.generateMipmaps = false;
+          hdr.flipY = true;
+          hdr.mapping = EquirectangularReflectionMapping;
+          hdr.needsUpdate = true;
+          const releaseHdrMeasurement = registerActual(hdr, [
+            {
+              owner: "rig:photographic-studio-v1",
+              name: "decoded-hdri",
+              domain: "cpu",
+              bytes: parsed.data.byteLength,
+              width: parsed.width,
+              height: parsed.height,
+              byteLength: parsed.data.byteLength
+            },
+            {
+              owner: "rig:photographic-studio-v1",
+              name: "rgbe-source",
+              domain: "gl",
+              bytes: parsed.data.byteLength,
+              width: parsed.width,
+              height: parsed.height
+            }
+          ]);
+          hdr.addEventListener("dispose", releaseHdrMeasurement);
+          pmrem = new PMREMGenerator2(gl);
+          target = withObservedPmremTargetsV1(gl, "rig:photographic-studio-v1", () => pmrem.fromEquirectangular(hdr), registerActual);
+          if (parsed.width !== 1024 || parsed.height !== 512 || parsed.type !== HalfFloatType2 || target.width !== 768 || target.height !== 1024 || target.texture.type !== HalfFloatType2 || target.texture.format !== RGBAFormat) {
+            throw new Error(`unexpected HDRI/PMREM allocation ${parsed.width}x${parsed.height}/${parsed.type} -> ${target.width}x${target.height}/${target.texture.type}/${target.texture.format}`);
+          }
+        } catch (error) {
+          throw new PhotographicStudioEnvironmentError(
+            "scene_photographic_environment_decode_failed",
+            `photographic-studio-v1 HDRI decode/PMREM failed: ${error instanceof Error ? error.message : String(error)}.`
+          );
+        }
+        if (!active) {
+          target.dispose();
+          target = null;
+          return;
+        }
+        scene.environment = target.texture;
+        scene.environmentIntensity = PHOTOGRAPHIC_STUDIO_RIG_FACTS.environmentIntensity;
+        advance(performance.now());
+        settle();
+      } catch (error) {
+        if (!active || abort.signal.aborted) return;
+        else settle(error instanceof Error ? error : new Error(String(error)));
+      } finally {
+        hdr?.dispose();
+        pmrem?.dispose();
+      }
+    })();
+    return () => {
+      active = false;
+      abort.abort();
+      if (target) {
+        if (scene.environment === target.texture) {
+          scene.environment = previousEnvironment;
+          scene.environmentIntensity = previousIntensity;
+        }
+        target.dispose();
+        target = null;
+      }
+      queueMicrotask(() => {
+        if (lifecycle.current.generation === generation) settle();
+      });
+    };
+  }, [advance, gl, handle, scene, registerActual]);
+  return null;
+}
+function PhotographicStudioRig({ worldScale = 1 }) {
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(FixedEnvironment, null), /* @__PURE__ */ React.createElement("hemisphereLight", { args: [
+    PHOTOGRAPHIC_STUDIO_RIG_FACTS.hemisphere.skyColor,
+    PHOTOGRAPHIC_STUDIO_RIG_FACTS.hemisphere.groundColor,
+    PHOTOGRAPHIC_STUDIO_RIG_FACTS.hemisphere.intensity
+  ] }), PHOTOGRAPHIC_STUDIO_RIG_FACTS.studioLights.map((light) => /* @__PURE__ */ React.createElement(
+    "directionalLight",
+    {
+      key: light.role,
+      position: studioLightPosition({ role: light.role, position: [...light.position], castShadow: false }, worldScale),
+      intensity: light.intensity,
+      castShadow: false
+    }
+  )), PHOTOGRAPHIC_STUDIO_EDGE_LIGHTS.map(([x, y, z], index) => /* @__PURE__ */ React.createElement(
+    "directionalLight",
+    {
+      key: `photographic-edge-${index}`,
+      position: [x * worldScale, y * worldScale, z * worldScale],
+      intensity: PHOTOGRAPHIC_STUDIO_EDGE_INTENSITY,
+      castShadow: false
+    }
+  )));
+}
+
+// ../execution/animate/src/scene/v2/finishes.ts
+import {
+  DataTexture as DataTexture2,
+  FrontSide,
+  LinearMipmapLinearFilter,
+  MeshPhysicalMaterial,
+  NoColorSpace,
+  RGBAFormat as RGBAFormat2,
+  RepeatWrapping,
+  UnsignedByteType
+} from "three";
+var SLAB_FINISHES = ["satin", "brushed"];
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var fade = (t) => t * t * (3 - 2 * t);
+function lattice(w, h, rand) {
+  const a = new Float32Array(w * h);
+  for (let i = 0; i < a.length; i += 1) a[i] = rand() * 2 - 1;
+  return a;
+}
+function sampleLattice(a, w, h, u, v) {
+  const x = u * w;
+  const y = v * h;
+  const x0 = Math.floor(x);
+  const y0 = Math.floor(y);
+  const fx = fade(x - x0);
+  const fy = fade(y - y0);
+  const xa = (x0 % w + w) % w;
+  const xb = (xa + 1) % w;
+  const ya = (y0 % h + h) % h;
+  const yb = (ya + 1) % h;
+  const p00 = a[ya * w + xa];
+  const p10 = a[ya * w + xb];
+  const p01 = a[yb * w + xa];
+  const p11 = a[yb * w + xb];
+  return (p00 * (1 - fx) + p10 * fx) * (1 - fy) + (p01 * (1 - fx) + p11 * fx) * fy;
+}
+function fbm(octaves, seed) {
+  const rand = mulberry32(seed);
+  const layers = octaves.map((o) => ({ ...o, data: lattice(o.w, o.h, rand) }));
+  const norm = layers.reduce((s, l) => s + l.amp, 0);
+  return (u, v) => {
+    let s = 0;
+    for (const l of layers) s += l.amp * sampleLattice(l.data, l.w, l.h, u, v);
+    return s / norm;
+  };
+}
+function asFinishMap(tex, tilePx) {
+  tex.wrapS = RepeatWrapping;
+  tex.wrapT = RepeatWrapping;
+  tex.repeat.set(1 / tilePx, 1 / tilePx);
+  tex.generateMipmaps = true;
+  tex.minFilter = LinearMipmapLinearFilter;
+  tex.colorSpace = NoColorSpace;
+  tex.needsUpdate = true;
+  return tex;
+}
+function satinRoughnessMap(size, tilePx, amp, seed) {
+  const n = fbm([{ w: 8, h: 8, amp: 1 }, { w: 16, h: 16, amp: 0.5 }, { w: 32, h: 32, amp: 0.25 }], seed);
+  const data = new Uint8Array(size * size * 4);
+  for (let y = 0; y < size; y += 1) {
+    for (let x = 0; x < size; x += 1) {
+      const v = (1 + amp * n(x / size, y / size)) / (1 + amp);
+      const b = Math.max(0, Math.min(255, Math.round(v * 255)));
+      const i = (y * size + x) * 4;
+      data[i] = b;
+      data[i + 1] = b;
+      data[i + 2] = b;
+      data[i + 3] = 255;
+    }
+  }
+  return asFinishMap(new DataTexture2(data, size, size, RGBAFormat2, UnsignedByteType), tilePx);
+}
+var satinRoughnessScalar = (base, amp) => base * (1 + amp);
+function normalFromHeight(size, tilePx, octaves, strength, seed) {
+  const n = fbm(octaves, seed);
+  const h = new Float32Array(size * size);
+  for (let y = 0; y < size; y += 1) for (let x = 0; x < size; x += 1) h[y * size + x] = n(x / size, y / size);
+  const at = (x, y) => h[(y % size + size) % size * size + (x % size + size) % size];
+  const data = new Uint8Array(size * size * 4);
+  for (let y = 0; y < size; y += 1) {
+    for (let x = 0; x < size; x += 1) {
+      const dx = (at(x + 1, y) - at(x - 1, y)) * 0.5 * strength;
+      const dy = (at(x, y + 1) - at(x, y - 1)) * 0.5 * strength;
+      const len = Math.hypot(-dx, -dy, 1);
+      const i = (y * size + x) * 4;
+      data[i] = Math.round((-dx / len * 0.5 + 0.5) * 255);
+      data[i + 1] = Math.round((-dy / len * 0.5 + 0.5) * 255);
+      data[i + 2] = Math.round((1 / len * 0.5 + 0.5) * 255);
+      data[i + 3] = 255;
+    }
+  }
+  return asFinishMap(new DataTexture2(data, size, size, RGBAFormat2, UnsignedByteType), tilePx);
+}
+var anodisedGrainNormal = (size, tilePx, seed) => normalFromHeight(size, tilePx, [{ w: 256, h: 256, amp: 1 }, { w: 512, h: 512, amp: 0.5 }], 1.2, seed);
+var brushedNormal = (size, tilePx, seed) => normalFromHeight(size, tilePx, [{ w: 512, h: 6, amp: 1 }, { w: 1024, h: 12, amp: 0.4 }], 2.5, seed);
+var SLAB_FINISH_SPEC = {
+  /** The W2 brushed defaults; satin overrides the original recipe's material fields below. */
+  common: {
+    clearcoat: 0.6,
+    clearcoatRoughness: 0.22,
+    /** Rule 2: declared here beside every map, so no map is silently multiplied by a stale scalar. */
+    metalness: 0,
+    mapSize: 2048
+  },
+  satin: {
+    /** The *base* roughness. The scalar three receives is `satinRoughnessScalar(base, amp)`. */
+    roughnessBase: 0.32,
+    roughnessAmp: 0.03,
+    roughnessTilePx: 1024,
+    roughnessSeed: 6221057,
+    roughnessMapSize: 512,
+    normalTilePx: 512,
+    normalSeed: 6221058,
+    normalMapSize: 512,
+    normalScale: 0.12,
+    metalness: 0.22,
+    clearcoat: 1,
+    clearcoatRoughness: 0.12,
+    envMapIntensity: 0.14
+  },
+  brushed: {
+    roughness: 0.28,
+    normalTilePx: 3,
+    normalSeed: 7,
+    /** Three's tangent/local-x is the slab's short axis, so rotate the BRDF onto long local-y. */
+    anisotropy: 0.65,
+    anisotropyRotation: Math.PI / 2,
+    clearcoatNormalTilePx: 9,
+    clearcoatNormalSeed: 13
+  }
+};
+function slabFinishMaterial(finish, baseColor, override, owner = "slab:unscoped", registerActual = registerActualSceneResourcesV1) {
+  const { common } = SLAB_FINISH_SPEC;
+  const material = new MeshPhysicalMaterial({
+    color: baseColor,
+    metalness: common.metalness,
+    clearcoat: common.clearcoat,
+    clearcoatRoughness: common.clearcoatRoughness,
+    side: FrontSide,
+    // The body is LIT and is drawn into the focus pass's half-float target, where three tone-maps
+    // nothing; this injection is what keeps its roll-off the same as on the canvas.
+    ...SELF_TONE_MAPPED
+  });
+  if (finish === "satin") {
+    const s = SLAB_FINISH_SPEC.satin;
+    material.roughness = satinRoughnessScalar(s.roughnessBase, s.roughnessAmp);
+    material.roughnessMap = satinRoughnessMap(s.roughnessMapSize, s.roughnessTilePx, s.roughnessAmp, s.roughnessSeed);
+    material.normalMap = anodisedGrainNormal(s.normalMapSize, s.normalTilePx, s.normalSeed);
+    material.normalScale.setScalar(s.normalScale);
+    material.metalness = s.metalness;
+    material.clearcoat = s.clearcoat;
+    material.clearcoatRoughness = s.clearcoatRoughness;
+    material.envMapIntensity = s.envMapIntensity;
+  } else {
+    const b = SLAB_FINISH_SPEC.brushed;
+    material.roughness = b.roughness;
+    material.normalMap = brushedNormal(common.mapSize, b.normalTilePx, b.normalSeed);
+    material.anisotropy = b.anisotropy;
+    material.anisotropyRotation = b.anisotropyRotation;
+    material.clearcoatNormalMap = anodisedGrainNormal(common.mapSize, b.clearcoatNormalTilePx, b.clearcoatNormalSeed);
+  }
+  if (override) {
+    if (override.type !== "physical") throw new Error(`scene_material_type_mismatch: slab body requires physical material.`);
+    if (override.color !== void 0) material.color.set(override.color);
+    for (const key of ["roughness", "metalness", "clearcoat", "clearcoatRoughness", "anisotropy", "anisotropyRotation", "ior", "reflectivity"]) {
+      const value = override[key];
+      if (value !== void 0) material[key] = value;
+    }
+  }
+  material.needsUpdate = true;
+  const maps = [material.roughnessMap, material.normalMap, material.clearcoatNormalMap].filter((map) => map instanceof DataTexture2);
+  const releaseMeasurement = registerActual(material, [
+    { owner, name: `${finish}-finish-source-arrays`, domain: "cpu", bytes: maps.reduce((sum, map) => sum + (map.image.data?.byteLength ?? 0), 0) },
+    { owner, name: `${finish}-finish-mip-chain`, domain: "gl", bytes: slabFinishDeclaredBytes(finish) }
+  ]);
+  return {
+    material,
+    dispose() {
+      material.roughnessMap?.dispose();
+      material.normalMap?.dispose();
+      material.clearcoatNormalMap?.dispose();
+      material.dispose();
+      releaseMeasurement();
+    }
+  };
+}
+function slabFinishDeclaredBytes(finish) {
+  const sizes = finish === "satin" ? [SLAB_FINISH_SPEC.satin.roughnessMapSize, SLAB_FINISH_SPEC.satin.normalMapSize] : [SLAB_FINISH_SPEC.common.mapSize, SLAB_FINISH_SPEC.common.mapSize];
+  let bytes = 0;
+  for (const size of sizes) {
+    let perMap = 0;
+    for (let edge = size; edge >= 1; edge = Math.floor(edge / 2)) {
+      perMap += edge * edge * 4;
+      if (edge === 1) break;
+    }
+    bytes += perMap;
+  }
+  return bytes;
+}
+
+// ../execution/animate/src/scene/v2/slabGeometry.ts
+import { BufferAttribute, ExtrudeGeometry as ExtrudeGeometry2 } from "three";
+var SLAB_TESSELLATION_VERSION = 1;
+var SLAB_TESSELLATION = { curveSegments: 24, bevelSegments: 6 };
+var SLAB_BODY_TRIANGLES = SCENE_SLAB_BODY_TRIANGLES;
+var SLAB_CONTENT_FACE_TRIANGLES = SCENE_SLAB_CONTENT_FACE_TRIANGLES;
+var SLAB_TRIANGLES = SLAB_BODY_TRIANGLES + SLAB_CONTENT_FACE_TRIANGLES;
+var SCENE_MAX_TRIANGLES = 25e4;
+var SCENE_MAX_LAYERS = 32;
+var SLAB_DEFAULTS = {
+  thickness: 32,
+  cornerRadius: 32,
+  edgeRadius: 15,
+  finish: "satin",
+  /** The flat dark base the two finishes are painted over; the specular is the whole performance. */
+  baseColor: "#16161c"
+};
+function slabBodyGeometry(width, height, thickness, cornerRadius, edgeRadius) {
+  const e = Math.min(edgeRadius, thickness / 2, cornerRadius, width / 4, height / 4);
+  const depth = thickness - e * 2;
+  const geometry = new ExtrudeGeometry2(roundedRectShape(width - e * 2, height - e * 2, cornerRadius - e), {
+    depth,
+    bevelEnabled: true,
+    bevelThickness: e,
+    bevelSize: e,
+    bevelOffset: 0,
+    bevelSegments: SLAB_TESSELLATION.bevelSegments,
+    curveSegments: SLAB_TESSELLATION.curveSegments
+  });
+  geometry.translate(0, 0, -depth / 2);
+  withNormalisedFaceUv(geometry, width, height);
+  return geometry;
+}
+function slabTriangleCount(geometry) {
+  const index = geometry.getIndex();
+  const count = index ? index.count : geometry.getAttribute("position").count;
+  return count / 3;
+}
+function slabTrianglesFor(slabCount) {
+  return slabCount * SLAB_TRIANGLES;
+}
+function withNormalisedFaceUv(geometry, width, height) {
+  const position = geometry.getAttribute("position");
+  const normal = geometry.getAttribute("normal");
+  geometry.computeBoundingBox();
+  const box = geometry.boundingBox;
+  const depth = box.max.z - box.min.z;
+  const uv1 = new Float32Array(position.count * 2);
+  for (let i = 0; i < position.count; i += 1) {
+    const ax = Math.abs(normal.getX(i));
+    const ay = Math.abs(normal.getY(i));
+    const az = Math.abs(normal.getZ(i));
+    if (az >= ax && az >= ay) {
+      uv1[i * 2] = position.getX(i) / width + 0.5;
+      uv1[i * 2 + 1] = 0.5 - position.getY(i) / height;
+    } else if (ax >= ay) {
+      uv1[i * 2] = (position.getZ(i) - box.min.z) / depth;
+      uv1[i * 2 + 1] = 0.5 - position.getY(i) / height;
+    } else {
+      uv1[i * 2] = position.getX(i) / width + 0.5;
+      uv1[i * 2 + 1] = (position.getZ(i) - box.min.z) / depth;
+    }
+  }
+  geometry.setAttribute("uv1", new BufferAttribute(uv1, 2));
+  return geometry;
+}
+
+// ../execution/animate/src/scene/v2/lighting.ts
+function admitSceneRigKind(value, path = "environment.kind") {
+  if (value === void 0 || value === "studio") return "studio";
+  if (value === PHOTOGRAPHIC_STUDIO_RIG_ID) return value;
+  throw new SceneLightingRefusal(
+    "scene_rig_unsupported",
+    `${JSON.stringify(value)} is not a scene rig. Supported rigs are "studio" and "${PHOTOGRAPHIC_STUDIO_RIG_ID}".`,
+    path,
+    { value, supported: ["studio", PHOTOGRAPHIC_STUDIO_RIG_ID] }
+  );
+}
+function admitSceneRigV2(rig, path = "environment") {
+  if (typeof rig !== "object" || rig === null || Array.isArray(rig)) {
+    throw new SceneLightingRefusal(
+      "scene_rig_unsupported",
+      "The scene environment must be a rig object.",
+      path,
+      { value: rig, supported: ["studio", PHOTOGRAPHIC_STUDIO_RIG_ID] }
+    );
+  }
+  const record = rig;
+  const kind = admitSceneRigKind(record.kind, `${path}.kind`);
+  if (kind === PHOTOGRAPHIC_STUDIO_RIG_ID) {
+    const unsupported = Object.keys(record).filter((key) => key !== "kind").sort();
+    if (unsupported.length > 0) {
+      const field = unsupported[0];
+      throw new SceneLightingRefusal(
+        "scene_photographic_rig_field_unsupported",
+        `"${PHOTOGRAPHIC_STUDIO_RIG_ID}" is fixed and does not accept environment.${field}. Its HDRI, lights, intensity, PMREM and absent floor are versioned production facts.`,
+        `${path}.${field}`,
+        { rigId: PHOTOGRAPHIC_STUDIO_RIG_ID, field, supported: ["kind"], unsupported }
+      );
+    }
+  }
+  return kind;
+}
+var SceneLightingRefusal = class extends Error {
+  code;
+  path;
+  detail;
+  constructor(code, message, path, detail) {
+    super(message);
+    this.name = "SceneLightingRefusal";
+    this.code = code;
+    this.path = path;
+    this.detail = detail;
+  }
+};
+function admitLightingProfile(value, path = "environment.lightingProfile") {
+  if (value === void 0) return DEFAULT_LIGHTING_PROFILE;
+  if (typeof value === "string" && LIGHTING_PROFILES.includes(value)) {
+    return value;
+  }
+  throw new SceneLightingRefusal(
+    "scene_lighting_profile_unsupported",
+    `${JSON.stringify(value)} is not a lighting profile. The shot's rig offers exactly two: ${LIGHTING_PROFILES.map((p) => `"${p}"`).join(" and ")}. Arbitrary light authoring is outside first delivery.`,
+    path,
+    { value, supported: [...LIGHTING_PROFILES] }
+  );
+}
+var SCENE_OBJECT_LIGHT_FIELDS = [
+  "light",
+  "lights",
+  "lighting",
+  "lightingProfile",
+  "intensity",
+  "lightIntensity",
+  "lightPosition",
+  "lightColor",
+  "lightColour",
+  "slabEdgeLighting",
+  "slabEdgeBoost",
+  "slabSideLighting",
+  "slabSideIntensity",
+  "edgeLight",
+  "edgeLighting",
+  "rimLight",
+  "castShadow",
+  "shadowOpacity"
+];
+function assertNoObjectLightField(node, layerPath) {
+  for (const field of SCENE_OBJECT_LIGHT_FIELDS) {
+    if (!Object.prototype.hasOwnProperty.call(node, field)) continue;
+    throw new SceneLightingRefusal(
+      "scene_object_light_field_unsupported",
+      `"${field}" is a light on an object, and no object carries a light. Lighting is a property of the SHOT: set environment.lightingProfile to ${LIGHTING_PROFILES.map((p) => `"${p}"`).join(" or ")}. Adding or removing objects never changes the shot's light count.`,
+      `${layerPath}.${field}`,
+      { field, supported: [...LIGHTING_PROFILES] }
+    );
+  }
+}
+var SCENE_ENVIRONMENT_VERSION = 1;
+function sceneRigIdentityV2(rig, worldScale, shadowBounds) {
+  const kind = admitSceneRigV2(rig);
+  if (kind === PHOTOGRAPHIC_STUDIO_RIG_ID) {
+    return {
+      rigId: PHOTOGRAPHIC_STUDIO_RIG_ID,
+      hdriSha256: PHOTOGRAPHIC_STUDIO_RIG_FACTS.hdri.sha256,
+      pmremVersion: PHOTOGRAPHIC_STUDIO_RIG_FACTS.pmremVersion,
+      lightingVersion: PHOTOGRAPHIC_STUDIO_RIG_FACTS.lightingVersion,
+      worldScale,
+      lightLayout: PHOTOGRAPHIC_STUDIO_RIG_FACTS.studioLights,
+      edgeLightLayout: PHOTOGRAPHIC_STUDIO_RIG_FACTS.edgeLights,
+      environmentIntensity: PHOTOGRAPHIC_STUDIO_RIG_FACTS.environmentIntensity,
+      floor: "none",
+      shadows: "none",
+      retainedGpuBytes: PHOTOGRAPHIC_STUDIO_GPU_BYTES.retained,
+      preparationPeakGpuBytes: PHOTOGRAPHIC_STUDIO_GPU_BYTES.preparationPeak
+    };
+  }
+  const studio = rig;
+  return {
+    lightingProfile: studio.lightingProfile ?? DEFAULT_LIGHTING_PROFILE,
+    preset: studio.preset,
+    intensity: studio.intensity,
+    floorY: studio.floorY,
+    shadowOpacity: studio.shadowOpacity,
+    shadowMapEdge: studioShadowFrustum(worldScale, shadowBounds, studio.floorY).mapSize,
+    environmentVersion: SCENE_ENVIRONMENT_VERSION
+  };
+}
+function lightingProfileDeclaredBytes(_profile) {
+  return 0;
+}
+function sceneLightCount(profile, objectCount) {
+  void objectCount;
+  return 3 + studioEdgeLightCount(profile);
+}
+
+// ../execution/animate/src/scene/v2/preparationFacts.ts
+import { PlaneGeometry } from "three";
+import { RoundedBoxGeometry as RoundedBoxGeometry2 } from "three/examples/jsm/geometries/RoundedBoxGeometry.js";
+function sceneSlabPreparationFactsV1(slab) {
+  const geometry = slabBodyGeometry(
+    slab.width,
+    slab.height,
+    slab.thickness,
+    slab.cornerRadius,
+    slab.edgeRadius
+  );
+  try {
+    const geometryBytes2 = Object.values(geometry.attributes).reduce((sum, attribute) => sum + attribute.array.byteLength, 0) + (geometry.index?.array.byteLength ?? 0);
+    let frontBytes = 0;
+    if (slab.surfaces?.front) {
+      const front = new PlaneGeometry(slab.width, slab.height);
+      try {
+        frontBytes = Object.values(front.attributes).reduce((sum, attribute) => sum + attribute.array.byteLength, 0) + (front.index?.array.byteLength ?? 0);
+      } finally {
+        front.dispose();
+      }
+    }
+    const mapSize = slab.finish === "satin" ? SLAB_FINISH_SPEC.satin.roughnessMapSize : SLAB_FINISH_SPEC.common.mapSize;
+    const finishCpuBytes = 2 * mapSize * mapSize * 4;
+    return {
+      bodyTriangles: slabTriangleCount(geometry),
+      allocations: [
+        {
+          owner: `slab:${slab.id}`,
+          name: "body-geometry",
+          domain: "gl",
+          resource: "geometry",
+          format: "three-buffer-attributes-and-index",
+          bytes: geometryBytes2,
+          lifetime: "context"
+        },
+        {
+          owner: `slab:${slab.id}`,
+          name: "body-geometry-arrays",
+          domain: "cpu",
+          resource: "geometry",
+          format: "three-typed-arrays",
+          bytes: geometryBytes2,
+          lifetime: "context"
+        },
+        ...frontBytes > 0 ? [
+          {
+            owner: `slab:${slab.id}`,
+            name: "front-geometry",
+            domain: "gl",
+            resource: "geometry",
+            format: "three-buffer-attributes-and-index",
+            bytes: frontBytes,
+            lifetime: "context"
+          },
+          {
+            owner: `slab:${slab.id}`,
+            name: "front-geometry-arrays",
+            domain: "cpu",
+            resource: "geometry",
+            format: "three-typed-arrays",
+            bytes: frontBytes,
+            lifetime: "context"
+          }
+        ] : [],
+        {
+          owner: `slab:${slab.id}`,
+          name: `${slab.finish}-finish-source-arrays`,
+          domain: "cpu",
+          resource: "decoded-image",
+          format: "rgba8",
+          bytes: finishCpuBytes,
+          lifetime: "context"
+        },
+        {
+          owner: `slab:${slab.id}`,
+          name: `${slab.finish}-finish-mip-chain`,
+          domain: "gl",
+          resource: "texture",
+          format: "rgba8-mip-chain",
+          bytes: slabFinishDeclaredBytes(slab.finish),
+          lifetime: "context"
+        }
+      ]
+    };
+  } finally {
+    geometry.dispose();
+  }
+}
+function sceneGrainPreparationAllocationV1() {
+  return sceneFocusPreparationAllocationsV1(1, 1, 4)[3];
+}
+function sceneGrainPreparationCpuAllocationV1() {
+  return sceneFocusPreparationAllocationsV1(1, 1, 4)[4];
+}
+function generatedStudioPreparationFactsV1(rig, worldScale, bounds, width, height) {
+  const edge = studioShadowFrustum(worldScale, bounds, rig.floorY * worldScale).mapSize;
+  return { identity: sceneRigIdentityV2(rig, worldScale, bounds), allocations: sceneW5GeneratedRigAllocationsV1(edge, width, height) };
+}
+function assertCanonicalAllocations(actual, expected, kind) {
+  if (JSON.stringify(actual) !== JSON.stringify(expected)) throw new Error(`scene_builder_allocation_measurement_mismatch: ${kind}`);
+}
+function geometryFacts(owner, name, geometry) {
+  const bytes = Object.values(geometry.attributes).reduce((sum, attribute) => sum + attribute.array.byteLength, 0) + (geometry.index?.array.byteLength ?? 0);
+  const triangles = geometry.index ? geometry.index.count / 3 : geometry.attributes.position.count / 3;
+  return { triangles, allocations: [
+    { owner, name, domain: "gl", resource: "geometry", format: "three-buffer-attributes-and-index", bytes, lifetime: "context" },
+    { owner, name: `${name}-arrays`, domain: "cpu", resource: "geometry", format: "three-typed-arrays", bytes, lifetime: "context" }
+  ] };
+}
+function planeFacts(owner, name) {
+  const geometry = new PlaneGeometry(1, 1);
+  try {
+    return geometryFacts(owner, name, geometry);
+  } finally {
+    geometry.dispose();
+  }
+}
+function scenePresetBuilderDescriptorV1(object, context) {
+  if (object.kind === "text") {
+    if (!context) throw new Error(`scene_builder_descriptor_context_missing: ${object.id}`);
+    const width = object.maxWidth ?? context.referenceSize.width;
+    const height = object.lines.length * object.fontSize * object.lineHeight;
+    const scale = context.output.width / context.referenceSize.width;
+    const rasterWidth = Math.max(1, Math.ceil(width * scale));
+    const rasterHeight = Math.max(1, Math.ceil(height * scale));
+    const cpu = rasterWidth * rasterHeight * 4;
+    let gl = 0;
+    for (let w = rasterWidth, h = rasterHeight; ; w = Math.max(1, Math.floor(w / 2)), h = Math.max(1, Math.floor(h / 2))) {
+      gl += w * h * 4;
+      if (w === 1 && h === 1) break;
+    }
+    const plane = planeFacts(`text:${object.id}`, "plane-geometry");
+    const allocations = [...plane.allocations, { owner: `text:${object.id}`, name: "raster-canvas", domain: "cpu", resource: "decoded-image", format: "rgba8", bytes: cpu, lifetime: "context" }, { owner: `text:${object.id}`, name: "raster-mip-chain", domain: "gl", resource: "texture", format: "rgba8-mip-chain", bytes: gl, lifetime: "context" }];
+    assertCanonicalAllocations(allocations, sceneW5WorldTextAllocationsV1(object, context.referenceSize.width, context.output.width), "text");
+    return { kind: "text", builderVersion: 1, tessellationVersion: 1, budgetTriangles: 2, parts: [{ partId: "quad", materialRole: "glyphs", triangles: 2, mounted: true }], surfaceSlots: [], materialRoles: ["glyphs"], localBounds: { center: [0, 0, 0], halfExtents: [width / 2, height / 2, 0] }, allocations };
+  }
+  if (object.kind === "slab") {
+    const facts = sceneSlabPreparationFactsV1(object);
+    const z = object.thickness / 2 + 0.6;
+    return {
+      kind: "slab",
+      builderVersion: 1,
+      tessellationVersion: 1,
+      budgetTriangles: SCENE_PRESET_TRIANGLES.slab,
+      parts: [{ partId: "body", materialRole: "body", triangles: facts.bodyTriangles, mounted: true }, { partId: "front", materialRole: "face", triangles: 2, mounted: !!object.surfaces?.front }],
+      surfaceSlots: [{ slot: "front", attachment: { partId: "front", materialRole: "face" }, dimensions: { width: object.width, height: object.height }, projectionQuad: [[-object.width / 2, object.height / 2, z], [object.width / 2, object.height / 2, z], [object.width / 2, -object.height / 2, z], [-object.width / 2, -object.height / 2, z]], uvOrigin: "top-left", fit: "contain", alpha: "straight", depth: "test-only", required: false, bakeScales: [2, 3] }],
+      materialRoles: ["body", "face"],
+      localBounds: { center: [0, 0, 0], halfExtents: [object.width / 2, object.height / 2, object.thickness / 2] },
+      allocations: facts.allocations
+    };
+  }
+  if (object.kind === "page") {
+    const face = planeFacts(`page:${object.id}`, "content-geometry");
+    return {
+      kind: "page",
+      builderVersion: 1,
+      tessellationVersion: 1,
+      budgetTriangles: SCENE_PRESET_TRIANGLES.page,
+      parts: [{ partId: "base", materialRole: "base", triangles: face.triangles, mounted: true }],
+      surfaceSlots: [{ slot: "content", attachment: { partId: "base", materialRole: "base" }, dimensions: { width: object.width, height: object.height }, projectionQuad: [[-object.width / 2, object.height / 2, 0], [object.width / 2, object.height / 2, 0], [object.width / 2, -object.height / 2, 0], [-object.width / 2, -object.height / 2, 0]], uvOrigin: "top-left", fit: object.fit, alpha: object.transparency, depth: object.depthWrite ? "write" : "test-only", required: true, bakeScales: [2, 3] }],
+      materialRoles: ["base"],
+      localBounds: { center: [0, 0, 0], halfExtents: [object.width / 2, object.height / 2, 0] },
+      allocations: face.allocations
+    };
+  }
+  const kind = object.kind;
+  const dim = deviceDimensions(kind, object.width);
+  const owner = `${kind}:${object.id}`;
+  const shellGeometry = kind === "phone" ? phoneShellGeometry(dim.w, dim.h, dim.t, dim.radius) : new RoundedBoxGeometry2(dim.w, dim.h, dim.t, 4, dim.radius);
+  const baseGeometry = new RoundedBoxGeometry2(dim.w, dim.t, dim.d, 4, dim.radius);
+  try {
+    const shell = geometryFacts(owner, "shell-geometry", shellGeometry);
+    const base = kind === "laptop" ? geometryFacts(owner, "base-geometry", baseGeometry) : null;
+    const planes = (kind === "phone" ? ["screen", "glass"] : ["keyboard", "trackpad", "bezel", "screen", "glass"]).flatMap((name) => planeFacts(owner, `${name}-geometry`).allocations);
+    if (kind === "phone") {
+      const allocations2 = [...shell.allocations, ...planes];
+      assertCanonicalAllocations(allocations2, sceneW5PresetAllocationsV1(object), "phone");
+      return { kind, builderVersion: 1, tessellationVersion: 1, budgetTriangles: SCENE_PRESET_TRIANGLES.phone, parts: [{ partId: "shell", materialRole: "shell", triangles: shell.triangles, mounted: true }, { partId: "screen", materialRole: "screen", triangles: 2, mounted: true }, { partId: "glass", materialRole: "glass", triangles: 2, mounted: true }], surfaceSlots: [{ slot: "screen", attachment: { partId: "screen", materialRole: "screen" }, dimensions: { width: dim.w - 2 * dim.screenInset, height: dim.h - 2 * dim.screenInset }, projectionQuad: [[-(dim.w - 2 * dim.screenInset) / 2, (dim.h - 2 * dim.screenInset) / 2, dim.t / 2 + DEVICE_PLANE_OFFSETS.screen], [(dim.w - 2 * dim.screenInset) / 2, (dim.h - 2 * dim.screenInset) / 2, dim.t / 2 + DEVICE_PLANE_OFFSETS.screen], [(dim.w - 2 * dim.screenInset) / 2, -(dim.h - 2 * dim.screenInset) / 2, dim.t / 2 + DEVICE_PLANE_OFFSETS.screen], [-(dim.w - 2 * dim.screenInset) / 2, -(dim.h - 2 * dim.screenInset) / 2, dim.t / 2 + DEVICE_PLANE_OFFSETS.screen]], uvOrigin: "top-left", fit: "contain", alpha: "straight", depth: "test-only", required: false, bakeScales: [2, 3] }], materialRoles: ["shell", "screen", "glass"], localBounds: { center: [0, 0, 0], halfExtents: [dim.w / 2, dim.h / 2, dim.t / 2 + DEVICE_PLANE_OFFSETS.glass] }, allocations: allocations2 };
+    }
+    const quad = sceneLaptopScreenQuadV1(object);
+    const layout = laptopLayout(dim);
+    const ys = [layout.bottomY, ...quad.map((p) => p[1])], zs = [-dim.d / 2, dim.d / 2, ...quad.map((p) => p[2])];
+    const allocations = [...shell.allocations, ...base.allocations, ...planes];
+    assertCanonicalAllocations(allocations, sceneW5PresetAllocationsV1(object), "laptop");
+    return { kind, builderVersion: 1, tessellationVersion: 1, budgetTriangles: SCENE_PRESET_TRIANGLES.laptop, parts: [{ partId: "base", materialRole: "shell", triangles: base.triangles, mounted: true }, { partId: "lid", materialRole: "shell", triangles: shell.triangles, mounted: true }, { partId: "keyboard", materialRole: "keyboard", triangles: 2, mounted: true }, { partId: "trackpad", materialRole: "trackpad", triangles: 2, mounted: true }, { partId: "bezel", materialRole: "bezel", triangles: 2, mounted: true }, { partId: "screen", materialRole: "screen", triangles: 2, mounted: true }, { partId: "glass", materialRole: "glass", triangles: 2, mounted: true }], surfaceSlots: [{ slot: "screen", attachment: { partId: "screen", materialRole: "screen" }, dimensions: { width: dim.w * 0.86, height: dim.h * 0.86 }, projectionQuad: quad, uvOrigin: "top-left", fit: "contain", alpha: "straight", depth: "test-only", required: false, bakeScales: [2, 3] }], materialRoles: ["shell", "keyboard", "trackpad", "bezel", "screen", "glass"], localBounds: { center: [0, (Math.max(...ys) + Math.min(...ys)) / 2, (Math.max(...zs) + Math.min(...zs)) / 2], halfExtents: [dim.w / 2, (Math.max(...ys) - Math.min(...ys)) / 2, (Math.max(...zs) - Math.min(...zs)) / 2] }, allocations };
+  } finally {
+    shellGeometry.dispose();
+    baseGeometry.dispose();
+  }
+}
+
+export {
+  SELF_TONE_MAPPED,
+  UNLIT_COLOUR_MANAGED,
+  useSceneActualResourceRegistrarV1,
+  SceneRuntimeAllocationBoundaryV1,
+  sceneRuntimeAllocationSnapshotV1,
+  resetSceneRuntimeAllocationCountersV1,
+  registerActualSceneResourcesV1,
+  acquireSceneRuntimeAllocationV1,
+  DEFAULT_LIGHTING_PROFILE,
+  LIGHTING_PROFILES,
+  STUDIO_EDGE_LIGHTS,
+  STUDIO_EDGE_INTENSITY,
+  studioEdgeLightCount,
+  studioShadowFrustum,
+  StudioRig,
+  MeasuredPlaneGeometry,
+  deviceDimensions,
+  laptopLayout,
+  DEVICE_GLASS_OPACITY_ENCODED,
+  DEVICE_GLASS_OPACITY_LINEAR,
+  DEVICE_LIT_MATERIALS,
+  takeSceneEnvironment,
+  lidRotationX,
+  DEVICE_PLANE_OFFSETS,
+  DeviceMesh,
+  PhotographicStudioEnvironmentError,
+  verifyPhotographicStudioHdr,
+  PhotographicStudioRig,
+  SLAB_FINISHES,
+  satinRoughnessMap,
+  satinRoughnessScalar,
+  anodisedGrainNormal,
+  brushedNormal,
+  SLAB_FINISH_SPEC,
+  slabFinishMaterial,
+  slabFinishDeclaredBytes,
+  SLAB_TESSELLATION_VERSION,
+  SLAB_TESSELLATION,
+  SLAB_TRIANGLES,
+  SCENE_MAX_TRIANGLES,
+  SCENE_MAX_LAYERS,
+  SLAB_DEFAULTS,
+  slabBodyGeometry,
+  slabTriangleCount,
+  slabTrianglesFor,
+  withNormalisedFaceUv,
+  admitSceneRigKind,
+  admitSceneRigV2,
+  SceneLightingRefusal,
+  admitLightingProfile,
+  SCENE_OBJECT_LIGHT_FIELDS,
+  assertNoObjectLightField,
+  SCENE_ENVIRONMENT_VERSION,
+  sceneRigIdentityV2,
+  lightingProfileDeclaredBytes,
+  sceneLightCount,
+  sceneSlabPreparationFactsV1,
+  sceneGrainPreparationAllocationV1,
+  sceneGrainPreparationCpuAllocationV1,
+  generatedStudioPreparationFactsV1,
+  scenePresetBuilderDescriptorV1
+};