@volter/blender-engine 0.1.148 → 0.1.149

package/browser/session.py

@@ -1,96 +1,4 @@
-"""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 array
 import base64
@@ -114,7 +22,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 +40,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,8 +97,13 @@ 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()
@@ -275,7 +175,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 +281,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 +305,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 +399,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 +448,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 +502,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 +512,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 +653,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 +677,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 +738,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 +752,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 +885,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 +903,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 +1016,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 +1037,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 +1056,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 +1073,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 +1086,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 +1131,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 +1140,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 +1170,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 +1185,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 +1229,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 +1313,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 +1366,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
@@ -1607,18 +1450,39 @@ class Session:
 
     def forget(self):
         self._known.clear()
+        self._action_revisions = {}
+
+    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 +1509,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 +1521,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 +1543,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 +1572,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 +1618,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 +1633,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 +1687,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 +1712,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 +1744,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 +1766,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 +1777,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 +1785,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 +1825,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 +1835,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 +1845,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 +1895,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"])
@@ -2151,9 +1924,7 @@ class Session:
             return {"document": relative_path, "opened": False}
         _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 +1934,39 @@ 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()
+        # 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 {"document": relative_path, "opened": True,
                 "objects": len(bpy.data.objects),
-                "size": size}
+                "size": size, "presented": 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 +1974,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 +2027,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 +2035,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 +2056,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 +2106,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 +2114,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 +2134,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 +2157,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 +2173,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 +2194,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 +2230,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 +2317,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 +2351,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 +2362,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 +2412,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 +2516,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 +2589,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 +2603,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 +2614,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 +2644,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 +2669,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 +2685,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 +2702,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 +2718,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 +2744,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 +2794,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 +2810,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 +2857,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 +2869,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 +2907,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 +3004,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 +3121,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 +3135,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 +3151,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 +3169,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 +3182,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 +3224,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 +3263,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 +3272,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 +3297,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 +3313,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 +3395,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 +3421,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 +3457,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 +3474,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 +3487,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 +3526,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 +3596,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 +3608,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 +3720,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 +3761,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 +3839,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 +3898,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 +3917,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 +3963,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 +3986,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 +3999,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"):
+    if prop.type not in ("FLOAT", "INT"):
         return {}
-    if getattr(prop, "array_length", 0):
-        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 +4036,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 +4060,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 +4123,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 +4202,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 +4215,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 +4227,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 +4261,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 +4286,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 +4303,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 +4340,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 +4354,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 +4366,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 +4395,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 +4434,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 +5067,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 +5130,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 +5245,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 +5280,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 +5295,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 +5329,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 +5346,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 +5366,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 +5398,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 +5478,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 +5620,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 +5761,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 +5785,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 +5807,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,20 +5822,16 @@ 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 == "reopen-document":
+        # The document's file in the engine's filesystem was just rewritten (a revert, a
+        # backup); open it again as the model.
+        return SESSION.bind_document(SESSION.document_relative)
     if op == "start":
         SESSION.project = request.get("project", SESSION.project)
         try:
@@ -5958,25 +5850,14 @@ def _dispatch(request):
 
 # ---------------------------------------------------------------- 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 +5869,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 +5881,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 +5921,46 @@ 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)):
+        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")
+    _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()
+    _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()