@volter/blender-engine 0.1.130 → 0.1.132

package/browser/blender-engine.mts

@@ -129,6 +129,7 @@ export interface BlenderEngineOptions {
  * answered as a whole frame is.
  */
 export interface SessionAsk {
+  evaluation?: 'render';
   checkpoint?: string;
   frame?: unknown;
   hold?: unknown;

package/browser/protocol.ts

@@ -105,6 +105,11 @@ export type WorkerRequest =
 export type WorkerReply =
   | { op: 'frame-stream'; id: number; chunk: FrameChunk }
   | { op: 'document-dirty'; dirty: boolean }
+  /** THE DOCUMENT FOLLOWED BLENDER: a script's `save_as_mainfile` (or `open_mainfile`) left
+   *  another project `.blend` open, and the session's saves now go there
+   *  (`session.py::follow_open_file`). Both paths are project-relative. Posted before the
+   *  call's own answer, so the tab's handle already names the new file when the call returns. */
+  | { op: 'document-moved'; from: string; document: string }
   | { op: 'history'; entries: NativeHistoryEntry[] }
   | { id: number; result: unknown }
   | { id: number; error: string }
@@ -174,6 +179,9 @@ export interface FileListSnapshot {
 }
 
 export interface CaptureRequest {
+  /** Geometry was exported from the render engine's RENDER depsgraph. It belongs
+   * to this capture alone and must never replace the live viewport frame. */
+  evaluation?: 'render';
   /** A viewport screenshot's bound, the longer side of a square frame.
    *  Absent on a render, which states its exact pixel dimensions instead. */
   size?: number;

package/browser/runtime.ts

@@ -33,7 +33,7 @@ type Request = DistributiveOmit<WorkerRequest, 'id'>;
 
 export interface BlenderRuntimeOptions {
   /** Stage one verified mesh/image without replacing the displayed frame. */
-  stage?(part: { session: string; revision: number; abort?: boolean; mesh?: string; image?: string; piece?: unknown }): Promise<void> | void;
+  stage?(part: { session: string; revision: number; evaluation?: 'render'; abort?: boolean; mesh?: string; image?: string; piece?: unknown }): Promise<void> | void;
   /** Operation-only diagnostics, never request payloads. The optional observer
    * must not affect work, even if it throws. End calls balance overlapping work. */
   work?(label: string): () => void;
@@ -52,6 +52,11 @@ export interface BlenderRuntimeOptions {
     capture?: CaptureRequest,
   ): Promise<PresentAnswer> | PresentAnswer;
   log?(level: 'log' | 'warn' | 'error', text: string): void;
+  /** The session's document followed Blender to another project `.blend` (a script's Save As,
+   *  `protocol.ts`'s `document-moved`). Called after {@link BlenderRuntime.document} already
+   *  names the new file and before the call that moved it answers. An observer: a throw here
+   *  changes nothing. */
+  documentMoved?(moved: { readonly from: string; readonly document: string }): void;
 }
 
 /**
@@ -237,7 +242,9 @@ export class BlenderRuntime {
     return this.#project;
   }
 
-  /** The startup document owned by this worker, including while boot is pending. */
+  /** The document owned by this worker, including while boot is pending: the startup one, until
+   *  a script's Save As leaves Blender holding another project `.blend` and the session follows
+   *  it there (`session.py::follow_open_file`). */
   get document(): string | null {
     return this.#document;
   }
@@ -638,7 +645,7 @@ export class BlenderRuntime {
   }
 
   readonly #frameStream = new FrameStreamReader();
-  #stagedIdentity: { session: string; revision: number } | null = null;
+  #stagedIdentity: { session: string; revision: number; evaluation?: 'render' } | null = null;
   #discardStagedFrame(): void {
     this.#frameStream.reset();
     const part = this.#stagedIdentity; this.#stagedIdentity = null;
@@ -654,13 +661,13 @@ export class BlenderRuntime {
         try {
           const decoded = await this.#frameStream.accept(reply.chunk);
           if (decoded) {
-            const value = decoded.value as ({ op: 'stage'; session: string; revision: number } | Omit<Extract<WorkerReply, { op: 'present' }>, 'id'>);
+            const value = decoded.value as ({ op: 'stage'; session: string; revision: number; evaluation?: 'render' } | Omit<Extract<WorkerReply, { op: 'present' }>, 'id'>);
             if (value.op === 'present') {
               await this.#receive({ ...value, id: reply.id } as WorkerReply);
               return;
             }
             if (value.op !== 'stage' || !this.#options.stage) throw new Error('The presenter does not support staged Blender frames');
-            this.#stagedIdentity = { session: value.session, revision: value.revision };
+            this.#stagedIdentity = { session: value.session, revision: value.revision, ...(value.evaluation ? { evaluation: value.evaluation } : {}) };
             await this.#options.stage(value);
           }
           this.#worker.postMessage({ op: 'present-result', id: reply.id } satisfies WorkerRequest);
@@ -674,6 +681,14 @@ export class BlenderRuntime {
         this.#dirty = reply.dirty;
         return;
       }
+      if (reply.op === 'document-moved') {
+        // The worker already saves to the new file; this handle must claim it too, or the
+        // editor refuses the new file's own Model tab as a resource conflict.
+        this.#document = reply.document;
+        try { this.#options.documentMoved?.({ from: reply.from, document: reply.document }); }
+        catch { /* an observer cannot undo the move Blender made */ }
+        return;
+      }
       if (reply.op === 'history') {
         this.#options.history?.(reply.entries);
         return;
@@ -693,7 +708,7 @@ export class BlenderRuntime {
       // true the moment the frame arrives. A presenter that refuses the frame
       // has not un-modelled it.
       const frame = reply.frame as { session?: unknown; revision?: unknown } | null;
-      if (typeof frame?.session === 'string' && typeof frame.revision === 'number')
+      if (reply.capture?.evaluation !== 'render' && typeof frame?.session === 'string' && typeof frame.revision === 'number')
         this.#presented = { session: frame.session, revision: frame.revision };
       const end = this.#work('presenting worker frame');
       try {

package/browser/session.py

@@ -1085,7 +1085,10 @@ def material_graph(material):
     if surface is None or surface.bl_idname not in _GRAPH_SURFACES:
         return None
     sockets = [surface.inputs[name] for name in _GRAPH_SURFACES[surface.bl_idname]]
-    if not any(_links_into(s) for s in sockets):
+    # Emission reflects no light even when its inputs are constants. The
+    # reduced MeshPhysicalMaterial otherwise adds diffuse/specular response
+    # to it (including a black Emission used as an unlit control).
+    if surface.bl_idname != "ShaderNodeEmission" and not any(_links_into(s) for s in sockets):
         return None
     # The door is quiet about a material whose graph ships, so a linked input
     # the graph does not carry is named here.
@@ -1464,6 +1467,9 @@ class Session:
         # Set by a present that left the document behind the model; cleared by
         # the save. The tab reads it as `saveDue` beside the frame.
         self.save_due = False
+        # The OUTSIDE-THE-PROJECT file Blender was last found holding, once said
+        # (`follow_open_file`): the refusal is told once per file, not per call.
+        self._outside_file = None
         # WHAT THE PRESENTER LAST REPORTED HOLDING, as an instrument: the
         # `(session, revision)` it held BEFORE the last frame, None when it
         # held nothing, and the string "unreported" for a presenter that does
@@ -1477,7 +1483,7 @@ class Session:
 
     # -- the export
 
-    def _export(self):
+    def _export(self, depsgraph=None):
         """THE EXPORT IS THE C++ DOOR (`bpy_web_export.cc`).
 
         One call evaluates the scene, walks the depsgraph's own update record
@@ -1494,14 +1500,14 @@ class Session:
         bones and the active vertex group's weights (`_armatures`,
         `_weights`). All per-scene, none of them geometry.
         """
-        scene = bpy.context.scene
+        scene = depsgraph.scene if depsgraph is not None else bpy.context.scene
         graphs = material_graphs(scene)
         _mark("export:graphs")
         # An IMAGE EMPTY's picture travels with the graphs' images: the overlay draws it
         # (`overlay_empty.hh` `image_sync`).
         empty_images = {obj.data.name for obj in scene.objects
                         if obj.type == "EMPTY" and obj.empty_display_type == "IMAGE" and obj.data is not None}
-        options = {"session": self.session, "evaluate": True, "known": self._known, "instance_sources": True,
+        options = {"session": self.session, "evaluate": depsgraph is None, "known": self._known, "instance_sources": True,
                    "graph_materials": sorted(graphs),
                    "graph_images": sorted({i for g in graphs.values() for i in g["images"]} | empty_images),
                    "graph_generated": sorted(n for n, g in graphs.items() if g["generated"])}
@@ -1560,7 +1566,7 @@ class Session:
         # A MANUAL TEXTURE SPACE, which Generated coordinates map through; the
         # automatic one is the evaluated bounds the presenter already holds.
         if graphs:
-            depsgraph = bpy.context.evaluated_depsgraph_get()
+            depsgraph = depsgraph if depsgraph is not None else bpy.context.evaluated_depsgraph_get()
             # BY NAME THROUGH ONE MAP: `scene.objects.get` searches the collection linearly, so a
             # lookup per row was quadratic -- measured on the Stoneguard file (11,702 rows): 11,343
             # calls, 14.4 s of every present.
@@ -1595,7 +1601,8 @@ class Session:
                     "roughness": float(material.roughness),
                     "metallic": float(material.metallic),
                 }
-        frame["instances"] = _depsgraph_placements(frame, bpy.context.evaluated_depsgraph_get())
+        graph = depsgraph if depsgraph is not None else bpy.context.evaluated_depsgraph_get()
+        frame["instances"] = _depsgraph_placements(frame, graph)
         frame["world"] = draw_world(scene)
         frame["cameras"] = {
             obj.name: draw_camera(obj) for obj in scene.objects if obj.type == "CAMERA"
@@ -1607,7 +1614,7 @@ class Session:
         render = scene.render
         frame["camera_view"] = {
             "scene_camera": scene.camera.name if scene.camera is not None else None,
-            "view_layer_cameras": [o.name for o in bpy.context.view_layer.objects if o.type == "CAMERA"],
+            "view_layer_cameras": [o.name for o in graph.view_layer.objects if o.type == "CAMERA"],
             "aspect": (render.resolution_x * render.pixel_aspect_x) / max(render.resolution_y * render.pixel_aspect_y, 1e-6),
         }
         # THE 3D CURSOR, `Scene.cursor`: where Blender's own "to 3D Cursor"
@@ -1617,7 +1624,7 @@ class Session:
         frame["cursor"] = [[float(v) for v in row] for row in scene.cursor.matrix]
         # THE OVERLAYS, after the door's frame stands: `_weights` reads the
         # mesh's own revision out of it (see there), so it cannot run before.
-        view_layer = bpy.context.view_layer
+        view_layer = graph.view_layer
         # THE VIEWPORT'S SUBJECT LINE and the units its grid step is named in: Blender composes
         # both from the scene, so they come from here (`_subject_line`).
         frame["subject"] = _subject_line(scene, view_layer)
@@ -1662,12 +1669,12 @@ class Session:
             self._known.clear()
             return self._present(capture)
 
-    def _present(self, capture=None):
+    def _present(self, capture=None, depsgraph=None):
         known = dict(self._known)
         _mark("present:before")
-        frame = self._export()
+        frame = self._export(depsgraph)
         _mark("present:exported")
-        pulled = self._pull(frame)
+        pulled = self._pull(frame, render=depsgraph is not None)
         _mark("present:pulled")
         self._drop_unreachable_textures(frame)
         # WHAT THIS FRAME SHIPPED, for the session's own accounting: the ids
@@ -1726,7 +1733,7 @@ class Session:
         self._reconcile_with_presenter(answer, frame)
         return answer
 
-    def _pull(self, frame):
+    def _pull(self, frame, render=False):
         """THE PULL, one datablock at a time, as Hydra's render delegate pulls each prim's data
         during Sync after the scene index's notice (`HydraSceneIndex::populate`). The door named
         the changed meshes and pictures as deferred; the worker first copies the frame's own
@@ -1740,9 +1747,9 @@ class Session:
         anything was pulled; the worker then presents the frame with its pieces."""
         meshes = [key for key, mesh in frame["meshes"].items() if mesh.get("deferred")]
         images = [name for name, image in frame["images"].items() if image.get("deferred")]
-        if not meshes and not images:
+        if not meshes and not images and not render:
             return False
-        _asked({"hold": frame})
+        _asked({"hold": frame, **({"evaluation": "render"} if render else {})})
         options = {"buffer_path": EXPORT_BUFFER_PATH} if EXPORT_BUFFER_PATH else {}
         for kind, keys, door in (("mesh", meshes, _blender_web.export_mesh),
                                  ("image", images, _blender_web.export_image)):
@@ -1762,6 +1769,20 @@ class Session:
                 _asked({kind: key, "piece": piece[kind]})
         return True
 
+    def photograph(self, depsgraph, capture):
+        """Render evaluation owns different geometry and visibility than a viewport.
+        Keep its native revisions, deferred pulls and presenter separate for the
+        entire blocking capture, and restore the authoring export in finally."""
+        if not hasattr(_blender_web, "begin_render_export"):
+            raise RuntimeError("This Blender artifact has no render-evaluated export; update the artifact and its corresponding source")
+        _blender_web.begin_render_export(depsgraph)
+        try:
+            rendering = Session()
+            rendering.session = "%s:render:%d" % (self.session, time.time_ns())
+            return rendering._present({**capture, "evaluation": "render"}, depsgraph)
+        finally:
+            _blender_web.end_render_export()
+
     def _send_encoded_image(self, key, deferred):
         """A PICTURE AS ITS FILE'S OWN BYTES, when that is exactly what the frame would carry.
 
@@ -1964,10 +1985,11 @@ class Session:
     def bind_document(self, relative_path):
         """Name the session's document and OPEN it when the project has one.
 
-        One session holds one document. The path is stated at start and never
-        moves afterwards: a script's own `save_as_mainfile` to somewhere else
-        is an ordinary thing for a script to do and is left alone -- it retargets
-        Blender's `bpy.data.filepath`, not this.
+        One session holds one document. The path is stated at start and moves
+        only where Blender itself moved: a script's own `save_as_mainfile` (or
+        `open_mainfile`) to another `.blend` in the project retargets
+        `bpy.data.filepath`, and `follow_open_file` moves the document with it
+        after the call.
 
         `open_mainfile` runs the session's `_load_post` like any other load
         (the export door's revision table is reset, the render engine ids are
@@ -2011,6 +2033,58 @@ class Session:
         if self.document is not None:
             self.save_due = True
 
+    def follow_open_file(self):
+        """FOLLOW BLENDER'S SAVE AS: the document is the file Blender has open.
+
+        Read after every `execute`, because a script is the one request that can
+        change which file Blender holds. `save_as_mainfile(filepath=X)` writes X
+        and leaves X OPEN -- `bpy.data.filepath` becomes X, and Blender's next
+        Save goes there. The session used to keep saving to the file it was
+        started on, so the model a script had just saved as X was written over
+        the OLD file on the next idle save, and the editor refused X's own tab
+        because the worker still claimed the old one. SEEN 2026-10-07: an
+        agent built an obby through the Blender MCP, saved it as
+        `src/models/obby.blend`, and its level landed in `src/models/cube.blend`
+        instead -- so Play looked for `cube.play.ts`.
+
+        What does NOT move, by Blender's own rules rather than ours:
+        `save_mainfile()` and a Save As to the same path leave the path where it
+        is, and `save_as_mainfile(copy=True)` writes a copy and keeps the
+        original open (which is also how `save_document` writes, so the
+        session's own save never moves anything). `open_mainfile` does move it:
+        Blender then holds that file, and saving the old path would write one
+        file's model over another's.
+
+        Answers None when nothing moved, `{"moved": True, "from", "document"}`
+        when the document followed Blender to another project `.blend`, and
+        `{"moved": False, "from", "outside"}` -- once per file -- when Blender
+        holds a file outside the project: the editor has no document there, so
+        the session keeps its own and keeps saving to it.
+        """
+        if self.document is None or not bpy.data.filepath:
+            return None
+        current = os.path.normpath(os.path.abspath(bpy.data.filepath))
+        if current == os.path.normpath(self.document):
+            self._outside_file = None
+            return None
+        root = os.path.normpath(self.project)
+        relative = current[len(root) + 1:] if current.startswith(root + "/") else None
+        # The same shape the worker and the server check (`worker.ts::isDocumentPath`).
+        if (relative is not None and relative.endswith(".blend") and "\\" not in relative
+                and all(part not in ("", ".", "..") for part in relative.split("/"))):
+            previous = self.document_relative
+            self.document = current
+            self.document_relative = relative
+            self._outside_file = None
+            # The file Blender wrote sits only in the engine's filesystem until the
+            # session's own save carries it to the project.
+            self.save_due = True
+            return {"moved": True, "from": previous, "document": relative}
+        if current == self._outside_file:
+            return None
+        self._outside_file = current
+        return {"moved": False, "from": self.document_relative, "outside": current}
+
     def save_document(self):
         """Write the document -- Blender's own format, by Blender's own operator.
 
@@ -2280,8 +2354,8 @@ def _photograph(depsgraph, width, height, linear=False):
     # result is what a render leaves, and it holds scene-linear pixels.
     if linear:
         render["linear"] = True
-    answer = SESSION.present(
-        {"position": position, "target": target, "up": up, "render": render}
+    answer = SESSION.photograph(
+        depsgraph, {"position": position, "target": target, "up": up, "render": render}
     )
     if not isinstance(answer, dict) or "base64" not in answer:
         raise RuntimeError("The renderer did not answer with a photograph")
@@ -5329,6 +5403,11 @@ def _dispatch(request):
         HISTORY.changed()
         SESSION.mark_changed()
         answer = execute(request["code"])
+        # Read before the present, so the save that present asks for goes to the
+        # file Blender now holds (`Session.follow_open_file`).
+        followed = SESSION.follow_open_file()
+        if followed is not None:
+            answer["document"] = followed
         # Every mutation is presented, the rule: the Model
         # document is what the agent is looking at.
         try:

package/browser/three/blender-graph-material.ts

@@ -14,6 +14,7 @@
  * built from the mesh's texture space (`orcoAttribute`).
  */
 import * as THREE from 'three';
+import {ISLAND_RANDOM_ATTRIBUTE} from './blender-island-random';
 import {presenterChanged} from './blender-presenter-change';
 import {attributeVarying, type CompiledGraph, rampTexture, uvVarying} from './blender-node-graph';
 import {graphAttributeName} from './blender-runtime-geometry';
@@ -458,7 +459,7 @@ varying vec3 vBlenderObjectNormal;
 varying vec3 vBlenderWorldPosition;
 varying vec3 vBlenderWorldNormal;
 varying vec3 vBlenderOrco;
-${compiled.attributes.map(n => `varying vec4 ${attributeVarying(n)};`).join('\n')}
+${compiled.attributes.map(n => `${n===ISLAND_RANDOM_ATTRIBUTE?'flat ':''}varying vec4 ${attributeVarying(n)};`).join('\n')}
 ${compiled.uvs.map(n => `varying vec2 ${uvVarying(n)};`).join('\n')}`;
   const attributes = compiled.attributes.map(n => `attribute vec4 ${graphAttributeName(n)};`).join('\n');
   shader.vertexShader = `attribute vec3 blenderOrco;\n${attributes}\n${varyings}\n${shader.vertexShader}`.replace(

package/browser/three/blender-island-random.ts

@@ -0,0 +1,41 @@
+/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
+ * SPDX-License-Identifier: Apache-2.0 */
+/** Cycles' attr_create_random_per_island, util/disjoint_set.h and
+ * util/hash.h (Blender Foundation, Apache-2.0). Connectivity uses the
+ * evaluated mesh's STORED edge order and union-by-rank representative,
+ * including loose edges. It is independent of draw/UV/normal splitting. */
+export const ISLAND_RANDOM_ATTRIBUTE='.cycles.random_per_island';
+
+function hashUint(value:number):number {
+  let a=(0xdeadbeef+17+value)>>>0,b=(0xdeadbeef+17)>>>0,c=b;
+  const rotate=(x:number,n:number)=>(x<<n)|(x>>>(32-n));
+  c=((c^b)-rotate(b,14))>>>0;a=((a^c)-rotate(c,11))>>>0;
+  b=((b^a)-rotate(a,25))>>>0;c=((c^b)-rotate(b,16))>>>0;
+  a=((a^c)-rotate(c,4))>>>0;b=((b^a)-rotate(a,14))>>>0;
+  c=((c^b)-rotate(b,24))>>>0;
+  // Native converts uint to float BEFORE the float reciprocal/multiply.
+  return Math.fround(Math.fround(c)*Math.fround(1/Math.fround(0xffffffff)));
+}
+
+export function cyclesIslandRandom(vertexCount:number,edges:Iterable<readonly [number,number]>):Float32Array {
+  const parents=Uint32Array.from({length:vertexCount},(_,i)=>i),ranks=new Uint8Array(vertexCount);
+  const find=(x:number):number=>{
+    let root=x;while(parents[root]!==root)root=parents[root]!;
+    while(parents[x]!==root){const parent=parents[x]!;parents[x]=root;x=parent;}
+    return root;
+  };
+  for(const [x,y] of edges) {
+    if(x<0 || y<0 || x>=vertexCount || y>=vertexCount || !Number.isInteger(x) || !Number.isInteger(y))
+      throw new Error('Island connectivity references a missing Blender vertex');
+    let a=find(x),b=find(y);if(a===b)continue;
+    if(ranks[a]!<ranks[b]!)[a,b]=[b,a];
+    parents[b]=a;if(ranks[a]===ranks[b])ranks[a]=ranks[a]!+1;
+  }
+  const result=new Float32Array(vertexCount);
+  for(let i=0;i<vertexCount;i++)result[i]=hashUint(find(i));
+  return result;
+}
+
+export function* storedMeshEdges(edges:Uint32Array):Iterable<readonly [number,number]> {
+  for(let i=0;i<edges.length;i+=2)yield [edges[i]!,edges[i+1]!];
+}

package/browser/three/blender-node-graph.ts

@@ -25,6 +25,7 @@ import * as THREE from 'three';
 import {z} from 'zod';
 import {BLENDER_NODE_GLSL, BLENDER_NODE_GLSL_PRELUDE} from './blender-node-glsl.generated';
 import {graphAttributeName} from './blender-runtime-geometry';
+import {ISLAND_RANDOM_ATTRIBUTE} from './blender-island-random';
 
 const scalar = z.number().finite();
 const gpuType = z.enum(['float', 'vec2', 'vec3', 'vec4']);
@@ -436,6 +437,13 @@ class Compiler {
     if (!node) throw new Error(`The graph links to ${key}, which it does not carry`);
     if (node.type === 'ShaderNodeParticleInfo' && node.outputs[index]?.id !== 'Random')
       throw new Error(`Particle Info output ${node.outputs[index]?.id ?? index} is not compiled by the presenter`);
+    // EEVEE's node_geometry returns zero here; reference rendering uses
+    // Cycles' evaluated per-island attribute instead. Keep it face constant.
+    if(node.type==='ShaderNodeNewGeometry' && node.outputs[index]?.id==='Random Per Island') {
+      this.s.attributes.add(ISLAND_RANDOM_ATTRIBUTE);
+      this.s.structure.push(['cycles-island',key,index]);
+      return convert(`${attributeVarying(ISLAND_RANDOM_ATTRIBUTE)}.x`,'float',to);
+    }
     const outputs = this.node(key, node);
     const output = outputs[index];
     if (!output) throw new Error(`${key} has no output ${index}`);

package/browser/three/blender-physical-material.ts

@@ -7,6 +7,7 @@ import {z} from 'zod';
 import {applyGraphShader, bindGraphDraw, bindPaletteGraph, borrowGraphDrawBinding, graphProgramKey, graphUvChannels, setGraphViewport} from './blender-graph-material';
 import type {CompiledGraph} from './blender-node-graph';
 import {bindNamedUvChannels} from './blender-texture-samplers';
+import {copyWorldVisibility,worldVisibilityShader,worldVisibilityUniforms} from './blender-world-visibility';
 
 const scalar = z.number().finite();
 const color = z.tuple([scalar, scalar, scalar]);
@@ -55,6 +56,7 @@ function graphShadow(material: THREE.MeshPhysicalMaterial): THREE.MeshPhysicalMa
   // which `copy` replaces with the material's own (it leaves hooks alone).
   applyPhysicalMaterial(shadow);
   shadow.copy(material);
+  copyWorldVisibility(material,shadow);
   const values = uniforms.get(shadow)!;
   if (held) {
     values.blenderCoatIor.value = held.blenderCoatIor.value;
@@ -149,6 +151,7 @@ export function syncPhysicalDrawMaterial(source: THREE.Material, target?: THREE.
     return null;
   }
   copy.copy(source);
+  copyWorldVisibility(source,copy);
   const held = uniforms.get(source)!;
   const values = uniforms.get(copy)!;
   values.blenderCoatIor.value = held.blenderCoatIor.value;
@@ -192,7 +195,7 @@ export function applyPhysicalMaterial(material: THREE.MeshPhysicalMaterial, inpu
       blenderWorldExtinction: {value: new THREE.Vector3()}};
     uniforms.set(material, values);
     const held = values;
-    material.customProgramCacheKey = () => `blender-principled-physical-v5${graphProgramKey(material)}`;
+    material.customProgramCacheKey = () => `blender-principled-physical-v6${graphProgramKey(material)}`;
     material.onBeforeRender = (renderer, scene, camera, geometry, object) => {
       bindNamedUvChannels(material, geometry);
       bindGraphDraw(material, geometry, renderer, scene, camera, object, graphShadow);
@@ -210,6 +213,12 @@ export function applyPhysicalMaterial(material: THREE.MeshPhysicalMaterial, inpu
         .map(i => (i <= 3 ? `#ifndef USE_UV${i}\nattribute vec2 uv${i};\n#endif` : `attribute vec2 uv${i};`))
         .join('\n') + '\n' + shader.vertexShader;
       Object.assign(shader.uniforms, held);
+      worldVisibilityUniforms(material,shader.uniforms);
+      shader.vertexShader='varying vec3 blenderWorldPosition;\n'+shader.vertexShader;
+      shader.vertexShader=shader.vertexShader.replace('#include <worldpos_vertex>',
+        '#include <worldpos_vertex>\n#if defined(USE_ENVMAP) || defined(USE_SHADOWMAP) || defined(USE_TRANSMISSION)\nblenderWorldPosition=worldPosition.xyz;\n#else\nblenderWorldPosition=(modelMatrix*vec4(transformed,1.)).xyz;\n#endif');
+      shader.fragmentShader=shader.fragmentShader.replace('#include <envmap_physical_pars_fragment>',
+        '#include <envmap_physical_pars_fragment>\n'+worldVisibilityShader);
       shader.fragmentShader = `uniform float blenderCoatIor;
         uniform vec3 blenderWorldExtinction;
         vec3 blenderInfiniteTransmission() { return vec3(
@@ -255,6 +264,10 @@ export function applyPhysicalMaterial(material: THREE.MeshPhysicalMaterial, inpu
           'rectAreaLight = rectAreaLights[ i ]; rectAreaLight.color *= exp(-blenderWorldExtinction * length(rectAreaLight.position-geometryPosition));')
         .replace('getAmbientLightIrradiance( ambientLightColor )', 'getAmbientLightIrradiance( ambientLightColor ) * blenderInfiniteTransmission()');
       const environment = THREE.ShaderChunk.lights_fragment_maps
+        .replace('getIBLIrradiance( geometryNormal )',
+          'blenderWorldIrradiance( geometryNormal, getIBLIrradiance( geometryNormal ) )')
+        .replaceAll(/(getIBL(?:Radiance|AnisotropyRadiance)\([^;]+\))/g,
+          '$1 * blenderWorldReflectionVisibility(geometryViewDir,geometryNormal,material.roughness)')
         .replaceAll(/(getIBL(?:Irradiance|Radiance|AnisotropyRadiance)\([^;]+\))/g, '$1 * blenderInfiniteTransmission()');
       shader.fragmentShader = shader.fragmentShader.replace('#include <lights_physical_fragment>', physical)
         .replace('#include <lights_fragment_begin>', lighting)

package/browser/three/blender-runtime-geometry.ts

@@ -19,6 +19,7 @@ import * as THREE from 'three';
 import { customCornerNormals, type Normal } from './blender-corner-normals';
 import { ATTRIBUTE_LAYOUT, type MeshColumns } from './blender-frame-columns';
 import { triangulatePolygon } from './blender-triangulate';
+import {cyclesIslandRandom,ISLAND_RANDOM_ATTRIBUTE,storedMeshEdges} from './blender-island-random';
 
 type MeshData = {
   v: [number, number, number][];
@@ -43,7 +44,8 @@ export interface DrawArrays {
   uvLayers?: {name: string; data: Float32Array}[] | undefined;
   /** The mesh's generic attribute layers a material's Attribute or Color
    *  Attribute node can read, four floats per drawn vertex as EEVEE loads them
-   *  (`graphAttributeLayers`). */
+   *  (`graphAttributeLayers`). The derived Cycles island layer stores one
+   *  scalar per drawn vertex rather than an authored float4. */
   attributeLayers?: {name: string; data: Float32Array}[] | undefined;
   /** Per drawn vertex, a deformed mesh's Generated coordinates (0..1), or
    *  null when the positions are undeformed and orco derives from them. */
@@ -294,7 +296,11 @@ export function geometryFromDrawArrays(
   }
   geometry.userData['blenderUvChannels'] = channels;
   for (const layer of arrays.attributeLayers ?? [])
-    geometry.setAttribute(graphAttributeName(layer.name), new THREE.BufferAttribute(layer.data, 4));
+    // Engine-derived island values use one float, while ordinary Blender
+    // material attributes retain EEVEE's float4 storage. Snapshots preserve
+    // the same name/stride, without inventing an authored mesh attribute.
+    geometry.setAttribute(graphAttributeName(layer.name), new THREE.BufferAttribute(layer.data,
+      layer.name===ISLAND_RANDOM_ATTRIBUTE?1:4));
   geometry.userData['blenderAttributes'] = (arrays.attributeLayers ?? []).map(layer => layer.name);
   if (arrays.orco) {
     geometry.setAttribute('blenderOrco', new THREE.BufferAttribute(arrays.orco, 3));
@@ -419,7 +425,7 @@ function drawNativeColumns(c: MeshColumns, hash: string): DrawArrays {
 
 /** The worker's door: the mesh store's columns, drawn into buffers. */
 export function drawArraysFromColumns(c: MeshColumns, hash: string): DrawArrays {
-  if (c.cornerTri && c.cornerNormal) return drawNativeColumns(c, hash);
+  if (c.cornerTri && c.cornerNormal) return withIslandRandom(drawNativeColumns(c, hash),c.co.length/3,storedMeshEdges(c.edge));
   const nv = c.co.length / 3;
   const maps = c.attributes.filter((a) => a.type === 'FLOAT2' && a.domain === 'CORNER');
   const mapName = c.renderUv ?? c.activeUv ?? maps[0]?.name;
@@ -482,7 +488,15 @@ export function drawArraysFromColumns(c: MeshColumns, hash: string): DrawArrays
     attributeLayers: graphAttributeLayers(c.attributes, data => data as ArrayLike<number>),
   };
   if (map && ATTRIBUTE_LAYOUT.FLOAT2.size !== 2) throw new Error('FLOAT2 layout');
-  return { ...drawCore(view), hash };
+  return {...withIslandRandom(drawCore(view),nv,edges),hash};
+}
+
+function withIslandRandom<T extends Omit<DrawArrays,'hash'>>(arrays:T,vertexCount:number,
+  edges:Iterable<readonly [number,number]>):T {
+  const native=cyclesIslandRandom(vertexCount,edges);
+  const data=Float32Array.from(arrays.sourceVertex,vertex=>native[vertex]!);
+  arrays.attributeLayers=[...(arrays.attributeLayers??[]),{name:ISLAND_RANDOM_ATTRIBUTE,data}];
+  return arrays;
 }
 
 /** The boundary JSON door. */
@@ -546,5 +560,8 @@ export function drawRuntimeGeometry(data: MeshData): THREE.BufferGeometry {
     attributeLayers: graphAttributeLayers(data.attributes ?? [],
       values => (Array.from(values) as (number | number[])[]).flat()),
   };
-  return geometryFromDrawArrays(drawCore(view));
+  // Native frames always supply stored edges. Legacy JSON without that
+  // order retains its old unsupported zero input rather than guessing IDs.
+  const arrays=drawCore(view);
+  return geometryFromDrawArrays(view.edges?withIslandRandom(arrays,vertices.length,view.edges):arrays);
 }

package/browser/three/blender-runtime-lighting.ts

@@ -724,6 +724,7 @@ export type WorldData = z.infer<typeof worldSchema>;
  * Constants and linked colors use the same radiometric path. The environment
  * samples the field at 256×128; features below a texel are filtered. */
 export class WorldBackground {
+  lightingTexture():THREE.Texture|null {return this.environmentTexture??this.texture;}
   readonly solarLights: THREE.DirectionalLight[] = [];
   private readonly solarDirections = new Map<THREE.DirectionalLight, THREE.Vector3>();
 

package/browser/three/blender-runtime-shadows.ts

@@ -58,6 +58,11 @@ export function fitModelDirectionalShadow(
   casters: THREE.Box3[],
 ): void {
   if (!light.castShadow || !receivers.length) return;
+  // A detached photograph fits before its first render. Newly composed suns
+  // and their targets have not yet passed through Scene.updateMatrixWorld;
+  // fitting in those stale axes produces a different map on the first draw.
+  light.updateWorldMatrix(true, false);
+  light.target.updateWorldMatrix(true, false);
   light.shadow.updateMatrices(light);
   const camera = light.shadow.camera;
   const view = camera.matrixWorldInverse;

package/browser/three/blender-runtime-view.ts

@@ -26,6 +26,7 @@ import {
   worldSchema,
 } from './blender-runtime-lighting';
 import { fitModelDirectionalShadow, visibleShadowReceivers } from './blender-runtime-shadows';
+import {BlenderWorldVisibility,bindWorldVisibility} from './blender-world-visibility';
 import { volumeMesh, volumeSchema } from './blender-runtime-volume';
 import { applyPhysicalMaterial, applyWorldExtinction, physicalMaterialSchema } from './blender-physical-material';
 import { prepareGraphGeometry, setMaterialGraph } from './blender-graph-material';
@@ -681,6 +682,7 @@ export class BlenderRuntimeView {
   private readonly lights = new Map<string, THREE.Light>();
   private readonly lighting = new ViewportLighting();
   private readonly world = new WorldBackground();
+  private readonly worldVisibility=new BlenderWorldVisibility();
   /**
    * THE INSPECTION OVERLAYS (I4). They are NOT children of {@link root}, and
    * that is the whole design: an overlay is EDITOR FURNITURE, so its
@@ -1333,6 +1335,13 @@ export class BlenderRuntimeView {
       // objects. Fit shadows for that draw, rather than the camera's pose
       // when Rendered shading was first entered. Captures use this path too.
       if (this.rendered) this.applyShadows(true, camera);
+      this.worldVisibility.sync(this.objects.values(),this.world.lightingTexture(),this.root,this.rendered);
+      for(const material of [...this.materials.values(),this.fallback])bindWorldVisibility(material,this.worldVisibility);
+      for(const object of this.objects.values()) {
+        const mesh=object as THREE.Mesh;if(!mesh.isMesh)continue;
+        for(const material of Array.isArray(mesh.material)?mesh.material:[mesh.material])bindWorldVisibility(material,this.worldVisibility);
+      }
+      if(options?.renderer)this.worldVisibility.prepare(options.renderer);
       const opaqueDone = performance.now();
       const motion = this.motionGeometry.prepare(camera, !this.rendered && (this.mode ?? this.frame?.mode) === 'OBJECT' &&
         options?.interactive === true, options?.height ?? 0);
@@ -2222,7 +2231,7 @@ export class BlenderRuntimeView {
   }
 
   drawStatistics() {
-    return {enabled: this.drawBatching, preparation: {...this.drawPreparation}, materialRanges: this.materialRanges.inspect(), opaque: this.instances.inspect(), transparent: this.transparentInstances.inspect(), motion: this.motionGeometry.inspect()};
+    return {enabled: this.drawBatching, preparation: {...this.drawPreparation}, worldVisibility:this.worldVisibility.diagnostics(), materialRanges: this.materialRanges.inspect(), opaque: this.instances.inspect(), transparent: this.transparentInstances.inspect(), motion: this.motionGeometry.inspect()};
   }
 
   snapshot() {
@@ -2404,10 +2413,48 @@ export class BlenderRuntimeView {
         if (disposed) throw new Error('Blender capture snapshot is disposed');
         return detached.setRendered(true, camera);
       },
+      prepareDraw:(renderer:THREE.WebGLRenderer,camera:THREE.Camera)=>{
+        if(disposed)throw new Error('Blender capture snapshot is disposed');
+        return detached.prepareDraw(camera,{interactive:false,height:renderer.domElement.height,renderer});
+      },
       dispose,
     };
   }
 
+  /** Build a render-evaluated frame without ever publishing it to a viewport. */
+  static forPhotograph(): BlenderRuntimeView {
+    const view = new BlenderRuntimeView();
+    view.photograph = true;
+    return view;
+  }
+
+  /** Transfer this render-only view to its capture owner. Its resources are
+   * already independent, so a second geometry/texture copy is unnecessary. */
+  takeCaptureSnapshot(): ReturnType<BlenderRuntimeView['captureSnapshot']> {
+    if (!this.photograph || !this.frame) throw new Error('A render-evaluated frame is required');
+    const source = this.frame;
+    const effect = this.createWorldVolumePass();
+    let disposed = false;
+    return {
+      effect, root: this.root, session: source.session, revision: source.revision,
+      prepare: camera => {
+        if (disposed) throw new Error('Blender capture snapshot is disposed');
+        return this.setRendered(true, camera);
+      },
+      prepareDraw: (renderer, camera) => {
+        if (disposed) throw new Error('Blender capture snapshot is disposed');
+        return this.prepareDraw(camera, { interactive: false, height: renderer.domElement.height, renderer });
+      },
+      dispose: () => {
+        if (disposed) return;
+        disposed = true;
+        effect?.dispose();
+        this.dispose();
+        this.root.removeFromParent();
+      },
+    };
+  }
+
   createWorldVolumePass(): WorldVolumePass | undefined {
     const medium = worldMedium(this.frame?.world);
     return medium ? new WorldVolumePass(medium) : undefined;
@@ -2452,6 +2499,7 @@ export class BlenderRuntimeView {
   }
 
   private clear() {
+    this.worldVisibility.dispose();
     this.objectInfoMaterials.clear();
     this.materialRanges.clear();
     this.motionGeometry.clear();

package/browser/three/blender-world-visibility.ts

@@ -0,0 +1,264 @@
+/** Directional world-light visibility. One shared depth atlas replaces repeated
+ * per-pixel triangle traversal. Geometry/placements are derived draw resources;
+ * Blender data and the visible canvas are never changed. This is finite
+ * directional quadrature, not indirect light transport. */
+import * as THREE from 'three';
+
+const SAMPLE_COUNT=16, TILES=4, TILE_SIZE=512;
+type Segment={mesh:THREE.Mesh; geometry:THREE.BufferGeometry; position:THREE.BufferAttribute|THREE.InterleavedBufferAttribute;
+ index:THREE.BufferAttribute|null; positionVersion:number; indexVersion:number; start:number; count:number;
+ offset:number; matrix:THREE.Matrix4; shown:boolean; bounds:THREE.Box3; dynamic:boolean};
+const version=(attribute:THREE.BufferAttribute|THREE.InterleavedBufferAttribute)=>
+ 'isInterleavedBufferAttribute' in attribute ? attribute.data.version : attribute.version;
+function shown(mesh:THREE.Mesh):boolean {
+ if(!mesh.castShadow || !mesh.layers.isEnabled(0))return false;
+ for(let parent:THREE.Object3D|null=mesh;parent;parent=parent.parent)if(!parent.visible)return false;
+ return true;
+}
+
+export class BlenderWorldVisibility {
+ readonly uniforms={
+  blenderWorldVisibilityEnabled:{value:false},
+  blenderWorldDepth:{value:null as THREE.Texture|null},
+  blenderWorldDynamicDepth:{value:null as THREE.Texture|null},
+  blenderWorldHasDynamicDepth:{value:false},
+  blenderWorldRadiance:{value:null as THREE.Texture|null},
+  blenderWorldDirections:{value:Array.from({length:SAMPLE_COUNT},(_,i)=>{
+   const z=1-2*(i+.5)/SAMPLE_COUNT,angle=i*2.399963229728653;
+   return new THREE.Vector3(Math.sqrt(1-z*z)*Math.cos(angle),z,Math.sqrt(1-z*z)*Math.sin(angle));
+  })},
+  blenderWorldMatrices:{value:Array.from({length:SAMPLE_COUNT},()=>new THREE.Matrix4())},
+  blenderWorldToNative:{value:new THREE.Matrix3()},
+  blenderWorldRayOffset:{value:1e-5},
+ };
+ private target:THREE.WebGLRenderTarget|null=null;
+ private dynamicTarget:THREE.WebGLRenderTarget|null=null;
+ private readonly dynamicScene=new THREE.Scene();
+ private readonly dynamicMeshes=new Map<THREE.Mesh,THREE.Mesh>();
+ private readonly scene=new THREE.Scene();
+ private readonly geometry=new THREE.BufferGeometry();
+ private readonly material=new THREE.MeshDepthMaterial({side:THREE.DoubleSide});
+ private readonly mesh=new THREE.Mesh(this.geometry,this.material);
+ private readonly camera=new THREE.OrthographicCamera();
+ private segments:Segment[]=[];
+ private dirty=true;
+ private staticDirty=true;
+ private dynamicDirty=false;
+ private fittedBounds=new THREE.Box3();
+ private passes=0;
+ private staticPasses=0;
+ private dynamicPasses=0;
+ constructor(){this.mesh.frustumCulled=false;this.scene.add(this.mesh);}
+
+ sync(objects:Iterable<THREE.Object3D>,world:THREE.Texture|null,root:THREE.Object3D,enabled:boolean):void {
+  this.uniforms.blenderWorldVisibilityEnabled.value=enabled && world!==null;
+  this.uniforms.blenderWorldRadiance.value=world;
+  this.uniforms.blenderWorldToNative.value.setFromMatrix4(root.matrixWorld).invert();
+  if(!enabled || !world)return;
+  const meshes=[...objects].filter((object):object is THREE.Mesh=>(object as THREE.Mesh).isMesh===true &&
+   !!(object as THREE.Mesh).geometry.getAttribute('position'));
+  const layoutChanged=meshes.length!==this.segments.length || meshes.some((mesh,i)=>{
+   const previous=this.segments[i],geometry=mesh.geometry;
+   return !previous || previous.mesh!==mesh || previous.geometry!==geometry ||
+    previous.position!==geometry.getAttribute('position') || previous.index!==geometry.index ||
+    previous.start!==geometry.drawRange.start || previous.count!==Math.min(geometry.drawRange.count,
+     (geometry.index?.count ?? geometry.getAttribute('position').count)-geometry.drawRange.start);
+  });
+  if(layoutChanged) {
+   for(const mesh of this.dynamicMeshes.values()){mesh.removeFromParent();mesh.geometry.dispose();}
+   this.dynamicMeshes.clear();this.dynamicDirty=true;this.fittedBounds.makeEmpty();
+   let offset=0;
+   this.segments=meshes.map(mesh=>{
+    const geometry=mesh.geometry,position=geometry.getAttribute('position'),index=geometry.index;
+    const start=geometry.drawRange.start,count=Math.max(0,Math.min(geometry.drawRange.count,(index?.count??position.count)-start));
+    const segment={mesh,geometry,position,index,positionVersion:-1,indexVersion:-1,start,count,
+     offset,matrix:new THREE.Matrix4(),shown:!shown(mesh),bounds:new THREE.Box3(),dynamic:false};
+    offset+=count;return segment;
+   });
+   this.geometry.setAttribute('position',new THREE.BufferAttribute(new Float32Array(offset*3),3));
+   this.dirty=true;this.staticDirty=true;
+  }
+  const attribute=this.geometry.getAttribute('position') as THREE.BufferAttribute|undefined;
+  if(!attribute)return;
+  const point=new THREE.Vector3();
+  for(const segment of this.segments) {
+   const visible=shown(segment.mesh),pv=version(segment.position),iv=segment.index?.version??0;
+   if(segment.shown===visible && segment.matrix.equals(segment.mesh.matrixWorld) &&
+      segment.positionVersion===pv && segment.indexVersion===iv)continue;
+   // Once an object moves/deforms, keep it in the small dynamic atlas. Its
+   // later poses must never redraw every static triangle in the environment.
+   if(!segment.dynamic && segment.positionVersion>=0 &&
+     (!segment.matrix.equals(segment.mesh.matrixWorld) || segment.positionVersion!==pv || segment.indexVersion!==iv)) {
+    const geometry=new THREE.BufferGeometry();
+    geometry.setAttribute('position',new THREE.BufferAttribute(new Float32Array(segment.count*3),3));
+    const mesh=new THREE.Mesh(geometry,this.material);mesh.frustumCulled=false;
+    this.dynamicScene.add(mesh);this.dynamicMeshes.set(segment.mesh,mesh);segment.dynamic=true;
+    (attribute.array as Float32Array).fill(0,segment.offset*3,(segment.offset+segment.count)*3);
+    attribute.addUpdateRange(segment.offset*3,segment.count*3);attribute.needsUpdate=true;this.staticDirty=true;
+   }
+   const dynamicMesh=this.dynamicMeshes.get(segment.mesh);
+   const written=(dynamicMesh?.geometry.getAttribute('position')??attribute) as THREE.BufferAttribute;
+   if(dynamicMesh)dynamicMesh.visible=visible;
+   segment.bounds.makeEmpty();
+   for(let i=0;i<segment.count;i++) {
+    if(visible) {
+     const vertex=segment.index?.getX(segment.start+i) ?? segment.start+i;
+     point.fromBufferAttribute(segment.position,vertex).applyMatrix4(segment.mesh.matrixWorld);
+     segment.bounds.expandByPoint(point);
+    } else point.set(0,0,0); // Degenerate the hidden range without changing its layout.
+    written.setXYZ(dynamicMesh?i:segment.offset+i,point.x,point.y,point.z);
+   }
+   written.addUpdateRange(dynamicMesh?0:segment.offset*3,segment.count*3);written.needsUpdate=true;
+   if(dynamicMesh)this.dynamicDirty=true;else this.staticDirty=true;
+   segment.shown=visible;segment.matrix.copy(segment.mesh.matrixWorld);
+   segment.positionVersion=pv;segment.indexVersion=iv;this.dirty=true;
+  }
+ }
+
+ /** Draw the atlas only when a caster changes. All directional samples share
+  * one texture sampler and one merged depth draw, retaining offscreen casters. */
+ prepare(renderer:THREE.WebGLRenderer):void {
+  if(!this.uniforms.blenderWorldVisibilityEnabled.value || !this.dirty)return;
+  if(!this.target) {
+   const size=TILES*TILE_SIZE;
+   this.target=new THREE.WebGLRenderTarget(size,size,{depthBuffer:true,stencilBuffer:false});
+   this.target.depthTexture=new THREE.DepthTexture(size,size,THREE.UnsignedIntType);
+   this.target.depthTexture.minFilter=this.target.depthTexture.magFilter=THREE.NearestFilter;
+   this.uniforms.blenderWorldDepth.value=this.target.depthTexture;
+  }
+  if(this.dynamicMeshes.size && !this.dynamicTarget) {
+   const size=TILES*TILE_SIZE;
+   this.dynamicTarget=new THREE.WebGLRenderTarget(size,size,{depthBuffer:true,stencilBuffer:false});
+   this.dynamicTarget.depthTexture=new THREE.DepthTexture(size,size,THREE.UnsignedIntType);
+   this.dynamicTarget.depthTexture.minFilter=this.dynamicTarget.depthTexture.magFilter=THREE.NearestFilter;
+   this.uniforms.blenderWorldDynamicDepth.value=this.dynamicTarget.depthTexture;
+  }
+  this.uniforms.blenderWorldHasDynamicDepth.value=this.dynamicMeshes.size>0;
+  const bounds=this.segments.reduce((all,segment)=>all.union(segment.bounds),new THREE.Box3());
+  if(this.fittedBounds.isEmpty() || !this.fittedBounds.containsBox(bounds)) {
+   this.fittedBounds.union(bounds);this.staticDirty=true;
+  }
+  const sphere=this.fittedBounds.getBoundingSphere(new THREE.Sphere());
+  this.mesh.visible=(this.geometry.getAttribute('position')?.count??0)>0;
+  const radius=Math.max(sphere.radius,1e-3),distance=radius*2+1;
+  this.uniforms.blenderWorldRayOffset.value=radius*1e-5;
+  this.camera.left=-radius;this.camera.right=radius;this.camera.top=radius;this.camera.bottom=-radius;
+  this.camera.near=.001;this.camera.far=distance+radius*2;
+  this.camera.updateProjectionMatrix();
+  const target=renderer.getRenderTarget(),autoClear=renderer.autoClear,shadowMap=renderer.shadowMap.enabled;
+  try {
+   renderer.autoClear=false;renderer.shadowMap.enabled=false;
+   const targets:[THREE.WebGLRenderTarget,THREE.Scene,boolean][]=[[this.target,this.scene,this.staticDirty]];
+   if(this.dynamicTarget)targets.push([this.dynamicTarget,this.dynamicScene,this.dynamicDirty||this.staticDirty]);
+   for(const [target,,draw] of targets)if(draw) {
+    target.viewport.set(0,0,TILES*TILE_SIZE,TILES*TILE_SIZE);target.scissorTest=false;
+    renderer.setRenderTarget(target);renderer.clear(true,true,false);
+   }
+   for(let i=0;i<SAMPLE_COUNT;i++) {
+    const direction=this.uniforms.blenderWorldDirections.value[i]!;
+    this.camera.position.copy(sphere.center).addScaledVector(direction,distance);
+    this.camera.up.set(0,1,0);this.camera.lookAt(sphere.center);this.camera.updateMatrixWorld(true);
+    this.uniforms.blenderWorldMatrices.value[i]!.multiplyMatrices(this.camera.projectionMatrix,this.camera.matrixWorldInverse);
+    const x=(i%TILES)*TILE_SIZE,y=Math.floor(i/TILES)*TILE_SIZE;
+    // Render-target viewports use device pixels. Renderer.setViewport uses
+    // logical pixels even offscreen, so a HiDPI view would overlap the tiles.
+    for(const [target,scene,draw] of targets)if(draw) {
+     target.viewport.set(x,y,TILE_SIZE,TILE_SIZE);target.scissor.set(x,y,TILE_SIZE,TILE_SIZE);target.scissorTest=true;
+     renderer.setRenderTarget(target);renderer.render(scene,this.camera);
+    }
+   }
+   if(this.staticDirty){this.passes+=SAMPLE_COUNT;this.staticPasses+=SAMPLE_COUNT;}
+   if(this.dynamicTarget && (this.dynamicDirty||this.staticDirty)){this.passes+=SAMPLE_COUNT;this.dynamicPasses+=SAMPLE_COUNT;}
+   this.dirty=false;this.staticDirty=false;this.dynamicDirty=false;
+  } finally {
+   renderer.setRenderTarget(target);renderer.autoClear=autoClear;renderer.shadowMap.enabled=shadowMap;
+  }
+ }
+ diagnostics(){return {enabled:this.uniforms.blenderWorldVisibilityEnabled.value,world:!!this.uniforms.blenderWorldRadiance.value,
+  depth:!!this.uniforms.blenderWorldDepth.value,passes:this.passes,staticPasses:this.staticPasses,dynamicPasses:this.dynamicPasses,
+  dynamicObjects:this.dynamicMeshes.size,vertices:this.geometry.getAttribute('position')?.count??0,
+  casters:this.segments.filter(segment=>segment.shown).length,dirty:this.dirty};}
+ dispose():void {
+  this.uniforms.blenderWorldVisibilityEnabled.value=false;
+  this.target?.dispose();this.target=null;this.uniforms.blenderWorldDepth.value=null;
+  this.dynamicTarget?.dispose();this.dynamicTarget=null;this.uniforms.blenderWorldDynamicDepth.value=null;
+  this.uniforms.blenderWorldHasDynamicDepth.value=false;
+  for(const mesh of this.dynamicMeshes.values()){mesh.removeFromParent();mesh.geometry.dispose();}this.dynamicMeshes.clear();
+  this.geometry.dispose();this.material.dispose();this.segments=[];
+  this.geometry.deleteAttribute('position');this.dirty=true;this.staticDirty=true;this.dynamicDirty=false;this.fittedBounds.makeEmpty();
+ }
+}
+
+const bindings=new WeakMap<THREE.Material,BlenderWorldVisibility>();
+const compiled=new WeakMap<THREE.Material,Set<THREE.WebGLProgramParametersWithUniforms['uniforms']>>();
+const inactive=new BlenderWorldVisibility();
+export function bindWorldVisibility(material:THREE.Material,visibility:BlenderWorldVisibility):void {
+ if(bindings.get(material)===visibility)return;
+ bindings.set(material,visibility);
+ for(const uniforms of compiled.get(material)??[])Object.assign(uniforms,visibility.uniforms);
+}
+export function copyWorldVisibility(source:THREE.Material,target:THREE.Material):void {
+ const visibility=bindings.get(source);if(visibility)bindWorldVisibility(target,visibility);
+}
+export function worldVisibilityUniforms(material:THREE.Material,uniforms:THREE.WebGLProgramParametersWithUniforms['uniforms']):void {
+ let held=compiled.get(material);if(!held){held=new Set();compiled.set(material,held);}held.add(uniforms);
+ Object.assign(uniforms,(bindings.get(material)??inactive).uniforms);
+}
+
+export const worldVisibilityShader=/* glsl */`
+varying vec3 blenderWorldPosition;
+uniform bool blenderWorldVisibilityEnabled;
+uniform sampler2D blenderWorldDepth, blenderWorldDynamicDepth, blenderWorldRadiance;
+uniform bool blenderWorldHasDynamicDepth;
+uniform vec3 blenderWorldDirections[16];
+uniform mat4 blenderWorldMatrices[16];
+uniform mat3 blenderWorldToNative;
+uniform float blenderWorldRayOffset;
+float blenderWorldVisible(int i, vec3 position, vec3 worldDx, vec3 worldDy) {
+ vec4 clip=blenderWorldMatrices[i]*vec4(position,1.);
+ vec3 point=clip.xyz/clip.w*.5+.5;
+ if(any(lessThan(point,vec3(0.))) || any(greaterThan(point,vec3(1.))))return 1.;
+ vec2 tile=vec2(float(i%4),float(i/4));
+ vec2 samplePoint=clamp((floor(point.xy*512.)+.5)/512.,vec2(.5/512.),vec2(1.-.5/512.));
+ vec2 uv=(tile+samplePoint)/4.;
+ float depth=texture2D(blenderWorldDepth,uv).x;
+ if(blenderWorldHasDynamicDepth)depth=min(depth,texture2D(blenderWorldDynamicDepth,uv).x);
+ // Compare the receiver plane AT THE DEPTH TEXEL, not at its nearby fragment.
+ // A fixed depth bias falsely shadows an unoccluded tilted plane; increasing
+ // that bias leaks through thin walls. Derivatives retain its actual slope.
+ vec3 dx=(blenderWorldMatrices[i]*vec4(worldDx,0.)).xyz*.5;
+ vec3 dy=(blenderWorldMatrices[i]*vec4(worldDy,0.)).xyz*.5;
+ float determinant=dx.x*dy.y-dx.y*dy.x;
+ vec2 gradient=abs(determinant)>1e-12 ? vec2(dx.z*dy.y-dy.z*dx.y,dy.z*dx.x-dx.z*dy.x)/determinant : vec2(0.);
+ float receiverDepth=point.z+dot(gradient,samplePoint-point.xy);
+ return receiverDepth<=depth+1e-6 ? 1. : 0.;
+}
+vec3 blenderWorldIrradiance(vec3 normal, vec3 fallbackIrradiance) {
+ if(!blenderWorldVisibilityEnabled)return fallbackIrradiance;
+ vec3 n=inverseTransformDirection(normal,viewMatrix),sum=vec3(0.);
+ float weights=0.;vec3 origin=blenderWorldPosition+n*blenderWorldRayOffset;
+ vec3 worldDx=dFdx(blenderWorldPosition),worldDy=dFdy(blenderWorldPosition);
+ for(int i=0;i<16;i++) {
+  vec3 direction=blenderWorldDirections[i];float weight=max(0.,dot(n,direction));weights+=weight;
+  if(weight>0. && blenderWorldVisible(i,origin,worldDx,worldDy)>0.) {
+   vec3 nativeDirection=normalize(blenderWorldToNative*direction);
+   vec2 uv=vec2(atan(-nativeDirection.y,nativeDirection.x)/6.28318530718+.5,
+    asin(clamp(nativeDirection.z,-1.,1.))/3.14159265359+.5);
+   sum+=texture2D(blenderWorldRadiance,uv).rgb*weight;
+  }
+ }
+ return sum*(3.14159265359/max(weights,1e-8));
+}
+float blenderWorldReflectionVisibility(vec3 viewDirection,vec3 normal,float roughness) {
+ if(!blenderWorldVisibilityEnabled)return 1.;
+ vec3 n=inverseTransformDirection(normal,viewMatrix),r=inverseTransformDirection(reflect(-viewDirection,normal),viewMatrix);
+ vec3 origin=blenderWorldPosition+n*blenderWorldRayOffset;
+ vec3 worldDx=dFdx(blenderWorldPosition),worldDy=dFdy(blenderWorldPosition);
+ float sum=0.,weights=0.;
+ for(int i=0;i<16;i++) {
+  float weight=pow(max(0.,dot(r,blenderWorldDirections[i])),mix(64.,1.,roughness));
+  weights+=weight;sum+=weight*blenderWorldVisible(i,origin,worldDx,worldDy);
+ }
+ return sum/max(weights,1e-8);
+}
+`;

package/browser/three/presenter.ts

@@ -90,6 +90,22 @@ export function createPresenter(options: PresenterOptions = {}): Presenter {
     frame: unknown,
     description: unknown,
     capture?: CaptureRequest,
+  ): Promise<PresentAnswer> {
+    if (capture?.evaluation === 'render') {
+      const detached = BlenderRuntimeView.forPhotograph();
+      const captureScene = new THREE.Scene();
+      view.root.updateWorldMatrix(true, false);
+      detached.root.matrix.copy(view.root.matrixWorld);
+      captureScene.add(detached.root);
+      try { return await presentFrame(detached, captureScene, frame, description, capture); }
+      finally { detached.dispose(); detached.root.removeFromParent(); }
+    }
+    return presentFrame(view, scene, frame, description, capture);
+  }
+
+  async function presentFrame(
+    view: BlenderRuntimeView, scene: THREE.Scene, frame: unknown, description: unknown,
+    capture?: CaptureRequest,
   ): Promise<PresentAnswer> {
     const applied = view.applyFrame(frame) as { held?: unknown } | null | undefined;
     const held =
@@ -169,6 +185,7 @@ export function createPresenter(options: PresenterOptions = {}): Presenter {
           renderer.setClearColor(0, 0);
         }
         try {
+          view.prepareDraw(camera, { interactive: false, height, renderer });
           renderer.render(scene, camera);
         } finally {
           scene.background = background;

package/browser/volter_three.py

@@ -212,7 +212,7 @@ def _world(scene):
     }
 
 
-def _export():
+def _export(depsgraph):
     """The C++ door's frame, with what the door does not describe merged in.
 
     `known` is ALWAYS EMPTY: this process keeps no record of what a presenter
@@ -221,7 +221,7 @@ def _export():
     """
     options = {
         "session": SESSION,
-        "evaluate": True,
+        "evaluate": False,
         "known": {},
         "buffer_path": EXPORT_BUFFER_PATH,
     }
@@ -236,7 +236,7 @@ def _export():
     _REVISION[0] += 1
     frame["session"] = SESSION
     frame["revision"] = _REVISION[0]
-    scene = bpy.context.scene
+    scene = depsgraph.scene
     frame["world"] = _world(scene)
     frame["volumes"] = {}
     # THE INSPECTION OVERLAYS ARE THE EDITOR'S, and a render hides them anyway.
@@ -249,8 +249,14 @@ def _export():
     return frame
 
 
-def _present(capture):
-    answer = ask({"frame": _export(), "capture": capture})
+def _present(depsgraph, capture):
+    if not hasattr(_blender_web, "begin_render_export"):
+        raise RuntimeError("This Blender artifact has no render-evaluated export")
+    _blender_web.begin_render_export(depsgraph)
+    try:
+        answer = ask({"frame": _export(depsgraph), "capture": {**capture, "evaluation": "render"}})
+    finally:
+        _blender_web.end_render_export()
     if isinstance(answer, dict) and answer.get("error"):
         raise RuntimeError(answer["error"])
     return answer
@@ -334,7 +340,7 @@ def _photograph(depsgraph, width, height, linear=False):
     if linear:
         render["linear"] = True
     answer = _present(
-        {"position": position, "target": target, "up": up, "render": render}
+        depsgraph, {"position": position, "target": target, "up": up, "render": render}
     )
     if not isinstance(answer, dict) or "base64" not in answer:
         raise RuntimeError("The renderer did not answer with a photograph")

package/browser/worker.ts

@@ -116,6 +116,7 @@ interface Copied {
   description: unknown;
 }
 interface PendingFrame {
+  evaluation?: 'render';
   session: string;
   revision: number;
   columns: Map<number, Copied>;
@@ -270,7 +271,7 @@ async function startBlender(project: string, document?: string): Promise<unknown
   const started = await startBlenderEngine({
     project,
     log,
-    ask: async ({ frame, hold, mesh, image, piece, present, capture, saveDue, checkpoint }) => {
+    ask: async ({ frame, hold, mesh, image, piece, present, capture, saveDue, checkpoint, evaluation }) => {
       if (typeof checkpoint === 'string') { await loadCheckpoint?.(checkpoint); return {}; }
       if (!holder.engine) throw new Error('The Blender session presented before it started');
       // Save once after the whole command, never during a partial frame.
@@ -286,8 +287,8 @@ async function startBlender(project: string, document?: string): Promise<unknown
       // gets the whole frame at `present`.
       if (hold !== undefined) {
         const identity = hold as { session: string; revision: number };
-        pending = { session: identity.session, revision: identity.revision, columns: await copyColumns(arena, hold), meshes: new Map(), images: new Map() };
-        await streamToTab({ op: 'stage', session: identity.session, revision: identity.revision });
+        pending = { ...(evaluation ? { evaluation } : {}), session: identity.session, revision: identity.revision, columns: await copyColumns(arena, hold), meshes: new Map(), images: new Map() };
+        await streamToTab({ op: 'stage', evaluation, session: identity.session, revision: identity.revision });
         return {};
       }
       if (mesh !== undefined || image !== undefined) {
@@ -312,7 +313,7 @@ async function startBlender(project: string, document?: string): Promise<unknown
             description: await describeFrame(arena, piece),
           };
         }
-        await streamToTab({ op: 'stage', session: pending.session, revision: pending.revision,
+        await streamToTab({ op: 'stage', evaluation: pending.evaluation, session: pending.session, revision: pending.revision,
           ...(mesh !== undefined ? { mesh } : { image }), piece: copied.typed });
         // Keep only the manifest and digest; the presenter already built this
         // resource, and the next pull may overwrite the engine arena.
@@ -577,6 +578,43 @@ async function stageProjectFiles(files_: BlenderFiles, project: string): Promise
   return failed;
 }
 
+/** What `session.py::follow_open_file` says after a script changed the file Blender holds. */
+type FollowedDocument =
+  | { moved: true; from: string; document: string }
+  | { moved: false; from: string; outside: string };
+
+/**
+ * THE DOCUMENT FOLLOWS BLENDER'S SAVE AS, and the script's caller is told in its own answer.
+ *
+ * A move retargets the session's saves here (the save this call ends with lands the new file
+ * in the project, which is where the editor's Model tab for it opens from) and tells the tab,
+ * whose runtime handle holds the same path. A file outside the project is refused: the editor
+ * has no document there, so the session keeps its own and keeps saving to it, and says so
+ * naming both files, since the script believes it is now working in the other one.
+ */
+function followDocument(followed: FollowedDocument | undefined): string {
+  if (!followed) return '';
+  if (!followed.moved) {
+    const line = `Blender now has ${followed.outside} open, which is outside the project, so the editor cannot ` +
+      `follow it there: this session's document stays ${followed.from}, and the model keeps saving to ` +
+      `${followed.from}. To move the model to another file, save it inside the project (src/models/<name>.blend).`;
+    log('warn', line);
+    return `\n\n${line}`;
+  }
+  if (!isDocumentPath(followed.document)) {
+    // The session checks the same shape, so this is a broken promise, not a refusal to explain.
+    throw new Error(`Blender moved its document to ${JSON.stringify(followed.document)}, which is not a project .blend path`);
+  }
+  documentPath = followed.document;
+  // Even a present that failed must not leave the new file only in the engine's filesystem.
+  setDocumentDirty(true);
+  post({ op: 'document-moved', from: followed.from, document: followed.document });
+  const line = `Blender now has ${followed.document} open (this code saved or opened it), so the editor follows it: ` +
+    `the model saves to ${followed.document} from now on, and ${followed.from} keeps what it last saved.`;
+  log('log', `@@VOLTER-DOCUMENT-MOVED ${JSON.stringify({ from: followed.from, document: followed.document })}`);
+  return `\n\n${line}`;
+}
+
 /** The failures `stageProjectFiles` answered, as one paragraph a script's caller can read. */
 function stagingNote(failed: readonly string[]): string {
   return failed.length === 0 ? '' :
@@ -678,9 +716,10 @@ async function handle(request: WorkerRequest): Promise<unknown> {
         const note = stagingNote(await stageProjectFiles(files, projectRoot));
         const answer = await ask({ op: 'execute', code: request.code, history: request.history ?? true,
           label: request.label ?? 'Blender Python' }) as {
-          error?: string; result: string;
+          error?: string; result: string; document?: FollowedDocument;
         };
-        return (answer.error ? `Error executing code: ${answer.error}` : `Code executed successfully: ${answer.result}`) + note;
+        return (answer.error ? `Error executing code: ${answer.error}` : `Code executed successfully: ${answer.result}`) +
+          note + followDocument(answer.document);
       }
     case 'present':
       // Straight through to `session.py`'s own `present` op — the worker adds

package/package.json

@@ -2,7 +2,7 @@
   "name": "@volter/blender-engine",
   "author": "Volter AI, Inc.",
   "license": "GPL-3.0-or-later",
-  "version": "0.1.130",
+  "version": "0.1.132",
   "publishConfig": {
     "access": "public"
   },

package/wasm/BUNDLE.json

@@ -1,9 +1,9 @@
 {
   "blender": "5.2.0 LTS",
-  "source": "434072350c0577eb155068d5a1b62bb45daf19f9",
+  "source": "5a3cb1250fc1fd7df59e3ff823949c06e52d9422",
   "upstream": "fbe6228777e7d9afefcd61a413844e790ae75db7",
   "sourceRepository": "https://github.com/volter-ai/blender",
-  "sourceRecipe": "https://github.com/volter-ai/blender/blob/434072350c0577eb155068d5a1b62bb45daf19f9/build_files/emscripten/RELEASE.md",
+  "sourceRecipe": "https://github.com/volter-ai/blender/blob/5a3cb1250fc1fd7df59e3ff823949c06e52d9422/build_files/emscripten/RELEASE.md",
   "factoryEngine": "BLENDER_EEVEE",
   "files": {
     "blender_browser.js": "raw",
@@ -16,8 +16,8 @@
       "sha256": "d818e8d746bc62ebf810206ac564d2dc75dc645b3121f4a3919d13ecef11e419"
     },
     "blender_browser.wasm": {
-      "bytes": 86344416,
-      "sha256": "f5b988d30a9f29708254bc84600f7b88d9c9eb41af904b84c9f398d5c41595e4"
+      "bytes": 86351436,
+      "sha256": "d4c3a8002cb1686f3c5299e28bcbb356934bbe910f2485b2572032b115cf67bd"
     },
     "blender_browser.data": {
       "bytes": 52699590,
@@ -30,8 +30,8 @@
       "sha256": "d818e8d746bc62ebf810206ac564d2dc75dc645b3121f4a3919d13ecef11e419"
     },
     "blender_browser.wasm.br": {
-      "bytes": 18611942,
-      "sha256": "b415a2fce0f2d2f796a2a3362b38420df063866898cc04c61d4604c5caf13e0d"
+      "bytes": 18605311,
+      "sha256": "97e3bc2c772e9fd6da5a3e28086c1ee1dfd62b35ebdeb127a413b4bd5904031f"
     },
     "blender_browser.data.br": {
       "bytes": 8056485,
@@ -42,9 +42,9 @@
       "sha256": "4085e9336266cf66f061d4d5c962a5929cc96d5732c746b5c13ea05cd104a75b"
     }
   },
-  "note": "Stoneguard c7/c14/c15 engine. Emscripten 6.0.5, Release -O3 objects and -O2 link. Portable native arm64 matrix reciprocal plus fused generic OpenSubdiv stencil and patch accumulation; bodice four-stage comparison 28/28 arrays exact. Full-scene comparison and memory scope recorded in provenance/stoneguard-memory.json. Historical battery absent; no full-battery or hosted acceptance claim. Rebuilt from the public instance-source commit with the same Emscripten 6.0.5, Release -O3 objects and -O2 link. All 6287 drawable Lone Monk placements resolve to 26 native source objects and 24 deferred mesh resources. Live raster rendering still differs from native Cycles; no full-scene visual parity claim. Rebuilt from the public evaluated-geometry identity commit with the same Emscripten 6.0.5 Release recipe. Distinct Array/Mirror/deformation outputs no longer borrow another object’s geometry. Native linked-input sharing and every deferred probe vertex are checked independently. Live raster illumination remains unoccluded environment lighting and differs substantially from native Cycles; no visual parity claim.",
+  "note": "Emscripten 6.0.5, Release -O3 objects and -O2 link, retained public build recipe and dependency licenses. Scoped render-evaluated export preserves render-only geometry and render-specific modifier results without replacing the viewport export state. Prior geometry identity and memory fixes remain. Full-scene Three versus Cycles rendering parity remains incomplete.",
   "callTrampoline": "CPython 3.13.13 is compiled with PY_CALL_TRAMPOLINE for Blender CPython slot arity casts. This applies to CPython dispatch, not arbitrary indirect calls.",
   "engineIds": "The session preserves the compiled native CYCLES engine. VOLTER_THREE selects the explicit raster presenter; BLENDER_EEVEE and BLENDER_WORKBENCH remain presentation engines.",
-  "exportDoor": "The source-owned bpy_web_export.cc exports Principled physical inputs, normal images, eight named UV layers and evaluated corner normals, and takes graph_materials/graph_images/graph_generated (a graph-drawn shader mix reduced to the one Principled BSDF it reaches, graph images at the door revisions with every UDIM tile, orco for deformed meshes whose graph reads Generated coordinates). A frame can defer its changed meshes and pictures (defer) for the caller to pull one at a time (export_mesh, export_image), each call freeing the previous one's columns and a picture it decoded; an undo step keeps the revisions when Blender kept the depsgraph (session_undo); Blender's CPU subdivision descriptor is released once a mesh is read; the memory door reports malloc in-use and free. Datablock revisions are keyed by session_uid. writefile.cc writes one copy of the document per save in the browser build. CPU evaluators adopt stencil tables without cloning; browser subdivision descriptors are released immediately after CPU tessellation/deformation. Native evaluated corner triangles accompany corner normals. Consumed local conversion stencils are released before later UV channels are constructed. Caller-thread file-read, evaluated-object and subdivision checkpoints provide backpressure for resumable startup. Shared geometry revisions advance once per frame. Existing synchronous export remains available. Optional instance_sources exports stable evaluated collection and particle source meshes, including excluded library meshes and converted curves. Frame-local instance_geometry tokens verify Python placement metadata against the exported geometry and are consumed before presentation. Geometry resource identity preserves implicit input storage only for unmodified geometry and separates evaluated modifier/deformation outputs. Object and mesh resource keys have independent namespaces.",
+  "exportDoor": "The source-owned bpy_web_export.cc exports Principled physical inputs, normal images, eight named UV layers and evaluated corner normals, and takes graph_materials/graph_images/graph_generated (a graph-drawn shader mix reduced to the one Principled BSDF it reaches, graph images at the door revisions with every UDIM tile, orco for deformed meshes whose graph reads Generated coordinates). A frame can defer its changed meshes and pictures (defer) for the caller to pull one at a time (export_mesh, export_image), each call freeing the previous one's columns and a picture it decoded; an undo step keeps the revisions when Blender kept the depsgraph (session_undo); Blender's CPU subdivision descriptor is released once a mesh is read; the memory door reports malloc in-use and free. Datablock revisions are keyed by session_uid. writefile.cc writes one copy of the document per save in the browser build. CPU evaluators adopt stencil tables without cloning; browser subdivision descriptors are released immediately after CPU tessellation/deformation. Native evaluated corner triangles accompany corner normals. Consumed local conversion stencils are released before later UV channels are constructed. Caller-thread file-read, evaluated-object and subdivision checkpoints provide backpressure for resumable startup. Shared geometry revisions advance once per frame. Existing synchronous export remains available. Optional instance_sources exports stable evaluated collection and particle source meshes, including excluded library meshes and converted curves. Frame-local instance_geometry tokens verify Python placement metadata against the exported geometry and are consumed before presentation. Geometry resource identity preserves implicit input storage only for unmodified geometry and separates evaluated modifier/deformation outputs. Object and mesh resource keys have independent namespaces. Scoped begin_render_export/end_render_export reads the render engine depsgraph and isolates viewport revision, undo, deferred resource and image watcher state. Geometry resource identity preserves implicit input storage only for unmodified geometry and separates evaluated modifier/deformation outputs. Object and mesh resource keys have independent namespaces.",
   "preloadedPayload": "releasePreloadedFileData releases the JS preload buffer after session ready. The measured working payload exclusions are retained."
 }