@volter/blender-engine 0.1.148 → 0.1.150

package/browser/session.py

@@ -1,96 +1,9 @@
-"""The editor tab's Blender session, INSIDE real Blender.
-
-THE BLENDER IN THE TAB IS BLENDER (ARCHITECTURE-CORE, owner ruling
-2026-09-17). Blender 5.2 LTS is compiled to WebAssembly and started
-`--background --factory-startup --python <this file>`; `main()` never returns
-because this script does not return, so the module's Blender pthread stays
-alive and holds ONE `bpy.data` for as long as the worker does. That is the
-session: `execute(code) -> {stdout, error}`, plus the same `get_scene_info` /
-`get_object_info` the MCP door has always carried, plus the EXPORT that feeds
-the presenter.
-
-THE CHANNEL IS A DIRECTORY, NOT STDIN, and that is a measurement rather than a
-preference (2026-09-17, node, the v0.1.1 release): the build's
-`FS_stdin_getChar` runs on the BLENDER PTHREAD -- `isMainThread=false` -- where
-node's `process.stdin.fd` is `undefined` and a browser pthread has no
-`window.prompt`, so stdin is not a channel the page can write into. WasmFS
-keeps its file table in the shared wasm memory, so a FILE is: the worker's own
-thread writes `in/<id>.json` then `in/<id>.done`, this loop sees it, and the
-answer goes back as `out/<id>.json` + `out/<id>.done`. Measured round trip on
-that same run: 5 ms idle, 30 ms for a cube, 436 ms for a subdivide-and-apply.
-
-THE CHANNEL HAS ONE WRITER PER DIRECTORY, and on the WALI skew that rule is
-what keeps a session alive for more than a few dozen calls:
-
-    in/     the PAGE writes and unlinks; this file only ever READS it.
-    out/    THIS FILE writes and unlinks; the page only reads.
-    ask/    THIS FILE writes and unlinks; the page only reads.
-    reply/  the PAGE writes and unlinks; this file only ever READS it.
-
-Under WALI the page and this program are two snapshot-backed views of one
-tree, reconciled by patches, and the host REFUSES a patch whose base no longer
-matches what it holds -- then terminates the program. A path can only
-disagree if someone other than the patch's author moved it, so disjoint
-writer sets leave the assertion nothing to fire on. Measured 2026-09-19: with
-the page unlinking this loop's `out/<id>.*` after every answer, a render loop
-in one session died at call 37 and at call 14, with no guest exit path run.
-
-THE ACK IS THE OTHER SIDE'S REQUEST FILE DISAPPEARING, which costs no file and
-no extra write. The page unlinks `in/<id>.json` and then `in/<id>.done` only
-after it has read `out/<id>.json`, so `in/<id>.done` gone means the answer was
-taken and this loop may remove its own `out/<id>.*` -- read straight out of
-the `listdir(IN)` the loop already does every pass. Symmetrically, `ask` waits
-for `reply/<id>.done`, reads `reply/<id>.json`, and then removes its OWN
-`ask/<id>.*`; the page watches those vanish and retires the reply it wrote.
-`.done` is unlinked last on both sides, because `.done` is the token the other
-side watches.
-
-THE DIRECTORIES FOLLOW THEIR CONTENTS' OWNER: this file creates `out` and
-`ask` and never `in` or `reply` (`blender-engine.mts`'s
-`PAGE_OWNED_DIRECTORIES` makes those before the program starts). A `mkdir` or
-`chmod` on a path the other side has already touched is the same crossing
-edit at a smaller scale.
-
-THE LOAD HANDLER IS `@persistent` because Blender clears every non-persistent
-handler on file load, and `open_mainfile` is an ordinary thing for a script
-here to do.
-
-THE EXPORT IS THE C++ DOOR, not Python. `_blender_web.export_frame` evaluates
-the scene, takes its revisions from the depsgraph's own update record, and
-writes every column into a side ARENA in wasm memory; the JSON frame names each
-one by `{offset, length, dtype, count, stride}`; the worker reads those bytes
-through the one door its skew has (`BlenderEngine.readArena`: the module heap
-where the host can reach it, the `buffer_path` file where it cannot). Nothing
-large crosses as JSON. What this file still describes is what the door
-does not: the WORLD's shader expression and the CAMERAS a photograph is framed
-through.
-
-THE REVISION SIGNAL IS THE DEPSGRAPH'S OWN UPDATE RECORD, accumulated by the
-door's C callbacks on BOTH `depsgraph_update_post` and `frame_change_post` (a
-`frame_set` fires only the second), with a render's own evaluation skipped.
-
-THE SESSION HAS A DOCUMENT, and it is a `.blend` Blender itself writes.
-`blender-start` names it (project-relative, `models/model.blend` by default);
-an existing one is OPENED at start and an absent one starts empty. The session
-saves it through `bpy.ops.wm.save_as_mainfile` -- never a codec of ours, and
-never a mutation of the script's own datablocks. A SCRIPT'S DATABLOCKS ARE THE
-SCRIPT'S: the session does not rewrite the paths a script loaded its images
-from in order to save. Where a document reopens from is a question the script
-answers when it loads its files, by loading them through project-relative
-paths; `save_as_mainfile`'s own Save-As semantics are the whole of what the
-session applies (see `save_document`).
-
-WHO CARRIES THE DOCUMENT OUT, and why it is not this loop's job: the save
-writes into the module filesystem, which mirrors the project at the SAME
-absolute path but is not the disk. Python cannot push it out on its own --
-`ask` is only served from inside a request's poll loop
-(`blender-engine.mts::serveAsks`), so an `ask` raised from this idle loop
-would never be answered and would wedge the Blender pthread forever. So the
-DEBOUNCE LIVES IN THE TAB: a present that leaves the document stale says so
-(`saveDue` beside the frame), the worker waits out an idle second, calls
-`save-document` as an ordinary request, and carries the bytes to the project
-(`worker.ts`). Every step is an explicit call; nothing polls.
-"""
+"""The tab’s long-lived Blender session. A directory protocol carries requests and replies while one bpy.data remains alive on Blender’s pthread. The page owns in/ and reply/; the guest owns out/ and ask/. Each writer cleans its own files after acknowledgement and removes .done last. Explicit saves write Blender’s native format and let worker.ts return changed output to the project."""
+
+import sys
+
+# The session module begins loading (a start step: see `main`).
+print("@@VOLTER-PHASE module", file=sys.stderr, flush=True)
 
 import array
 import base64
@@ -100,7 +13,6 @@ import json
 import math
 import os
 import re
-import sys
 import time
 import traceback
 from contextlib import redirect_stdout
@@ -114,7 +26,12 @@ import mathutils
 # THE EXPORT DOOR, compiled into this Blender (`bpy_web_export.cc`): one call
 # reads the scene out as typed columns in a side arena the worker reads
 # through `BlenderEngine.readArena` -- see EXPORT_BUFFER_PATH below.
-import _blender_web
+try:
+    import _blender_web
+except ModuleNotFoundError as error:
+    if error.name != "_blender_web":
+        raise
+    _blender_web = None
 
 # The presenter's refusals, spelled in
 # `packages/blender-engine/browser/three/blender-runtime-frame.ts`. This is the only
@@ -127,30 +44,12 @@ IN = os.path.join(ROOT, "in")
 OUT = os.path.join(ROOT, "out")
 ASK = os.path.join(ROOT, "ask")
 REPLY = os.path.join(ROOT, "reply")
-# WHERE THE CALLER WANTS THE EXPORT ARENA, if it wants it anywhere.
-#
-# The export door offers TWO ways to read the arena it fills, and has since
-# `bpy_web_export.cc` was written: the C exports that name it in linear
-# memory, and a `buffer_path` option that also writes the same bytes to a file
-# -- "natively the path is the caller's own string". Which door the caller
-# uses is the caller's business, and this file does not know its toolchain: it
-# states the path it was given, or states nothing.
-#
-# EMPTY UNLESS THE ENGINE SETS IT, and that is the point. The standalone skew
-# reads the arena straight off the module heap and must not pay a
-# megabyte-scale file write per present. The engine that sets it is the one
-# whose host cannot reach the module's memory at all
-# (`blender-wali-engine.mts`), where the file is not a fallback but the
-# native door onto the same bytes.
+# Use the caller-supplied EXPORT_BUFFER_PATH when its host reads the arena through the filesystem.
+# Hosts with access to linear memory leave it empty to avoid a second copy. Both doors expose the
+# same native export bytes.
 EXPORT_BUFFER_PATH = os.environ.get("VOLTER_EXPORT_BUFFER_PATH", "")
 
-# WHERE THE ENGINE'S HEAP WENT, stage by stage: the heap only grows, so its size after a stage says
-# nothing about the stage before it; this records `_blender_web.memory()` at each, in MB
-# ([label, heap, mallocInUse, mallocFree, guarded, guardedPeak]), and a script reads `MEMORY_MARKS`
-# (the last 64) to say which stage raised the high-water mark. MEASURED 2026-09-29 on the
-# Stoneguard file: the first export's door call took the heap from 1,442 to 3,644 MB while in-use
-# rose 28 MB and the guarded peak did not move -- OpenSubdiv's limit-surface evaluator for one
-# head (quality 3), which native Blender pays too (+1.2 GB peak RSS there).
+# Retain the last 64 heap marks as [label, heap, mallocInUse, mallocFree, guarded, guardedPeak] in MB so callers can attribute growth to a stage.
 MEMORY_MARKS = []
 
 
@@ -202,11 +101,17 @@ def _prepare_directories():
 
 # ---------------------------------------------------------------- file load
 
+# Each file load, counted: a request during which one came replaced the file, never removed its objects.
+_LOADS = {"count": 0}
+
+
 @bpy.app.handlers.persistent
 def _load_post(_arg):
+    _LOADS["count"] += 1
     # The DOOR resets its own revision table on LOAD_POST (it holds ID pointers
     # into the Main that just went away); this is the session's half.
     SESSION.forget()
+    SESSION.renew()
     SESSION.loaded()
     # Factory reset reloads add-ons. Preserve native Cycles and re-register
     # only the headless GPU presenters we own.
@@ -275,7 +180,7 @@ def _surface_backgrounds(node):
     """World Surface as `(what the camera sees, what lights the scene)`; a
     world that is one Background is both and the second is None. A Mix Shader
     by Light Path `Is Camera Ray` is how a scene gets a bright backdrop and a
-    restrained fill from one sky (the tram stop): input 2 is the camera's,
+    restrained fill from one sky: input 2 is the camera's,
     input 1 lights the scene."""
     kind = node.bl_idname
     if kind == "ShaderNodeBackground":
@@ -381,13 +286,12 @@ def _describe_world_socket(root_socket, camera_ray):
             if kind == "ShaderNodeMapRange" and socket == "Result":
                 if node.data_type != "FLOAT":
                     raise NotImplementedError("World Map Range data type %s" % node.data_type)
-                steps = node.inputs.get("Steps")
                 return {"kind": "map_range", "interpolation": node.interpolation_type,
                         "clamp": bool(node.clamp) and node.interpolation_type not in ("SMOOTHSTEP", "SMOOTHERSTEP"),
                         "value": value(node.inputs["Value"]),
                         "from_min": value(node.inputs["From Min"]), "from_max": value(node.inputs["From Max"]),
                         "to_min": value(node.inputs["To Min"]), "to_max": value(node.inputs["To Max"]),
-                        "steps": value(steps) if steps is not None else 0.0}
+                        "steps": value(node.inputs["Steps"])}
             if kind == "ShaderNodeSeparateXYZ" and socket in ("X", "Y", "Z"):
                 return {"kind": "separate", "vector": value(node.inputs["Vector"]), "axis": ("X", "Y", "Z").index(socket)}
             if kind == "ShaderNodeValToRGB" and socket == "Color":
@@ -406,8 +310,8 @@ def _describe_world_socket(root_socket, camera_ray):
                 if model not in ("SINGLE_SCATTERING", "MULTIPLE_SCATTERING"):
                     raise NotImplementedError(
                         "World Sky Texture: sky_type %r is not implemented (SINGLE_SCATTERING and MULTIPLE_SCATTERING are)" % model)
-                vector = node.inputs.get("Vector")
-                if vector is not None and vector.links:
+                vector = node.inputs["Vector"]
+                if vector.links:
                     raise NotImplementedError("Linked World Sky Texture Vector")
                 return {"kind": "sky", "sky_model": model, "sun_disc": bool(node.sun_disc),
                         "sun_size": float(node.sun_size), "sun_intensity": float(node.sun_intensity),
@@ -500,10 +404,10 @@ def _describe_world(world):
     # Only a wholly constant background can drop the expression: linked
     # Strength may carry spatial radiance even when Color itself is constant.
     if not any(background.inputs[name].is_linked for name in ("Color", "Strength")):
-        described.pop("shader", None)
+        del described["shader"]
     if "lighting" in described and not any(
             (lighting or background).inputs[name].is_linked for name in ("Color", "Strength")):
-        described["lighting"].pop("shader", None)
+        del described["lighting"]["shader"]
     return described
 
 
@@ -549,36 +453,7 @@ def draw_camera(obj):
     }
 
 
-# ------------------------------------------------------- the material graphs
-
-# THE MATERIAL GRAPH, for a surface whose inputs are more than constants.
-#
-# The export door reduces each material to what a three.js standard material
-# holds -- a constant or one image per input. A LINKED input of a Principled
-# BSDF or an Emission is instead shipped as the node graph that drives it, and
-# the presenter compiles that graph with Blender's own node GLSL
-# (`three/blender-node-graph.ts`, `three/blender-node-glsl.generated.ts`). The
-# door is told which materials those are (`graph_materials`), so it stays quiet
-# about reducing them, which images their graphs sample (`graph_images`), so it
-# ships those pictures with the same revisions as every other, and which read
-# Generated coordinates (`graph_generated`), so a deformed mesh wearing one
-# ships Blender's orco -- or the door names why it cannot.
-#
-# The graph is flattened here: reroutes and muted nodes are followed the way
-# Blender's own node tree evaluation follows them, and group nodes are inlined
-# (their nodes keyed by the group path), so the presenter sees one acyclic
-# list of Blender nodes. What reaches the presenter is Blender's own data:
-# every input socket in declaration order with its GPU type and value, every
-# output socket's GPU type, and the node's own RNA properties.
-
-# The node types the presenter compiles. A graph reaching any other type is
-# not shipped; the door's reduction stands and a warning names the node.
-
-# EVERY LINK INTO A SOCKET, from one pass over its tree. `NodeSocket.links`
-# is Python in Blender (`_bpy_types.py`): each read walks ALL of the tree's
-# links, and the graph pass reads it per socket per present -- measured on a
-# 28-material scene, 875 reads and 9 of the pass's 15 profiled seconds. The
-# map is built once per tree per present (`material_graphs` clears it).
+# Ship linked Principled BSDF and Emission inputs as node graphs for blender-node-graph.ts to compile. Build socket-link indexes once per node tree per present.
 _TREE_LINKS = {}
 
 
@@ -632,7 +507,7 @@ def _gpu_type(socket):
     if kind in ("VALUE", "INT", "BOOLEAN"):
         return "float"
     if kind == "VECTOR":
-        return "vec%d" % len(socket.default_value) if hasattr(socket, "default_value") else "vec3"
+        return "vec%d" % len(socket.default_value)
     if kind in ("RGBA", "ROTATION"):
         return "vec4"
     if kind == "SHADER":
@@ -642,8 +517,6 @@ def _gpu_type(socket):
 
 def _socket_value(socket, gpu):
     """An unlinked socket's value in its GPU type (`nodestack_get_vec`)."""
-    if not hasattr(socket, "default_value"):
-        return 0.0 if gpu == "float" else [0.0] * int(gpu[3:])
     value = socket.default_value
     if gpu == "float":
         return float(value)
@@ -785,7 +658,10 @@ def _saved_view():
     Modeling), else the first 3D View any screen holds. `RegionView3D`'s pivot, rotation (view to
     world, `(w, x, y, z)`), distance and projection (`PERSP`, `ORTHO`, or `CAMERA` for a view
     through the scene camera), the `View3D`'s lens, and its SHADING TYPE, which Blender reopens
-    with the view: a file saved in Material Preview opens in Material Preview."""
+    with the view: a file saved in Material Preview opens in Material Preview. Beside them, the
+    Solid options the tab draws as Blender does: the object outline (`show_object_outline`, in
+    `object_outline_color`), the specular term (`show_specular_highlight`) and what Solid and
+    Wireframe draw behind the model (`background_type`, with `background_color` for VIEWPORT)."""
     screens = [window.screen for wm in bpy.data.window_managers for window in wm.windows
                if window.screen is not None]
     workspace = bpy.data.workspaces.get("Modeling")
@@ -806,6 +682,11 @@ def _saved_view():
                 "shading": space.shading.type,
                 "scene_world": bool(space.shading.use_scene_world),
                 "scene_lights": bool(space.shading.use_scene_lights),
+                "show_object_outline": bool(space.shading.show_object_outline),
+                "object_outline_color": [float(v) for v in space.shading.object_outline_color],
+                "show_specular_highlight": bool(space.shading.show_specular_highlight),
+                "background_type": space.shading.background_type,
+                "background_color": [float(v) for v in space.shading.background_color],
             }
     return None
 
@@ -862,7 +743,7 @@ def _subject_line(scene, view_layer):
                     bone = rig.data.bones.active
                     if bone is not None and _bone_shown(bone):
                         parts.append(" : " + bone.name)
-            key = ob.active_shape_key if getattr(ob.data, "shape_keys", None) is not None else None
+            key = ob.active_shape_key
             if key is not None:
                 parts.append(" : " + key.name)
                 if ob.show_only_shape_key:
@@ -876,7 +757,7 @@ def _subject_line(scene, view_layer):
 
 def _bone_shown(bone):
     """`ANIM_bonecoll_is_visible_actbone`: a bone in no collection, or in a visible one."""
-    collections = getattr(bone, "collections", None)
+    collections = bone.collections
     return not collections or any(c.is_visible for c in collections)
 
 
@@ -1009,7 +890,7 @@ def _follow(socket, stack):
             return stack, node
 
 
-def _light_path_side(socket, stack):
+def _light_path_side(socket):
     """A Mix Shader factor that separates the camera's surface (a Light Path's
     Is Camera Ray: 1, Is Shadow Ray: 0 on a camera ray), or a constant 0 or 1,
     as the input index the camera sees; None for any other factor. The door
@@ -1027,7 +908,7 @@ def _light_path_side(socket, stack):
 def _collapse(stack, node):
     """Follow the Mix Shaders the camera sees one side of (`_light_path_side`)."""
     while node is not None and node.bl_idname == "ShaderNodeMixShader" and not node.mute:
-        side = _light_path_side(node.inputs[0], stack)
+        side = _light_path_side(node.inputs[0])
         if side is None:
             break
         stack, node = _follow(node.inputs[side], stack)
@@ -1140,23 +1021,17 @@ def _mixed_graph(material, stack, surface):
     }
 
 
-def _object_info_random(name):
-    """Ordinary-object Random, shared by EEVEE and Cycles: hash_string then
-    Jenkins hash_uint2(name_hash, 0), converted to float32 * 2**-32.
-    Instances must use depsgraph.random_id instead; their export is separate.
-    See draw_handle.hh::random and cycles/blender/object.cpp.
-    """
+def _hash_uint2_float(value):
+    """Jenkins hash_uint2(value, 0), converted to float32 * 2**-32."""
     import struct
 
     mask = 0xffffffff
-    h = 0
-    # Blender's platform flags specify -funsigned-char (native and WASM).
-    for byte in name.encode("utf8"):
-        h = (h * 37 + byte) & mask
-    a = (0xdeadbeef + 21 + h) & mask
+    a = (0xdeadbeef + 21 + value) & mask
     b = c = (0xdeadbeef + 21) & mask
+
     def rotate(x, bits):
         return ((x << bits) | (x >> (32 - bits))) & mask
+
     c = ((c ^ b) - rotate(b, 14)) & mask
     a = ((a ^ c) - rotate(c, 11)) & mask
     b = ((b ^ a) - rotate(a, 25)) & mask
@@ -1167,6 +1042,18 @@ def _object_info_random(name):
     return struct.unpack("f", struct.pack("f", c / 4294967296.0))[0]
 
 
+def _object_info_random(name):
+    """Ordinary-object Random, shared by EEVEE and Cycles: hash_string then
+    hash_uint2(name_hash, 0). Instances use depsgraph.random_id instead.
+    See draw_handle.hh::random and cycles/blender/object.cpp.
+    """
+    h = 0
+    # Blender's platform flags specify -funsigned-char (native and WASM).
+    for byte in name.encode("utf8"):
+        h = (h * 37 + byte) & 0xffffffff
+    return _hash_uint2_float(h)
+
+
 def _particle_info_random(index=0):
     """Cycles Particle Info Random: hash_uint2(particle.index, 0).
 
@@ -1174,20 +1061,7 @@ def _particle_info_random(index=0):
     without a particle record use the zero-index dummy KernelParticle.
     This is distinct from Object Info's placement random_id.
     """
-    import struct
-    mask = 0xffffffff
-    a = (0xdeadbeef + 21 + index) & mask
-    b = c = (0xdeadbeef + 21) & mask
-    def rotate(x, bits):
-        return ((x << bits) | (x >> (32 - bits))) & mask
-    c = ((c ^ b) - rotate(b, 14)) & mask
-    a = ((a ^ c) - rotate(c, 11)) & mask
-    b = ((b ^ a) - rotate(a, 25)) & mask
-    c = ((c ^ b) - rotate(b, 16)) & mask
-    a = ((a ^ c) - rotate(c, 4)) & mask
-    b = ((b ^ a) - rotate(a, 14)) & mask
-    c = ((c ^ b) - rotate(b, 24)) & mask
-    return struct.unpack("f", struct.pack("f", c / 4294967296.0))[0]
+    return _hash_uint2_float(index)
 
 
 def _depsgraph_placements(frame, depsgraph):
@@ -1204,7 +1078,7 @@ def _depsgraph_placements(frame, depsgraph):
             row["shadow_visible"] = bool(source.visible_shadow)
     # Frame-local native addresses are comparison tokens, not authoring IDs.
     # Consume them here so neither the presenter nor saved projects retain them.
-    geometry = frame.pop("instance_geometry", {})
+    geometry = frame.pop("instance_geometry")
     placements = []
     for instance in depsgraph.object_instances:
         source = instance.object.original
@@ -1217,9 +1091,8 @@ def _depsgraph_placements(frame, depsgraph):
             continue
         if not instance.show_self:
             continue
-        # AN UNSUPPORTED PLACEMENT IS LEFT OUT, NAMED ONCE (`warn`): raising here
-        # lost the whole frame, so one odd instance kept the entire scene from
-        # opening. The native exporter skips the same duplis.
+        # Omit unsupported placements and name each refusal through `warn`.
+        # The rest of the frame remains drawable.
         if (instance.instance_object is not None and instance.object.data != instance.instance_object.data and
                 (instance.object.data is None or geometry.get(source.name) != instance.object.data.as_pointer())):
             warn("Depsgraph instances of %r are not drawn: their geometry differs from the exported source" % source.name)
@@ -1263,7 +1136,7 @@ def material_graphs(scene):
     _TREE_LINKS.clear()
     graphs = {}
     for obj in scene.objects:
-        for slot in getattr(obj, "material_slots", ()):
+        for slot in obj.material_slots:
             material = slot.material
             if material is not None and material.name not in graphs:
                 graphs[material.name] = material_graph(material)
@@ -1272,9 +1145,7 @@ def material_graphs(scene):
 
 # ------------------------------------------------------------- the overlays
 #
-# INSPECTION OVERLAYS, READ OFF THE ENGINE (ARCHITECTURE-CORE §Blender north
-# star, "Inspection parity, not editing parity"; WORK.md §Blender in the tab
-# is Blender, "Inspection parity", I4). Blender's overlay ENGINE
+# INSPECTION OVERLAYS, READ OFF THE ENGINE. Blender's overlay engine
 # (`source/blender/draw/engines/overlay/`) is never run, ported or recorded
 # here: what these answer is the DATA its draw functions read -- a bone's
 # display matrix, a vertex's weight -- and a three.js presenter draws it
@@ -1304,7 +1175,7 @@ def _armature_bones(obj, locked_groups):
     [...].matrix` in the RNA door reads back identical -- and the presenter
     scales the unit shape itself."""
     armature = obj.data
-    active = getattr(armature.bones, "active", None)
+    active = armature.bones.active
     active_name = active.name if active is not None else None
     bones = []
     for pchan in obj.pose.bones:
@@ -1319,19 +1190,8 @@ def _armature_bones(obj, locked_groups):
             "hide": bool(bone.hide),
             "length": float(bone.length),
             "matrix": [[float(v) for v in row] for row in pchan.matrix],
-            # BONE_SELECTED / BONE_DRAW_ACTIVE, the two flags
-            # `get_pchan_color_wire` branches on (`:760-795`).
-            #
-            # SELECTION IS THE POSE CHANNEL'S, and that is a MEASUREMENT rather
-            # than a preference: at this pin `Bone` carries `hide` and
-            # `hide_select` and NO `select` — `rna_def_bone_common`
-            # (`rna_armature.cc:1305`) declares none and `:1913` puts one on
-            # `EditBone` alone, so `bone.select` is an AttributeError. Asked of
-            # the engine itself, a `Bone`'s sel/hide properties are
-            # `['hide', 'hide_select']` and a `PoseBone`'s are
-            # `['hide', 'select']`. It is the same BIT either way — both write
-            # `Bone.flag`'s `BONE_SELECTED`, which is what the overlay's
-            # `bone.flag() & BONE_SELECTED` reads.
+            # PoseBone.select supplies BONE_SELECTED; Bone has no select RNA property.
+            # Selection and the active bone determine get_pchan_color_wire's colours.
             "select": bool(pchan.select),
             "active": bone.name == active_name,
             # BONE_DRAW_LOCKED_WEIGHT, set in weight-paint mode for every bone
@@ -1374,7 +1234,7 @@ def _bone_inherit(bone):
         flags.append("inherit_scale=%s" % bone.inherit_scale)
     if not bone.use_local_location:
         flags.append("use_local_location=False")
-    if getattr(bone, "use_relative_parent", False):
+    if bone.use_relative_parent:
         flags.append("use_relative_parent=True")
     return {"inherit": flags} if flags else {}
 
@@ -1458,10 +1318,25 @@ def _locked_weight_groups(view_layer):
     obj = view_layer.objects.active
     if obj is None or "WEIGHT_PAINT" not in obj.mode:
         return frozenset()
-    groups = getattr(obj, "vertex_groups", None) or ()
+    groups = obj.vertex_groups
     return frozenset(group.name for group in groups if group.lock_weight)
 
 
+def _warn_after_armature(view_layer):
+    """Warn once per object and stack when a modifier after Armature depends on the pose: exported vertices include its bind-time result, while the presenter subsequently moves only the skin."""
+    for obj in view_layer.objects:
+        if obj.type != "MESH":
+            continue
+        stack = [m for m in obj.modifiers if m.show_viewport]
+        at = next((i for i, m in enumerate(stack) if m.type == "ARMATURE" and m.object is not None), None)
+        if at is None or at == len(stack) - 1:
+            continue
+        after = ", ".join("%s (%s)" % (m.name, m.type) for m in stack[at + 1:])
+        warn("%s: the modifiers after its Armature (%s) are evaluated once at the pose it was sent in; as its bones "
+             "move in Play they are carried by the skin, not run again. Apply them, or move them "
+             "before the Armature, where the pose should change their result." % (obj.name, after))
+
+
 def _armatures(view_layer):
     """Every armature the view layer shows, with its display type and pose.
 
@@ -1496,39 +1371,12 @@ def _armatures(view_layer):
     return armatures
 
 
-def _weights(scene, view_layer, frame, known):
-    """PER-VERTEX WEIGHT for the active object's active vertex group.
-
-    Blender's own evaluation, `evaluate_vertex_weight`
-    (`draw/intern/mesh_extractors/extract_mesh_vbo_weights.cc:20-67`), in the
-    default state -- no Multi-Paint, no Lock-Relative -- so the weight is
-    `BKE_defvert_find_weight(dvert, active)` clamped to [0,1], and a vertex the
-    group does not weight is the ALERT value the fragment shader paints
-    `TH_VERTEX_UNREFERENCED` over. WHICH vertices alert is
-    `scene.tool_settings.vertex_group_user` (`rna_scene.cc:3428-3434`, default
-    ACTIVE): ACTIVE alerts a vertex with no weight in the ACTIVE group, ALL only
-    one with no weight in ANY group, NONE never.
-
-    THE ARRAY IS A REFERENCE WHEN NOTHING MOVED, the same contract the meshes
-    have (`blender-runtime-frame.ts`): it is the size of a vertex column and
-    every mutation presents, so it ships only when its CONTENT has changed since
-    the frame this session last sent.
-
-    ITS OWN DIGEST, NOT THE MESH'S REVISION, and that is a measurement rather
-    than a preference. The first shape of this function keyed the reference on
-    the mesh's export revision -- the number the geometry itself ships under --
-    and MEASURED live 2026-09-19: writing 640 deform weights through
-    `VertexGroup.add()` does not move it, because the door's revision follows
-    the depsgraph's GEOMETRY update record and a deform layer is not geometry.
-    So the array shipped once, all zeros, and every later present said
-    "unchanged" while the engine held a full ramp. The walk is unavoidable
-    either way -- an honest answer has to read every vertex -- so what the
-    reference saves is the TRANSFER, and a digest of the bytes is the only key
-    that cannot lie about them."""
+def _weights(scene, view_layer, known):
+    """Return the active vertex group’s weights and zero-weight alert flags using Blender’s default evaluation. Transfer typed arrays as base64 and identify retained arrays by their byte digest."""
     obj = view_layer.objects.active
     if obj is None or obj.type != "MESH" or obj.data is None:
         return None
-    group = getattr(getattr(obj, "vertex_groups", None), "active", None)
+    group = obj.vertex_groups.active
     if group is None:
         return None
     mesh = obj.data
@@ -1578,10 +1426,10 @@ class Session:
         self._known = {}
         # The last frame's accounting (`_present`), read by `dispatch`.
         self.last_shipped = None
-        # THE SESSION'S DOCUMENT: the `.blend` it opens at start and saves back
+        # THE SESSION'S DOCUMENT: the `.blend` it last opened and saves back
         # into. Absolute (the module filesystem mirrors the project at its own
         # host path) plus the project-relative spelling the tab needs to name
-        # the destination. None until `blender-start` states one.
+        # the destination. None until `open-document` names one.
         self.document = None
         self.document_relative = None
         # Set by a present that left the document behind the model; cleared by
@@ -1607,18 +1455,48 @@ class Session:
 
     def forget(self):
         self._known.clear()
+        self._action_revisions = {}
+
+    def renew(self):
+        """A NEW PRESENTATION SESSION FOR EACH FILE LOAD: the editor's open of a document, a
+        script's `open_mainfile` or `read_homefile` alike. A load restarts the revisions the export
+        door numbers its datablocks with, and the view keeps a mesh whose session and revision it
+        already holds (`blender-runtime-view.ts`), so another file's "Cube" at the same revision
+        would be drawn as the last one's. A new id makes the view clear what it held and refuse the
+        last file's late frames."""
+        self.session = "blender-%d" % time.time_ns()
+
+    def _kept_action_revisions(self, door):
+        """Keep action revisions stable across evaluation-only updates. An edit advances
+        _ACTION_EDITS and permits the native revision to replace the retained revision. All
+        writing requests, scripts, undo and redo count as edits; a file read resets the table."""
+        held = getattr(self, "_action_revisions", None)
+        if held is None:
+            held = self._action_revisions = {}
+        edits = _ACTION_EDITS["count"]
+        shown = {}
+        for name, revision in door.items():
+            known = held.get(name)
+            if known is None or (known[0] != revision and known[2] != edits):
+                held[name] = (revision, revision, edits)
+            else:
+                held[name] = (revision, known[1], edits)
+            shown[name] = held[name][1]
+        for name in [name for name in held if name not in door]:
+            del held[name]
+        return shown
 
     # -- the export
 
-    def _export(self, depsgraph=None):
+    def _export(self, depsgraph):
         """THE EXPORT IS THE C++ DOOR (`bpy_web_export.cc`).
 
         One call evaluates the scene, walks the depsgraph's own update record
         for the revisions, reads Blender's arrays straight into a side arena
         and answers a small JSON frame that names each column by
         `{offset, length, dtype, count, stride}`; the worker copies those bytes
-        off the module heap (`session-frame.mts`). Nothing large crosses as
-        JSON and nothing is staged through the filesystem.
+        from EXPORT_BUFFER_PATH (`session-frame.mts`). Large arrays cross
+        through that binary arena rather than JSON.
 
         WHAT THE DOOR DOES NOT DESCRIBE is reduced here and merged in: the
         WORLD, whose sky/gradient graph becomes the presenter's world
@@ -1645,18 +1523,11 @@ class Session:
         # that can see the ask can read the file.
         if EXPORT_BUFFER_PATH:
             options["buffer_path"] = EXPORT_BUFFER_PATH
-        # NOTICE, THEN PULL (`_present`): a changed mesh is named here and its columns are written
-        # one mesh at a time after, so the engine never holds every changed mesh's columns at once.
-        # An engine without the pull door ships them all in this call, as before.
-        if hasattr(_blender_web, "export_mesh"):
-            options["defer"] = True
-        if hasattr(_blender_web, "memory_reset_peak"):
-            _blender_web.memory_reset_peak()
-        if hasattr(_blender_web, "export_frame_chunked"):
-            exported = _blender_web.export_frame_chunked(json.dumps(options, ensure_ascii=False),
-                lambda: _asked({"checkpoint": "native-export"}))
-        else:
-            exported = _blender_web.export_frame(json.dumps(options, ensure_ascii=False))
+        # Pull changed resource columns individually after the frame describes them.
+        options["defer"] = True
+        _blender_web.memory_reset_peak()
+        exported = _blender_web.export_frame_chunked(json.dumps(options, ensure_ascii=False),
+            lambda: _asked({"checkpoint": "native-export"}))
         _mark("export:door")
         frame = json.loads(exported)
         del exported
@@ -1664,22 +1535,14 @@ class Session:
         error = frame.get("error")
         if error:
             raise RuntimeError("Blender export door: %s" % error)
-        # THE SESSION OWNS BOTH HALVES OF ITS IDENTITY. The presenter reads
-        # `(session, revision)` as a PAIR and refuses outright a frame whose
-        # revision went backwards under a name it already holds ("The runtime
-        # frame is older than the displayed model"). The door's own counter is
-        # per-`Main` -- it starts over on every file read, which is what its
-        # per-datablock revisions must do -- while the session name does not, so
-        # leaving the two in different hands splits the pair the moment a script
-        # opens a .blend. MEASURED 2026-09-18 through the editor tab:
-        # `read_factory_settings` took the door's counter from 40 back to 1 and
-        # nine of 17-workshop-interior's 63 calls died on that refusal.
+        # Keep session and revision under one owner. The native per-Main counter restarts on file reads, while the session’s frame revision must remain monotonic.
         self.revision += 1
         frame["revision"] = self.revision
+        frame["actions"] = self._kept_action_revisions(frame["actions"])
         # THE GRAPHS JOIN THE DOOR'S MATERIALS, each image a graph samples
         # named at the revision the door holds it at (`graph_images`, which is
         # the session's to read and not part of the presenter's frame).
-        revisions = frame.pop("graph_images", {})
+        revisions = frame.pop("graph_images")
         for name, graph in graphs.items():
             if name not in frame["materials"]:
                 continue
@@ -1694,9 +1557,7 @@ class Session:
         # automatic one is the evaluated bounds the presenter already holds.
         if graphs:
             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.
+            # Index scene objects by name once for the export-row lookup.
             by_name = {obj.name: obj for obj in scene.objects}
             for row in frame["objects"]:
                 if not any(m in graphs for m in row["materials"] if m is not None):
@@ -1725,13 +1586,21 @@ class Session:
         # by (`View3DShading.color_type` MATERIAL reads `Material.diffuse_color`, `roughness`,
         # `metallic`; `workbench_world_light_lib.glsl`), not its node graph.
         for entry in frame["materials"].values():
-            material = bpy.data.materials.get(entry.get("name", ""))
+            material = bpy.data.materials.get(entry["name"])
             if material is not None:
                 entry["viewport"] = {
                     "color": [float(v) for v in material.diffuse_color],
                     "roughness": float(material.roughness),
                     "metallic": float(material.metallic),
                 }
+                # Settings > Backface Culling > Shadow: a shadow from the faces turned to the light
+                # only. Off (the default), EEVEE casts from both faces of every surface.
+                entry["backface_culling_shadow"] = bool(material.use_backface_culling_shadow)
+                # Settings > Backface Culling > Camera: the surface's back faces are not drawn (the
+                # glTF importer sets it on every single-sided material). Transparency Overlap draws
+                # all faces of a blended surface in one pass (on, the default), or only the nearest (off).
+                entry["backface_culling"] = bool(material.use_backface_culling)
+                entry["transparency_overlap"] = bool(material.use_transparency_overlap)
         graph = depsgraph if depsgraph is not None else bpy.context.evaluated_depsgraph_get()
         # ONE NAME, TWO OBJECTS: Blender tells a linked object from a local one (or from another
         # file's) by its library as well as its name; the presenter knows them by name alone and
@@ -1763,8 +1632,8 @@ class Session:
         # (`overlay_cursor.hh`). Its MATRIX, because the overlay's axis lines
         # turn with the cursor's rotation in whichever `rotation_mode` it has.
         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.
+        # Inspection overlays are derived from the evaluated scene and view layer.
+        # Weight-array reuse is keyed by their own byte digest.
         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`).
@@ -1778,36 +1647,52 @@ class Session:
         # WHAT THE OVERLAY DRAWS FOR AN EMPTY (`overlay_empty.hh`): its display type and size.
         frame["empties"] = {obj.name: _empty_display(obj) for obj in scene.objects if obj.type == "EMPTY"}
         frame["view"] = _saved_view()
+        # A WORLD background is the World's Viewport Display colour (`World.color`).
+        if frame["view"] is not None:
+            frame["view"]["world_color"] = [float(v) for v in scene.world.color] if scene.world else None
+        # THE SCENE'S COLOUR MANAGEMENT, with the frame it colours: Rendered and Material Preview
+        # are drawn through it (`blender-display-transform.ts`), so it travels with every present
+        # and the tab never draws a frame through settings it has not been sent yet.
+        # HOW THE VIEWPORT ANTI-ALIASES: Solid by Workbench's accumulation (the scene's own
+        # `display.viewport_aa` when Workbench renders it, the Preferences' otherwise) and
+        # Rendered by EEVEE's film (`taa_samples` over `filter_size`).
+        frame["sampling"] = {
+            "engine": scene.render.engine,
+            "viewport_aa": scene.display.viewport_aa,
+            "taa_samples": int(scene.eevee.taa_samples),
+            "filter_size": float(scene.render.filter_size),
+        }
+        view_settings = scene.view_settings
+        frame["display"] = {
+            "view_transform": view_settings.view_transform,
+            "look": view_settings.look or "None",
+            "exposure": float(view_settings.exposure),
+            "gamma": float(view_settings.gamma),
+            "display_device": scene.display_settings.display_device,
+        }
         frame["units"] = {
             "system": scene.unit_settings.system,
             "scale_length": float(scene.unit_settings.scale_length),
         }
         frame["armatures"] = _armatures(view_layer)
+        _warn_after_armature(view_layer)
         # THE SCENE'S CLOCK beside the frame number: what a Timeline draws and a mixer maps time by.
         frame["clock"] = {"start": int(scene.frame_start), "end": int(scene.frame_end),
                           "fps": float(scene.render.fps) / float(scene.render.fps_base or 1.0)}
         # ACTIONS NOTHING KEEPS: no user and no fake user, so the next save drops them (Blender's own
         # rule). A game that plays one is told before it vanishes.
         frame["unkeptActions"] = sorted(a.name for a in bpy.data.actions if a.users == 0 and not a.use_fake_user)
-        frame["weights"] = _weights(scene, view_layer, frame, self._known)
-        warnings = list(frame.get("warnings", ()))
+        frame["weights"] = _weights(scene, view_layer, self._known)
+        warnings = list(frame["warnings"])
         warnings.extend(_WARNINGS)
         del _WARNINGS[:]
         frame["warnings"] = warnings
         return frame
 
     def present(self, capture=None):
-        """Hand the tab a frame, and give back whatever it answered with.
-
-        A render's photograph comes back through this same door, which is why
-        it blocks: `bpy.ops.render.render()` is waiting on the pixels.
-
-        THE PRESENTER IS THE AUTHORITY ON WHAT IT HOLDS, and it says so by
-        name: a page that reloaded under a still-running session holds none of
-        this session's geometry while `_known` says it was sent. The record is
-        dropped and the frame goes out again IN FULL -- the same answer
-        `runtime_session.present` gives, for the same reason.
-        """
+        """Present a frame and return the tab’s answer. Rendering blocks on this same channel for its
+        pixels. Reconcile resource identity with the presenter’s held frame; when a document
+        reload has discarded it, resend the required resources in full."""
         try:
             return self._present(capture)
         except RuntimeError as error:
@@ -1816,11 +1701,12 @@ class Session:
             self._known.clear()
             return self._present(capture)
 
-    def _present(self, capture=None, depsgraph=None):
+    def _present(self, capture, depsgraph=None):
         known = dict(self._known)
         _mark("present:before")
         frame = self._export(depsgraph)
         _mark("present:exported")
+        self._carry_browser_decoded_images(frame)
         pulled = self._pull(frame, render=depsgraph is not None)
         _mark("present:pulled")
         self._drop_unreachable_textures(frame)
@@ -1840,22 +1726,14 @@ class Session:
             # its value also depends on native undo initialization/checkpoints.
             "dirty": bool(bpy.data.is_dirty),
         }
-        # A PRESENT DOES NOT MAKE THE DOCUMENT STALE; a request that can change
-        # the model does (`mark_changed`, from `dispatch`). The predicate was the
-        # present itself, and a present also runs with no change behind it --
-        # opening the document, rebinding its view. MEASURED 2026-09-24 on
-        # `arena`: opening a Model document and doing nothing rewrote its
-        # `.blend` with 556 bytes changed, so a file a person only looked at read
-        # as modified. `columns`/`images` above stay the wrong question for the
-        # same reason as before: a MOVE ships zero columns and a DELETION ships
-        # nothing, and both come from a request `mark_changed` sees.
+        # Only a request that can mutate the model marks the document changed. A present or view rebind alone must not trigger a save.
         for key, mesh in frame["meshes"].items():
             self._known["mesh:" + key] = mesh["revision"]
         for name, image in frame["images"].items():
             self._known["image:" + name] = image["revision"]
         # The weight array follows the meshes' own rule: recorded as sent, so
         # the next present ships a reference instead of the bytes.
-        weights = frame.get("weights")
+        weights = frame["weights"]
         if weights is not None:
             self._known["weights:%s:%s" % (weights["object"], weights["group"])] = (
                 weights["digest"])
@@ -1880,18 +1758,11 @@ class Session:
         self._reconcile_with_presenter(answer, frame)
         return answer
 
-    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
-        columns out of the heap (`hold`), then each mesh's columns and each picture's pixels in
-        turn, copying each out before the next is written (every pull frees the one before). The
-        engine's peak is the scene plus one datablock's columns, not plus every changed one's.
-
-        The pieces come back into the frame as the door would have written them: a picture with no
-        readable pixels leaves `images` with its warning, as it did when the frame carried it
-        whole, so `_drop_unreachable_textures` reads the same frame either way. Answers whether
-        anything was pulled; the worker then presents the frame with its pieces."""
+    def _pull(self, frame, render):
+        """Pull deferred mesh and image columns one datablock at a time after the worker copies the
+        frame header. Copy each resource before the next pull releases its columns. Remove
+        unreadable images with their warnings before texture reconciliation. Return whether any
+        resource was pulled."""
         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 and not render:
@@ -1909,7 +1780,7 @@ class Session:
                 piece = json.loads(door(json.dumps(options, ensure_ascii=False)))
                 if piece.get("error"):
                     raise RuntimeError("Blender export door: %s" % piece["error"])
-                frame["warnings"].extend(piece.get("warnings", []))
+                frame["warnings"].extend(piece["warnings"])
                 if piece[kind] is None:
                     del frame["images"][key]
                     continue
@@ -1920,8 +1791,6 @@ class Session:
         """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()
@@ -1930,20 +1799,33 @@ class Session:
         finally:
             _blender_web.end_render_export()
 
+    def _carry_browser_decoded_images(self, frame):
+        """Send WebP images as their encoded file bytes when Blender has no decoder and the browser can decode them. Revision them by the bytes and include them as deferred images."""
+        carried = frame["images"]
+        names = set()
+        for material in frame["materials"].values():
+            for slot in ("texture", "roughness_texture", "normal_texture"):
+                reference = material.get(slot)
+                if reference is not None:
+                    names.add(reference["image"]["name"])
+            graph = material.get("graph")
+            for node in graph["nodes"].values() if graph is not None else ():
+                image = node["props"].get("image")
+                if image is not None:
+                    names.add(image["name"])
+        for name in names:
+            if name in carried:
+                continue
+            data = _browser_decoded_bytes(bpy.data.images.get(name))
+            if data is None:
+                continue
+            revision = int.from_bytes(hashlib.sha256(data).digest()[:4], "big") & 0x7fffffff
+            if self._known.get("image:" + name) == revision:
+                continue
+            carried[name] = {"deferred": True, "revision": revision}
+
     def _send_encoded_image(self, key, deferred):
-        """A PICTURE AS ITS FILE'S OWN BYTES, when that is exactly what the frame would carry.
-
-        A modelling program keeps a picture compressed as its file and lets the GPU hold the
-        decoded texture; only this side's raster door decoded every picture into RGBA and shipped
-        that. MEASURED 2026-09-29 on the Stoneguard bridge: its 84 material pictures are 171 MB as
-        their packed files and 1,343 MB as RGBA, and the hosted tab's renderer passed 10 GB while
-        it opened. So a picture whose texels ARE its file -- a plain file or packed PNG or JPEG,
-        not edited in this session -- is written to the engine's filesystem as those bytes and
-        crosses as they are (`worker.ts`), decoded by the browser. The rest keep the raster door:
-        a key with `@` (a roughness remap bakes new texels), a picture painted here (`is_dirty`),
-        a UDIM or generated one, or bytes neither decoder reads.
-
-        Answers whether it was sent."""
+        """Send unchanged file-backed encoded images directly when their bytes represent the frame’s texels. Painted, generated and UDIM images retain the raw-pixel path. Return whether the image was sent."""
         if "@" in key:
             return False
         image = bpy.data.images.get(key)
@@ -1957,11 +1839,8 @@ class Session:
                     data = fh.read()
         except (OSError, TypeError, ValueError):
             return False
-        if data[:8] == b"\x89PNG\r\n\x1a\n":
-            mime = "image/png"
-        elif data[:3] == b"\xff\xd8\xff":
-            mime = "image/jpeg"
-        else:
+        mime = _encoded_mime(data)
+        if mime is None:
             return False
         path = os.path.join(ROOT, "encoded-image.bin")
         with open(path, "wb") as fh:
@@ -1970,7 +1849,9 @@ class Session:
             _asked({"image": key, "piece": {
                 "revision": deferred["revision"],
                 "mime": mime,
-                "colorspace": "sRGB" if image.colorspace_settings.name == "sRGB" else "data",
+                # (a picture this Blender could not load has no colour space name; an 8-bit file's default is sRGB)
+                "colorspace": "sRGB" if image.colorspace_settings.name == "sRGB" or (
+                    image.colorspace_settings.name == "" and not image.colorspace_settings.is_data) else "data",
                 "encodedPath": path,
             }})
         finally:
@@ -1978,137 +1859,43 @@ class Session:
         return True
 
     def _drop_unreachable_textures(self, frame):
-        """A picture the export could not read is a WARNING, not a refusal.
-
-        The door writes an image by reading its ibuf; an image it cannot read
-        is named by the door (`image <name> has no readable pixels`) and left
-        out of the frame -- while the MATERIAL still carries the texture
-        reference. The presenter then refuses BY NAME
-        (`RUNTIME_FRAME_UNKNOWN_IMAGE`), and that refusal cannot be satisfied:
-        re-sending the frame in full re-exports the same unreadable image, so
-        the second present dies the same way and the whole call fails.
-
-        WHY an image is unreadable is the EXPORT DOOR's question and is not
-        answered here, so this says only what it observed. Three mechanisms
-        that would explain it were measured in the tab on 2026-09-18 and all
-        three SHIP correctly, so none of them is it: a `images.new` image
-        filled through `pixels.foreach_set`; a PNG written with `image.save()`
-        and read back with `images.load`; and the same PNG written and read
-        through a `replay_fs`-style symlinked run directory.
-
-        MEASURED 2026-09-18: the five-model battery's `17-workshop-interior`,
-        `18-riverside-bridge`, `19-tram-stop` and `20-rigged-courier` each got
-        ZERO calls, refused inside `blender-start` -- `bind_document` opened
-        the document the previous model wrote, whose textures live OUTSIDE the
-        project (another folder of the machine that wrote it) and
-        are in no fresh worker's filesystem.
-
-        THE PRESENTER'S REFUSAL IS RIGHT AND STAYS. It answers "the record says
-        I hold this and I do not", which is the desync `_reconcile_with_presenter`
-        exists for. What is wrong is asking it about a picture the session
-        NEVER SENT AND CANNOT SEND. So a texture reference naming an image that
-        is in neither this frame nor `_known` is dropped here, and the
-        mechanism is named once (`warn`) -- the material falls back to its own
-        socket colour, which is this file's stated rule for a capability the
-        export cannot reach.
-
-        A name `_known` still holds is left alone: that IS the desync case, and
-        the refusal it raises is the signal that clears the tables and re-ships.
-        """
-        carried = frame.get("images") or {}
-        for material in (frame.get("materials") or {}).values():
+        """Warn for unreadable images and mark their material references as missing so the presenter can draw Blender’s missing-image colour. Unknown previously sent images still trigger desynchronization recovery."""
+        carried = frame["images"]
+        for material in frame["materials"].values():
             for slot in ("texture", "roughness_texture", "normal_texture"):
                 reference = material.get(slot)
-                if not isinstance(reference, dict):
+                if reference is None:
                     continue
-                name = (reference.get("image") or {}).get("name")
-                if name is None or name in carried or ("image:" + name) in self._known:
+                name = reference["image"]["name"]
+                if name in carried or ("image:" + name) in self._known:
                     continue
                 del material[slot]
-                # THE TWO CAUSES THIS WARNING HAS HAD, and the one line that
-                # tells them apart -- because the text names `write_image` and
-                # a reader reasonably concludes the EXPORT is broken, which
-                # twice it was not. `write_image` says "no readable pixels"
-                # when `BKE_image_acquire_ibuf` hands back nothing, and the
-                # image is usually the thing at fault, not the export:
-                #
-                #   1. THE IMAGE NEVER LOADED. `source == 'FILE'` and the
-                #      filepath does not resolve inside the program -- a
-                #      relative path saved against a directory the guest
-                #      filesystem does not carry is the worked case. Measured
-                #      2026-09-19 (WS-W): a probe's `models/model.blend`
-                #      raised 18 of these, and every one of its images read
-                #      `has_data False, size (0, 0), len(pixels) 0`.
-                #   2. THE PROGRAM WAS OUT OF MEMORY. Measured 2026-09-19 on
-                #      the WALI skew: `16-market-courtyard` raised eight of
-                #      these while the module was linked
-                #      `-Wl,--max-memory=1073741824`, and raising that link to
-                #      4 GiB made all eight vanish -- same recording, same
-                #      staged textures, same door, 95/95 calls and a silent
-                #      console.
-                #
-                # So before suspecting the export, ask the images:
-                #   for im in bpy.data.images:
-                #       print(im.name, im.source, tuple(im.size), im.has_data,
-                #             im.filepath)
-                # (0, 0) with has_data False is cause 1 or 2, never the export.
+                # Warn when neither this frame nor the retained record can supply the image.
                 warn("material %s: the export could not read the picture %s, so this "
                      "frame draws the material without it. The image is in neither "
                      "this frame nor the presenter's record, so nothing can be "
                      "re-sent to satisfy it; the export door is what knows why "
                      "(`bpy_web_export.cc::write_image`)."
-                     % (material.get("name", "?"), name))
-
-            # A MATERIAL'S NODE GRAPH samples its pictures through Image Texture nodes, which
-            # the slots above do not cover: a graph naming a picture that was never sent had
-            # the presenter refuse the whole frame, so a file whose textures are missing did
-            # not open at all (measured on `16-market-courtyard` saved with its textures
-            # outside the project). Blender opens such a file and draws each missing picture
-            # magenta; the node is kept, marked, and the presenter draws it so.
+                     % (material["name"], name))
+
+            # Mark unreadable node-graph images as missing, retaining the nodes so the presenter draws them magenta.
             graph = material.get("graph")
-            for node in ((graph or {}).get("nodes") or {}).values():
-                props = node.get("props") or {}
+            for node in graph["nodes"].values() if graph is not None else ():
+                props = node["props"]
                 image = props.get("image")
-                name = image.get("name") if isinstance(image, dict) else None
-                if name is None or name in carried or ("image:" + name) in self._known:
+                if image is None:
+                    continue
+                name = image["name"]
+                if name in carried or ("image:" + name) in self._known:
                     continue
                 props["image"] = None
                 props["image_missing"] = True
                 warn("material %s: the picture %s is not readable in this program (%s), so it "
                      "draws magenta, as Blender draws a missing image."
-                     % (material.get("name", "?"), name, "a path outside the project, or no pixels"))
+                     % (material["name"], name, "a path outside the project, or no pixels"))
 
     def _reconcile_with_presenter(self, answer, frame):
-        """THE PRESENTER'S REPORT OUTRANKS THE SESSION'S RECORD.
-
-        `_known` is what this session BELIEVES the tab holds, accumulated one
-        present at a time. The presenter is what actually holds it, and the two
-        come apart with neither side failing: the worker and this Python
-        session belong to the TAB (`blender-runtime-host.ts` keeps one
-        `BlenderRuntime`), while the presenter belongs to the Model DOCUMENT --
-        so rebuilding that document (closing and reopening it, a play stall
-        that remounts it) leaves a view holding nothing under a session whose
-        tables say everything crossed. Every later frame then ships references
-        to bytes that are gone.
-
-        MEASURED 2026-09-18, the battery's `19-tram-stop` and `20-rigged-courier`:
-        both got zero calls, refused at `blender-start` with
-        `RUNTIME_FRAME_UNKNOWN_IMAGE: the presenter does not hold runtime image
-        wood_planks_roughness.png@roughness(...) (revision 1)`.
-
-        So every present's answer carries `held` -- what the presenter held
-        BEFORE this frame (`protocol.ts`) -- and a holding that is not this
-        session's means the accumulated record describes a presenter that is
-        gone. What survives is exactly what THIS frame carried: a mesh whose
-        columns crossed and every image in it (there is no unchanged-image
-        form). A mesh that went as a reference did not cross and is dropped.
-
-        An ABSENT `held` is not a report and is judged as nothing: an older
-        presenter must not be read as "holds nothing" on every frame.
-
-        `_known` is only ever narrowed here, never widened, so the correction
-        costs one re-ship and can never suppress one.
-        """
+        """Reconcile the session’s known resources with the presenter’s held frame. A reopened document can discard data while the worker survives; narrow known resources so missing data is sent again."""
         if not isinstance(answer, dict) or "held" not in answer:
             self.presenter_held = "unreported"
             return
@@ -2122,7 +1909,7 @@ class Session:
                 self._known["mesh:" + key] = mesh["revision"]
         for name, image in frame["images"].items():
             self._known["image:" + name] = image["revision"]
-        weights = frame.get("weights")
+        weights = frame["weights"]
         if weights is not None and not weights.get("unchanged"):
             self._known["weights:%s:%s" % (weights["object"], weights["group"])] = (
                 weights["digest"])
@@ -2132,28 +1919,36 @@ 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 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.
+        The session holds one document at a time: the one the editor last opened
+        here (`open-document`), and it moves otherwise 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
         retaken), and the one present afterwards is what puts the reopened
-        model on the tab's screen.
+        model on the tab's screen, as a new presentation session (`renew`).
         """
         self.document_relative = relative_path
         self.document = os.path.join(self.project, relative_path)
         self._foreign = False
         self._foreign_said = False
+        self._outside_file = None
         if not os.path.exists(self.document):
-            return {"document": relative_path, "opened": False}
+            # A DOCUMENT NOT YET WRITTEN OPENS EMPTY: Blender's empty file
+            # (`read_homefile(use_empty=True)`: its scenes, windows and workspaces alone), loaded as the session's
+            # own open, so its first save writes the new model, never the factory startup's cube, light and camera
+            # a fresh worker holds, or the file it held before.
+            self._binding = True
+            try:
+                bpy.ops.wm.read_homefile(use_empty=True)
+            finally:
+                self._binding = False
+            return {"document": relative_path, "opened": False, "presented": self._present_opened(relative_path)}
         _asked({"checkpoint": "document-open"})
         _mark("open:before")
-        checkpointed_read = hasattr(_blender_web, "set_read_checkpoint")
-        if checkpointed_read:
-            _blender_web.set_read_checkpoint(lambda: _asked({"checkpoint": "file-read"}))
+        _blender_web.set_read_checkpoint(lambda: _asked({"checkpoint": "file-read"}))
         self._binding = True
         try:
             bpy.ops.wm.open_mainfile(filepath=self.document)
@@ -2163,32 +1958,46 @@ class Session:
             raise
         finally:
             self._binding = False
-            if checkpointed_read:
-                _blender_web.set_read_checkpoint(None)
+            _blender_web.set_read_checkpoint(None)
         _mark("open:after")
         _asked({"checkpoint": "document-opened"})
         size = os.path.getsize(self.document)
-        # THE STAGED COPY GOES ONCE BLENDER HAS READ IT. It sits in the engine's heap (WasmFS keeps
-        # file data in linear memory) and nothing reads it again: the load took everything into
-        # Blender's own memory, packed pictures included, and the next save writes the path anew.
-        # Freed before the first present, its bytes serve that present's evaluation instead of
-        # raising the heap's high-water mark by the file's size (307 MB for the Stoneguard file).
-        # The worker still holds the host's stamp for it, so it is not staged in again.
+        # Remove the staged .blend after Blender loads it to release its WasmFS bytes before
+        # presentation. The worker keeps its host stamp, and the next save rewrites the file.
         os.remove(self.document)
-        self.present()
-        # The load did not dirty anything: what is in memory IS the file.
-        self.save_due = False
+        presented = self._present_opened(relative_path)
         return {"document": relative_path, "opened": True,
                 "objects": len(bpy.data.objects),
-                "size": size}
+                "size": size, "presented": presented}
+
+    def _present_opened(self, relative_path):
+        """The first present of a document just opened, and whether it was taken.
+
+        A DOCUMENT BLENDER OPENED IS OPEN, whatever its first present does: a present that
+        failed the open would leave a saved document unopenable and every MCP call refused.
+        The model is in Blender, so the session keeps it and says loudly that the view is behind;
+        the next edit presents again, and can remove whatever the presenter could not take.
+        """
+        presented = True
+        try:
+            self.present()
+        except Exception as thrown:  # noqa: BLE001
+            presented = False
+            if _another_document_shown(thrown):
+                # A document switched away during opening may refuse this frame. It presents again when it becomes active.
+                _say("%s is open in Blender; the editor is showing another document, so it is presented when "
+                     "it is shown again" % relative_path)
+            else:
+                _say("@@VOLTER-ERROR %s is open in Blender, but its first present failed, so the Model "
+                     "document does not show it yet: %r" % (relative_path, thrown))
+        # The load did not dirty anything: what is in memory IS the file.
+        self.save_due = False
+        return presented
 
     def loaded(self):
-        """A FILE WAS LOADED (`_load_post`). The session's own open of its document is the one
-        load that leaves the document's model in memory; any other replaces it with another
-        file's (`read_homefile` is Blender's File > New), and the session used to save that over
-        the document: a script that ran `read_homefile` on its own, meaning to Save As a new
-        piece next, emptied the open level on disk. MEASURED 2026-10-08 in the editor's Blender:
-        a document with four objects was saved with none."""
+        """Track file loads that replace the session’s document model. The session’s own document
+        open retains ownership; other loads suspend saving until the model belongs to the document
+        again."""
         if self._binding:
             return
         self._foreign = True
@@ -2196,38 +2005,16 @@ class Session:
 
     def mark_changed(self):
         """A request that can change the model ran: the next present carries
-        `saveDue`, and the tab saves after an idle second."""
+        `saveDue`, and the document is dirty until the workbench saves it. (Its actions too: `_kept_action_revisions`.)"""
+        _ACTION_EDITS["count"] += 1
         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.
-        """
+        """Follow Blender’s open file after execute. Save As and open_mainfile can move the bound
+        document to another project .blend; saving a copy preserves the current binding. Return
+        None when unchanged, a moved answer for a project path, or an outside-project refusal once
+        per file. Never save another file’s in-memory model over the bound document."""
         if self.document is None:
             return None
         if not bpy.data.filepath:
@@ -2271,94 +2058,7 @@ class Session:
                            self.document_relative)}
 
     def save_document(self):
-        """Write the document -- Blender's own format, by Blender's own operator.
-
-        ONE WRITE, AND IT DOES NOT TOUCH THE SCRIPT'S DATABLOCKS. The save used
-        to run `bpy.ops.file.make_paths_relative()` and then write a second
-        time, so that a document would reopen on another machine. That rewrote
-        the filepath of every image in `bpy.data` -- datablocks the SCRIPT
-        owns and did not ask to have moved. MEASURED 2026-09-18,
-        `16-market-courtyard` seq 10: the model loads its textures from an
-        absolute host path the harness maps into the sandbox, the first idle
-        save at seq ~8 turned those filepaths into `//../../..` relative to
-        `/project/models/`, and the next texture write resolved against the
-        document's directory instead and died in Emscripten's FS with
-        `ErrnoError`. Nine of the courtyard's 95 calls ran. The document the
-        run left behind then named images that no longer resolved, so the three
-        models that opened it afterwards got zero calls apiece.
-
-        `relative_remap` IS FALSE, and that is a measurement rather than a
-        reading of the operator's documentation. `save_as_mainfile`'s
-        `relative_remap` is described as remapping RELATIVE paths so they stay
-        valid from a new location; on this build it also rewrites ABSOLUTE
-        ones. MEASURED 2026-09-18 in the tab, four cells, one image loaded from
-        an absolute path outside the project, `/outside/wsh-outside/textures/wsh_abs.png`:
-
-          relative_remap  use_relative_paths  img.filepath after the save
-          False           True                /outside/.../wsh_abs.png
-          False           False               /outside/.../wsh_abs.png
-          True            False               //../../../wsh-outside/.../wsh_abs.png
-          True            True                //../../../wsh-outside/.../wsh_abs.png
-
-        `relative_remap` alone decides it and the preference does not enter.
-        So True is the same rewrite `make_paths_relative` was, arriving through
-        a different door, and False is the only value that leaves a script's
-        paths as the script wrote them. "Reopens on another machine" is served
-        by a script loading its project files through project-relative paths in
-        the first place, which is the script's choice to make.
-
-        `copy` IS SET, and it is what makes "the session mutates nothing" true
-        of the save as a whole rather than only of the path flag above. Without
-        it `save_as_mainfile` MOVES the file: `bpy.data.filepath` becomes the
-        document, so a script that saved to its own path has been retargeted,
-        and every RELATIVE path it wrote now resolves from the document's
-        directory instead of the one the script chose.
-
-        MEASURED 2026-09-18 on `18-riverside-bridge`, which is an ordinary
-        thing for a script to do: seq 26 is
-        `save_as_mainfile(filepath=os.path.join(ITEM, 'model.blend'))`, which
-        left its nine textures as `//inputs/<name>.png` relative to ITEM, and
-        seq 27-34 call `save_mainfile()` again. With the session's save moving
-        `bpy.data.filepath` to `models/model.blend` in between, those paths
-        resolved to `models/inputs/` — nothing — and each later save rebased
-        the already-relative path again, compounding to
-        `//../../probes/probes/ws-h-probe/models/inputs/bark_color.png`. Every
-        one of the bridge's pictures was unreadable from there, so the export
-        could not write them and the model presented untextured.
-
-        The two flags are one rule, and neither alone is it: `relative_remap`
-        False is what leaves an ABSOLUTE path absolute, and `copy` is what
-        leaves a RELATIVE one resolving from the base the script gave it.
-
-        What this costs, stated: a script's own `bpy.ops.wm.save_mainfile()`
-        writes where the SCRIPT pointed it, not the session's document. That is
-        the script's choice to make, which is the whole of the rule.
-
-        `compress` IS stated, and that is the whole reason it appears here.
-        MEASURED 2026-09-18 in the tab: the operator's own RNA default is
-        False, but `save_as_mainfile` takes its value from
-        `preferences.filepaths.use_file_compression`, which is True in this
-        build -- so the first documents this lane wrote came out Zstandard
-        (`file` says "Zstandard compressed data", `head -c 12` is not
-        `BLENDER`). Blender reads either back, so nothing was broken; what was
-        wrong is that the BYTES of a file the project commits depended on a
-        per-machine preference. A document states its own format.
-
-        THE FORMAT IT STATES IS COMPRESSED (Zstandard, Blender's own). Measured
-        2026-10-08 on a character with a 43-clip library (1.3 million keys): the
-        uncompressed write was 101.9 MB, compressed 12.8 MB, and the save itself
-        took the same time (0.07-0.17 s against 0.10-0.14 s). A game scene with
-        that character was 120 MB uncompressed, past GitHub's 100 MB file limit,
-        and 17 MB compressed. Blender reads both.
-
-        THE SAVE'S CHUNKED TRANSPORT READS THE BYTES (`document-chunks.mts`): it
-        sends the server only the chunks it lacks, and that reuse was measured
-        on uncompressed files. Measured again with compression, same character,
-        one small edit per save after the first: uncompressed sent 4.19 MB (one
-        chunk) in about 1.4 s end to end; compressed sent 2.31 MB in about
-        0.26 s. Zstandard compresses in independent blocks, so an edit still
-        changes part of the file, not all of it.
-        """
+        """Save Blender’s native document without rewriting script-owned datablock paths. Use relative_remap=False and compression; the worker returns the saved bytes to the bound project file."""
         self.save_due = False
         if self.document is None:
             return {"saved": False, "reason": "no-document"}
@@ -2366,19 +2066,9 @@ class Session:
             # Not the document's model (`loaded`): writing it would replace the file with another.
             return {"saved": False, "reason": "not-the-document", "document": self.document_relative,
                     "holds": bpy.data.filepath or "a new, untitled file"}
-        # `bpy.data.is_dirty` IS NOT A PREDICATE HERE, and this is the measurement
-        # rather than a preference. Before native undo initialization it stayed
-        # False even after a script built fourteen objects; with explicit undo
-        # checkpoints it can stay True across read-only operations. It is not
-        # a reliable change detector for this request-driven background session.
-        #
-        # It was briefly used to skip a redundant write, and it froze the
-        # document after its first save -- a reopened session could model all
-        # day and never write again. The predicate is `mark_changed`'s instead:
-        # a request that can change the model ran. Coarser than a diff (a
-        # read-only script rewrites the file once), bounded by the tab's
-        # idle-second debounce, and it cannot miss a change. The reading still
-        # rides in the answer, as an instrument.
+        # Save requests follow mark_changed, which records potentially mutating
+        # operations. bpy.data.is_dirty is diagnostic: native undo checkpoints
+        # do not reliably track this background session's mutations.
         dirty = bool(bpy.data.is_dirty)
         existed = os.path.exists(self.document)
         directory = os.path.dirname(self.document)
@@ -2397,12 +2087,38 @@ class Session:
                 "document": self.document_relative,
                 "size": os.path.getsize(self.document),
                 "revision": self.revision,
-                # The instruments a reader needs to judge the save: what
-                # Blender thought of the file's state, and whether this was the
-                # first write.
+                # Report the dirty state and whether the document already existed before this
+                # write.
                 "dirty": dirty, "existed": existed}
 
 
+def _encoded_mime(data):
+    """The MIME type of a picture file the browser decodes and the tab takes as it is, else None."""
+    if data[:8] == b"\x89PNG\r\n\x1a\n":
+        return "image/png"
+    if data[:3] == b"\xff\xd8\xff":
+        return "image/jpeg"
+    if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
+        return "image/webp"
+    return None
+
+
+def _browser_decoded_bytes(image):
+    """A file image's bytes when this Blender holds no pixels for it and the file is one the browser decodes
+    (WebP: the editor's Blender is built without it), else None."""
+    if image is None or image.source != "FILE" or image.is_dirty or image.has_data:
+        return None
+    try:
+        if image.packed_file is not None:
+            data = bytes(image.packed_file.data)
+        else:
+            with open(bpy.path.abspath(image.filepath), "rb") as fh:
+                data = fh.read()
+    except (OSError, TypeError, ValueError):
+        return None
+    return data if _encoded_mime(data) == "image/webp" else None
+
+
 SESSION = Session()
 
 
@@ -2421,12 +2137,7 @@ def _drop(path):
         _say("@@VOLTER-WARN the session could not remove its own %s: %r" % (path, error))
 
 
-# HOW OFTEN TO LOOK, by how recently something happened. A present's answer
-# and the next call of a gesture are usually a few milliseconds away, and a
-# fixed 2 ms sleep put a whole sleep into each of them: a no-op execute spent
-# 6-7 ms of its 8-10 ms coming back, most of it the present's `ask` waiting out
-# sleeps on both skews (measured 2026-09-28). Brisk for 50 ms after activity,
-# then the old 2 ms, so an idle session lists its directory no more than before.
+# Poll briskly for 50 ms after activity, then sleep 2 ms between idle directory reads.
 _BRISK_SECONDS = 0.05
 
 
@@ -2434,10 +2145,15 @@ def _pause(since):
     time.sleep(0.0002 if time.monotonic() - since < _BRISK_SECONDS else 0.002)
 
 
+def _another_document_shown(thrown):
+    """Whether a refusal is the tab's for a document it does not show (`blender-runtime-host.ts`'s
+    `modelDocumentConflict`, "Blender is editing <held>, but the editor is showing <other>"): the editor moved on to
+    another document while this one was opening, which is no fault of the document's."""
+    return "but the editor is showing" in str(thrown)
+
+
 def _asked(payload):
-    """`ask`, failing as the tab failed: a piece the worker could not take comes back as
-    `{"error": ...}`, and a pull that read past it presented a frame missing that piece, refused
-    later under another name ("deferred and never pulled")."""
+    """Raise the tab's structured error before a refused piece can enter a frame."""
     answer = ask(payload)
     if isinstance(answer, dict) and answer.get("error"):
         raise RuntimeError("The tab refused %s: %s" % (
@@ -2449,11 +2165,9 @@ def ask(payload):
     """Block until the tab answers. The worker's own thread is free while this
     waits; only the Blender pthread is held, which is where the operator is.
 
-    THE REQUEST IS OURS AND THE REPLY IS THE PAGE'S -- see the header's
-    ownership table. We write `ask/<n>.json` + `ask/<n>.done`, read the page's
-    `reply/<n>.json` once `reply/<n>.done` appears, and then remove only our
-    own two files; their disappearance is what tells the page it may retire
-    the reply it wrote. `.done` goes last, both times."""
+    The guest writes ask/<n>.json and ask/<n>.done, then reads reply/<n>.json
+    after the page writes reply/<n>.done. It removes only its own ask files
+    to acknowledge the reply. Each writer creates and removes .done last."""
     _ASK_SEQUENCE[0] += 1
     name = str(_ASK_SEQUENCE[0])
     with open(os.path.join(ASK, name + ".json"), "w") as fh:
@@ -2474,20 +2188,7 @@ def ask(payload):
 # ---------------------------------------------------------------- the render engine
 
 def _vertical_extent(cam, width, height):
-    """The photograph's vertical field of view in degrees (or, for an
-    orthographic camera, its vertical extent in Blender units), framed the way
-    Blender frames a render: `BKE_camera_params_compute_viewplane`.
-
-    Blender's `sensor_fit` says which sensor dimension spans which image
-    dimension. HORIZONTAL: `sensor_width` spans the image width, and the
-    vertical extent follows from the aspect. VERTICAL: `sensor_height` spans the
-    height. AUTO: `sensor_width` spans the LARGER image dimension. The previous
-    line sent `camera.angle_y`, which Blender derives from `sensor_height`
-    alone, so under AUTO or HORIZONTAL fit a 36x24 sensor photographed 1.5x too
-    wide a view -- measured on the ten-model battery (2026-09-18): every hero
-    image differed across ~100% of pixels by exactly the 36/24 ratio, and
-    `sensor_height = 36` made rendered/analytic 0.9991. Pixel aspect is not
-    applied; the presenter renders square pixels."""
+    """Compute vertical field of view or orthographic extent using Blender’s sensor-fit rules. HORIZONTAL uses sensor_width across image width; VERTICAL uses sensor_height across height; AUTO fits the larger image dimension. The presenter uses square pixels."""
     import math
     landscape = width >= height
     fit = cam.sensor_fit
@@ -2503,11 +2204,11 @@ def _vertical_extent(cam, width, height):
     return math.degrees(2.0 * math.atan(extent / (2.0 * float(cam.lens))))
 
 
-def _photograph(depsgraph, width, height, linear=False):
+def _photograph(depsgraph, width, height, linear=False, viewport=False):
     """three.js IS the renderer: the render is a photograph of the scene the
     engine holds, taken through the scene's own camera at `scene.render`'s
     exact resolution. `bpy.ops.render.render` semantics are the contract."""
-    scene = depsgraph.scene if hasattr(depsgraph, "scene") else bpy.context.scene
+    scene = depsgraph.scene
     camera = scene.camera
     if camera is None:
         raise RuntimeError("The scene has no camera, so there is nothing to render")
@@ -2524,12 +2225,14 @@ def _photograph(depsgraph, width, height, linear=False):
     # matrix (`blender-runtime-host.ts`).
     up = [float(v) for v in rotation @ vector((0.0, 1.0, 0.0))]
     view = scene.view_settings
-    look = getattr(view, "look", "None") or "None"
+    look = view.look or "None"
     transform = {
         "Standard": "none",
         "AgX": "agx",
         "Filmic": "filmic",
         "Khronos PBR Neutral": "neutral",
+        "ACES 1.3": "aces13",
+        "ACES 2.0": "aces20",
     }.get(view.view_transform)
     if transform is None:
         raise RuntimeError(
@@ -2558,32 +2261,27 @@ 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.photograph(
-        depsgraph, {"position": position, "target": target, "up": up, "render": render}
-    )
+    pose = {"position": position, "target": target, "up": up, "render": render}
+    # Capture the already-presented scene through its camera using the ordinary incremental present path.
+    answer = SESSION.present(pose) if viewport else SESSION.photograph(depsgraph, pose)
     if not isinstance(answer, dict) or "base64" not in answer:
         raise RuntimeError("The renderer did not answer with a photograph")
     _assert_photographed_from(answer.get("camera"), position, target, up)
     return base64.b64decode(answer["base64"]), render, answer
 
 
+def photograph_frame(width, height):
+    """A FILM'S FRAME (`render-movie`): the scene at its current frame, as the viewport presents it,
+    photographed through the scene camera (marker cuts included, as Blender switches the camera on a
+    frame change) at `width` x `height`, with the scene's view transform. Answers the PNG's bytes."""
+    png, _render, _answer = _photograph(bpy.context.evaluated_depsgraph_get(), width, height, viewport=True)
+    return png
+
+
 def _assert_photographed_from(reported, position, target, up):
-    """The photograph answers with the pose it ACTUALLY used, back in Blender's
-    frame, and it must be the pose that was sent -- exactly, with no tolerance.
-
-    This is an instrument, not a nicety. A render's image is allowed to differ
-    from Cycles (three.js is the renderer), so a camera placed in the wrong
-    frame produces a picture nobody can call wrong: the lane shipped for its
-    whole life photographing the model's underside from below the floor because
-    Blender's Z-up numbers were read as three.js world space, and every hero
-    image the battery graded came from that camera.
-
-    The check is exact because the conversion is exact: the model root's world
-    matrix is a signed axis permutation (`blender-runtime-view.ts` sets the
-    matrix outright rather than a float quarter turn), so a vector through it
-    and its inverse is bit-identical. A mismatch is the conversion being wrong,
-    never the check being too strict -- do not widen it.
-    """
+    """Require the photograph’s camera pose, transformed back into Blender’s frame, to equal the sent
+    pose exactly. The model root uses a signed axis permutation, so the transform and its inverse
+    preserve the values without a floating-point tolerance."""
     sent = {"position": position, "target": target, "up": up}
     if not isinstance(reported, dict):
         raise RuntimeError(
@@ -2650,20 +2348,8 @@ class VolterRenderEngine(bpy.types.RenderEngine):
 
 
 def _fill_result(engine, result, answer, png, width, height):
-    """THE RENDER RESULT HOLDS SCENE-LINEAR PIXELS, and Blender runs the scene's
-    view transform over them wherever it shows or saves one (`write_still`, the
-    Image Editor), as it does over Cycles'. The photograph's PNG is the display
-    image -- the transform already ran -- so loading it put every render
-    through AgX or Filmic twice. Measured 2026-09-28 by Cyclotron's
-    render view: a background 53 against the viewport's 59, a shadow's blue 2
-    against 7. The same capture's linear frame goes in instead: half floats,
-    RGBA, bottom row first, which is Blender's own row order. Linear 0.005,
-    0.05, 0.5 and 4.0 then save under AgX as 8, 58, 170 and 234 (the PNG
-    path saved 3, 53, 160 and 190), and under Standard as 15, 64, 188 and 255,
-    as the PNG path did.
-
-    A renderer that sends no linear frame gets the old path, and says so."""
-    linear = answer.get("linearBase64") if isinstance(answer, dict) else None
+    """Load scene-linear capture pixels into RenderResult so Blender applies the scene view transform exactly once. A presenter without linear pixels uses the declared PNG path."""
+    linear = answer.get("linearBase64")
     if linear and answer.get("linearWidth") == width and answer.get("linearHeight") == height:
         import numpy
 
@@ -2696,8 +2382,7 @@ def _engine_class(identifier):
 
     A Python-registered engine is exposed on `bpy.types` under its CLASS name
     (`bpy.types.CyclesRender`), never under its id, so `bpy.types.CYCLES` is
-    always absent -- looking there found nothing and left the add-on's engine
-    in place. The subclass tree is the one true registry."""
+    always absent. Search the RenderEngine subclass tree by `bl_idname`."""
     pending = list(bpy.types.RenderEngine.__subclasses__())
     while pending:
         cls = pending.pop()
@@ -2708,28 +2393,8 @@ def _engine_class(identifier):
 
 
 def _release_from_owning_addon(existing):
-    """Take the class out of its OWNING ADD-ON's registration list as well.
-
-    `unregister_class(existing)` is only half the gesture. The add-on that
-    registered the class still holds it in its module-level `classes`, and
-    Blender tears every add-on down again on `read_factory_settings` and on
-    each `open_mainfile` -- so the add-on's own `unregister()` calls
-    `unregister_class` on a class that is already gone and raises
-    `RuntimeError: missing bl_rna attribute`. `addon_utils.disable` catches
-    that and prints a full traceback, and the remainder of that add-on's
-    `unregister()` never runs.
-
-    MEASURED 2026-09-18 through the editor tab, running Blender's own
-    `tests/python` suites against the bundle: 25 of 43 suites printed
-    `Exception in module unregister(): '/bw/scripts/addons_core/cycles/
-    __init__.py'`, and the native oracle at the same pin (5.2.0 LTS,
-    fbe6228777e7) printed it in NONE of them -- the add-on is intact there
-    because nothing took its engine id. Dropping the class from `classes`
-    makes the add-on's next `register()`/`unregister()` pair agree with what
-    this session actually did, which is what keeps `scene.cycles` (the reason
-    the add-on stays enabled at all) reachable after a factory reset.
-    """
-    module = sys.modules.get(getattr(existing, "__module__", ""))
+    """Remove a replaced engine class from its add-on’s registration list as well as Blender’s registry, so file loads and factory resets can unregister the remaining add-on classes."""
+    module = sys.modules.get(existing.__module__)
     classes = getattr(module, "classes", None)
     if isinstance(classes, tuple):
         if existing in classes:
@@ -2778,14 +2443,7 @@ def _register_engine():
             bpy.utils.register_class(engine)
             made.append(identifier)
         except Exception:  # noqa: BLE001
-            # Upstream Blender refuses to let a Python engine take a BUILT-IN
-            # id ("is built-in"); the shipped bundle carries a patch that sets
-            # the built-in type aside instead, since headless has no GPU for it
-            # to render with, so the two GPU ids are taken there (measured
-            # 2026-09-17). A bundle without that patch keeps `BLENDER_EEVEE`
-            # and `BLENDER_WORKBENCH`: that is a fact about the build, stated
-            # in the start reply and refused by name at the render, never a
-            # warning on every boot.
+            # Report an engine id whose registration failed.
             unavailable.append(identifier)
     # `VOLTER_THREE` is the engine under its own name, registered ONCE: this runs
     # again after every file load (the ids have to be retaken), and Blender
@@ -2889,12 +2547,8 @@ class NativeHistory:
         finally:
             self.moving = False
         self.cursor += -1 if direction == "undo" else 1
-        # AN UNDO STEP IS AN ORDINARY UPDATE when Blender kept its datablocks and depsgraph:
-        # memfile undo re-reads only the changed IDs and tags exactly those, so the next frame
-        # re-ships what changed and the presenter keeps the rest (`session_undo`). A step that
-        # replaced the depsgraph starts both revision caches over, as does an engine without
-        # the door.
-        if not hasattr(_blender_web, "session_undo") or _blender_web.session_undo():
+        # An undo that retains the depsgraph sends only changed IDs; a replaced depsgraph resets revision caches.
+        if _blender_web.session_undo():
             _blender_web.session_reset()
             SESSION.forget()
         SESSION.present()
@@ -2966,12 +2620,8 @@ def get_object_info(name):
 
 
 def execute(code):
-    """Run one script in a namespace of its own, `{"bpy": bpy}`, which is what
-    the Blender MCP add-on gives every call. A helper one call defines reaches
-    a later call only through `bpy.app.driver_namespace`, and a name a later
-    call binds never reaches an earlier call's closure: with one dict shared
-    across calls, the courtyard's render helper (defined at seq 29) found its
-    `sc` rebound to a tuple by seq 35 and failed where the recording did not."""
+    """Run one script in its own `{"bpy": bpy}` namespace. Calls can share helpers
+    through `bpy.app.driver_namespace`; local names and closures stay isolated."""
     namespace = {"bpy": bpy}
     captured = io.StringIO()
     error = None
@@ -2984,14 +2634,7 @@ def execute(code):
     return {"executed": error is None, "result": captured.getvalue(), "error": error}
 
 
-# CAPABILITIES COMPILED OUT OF THIS BUILD, refused BY NAME at the door. Blender
-# built without them keeps their operators registered and reports success while
-# doing nothing: measured on `06-cable-gripper` (2026-09-18),
-# `bpy.ops.rigidbody.world_add()` returned {'FINISHED'} with `scene.rigidbody_world`
-# still None, and the script died three lines later on the None. That is the
-# silent degrade the rulings forbid. The build option is Blender's own fact
-# (`bpy.app.build_options`); the keyword is the operator namespace a script
-# reaches the capability through. Same shape as the render-engine refusal above.
+# Refuse script requests for capabilities disabled by bpy.app.build_options, naming the operator namespace and unavailable build feature.
 _ABSENT_CAPABILITIES = (
     ("bullet", "rigidbody", "rigid body physics (Bullet)"),
     ("fluid", "bpy.ops.fluid", "fluid simulation (Mantaflow)"),
@@ -3002,31 +2645,14 @@ _ABSENT_CAPABILITIES = (
 def _absent_capability(code):
     options = bpy.app.build_options
     for option, keyword, capability in _ABSENT_CAPABILITIES:
-        if keyword in code and not getattr(options, option, True):
+        if keyword in code and not getattr(options, option):
             return ("CapabilityUnavailable: %s is not compiled into this Blender build, so "
                     "`%s` operators are refused rather than reported as done with nothing "
                     "created. (bpy.app.build_options.%s is False.)" % (capability, keyword, option))
     return _absent_essentials_assets(code)
 
 
-# THE ESSENTIALS ASSET LIBRARY is not a build option, so it cannot be refused
-# from `bpy.app.build_options` like the three above -- it is a PAYLOAD fact, and
-# the only honest predicate is the directory itself.
-#
-# MEASURED 2026-09-18 in the tab: `bpy.utils.system_resource('DATAFILES')` is
-# `/bw/datafiles` and holds exactly `['colormanagement', 'fonts']`, because the
-# preload payload ships those two and nothing else from `release/datafiles`
-# (recipe/blender_web_headless.cmake). So
-# `system_resource('DATAFILES', path='assets')` answers `''`, and Blender
-# reports the empty string back to the caller verbatim:
-#
-#   bpy.ops.object.shade_auto_smooth(use_auto_smooth=True)
-#   RuntimeError: Error: No asset found at path ""
-#
-# Running Blender's own suites against the bundle, that one absence is every
-# failing assertion in `object_edit` (1) and `sculpt_paint/brush_asset_test`
-# (4) -- both clean on the native oracle at the same pin. A message naming the
-# empty path is not something an author can act on; naming the library is.
+# Check the Essentials asset-library directory itself; availability is a payload property rather than a bpy.app.build_options flag.
 _ESSENTIALS_KEYWORDS = ("shade_auto_smooth", "asset_activate", "ESSENTIALS")
 
 
@@ -3049,9 +2675,7 @@ def _absent_essentials_assets(code):
 
 # ------------------------------------------------------------------ the RNA door
 #
-# EVERYTHING BLENDER SHOWS ABOUT A DATABLOCK, READ THROUGH RNA (ARCHITECTURE-CORE
-# §Blender north star, "Inspection parity, not editing parity"; WORK.md §Blender
-# in the tab is Blender, "Inspection parity", I1). Blender's UI layer is never
+# DATABLOCK PROPERTIES READ THROUGH RNA. Blender's UI layer is never
 # run, ported or recorded here: what this answers is `bl_rna.properties` --
 # Blender's own introspection of its own data -- as typed rows, and what our
 # panels draw is those rows.
@@ -3076,20 +2700,7 @@ _RNA_STRING_LIMIT = 4096
 # struct carries it and it points at the struct's own type.
 _RNA_SKIP = ("rna_type",)
 
-# BLENDER'S PYTHON LAYER ADDS PROPERTIES RNA DOES NOT KNOW. `bl_rna.properties`
-# is RNA's own list, and `scripts/modules/bpy_types.py` puts ordinary Python
-# `property` descriptors on top of the generated classes -- `Object.children`,
-# `Object.users_collection`, `Object.users_scene`, `Bone.children`. They are
-# part of the API Blender's OWN panels read: `properties_object.py:201` draws
-# the Collections panel straight out of `obj.users_collection`, which is why
-# that panel came up EMPTY here until the door answered them (measured
-# 2026-09-19; `users_collection` appears nowhere under `source/blender/makesrna`
-# at the pin, so nothing in the RNA iteration could ever have found it).
-#
-# SKIPPED BY A RULE, NOT A LIST: a name ending `_recursive` is Blender's own
-# spelling for a walker that re-derives a whole subtree on every read
-# (`children_recursive`, `parent_recursive`), and what it holds is one drill
-# away through the plain property beside it.
+# Include Python property descriptors from bpy_types alongside RNA properties, excluding recursive variants when the immediate property already offers traversal.
 _PY_PROPERTY_SUFFIX_SKIP = ("_recursive",)
 
 _ID_COLLECTIONS = None
@@ -3105,7 +2716,7 @@ def _id_collections():
     for prop in bpy.data.bl_rna.properties:
         if prop.type != "COLLECTION":
             continue
-        fixed = getattr(prop, "fixed_type", None)
+        fixed = prop.fixed_type
         if fixed is not None:
             table.setdefault(fixed.identifier, prop.identifier)
     return table
@@ -3122,7 +2733,7 @@ def _id_collection_for(datablock):
         name = _ID_COLLECTIONS.get(rna.identifier)
         if name:
             return name
-        rna = getattr(rna, "base", None)
+        rna = rna.base
     return None
 
 
@@ -3138,7 +2749,7 @@ def _rna_address(struct):
         if collection is None:
             return None
         return 'bpy.data.%s["%s"]' % (collection, bpy.utils.escape_identifier(struct.name))
-    owner = getattr(struct, "id_data", None)
+    owner = struct.id_data
     if owner is None:
         return None
     base = _rna_address(owner)
@@ -3164,23 +2775,17 @@ def _rna_resolve(path):
 
 
 def _rna_group(struct_rna, identifier):
-    """WHICH RNA STRUCT DECLARES THIS PROPERTY -- the only grouping RNA itself
-    exposes, and a real one: `Object`'s own properties read apart from the `ID`
-    fields every datablock carries. It is NOT Blender's panel layout. Which
-    properties a Properties panel draws, and in what order, lives in
-    `scripts/startup/bl_ui/properties_*.py`, which the ruling forbids running,
-    porting or recording; our own curated panels are I2 and name their RNA
-    themselves. Cached per struct -- the base chain is walked once."""
+    """Find the RNA struct declaring a property and cache the result per struct. This groups RNA inheritance independently of Blender’s panel layout."""
     cached = _RNA_GROUPS.get(struct_rna.identifier)
     if cached is None:
         cached = {}
         for prop in struct_rna.properties:
             declaring = struct_rna
-            base = getattr(struct_rna, "base", None)
+            base = struct_rna.base
             while base is not None:
                 if prop.identifier in base.properties:
                     declaring = base
-                base = getattr(base, "base", None)
+                base = base.base
             cached[prop.identifier] = (declaring.identifier, declaring.name)
         _RNA_GROUPS[struct_rna.identifier] = cached
     return cached.get(identifier, (struct_rna.identifier, struct_rna.name))
@@ -3220,7 +2825,7 @@ def _rna_value(target, prop):
     if kind == "COLLECTION":
         value = getattr(target, prop.identifier)
         row = {"count": len(value)}
-        fixed = getattr(prop, "fixed_type", None)
+        fixed = prop.fixed_type
         # A mesh's `vertices` has no `name`, and asking 100k of them for one is
         # exactly the serialisation this door refuses -- so the question is
         # asked of the TYPE, once, off its own RNA.
@@ -3236,14 +2841,7 @@ def _rna_value(target, prop):
     if kind == "ENUM":
         return sorted(value) if prop.is_enum_flag else value
     if getattr(prop, "array_length", 0):
-        # A MATRIX IS AN ARRAY OF ROWS, not of numbers. `bpy_prop_array` is
-        # multi-dimensional wherever `PropertyRNA.array_dimension > 1` --
-        # `Bone.matrix` is 3x3, `matrix_local` and `Object.matrix_world` 4x4 --
-        # and iterating one yields `Vector`s, which `float()` refuses by name
-        # ("could not convert string to float: Vector((1.0, 0.0, 0.0))").
-        # Measured live 2026-09-19 on the Bone tab's Transform panel, which is
-        # where a matrix first got named. Flattened in ROW-MAJOR order, which
-        # is how `array_length` already counts it (9 and 16, not 3 and 4).
+        # Flatten multidimensional bpy_prop_array values in row-major order; RNA array_length counts scalar values rather than rows.
         return [_rna_scalar(item, kind) for item in _rna_flatten(value)]
     if kind == "BOOLEAN":
         return bool(value)
@@ -3290,19 +2888,7 @@ def _rna_row(target, prop):
         # by the presentation, so the door stays the whole surface.
         "hidden": bool(prop.is_hidden),
     }
-    # UNDRAWN STATE -- the second standing rule, ruled on after I2 measured it
-    # (WORK.md §Blender in the tab is Blender, "Inspection parity", I2, "The two
-    # standing rules"). `rna_define.cc:1311-1312` gives every property
-    # `prop->name = identifier` and `prop->description = ""` at definition, and
-    # `RNA_def_property_ui_text` is what replaces them -- so a property whose
-    # NAME is still its identifier and whose description is still empty is one
-    # Blender never gave UI text to. That is what the modifier panel-open
-    # booleans are (`rna_def_modifier_panel_open_prop`, `:2694-2705`, which sets
-    # `PROP_NO_DEG_UPDATE` and an sdna bit and no flag at all, so the
-    # PROP_HIDDEN rule above does not catch them): state a panel's open/closed
-    # arrow writes, not data about the datablock. Reported here and FILTERED by
-    # the generic view, exactly as `hidden` is; a curated list names none of
-    # them because `bl_ui` draws none of them.
+    # Mark properties without UI text as undrawn when their name equals the identifier and their description is empty.
     if prop.name == prop.identifier and not prop.description:
         row["undrawn"] = True
     if prop.type in ("INT", "FLOAT"):
@@ -3314,20 +2900,20 @@ def _rna_row(target, prop):
         if prop.type == "FLOAT":
             row["precision"] = int(prop.precision)
     if prop.type == "STRING":
-        row["lengthMax"] = int(getattr(prop, "length_max", 0) or 0)
+        row["lengthMax"] = int(prop.length_max)
     if prop.type == "ENUM":
         row["isFlag"] = bool(prop.is_enum_flag)
         try:
             items = prop.enum_items
         except Exception:  # noqa: BLE001
-            items = getattr(prop, "enum_items_static", ())
+            items = prop.enum_items_static
         row["items"] = [
             {"identifier": item.identifier, "name": item.name,
              "description": item.description, "icon": item.icon}
             for item in items
         ]
     if prop.type in ("POINTER", "COLLECTION"):
-        fixed = getattr(prop, "fixed_type", None)
+        fixed = prop.fixed_type
         if fixed is not None:
             row["itemType"] = fixed.identifier
     if length > _RNA_ARRAY_LIMIT:
@@ -3352,8 +2938,7 @@ def _py_properties(cls):
         return cached
     found = []
     seen = set()
-    rna = getattr(cls, "bl_rna", None)
-    declared = set(rna.properties.keys()) if rna is not None else set()
+    declared = set(cls.bl_rna.properties.keys())
     for base in cls.__mro__:
         for name, member in vars(base).items():
             if name.startswith("_") or name in seen or name in declared:
@@ -3450,16 +3035,7 @@ def _py_row(target, name, descriptor, owner):
 
 
 def _rna_member(collection_path, item, index):
-    """One member of a collection, ADDRESSED.
-
-    `path_from_id()` is the first answer and the right one -- but it is not
-    always an answer: a `VertexGroup` has no RNA path back to its object (the
-    three groups of a skinned mesh came out with `path: null` on the first
-    live walk, 2026-09-19), while `bpy.data.path_resolve` resolves
-    `objects["X"].vertex_groups["chest"]` perfectly well. So where the struct
-    cannot say where it lives, the COLLECTION says it: this path plus the
-    member's own key. Index for a member with no name -- a mesh vertex -- which
-    is also how `path_from_id` would spell it."""
+    """Address collection members with path_from_id when available, otherwise append their name or index to the collection’s own path."""
     address = _rna_address(item)
     name = getattr(item, "name", None)
     if address is None:
@@ -3576,11 +3152,11 @@ def _rna_active_object(name):
     return bpy.context.view_layer.objects.active
 
 
-def _named(value, path=None):
+def _named(value):
     if value is None:
         return None
-    return {"name": getattr(value, "name", None),
-            "path": path if path is not None else _rna_address(value),
+    return {"name": value.name,
+            "path": _rna_address(value),
             "type": value.bl_rna.identifier}
 
 
@@ -3590,14 +3166,7 @@ def _tab(identifier, label, icon, paths):
 
 
 def _layer_collection_path(view_layer_path, root, target):
-    """A `LayerCollection` HAS NO `path_from_id()` -- measured live 2026-09-19,
-    the same shape as I1's `VertexGroup` finding, and it made
-    `COLLECTION_PT_viewlayer_flags`'s datablock unaddressable so the View Layer
-    sub-panel drew nothing. Its address is its POSITION in the view layer's
-    tree, which the tree itself can spell."""
-    if target is None:
-        return None
-
+    """Address a LayerCollection by its position in the view-layer tree because it has no path_from_id."""
     def walk(node, path):
         if node == target:
             return path
@@ -3613,12 +3182,14 @@ def _layer_collection_path(view_layer_path, root, target):
 
 def _texture_slot_users(users, owner, slots, label, name=None):
     """Blender's `buttons_texture_user_mtex_add`: one user per FILLED slot."""
-    for index, slot in enumerate(slots or ()):
-        texture = getattr(slot, "texture", None)
+    for slot in slots:
+        if slot is None:
+            continue
+        texture = slot.texture
         if texture is None:
             continue
         users.append({"label": label,
-                      "name": name if name else getattr(owner, "name", None),
+                      "name": name if name else owner.name,
                       "path": _rna_address(slot),
                       "property": "texture",
                       "texture": _named(texture)})
@@ -3629,11 +3200,11 @@ def _texture_node_users(users, tree, label):
     `texture` pointer is filled."""
     if tree is None:
         return
-    for node in getattr(tree, "nodes", ()):
+    for node in tree.nodes:
         prop = node.bl_rna.properties.get("texture")
         if prop is None or prop.type != "POINTER":
             continue
-        texture = getattr(node, "texture", None)
+        texture = node.texture
         if texture is None:
             continue
         users.append({"label": label, "name": node.name,
@@ -3642,58 +3213,41 @@ def _texture_node_users(users, tree, label):
 
 
 def _texture_users(scene, view_layer, obj):
-    """WHO USES A TEXTURE, mirrored from
-    `space_buttons/buttons_texture.cc::buttons_texture_users_from_context`
-    (`:244-366`) at the engine's pin -- in ITS order, because
-    `buttons_texture_context_compute` (`:369`) takes `ct->index` (0 unless a
-    person picks another) and the Texture tab then shows THAT user's texture.
-
-    The C walks, in order: the scene's compositing node tree ("Compositor"),
-    the active line style's slots and node tree ("Line Style"), the object's
-    modifiers via `BKE_modifiers_foreach_tex_link` ("Modifiers"), the ACTIVE
-    particle system's `part.mtex[]` ("Particles"), the object's force field
-    when `forcefield == PFIELD_TEXTURE` ("Fields"), and the active paint
-    brush's own two slots ("Brush").
-
-    NOTE, because it is easy to assume otherwise from older Blenders: a LIGHT
-    is not a texture user at this pin. `buttons_texture_users_from_context`
-    does not look at `ob->data` at all -- lamp textures went with 2.8's
-    renderer rewrite. Measured, not remembered."""
+    """Report texture users in Blender buttons_texture_users_from_context order, with the active user index selecting the displayed texture."""
     users = []
-    _texture_node_users(users, getattr(scene, "compositing_node_group", None), "Compositor")
+    _texture_node_users(users, scene.compositing_node_group, "Compositor")
 
-    freestyle = getattr(view_layer, "freestyle_settings", None)
-    linesets = getattr(freestyle, "linesets", None)
-    linestyle = getattr(getattr(linesets, "active", None), "linestyle", None)
+    lineset = view_layer.freestyle_settings.linesets.active
+    linestyle = lineset.linestyle if lineset is not None else None
     if linestyle is not None:
-        _texture_slot_users(users, linestyle, getattr(linestyle, "texture_slots", None),
+        _texture_slot_users(users, linestyle, linestyle.texture_slots,
                             "Line Style")
-        _texture_node_users(users, getattr(linestyle, "node_tree", None), "Line Style")
+        _texture_node_users(users, linestyle.node_tree, "Line Style")
 
     if obj is not None:
         for modifier in obj.modifiers:
             for prop in modifier.bl_rna.properties:
                 if prop.type != "POINTER":
                     continue
-                fixed = getattr(prop, "fixed_type", None)
+                fixed = prop.fixed_type
                 if fixed is None or fixed.identifier != "Texture":
                     continue
-                texture = getattr(modifier, prop.identifier, None)
+                texture = getattr(modifier, prop.identifier)
                 if texture is None:
                     continue
                 users.append({"label": "Modifiers", "name": modifier.name,
                               "path": _rna_address(modifier),
                               "property": prop.identifier,
                               "texture": _named(texture)})
-        systems = getattr(obj, "particle_systems", None)
-        active_system = getattr(systems, "active", None) if systems is not None else None
-        settings = getattr(active_system, "settings", None)
+        systems = obj.particle_systems
+        active_system = systems.active
+        settings = active_system.settings if active_system is not None else None
         if settings is not None:
-            _texture_slot_users(users, settings, getattr(settings, "texture_slots", None),
+            _texture_slot_users(users, settings, settings.texture_slots,
                                 "Particles", name=active_system.name)
-        field = getattr(obj, "field", None)
-        if field is not None and getattr(field, "type", None) == "TEXTURE" \
-                and getattr(field, "texture", None) is not None:
+        field = obj.field
+        if field is not None and field.type == "TEXTURE" \
+                and field.texture is not None:
             users.append({"label": "Fields", "name": "Texture Field",
                           "path": _rna_address(field), "property": "texture",
                           "texture": _named(field.texture)})
@@ -3701,17 +3255,17 @@ def _texture_users(scene, view_layer, obj):
     # `BKE_paint_brush(BKE_paint_get_active_from_context(C))`. Headless has no
     # paint mode, so this is whichever tool settings hold a brush at all --
     # asked of every `Paint` the tool settings carry rather than of a mode.
-    tools = getattr(bpy.context, "tool_settings", None)
+    tools = bpy.context.tool_settings
     for member in ("image_paint", "sculpt", "vertex_paint", "weight_paint",
                    "gpencil_paint", "curves_sculpt"):
-        paint = getattr(tools, member, None)
-        brush = getattr(paint, "brush", None)
+        paint = getattr(tools, member) if tools is not None else None
+        brush = paint.brush if paint is not None else None
         if brush is None:
             continue
         for slot, prop in (("texture_slot", "texture"), ("mask_texture_slot", "mask_texture")):
-            holder = getattr(brush, slot, None)
-            texture = getattr(brush, prop, None)
-            if holder is None or texture is None:
+            holder = getattr(brush, slot)
+            texture = getattr(brush, prop)
+            if texture is None:
                 continue
             users.append({"label": "Brush", "name": brush.name,
                           "path": _rna_address(holder), "property": "texture",
@@ -3740,7 +3294,7 @@ def rna_context(object_name=None, collection_path=None):
     # then shows THAT collection. Activating it here would be a mutation the
     # document saves, so the row's own address arrives as a parameter and stands
     # in for `view_layer.active_layer_collection` for this read alone.
-    active_layer_collection = getattr(view_layer, "active_layer_collection", None)
+    active_layer_collection = view_layer.active_layer_collection
     if collection_path:
         named = _rna_resolve(collection_path)
         if not isinstance(named, bpy.types.LayerCollection):
@@ -3749,7 +3303,7 @@ def rna_context(object_name=None, collection_path=None):
                 "LayerCollection (`buttons_context_path_collection`)."
                 % (collection_path, named.bl_rna.identifier))
         active_layer_collection = named
-    collection = getattr(active_layer_collection, "collection", None)
+    collection = active_layer_collection.collection if active_layer_collection is not None else None
     if collection is not None and collection == scene.collection:
         collection = None
 
@@ -3774,7 +3328,7 @@ def rna_context(object_name=None, collection_path=None):
         # object whose data supports materials even when the slot is empty --
         # `OB_TYPE_SUPPORT_MATERIAL` is asked here as "does this data hold a
         # `materials` collection", which is the same set, read off RNA.
-        slot_index = max(int(getattr(obj, "active_material_index", 0)), 0)
+        slot_index = max(int(obj.active_material_index), 0)
         slots = obj.material_slots
         slot = slots[slot_index] if slot_index < len(slots) else None
         held = slot.material if slot is not None else None
@@ -3790,16 +3344,15 @@ def rna_context(object_name=None, collection_path=None):
     particle_system = None
     if obj is not None:
         if obj.type in _MODIFIER_OBJECT_TYPES:
-            modifier = _named(getattr(obj.modifiers, "active", None))
-        groups = getattr(obj, "vertex_groups", None)
-        if groups is not None and getattr(groups, "active", None) is not None:
+            modifier = _named(obj.modifiers.active)
+        groups = obj.vertex_groups
+        if groups.active is not None:
             vertex_group = {"index": int(groups.active_index)}
             vertex_group.update(_named(groups.active))
-        shape_key = _named(getattr(obj, "active_shape_key", None))
-        constraint = _named(getattr(obj.constraints, "active", None))
-        systems = getattr(obj, "particle_systems", None)
-        if systems is not None:
-            particle_system = _named(getattr(systems, "active", None))
+        shape_key = _named(obj.active_shape_key)
+        constraint = _named(obj.constraints.active)
+        systems = obj.particle_systems
+        particle_system = _named(systems.active)
 
     # ED_buttons_tabs_list (`space_buttons.cc:218-252`), in its own order. The
     # TOOL tab is Blender's active-tool settings and has no reader here; SHADERFX
@@ -3873,18 +3426,14 @@ def rna_context(object_name=None, collection_path=None):
                 # it is what nearly every panel on this tab draws -- `part` in
                 # every one of their draw functions. The system itself carries
                 # only a handful (`seed`, `parent`, the vertex-group names).
-                systems_active = getattr(systems, "active", None)
-                settings = getattr(systems_active, "settings", None)
-                if settings is not None:
-                    paths.append(("Settings", _rna_address(settings)))
-                    cloth = getattr(systems_active, "cloth", None)
-                    if cloth is not None:
-                        # PARTICLE_PT_hair_dynamics reads `psys.cloth.settings`
-                        # and `.collision_settings` (`:390-404`, `:463-470`).
-                        paths.append(("Hair Dynamics",
-                                      _rna_address(getattr(cloth, "settings", None))))
-                        paths.append(("Hair Collisions",
-                                      _rna_address(getattr(cloth, "collision_settings", None))))
+                systems_active = systems.active
+                paths.append(("Settings", _rna_address(systems_active.settings)))
+                cloth = systems_active.cloth
+                if cloth is not None:
+                    # PARTICLE_PT_hair_dynamics reads `psys.cloth.settings`
+                    # and `.collision_settings` (`:390-404`, `:463-470`).
+                    paths.append(("Hair Dynamics", _rna_address(cloth.settings)))
+                    paths.append(("Hair Collisions", _rna_address(cloth.collision_settings)))
             tabs.append(_tab("particle", "Particles", "properties-particles", paths))
         # `buttons_context_path_object` answers Physics and Constraints both.
         #
@@ -3903,34 +3452,28 @@ def rna_context(object_name=None, collection_path=None):
                                         ("Soft Body", "soft_body"),
                                         ("Collision", "collision"),
                                         ("Force Field", "field"))
-                   if getattr(obj, field, None) is not None]
-        for label, kind, members in (("Cloth", "CLOTH",
-                                      # The MODIFIER as well as its settings:
-                                      # `point_cache_ui(self, md.point_cache, …)`
-                                      # is the cache panel's datablock
-                                      # (`properties_physics_cloth.py:269`), and
-                                      # that lives on the modifier, not on
-                                      # `md.settings`. Measured live 2026-09-19:
-                                      # the Cache panel drew nothing without it.
+                   if getattr(obj, field) is not None]
+        for kind, members in (("CLOTH",
+                                      # Include the modifier itself beside its settings because the point-cache panel addresses md.point_cache.
                                       (("Cloth Modifier", None),
                                        ("Cloth", "settings"),
                                        ("Cloth Collisions", "collision_settings"))),
-                                     ("Soft Body", "SOFT_BODY",
+                                     ("SOFT_BODY",
                                       (("Soft Body Modifier", None),)),
-                                     ("Fluid", "FLUID",
+                                     ("FLUID",
                                       (("Fluid", None),
                                        ("Fluid Domain", "domain_settings"),
                                        ("Fluid Flow", "flow_settings"),
                                        ("Fluid Effector", "effector_settings"))),
-                                     ("Dynamic Paint", "DYNAMIC_PAINT",
+                                     ("DYNAMIC_PAINT",
                                       (("Dynamic Paint", None),
                                        ("Dynamic Paint Canvas", "canvas_settings"),
                                        ("Dynamic Paint Brush", "brush_settings")))):
-            modifier = next((item for item in obj.modifiers if item.type == kind), None)
-            if modifier is None:
+            physics_modifier = next((item for item in obj.modifiers if item.type == kind), None)
+            if physics_modifier is None:
                 continue
             for name, member in members:
-                target = modifier if member is None else getattr(modifier, member, None)
+                target = physics_modifier if member is None else getattr(physics_modifier, member)
                 physics.append((name, _rna_address(target)))
         tabs.append(_tab("physics", "Physics", "properties-physics",
                          physics or [("Object", object_path)]))
@@ -3945,7 +3488,7 @@ def rna_context(object_name=None, collection_path=None):
             paths = [("Object Data", data_path)]
             if obj.type == "ARMATURE":
                 paths.append(("Bones", "%s.bones" % data_path))
-            if getattr(obj, "vertex_groups", None) is not None and len(obj.vertex_groups):
+            if len(obj.vertex_groups):
                 paths.append(("Vertex Groups", "%s.vertex_groups" % object_path))
             keys = getattr(obj.data, "shape_keys", None)
             if keys is not None:
@@ -3962,11 +3505,11 @@ def rna_context(object_name=None, collection_path=None):
                                  [("Constraints", "%s.constraints" % pose_bone["path"])]))
         if material is not None:
             paths = [("Material Slots", "%s.material_slots" % object_path)]
-            if material.get("path"):
+            if material["path"]:
                 paths.insert(0, ("Material", material["path"]))
             tabs.append(_tab("material", "Material", "properties-material", paths))
     # Blender's Texture tab is `buttons_texture_context_compute`'s search for a
-    # texture USER, now mirrored in `_texture_users` -- in the C's own order,
+    # texture USER, mirrored in `_texture_users` -- in the C's own order,
     # with user 0 the active one (`ct->index`). The tab stands when that search
     # finds a user, or (as `buttons_context_path_texture` does through the
     # pinned-ID branch) when the file holds textures at all.
@@ -3975,7 +3518,7 @@ def rna_context(object_name=None, collection_path=None):
     if texture_users or len(bpy.data.textures):
         paths = []
         if active_texture_user is not None:
-            paths.append(("Texture", (active_texture_user["texture"] or {}).get("path")))
+            paths.append(("Texture", active_texture_user["texture"]["path"]))
             paths.append(("User", active_texture_user["path"]))
         paths.append(("Textures", "bpy.data.textures"))
         tabs.append(_tab("texture", "Texture", "properties-texture", paths))
@@ -4014,47 +3557,11 @@ def rna_context(object_name=None, collection_path=None):
 
 
 
-# ---- the outliner tree ------------------------------------------------------
-#
-# MIRRORED FROM `space_outliner/tree/tree_display_view_layer.cc` -- Blender's
-# VIEW LAYER display mode, the one its Outliner opens on -- and from the
-# per-datablock expansions beside it: `tree_element_id_object.cc` (the order an
-# object expands in), `tree_element_id_mesh.cc`, `tree_element_id_armature.cc`,
-# `tree_element_pose.cc`, `tree_element_modifier.cc`, `tree_element_defgroup.cc`
-# and `tree_element_particle_system.cc`, all read at the engine's pin (Blender
-# 5.2.0, `fbe6228777e7`). Blender's UI layer is never run, ported or recorded:
-# what this answers is the TREE those functions build, as rows, and OUR
-# hierarchy panel draws it (ARCHITECTURE-CORE §Blender north star, "Inspection
-# parity, not editing parity"; WORK.md §Blender in the tab is Blender,
-# "Inspection parity", I3).
-#
-# THE ADDRESS IS THE ENGINE'S OWN, exactly as `rna_view`'s is: a row's `path` is
-# `_rna_address` (or a collection's address plus the member's key, I1's
-# answer for a struct that cannot say where it lives), so a row opens in the
-# RNA door with no translation. `id` is the row's IDENTITY in the tree, and it
-# IS the path in every ordinary case -- the two differ only where Blender
-# itself draws one datablock twice (an object linked into two collections, and
-# the `TE_CHILD_NOT_IN_COLLECTION` duplicate
-# `make_object_parent_hierarchy_collections` adds), where an ordinal keeps the
-# rows distinct while `path` stays the engine's own address for both.
-#
-# WHAT IS OPEN AT REST. A fresh tree-store element is CLOSED
-# (`outliner_tree.cc:139`, `tselem->flag = TSE_CLOSED`); the Scene Collection
-# (`tree_display_view_layer.cc:130`) and every editable layer collection
-# (`:167`) clear that flag and NOTHING else does -- so a collection is open and
-# an OBJECT is closed, its data, modifiers and groups with it.
-#
-# BIG LISTS ARE PAGED, the way `rna_view`'s collections are counted: a child
-# list longer than _OUTLINER_PAGE answers its first page and says how many more
-# there are, so a scene of 20,000 objects cannot turn one read into a
-# 20,000-row payload.
-#
-# AND THE READ COSTS WHAT IT SHOWS, not what the scene holds: an object's row
-# and its expansion are built only once the page has kept its place
-# (`rna_outliner`). The ids do not move for it. An id's ordinal is the number of
-# rows that claimed the same address before it in the WHOLE tree's order, kept
-# rows or not, and `_OutlinerScope` answers that count for a kept object's rows
-# from what every earlier object would have claimed.
+# Build the outliner’s View Layer tree from Blender’s tree_display_view_layer and per-datablock
+# expansion rules. Rows use native RNA addresses; duplicate appearances get distinct ordinal ids
+# while preserving their shared path. Collections begin expanded and object rows collapsed. Page
+# long child lists and build expansions only for retained objects. _OutlinerScope counts preceding
+# claims across the full tree so row identities remain stable between pages.
 
 _OUTLINER_PAGE = 64
 
@@ -4120,11 +3627,9 @@ def _enum_icon(target, identifier):
     (`outliner_draw.cc:2773-2785`); `rna_enum_constraint_type_items` carries
     that function's own constraint switch. Reading the engine's enum is reading
     the table the Outliner draws from, rather than transcribing it."""
-    prop = target.bl_rna.properties.get(identifier)
-    if prop is None:
-        return None
-    item = prop.enum_items.get(getattr(target, identifier, None))
-    return (getattr(item, "icon", None) or None) if item is not None else None
+    prop = target.bl_rna.properties[identifier]
+    item = prop.enum_items.get(getattr(target, identifier))
+    return (item.icon or None) if item is not None else None
 
 
 def _outliner_object_icon(obj):
@@ -4134,30 +3639,26 @@ def _outliner_object_icon(obj):
     if obj.type == "EMPTY":
         if obj.instance_collection is not None and obj.instance_type == "COLLECTION":
             return "OUTLINER_OB_GROUP_INSTANCE"
-        if getattr(obj, "empty_display_type", None) == "IMAGE":
+        if obj.empty_display_type == "IMAGE":
             return "OUTLINER_OB_IMAGE"
-        field = getattr(obj, "field", None)
-        if field is not None and getattr(field, "type", "NONE") != "NONE":
+        field = obj.field
+        if field is not None and field.type != "NONE":
             return "OUTLINER_OB_FORCE_FIELD"
     return _enum_icon(obj, "type") or "OBJECT_DATA"
 
 
 def _outliner_id_icon(datablock):
     """`tree_element_get_icon_from_id` for anything that is not an object."""
-    if datablock is None:
-        return "DOT"
     if isinstance(datablock, bpy.types.Light):
-        return _OUTLINER_LIGHT_ICONS.get(getattr(datablock, "type", None),
-                                         "OUTLINER_DATA_LIGHT")
+        return _OUTLINER_LIGHT_ICONS[datablock.type]
     if isinstance(datablock, bpy.types.LightProbe):
-        return _OUTLINER_PROBE_ICONS.get(getattr(datablock, "type", None),
-                                         "LIGHTPROBE_SPHERE")
+        return _OUTLINER_PROBE_ICONS[datablock.type]
     rna = datablock.bl_rna
     while rna is not None:
         icon = _OUTLINER_ID_ICONS.get(rna.identifier)
         if icon:
             return icon
-        rna = getattr(rna, "base", None)
+        rna = rna.base
     return "DOT"
 
 
@@ -4250,7 +3751,7 @@ def _outliner_modifier(md, obj, object_path, seen):
         linked = getattr(md, member, None)
         if linked is None:
             continue
-        linked_path = _rna_address(linked) or "%s.%s" % (path, member)
+        linked_path = _rna_address(linked)
         children.append(_outliner_row(linked_path, linked.name, kind, icon, seen))
         break
     system = getattr(md, "particle_system", None)
@@ -4291,8 +3792,8 @@ def _outliner_data(obj, seen):
             children.extend(_outliner_bone(bone, path, seen) for bone in page)
             if more:
                 row["more"] = more
-        collections = getattr(data, "collections", None)
-        if collections is not None and len(collections):
+        collections = data.collections
+        if collections:
             base = _outliner_row("%s.collections" % path, "Bone Collections",
                                  "TSE_BONE_COLLECTION_BASE", "GROUP_BONE", seen)
             page, more = _outliner_page(collections)
@@ -4369,10 +3870,9 @@ def _outliner_object(obj, view_layer, seen, chosen, active):
                              "MODIFIER_DATA", seen, object=obj.name)
         base["children"] = [_outliner_modifier(md, obj, path, seen) for md in obj.modifiers]
         children.append(base)
-    groups = getattr(obj, "vertex_groups", None)
-    if groups is not None and len(groups):
-        # `expand_vertex_groups`: mesh, lattice and grease pencil only, which is
-        # the same set as "this object carries a `vertex_groups` collection".
+    groups = obj.vertex_groups
+    if groups:
+        # `expand_vertex_groups`: objects with vertex groups expose their collection here.
         base_path = "%s.vertex_groups" % path
         base = _outliner_row(base_path, "Vertex Groups", "TSE_DEFGROUP_BASE", "GROUP_VERTEX",
                              seen, object=obj.name)
@@ -4429,13 +3929,12 @@ class _OutlinerScope:
         self.local = {}
 
     def _before(self, path):
-        if path is not None:
-            for prefix, address, before in self.scopes:
-                if path == address or path.startswith(prefix):
-                    return before
+        for prefix, address, before in self.scopes:
+            if path == address or path.startswith(prefix):
+                return before
         return None
 
-    def get(self, path, default=0):
+    def get(self, path, default):
         if path in self.local:
             return self.local[path]
         before = self._before(path)
@@ -4449,30 +3948,16 @@ class _OutlinerScope:
 
 # ---- the node editor's tree ------------------------------------------------
 #
-# THE ONE READ A NODE VIEW NEEDS. The generic `rna_view` door answers every one
-# of these facts -- `bpy.data.materials["M"].node_tree.nodes` is a collection it
-# opens, and each member is a struct it describes -- but it answers them ONE
-# STRUCT AT A TIME, and a node tree's drawing is a fact about the WHOLE tree:
-# the default Principled material is 2 nodes and 37 sockets, so drawing it
-# through the generic door is 40 round trips at the door's own ~100 ms median.
-# This door answers the same facts in one, and answers NOTHING the generic view
-# could not: every field below is a `bl_rna` property of `Node`, `NodeSocket` or
-# `NodeLink`, named here so a reader can check it against `rna_nodetree.cc`.
-#
-# IT IS A READ AND ONLY A READ (ARCHITECTURE-CORE "Inspection parity, not
-# editing parity"): there is no node-tree writer beside it, because a gesture
-# that moved a node or retyped a value would be editing, and editing parity is
-# not the program. `rna_set` remains the one writer, and it refuses a node's
-# `location` the same way it refuses anything else RNA declares read-only --
-# which `location` is not, so the VIEW is what refuses, by name, in its own
-# status line.
+# Read a whole node tree in one response. Fields are bl_rna properties of
+# Node, NodeSocket and NodeLink, matching rna_nodetree.cc.
+# The node view inspects and navigates; it refuses editing gestures in its
+# status line. RNA property writes remain on rna_set.
 _NODE_SOCKET_VALUE_MAX = 4
 
 
 def _node_socket_value(socket):
     """A socket's `default_value`, flattened the way `_rna_flatten` flattens an
-    array property -- and OMITTED where the socket has none (a shader socket,
-    a geometry socket) or Blender itself would not draw it (`hide_value`)."""
+    array property; None when the socket has no default or its value is unsupported."""
     if not hasattr(socket, "default_value"):
         return None
     value = socket.default_value
@@ -4509,18 +3994,17 @@ def _node_socket(socket, index):
         "shape": socket.display_shape,
         "enabled": bool(socket.enabled),
         "hide": bool(socket.hide),
-        "hideValue": bool(getattr(socket, "hide_value", False)),
+        "hideValue": bool(socket.hide_value),
         "linked": bool(socket.is_linked),
-        "multiInput": bool(getattr(socket, "is_multi_input", False)),
+        "multiInput": bool(socket.is_multi_input),
         "index": index,
         "value": _node_socket_value(socket),
         # THE SLIDER'S RANGE. A scalar socket whose `default_value` property
         # carries a BOUNDED soft range is drawn by Blender as a NUMBER SLIDER
         # -- `ui_but_is_slider`'s `UI_BTYPE_NUM_SLIDER`, whose back is filled to
         # the value's proportion of that range (`widget_numslider`,
-        # `interface_widgets.cc`). Without the range a view can only draw the
-        # flat NUM field, which is what ours did: Roughness at 0.5 read as a
-        # text box where Blender's reads half-filled at a glance.
+        # `interface_widgets.cc`). The soft range determines the filled
+        # proportion; an unbounded field has no slider fill.
         #
         # `soft_min`/`soft_max` are the UI range and `min`/`max` the hard one;
         # Blender sliders against the SOFT pair. An unbounded property (a
@@ -4533,11 +4017,7 @@ def _node_socket(socket, index):
 def _node_socket_range(socket):
     """The soft range of a scalar socket drawn as a SLIDER, when it is one.
 
-    BEING BOUNDED IS NOT THE TEST, and the reference frame is what says so.
-    A first pass here reported the range for every bounded scalar, and the view
-    drew IOR (soft range 1..3) half-filled at 1.500 -- while Blender's own
-    shader editor leaves IOR FLAT and fills only Roughness and Alpha. The
-    separating property is the SUBTYPE: `PROP_FACTOR` is what
+    The socket subtype determines whether Blender draws a slider: `PROP_FACTOR` is what
     `uiItemR`/`node_socket_button_default` pass `UI_ITEM_R_SLIDER` for, so a
     factor draws as `UI_BTYPE_NUM_SLIDER` with a filled back and every other
     number draws as a plain `UI_BTYPE_NUM`.
@@ -4550,61 +4030,28 @@ def _node_socket_range(socket):
         prop = socket.bl_rna.properties["default_value"]
     except (AttributeError, KeyError):
         return {}
-    if getattr(prop, "type", None) not in ("FLOAT", "INT"):
-        return {}
-    if getattr(prop, "array_length", 0):
+    if prop.type not in ("FLOAT", "INT"):
         return {}
-    if getattr(prop, "subtype", None) != "FACTOR":
+    if prop.array_length:
         return {}
-    low = getattr(prop, "soft_min", None)
-    high = getattr(prop, "soft_max", None)
-    if low is None or high is None:
+    if prop.subtype != "FACTOR":
         return {}
+    low = prop.soft_min
+    high = prop.soft_max
     if not (math.isfinite(low) and math.isfinite(high)) or high <= low:
         return {}
     return {"softMin": float(low), "softMax": float(high)}
 
 
 def _node_row(node):
-    """One node, as the node editor draws it.
-
-    `colorTag` is `Node.color_tag` (`rna_nodetree.cc:9480-9484`), which RNA
-    reads from `bke::node_color_tag(*node)` -- the very value
-    `node_get_colorid` (`node_draw.cc:1388-1434`) switches on to pick a header
-    colour. So the header hue is a READ of the engine, not a table of ours.
-
-    `panels` is `Node.panel_states` (`rna_nodetree.cc:9430-9434`): per panel,
-    the declaration's `persistent_uid` and `is_collapsed`, and NOTHING ELSE --
-    no label, and no way to ask which sockets belong to it. That membership
-    lives in the node's C++ declaration, which `node_update_basis_from_
-    declaration` (`node_draw.cc:1086-1218`) walks and bpy does not expose.
-    Measured 2026-09-19 on Blender 5.2.0 in the tab: `ShaderNodeBsdfPrincipled`
-    answers 8 panel states (uids 9, 11, 18, 25, 27, 33, 37, 40), all collapsed,
-    and not one of its 32 `NodeSocket`s carries a panel field.
-
-    RULED 2026-09-19: the MEMBERSHIP is traced from Blender's own `declare()`
-    bodies instead, so what this door owes is the COLLAPSED STATE the trace
-    cannot know -- per node, live, and changed under the person's hand. The
-    states arrive IN ORDER, because Blender indexes `panel_states_array` by
-    the declaration's panel INDEX (`node_draw.cc:1037`) and RNA's collection
-    IS that array; the uid rides along so a disagreement is visible rather
-    than silently mis-joined.
-
-    THE TRACE IS THE CONSUMER'S, NOT THIS PACKAGE'S, and the split is the
-    point: `@volter/editor-blender`'s `blender-node-panels.source.mjs` reads a Blender
-    CHECKOUT at the engine's pin and writes `blender.node-panels.json` beside
-    the view that draws with it. Nothing of it belongs here -- this package is
-    the engine and its wire, and it answers what the RUNNING engine knows.
-
-    `showOptions` is `Node.show_options` -> `NODE_OPTIONS`, the flag
-    `add_flat_items_for_layout` (`node_draw.cc:739-746`) returns early on."""
+    """Report node header colour tags, live panel states, sockets and show_options from RNA. Socket-panel labels and membership belong to the consumer’s Blender source declarations."""
     return {
         "name": node.name,
         "idname": node.bl_idname,
         "type": node.type,
         "typeLabel": node.bl_label,
         "label": node.label or None,
-        "colorTag": getattr(node, "color_tag", "NONE"),
+        "colorTag": node.color_tag,
         # `Node.location` is the tree-space corner Blender lays out from
         # (`node_update_basis`: `dy = loc.y`, `node_draw.cc:1297`); `width` is
         # the value `NODE_WIDTH(node)` scales (`node_intern.hh:337`).
@@ -4620,11 +4067,11 @@ def _node_row(node):
         # gives an OUTPUT-class node the output colour only when it is the
         # active output (`node_draw.cc:1395-1401`).
         "activeOutput": bool(getattr(node, "is_active_output", False)),
-        "panelCount": len(getattr(node, "panel_states", ())),
+        "panelCount": len(node.panel_states),
         "panels": [{"identifier": int(state.identifier),
                     "collapsed": bool(state.is_collapsed)}
-                   for state in getattr(node, "panel_states", ())],
-        "showOptions": bool(getattr(node, "show_options", True)),
+                   for state in node.panel_states],
+        "showOptions": bool(node.show_options),
         "inputs": [_node_socket(socket, index) for index, socket in enumerate(node.inputs)],
         "outputs": [_node_socket(socket, index) for index, socket in enumerate(node.outputs)],
     }
@@ -4644,7 +4091,7 @@ def _node_tree_of(path, material):
             raise ValueError("The engine holds no material named %r" % (material,))
     else:
         obj = bpy.context.view_layer.objects.active
-        mat = getattr(obj, "active_material", None) if obj is not None else None
+        mat = obj.active_material if obj is not None else None
     if mat is None:
         return None, None, None
     if not mat.use_nodes:
@@ -4707,32 +4154,7 @@ def _uv_object_of(object_name):
 
 
 def rna_uv_layout(object_name=None, uv_layer=None):
-    """ONE MESH'S UV LAYOUT, as Blender's UV editor would draw it.
-
-    WHY A DOOR AND NOT THE GENERIC VIEW. `rna_view` answers a struct at a time
-    and reports a collection as a COUNT, and a UV layout is
-    `len(mesh.loops)` two-float corners plus a triangulation -- 8,008 corners
-    over 31 meshes in `arena-weapons.blend`, measured 2026-09-19. The
-    per-corner arrays therefore cross as BASE64 typed-array bytes, exactly as
-    I4's weights do, and every scalar beside them is a `bl_rna` property the
-    generic door also answers.
-
-    WHAT IT IS NOT GATED ON. Blender draws UVs only when
-    `space_mode_is_uv && object_mode_is_edit` (`overlay_mesh.hh:593`), and both
-    halves of that are its UI layer's -- a space this engine has none of, and a
-    mode an inspection surface does not enter (orchestrator ruling 1,
-    2026-09-19: "inspection is not mode-gated"). So this reads the DATA in
-    whatever mode the engine is in and reports `mode` beside it, and the view
-    names the Blender mode the same picture would need.
-
-    THE SELECTION FLAGS ARE REPORTED WHERE THE DATA CARRIES THEM, and at this
-    pin an evaluated mesh usually carries none: `MeshUVLoopLayer`
-    (`rna_mesh.cc:2380-2456`) declares `uv`, `pin`, `name`, `active`,
-    `active_render` and `active_clone` -- and NO vertex or edge selection,
-    because UV selection lives in the BMesh an edit-mode session holds. `pin`
-    IS declared, so it is answered; everything else draws unselected, which is
-    the second half of the same ruling.
-    """
+    """Return per-corner UVs, triangulation, polygon ranges and pin flags as base64 typed arrays. Selection remains null outside edit-mode BMesh because MeshUVLoopLayer exposes no selection field."""
     obj = _uv_object_of(object_name)
     if obj is None:
         return {"object": None, "mesh": None, "layers": [], "active": None,
@@ -4811,7 +4233,7 @@ def _uv_backdrop_image(obj):
     (`ED_space_image_auto_set`, `space_image.cc:60-101`). There is no
     `SpaceImage` here, so the second half is the whole rule: the active
     material's node tree's active `TEX_IMAGE`."""
-    mat = getattr(obj, "active_material", None)
+    mat = obj.active_material
     if mat is None or not mat.use_nodes or mat.node_tree is None:
         return None
     nodes = [n for n in mat.node_tree.nodes if n.type == "TEX_IMAGE" and n.image is not None]
@@ -4824,25 +4246,7 @@ def _uv_backdrop_image(obj):
             "source": image.source, "hasData": bool(image.has_data)}
 
 
-# ------------------------------------------------------- the rig and its clip
-#
-# WE VISUALIZE WITH THREE.JS, NOT BLENDER (owner rule, 2026-09-20). Blender
-# holds the animation as DATA; three.js PLAYS it. A Timeline that asked Blender
-# to re-evaluate the depsgraph and re-export the columns once per frame would
-# be the wrong architecture -- so these two doors hand the tab everything it
-# needs to build a `THREE.SkinnedMesh` + `Skeleton` + `AnimationMixer` ONCE,
-# and the scrub, the playback and the frame counter after that are three.js's
-# with ZERO calls back into this process.
-#
-# WHAT THE BIND POSE IS, and why it is not the rest pose. The export door runs
-# with `evaluate: True`, so the mesh columns the presenter already holds are
-# the EVALUATED mesh -- the armature modifier included -- which means they are
-# the deformed mesh at whatever frame Blender is sitting on. Binding a skeleton
-# whose bones are in that SAME pose makes the skinning an identity there
-# (`skinMatrix = sum(w_i * B_i * B_i^-1) = I`), so the picture at the bind
-# frame is byte-for-byte the frame Blender presented, and every other frame is
-# three.js's own evaluation of the same skin. That is what lets Blender's
-# `frame_current` stand still for the whole of playback.
+# Export rig and clip data once for the presenter’s Skeleton and AnimationMixer. Bind to the evaluated pose so skinning is the identity at the exported frame; playback does not advance Blender’s frame_current.
 
 
 def _rig_armature_of(obj):
@@ -4854,170 +4258,18 @@ def _rig_armature_of(obj):
     return obj.find_armature()
 
 
-def _pose_bones_parents_first(arm_obj):
-    """Every pose bone, parents before children. `Object.pose.bones` is already
-    in hierarchy order at this pin, but three.js's `Skeleton` is built by
-    INDEX and a child whose parent has no index yet cannot be parented, so the
-    order is made explicit rather than assumed."""
-    order = []
-    seen = set()
-
-    def walk(pchan):
-        if pchan.name in seen:
-            return
-        parent = pchan.parent
-        if parent is not None:
-            walk(parent)
-        if pchan.name in seen:
-            return
-        seen.add(pchan.name)
-        order.append(pchan)
-
-    for pchan in arm_obj.pose.bones:
-        walk(pchan)
-    return order
-
-
 def _matrix_rows(matrix):
     return [[float(v) for v in row] for row in matrix]
 
 
-
-def _rig_of(obj):
-    """ONE MESH'S SKIN BINDING: the armature's bones, and up to four weighted
-    bone influences per Blender vertex.
-
-    WHY A DOOR AND NOT THE GENERIC VIEW, the same answer `rna_uv_layout` gives:
-    `rna_view` reports a collection as a COUNT, and a skin binding is
-    `len(mesh.vertices)` x 4 pairs -- 1,152 vertices is 4,608 of them on the
-    smallest probe. They cross as base64 typed-array bytes, the shape I4's
-    weights established: `skinIndexBase64` Uint16 (`vertices * 4`) and
-    `skinWeightBase64` Float32 (`vertices * 4`), normalized so the four sum to
-    one.
-
-    THE INDICES ARE BLENDER VERTEX INDICES, not drawn-vertex ones. The draw
-    splits a Blender vertex into as many drawn vertices as its corners need,
-    and `DrawArrays.sourceVertex` is the map -- so the presenter EXPANDS these
-    arrays through it (`blender-runtime-skin.ts`), exactly as I4's weight
-    overlay expands its ramp.
-
-    TWO MATRICES PER BONE, both in the armature OBJECT's space and row-major as
-    four rows: `rest` is `Bone.matrix_local` (the armature's rest pose, what
-    `pose.bones[...]` is measured against) and `pose` is `PoseBone.matrix` --
-    `pchan->pose_mat`, the SAME matrix I4's bone overlay draws. `pose` is the
-    BIND pose, because it is the pose the exported columns were evaluated at.
-    """
-    if obj is None or obj.type != "MESH" or obj.data is None:
-        return {"object": obj.name if obj is not None else None, "armature": None,
-                "bones": [], "vertexCount": 0,
-                "reason": "Only a mesh object carries a skin binding."}
-    mesh = obj.data
-    arm_obj = _rig_armature_of(obj)
-    header = {
-        "object": obj.name,
-        "mesh": mesh.name,
-        "vertexCount": len(mesh.vertices),
-        "frame": int(bpy.context.scene.frame_current),
-        "mode": bpy.context.mode,
-    }
-    if arm_obj is None:
-        header.update({"armature": None, "bones": [],
-                       "reason": "%r is deformed by no armature -- `Object.find_armature()` "
-                                 "answers none, so it presents as an ordinary Mesh." % (obj.name,)})
-        return header
-    order = _pose_bones_parents_first(arm_obj)
-    index_of = {pchan.name: i for i, pchan in enumerate(order)}
-    header.update({
-        "armature": arm_obj.name,
-        "armatureData": arm_obj.data.name,
-        # THE CONSTRAINT COUNT IS REPORTED because the CLIP is derived from the
-        # F-Curves alone (`rna_action_clip`) while this bind pose is read live
-        # off `PoseBone.matrix`. For a constraint-free rig the two agree by
-        # construction; a constrained bone's pose is Blender's solver's and the
-        # clip cannot reproduce it, so the view says so rather than drifting.
-        "constrainedBones": sorted(p.name for p in order if len(p.constraints)),
-        "bones": [{
-            "name": pchan.name,
-            "parent": pchan.parent.name if pchan.parent is not None else None,
-            "rest": _matrix_rows(pchan.bone.matrix_local),
-            "pose": _matrix_rows(pchan.matrix),
-            "length": float(pchan.bone.length),
-            "deform": bool(pchan.bone.use_deform),
-            "connected": bool(pchan.bone.use_connect),
-        } for pchan in order],
-    })
-    group_to_bone = {}
-    unmapped = []
-    for group in obj.vertex_groups:
-        bone = index_of.get(group.name)
-        if bone is None:
-            unmapped.append(group.name)
-        else:
-            group_to_bone[int(group.index)] = bone
-    count = len(mesh.vertices)
-    # FOUR INFLUENCES, which is three.js's `skinIndex`/`skinWeight` shape and
-    # also glTF's; a vertex with more is truncated to its four heaviest and
-    # RENORMALIZED, and the count of such vertices is reported rather than
-    # quietly dropped.
-    indices = array.array("H", bytes(count * 8))
-    weights = array.array("f", bytes(count * 16))
-    truncated = 0
-    unweighted = 0
-    most = 0
-    checkpoint_at = time.monotonic()
-    for i, vertex in enumerate(mesh.vertices):
-        if i % 1024 == 0 and time.monotonic() - checkpoint_at >= 0.05:
-            _asked({"checkpoint": "rig-weights"})
-            checkpoint_at = time.monotonic()
-        pairs = []
-        for element in vertex.groups:
-            bone = group_to_bone.get(int(element.group))
-            if bone is None:
-                continue
-            value = float(element.weight)
-            if value > 0.0:
-                pairs.append((value, bone))
-        most = max(most, len(pairs))
-        if len(pairs) > 4:
-            truncated += 1
-            pairs.sort(reverse=True)
-            pairs = pairs[:4]
-        total = sum(value for value, _ in pairs)
-        if total <= 0.0:
-            unweighted += 1
-            continue
-        for slot, (value, bone) in enumerate(pairs):
-            indices[i * 4 + slot] = bone
-            weights[i * 4 + slot] = value / total
-    header.update({
-        "skinIndexBase64": base64.b64encode(indices.tobytes()).decode("ascii"),
-        "skinWeightBase64": base64.b64encode(weights.tobytes()).decode("ascii"),
-        "maxInfluences": most,
-        "truncatedVertices": truncated,
-        "unweightedVertices": unweighted,
-        "unmappedGroups": unmapped,
-    })
-    return header
-
-
 def _action_channelbag(action, slot_handle):
-    """THE LAYERED ACTION'S F-CURVES. At this pin an `Action` HAS NO
-    `.fcurves` -- measured 2026-09-19 and again here: `hasattr(action,
-    'fcurves')` is False. They live at
-    `action.layers[i].strips[j].channelbags[k].fcurves`, and WHICH channelbag
-    is decided by the SLOT the animated object uses
-    (`Object.animation_data.action_slot`). The legacy attribute is still read
-    first for a build where it exists, which is the same two-branch shape the
-    rest of this file uses for a moved API."""
-    legacy = getattr(action, "fcurves", None)
-    if legacy is not None:
-        return list(legacy), "legacy"
-    for layer in getattr(action, "layers", ()):
-        for strip in getattr(layer, "strips", ()):
-            for bag in (getattr(strip, "channelbags", None) or ()):
-                if slot_handle is None or int(getattr(bag, "slot_handle", -1)) == int(slot_handle):
-                    return list(bag.fcurves), "layered"
-    return [], "none"
+    """Return the first matching channelbag's F-curves, or the first bag's when no slot is supplied; no match yields an empty list."""
+    for layer in action.layers:
+        for strip in layer.strips:
+            for bag in strip.channelbags:
+                if slot_handle is None or int(bag.slot_handle) == int(slot_handle):
+                    return list(bag.fcurves)
+    return []
 
 
 _BONE_PATH = re.compile(r'^pose\.bones\["(.+)"\]\.(location|rotation_quaternion|'
@@ -5040,7 +4292,7 @@ def _key_columns(curves):
             # EXTREME wins over KEYFRAME the way Blender's own merge does:
             # `nupdate_ak_bezt` keeps the "most significant" type
             # (`keyframes_keylist.cc`, `KEYFRAME_STATE` ordering).
-            if _KEY_TYPE_RANK.get(key.type, 0) > _KEY_TYPE_RANK.get(record["type"], 0):
+            if _KEY_TYPE_RANK[key.type] > _KEY_TYPE_RANK[record["type"]]:
                 record["type"] = key.type
     return columns
 
@@ -5065,12 +4317,12 @@ def _summary_objects():
     """
     out = []
     for obj in bpy.context.view_layer.objects:
-        adt = getattr(obj, "animation_data", None)
-        action = getattr(adt, "action", None) if adt is not None else None
+        adt = obj.animation_data
+        action = adt.action if adt is not None else None
         if action is None:
             continue
-        slot = getattr(adt, "action_slot", None)
-        curves, _shape = _action_channelbag(action, getattr(slot, "handle", None))
+        slot = adt.action_slot
+        curves = _action_channelbag(action, slot.handle if slot is not None else None)
         columns = _key_columns(curves)
         out.append({
             "object": obj.name,
@@ -5082,31 +4334,7 @@ def _summary_objects():
 
 
 def rna_action_clip(object_name=None, bake=True, action_name=None, summary=True):
-    """ONE ACTION AS A THREE.JS CLIP: per bone, the LOCAL transform it has at
-    every integer frame of the action's own range.
-
-    WHAT CROSSES, and why it is a BAKE rather than the raw keys. Blender's
-    channels are `PoseBone.location/rotation_*/scale` in the bone's own REST
-    space (`pchan->chan_mat`), while three.js's `Bone` carries a LOCAL
-    transform relative to its PARENT BONE. The relation is
-    `local = (parent.matrix_local^-1 @ bone.matrix_local) @ basis`, so no
-    per-channel re-labelling can turn one into the other -- the matrices have
-    to be composed. Composing them per KEY would then also have to reproduce
-    Blender's Bezier handles between keys, so the honest, one-code-path answer
-    is to SAMPLE at every integer frame and ship LINEAR tracks: exact at every
-    frame a Timeline can scrub to, linear in between, and stated as the
-    justified difference rather than implied.
-
-    THE FRAME IS NEVER MOVED to do it. `FCurve.evaluate(frame)` reads the curve
-    without touching `scene.frame_current` or the depsgraph, which is what
-    makes this door cheap and what keeps bpy's own frame where the person left
-    it.
-
-    A CONSTANT TRACK IS TWO KEYS. A rig's channels are overwhelmingly still --
-    an untouched bone contributes three tracks of identical samples -- so a
-    track whose every sample equals its first is shipped as its first and last
-    only. Measured on the probe below.
-    """
+    """Bake each bone’s parent-relative transform at integer action frames for a three.js clip. Convert from Blender rest space through the parent rest matrix; compact constant tracks to one sample."""
     if object_name:
         obj = bpy.data.objects.get(object_name)
         if obj is None:
@@ -5143,14 +4371,7 @@ def rna_action_clip(object_name=None, bake=True, action_name=None, summary=True)
         "slot": None,
         "tracks": [],
         "keyframes": [],
-        # EVERY ANIMATED OBJECT AND ITS SELECTION, unconditionally -- the
-        # Timeline's summary row is filtered by SELECTION in Blender
-        # (`show_keys_from_selected_only`) and the view is what decides which
-        # side of that filter it is on, so the door answers both halves even
-        # when the subject below turns out to be nothing at all.
-        # `summary=False` for a reader that plays the clip (a game's clip library): the row walks
-        # every animated object in the view layer, which was ~690 of a ~700 ms read on a level of
-        # 23 armatures (measured 2026-10-08), and nothing that plays a clip draws it.
+        # Include every animated object and its selection for Timeline summary filtering. A clip-only reader passes summary=False to skip the scene-wide summary walk.
         "summary": _summary_objects() if summary else [],
     }
     adt = arm_obj.animation_data if arm_obj is not None else None
@@ -5164,11 +4385,11 @@ def rna_action_clip(object_name=None, bake=True, action_name=None, summary=True)
                                 "and an empty summary row, which is Blender's own empty state.")
         return header
     action = assigned
-    slot = getattr(adt, "action_slot", None) if adt is not None else None
+    slot = adt.action_slot if adt is not None else None
     if action_name and (assigned is None or action_name != assigned.name):
         # A NAMED ACTION, assigned or not (a game's clip library: Idle, Run, Attack side by side):
-        # baked against this armature WITHOUT assigning it, so the file is untouched. Its curves
-        # are its first channelbag's (no slot of this object chooses among them).
+        # baked against this armature WITHOUT assigning it, so the file is untouched. The
+        # owner's identifier selects its slot, otherwise the first object slot is used.
         action = bpy.data.actions.get(action_name)
         if action is None:
             raise ValueError("The engine holds no action named %r" % (action_name,))
@@ -5176,23 +4397,20 @@ def rna_action_clip(object_name=None, bake=True, action_name=None, summary=True)
         # identifier names this object (`OB<name>`), else the only object slot. A layered action
         # with several object slots and none for this armature has no right answer; its first
         # object slot is used and said in the reason.
-        slots = [one for one in getattr(action, "slots", ()) if getattr(one, "target_id_type", "OBJECT") == "OBJECT"]
-        slot = next((one for one in slots if getattr(one, "identifier", "") == "OB" + arm_obj.name), None)
+        slots = [one for one in action.slots if one.target_id_type == "OBJECT"]
+        slot = next((one for one in slots if one.identifier == "OB" + arm_obj.name), None)
         if slot is None and slots:
             slot = slots[0]
             if len(slots) > 1:
                 header["reason"] = ("%r has %d object slots and none named for %r; the first, %r, is played."
-                                    % (action.name, len(slots), arm_obj.name, getattr(slot, "identifier", "?")))
-    curves, shape = _action_channelbag(action, getattr(slot, "handle", None))
-    # HOW MANY OBJECT SLOTS THE ACTION HAS: with one (or a legacy action, none) every armature
-    # reads the same curves, so a reader may share the clip across armatures with the same bones;
-    # with several, which one plays depends on the armature, so it may not.
-    header["objectSlots"] = len([one for one in getattr(action, "slots", ())
-                                 if getattr(one, "target_id_type", "OBJECT") == "OBJECT"])
+                                    % (action.name, len(slots), arm_obj.name, slot.identifier))
+    curves = _action_channelbag(action, slot.handle if slot is not None else None)
+    # Report object-slot count so consumers share a clip across matching armatures only when its channel set is independent of the owner.
+    header["objectSlots"] = len([one for one in action.slots
+                                 if one.target_id_type == "OBJECT"])
     header.update({
         "action": action.name,
-        "slot": getattr(slot, "name_display", None),
-        "channels": shape,
+        "slot": slot.name_display if slot is not None else None,
         "fcurves": len(curves),
         "keys": sum(len(fc.keyframe_points) for fc in curves),
     })
@@ -5208,32 +4426,32 @@ def rna_action_clip(object_name=None, bake=True, action_name=None, summary=True)
     # THE ACTION'S OWN RANGE (`Action.frame_range`: its keys, or its manual range) with its keys:
     # what a strip or the action line plays, sampled through `FCurve.evaluate`, which applies the
     # curves' extrapolation and modifiers (a Cycles modifier repeats them) as Blender does.
-    span = getattr(action, "frame_range", None)
-    first = int(math.floor(min(frames[0], span[0] if span is not None else frames[0])))
-    last = int(math.ceil(max(frames[-1], span[1] if span is not None else frames[-1])))
+    span = action.frame_range
+    first = int(math.floor(min(frames[0], span[0])))
+    last = int(math.ceil(max(frames[-1], span[1])))
     if last <= first:
         last = first + 1
     header["clipStart"] = first
     header["clipEnd"] = last
-    # THE RANGE BLENDER PLACES THE ACTIVE ACTION OVER over NLA strips (`calc_action_range` with
-    # modifiers): its keys, opened to either side a Cycles modifier repeats into (null: unbounded).
-    # A manual frame range does not enter it. Measured: a cycling action is not held at its end.
+    # Report the active action range including Cycles modifier extensions; null bounds are unbounded. The manual frame range does not enter it.
     header["keysStart"], header["keysEnd"] = _action_key_range(action, first, last)
     channels = {}
     others = set()
     for fcurve in curves:
         match = _BONE_PATH.match(fcurve.data_path)
         if match is None:
-            # NOT A BONE'S CHANNEL: the armature object's own transform (root motion), a custom
-            # property, a bone channel this door does not read. Named, so it is never dropped quietly.
-            others.add(fcurve.data_path)
+            # NOT A BONE'S CHANNEL: a custom property, a bone channel this door does not read.
+            # Named, so it is never dropped quietly. The armature object's OWN transform is not
+            # this door's either, but it plays: the scene's movie (`rna_scene_movie`) carries it.
+            if _OBJECT_PATH.match(fcurve.data_path) is None:
+                others.add(fcurve.data_path)
             continue
         bone, prop = match.group(1), match.group(2)
         channels.setdefault((bone, prop), {})[int(fcurve.array_index)] = fcurve
     if not channels:
-        header["reason"] = ("%r animates no pose bone -- every F-Curve is on a data path this "
-                            "door does not play (object transform, shape keys, a material). The "
-                            "Timeline still draws its keys." % (action.name,))
+        header["reason"] = ("%r has no pose-bone transform channels. The scene's movie "
+                            "(`rna_scene_movie`) carries supported object, material and shape-key "
+                            "animation; the Timeline still draws this action's keys." % (action.name,))
         return header
     tracks = []
     unplayed = []
@@ -5247,12 +4465,621 @@ def rna_action_clip(object_name=None, bake=True, action_name=None, summary=True)
         header["unsupported"] = ["curves on %s" % ", ".join(sorted(others))]
     header.update({
         "tracks": tracks,
+        "bones": _three_bones(arm_obj, channels, first, last),
         "duration": (last - first) / fps,
         "unplayedBones": unplayed,
     })
     return header
 
 
+def _three_bones(arm_obj, channels, first, last):
+    """THE ACTION AS THREE.JS PLAYS IT: per bone it keys, the bone's LOCAL transform (relative to
+    its parent bone, as a `THREE.Bone` carries it) at every integer frame from `first` to `last`.
+
+    Blender evaluates every channel (`FCurve.evaluate`: its keys, handles, interpolation, easing,
+    extrapolation and modifiers); a component the action does not key keeps the bone's own value.
+    The basis is composed by the bone's rotation mode and placed by its rest relative to its
+    parent's rest, `local = (parent.matrix_local^-1 @ bone.matrix_local) @ basis`, so a clip moves
+    a bone exactly as Blender's pose does at every frame, and three.js interpolates between them.
+
+    Each column crosses as base64 Float32: `position` three per frame, `quaternion` four (x, y, z,
+    w, as three reads them, kept on one hemisphere so a slerp never turns the long way), `scale`
+    three. A column whose every sample equals its first crosses as that one sample."""
+    frames = list(range(first, last + 1))
+    by_bone = {}
+    for (bone, prop), components in channels.items():
+        by_bone.setdefault(bone, {})[prop] = components
+    out = []
+    for name in sorted(by_bone):
+        pbone = arm_obj.pose.bones.get(name)
+        if pbone is None:
+            continue
+        rest = pbone.bone.matrix_local
+        parent = pbone.bone.parent
+        rest_relative = (parent.matrix_local.inverted() @ rest) if parent is not None else rest.copy()
+        props = by_bone[name]
+        mode = pbone.rotation_mode
+        own = {
+            "location": list(pbone.location),
+            "rotation_quaternion": list(pbone.rotation_quaternion),
+            "rotation_euler": list(pbone.rotation_euler),
+            "rotation_axis_angle": list(pbone.rotation_axis_angle),
+            "scale": list(pbone.scale),
+        }
+        position = array.array("f")
+        quaternion = array.array("f")
+        scale = array.array("f")
+        last_q = None
+        keys = set()
+        for components in props.values():
+            for fcurve in components.values():
+                for point in fcurve.keyframe_points:
+                    keys.add(round(float(point.co[0]), 3))
+        for frame in frames:
+            values = {prop: list(value) for prop, value in own.items()}
+            for prop, components in props.items():
+                for index, fcurve in components.items():
+                    if index < len(values[prop]):
+                        values[prop][index] = fcurve.evaluate(frame)
+            if mode == "QUATERNION":
+                rotation = mathutils.Quaternion(values["rotation_quaternion"]).normalized()
+            elif mode == "AXIS_ANGLE":
+                angle, x, y, z = values["rotation_axis_angle"]
+                axis = mathutils.Vector((x, y, z))
+                rotation = mathutils.Quaternion(axis.normalized() if axis.length > 0 else (0.0, 1.0, 0.0), angle)
+            else:
+                rotation = mathutils.Euler(values["rotation_euler"], mode).to_quaternion()
+            basis = mathutils.Matrix.LocRotScale(mathutils.Vector(values["location"]), rotation,
+                                                 mathutils.Vector(values["scale"]))
+            loc, rot, size = (rest_relative @ basis).decompose()
+            if last_q is not None and last_q.dot(rot) < 0:
+                rot.negate()
+            last_q = rot
+            position.extend((loc.x, loc.y, loc.z))
+            quaternion.extend((rot.x, rot.y, rot.z, rot.w))
+            scale.extend((size.x, size.y, size.z))
+
+        out.append({"bone": name, "keys": sorted(keys), "position": _column(position, 3),
+                    "quaternion": _column(quaternion, 4), "scale": _column(scale, 3)})
+    return out
+
+
+# ------------------------------------------------------------- the scene's movie
+
+# AN OBJECT'S OWN TRANSFORM CHANNELS, as an action keys them on the object (not on a bone).
+_OBJECT_PATH = re.compile(r'^(location|rotation_quaternion|rotation_euler|rotation_axis_angle|scale)$')
+# A CAMERA'S KEYABLE PROJECTION, as an action keys it on the camera's data.
+_CAMERA_PROPS = ("lens", "sensor_width", "sensor_height", "ortho_scale", "shift_x", "shift_y",
+                 "clip_start", "clip_end")
+
+
+def _slot_handle(action, owner, prefix, slot):
+    """Use the assigned slot, then the owner identifier, then the first slot of the owner’s ID type."""
+    if slot is not None:
+        return slot.handle
+    slots = list(action.slots)
+    if not slots:
+        return None
+    kind = {"OB": "OBJECT", "CA": "CAMERA", "NT": "NODETREE", "KE": "KEY", "SC": "SCENE"}[prefix]
+    named = next((one for one in slots if one.identifier == prefix + owner.name), None)
+    if named is not None:
+        return named.handle
+    typed = [one for one in slots if one.target_id_type == kind]
+    return typed[0].handle if typed else None
+
+
+def _object_constraints(obj):
+    """An object's constraint stack, in order: Damped Track and Track To carry what the presenter
+    evaluates them from; every other type is named and played only in Blender."""
+    stack = []
+    for con in obj.constraints:
+        target = getattr(con, "target", None)
+        entry = {"name": con.name, "type": con.type, "enabled": bool(con.enabled),
+                 "influence": float(con.influence)}
+        if target is not None:
+            entry["target"] = target.name
+        if con.type in ("DAMPED_TRACK", "TRACK_TO"):
+            entry["trackAxis"] = con.track_axis
+        if con.type == "TRACK_TO":
+            entry["upAxis"] = con.up_axis
+            entry["useTargetZ"] = bool(con.use_target_z)
+        stack.append(entry)
+    return stack
+
+
+def _column(samples, stride):
+    """A sampled column as base64 Float32: its first sample alone when it never changes."""
+    if len(samples) > stride and all(abs(samples[i] - samples[i % stride]) < 1e-7 for i in range(len(samples))):
+        samples = samples[:stride]
+    return {"count": len(samples) // stride, "base64": base64.b64encode(samples.tobytes()).decode("ascii")}
+
+
+def _owner_action_at(adt, frame):
+    """Use the active action at the scene frame, otherwise the last unmuted strip containing it,
+    or the first unmuted strip when none contains it. Clamp to that strip's range and apply its
+    scale and repeat. Return no action when no unmuted action strip exists."""
+    if adt.action is not None:
+        return adt.action, frame
+    best = None
+    for track in adt.nla_tracks:
+        if track.mute:
+            continue
+        for strip in track.strips:
+            if strip.mute or strip.action is None:
+                continue
+            if strip.frame_start <= frame <= strip.frame_end or best is None:
+                best = strip
+    if best is None:
+        return None, frame
+    length = (best.action_frame_end - best.action_frame_start) or 1.0
+    scale = abs(best.scale) or 1.0
+    at = min(max(frame, best.frame_start), best.frame_end)
+    into = ((at - best.frame_start) / scale) % length if at < best.frame_end else length
+    return best.action, best.action_frame_start + into
+
+
+def _sample_object(obj, pre, delta, first, last, unsupported):
+    """AN OBJECT'S MOVIE AS THREE.JS PLAYS IT: its local transform (`pre @ basis`, the basis with its
+    delta transform, `BKE_object_to_mat4`) at every scene frame from `first` to `last`, each channel
+    evaluated by Blender (`FCurve.evaluate`) from the action it shows there. Columns as the clip
+    door's: position, quaternion (x, y, z, w, one hemisphere), scale; and `hidden` (one per frame,
+    1 hidden) when its render visibility is keyed."""
+    adt = obj.animation_data
+    if len([track for track in adt.nla_tracks if not track.mute]) > 1 or (adt.action is not None and len(adt.nla_tracks)):
+        unsupported.append("its NLA layering (the active action, else the top strip, is played)")
+    position = array.array("f")
+    quaternion = array.array("f")
+    scale = array.array("f")
+    hidden = array.array("f")
+    keyed_hidden = False
+    last_q = None
+    mode = obj.rotation_mode
+    own = {"location": list(obj.location), "rotation_quaternion": list(obj.rotation_quaternion),
+           "rotation_euler": list(obj.rotation_euler), "rotation_axis_angle": list(obj.rotation_axis_angle),
+           "scale": list(obj.scale), "hide_render": [float(obj.hide_render)]}
+    curves_of = {}
+    for frame in range(first, last + 1):
+        action, at = _owner_action_at(adt, frame)
+        values = {prop: list(value) for prop, value in own.items()}
+        if action is not None:
+            curves = curves_of.get(action.name)
+            if curves is None:
+                handle = _slot_handle(action, obj, "OB", adt.action_slot if action == adt.action else None)
+                curves = curves_of[action.name] = _action_channelbag(action, handle)
+            for fcurve in curves:
+                if fcurve.data_path in values and fcurve.array_index < len(values[fcurve.data_path]):
+                    values[fcurve.data_path][fcurve.array_index] = fcurve.evaluate(at)
+                    if fcurve.data_path == "hide_render":
+                        keyed_hidden = True
+        if mode == "QUATERNION":
+            rotation = mathutils.Quaternion(values["rotation_quaternion"]).normalized()
+        elif mode == "AXIS_ANGLE":
+            angle, x, y, z = values["rotation_axis_angle"]
+            axis = mathutils.Vector((x, y, z))
+            rotation = mathutils.Quaternion(axis.normalized() if axis.length > 0 else (0.0, 0.0, 1.0), angle)
+        else:
+            rotation = mathutils.Euler(values["rotation_euler"], mode).to_quaternion()
+        rotation = delta @ rotation
+        location = mathutils.Vector(values["location"]) + obj.delta_location
+        size = mathutils.Vector([a * b for a, b in zip(values["scale"], obj.delta_scale)])
+        loc, rot, sca = (pre @ mathutils.Matrix.LocRotScale(location, rotation, size)).decompose()
+        if last_q is not None and last_q.dot(rot) < 0:
+            rot.negate()
+        last_q = rot
+        position.extend((loc.x, loc.y, loc.z))
+        quaternion.extend((rot.x, rot.y, rot.z, rot.w))
+        scale.extend((sca.x, sca.y, sca.z))
+        hidden.append(1.0 if values["hide_render"][0] >= 0.5 else 0.0)
+    out = {"start": first, "end": last, "position": _column(position, 3), "quaternion": _column(quaternion, 4),
+           "scale": _column(scale, 3)}
+    if keyed_hidden:
+        out["hidden"] = _column(hidden, 1)
+    return out
+
+
+def _sample_camera(data, first, last):
+    """A CAMERA'S PROJECTION AS THE MOVIE HAS IT: each of `_CAMERA_PROPS` at every scene frame, by
+    Blender's evaluation of the action its data shows there."""
+    adt = data.animation_data
+    columns = {prop: array.array("f") for prop in _CAMERA_PROPS}
+    curves_of = {}
+    for frame in range(first, last + 1):
+        action, at = _owner_action_at(adt, frame)
+        values = {prop: float(getattr(data, prop)) for prop in _CAMERA_PROPS}
+        if action is not None:
+            curves = curves_of.get(action.name)
+            if curves is None:
+                handle = _slot_handle(action, data, "CA", adt.action_slot if action == adt.action else None)
+                curves = curves_of[action.name] = _action_channelbag(action, handle)
+            for fcurve in curves:
+                if fcurve.data_path in values:
+                    values[fcurve.data_path] = fcurve.evaluate(at)
+        for prop in _CAMERA_PROPS:
+            columns[prop].append(values[prop])
+    return {"start": first, "end": last, **{prop: _column(column, 1) for prop, column in columns.items()}}
+
+
+_MATERIAL_INPUTS = {"Base Color": 4, "Emission Color": 4, "Emission Strength": 1, "Alpha": 1}
+
+
+def _sample_material(material, first, last):
+    """Sample a material’s keyed Principled Base Color, Emission and Alpha through the action its
+    node tree shows at each scene frame. Return only keyed inputs, or None when none are keyed."""
+    tree = material.node_tree
+    adt = tree.animation_data if tree is not None else None
+    if adt is None:
+        return None
+    bsdf = next((node for node in tree.nodes if node.type == "BSDF_PRINCIPLED"), None)
+    if bsdf is None:
+        return None
+    index = {}
+    for i, socket in enumerate(bsdf.inputs):
+        index.setdefault(socket.name, i)
+    paths = {}
+    own = {}
+    for name, size in _MATERIAL_INPUTS.items():
+        paths['nodes["%s"].inputs[%d].default_value' % (bsdf.name, index[name])] = name
+        value = bsdf.inputs[index[name]].default_value
+        own[name] = [float(v) for v in value] if size > 1 else [float(value)]
+    keyed = set()
+    color, emissive, opacity = array.array("f"), array.array("f"), array.array("f")
+    curves_of = {}
+    for frame in range(first, last + 1):
+        action, at = _owner_action_at(adt, frame)
+        values = {name: list(value) for name, value in own.items()}
+        if action is not None:
+            curves = curves_of.get(action.name)
+            if curves is None:
+                handle = _slot_handle(action, tree, "NT", adt.action_slot if action == adt.action else None)
+                curves = curves_of[action.name] = _action_channelbag(action, handle)
+            for fcurve in curves:
+                name = paths.get(fcurve.data_path)
+                if name is not None and fcurve.array_index < len(values[name]):
+                    values[name][fcurve.array_index] = fcurve.evaluate(at)
+                    keyed.add(name)
+        base = values["Base Color"]
+        color.extend(base[:3])
+        glow = values["Emission Color"]
+        strength = values["Emission Strength"][0]
+        emissive.extend((glow[0] * strength, glow[1] * strength, glow[2] * strength))
+        opacity.append(values["Alpha"][0])
+    if not keyed:
+        return None
+    out = {"start": first, "end": last}
+    if "Base Color" in keyed:
+        out["color"] = _column(color, 3)
+    if keyed & {"Emission Color", "Emission Strength"}:
+        out["emissive"] = _column(emissive, 3)
+    if "Alpha" in keyed:
+        out["opacity"] = _column(opacity, 1)
+    return out
+
+
+def _sample_shapes(obj, first, last, depsgraph):
+    """Sample each keyed relative shape key’s vertex offsets and values at every scene frame,
+    including the presented geometry’s current value. mapped is False when modifiers change vertex
+    correspondence. Return None when no key is keyed."""
+    mesh = obj.data
+    keys = mesh.shape_keys if mesh is not None else None
+    if keys is None or not keys.use_relative or len(keys.key_blocks) < 2:
+        return None
+    adt = keys.animation_data
+    if adt is None:
+        return None
+    blocks = list(keys.key_blocks)[1:]
+    path_of = {'key_blocks["%s"].value' % block.name: block.name for block in blocks}
+    values = {block.name: array.array("f") for block in blocks}
+    keyed = set()
+    curves_of = {}
+    for frame in range(first, last + 1):
+        action, at = _owner_action_at(adt, frame)
+        now = {block.name: float(block.value) for block in blocks}
+        if action is not None:
+            curves = curves_of.get(action.name)
+            if curves is None:
+                handle = _slot_handle(action, keys, "KE", adt.action_slot if action == adt.action else None)
+                curves = curves_of[action.name] = _action_channelbag(action, handle)
+            for fcurve in curves:
+                name = path_of.get(fcurve.data_path)
+                if name is not None:
+                    now[name] = fcurve.evaluate(at)
+                    keyed.add(name)
+        for name, value in now.items():
+            values[name].append(value)
+    if not keyed:
+        return None
+    count = len(obj.data.vertices)
+    try:
+        mapped = len(obj.evaluated_get(depsgraph).data.vertices) == count
+    except Exception:
+        mapped = False
+    out = []
+    for block in blocks:
+        if block.name not in keyed:
+            continue
+        own = array.array("f", [0.0]) * (3 * count)
+        base = array.array("f", [0.0]) * (3 * count)
+        block.data.foreach_get("co", own)
+        (block.relative_key or keys.reference_key).data.foreach_get("co", base)
+        delta = array.array("f", (a - b for a, b in zip(own, base)))
+        out.append({"name": block.name, "delta": {"count": count, "base64": base64.b64encode(delta.tobytes()).decode("ascii")},
+                    "values": _column(values[block.name], 1), "current": float(block.value)})
+    return {"object": obj.name, "start": first, "end": last, "vertices": count, "mapped": mapped, "keys": out}
+
+
+def rna_scene_movie():
+    """Scene animation for Timeline preview and export: range, rate, camera, bound
+    markers and sampled object, camera, material and shape-key columns. Object
+    records retain parent-space transforms and constraints. Cameras named by
+    the scene or a marker are included whether animated or not. Sampling leaves
+    the scene frame unchanged."""
+    scene = bpy.context.scene
+    view_layer = bpy.context.view_layer
+    fps = float(scene.render.fps) / float(scene.render.fps_base or 1.0)
+    markers = []
+    for marker in scene.timeline_markers:
+        markers.append({"name": marker.name, "frame": int(marker.frame),
+                        "camera": marker.camera.name if marker.camera is not None else None})
+    wanted = {marker["camera"] for marker in markers if marker["camera"]}
+    if scene.camera is not None:
+        wanted.add(scene.camera.name)
+
+    def transform(path):
+        return path if _OBJECT_PATH.match(path) or path == "hide_render" else None
+
+    def projection(path):
+        return path if path in _CAMERA_PROPS else None
+
+    objects = []
+    animated = {}
+    for obj in view_layer.objects:
+        own = _owner_animated(obj, transform, animated)
+        constraints = _object_constraints(obj)
+        camera = None
+        if obj.type == "CAMERA" and obj.data is not None:
+            data = obj.data
+            camera = {
+                "type": data.type, "lens": float(data.lens), "sensor_width": float(data.sensor_width),
+                "sensor_height": float(data.sensor_height), "sensor_fit": data.sensor_fit,
+                "ortho_scale": float(data.ortho_scale), "clip_start": float(data.clip_start),
+                "clip_end": float(data.clip_end), "shift_x": float(data.shift_x), "shift_y": float(data.shift_y),
+                "renderHidden": bool(obj.hide_render),
+                **({"keyed": True} if _owner_animated(data, projection, animated) else {}),
+            }
+        if not own and (camera is None or (obj.name not in wanted and "keyed" not in camera)):
+            continue
+        unsupported = []
+        parent = obj.parent
+        if parent is None:
+            pre = mathutils.Matrix.Identity(4)
+        elif obj.parent_type == "OBJECT":
+            pre = obj.matrix_parent_inverse
+        else:
+            # Parented to a bone, a vertex or a curve: the offset it has now is held.
+            pre = (parent.matrix_world.inverted_safe() @ obj.matrix_world) @ obj.matrix_basis.inverted_safe()
+            unsupported.append("its %s parenting (held where it is now)" % obj.parent_type.lower())
+        mode = obj.rotation_mode
+        if mode == "QUATERNION":
+            delta = obj.delta_rotation_quaternion.normalized()
+        elif mode == "AXIS_ANGLE":
+            delta = mathutils.Quaternion((1.0, 0.0, 0.0, 0.0))
+        else:
+            delta = mathutils.Euler(obj.delta_rotation_euler, mode).to_quaternion()
+        adt = obj.animation_data
+        if adt is not None:
+            for path in sorted({fc.data_path for fc in adt.drivers if _OBJECT_PATH.match(fc.data_path)}):
+                unsupported.append("the driver on its %s" % path)
+        for con in constraints:
+            if con["enabled"] and con["type"] not in ("DAMPED_TRACK", "TRACK_TO"):
+                unsupported.append("its %s constraint %r" % (con["type"].replace("_", " ").title(), con["name"]))
+        sampled = _sample_object(obj, pre, delta, int(scene.frame_start), int(scene.frame_end),
+                                 unsupported) if own else None
+        if camera is not None and camera.pop("keyed", False):
+            camera["sampled"] = _sample_camera(obj.data, int(scene.frame_start), int(scene.frame_end))
+        objects.append({
+            "name": obj.name,
+            "type": obj.type,
+            "parent": parent.name if parent is not None else None,
+            **({"sampled": sampled} if sampled is not None else {}),
+            "rotationMode": mode,
+            "channels": {
+                "location": [float(v) for v in obj.location],
+                "rotation_quaternion": [float(v) for v in obj.rotation_quaternion],
+                "rotation_euler": [float(v) for v in obj.rotation_euler],
+                "rotation_axis_angle": [float(v) for v in obj.rotation_axis_angle],
+                "scale": [float(v) for v in obj.scale],
+            },
+            "delta": {"location": [float(v) for v in obj.delta_location], "rotation": [float(v) for v in delta],
+                      "scale": [float(v) for v in obj.delta_scale]},
+            "pre": _matrix_rows(pre),
+            "constraints": constraints,
+            **({"camera": camera} if camera is not None else {}),
+            **({"unsupported": unsupported} if unsupported else {}),
+        })
+    # Sample keyed material inputs and shape keys.
+    first, last = int(scene.frame_start), int(scene.frame_end)
+    materials = []
+    seen = set()
+    for obj in view_layer.objects:
+        for slot in obj.material_slots:
+            material = slot.material
+            if material is None or material.name in seen:
+                continue
+            seen.add(material.name)
+            sampled = _sample_material(material, first, last)
+            if sampled is not None:
+                materials.append({"name": material.name, **sampled})
+    depsgraph = bpy.context.evaluated_depsgraph_get()
+    shapes = [one for one in (_sample_shapes(obj, first, last, depsgraph) for obj in view_layer.objects if obj.type == "MESH") if one]
+    return {
+        "materials": materials,
+        "shapes": shapes,
+        "scene": {"name": scene.name, "start": int(scene.frame_start), "end": int(scene.frame_end), "fps": fps,
+                  "current": int(scene.frame_current),
+                  "camera": scene.camera.name if scene.camera is not None else None},
+        "markers": sorted(markers, key=lambda marker: marker["frame"]),
+        "objects": objects,
+    }
+
+
+def rna_sound_scene(first, last):
+    """The scene's sound for the page to mix (docs/adr/movie-sound-and-react-frames.md,
+    decision 2). Native audio mixing is unavailable in this Blender. Describe the movie's frames
+    `first` to `last` for `@volter/editor-blender` to render in an OfflineAudioContext:
+
+      - the sequencer's sound strips: each one's file (or, packed, a copy written beside the
+        session), where its sound starts and where the strip is cut, its speed, whether it is muted
+        or mono, and its volume and pan at every frame, read through the scene's F-Curves (a fade
+        is keys on volume);
+      - the speakers: each one's file, the frames its NLA sound strips start on, its volume and
+        distance settings, and its place and facing at every frame, with the scene camera's (the
+        listener). Those are evaluated, so the frame moves and is restored.
+
+    The scene's own volume and distance model come too. READ ONLY: no history, save or present."""
+    scene = bpy.context.scene
+    fps = float(scene.render.fps) / float(scene.render.fps_base or 1.0)
+    count = last - first + 1
+
+    def sound_file(sound):
+        if sound is None:
+            return None
+        if sound.packed_file is not None:
+            path = os.path.join(ROOT, "sound-%s" % hashlib.sha256(sound.name.encode("utf-8")).hexdigest()[:16])
+            with open(path, "wb") as out:
+                out.write(sound.packed_file.data)
+            return {"packed": path}
+        # normalized: a path saved relative to the .blend ("//../../sounds/x.wav") keeps its ".." segments otherwise
+        return {"path": os.path.normpath(bpy.path.abspath(sound.filepath, library=sound.library))}
+
+    # A strip's keyed volume and pan are the scene's F-Curves on the strip's own path.
+    adt = scene.animation_data
+    curves = {}
+    if adt is not None and adt.action is not None:
+        handle = _slot_handle(adt.action, scene, "SC", adt.action_slot)
+        for fcurve in _action_channelbag(adt.action, handle):
+            curves[(fcurve.data_path, fcurve.array_index)] = fcurve
+
+    def sampled(strip, prop):
+        constant = float(getattr(strip, prop))
+        fcurve = next((curves[(path, 0)] for path in (
+            'sequence_editor.strips_all["%s"].%s' % (strip.name, prop),
+            'sequence_editor.sequences_all["%s"].%s' % (strip.name, prop)) if (path, 0) in curves), None)
+        values = array.array("f", (fcurve.evaluate(frame) if fcurve is not None else constant
+                                   for frame in range(first, last + 1)))
+        return _column(values, 1)
+
+    editor = scene.sequence_editor
+    strips = []
+    if editor is not None:
+        channels = editor.channels
+        for strip in editor.strips_all:
+            if strip.type != "SOUND":
+                continue
+            channel = channels[strip.channel] if 0 <= strip.channel < len(channels) else None
+            strips.append({
+                "name": strip.name,
+                "file": sound_file(strip.sound),
+                "mono": bool(strip.sound is not None and strip.sound.use_mono),
+                "muted": bool(strip.mute or (channel is not None and channel.mute)),
+                "start": float(strip.frame_start),
+                "finalStart": float(strip.frame_final_start),
+                "finalEnd": float(strip.frame_final_end),
+                "speed": float(getattr(strip, "speed_factor", 1.0)),
+                "volume": sampled(strip, "volume"),
+                "pan": sampled(strip, "pan"),
+            })
+
+    speakers = [obj for obj in scene.objects if obj.type == "SPEAKER" and obj.data is not None]
+    described = []
+    listener = None
+    if speakers:
+        tracks = {obj.name: [] for obj in speakers}
+        for obj in speakers:
+            for track in (obj.animation_data.nla_tracks if obj.animation_data is not None else ()):
+                if track.mute:
+                    continue
+                for strip in track.strips:
+                    if strip.type == "SOUND" and not strip.mute:
+                        tracks[obj.name].append(float(strip.frame_start))
+        places = {obj.name: array.array("f") for obj in speakers}
+        facings = {obj.name: array.array("f") for obj in speakers}
+        volumes = {obj.name: array.array("f") for obj in speakers}
+        heard = {"position": array.array("f"), "forward": array.array("f"), "up": array.array("f")}
+        kept = scene.frame_current
+        try:
+            for frame in range(first, last + 1):
+                scene.frame_set(frame)
+                for obj in speakers:
+                    matrix = obj.matrix_world
+                    places[obj.name].extend(matrix.translation)
+                    facings[obj.name].extend((matrix.to_3x3() @ mathutils.Vector((0.0, 0.0, -1.0))).normalized())
+                    volumes[obj.name].append(float(obj.data.volume))
+                camera = scene.camera
+                matrix = camera.matrix_world if camera is not None else mathutils.Matrix.Identity(4)
+                heard["position"].extend(matrix.translation)
+                heard["forward"].extend((matrix.to_3x3() @ mathutils.Vector((0.0, 0.0, -1.0))).normalized())
+                heard["up"].extend((matrix.to_3x3() @ mathutils.Vector((0.0, 1.0, 0.0))).normalized())
+        finally:
+            scene.frame_set(kept)
+        for obj in speakers:
+            data = obj.data
+            described.append({
+                "name": obj.name,
+                "file": sound_file(data.sound),
+                "muted": bool(data.muted),
+                "starts": tracks[obj.name],
+                "volume": _column(volumes[obj.name], 1),
+                "volumeMin": float(data.volume_min),
+                "volumeMax": float(data.volume_max),
+                "attenuation": float(data.attenuation),
+                "distanceReference": float(data.distance_reference),
+                "distanceMax": float(data.distance_max),
+                "coneInner": float(data.cone_angle_inner),
+                "coneOuter": float(data.cone_angle_outer),
+                "coneOuterVolume": float(data.cone_volume_outer),
+                "position": _column(places[obj.name], 3),
+                "facing": _column(facings[obj.name], 3),
+            })
+        listener = {key: _column(column, 3) for key, column in heard.items()}
+
+    return {
+        "fps": fps, "first": first, "last": last, "count": count,
+        "volume": float(scene.audio_volume),
+        # `use_audio` is the negation of `AUDIO_MUTE`: true, the default, plays the sequencer's sound
+        "muted": not bool(scene.use_audio),
+        "distanceModel": scene.audio_distance_model,
+        "strips": strips,
+        "speakers": described,
+        "listener": listener,
+    }
+
+
+def _owner_animated(owner, accept, cache):
+    """Whether an owner's own properties (`accept` names them) are keyed by an action it shows: its
+    active action or an unmuted NLA strip's. One look per action and owner kind, kept in `cache`:
+    a level's armatures share their few actions, and their curves are bones', not the object's."""
+    adt = owner.animation_data
+    if adt is None:
+        return False
+    actions = [adt.action] if adt.action is not None else []
+    for track in adt.nla_tracks:
+        if not track.mute:
+            actions.extend(strip.action for strip in track.strips if strip.action is not None and not strip.mute)
+    for action in actions:
+        key = (action.name, accept)
+        if key not in cache:
+            # EVERY SLOT'S CURVES: a camera's object and its lens share one action through two slots.
+            curves = []
+            for layer in action.layers:
+                for strip in layer.strips:
+                    for bag in strip.channelbags:
+                        curves.extend(bag.fcurves)
+            cache[key] = any(accept(fcurve.data_path) for fcurve in curves)
+        if cache[key]:
+            return True
+    return False
+
+
 # `Keyframe.type`'s significance order, mirrored from the `KEYFRAME_STATE`
 # merge in `keyframes_keylist.cc` -- a column drawn from several curves takes
 # the most significant type any of them carries.
@@ -5271,10 +5098,10 @@ def _action_key_range(action, first, last):
     repeats into, any other type opens both sides. Mute is not read. None is an open side."""
     low, high = None, None
     opened_low = opened_high = False
-    curves = list(getattr(action, "fcurves", None) or ())
-    for layer in getattr(action, "layers", ()):
-        for strip in getattr(layer, "strips", ()):
-            for bag in (getattr(strip, "channelbags", None) or ()):
+    curves = []
+    for layer in action.layers:
+        for strip in layer.strips:
+            for bag in strip.channelbags:
                 curves.extend(bag.fcurves)
     # A curve's keys and its last modifier count independently: a keyless curve carrying a
     # Generator or Noise still opens the range, as in Blender.
@@ -5334,8 +5161,8 @@ def _curve_body(fcurve):
         if modifier.mute:
             continue
         if modifier.type == "CYCLES" and not modifier.use_restricted_range and not modifier.use_influence:
-            cycles = [_CYCLE_MODE.get(modifier.mode_before, 0), int(modifier.cycles_before),
-                      _CYCLE_MODE.get(modifier.mode_after, 0), int(modifier.cycles_after)]
+            cycles = [_CYCLE_MODE[modifier.mode_before], int(modifier.cycles_before),
+                      _CYCLE_MODE[modifier.mode_after], int(modifier.cycles_after)]
         else:
             unsupported.append("%s modifier" % modifier.type.lower())
     out = {
@@ -5449,9 +5276,7 @@ def rna_outliner(selected=None):
             placed.add(obj.name)
             ordered.append(obj)
 
-    # The placed object itself, not `bpy.data.objects[name]`: a lookup by name is
-    # a walk of the whole ID list, and one per object made this loop quadratic
-    # (43 ms of a 1,490-object read).
+    # Reuse each placed object to avoid a linear ID-name lookup per row.
     for entries in list(placements.values()):
         order(entries[0][0]["place"])
     # A move takes the place out of its collection's list; the lists are
@@ -5486,16 +5311,9 @@ def rna_outliner(selected=None):
         for row in collections:
             row["children"] = [child for child in row["children"] if id(child) not in moved]
 
-    # THE SELECTION KEEPS ITS ROWS PAST THE PAGE. A row is how the editor
-    # addresses an object -- the viewport's outline and gizmo, the Properties
-    # rail -- so a selected or active object, the caller's or the engine's, keeps
-    # its row and every row above it however far down a long list it sits.
-    # BOUNDED LIKE THE PAGE ITSELF: the active object always, then at most one
-    # page of the selection, so selecting everything cannot turn one read back
-    # into the whole tree the page exists to keep out (Canyon Comet, 1,493
-    # objects selected: 1.77 MB a read uncapped, 142 KB capped).
-    # The caller's choice comes before the rest of the engine's selection: a click
-    # onto a selection already larger than a page keeps the object just clicked.
+    # Retain at most one page of active/selected rows and their ancestors.
+    # Prioritize the active object, then the caller's selection, then the
+    # engine's remaining selection so a clicked object keeps its address.
     wanted = [active] if active is not None else []
     wanted += sorted(chosen)
     wanted += [o.name for o in view_layer.objects if o.select_get(view_layer=view_layer)]
@@ -5508,7 +5326,7 @@ def rna_outliner(selected=None):
 
     def hold(row):
         inside = "place" in row and row["name"] in kept
-        for child in row.get("children", []):
+        for child in row["children"]:
             inside = hold(child) or inside
         if inside:
             holding.add(id(row))
@@ -5542,7 +5360,7 @@ def rna_outliner(selected=None):
     # Cap the hierarchy's visible child lists, not the collection's flat input.
     # Every parent participates in folding even when its child list needs a page.
     def page_tree(row):
-        members = row.get("children", [])
+        members = row["children"]
         children, more = _outliner_page(members)
         beyond = [child for child in members[len(children):] if id(child) in holding]
         children = [kept_row(child) for child in children + beyond]
@@ -5559,8 +5377,7 @@ def rna_outliner(selected=None):
     # page left behind adds only what it would have claimed that a later row
     # can share -- its own address, its materials, its modifiers' linked
     # datablocks, its instanced collection -- and one more expansion of itself
-    # and of its data. Data with no address of its own claims its rows the
-    # long way, every one in the shared count.
+    # and of its data.
     addresses = {}
 
     def address(datablock):
@@ -5580,33 +5397,24 @@ def rna_outliner(selected=None):
         object_key = obj.as_pointer()
         object_path = address(obj)
         data = obj.data
-        exact = object_path is None
-        scopes = [] if exact else [(object_path + ".", None, expanded.get(object_key, 0))]
+        scopes = [(object_path + ".", None, expanded.get(object_key, 0))]
         data_key = bones = None
         if data is not None:
             data_key = data.as_pointer()
             data_path = address(data)
             keys = getattr(data, "shape_keys", None)
             keys_path = address(keys) if keys is not None else None
-            exact = exact or data_path is None or (keys is not None and keys_path is None)
             bones = isinstance(data, bpy.types.Armature) and obj.mode != "POSE"
-            if not exact:
-                before = data_expanded.get(data_key, 0)
-                scopes += [(data_path + ".bones[", None, bones_expanded.get(data_key, 0)),
-                           (data_path + ".", data_path, before)]
-                if keys_path is not None:
-                    scopes.append((keys_path + ".", keys_path, before))
-        if exact:
-            scopes = []
+            before = data_expanded.get(data_key, 0)
+            scopes += [(data_path + ".bones[", None, bones_expanded.get(data_key, 0)),
+                       (data_path + ".", data_path, before)]
+            if keys is not None:
+                scopes.append((keys_path + ".", keys_path, before))
         row = spot.get("row")
-        if row is not None or exact:
-            # Built rows, or the long way for data the scopes cannot name.
+        if row is not None:
             scope = _OutlinerScope(seen, scopes)
-            if row is None:
-                _outliner_object(obj, view_layer, scope, chosen, active)
-            else:
-                for claimed in spot["claims"]:
-                    claimed["id"] = _outliner_unique(claimed["path"], scope)
+            for claimed in spot["claims"]:
+                claimed["id"] = _outliner_unique(claimed["path"], scope)
         else:
             bump(object_path)
             if data is not None:
@@ -5621,9 +5429,7 @@ def rna_outliner(selected=None):
                     linked = getattr(md, member, None)
                     if linked is None:
                         continue
-                    linked_path = address(linked)
-                    if linked_path:
-                        bump(linked_path)
+                    bump(address(linked))
                     break
             if obj.instance_collection is not None and obj.instance_type == "COLLECTION":
                 bump(address(obj.instance_collection))
@@ -5703,32 +5509,55 @@ def outliner_set(path, column, value):
         % (column, target.bl_rna.identifier, path))
 
 
-# REQUESTS THAT CAN REMOVE OBJECTS, watched: a removal is reported with its cause, because an
-# object that disappears without a named act is the loss this session must never hide. A scene
-# was once found emptied and saved over its file by a burst of three edits at boot, with nothing
-# recording which requests they were.
-_WATCHED_OPS = ("execute", "rna-set", "outliner-set", "history-step")
+# Record requests that can remove objects so every disappearance has a named cause.
+_WATCHED_OPS = ("execute", "rna-set", "outliner-set", "history-step", "gltf-export", "run-script")
+# The requests that may change an action's keys (`Session._kept_action_revisions`): every edit, not an
+# export (which puts everything back) and not a read.
+_ACTION_EDIT_OPS = ("execute", "rna-set", "outliner-set", "history-step")
+_ACTION_EDITS = {"count": 0}
 
 
 def dispatch(request):
     op = request.get("op")
+    if op in _ACTION_EDIT_OPS:
+        _ACTION_EDITS["count"] += 1
     if op not in _WATCHED_OPS:
         return _dispatch_request(request)
-    # ID.session_uid survives renames, reallocations and file reloads.
-    # Names alone falsely reported an ordinary rename as a deleted object.
+    # Compare stable session_uids so renames do not count as object deletions.
     before = {o.session_uid: o.name for o in bpy.data.objects}
+    # A request that loads a file (`read_homefile`, `open_mainfile`, then perhaps `save_as_mainfile`, to the same path
+    # or another) removes nothing from the document it replaced: its objects are that file's, as saved. What it can
+    # lose is the document's unsaved changes, said where there were any.
+    before_path = bpy.data.filepath
+    # (the session's own record of changes not yet saved, `mark_changed`'s: Blender's `is_dirty` is instrumentation)
+    before_dirty = SESSION.save_due
+    before_loads = _LOADS["count"]
     try:
         return _dispatch_request(request)
     finally:
-        remaining = {o.session_uid for o in bpy.data.objects}
-        removed = [name for uid, name in before.items() if uid not in remaining]
-        if removed:
-            cause = {k: request[k] for k in ("label", "property", "column", "direction", "token", "path")
-                     if k in request}
-            if op == "execute":
-                cause["code"] = str(request.get("code", ""))[:160]
-            _say("@@VOLTER-WARN %s removed objects %s (%s); %d remain" % (
-                op, sorted(removed), json.dumps(cause), len(bpy.data.objects)))
+        cause = {k: request[k] for k in ("label", "property", "column", "direction", "token", "path")
+                 if k in request}
+        if op == "execute":
+            cause["code"] = str(request.get("code", ""))[:160]
+        if _LOADS["count"] != before_loads:
+            same = bool(before_path) and os.path.normpath(bpy.data.filepath) == os.path.normpath(before_path)
+            if before_dirty:
+                _say("@@VOLTER-WARN %s now holds %s in place of %s, whose unsaved changes are lost (%s)" % (
+                    op, bpy.data.filepath or "a new, unsaved file", before_path or "an unsaved file",
+                    json.dumps(cause)))
+            if same:
+                # (the same file reloaded, rebuilt perhaps: its objects are new, so an object it no longer holds is
+                # known by its name)
+                gone = sorted(set(before.values()) - {o.name for o in bpy.data.objects})
+                if gone:
+                    _say("@@VOLTER-WARN %s reloaded %s without objects %s (%s); %d remain" % (
+                        op, before_path, gone, json.dumps(cause), len(bpy.data.objects)))
+        else:
+            remaining = {o.session_uid for o in bpy.data.objects}
+            removed = [name for uid, name in before.items() if uid not in remaining]
+            if removed:
+                _say("@@VOLTER-WARN %s removed objects %s (%s); %d remain" % (
+                    op, sorted(removed), json.dumps(cause), len(bpy.data.objects)))
 
 
 def _dispatch_request(request):
@@ -5822,10 +5651,119 @@ def _native_preview(request):
         bpy.data.scenes.remove(preview, do_unlink=True)
 
 
+# WHERE AN EXPORT IS WRITTEN in the module filesystem, before the tab carries it to the project:
+# one export's files at a time, outside the project's tree, so the MCP mirror never lists them.
+_GLTF_EXPORT_DIR = "/tmp/volter-gltf-export"
+
+
+def _gltf_export(request):
+    """A COMPONENT OR A LEVEL BY BLENDER'S OWN glTF EXPORTER (`gltf_export.py`, RFC 0007).
+
+    The document as it is, written as `<name>.glb` and its manifest `<name>.json` into
+    `_GLTF_EXPORT_DIR`, which the tab reads and writes into the project's
+    `.volter/export/components/` or `.volter/export/levels/`. The export puts back everything it
+    sets up (its temporary markers and collection, the active collection, an instancer's
+    realization, the frame) before it answers, so, like `native-preview`, no history checkpoint,
+    save, frame export or revision bump is owed. `previous` is the project's earlier manifest and
+    its file's SHA-256: when the `.blend`, the exporter and the settings still match, nothing is
+    exported and the answer is `current`. `blendSha256` is the document's SHA-256 as the tab reads
+    it from the project: the module filesystem keeps no copy of a document it streamed in.
+    """
+    kind = request.get("kind")
+    if kind not in ("component", "level"):
+        raise ValueError("A glTF export is a component or a level")
+    if SESSION.document is None or SESSION._foreign:
+        raise RuntimeError("Blender holds no project document to export")
+    if ROOT not in sys.path:
+        sys.path.insert(0, ROOT)
+    import gltf_export
+    name = os.path.splitext(os.path.basename(SESSION.document))[0]
+    os.makedirs(_GLTF_EXPORT_DIR, exist_ok=True)
+    for stale in os.listdir(_GLTF_EXPORT_DIR):
+        os.unlink(os.path.join(_GLTF_EXPORT_DIR, stale))
+    out = os.path.join(_GLTF_EXPORT_DIR, name + ".glb")
+    previous = request.get("previous")
+    blend_sha = request.get("blendSha256")
+    # The display LUTs the project holds intact (`.volter/export/display/<key>.cube`), each with its
+    # recorded SHA-256: one is baked only when the scene's view settings have none.
+    luts = request.get("luts")
+    luts = ({str(k): str(v) for k, v in luts.items()} if isinstance(luts, dict)
+            else [str(k) for k in luts] if isinstance(luts, list) else [])
+    previous = previous if isinstance(previous, dict) else None
+    blend_sha = blend_sha if isinstance(blend_sha, str) and blend_sha else None
+    answer = None
+    # Check whether the existing export is current before retaining document state. Unchanged
+    # exports touch nothing; changed exports use gltf_export.export, which restores its temporary
+    # changes.
+    if not request.get("force") and previous is not None and blend_sha is not None:
+        started = time.perf_counter()
+        settings = dict(gltf_export.COMPONENT_SETTINGS if kind == "component" else gltf_export.LEVEL_SETTINGS)
+        current = gltf_export._current(out, blend_sha, gltf_export.exporter_version(), settings, previous)
+        if current is not None:
+            answer = gltf_export._current_answer(out, current, started, luts)
+    if answer is None:
+        answer = gltf_export.export(kind, out, SESSION.project, force=bool(request.get("force")),
+                                    previous=previous, blend_sha=blend_sha, luts=luts)
+    # The file, what travels beside it (a newly baked display LUT), then its manifest, which names
+    # them; a current export may still bring the LUT it names when the project lost it.
+    sidecars = answer["sidecars"]
+    files = list(sidecars) if answer["current"] else [out, *sidecars, os.path.splitext(out)[0] + ".json"]
+    # What this Blender would write for either kind, so a caller can tell whether another file's
+    # earlier export (a level's components) still stands without opening it.
+    return {"kind": kind, "name": name, "document": SESSION.document_relative, "current": answer["current"],
+            "ms": answer["ms"], "steps": answer.get("steps", {}), "manifest": answer["manifest"], "files": files,
+            "exporter": gltf_export.exporter_version(),
+            "settings": {"component": dict(gltf_export.COMPONENT_SETTINGS), "level": dict(gltf_export.LEVEL_SETTINGS)}}
+
+
+def _run_script(request):
+    """A SCRIPT RUN AS `blender -b <document> -P <script> -- <args>` RUNS ONE, in the document Blender holds.
+
+    Its `sys.argv` ends in `--` and `args`, as Blender's own does, and its working directory is the run's own `dir`
+    (new for each run, outside the project's tree): a file it writes by a relative path is named in the answer's
+    `files` by that path, and the worker carries it out. It runs as `execute` runs a script (`output` its printing,
+    `error` its raise, `SystemExit` included). This path adds no history step, save or present;
+    scripts restore any temporary document changes themselves. The runner restores argv and cwd.
+    """
+    if SESSION.document is None or SESSION._foreign:
+        raise RuntimeError("Blender holds no project document to run a script in")
+    root = request["dir"]
+    os.makedirs(root)
+    argv, cwd = sys.argv, os.getcwd()
+    sys.argv = [argv[0], "--", *[str(arg) for arg in request["args"]]]
+    os.chdir(root)
+    try:
+        ran = execute(request["source"])
+    finally:
+        sys.argv = argv
+        os.chdir(cwd)
+    files = sorted(os.path.relpath(os.path.join(folder, name), root).replace(os.sep, "/")
+                   for folder, _, names in os.walk(root) for name in names)
+    return {"output": ran["result"], "error": ran["error"], "files": files}
+
+
+def _asset_library(request):
+    """AN ASSET LIBRARY IN BLENDER'S PREFERENCES (Preferences > File Paths > Asset Libraries): `name`, at the
+    project's folder `directory`, importing its assets by `importMethod` (`LINK`, `APPEND`, ...). One of that name
+    already there is set again. A preference, not a document edit: nothing is owed."""
+    library = request["library"]
+    path = os.path.join(SESSION.project, library["directory"])
+    libraries = bpy.context.preferences.filepaths.asset_libraries
+    held = libraries.get(library["name"]) or libraries.new(name=library["name"], directory=path)
+    held.path = path
+    held.import_method = library["importMethod"]
+
+
 def _dispatch(request):
     op = request.get("op")
     if op == "native-preview":
         return _native_preview(request)
+    if op == "gltf-export":
+        return _gltf_export(request)
+    if op == "run-script":
+        return _run_script(request)
+    if op == "asset-library":
+        return _asset_library(request)
     if op == "document-info":
         return {"filepath": bpy.data.filepath, "session": SESSION.session, "revision": SESSION.revision}
     if op == "execute":
@@ -5854,15 +5792,7 @@ def _dispatch(request):
         try:
             SESSION.present()
         except Exception as thrown:  # noqa: BLE001
-            # LOUD, because a present that fails leaves the Model document
-            # showing the state BEFORE this call and nothing else says so.
-            # `@@VOLTER-PRESENT-FAILED` was not one of the prefixes the engines
-            # escalate (`blender-emscripten-engine.mts:159`,
-            # `blender-wali-engine.mts:266` raise `@@VOLTER-WARN`/`@@VOLTER-ERROR`
-            # to the console and nothing else), so it logged at `log` level and
-            # reached no counter -- measured 2026-09-19 (I4), when a throw in
-            # the overlay walk froze the viewport through a dozen successful
-            # `blender-execute` calls with `cyclotron console` silent throughout.
+            # Escalate present failures because the displayed document still holds its preceding state.
             _say("@@VOLTER-ERROR the present after this call failed, so the Model document is "
                  "showing the state before it: " + repr(thrown))
         return answer
@@ -5886,12 +5816,17 @@ def _dispatch(request):
         return rna_node_tree(request.get("path"), request.get("material"))
     if op == "uv-layout":
         return rna_uv_layout(request.get("object"), request.get("uvLayer"))
-    # THE RIG AND CLIP DOORS (the Timeline): both READS, so neither presents
-    # and neither owes a derivation. There is deliberately no writer beside
-    # them -- keying, moving a key and setting a range are edits.
+    # The Timeline clip read neither presents nor creates a derivation.
+    # Keying, moving a key and setting a range remain edits.
     if op == "action-clip":
         return rna_action_clip(request.get("object"), request.get("bake", True), request.get("action"),
                                request.get("summary", True))
+    # The movie is a read.
+    if op == "scene-movie":
+        return rna_scene_movie()
+    # The scene's sound for the page to mix: a read; speakers move the frame and restore it.
+    if op == "sound-scene":
+        return rna_sound_scene(int(request["first"]), int(request["last"]))
     if op == "outliner":
         return rna_outliner(request.get("selected"))
     if op == "outliner-set":
@@ -5903,15 +5838,7 @@ def _dispatch(request):
         try:
             SESSION.present()
         except Exception as thrown:  # noqa: BLE001
-            # LOUD, because a present that fails leaves the Model document
-            # showing the state BEFORE this call and nothing else says so.
-            # `@@VOLTER-PRESENT-FAILED` was not one of the prefixes the engines
-            # escalate (`blender-emscripten-engine.mts:159`,
-            # `blender-wali-engine.mts:266` raise `@@VOLTER-WARN`/`@@VOLTER-ERROR`
-            # to the console and nothing else), so it logged at `log` level and
-            # reached no counter -- measured 2026-09-19 (I4), when a throw in
-            # the overlay walk froze the viewport through a dozen successful
-            # `blender-execute` calls with `cyclotron console` silent throughout.
+            # Escalate present failures because the displayed document still holds its preceding state.
             _say("@@VOLTER-ERROR the present after this call failed, so the Model document is "
                  "showing the state before it: " + repr(thrown))
         return answer
@@ -5926,57 +5853,38 @@ def _dispatch(request):
         try:
             SESSION.present()
         except Exception as thrown:  # noqa: BLE001
-            # LOUD, because a present that fails leaves the Model document
-            # showing the state BEFORE this call and nothing else says so.
-            # `@@VOLTER-PRESENT-FAILED` was not one of the prefixes the engines
-            # escalate (`blender-emscripten-engine.mts:159`,
-            # `blender-wali-engine.mts:266` raise `@@VOLTER-WARN`/`@@VOLTER-ERROR`
-            # to the console and nothing else), so it logged at `log` level and
-            # reached no counter -- measured 2026-09-19 (I4), when a throw in
-            # the overlay walk froze the viewport through a dozen successful
-            # `blender-execute` calls with `cyclotron console` silent throughout.
+            # Escalate present failures because the displayed document still holds its preceding state.
             _say("@@VOLTER-ERROR the present after this call failed, so the Model document is "
                  "showing the state before it: " + repr(thrown))
         return answer
     if op == "save-document":
         return SESSION.save_document()
+    if op == "open-document":
+        # The worker just staged the document's file into the engine's filesystem (another
+        # `.blend`, or this one again for a revert or a backup); open it as the model.
+        return SESSION.bind_document(request["document"])
     if op == "start":
         SESSION.project = request.get("project", SESSION.project)
         try:
             os.chdir(SESSION.project)
         except OSError:
             pass
-        answer = {"session": SESSION.session, "python": sys.version,
-                  "blender": bpy.app.version_string, "engines": ENGINES,
-                  "unavailableEngines": UNAVAILABLE_ENGINES}
-        document = request.get("document")
-        if document:
-            answer.update(SESSION.bind_document(document))
-        return answer
+        return {"session": SESSION.session, "python": sys.version,
+                "blender": bpy.app.version_string, "engines": ENGINES,
+                "unavailableEngines": UNAVAILABLE_ENGINES}
     raise ValueError("Unknown session op %r" % (op,))
 
 
 # ---------------------------------------------------------------- the loop
 
-_prepare_directories()
-bpy.app.handlers.load_post.append(_load_post)
-bpy.app.handlers.undo_post.append(_history_post)
-bpy.app.handlers.redo_post.append(_history_post)
-ENGINES, UNAVAILABLE_ENGINES = _register_engine()
-_say("@@VOLTER-READY " + json.dumps({"blender": bpy.app.version_string, "engines": ENGINES,
-                                   "unavailableEngines": UNAVAILABLE_ENGINES}))
-
-# Markers already dispatched, and the answers whose `out/` files this loop
-# still owes a cleanup. Both are pruned as the page acks, so neither grows
-# with the session.
 def _channel_loop():
     """Serve the directory channel until the program ends.
 
     A FUNCTION SO ITS DEATH HAS A NAME. Everything here below the per-request
-    `try` is the CHANNEL itself, and an exception in it used to fall off the
-    end of this script: Blender then finishes `--python` and exits 0 through
-    its ordinary path, so the page is told "Blender exited 0" and nothing
-    anywhere says why. MEASURED 2026-09-19 -- from outside, a channel death is
+    `try` is the CHANNEL itself. An exception in it that fell off the end of
+    this script would let Blender finish `--python` and exit 0 through its
+    ordinary path, so the page would be told "Blender exited 0" and nothing
+    anywhere would say why: from outside, a channel death is
     indistinguishable from a clean shutdown, and the traceback goes to stderr,
     which is page output rather than a console condition. The caller below
     makes it one.
@@ -5988,12 +5896,11 @@ def _channel_loop():
     unacked = []
     active = 0.0
     while True:
-        # A FAILED LISTING IS NOT AN EMPTY ONE. This swallowed every OSError
-        # into "no requests", so the one failure that matters -- the process
-        # out of file descriptors -- turned the session DEAF: it kept looping
-        # at full speed, answered nothing ever again, and the page waited on a
-        # call with a live program and no error anywhere (measured
-        # 2026-09-19, 1,008 s). The directory is the page's and is made before
+        # A FAILED LISTING IS NOT AN EMPTY ONE. Read as "no requests", the one
+        # failure that matters -- the process out of file descriptors -- would
+        # turn the session DEAF: looping at full speed, answering nothing ever
+        # again, while the page waits on a call with a live program and no
+        # error anywhere. The directory is the page's and is made before
         # the program starts, so its absence is the only benign reading;
         # anything else is named and ends the loop through the guard below.
         try:
@@ -6001,12 +5908,9 @@ def _channel_loop():
                           if n.endswith(".done") and n[: -len(".done")].isdigit())
         except FileNotFoundError:
             markers = set()
-        # THE PAGE'S ACK IS ITS OWN REQUEST FILE BEING GONE: it unlinks
-        # `in/<id>.done` only after reading `out/<id>.json`, so anything
-        # missing from this listing has been taken and the answer is ours to
-        # remove. This is the whole of the page's former four-unlink cleanup,
-        # moved to the side that wrote the files (see the header's ownership
-        # table).
+        # The page removes in/<id>.done after reading out/<id>.json.
+        # An absent request marker acknowledges the guest-owned reply files,
+        # which the guest can then remove.
         if unacked:
             still_owed = []
             for rid in unacked:
@@ -6044,12 +5948,51 @@ def _channel_loop():
         active = time.monotonic()
 
 
-try:
-    _channel_loop()
-except BaseException as _thrown:  # noqa: BLE001
-    # The one place a channel death can still be named. Without this the
-    # program ends 0 and the page reports only that Blender is gone.
-    _say("@@VOLTER-ERROR the session's channel loop raised %s: %s -- the session is over and "
-         "every outstanding call will go unanswered. %s"
-         % (type(_thrown).__name__, _thrown, traceback.format_exc().replace("\n", " | ")))
-    raise
+# THE ADD-ONS THIS BLENDER SHIPS beside Blender's own: each a package the engine writes under `_ADDONS` before
+# Blender starts (`session-addons.mts`), enabled for the whole session, whatever file it opens, as Preferences >
+# Add-ons enables an installed one.
+_ADDONS = os.path.join(ROOT, "addons")
+
+
+def _enable_addons():
+    import addon_utils
+    sys.path.insert(0, _ADDONS)
+    for name in sorted(os.listdir(_ADDONS)):
+        _say("@@VOLTER-PHASE addon/%s" % name)
+        failed = []
+        addon_utils.enable(name, default_set=True, persistent=True, handle_error=failed.append)
+        if failed:
+            _say("@@VOLTER-WARN the %s add-on did not enable: %s: %s" % (name, type(failed[0]).__name__, failed[0]))
+
+
+def main():
+    """Start the worker channel; importing this module only exposes its RNA readers."""
+    global ENGINES, UNAVAILABLE_ENGINES
+    if _blender_web is None:
+        raise RuntimeError("The session worker needs Blender with the _blender_web native door")
+    # Each step of the session's start says it began (`@@VOLTER-PHASE`): the page makes each a load boundary, so the
+    # wait for the ready line is timed step by step, Blender's and Python's own start being the wait before the first.
+    _say("@@VOLTER-PHASE session")
+    _prepare_directories()
+    bpy.app.handlers.load_post.append(_load_post)
+    bpy.app.handlers.undo_post.append(_history_post)
+    bpy.app.handlers.redo_post.append(_history_post)
+    _say("@@VOLTER-PHASE engines")
+    ENGINES, UNAVAILABLE_ENGINES = _register_engine()
+    _enable_addons()
+    _say("@@VOLTER-READY " + json.dumps({"blender": bpy.app.version_string, "engines": ENGINES,
+                                       "unavailableEngines": UNAVAILABLE_ENGINES}))
+
+    try:
+        _channel_loop()
+    except BaseException as _thrown:  # noqa: BLE001
+        # The one place a channel death can still be named. Without this the
+        # program ends 0 and the page reports only that Blender is gone.
+        _say("@@VOLTER-ERROR the session's channel loop raised %s: %s -- the session is over and "
+             "every outstanding call will go unanswered. %s"
+             % (type(_thrown).__name__, _thrown, traceback.format_exc().replace("\n", " | ")))
+        raise
+
+
+if __name__ == "__main__":
+    main()