@volter/blender-engine 0.1.147 → 0.1.149

package/browser/gltf_export.py

@@ -0,0 +1,3161 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Export components and levels through Blender’s glTF exporter. Components include view-layer
+content outside Notes and References and carry one animation per action. Levels replace linked
+placements with markers carrying component identity, action, tint, visibility and NLA metadata,
+and export their own scene animation. Standard glTF extensions describe display transforms,
+environment, render settings, light units, ray visibility, animation tracks and blending data.
+Collection membership, timelines and keyed-bone masks preserve authored relationships. Preserve
+quaternion key signs and lengths for Blender-compatible layering, and carry declared runtime
+constraints without baking them. Temporary objects, collection state, poses and keyed values are
+restored before answering; export creates no save, history step or present. A sibling manifest
+records source, exporter, settings and artifact identities so unchanged exports can return
+current. This module runs in session.py or headless desktop Blender: blender -b --factory-startup
+<file.blend> --python gltf_export.py -- <component|level> <out.glb> <project> [--force]."""
+import bisect
+import hashlib
+import importlib
+import json
+import os
+import re
+import struct
+import sys
+import time
+import types
+
+import bpy
+import math
+import mathutils
+
+FORMAT = 1
+AUTHORING = ("Notes", "References")
+
+# RFC 0007 section 1, exactly.
+COMPONENT_SETTINGS = {
+    "export_format": "GLB",
+    "export_yup": True,
+    "export_skins": True,
+    "export_animations": True,
+    "export_animation_mode": "ACTIONS",
+    "export_force_sampling": True,
+    "export_extras": True,
+    # What Blender renders, not the raw mesh: modifiers applied (the exporter leaves an Armature
+    # modifier to the skin). The scene's lights and cameras go too.
+    "export_apply": True,
+    "export_cameras": True,
+    "export_lights": True,
+    # Light units as Blender renders them and three.js reads them: a sun's W/m^2 as is, a point or
+    # spot's watts over 4 pi. The default (SPEC) multiplies by 683 lm/W.
+    "export_import_convert_lighting_mode": "COMPAT",
+}
+# Sections 2 and 3: the same exporter and settings; the timeline as ONE scene animation (the
+# exporter splits SCENE mode per object unless told not to).
+LEVEL_SETTINGS = dict(COMPONENT_SETTINGS, export_animation_mode="SCENE", export_anim_scene_split_object=False)
+
+# Override edits a marker carries (D1), and the hierarchy bookkeeping every override has.
+CARRIED = ("location", "rotation_euler", "rotation_quaternion", "rotation_axis_angle", "scale",
+           "hide_render", "hide_viewport", "animation_data.action", "color")
+STRUCTURAL = ("parent", "matrix_parent_inverse", "data")
+
+_HOOK_MODULE = "volter_gltf_export_hooks"
+_HOLDER = "__volter_export__"
+# Display LUT size and log2 shaper range. t = (log2(x + 2^-10) + 10) / 18 maps black to the first sample.
+LUT_SIZE = 48
+LUT_DOMAIN = (-10.0, 8.0)
+LUT_FORMAT = 2
+# Blender's per-object ray visibility, as `STD_ray_visibility` keys.
+RAY_VISIBILITY = (("camera", "camera"), ("shadow", "shadow"), ("diffuse", "diffuse"), ("glossy", "glossy"),
+                  ("transmission", "transmission"), ("volume", "volume_scatter"))
+# The standard's own `STD_*` extensions (their schemas are the standard's registry), listed in `extensionsUsed` only.
+STD_EXTENSIONS = ("STD_display", "STD_environment", "STD_render", "STD_light", "STD_ray_visibility",
+                  "STD_material_shadow", "STD_animation_tracks", "STD_animation_blending")
+# Blender's NLA enums as the standard names them (AnimationLayers' blend modes; a strip's extrapolation).
+BLENDS = {"REPLACE": "replace", "ADD": "add", "SUBTRACT": "subtract", "MULTIPLY": "multiply", "COMBINE": "combine"}
+EXTRAPOLATIONS = {"HOLD": "hold", "HOLD_FORWARD": "hold-forward", "NOTHING": "none"}
+# Blender's sky models, by their published names.
+SKY_MODELS = {"NISHITA": "nishita", "SINGLE_SCATTERING": "nishita", "MULTIPLE_SCATTERING": "nishita-multiple",
+              "PREETHAM": "preetham", "HOSEK_WILKIE": "hosek-wilkie"}
+
+
+def _sha256(path):
+    digest = hashlib.sha256()
+    with open(path, "rb") as handle:
+        for chunk in iter(lambda: handle.read(1 << 20), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _gltf_addon():
+    module = next((m for name, m in list(sys.modules.items()) if name.split(".")[-1] == "io_scene_gltf2"), None)
+    if module is None:
+        import addon_utils
+        addon_utils.enable("io_scene_gltf2", default_set=False)
+        module = sys.modules.get("io_scene_gltf2")
+    if module is None:
+        raise RuntimeError("Blender's glTF exporter (io_scene_gltf2) is not available in this Blender.")
+    return module
+
+
+def exporter_version():
+    """What made a file: Blender, its glTF add-on, and this script (its SHA-256), so a change to any of
+    the three exports again."""
+    module = _gltf_addon()
+    version = getattr(module, "bl_info", {}).get("version", ())
+    return {"blender": bpy.app.version_string, "gltf": ".".join(str(part) for part in version),
+            "script": _sha256(os.path.abspath(__file__))[:16]}
+
+
+def _extension_class():
+    module = _gltf_addon()
+    return importlib.import_module(module.__name__ + ".io.com.gltf2_io_extensions").Extension
+
+
+def _project_relative(path, project):
+    absolute = os.path.normpath(os.path.abspath(path))
+    if project:
+        root = os.path.normpath(os.path.abspath(project))
+        relative = os.path.relpath(absolute, root)
+        if not relative.startswith(".."):
+            return relative.replace(os.sep, "/")
+    return absolute.replace(os.sep, "/")
+
+
+def _library_file(library, project):
+    path = bpy.path.abspath(library.filepath, library=library.library)
+    return _project_relative(path, project)
+
+
+def _hidden_collections(scene):
+    """Collections hidden from renders, a parent hiding its children."""
+    hidden = set()
+
+    def walk(collection, parent_hidden):
+        here = parent_hidden or collection.hide_render
+        if here:
+            hidden.add(collection.name_full)
+        for child in collection.children:
+            walk(child, here)
+
+    walk(scene.collection, False)
+    return hidden
+
+
+def _render_visible(obj, hidden):
+    if obj.hide_render:
+        return False
+    owners = [c for c in obj.users_collection]
+    return not owners or any(c.name_full not in hidden for c in owners)
+
+
+def _world(scene):
+    """The world as data (`STD_environment`): its surface when it is one Background colour (colour and
+    strength) or a sky by its parameters, which a renderer draws as its background and ambient light, or two of
+    them mixed by Light Path's Is Camera Ray (what lights the scene, and a `background` the camera sees), and
+    its volume when it is a homogeneous medium. Anything else (an image, a node graph) is named: it needs
+    a bake beside its parameters. Answers the data and what it could not carry."""
+    world = scene.world
+    if world is None:
+        return None, []
+    if not world.use_nodes or world.node_tree is None:
+        return {"color": [round(float(c), 6) for c in world.color[:3]], "strength": 1.0}, []
+    outputs = [n for n in world.node_tree.nodes if n.type == "OUTPUT_WORLD"]
+    output = next((n for n in outputs if n.is_active_output), outputs[0] if outputs else None)
+    gaps = []
+    links = output.inputs["Surface"].links if output is not None else []
+    source = links[0].from_node if links else None
+    if source is None:
+        data = {"color": [0.0, 0.0, 0.0], "strength": 0.0}
+    elif source.type == "MIX_SHADER" and _camera_ray_mix(source):
+        # "THE CAMERA SEES ONE THING, THE SCENE IS LIT BY ANOTHER": a Mix Shader by Light Path's Is Camera Ray between
+        # two backgrounds. Its first input lights the scene (the radiance); its second is what camera rays see
+        # (`background`).
+        lit, seen = (_background_radiance(socket.links[0].from_node, world, gaps) for socket in source.inputs[1:3])
+        if lit is None or seen is None:
+            data = None
+            gaps.append("the world %s mixes by camera ray, but an input is not one colour or a sky: it is not carried yet" % world.name)
+        else:
+            data = dict(lit, background=seen)
+    else:
+        data = _background_radiance(source, world, gaps)
+        if data is None:
+            gaps.append("the world %s is a %s graph, not one colour or a sky: it is not carried yet" % (world.name, source.type))
+    volume, volume_gap = _world_volume(world, output)
+    if volume_gap:
+        gaps.append(volume_gap)
+    if volume is not None:
+        data = dict(data or {"strength": 0.0}, volume=volume)
+        gaps.append("the world %s has a volume: an infinite medium, which absorbs the sun and the world's own light before "
+                    "they arrive, as Blender renders it (a haze around a play space is a volume object, a box)" % world.name)
+    return data, gaps
+
+
+def _camera_ray_mix(node):
+    """A Mix Shader whose factor is Light Path's Is Camera Ray, between two linked backgrounds."""
+    factor = node.inputs[0]
+    if not factor.is_linked or not node.inputs[1].is_linked or not node.inputs[2].is_linked:
+        return False
+    link = factor.links[0]
+    return link.from_node.type == "LIGHT_PATH" and link.from_socket.name == "Is Camera Ray"
+
+
+def _background_radiance(source, world, gaps):
+    """A Background node as the world's radiance: one colour and strength, or a sky by its published model and physical
+    parameters (rule G: a host with a physical sky draws it; a bake for hosts without one goes beside them, never
+    instead). None for anything else."""
+    if source is None or source.type != "BACKGROUND" or source.inputs[1].is_linked:
+        return None
+    if not source.inputs[0].is_linked:
+        return {"color": [round(float(c), 6) for c in source.inputs[0].default_value[:3]],
+                "strength": round(float(source.inputs[1].default_value), 6)}
+    sky = source.inputs[0].links[0].from_node
+    if sky.type != "TEX_SKY":
+        return None
+    model = SKY_MODELS.get(sky.sky_type)
+    number = lambda value: round(float(value), 6)
+    params = {"model": model or str(sky.sky_type).lower(),
+              "sun": {"elevation": number(sky.sun_elevation), "rotation": number(sky.sun_rotation),
+                      "angularDiameter": number(sky.sun_size), "intensity": number(sky.sun_intensity),
+                      "disc": bool(sky.sun_disc)},
+              "altitude": number(sky.altitude), "air": number(sky.air_density),
+              "aerosol": number(sky.aerosol_density),
+              "ozone": number(sky.ozone_density), "groundAlbedo": number(sky.ground_albedo)}
+    if model in ("preetham", "hosek-wilkie"):
+        params["turbidity"] = number(sky.turbidity)
+    gaps.append("the world %s is a sky: its parameters are carried; a host without a physical sky needs a bake" % world.name)
+    if model is None:
+        gaps.append("the world %s's sky model %s has no published name in the standard" % (world.name, sky.sky_type))
+    return {"sky": params, "strength": round(float(source.inputs[1].default_value), 6)}
+
+
+def _volume_coefficients(node):
+    """A volume shader with unlinked inputs as a homogeneous medium's coefficients per metre (EEVEE's own
+    formulas): scattering, absorption and emission (linear RGB) and the phase function's anisotropy.
+    An unlinked Add Shader has no medium; unsupported or linked shader inputs raise ValueError."""
+    inputs = node.inputs
+    def value(name):
+        socket = inputs[name]
+        if socket.is_linked:
+            raise ValueError("its %s is linked" % name)
+        return socket.default_value
+    def rgb(v):
+        return [float(c) for c in v[:3]]
+    if node.type == "PRINCIPLED_VOLUME":
+        density = max(float(value("Density")), 0.0)
+        color = rgb(value("Color"))
+        absorption_color = [math.sqrt(max(c, 0.0)) for c in rgb(value("Absorption Color"))]
+        scattering = [c * density for c in color]
+        absorption = [max(1.0 - c, 0.0) * max(1.0 - a, 0.0) * density for c, a in zip(color, absorption_color)]
+        strength = max(float(value("Emission Strength")), 0.0)
+        emission = [c * strength for c in rgb(value("Emission Color"))]
+        if float(value("Blackbody Intensity")) > 0:
+            raise ValueError("its blackbody emission is not carried")
+        return scattering, absorption, emission, float(value("Anisotropy"))
+    if node.type == "VOLUME_SCATTER":
+        density = max(float(value("Density")), 0.0)
+        return [c * density for c in rgb(value("Color"))], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], float(value("Anisotropy"))
+    if node.type == "VOLUME_ABSORPTION":
+        density = max(float(value("Density")), 0.0)
+        return [0.0, 0.0, 0.0], [max(1.0 - c, 0.0) * density for c in rgb(value("Color"))], [0.0, 0.0, 0.0], 0.0
+    if node.type == "ADD_SHADER":
+        parts = [_volume_coefficients(link.from_node) for socket in node.inputs for link in socket.links]
+        if not parts:
+            return None
+        scattering = [sum(p[0][k] for p in parts) for k in range(3)]
+        weight = sum(sum(p[0]) for p in parts)
+        anisotropy = sum(sum(p[0]) * p[3] for p in parts) / weight if weight > 0 else 0.0
+        return (scattering, [sum(p[1][k] for p in parts) for k in range(3)],
+                [sum(p[2][k] for p in parts) for k in range(3)], anisotropy)
+    raise ValueError("it is a %s node" % node.type)
+
+
+def _world_volume(world, output):
+    """The world's Volume socket as a homogeneous medium (`STD_environment.volume`), and what could not be
+    carried. Nothing is dropped silently: a volume that isn't homogeneous is named."""
+    socket = output.inputs["Volume"] if output is not None else None
+    if socket is None or not socket.is_linked:
+        return None, None
+    try:
+        found = _volume_coefficients(socket.links[0].from_node)
+    except ValueError as why:
+        return None, "the world %s's volume is not a homogeneous medium (%s): it is not carried" % (world.name, why)
+    if found is None:
+        return None, None
+    scattering, absorption, emission, anisotropy = found
+    r6 = lambda values: [round(v, 6) for v in values]
+    return {"scattering": r6(scattering), "absorption": r6(absorption), "emission": r6(emission),
+            "anisotropy": round(max(-1.0, min(1.0, anisotropy)), 6)}, None
+
+
+def _object_volumes(objects, visibility):
+    """BOUNDED VOLUMES (`STD_volume`): a mesh whose material is a homogeneous volume and no surface (a haze or fog
+    bank's box) is the volume's domain: its coefficients per metre, as the world's are, and its shape (its bounding
+    box, a box when the mesh is one; else the box around it, named), in the node's own Y-up frame. The node is hidden
+    (KHR_node_visibility), as Blender renders no surface there. Any other volume (beside a surface, not homogeneous)
+    is named, not carried. Answers {object: data} and the warnings."""
+    found, warnings = {}, []
+    for obj in objects:
+        if obj.type != "MESH" or not visibility[obj.name]:
+            continue
+        volumes = []
+        for slot in obj.material_slots:
+            material = slot.material
+            if material is None or not material.use_nodes or material.node_tree is None:
+                continue
+            outputs = [n for n in material.node_tree.nodes if n.type == "OUTPUT_MATERIAL"]
+            output = next((n for n in outputs if n.is_active_output), outputs[0] if outputs else None)
+            if output is not None and output.inputs["Volume"].is_linked:
+                volumes.append((material, output))
+        if not volumes:
+            continue
+        material, output = volumes[0]
+        surface = output.inputs["Surface"]
+        if len(obj.material_slots) != 1 or surface.is_linked:
+            warnings.append("%s's material %s has a volume beside a surface: it is not carried (a volume's domain is a mesh "
+                            "of a volume material alone)" % (obj.name, material.name))
+            continue
+        try:
+            coefficients = _volume_coefficients(output.inputs["Volume"].links[0].from_node)
+        except ValueError as why:
+            warnings.append("%s's volume is not a homogeneous medium (%s): it is not carried" % (obj.name, why))
+            continue
+        if coefficients is None:
+            continue
+        scattering, absorption, emission, anisotropy = coefficients
+        corners = [mathutils.Vector(c) for c in obj.bound_box]
+        low = mathutils.Vector((min(c.x for c in corners), min(c.y for c in corners), min(c.z for c in corners)))
+        high = mathutils.Vector((max(c.x for c in corners), max(c.y for c in corners), max(c.z for c in corners)))
+        centre, size = (low + high) / 2, high - low
+        if len(obj.data.vertices) != 8:
+            warnings.append("%s's volume domain is not a box: it is carried as the box around it" % obj.name)
+        r6 = lambda values: [round(float(v), 6) for v in values]
+        # (Blender's local x, y, z are the glTF node's x, z, -y)
+        found[obj.name] = {"shape": "box", "center": r6((centre.x, centre.z, -centre.y)), "size": r6((size.x, size.z, size.y)),
+                           "scattering": r6(scattering), "absorption": r6(absorption), "emission": r6(emission),
+                           "anisotropy": round(max(-1.0, min(1.0, anisotropy)), 6)}
+    return found, warnings
+
+
+def _pick(owner, name):
+    return getattr(owner, name) if hasattr(owner, name) else None
+
+
+def _render(scene):
+    """The scene's render settings, as the neutral data a renderer honours or names (Q7; `STD_render`).
+    Look-defining: shadows and whether light bounces; the rest are quality hints."""
+    render, eevee = scene.render, scene.eevee
+    data = {"shadows": bool(eevee.use_shadows)}
+    if render.engine == "CYCLES":
+        # A path tracer: light bounces everywhere.
+        data["globalIllumination"] = {"mode": "full"}
+    else:
+        data["softShadows"] = {"rays": int(eevee.shadow_ray_count), "steps": int(eevee.shadow_step_count)}
+        # EEVEE enables Fast GI only when ray tracing is enabled.
+        if eevee.use_fast_gi and eevee.use_raytracing:
+            data["globalIllumination"] = {"mode": "occlusion" if eevee.fast_gi_method == "AMBIENT_OCCLUSION_ONLY" else "screen-space",
+                                          "resolution": round(1.0 / max(1, int(eevee.fast_gi_resolution)), 6)}
+        data["raytracing"] = bool(eevee.use_raytracing)
+        # The range EEVEE draws volumes over: its custom range where that is on, else the camera's clip range
+        # (the scene's camera; none: the custom values, as EEVEE has nothing else to go by).
+        start, end = float(eevee.volumetric_start), float(eevee.volumetric_end)
+        if not eevee.use_volume_custom_range and scene.camera is not None and scene.camera.type == "CAMERA":
+            start, end = float(scene.camera.data.clip_start), float(scene.camera.data.clip_end)
+        data["volumetric"] = {"start": round(start, 6), "end": round(end, 6),
+                              "tileSize": int(eevee.volumetric_tile_size), "samples": int(eevee.volumetric_samples),
+                              "shadows": bool(eevee.use_volumetric_shadows)}
+        data["antialiasing"] = {"samples": int(eevee.taa_render_samples), "filterWidth": round(render.filter_size, 6)}
+    data["transparentBackground"] = bool(render.film_transparent)
+    data["motionBlur"] = bool(render.use_motion_blur)
+    return data
+
+
+def _display(scene, lut):
+    """How the scene is seen (`STD_display`): its colour management, which glTF has no place for. The LUT
+    is what a host applies; the view's name is information only."""
+    view = scene.view_settings
+    display = {"exposure": round(view.exposure, 6), "gamma": round(view.gamma, 6), "view": view.view_transform}
+    display["lut"] = {"uri": lut["file"], "size": lut["size"],
+                      "shaper": {"type": "log2", "min": lut["shaper"]["min"], "max": lut["shaper"]["max"]},
+                      "input": "linear-rec709", "output": "display"}
+    display["key"] = lut["key"]
+    return display
+
+
+def _light(light):
+    """What KHR_lights_punctual can't say of a light (`STD_light`): the units its intensity is in, its shadow
+    (the emitter's radius softens it), a sun's angular diameter, and an AREA light, which glTF has no light
+    for: its shape, size, colour and radiance. A Blender area light of power P (W, times 2^exposure; times its
+    area when not normalised) seen from the front is a point light of P: its radiance is P / (4 pi area)."""
+    data = {"units": "scene-linear",
+            "shadow": {"cast": bool(light.use_shadow), "radius": round(float(_pick(light, "shadow_soft_size") or 0.0), 6)}}
+    if light.type == "SUN":
+        data["angularDiameter"] = round(float(light.angle), 6)
+    elif light.type == "AREA":
+        width = float(light.size)
+        height = float(light.size_y) if light.shape in ("RECTANGLE", "ELLIPSE") else width
+        ellipse = light.shape in ("DISK", "ELLIPSE")
+        area = max((math.pi / 4 if ellipse else 1.0) * width * height, 1e-9)
+        power = float(light.energy) * 2 ** float(light.exposure)
+        if not light.normalize:
+            power *= area
+        data["area"] = {"shape": "ellipse" if ellipse else "rectangle", "width": round(width, 6), "height": round(height, 6),
+                        "color": [round(float(c), 6) for c in light.color], "radiance": round(power / (4 * math.pi * area), 9)}
+    return data
+
+
+def _area_lights(objects, visibility):
+    return ["the AREA light %s has no glTF light (KHR_lights_punctual is point, spot and sun): it goes as its node's "
+            "STD_light.area (shape, size, colour, radiance) only" % o.name
+            for o in objects if o.type == "LIGHT" and o.data.type == "AREA" and visibility[o.name]]
+
+
+def _hidden_over_visible(objects, visibility):
+    """`KHR_node_visibility` hides a node's whole subtree; Blender's render visibility does not."""
+    exported = set(objects)
+    found = []
+    for obj in objects:
+        if visibility[obj.name]:
+            continue
+        shown = [c.name for c in obj.children_recursive if c in exported and visibility[c.name]]
+        if shown:
+            found.append("%s is hidden in renders but its children %s are not; the glTF hides them too"
+                         % (obj.name, ", ".join(sorted(shown)[:5])))
+    return found
+
+
+def _collection_ancestors(scene):
+    """Every collection of the scene's hierarchy, by name, with the collections that hold it."""
+    ancestors = {}
+
+    def walk(collection, chain):
+        for child in collection.children:
+            if child.name == _HOLDER:
+                continue
+            ancestors.setdefault(child.name, set()).update(chain)
+            walk(child, chain + [child.name])
+
+    walk(scene.collection, [])
+    # A collection of the file outside the scene (a variant a level places: `Helldiver.Rifleman`, some of
+    # the Helldiver's objects) holds its objects too, with the collections that hold it.
+    parents = {}
+    for collection in bpy.data.collections:
+        for child in collection.children:
+            parents.setdefault(child.name, set()).add(collection.name)
+    for collection in bpy.data.collections:
+        if collection.library is not None or collection.name in ancestors or collection.name == _HOLDER:
+            continue
+        chain, todo = set(), list(parents.get(collection.name, ()))
+        while todo:
+            name = todo.pop()
+            if name not in chain:
+                chain.add(name)
+                todo.extend(parents.get(name, ()))
+        ancestors[collection.name] = chain
+    return ancestors
+
+
+def _collections_of(names, ancestors):
+    """The collections named and every collection holding them, sorted; the scene's own collection,
+    the authoring collections and the export's holder are not among them."""
+    found = set()
+    for name in names:
+        if name in ancestors and name not in AUTHORING:
+            found.add(name)
+            found.update(a for a in ancestors[name] if a not in AUTHORING)
+    return sorted(found)
+
+
+def _node_collections(objects, ancestors):
+    return {o.name: _collections_of([c.name for c in o.users_collection], ancestors) for o in objects}
+
+
+def _strip(strip):
+    """One NLA strip's timing, as Blender plays it, in the standard's names (`STD_animation_tracks`): its
+    scene range, the clip's range it plays, scale and repeats, blend in and out, extrapolation, blend,
+    influence, and whether it plays backwards. None for a strip with no action."""
+    if strip.action is None:
+        return None
+    data = {"clip": strip.action.name,
+            "start": round(float(strip.frame_start), 6), "end": round(float(strip.frame_end), 6),
+            "clipStart": round(float(strip.action_frame_start), 6), "clipEnd": round(float(strip.action_frame_end), 6),
+            "scale": round(float(strip.scale), 6), "repeat": round(float(strip.repeat), 6),
+            "blendIn": round(float(strip.blend_in), 6), "blendOut": round(float(strip.blend_out), 6),
+            "extrapolation": EXTRAPOLATIONS[strip.extrapolation], "blend": BLENDS[strip.blend_type],
+            "influence": round(float(strip.influence), 6) if strip.use_animated_influence else 1.0,
+            "reversed": bool(strip.use_reverse), "mute": bool(strip.mute)}
+    if strip.use_animated_influence:
+        # THE INFLUENCE AS THE FILE ANIMATES IT: its F-curve read at every frame of the strip.
+        curve = strip.fcurves.find("influence")
+        if curve is not None:
+            first, last = int(math.floor(strip.frame_start)), int(math.ceil(strip.frame_end))
+            data["influenceKeys"] = [[frame, round(min(1.0, max(0.0, float(curve.evaluate(frame)))), 6)]
+                                     for frame in range(first, last + 1)]
+    return data
+
+
+def _tracks(obj):
+    """An armature's NLA tracks, bottom to top (RFC 0007 §1, `STD_animation_tracks.tracks`): each one's name
+    and mute, and its strips unless muted. A placement marker carries its override's own tracks the same way."""
+    data = obj.animation_data
+    if data is None:
+        return None
+    tracks = []
+    for track in data.nla_tracks:
+        entry = {"name": track.name, "mute": bool(track.mute)}
+        if track.is_solo:
+            entry["solo"] = True
+        if not track.mute:
+            entry["strips"] = [s for s in (_strip(strip) for strip in track.strips if strip.type == "CLIP") if s is not None]
+        tracks.append(entry)
+    return tracks
+
+
+def _nla_settings(obj):
+    """An armature's NLA settings a game plays by, where they are not Blender's defaults: the NLA turned off
+    (`tracksEnabled: false`), and the active action's own blend over the strips (`clipBlend`: blend, influence)."""
+    data = obj.animation_data
+    if data is None:
+        return {}
+    settings = {}
+    if not data.use_nla:
+        settings["tracksEnabled"] = False
+    if data.action_blend_type != "REPLACE" or abs(data.action_influence - 1.0) > 1e-6:
+        settings["clipBlend"] = {"blend": BLENDS[data.action_blend_type], "influence": round(float(data.action_influence), 6)}
+    return settings
+
+
+_OBJECT_CHANNELS = ("location", "rotation_quaternion", "rotation_euler", "rotation_axis_angle", "scale", "delta_location",
+                    "delta_rotation_quaternion", "delta_rotation_euler", "delta_scale")
+
+
+def _moves_itself(obj):
+    """Whether an object's own transform is animated: by its action, or by an unmuted NLA strip's."""
+    data = obj.animation_data
+    if data is None:
+        return False
+    actions = [data.action] if data.action is not None else []
+    for track in data.nla_tracks:
+        if not track.mute:
+            actions.extend(strip.action for strip in track.strips if strip.action is not None)
+    return any(c.data_path in _OBJECT_CHANNELS for action in actions for c in _action_curves(action))
+
+
+def _bake_placement_motion(scene, moving):
+    """THE PLACEMENT'S OWN MOTION (RFC 0007 §3): key each moving placement's marker at every scene frame
+    where Blender puts its override root (its action and NLA strips, any blend, as Blender evaluates
+    them), so the level's scene animation carries it. Answers the actions made, for the caller to remove."""
+    made = []
+    if not moving:
+        return made
+    for marker, _root, _inverse in moving:
+        marker.rotation_mode = "QUATERNION"
+        marker.animation_data_create()
+        action = bpy.data.actions.new("__volter_marker_motion")
+        marker.animation_data.action = action
+        made.append(action)
+    for frame in range(scene.frame_start, scene.frame_end + 1):
+        scene.frame_set(frame)
+        for marker, root, inverse in moving:
+            marker.matrix_world = root.matrix_world @ inverse
+            for path in ("location", "rotation_quaternion", "scale"):
+                marker.keyframe_insert(path, frame=frame)
+    return made
+
+
+def _level_actions(root):
+    """The actions a placement plays that the level made (its active action or its NLA strips' actions
+    that are not its component's), keying its bones."""
+    data = root.animation_data
+    if data is None or root.type != "ARMATURE":
+        return []
+    candidates = [data.action] if data.action is not None else []
+    for track in data.nla_tracks:
+        if not track.mute:
+            candidates.extend(strip.action for strip in track.strips if strip.action is not None)
+    found = []
+    for action in candidates:
+        if action.library is None and action not in found and any(c.data_path.startswith("pose.bones[") for c in _action_curves(action)):
+            found.append(action)
+    return found
+
+
+def _companion(out, placement):
+    """The file a placement's own actions are written to, beside the level's."""
+    base = os.path.splitext(os.path.basename(out))[0]
+    return "%s.%s.actions.glb" % (base, re.sub(r"[^A-Za-z0-9._-]", "_", placement))
+
+
+def _export_placement_actions(scene, view_layer, root, actions, path):
+    """A PLACEMENT'S OWN ACTIONS (made in the level, played by the override's NLA): Blender's exporter writes
+    them for the placed armature alone (its bones, no meshes), one animation each, through the same passes as
+    a component's (RFC 0007 §1, §2): its runtime constraints muted while Blender samples (they are the script's,
+    applied at runtime, never baked into the keys), only what each action moves, samples between frames where
+    whole frames miss its motion, each rotation key in its action's sign with its keyed length. Answers its
+    warnings and what the sub-frame pass did, for the level's manifest."""
+    module = _gltf_addon()
+    keep = {action.name for action in actions}
+    runtime, _data, warnings = _runtime_constraints([root])
+    registered = hasattr(bpy.types.Scene, "gltf_action_filter")
+    if not registered:
+        bpy.types.Scene.gltf_action_filter = bpy.props.CollectionProperty(type=module.GLTF2_filter_action)
+    # (a scene that stored no list before stores none after: the property is unset again)
+    stored = {scene_.name for scene_ in bpy.data.scenes if scene_.is_property_set("gltf_action_filter")}
+    listed = bpy.data.scenes[0].gltf_action_filter
+    saved = [(item.action, item.keep) for item in listed]
+    listed.clear()
+    try:
+        for action in bpy.data.actions:
+            item = listed.add()
+            item.action = action
+            item.keep = action.name in keep
+        settings = dict(COMPONENT_SETTINGS, export_extras=False, export_cameras=False, export_lights=False, export_apply=False)
+        _with_hooks(_Hooks({}, {"keyRate": _key_rate(scene)}, {}), lambda: _muted(runtime, lambda: _at_rest([root], lambda: _export_set(
+            scene, view_layer, [root], lambda: _gltf(path, settings)))))
+        _unique_channels(path)
+        _weights_keyed(path)
+        candidates = {key: value for key, value in _subframe_candidates([root]).items() if key[1] in keep}
+        dense = _muted(runtime, lambda: _densify_subframes(path, [root], scene, candidates))
+        warnings.extend(_subframe_warnings(dense, candidates))
+        _align_rotation_signs(path, [root], scene)
+    finally:
+        listed.clear()
+        for action, kept in saved:
+            item = listed.add()
+            item.action, item.keep = action, kept
+        for scene_ in bpy.data.scenes:
+            if scene_.name not in stored and scene_.is_property_set("gltf_action_filter"):
+                scene_.property_unset("gltf_action_filter")
+        if not registered:
+            del bpy.types.Scene.gltf_action_filter
+    warnings.extend(_euler_bones([root], keep))
+    warnings.extend(_evaluated_bones([root]))
+    return {"warnings": warnings, "subframeSampling": _subframe_manifest(dense)}
+
+
+def _strip_warnings(objects):
+    """What of the NLA a game cannot play as Blender does, by name."""
+    found = []
+    for obj in objects:
+        data = obj.animation_data if obj.type == "ARMATURE" else None
+        if data is None:
+            continue
+        for track in data.nla_tracks:
+            if track.mute:
+                continue
+            for strip in track.strips:
+                if strip.type != "CLIP":
+                    found.append("%s's NLA strip %s is a %s strip: only action strips play" % (obj.name, strip.name, strip.type))
+                if strip.use_animated_time:
+                    found.append("%s's NLA strip %s has an animated strip time: a game plays the strip's own timing"
+                                 % (obj.name, strip.name))
+        if data.action_extrapolation != "HOLD" and data.action is not None:
+            found.append("%s's active action extrapolates as %s: a game plays its active action looping, or held at its "
+                         "end, as the script sets it" % (obj.name, data.action_extrapolation))
+    return found
+
+
+def _euler_bones(objects, only=None):
+    """Actions that key bones' rotations in Euler angles (or axis-angle): glTF carries rotations as
+    quaternions, so layered they blend as quaternions, where Blender's NLA blends the angles. Named per
+    action, with its bones (RFC 0007 §5); `only`, the action names to look at (all when None)."""
+    found = []
+    for obj in objects:
+        if obj.type != "ARMATURE" or obj.pose is None:
+            continue
+        angled = {b.name for b in obj.pose.bones if b.rotation_mode != "QUATERNION"}
+        if not angled:
+            continue
+        by_action = {}
+        for action in bpy.data.actions:
+            if only is not None and action.name not in only:
+                continue
+            for curve in _action_curves(action):
+                found_path = _BONE_PATH.match(curve.data_path)
+                if found_path and found_path.group(2) in ("rotation_euler", "rotation_axis_angle") and found_path.group(1) in angled:
+                    by_action.setdefault(action.name, set()).add(found_path.group(1))
+        for action, bones in sorted(by_action.items()):
+            found.append("%s's action %s keys Euler rotations (%s): glTF carries rotations as quaternions, so layered it "
+                         "blends as quaternions where Blender's NLA blends the angles; the two differ most for angles far "
+                         "apart" % (obj.name, action, ", ".join(sorted(bones))))
+    return found
+
+
+def _evaluated_bones(objects):
+    """Bones Blender poses from other bones as it plays (a constraint baked into the clips, every bone of
+    an IK chain, a bone not inheriting its parent's rotation or scale): each action carries their
+    evaluated pose, so a layer over another action blends those poses, where Blender evaluates them
+    again from the blended keys. Named, with the bones."""
+    found = []
+    for obj in objects:
+        if obj.type != "ARMATURE" or obj.pose is None:
+            continue
+        solved, loose = set(), set()
+        for pb in obj.pose.bones:
+            # (a runtime Damped Track is the script's, not baked)
+            runtime = {c.name for c in pb.constraints if c.name in _runtime_names(pb) and c.type == "DAMPED_TRACK"}
+            for constraint in pb.constraints:
+                if constraint.mute or constraint.influence <= 0 or constraint.name in runtime:
+                    continue
+                if constraint.type in ("IK", "SPLINE_IK"):
+                    length = constraint.chain_count
+                    bone, depth = pb, 0
+                    while bone is not None and (length == 0 or depth < length):
+                        solved.add(bone.name)
+                        bone, depth = bone.parent, depth + 1
+                else:
+                    solved.add(pb.name)
+            if not pb.bone.use_inherit_rotation or pb.bone.inherit_scale != "FULL":
+                loose.add(pb.name)
+        parts = []
+        if solved:
+            parts.append("constrained (IK chains included): " + ", ".join(sorted(solved)))
+        if loose:
+            parts.append("not inheriting their parent's rotation or scale: " + ", ".join(sorted(loose)))
+        if parts:
+            found.append("%s's bones that Blender poses from others are carried as each action evaluates them, so a "
+                         "layer over another action blends those poses, not Blender's evaluation of the blended keys; "
+                         "%s" % (obj.name, "; ".join(parts)))
+    return found
+
+
+# BETWEEN FRAMES (RFC 0007 §1): where interpolating whole-frame samples is this far from what Blender
+# evaluates at a half step, the export samples there too.
+SUBFRAME_DEGREES = 0.25
+SUBFRAME_METRES = 0.001
+SUBFRAME_SCALE = 0.001
+SUBFRAME_MOST = 32
+_Y_UP = mathutils.Matrix(((1.0, 0.0, 0.0, 0.0), (0.0, 0.0, 1.0, 0.0), (0.0, -1.0, 0.0, 0.0), (0.0, 0.0, 0.0, 1.0)))
+
+
+def _world_unit(obj):
+    """How long one unit of an armature's own space is in the world (its largest scale)."""
+    return max(abs(v) for v in obj.matrix_world.to_scale()) or 1.0
+
+
+def _subframe_candidates(objects):
+    """WHICH ACTIONS MAY NEED SAMPLING BETWEEN FRAMES, from their curves alone (no frame is evaluated): per
+    armature and action, the largest difference at a half frame between Blender's curve and the interpolation
+    of its whole-frame values, for each keyed bone rotation (quaternion or Euler: its own rotation, in degrees)
+    and location (in metres in the world). Answers {(armature, action): (degrees, metres, bone, frame)}."""
+    found = {}
+    for obj in objects:
+        if obj.type != "ARMATURE" or obj.pose is None:
+            continue
+        unit = _world_unit(obj)
+        modes = {b.name: b.rotation_mode for b in obj.pose.bones}
+        modes[_OBJECT] = obj.rotation_mode
+        for action in bpy.data.actions:
+            curves = {}
+            for curve in _action_curves(action):
+                matched = _BONE_PATH.match(curve.data_path)
+                if matched and matched.group(1) in modes:
+                    bone, path = matched.group(1), matched.group(2)
+                elif curve.data_path in ("location", "rotation_quaternion", "rotation_euler"):
+                    bone, path = _OBJECT, curve.data_path
+                else:
+                    continue
+                if path in ("rotation_quaternion", "rotation_euler", "location") and 0 <= curve.array_index < 4:
+                    curves.setdefault((bone, path), [None, None, None, None])[curve.array_index] = curve
+            if not curves:
+                continue
+            first, last = (int(math.floor(v)) for v in action.frame_range)
+            halves = range(2 * first, 2 * last + 1)
+            worst = [0.0, 0.0, None, None]
+            for (bone, path), four in curves.items():
+                if path == "rotation_quaternion" and modes[bone] != "QUATERNION":
+                    continue
+                if path == "rotation_euler" and modes[bone] in ("QUATERNION", "AXIS_ANGLE"):
+                    continue
+                size = 4 if path == "rotation_quaternion" else 3
+                rest = (1.0, 0.0, 0.0, 0.0) if path == "rotation_quaternion" else (0.0, 0.0, 0.0)
+                at = [[c.evaluate(f / 2.0) if c is not None else rest[i] for f in halves] for i, c in enumerate(four[:size])]
+
+                def value(k):
+                    v = [at[i][k] for i in range(size)]
+                    if path == "rotation_quaternion":
+                        return tuple(_unit_quaternion([v[1], v[2], v[3], v[0]]))
+                    if path == "rotation_euler":
+                        q = mathutils.Euler(v, modes[bone]).to_quaternion()
+                        return (q.x, q.y, q.z, q.w)
+                    return v
+                values = [value(k) for k in range(len(at[0]))]
+                for k in range(0, len(at[0]) - 2, 2):
+                    a, b, half = values[k], values[k + 2], values[k + 1]
+                    if path == "location":
+                        metres = math.sqrt(sum((m - (x + y) / 2.0) ** 2 for x, y, m in zip(a, b, half))) * unit
+                        if metres > worst[1]:
+                            worst[1] = metres
+                            if worst[2] is None:
+                                worst[2], worst[3] = bone, first + k / 2.0 + 0.5
+                        continue
+                    points = [(0.5, half)]
+                    if abs(sum(x * y for x, y in zip(a, b))) < 0.9962:
+                        # Turning over 10 degrees in a frame: Blender's normalised interpolation meets the arc in
+                        # the middle and parts from it near the quarters, so look there too.
+                        for u in (0.25, 0.75):
+                            at_u = first + k / 2.0 + u
+                            v = [c.evaluate(at_u) if c is not None else rest[i] for i, c in enumerate(four[:size])]
+                            if path == "rotation_quaternion":
+                                points.append((u, (v[1], v[2], v[3], v[0])))
+                            else:
+                                q = mathutils.Euler(v, modes[bone]).to_quaternion()
+                                points.append((u, (q.x, q.y, q.z, q.w)))
+                    difference = _off_arc(a, b, points)
+                    if difference > worst[0]:
+                        worst[0], worst[2], worst[3] = difference, bone, first + k / 2.0 + 0.5
+            if worst[0] > 0.0 or worst[1] > 0.0:
+                found[(obj.name, action.name)] = tuple(worst)
+    return found
+
+
+def _scene_actions(obj):
+    """What moves an object in the scene's animation: its active action (scene frame = action frame) and each
+    unmuted action strip of its unmuted NLA tracks, with the strip that maps scene frames into the action."""
+    data = obj.animation_data
+    if data is None:
+        return []
+    found = [(data.action, None)] if data.action is not None else []
+    if data.use_nla:
+        for track in data.nla_tracks:
+            if track.mute:
+                continue
+            found.extend((strip.action, strip) for strip in track.strips
+                         if strip.type == "CLIP" and not strip.mute and strip.action is not None)
+    return found
+
+
+def _strip_frame(strip, frame):
+    """The action frame a strip shows at a scene frame inside it (its range, scale, repeats, reversed)."""
+    if strip is None:
+        return frame
+    span = strip.action_frame_end - strip.action_frame_start
+    into = max(0.0, frame - strip.frame_start) / (strip.scale or 1.0)
+    if span > 0 and into > span:
+        into = span if frame >= strip.frame_end else into % span
+    at = strip.action_frame_start + into
+    return strip.action_frame_end - into if strip.use_reverse else at
+
+
+def _scene_subframe_worst(objects, scene):
+    """Measure scene-animation interpolation error from active actions and NLA strips at half frames, adding quarter frames for rotations over ten degrees per frame. Return worst rotation and position errors with object, bone and frame."""
+    worst_turn, worst_move = (0.0, None, None, None), (0.0, None, None, None)
+    first, last = scene.frame_start, scene.frame_end
+    for obj in objects:
+        for action, strip in _scene_actions(obj):
+            groups = _curve_groups(obj, action)
+            if not groups:
+                continue
+            lo, hi = (first, last) if strip is None else (max(first, int(math.ceil(strip.frame_start))), min(last, int(math.floor(strip.frame_end))))
+            unit = _world_unit(obj) if obj.type == "ARMATURE" else 1.0
+            for group in groups:
+                bone = None if group[0] == _OBJECT else group[0]
+
+                def value(frame):
+                    found = _curve_value(group, _strip_frame(strip, frame))
+                    return found if group[1] == "location" else tuple(_unit_quaternion(found))
+                previous = value(lo) if lo <= hi else None
+                for frame in range(lo, hi):
+                    a, b = previous, value(frame + 1)
+                    previous = b
+                    if group[1] == "location":
+                        mid = value(frame + 0.5)
+                        gap = math.sqrt(sum((m - (x + y) / 2.0) ** 2 for x, y, m in zip(a, b, mid))) * (unit if bone else 1.0)
+                        if gap > worst_move[0]:
+                            worst_move = (gap, obj.name, bone, frame + 0.5)
+                        continue
+                    points = [(0.5, value(frame + 0.5))]
+                    if abs(sum(x * y for x, y in zip(a, b))) < 0.9962:
+                        points += [(u, value(frame + u)) for u in (0.25, 0.75)]
+                    gap = _off_arc(a, b, points)
+                    if gap > worst_turn[0]:
+                        worst_turn = (gap, obj.name, bone, frame + 0.5)
+    return worst_turn, worst_move
+
+
+def _scene_subframe_warnings(worst):
+    turn, move = worst
+    if turn[0] < 0.01 and move[0] < 0.0001:
+        return []
+    where = lambda w: "%s%s, frame %.2f" % (w[1], " / " + w[2] if w[2] else "", w[3] or 0.0)
+    return ["between frames: the level's scene animation (cameras, keyed objects, the placements' motion, its own rigs) "
+            "is sampled at whole frames, and a cutscene plays between them; its curves part from the interpolation of "
+            "their whole-frame values by up to %.2f deg (%s) and %.1f mm (%s)" % (turn[0], where(turn) if turn[1] else "-",
+                                                                                move[0] * 1000.0, where(move) if move[1] else "-")]
+
+
+def _action_slot_for(action):
+    """The action's only object slot, or None when there is not exactly one."""
+    slots = [slot for slot in action.slots if slot.target_id_type == "OBJECT"]
+    return slots[0] if len(slots) == 1 else None
+
+
+def _as_exported(obj, action, slot, run):
+    """Run with `obj` posed as Blender's glTF exporter samples an action (its animation/action.py): the NLA off,
+    no track soloed, out of tweak mode, every pose bone at its rest, the action and its slot assigned; then put
+    everything back."""
+    data = obj.animation_data_create()
+    kept = (data.action, data.action_slot if data.action is not None else None, data.use_nla, data.use_tweak_mode)
+    soloed = [track for track in data.nla_tracks if track.is_solo]
+    held = _pose_channels([obj])
+    try:
+        if data.use_tweak_mode:
+            data.use_tweak_mode = False
+        for track in soloed:
+            track.is_solo = False
+        data.use_nla = False
+        data.action = None
+        _clear_pose([obj])
+        data.action = action
+        if slot is not None:
+            data.action_slot = slot
+        return run()
+    finally:
+        data.action = None
+        _put_back(held)
+        data.action = kept[0]
+        if kept[0] is not None and kept[1] is not None:
+            data.action_slot = kept[1]
+        data.use_nla = kept[2]
+        for track in soloed:
+            track.is_solo = True
+        if kept[3] and not data.use_tweak_mode:
+            try:
+                data.use_tweak_mode = True
+            except Exception:  # noqa: BLE001 (no strip to tweak any more)
+                pass
+
+
+def _bone_transforms(obj, parents):
+    """Each exported bone's glTF translation, rotation and scale from its pose now, computed as Blender's
+    exporter computes them (sampling_cache.armature_caching, then armature/sampler.py's correction and
+    gltf2_blender_math.transform): `parents` gives each bone's exported parent bone, or None at the root."""
+    axis = _Y_UP
+    fixed = {}
+    for name, parent in parents.items():
+        bone = obj.pose.bones[name]
+        if parent is not None:
+            rest = obj.pose.bones[parent].bone.matrix_local.inverted_safe() @ bone.bone.matrix_local
+            fixed[name] = (rest.inverted_safe(), rest, parent)
+        elif bone.parent is None:
+            fixed[name] = (bone.bone.matrix_local.inverted_safe(), axis @ bone.bone.matrix_local, None)
+        else:
+            fixed[name] = (None, axis, None)
+
+    def now():
+        out = {}
+        # The armature object's node: its world matrix in its parent's (sampling_cache.object_caching), each part
+        # through gltf2_blender_math.transform and swizzled to Y-up (object/sampler.py).
+        matrix = (obj.parent.matrix_world.inverted_safe() @ obj.matrix_world) if obj.parent is not None else obj.matrix_world.copy()
+        t, r, sc = matrix.decompose()
+        r.normalize()
+        q = r.to_matrix().to_4x4().to_quaternion()
+        sc = mathutils.Matrix.Diagonal(sc).to_4x4().to_scale()
+        out[_OBJECT] = {"translation": [t[0], t[2], -t[1]],
+                        "rotation": [q.x, q.z, -q.y, q.w],
+                        "scale": [sc[0], sc[2], sc[1]]}
+        for name, (before, correction, parent) in fixed.items():
+            bone = obj.pose.bones[name]
+            if parent is not None:
+                matrix = before @ obj.pose.bones[parent].matrix.inverted_safe() @ bone.matrix
+            elif before is not None:
+                matrix = before @ bone.matrix
+            else:
+                matrix = bone.matrix.copy()
+            t, r, sc = matrix.decompose()
+            r.normalize()
+            stretch = mathutils.Matrix.Identity(4)
+            stretch[0][0], stretch[1][1], stretch[2][2] = sc
+            q = (correction @ r.to_matrix().to_4x4()).to_quaternion()
+            out[name] = {"translation": list((correction @ mathutils.Matrix.Translation(t)).to_translation()),
+                         "rotation": [q.x, q.y, q.z, q.w], "scale": list((correction @ stretch).to_scale())}
+        return out
+    return now
+
+
+def _unit_quaternion(q):
+    n = math.sqrt(sum(v * v for v in q)) or 1.0
+    return [v / n for v in q]
+
+
+def _quaternion_degrees(a, b):
+    """The angle between two rotations ([x, y, z, w]), in double precision, either sign."""
+    a, b = _unit_quaternion(a), _unit_quaternion(b)
+    # conj(a) * b
+    w = a[3] * b[3] + a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+    x = a[3] * b[0] - a[0] * b[3] - a[1] * b[2] + a[2] * b[1]
+    y = a[3] * b[1] + a[0] * b[2] - a[1] * b[3] - a[2] * b[0]
+    z = a[3] * b[2] - a[0] * b[1] + a[1] * b[0] - a[2] * b[3]
+    return math.degrees(2.0 * math.atan2(math.sqrt(x * x + y * y + z * z), abs(w)))
+
+
+def _quaternion_slerp(a, b, t):
+    """The shortest arc from `a` to `b` at `t` ([x, y, z, w]), as a reader interpolates two keys."""
+    a, b = _unit_quaternion(a), _unit_quaternion(b)
+    dot = sum(x * y for x, y in zip(a, b))
+    if dot < 0.0:
+        b, dot = [-v for v in b], -dot
+    if dot > 0.9999999:
+        return _unit_quaternion([x + (y - x) * t for x, y in zip(a, b)])
+    theta = math.acos(min(1.0, dot))
+    s0, s1 = math.sin((1.0 - t) * theta) / math.sin(theta), math.sin(t * theta) / math.sin(theta)
+    return [s0 * x + s1 * y for x, y in zip(a, b)]
+
+
+def _off_arc(a, b, points):
+    """The largest angle, in degrees, between each (u, rotation) of `points` and the shortest arc from `a` to `b`
+    at u: what a reader interpolating keys `a` and `b` misses there. `a` and `b` are unit [x, y, z, w]; the
+    points' rotations need not be unit. Pure Python, the arc's angle worked out once."""
+    ax, ay, az, aw = a
+    bx, by, bz, bw = b
+    dot = ax * bx + ay * by + az * bz + aw * bw
+    if dot < 0.0:
+        bx, by, bz, bw, dot = -bx, -by, -bz, -bw, -dot
+    theta = math.acos(min(1.0, dot))
+    sine = math.sin(theta)
+    worst = 0.0
+    for u, (mx, my, mz, mw) in points:
+        if sine < 1e-9:
+            w0, w1 = 1.0 - u, u
+        else:
+            w0, w1 = math.sin((1.0 - u) * theta) / sine, math.sin(u * theta) / sine
+        px, py, pz, pw = w0 * ax + w1 * bx, w0 * ay + w1 * by, w0 * az + w1 * bz, w0 * aw + w1 * bw
+        # conj(p) * m: its vector part against its scalar part is half the angle between them.
+        w = pw * mw + px * mx + py * my + pz * mz
+        x = pw * mx - px * mw - py * mz + pz * my
+        y = pw * my + px * mz - py * mw - pz * mx
+        z = pw * mz - px * my + py * mx - pz * mw
+        angle = math.degrees(2.0 * math.atan2(math.sqrt(x * x + y * y + z * z), abs(w)))
+        if angle > worst:
+            worst = angle
+    return worst
+
+
+_OBJECT = "\u0000object"
+
+
+def _curve_groups(obj, action):
+    """The action's curves on `obj`'s bones, per bone and property: (bone, path, four curves, rotation mode), for
+    a quaternion or Euler rotation and a location. The armature object's own channels (root motion keyed on the
+    object) are one more group, its bone named _OBJECT."""
+    modes = {b.name: b.rotation_mode for b in obj.pose.bones} if obj.pose is not None else {}
+    modes[_OBJECT] = obj.rotation_mode
+    curves = {}
+    for curve in _action_curves(action):
+        matched = _BONE_PATH.match(curve.data_path)
+        if matched and matched.group(1) in modes:
+            bone, path = matched.group(1), matched.group(2)
+        elif curve.data_path in ("location", "rotation_quaternion", "rotation_euler"):
+            bone, path = _OBJECT, curve.data_path
+        else:
+            continue
+        if path in ("rotation_quaternion", "rotation_euler", "location") and 0 <= curve.array_index < 4:
+            curves.setdefault((bone, path), [None, None, None, None])[curve.array_index] = curve
+    groups = []
+    for (bone, path), four in sorted(curves.items()):
+        mode = modes[bone]
+        if path == "rotation_quaternion" and mode != "QUATERNION":
+            continue
+        if path == "rotation_euler" and mode in ("QUATERNION", "AXIS_ANGLE"):
+            continue
+        groups.append((bone, path, four, mode))
+    return groups
+
+
+def _curve_value(group, frame):
+    """A group's value at a frame: a rotation as [x, y, z, w], a location as [x, y, z]."""
+    _bone, path, four, mode = group
+    if path == "rotation_quaternion":
+        v = [c.evaluate(frame) if c is not None else (1.0 if i == 0 else 0.0) for i, c in enumerate(four)]
+        return [v[1], v[2], v[3], v[0]]
+    v = [c.evaluate(frame) if c is not None else 0.0 for c in four[:3]]
+    if path == "rotation_euler":
+        q = mathutils.Euler(v, mode).to_quaternion()
+        return [q.x, q.y, q.z, q.w]
+    return v
+
+
+def _straight(group):
+    """Whether every key of the group's curves interpolates linearly, with no modifier: then between two of its
+    keys each component moves in a straight line."""
+    return all(c is None or (len(c.modifiers) == 0 and all(p.interpolation == "LINEAR" for p in c.keyframe_points))
+               for c in group[2])
+
+
+def _sample_frames(groups, first, last, unit, chains):
+    """WHERE TO SAMPLE AN ACTION: its whole frames (as the exporter samples it), its own keys (an action keyed
+    off whole frames, every 0.8 frames for a 30 fps source in a 24 fps scene, turns between whole frames), and,
+    where its curves still part from what a reader interpolates between two of those by more than the limit
+    (looked at a quarter, half and three quarters of the way), the middle, down to 1 / SUBFRAME_MOST of a frame. A rotation is judged along its bone's chain: the sum of
+    its own and its parents' differences (`chains`: each bone with its parents), so a fingertip, which turns
+    with every bone above it, stays within the limit too. Rotations keyed linearly still part from a reader's
+    interpolation (Blender normalises the interpolated components, a reader turns along the arc), so every
+    rotation is judged; a linearly keyed location is not. Answers the frames, sorted, and what the curves leave
+    between them: (degrees along a chain, bone, frame)."""
+    frames = {float(f) for f in range(int(math.ceil(first)), int(math.floor(last)) + 1)}
+    frames.update((first, last))
+    for group in groups:
+        for curve in group[2]:
+            if curve is not None:
+                frames.update(round(p.co[0], 4) for p in curve.keyframe_points if first < p.co[0] < last)
+    judged = [g for g in groups if g[1] != "location" or not _straight(g)]
+    straight = {id(g) for g in judged if _straight(g)}
+    left = (0.0, None, None)
+    if not judged:
+        return sorted(frames), left
+    cache = {}
+
+    def value(group, at):
+        key = (id(group), at)
+        if key not in cache:
+            found = _curve_value(group, at)
+            cache[key] = found if group[1] == "location" else tuple(_unit_quaternion(found))
+        return cache[key]
+
+    ordered = sorted(frames)
+    todo = list(zip(ordered, ordered[1:]))
+    while todo:
+        a, b = todo.pop()
+        middle = (a + b) / 2.0
+        turned, moved = {}, False
+        for group in judged:
+            va, vb = value(group, a), value(group, b)
+            if group[1] == "location":
+                vm = value(group, middle)
+                moved = moved or math.sqrt(sum((m - (x + y) / 2.0) ** 2 for x, y, m in zip(va, vb, vm))) * unit > SUBFRAME_METRES
+                continue
+            if id(group) in straight and abs(sum(x * y for x, y in zip(va, vb))) > 0.99985:
+                # Keyed linearly and turning under 2 degrees here: its normalised interpolation is on the arc
+                # to within thousandths of a degree.
+                continue
+            # At the quarters too: Blender's normalised interpolation meets the arc in the middle and parts from
+            # it most near a quarter.
+            turned[group[0]] = _off_arc(va, vb, [(u, value(group, a + (b - a) * u)) for u in (0.25, 0.5, 0.75)])
+        along = max(((sum(turned.get(b, 0.0) for b in chains[bone]), bone) for bone in turned), default=(0.0, None))
+        if (moved or along[0] > SUBFRAME_DEGREES) and (b - a) / 2.0 >= 1.0 / SUBFRAME_MOST:
+            frames.add(middle)
+            todo.extend(((a, middle), (middle, b)))
+            continue
+        if along[0] > left[0]:
+            left = (along[0], along[1], middle)
+    return sorted(frames), left
+
+
+def _densify_subframes(out, objects, scene, candidates):
+    """SAMPLE BETWEEN FRAMES WHERE IT MATTERS (RFC 0007 §1). Blender's exporter samples each action at whole
+    frames only: it calls `scene.frame_set(int(frame))` (its sampled/sampling_cache.py), so a fractional
+    `export_frame_step` is cut to whole frames, and the step itself is a whole number.
+
+    For each action whose curves say a half frame may be off by more than SUBFRAME_DEGREES (or
+    SUBFRAME_METRES), this chooses where to sample (_sample_frames: whole frames, the action's own keys, and
+    the middles its bending curves need), poses the armature as the exporter does (_as_exported) and evaluates
+    Blender at each of those frames that isn't whole, computing each bone's glTF values with the exporter's own
+    formulas (_bone_transforms). Whole frames keep the exporter's own keys; a few are evaluated too, and must
+    give the same values, else the action is left as exported and named. A bone channel whose new samples lie
+    more than the limit from its whole-frame interpolation gets all of them; every other channel stays as the
+    exporter wrote it. Runs before the sign pass, which then writes every key, the new ones too, in its
+    action's sign with its keyed length.
+
+    Answers {"actions": {action: keys}, "channels": n, "bytes": change in the file's size, "remaining":
+    (degrees, action, bone, frame), "mismatch": [...], "evaluated": frames evaluated}."""
+    result = {"actions": {}, "channels": 0, "bytes": 0, "remaining": (0.0, None, None, None), "mismatch": [], "evaluated": 0}
+    wanted = {action for (_armature, action), (degrees, metres, _b, _f) in candidates.items()
+              if degrees > SUBFRAME_DEGREES or metres > SUBFRAME_METRES}
+    armatures = {o.name: o for o in objects if o.type == "ARMATURE" and o.pose is not None}
+    if not wanted or not armatures:
+        return result
+    before_bytes = os.path.getsize(out)
+    data, length, document, binary = _glb_parts(out)
+    nodes = document.get("nodes", [])
+    accessors, views = document.get("accessors", []), document.get("bufferViews", [])
+    parent_of = {child: index for index, node in enumerate(nodes) for child in node.get("children", [])}
+    rate = _key_rate(scene)
+    frame, subframe = scene.frame_current, scene.frame_subframe
+
+    def read(index):
+        accessor = accessors[index]
+        view = views[accessor["bufferView"]]
+        width = {"SCALAR": 1, "VEC3": 3, "VEC4": 4}[accessor["type"]]
+        start = view.get("byteOffset", 0) + accessor.get("byteOffset", 0)
+        flat = struct.unpack_from("<%df" % (accessor["count"] * width), binary, start)
+        return [list(flat[i * width:(i + 1) * width]) for i in range(accessor["count"])] if width > 1 else list(flat)
+
+    def append(values, kind, bounds=False):
+        flat = [v for value in values for v in value] if kind != "SCALAR" else list(values)
+        packed = struct.pack("<%df" % len(flat), *flat)
+        binary.extend(b"\0" * ((4 - len(binary) % 4) % 4))
+        views.append({"buffer": 0, "byteOffset": len(binary), "byteLength": len(packed)})
+        binary.extend(packed)
+        accessor = {"bufferView": len(views) - 1, "componentType": 5126, "count": len(values), "type": kind}
+        if bounds:
+            accessor["min"], accessor["max"] = [min(values)], [max(values)]
+        accessors.append(accessor)
+        return len(accessors) - 1
+
+    def interpolate(path, frames, values, at):
+        """A channel's exported keys read at a frame, as a reader reads them (held past the ends)."""
+        if at <= frames[0]:
+            return values[0]
+        if at >= frames[-1]:
+            return values[-1]
+        for k in range(1, len(frames)):
+            if at <= frames[k]:
+                u = (at - frames[k - 1]) / (frames[k] - frames[k - 1]) if frames[k] > frames[k - 1] else 1.0
+                if path == "rotation":
+                    return _quaternion_slerp(values[k - 1], values[k], u)
+                return [x + (y - x) * u for x, y in zip(values[k - 1], values[k])]
+    try:
+        for animation in document.get("animations", []):
+            name = animation.get("name", "")
+            action = bpy.data.actions.get(name)
+            if action is None or name not in wanted:
+                continue
+            channels = []
+            for channel in animation.get("channels", []):
+                target = channel.get("target", {})
+                node = target.get("node")
+                if node is None or target.get("path") not in ("translation", "rotation", "scale"):
+                    continue
+                bone = nodes[node].get("name", "")
+                owner = next((a for a in armatures.values() if a.pose.bones.get(bone) is not None), None)
+                if owner is None and bone in armatures:
+                    owner, bone = armatures[bone], _OBJECT
+                sampler = animation["samplers"][channel["sampler"]]
+                if owner is None or sampler.get("interpolation", "LINEAR") != "LINEAR":
+                    continue
+                channels.append((node, channel, owner, bone, target["path"], sampler))
+            owners = {owner.name for _n, _c, owner, _b, _p, _s in channels}
+            if len(owners) != 1:
+                continue
+            obj = armatures[owners.pop()]
+            slot = _action_slot_for(action)
+            if slot is None and len(action.slots) > 1:
+                result["mismatch"].append("%s has several slots: sampled at whole frames only" % name)
+                continue
+            slide = _action_slide(action)
+            exported = {}
+            for _n, _c, _o, _b, _p, sampler in channels:
+                key = (sampler["input"], sampler["output"])
+                if key not in exported:
+                    exported[key] = ([round(t * rate + slide, 4) for t in read(sampler["input"])], read(sampler["output"]))
+            first = min(f[0][0] for f in exported.values())
+            last = max(f[0][-1] for f in exported.values())
+            if last - first < 1:
+                continue
+            unit = _world_unit(obj)
+            groups = _curve_groups(obj, action)
+            chains = {_OBJECT: [_OBJECT]}
+            for bone in obj.pose.bones:
+                chains[bone.name] = [bone.name] + [parent.name for parent in bone.parent_recursive] + [_OBJECT]
+            frames, curves_left = _sample_frames(groups, first, last, unit, chains)
+            between = [f for f in frames if abs(f - round(f)) > 1e-4]
+            if not between:
+                continue
+            parents = {}
+            for node, _c, _o, bone, _p, _s in channels:
+                if bone == _OBJECT:
+                    continue
+                parent = parent_of.get(node)
+                parent_name = nodes[parent].get("name") if parent is not None else None
+                parents[bone] = parent_name if parent_name is not None and obj.pose.bones.get(parent_name) is not None else None
+            transforms = _bone_transforms(obj, parents)
+            # Three whole frames are evaluated too: the exporter's formulas must give its own keys there.
+            checks = sorted({float(math.ceil(first)), float(round((first + last) / 2.0)), float(math.floor(last))})
+
+            def evaluate():
+                found = {}
+                for at in checks + between:
+                    whole = math.floor(at)
+                    scene.frame_set(int(whole), subframe=at - whole)
+                    found[at] = transforms()
+                result["evaluated"] += len(found)
+                return found
+            posed = _as_exported(obj, action, slot, evaluate)
+            worst_match = 0.0
+            for _n, _c, _o, bone, path, sampler in channels:
+                key_frames, values = exported[(sampler["input"], sampler["output"])]
+                for at in checks:
+                    if at in key_frames:
+                        mine, theirs = posed[at][bone][path], values[key_frames.index(at)]
+                        worst_match = max(worst_match, _quaternion_degrees(mine, theirs) if path == "rotation" else
+                                          max(abs(x - y) / max(1.0, abs(y)) for x, y in zip(mine, theirs)) * 1000.0)
+            if worst_match > 0.01:
+                result["mismatch"].append("%s: Blender's poses at whole frames differ from the exported keys by %.4f "
+                                          "(degrees or mm): sampled at whole frames only" % (name, worst_match))
+                continue
+            seconds = [(f - slide) / rate for f in frames]
+            new_input = None
+            moved = 0
+            placed = {}
+            for _n, channel, _o, bone, path, sampler in channels:
+                key_frames, values = exported[(sampler["input"], sampler["output"])]
+                if sampler["input"] not in placed:
+                    where = []
+                    for at in between:
+                        k = min(max(bisect.bisect_left(key_frames, at), 1), len(key_frames) - 1)
+                        span = key_frames[k] - key_frames[k - 1]
+                        where.append((at, k, min(1.0, max(0.0, (at - key_frames[k - 1]) / span)) if span > 0 else 1.0))
+                    placed[sampler["input"]] = where
+                where = placed[sampler["input"]]
+                if path == "rotation":
+                    off = 0.0
+                    for at, k, u in where:
+                        off = max(off, _off_arc(_unit_quaternion(values[k - 1]), _unit_quaternion(values[k]), [(u, posed[at][bone][path])]))
+                else:
+                    off = max(max(abs(m - (x + (y - x) * u)) for x, y, m in zip(values[k - 1], values[k], posed[at][bone][path]))
+                              for at, k, u in where) * (unit if path == "translation" else 1.0)
+                if off <= (SUBFRAME_DEGREES / 25.0 if path == "rotation" else SUBFRAME_METRES / 10.0 if path == "translation"
+                           else SUBFRAME_SCALE / 10.0):
+                    continue
+                if new_input is None:
+                    new_input = append(seconds, "SCALAR", bounds=True)
+                at_key = dict(zip(key_frames, values))
+                dense = [posed[f][bone][path] if f in posed and f not in checks else at_key[f] if f in at_key
+                         else interpolate(path, key_frames, values, f) for f in frames]
+                output = append(dense, "VEC4" if path == "rotation" else "VEC3")
+                animation["samplers"].append({"input": new_input, "output": output, "interpolation": "LINEAR"})
+                channel["sampler"] = len(animation["samplers"]) - 1
+                moved += 1
+            if curves_left[0] > result["remaining"][0]:
+                result["remaining"] = (curves_left[0], name, curves_left[1], curves_left[2])
+            if not moved:
+                continue
+            used = sorted({channel["sampler"] for channel in animation["channels"]})
+            index = {old: new for new, old in enumerate(used)}
+            animation["samplers"] = [animation["samplers"][old] for old in used]
+            for channel in animation["channels"]:
+                channel["sampler"] = index[channel["sampler"]]
+            result["actions"][name] = len(frames)
+            result["channels"] += moved
+    finally:
+        scene.frame_set(frame, subframe=subframe)
+    if not result["actions"]:
+        return result
+    binary = _compact(document, binary)
+    document["buffers"][0]["byteLength"] = len(binary) + (4 - len(binary) % 4) % 4
+    _write_glb(out, document, binary)
+    result["bytes"] = os.path.getsize(out) - before_bytes
+    return result
+
+
+_COMPACT_SAFE = ("KHR_node_visibility", "KHR_lights_punctual", "KHR_texture_transform", "KHR_animation_pointer",
+                 "KHR_mesh_quantization") + STD_EXTENSIONS
+
+
+def _compact(document, binary):
+    """Drop the accessors and buffer views nothing uses any more (the samples a denser channel replaced) and
+    pack the rest, each view's bytes as they were, in their order. Left as it is when the file uses an
+    extension this does not know the references of."""
+    used_extensions = [e for e in document.get("extensionsUsed", []) if not e.startswith("KHR_materials_") and e not in _COMPACT_SAFE]
+    accessors, views = document.get("accessors", []), document.get("bufferViews", [])
+    if used_extensions or any("sparse" in a for a in accessors) or len(document.get("buffers", [])) != 1:
+        return binary
+    refs = []   # (holder, key) pairs holding an accessor index
+    for mesh in document.get("meshes", []):
+        for primitive in mesh.get("primitives", []):
+            attributes = primitive.get("attributes", {})
+            refs.extend((attributes, key) for key in attributes)
+            if "indices" in primitive:
+                refs.append((primitive, "indices"))
+            for target in primitive.get("targets", []):
+                refs.extend((target, key) for key in target)
+    for skin in document.get("skins", []):
+        if "inverseBindMatrices" in skin:
+            refs.append((skin, "inverseBindMatrices"))
+    for animation in document.get("animations", []):
+        for sampler in animation.get("samplers", []):
+            refs.extend([(sampler, "input"), (sampler, "output")])
+        lengths = ((animation.get("extensions") or {}).get("STD_animation_blending") or {}).get("rotationLengths") or {}
+        refs.extend((lengths, key) for key in lengths)
+    keep = sorted({holder[key] for holder, key in refs})
+    remap = {old: new for new, old in enumerate(keep)}
+    for holder, key in refs:
+        holder[key] = remap[holder[key]]
+    document["accessors"] = accessors = [accessors[old] for old in keep]
+    view_refs = [(a, "bufferView") for a in accessors if "bufferView" in a] + \
+                [(image, "bufferView") for image in document.get("images", []) if "bufferView" in image]
+    kept_views = sorted({holder[key] for holder, key in view_refs})
+    view_map = {old: new for new, old in enumerate(kept_views)}
+    packed = bytearray()
+    new_views = []
+    for old in kept_views:
+        view = dict(views[old])
+        start = view.get("byteOffset", 0)
+        packed.extend(b"\0" * ((4 - len(packed) % 4) % 4))
+        chunk = binary[start:start + view["byteLength"]]
+        view["byteOffset"] = len(packed)
+        packed.extend(chunk)
+        new_views.append(view)
+    for holder, key in view_refs:
+        holder[key] = view_map[holder[key]]
+    document["bufferViews"] = new_views
+    document["buffers"][0]["byteLength"] = len(packed) + (4 - len(packed) % 4) % 4
+    return packed
+
+
+def _subframe_warnings(dense, candidates):
+    """What remains between frames, named (RFC 0007 §5)."""
+    found = list(dense["mismatch"])
+    if dense["actions"]:
+        found.append("between frames: %d actions sampled also off whole frames where a half frame was over %.2f deg "
+                     "(%s keys); the largest half-step difference their curves leave is %.2f deg (%s, %s, frame %.2f), in "
+                     "that bone's own rotation" % (len(dense["actions"]), SUBFRAME_DEGREES,
+                        ", ".join("%s %d" % (name, k) for name, k in sorted(dense["actions"].items())),
+                        dense["remaining"][0], dense["remaining"][1], dense["remaining"][2], dense["remaining"][3] or 0.0))
+    under = [(degrees, action, bone, frame) for (_armature, action), (degrees, metres, bone, frame) in candidates.items()
+             if action not in dense["actions"] and degrees > 0.01]
+    if under:
+        worst = max(under)
+        found.append("between frames, the actions sampled at whole frames: the largest half-frame difference of their "
+                     "curves is %.2f deg (%s, %s, frame %.1f); only keyed curves are measured, so a bone posed by IK or "
+                     "a constraint can differ more" % worst)
+    return found
+
+
+def _subframe_manifest(dense):
+    return {"limitDegrees": SUBFRAME_DEGREES, "limitMetres": SUBFRAME_METRES, "actions": dense["actions"],
+            "channels": dense["channels"], "bytes": dense["bytes"], "framesEvaluated": dense["evaluated"],
+            "remaining": {"degrees": round(dense["remaining"][0], 4), "action": dense["remaining"][1],
+                          "bone": dense["remaining"][2], "frame": dense["remaining"][3]}}
+
+
+def _driven_shape_keys(objects):
+    """Shape keys a driver sets (a corrective shape following a bone): the glTF exporter bakes them into each
+    action as morph weights, so a layer over another action blends those weights, where Blender drives them
+    again from the blended pose. Named, with the keys."""
+    found = []
+    for obj in objects:
+        keys = obj.data.shape_keys if obj.type == "MESH" and obj.data is not None else None
+        drivers = keys.animation_data.drivers if keys is not None and keys.animation_data is not None else []
+        names = sorted({d.data_path.split('"')[1] for d in drivers if d.data_path.startswith("key_blocks[")})
+        if names:
+            found.append("%s's shape keys %s are driven: each action carries them as morph weights as it evaluates "
+                         "them, so a layer over another action blends those weights, not Blender's drivers on the "
+                         "blended pose" % (obj.name, ", ".join(names)))
+    return found
+
+
+def _object_only_armature_actions(objects):
+    """An armature's actions that key no bone: Blender's glTF exporter carries an armature's action only
+    when a bone is keyed (its __is_armature_slot), so the armature object's own moves in them are lost."""
+    found = []
+    for obj in objects:
+        if obj.type != "ARMATURE":
+            continue
+        animation = obj.animation_data
+        used = {animation.action} if animation and animation.action else set()
+        for track in (animation.nla_tracks if animation else []):
+            used.update(strip.action for strip in track.strips if strip.action)
+        lone = []
+        for action in bpy.data.actions:
+            slots = [s for s in action.slots if s.target_id_type == "OBJECT"
+                     and (action in used or s.identifier == "OB" + obj.name)]
+            if not slots:
+                continue
+            curves = _action_curves(action)
+            if curves and not any(_BONE_PATH.match(c.data_path) or c.data_path.startswith("pose.bones[") for c in curves):
+                lone.append(action.name)
+        if lone:
+            found.append("%s's actions %s key the armature object and no bone: the glTF exporter carries an armature's "
+                         "action only with a bone keyed, so they are not exported (key a bone in them too)"
+                         % (obj.name, ", ".join(sorted(lone))))
+    return found
+
+
+def _action_curves(action):
+    from bpy_extras import anim_utils
+    curves = []
+    for slot in action.slots:
+        bag = anim_utils.action_get_channelbag_for_slot(action, slot)
+        if bag is not None:
+            curves.extend(bag.fcurves)
+    return curves
+
+
+def _key_rate(scene):
+    """Blender's exporter writes a key at frame f at time f / (fps * fps_base)."""
+    return round(float(scene.render.fps * (scene.render.fps_base or 1.0)), 6)
+
+
+def _action_slide(action):
+    """The frame an action's clip starts at, when the exporter slid it to zero (its negative frames,
+    SLIDE, the exporter's default); 0 otherwise. A key at action frame f is at clip time
+    (f - slide) / keyRate."""
+    start = float(action.frame_range[0])
+    return start if start < 0 else 0.0
+
+
+def _action_slides():
+    slides = {}
+    for action in bpy.data.actions:
+        slide = _action_slide(action)
+        if slide != 0.0:
+            slides[action.name] = slide
+    return slides
+
+
+def _collection_tree(scene, authoring):
+    """Each collection of the scene's hierarchy with its parents (`extras.collections` on the scene)."""
+    tree = {}
+
+    def walk(collection, parent):
+        for child in collection.children:
+            if child.name == _HOLDER or child.name_full in authoring:
+                continue
+            tree.setdefault(child.name, [])
+            if parent is not None and parent not in tree[child.name]:
+                tree[child.name].append(parent)
+            walk(child, child.name)
+
+    walk(scene.collection, None)
+    return tree
+
+
+def _runtime_names(bone):
+    """The constraints a pose bone's `std.runtime` marks for a script (a name, several separated by commas, or
+    true for all of them), by name."""
+    marked = bone.get("std.runtime")
+    if marked is None or marked is False or marked == 0:
+        return []
+    if isinstance(marked, str):
+        return [n.strip() for n in marked.split(",") if n.strip()]
+    return [c.name for c in bone.constraints]
+
+
+def _runtime_constraints(objects):
+    """The constraints scripts drive, by armature and bone, and the warnings for those that cannot be."""
+    found, warnings = {}, []
+    for obj in objects:
+        if obj.type != "ARMATURE" or obj.pose is None:
+            continue
+        for bone in obj.pose.bones:
+            for name in _runtime_names(bone):
+                constraint = bone.constraints.get(name)
+                if constraint is None:
+                    warnings.append("%s/%s names a runtime constraint %s the bone does not have" % (obj.name, bone.name, name))
+                    continue
+                if constraint.type != "DAMPED_TRACK":
+                    warnings.append("%s/%s's %s is a %s: only a Damped Track runs at runtime, so it is baked into the clips"
+                                    % (obj.name, bone.name, name, constraint.type))
+                    continue
+                found.setdefault((obj.name, bone.name), []).append(constraint)
+    # Read now, before the export mutes them for sampling: the file's own mute state.
+    data = {key: [_constraint_data(c) for c in constraints] for key, constraints in found.items()}
+    return found, data, warnings
+
+
+def _constraint_data(constraint):
+    target = constraint.target
+    data = {"name": constraint.name, "type": constraint.type,
+            "target": target.name if target is not None else None, "subtarget": constraint.subtarget or None,
+            "trackAxis": constraint.track_axis, "headTail": round(float(constraint.head_tail), 6),
+            "influence": round(float(constraint.influence), 6), "mute": bool(constraint.mute)}
+    # Head/Tail places the aim point along the TARGET bone, head to tail: its length goes with it.
+    if target is not None and target.type == "ARMATURE" and constraint.subtarget and target.data.bones.get(constraint.subtarget):
+        data["subtargetLength"] = round(float(target.data.bones[constraint.subtarget].length), 6)
+    return data
+
+
+_BONE_PATH = re.compile(r'^pose\.bones\["((?:[^"\\]|\\.)*)"\]\.(\w+)')
+_BONE_NAME = re.compile(r'^pose\.bones\["((?:[^"\\]|\\.)*)"\]')
+_GLTF_PATH = {"location": "translation", "rotation_quaternion": "rotation", "rotation_euler": "rotation",
+              "rotation_axis_angle": "rotation", "scale": "scale"}
+
+
+def _action_keyed_bones(action):
+    """std's character-layer mask: the authored F-curves' bones, never the baked channels.
+    Read every action slot, and keep constant keys and bone custom-property/constraint curves too."""
+    return sorted({bpy.utils.unescape_identifier(found.group(1))
+                   for curve in _action_curves(action)
+                   if (found := _BONE_NAME.match(curve.data_path)) is not None})
+
+
+def _animation_keyed_bones(animation, bones):
+    """Write std's reserved mask while retaining other animation extras and std members."""
+    extras = dict(animation.extras or {})
+    namespace = extras.get("std")
+    namespace = dict(namespace) if isinstance(namespace, dict) else {}
+    namespace["keyedBones"] = sorted(set(bones))
+    extras["std"] = namespace
+    animation.extras = extras
+
+
+def _keyed_bone_channels(action):
+    """The (bone, glTF path) pairs an action keys."""
+    keyed = set()
+    for curve in _action_curves(action):
+        found = _BONE_PATH.match(curve.data_path)
+        if found and found.group(2) in _GLTF_PATH:
+            keyed.add((found.group(1).replace('\\"', '"'), _GLTF_PATH[found.group(2)]))
+    return keyed
+
+
+def _rest_channels(armature):
+    """Each bone's rest local transform as the exporter writes a joint: translation, rotation
+    (x, y, z, w) and scale, by bone name."""
+    axis = _Y_UP
+    rest = {}
+    for bone in armature.data.bones:
+        local = (bone.parent.matrix_local.inverted_safe() @ bone.matrix_local) if bone.parent is not None else axis @ bone.matrix_local
+        t, r, s = local.decompose()
+        rest[bone.name] = {"translation": (t.x, t.y, t.z), "rotation": (r.x, r.y, r.z, r.w), "scale": (s.x, s.y, s.z)}
+    return rest
+
+
+def _sampled_values(channel):
+    accessor = channel.sampler.output
+    data = getattr(accessor.buffer_view, "data", None)
+    if data is None:
+        return None
+    return struct.unpack("<%df" % (len(data) // 4), bytes(data))
+
+
+def _leaves_rest(path, values, rest):
+    if path == "rotation":
+        for k in range(0, len(values) - 3, 4):
+            dot = abs(values[k] * rest[0] + values[k + 1] * rest[1] + values[k + 2] * rest[2] + values[k + 3] * rest[3])
+            # A turn of more than about 0.1 degrees (float32 keys carry about 1e-7 of noise).
+            if dot < 1.0 - 5e-7:
+                return True
+        return False
+    width = len(rest)
+    for k in range(0, len(values) - width + 1, width):
+        if any(abs(values[k + i] - rest[i]) > 1e-5 for i in range(width)):
+            return True
+    return False
+
+
+def _glb_parts(path):
+    with open(path, "rb") as handle:
+        data = bytearray(handle.read())
+    length = int.from_bytes(data[12:16], "little")
+    document = json.loads(bytes(data[20:20 + length]).decode("utf-8"))
+    binary_length = int.from_bytes(data[20 + length:24 + length], "little")
+    binary = bytearray(data[28 + length:28 + length + binary_length])
+    return data, length, document, binary
+
+
+def _write_glb(path, document, binary):
+    text = json.dumps(document, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+    text += b" " * ((4 - len(text) % 4) % 4)
+    binary = bytes(binary) + b"\0" * ((4 - len(binary) % 4) % 4)
+    total = 12 + 8 + len(text) + 8 + len(binary)
+    with open(path, "wb") as handle:
+        handle.write(b"glTF" + (2).to_bytes(4, "little") + total.to_bytes(4, "little"))
+        handle.write(len(text).to_bytes(4, "little") + b"JSON" + text)
+        handle.write(len(binary).to_bytes(4, "little") + b"BIN\0" + binary)
+
+
+def _keys_bone_rotation(action, bone):
+    """Whether the action keys `bone`'s rotation in any mode (quaternion, Euler, axis-angle)."""
+    prefix = 'pose.bones["%s"].rotation_' % bone.replace('"', '\\"')
+    return any(c.data_path.startswith(prefix) for c in _action_curves(action))
+
+
+def _keyed_quaternion_curves(action, bone):
+    """The action's four rotation_quaternion curves of `bone` (None where one is not keyed), or None."""
+    from bpy_extras import anim_utils
+    bags = [anim_utils.action_get_channelbag_for_slot(action, slot) for slot in action.slots]
+    curves_of = [list(bag.fcurves) for bag in bags if bag is not None]
+    path = 'pose.bones["%s"].rotation_quaternion' % bone.replace('"', '\\"')
+    for curves in curves_of:
+        found = [None, None, None, None]
+        for curve in curves:
+            if curve.data_path == path and 0 <= curve.array_index < 4:
+                found[curve.array_index] = curve
+        if any(c is not None for c in found):
+            return found
+    return None
+
+
+_SHAPE_KEY_PATH = re.compile(r'^key_blocks\["((?:[^"\\]|\\.)*)"\]\.value$')
+
+
+def _blending(document, animation):
+    """An animation's `STD_animation_blending` (made, and listed in the file's `extensionsUsed`, when it has
+    none yet)."""
+    used = document.setdefault("extensionsUsed", [])
+    if "STD_animation_blending" not in used:
+        used.append("STD_animation_blending")
+    return animation.setdefault("extensions", {}).setdefault("STD_animation_blending", {})
+
+
+def _weights_keyed(out):
+    """WHICH MORPH TARGETS AN ACTION KEYS (RFC 0007 §2, `STD_animation_blending.weightsKeyed`). A glTF `weights` channel
+    animates every target of its mesh together, so an action keying one shape key writes the others too (at
+    their value when Blender sampled it). Blender's NLA leaves a shape key the action does not key to the
+    layers below. Where an action keys only some of a mesh's targets, the animation names the ones it keys:
+    `{ "<channel index>": [target index, ...] }`, the indices into the mesh's `extras.targetNames`. Answers how
+    many channels were named."""
+    data, length, document, binary = _glb_parts(out)
+    nodes, meshes = document.get("nodes", []), document.get("meshes", [])
+    named = 0
+    for animation in document.get("animations", []):
+        action = bpy.data.actions.get(animation.get("name", ""))
+        if action is None:
+            continue
+        keyed = set()
+        for curve in _action_curves(action):
+            found = _SHAPE_KEY_PATH.match(curve.data_path)
+            if found:
+                keyed.add(found.group(1).replace('\\"', '"'))
+        if not keyed:
+            continue
+        written = {}
+        for index, channel in enumerate(animation.get("channels", [])):
+            target = channel.get("target", {})
+            if target.get("path") != "weights" or "node" not in target:
+                continue
+            mesh = nodes[target["node"]].get("mesh")
+            names = ((meshes[mesh].get("extras") or {}).get("targetNames") or []) if mesh is not None else []
+            indices = [i for i, name in enumerate(names) if name in keyed]
+            if names and len(indices) < len(names):
+                written[str(index)] = indices
+        if written:
+            _blending(document, animation)["weightsKeyed"] = written
+            named += len(written)
+    if named:
+        _write_glb(out, document, binary)
+    return named
+
+
+def _unique_channels(out):
+    """One channel per target in each animation, as glTF requires: Blender's exporter gathers an action once
+    for every unmuted NLA strip that plays it and merges them, so two tracks playing one action give its
+    animation every channel twice. The first of each is kept (they are the same samples); samplers no channel
+    uses go. Answers how many channels were taken out."""
+    data, length, document, binary = _glb_parts(out)
+    removed = 0
+    for animation in document.get("animations", []):
+        seen, kept = set(), []
+        for channel in animation.get("channels", []):
+            target = channel.get("target", {})
+            key = (target.get("node"), target.get("path"))
+            if key in seen:
+                removed += 1
+                continue
+            seen.add(key)
+            kept.append(channel)
+        if len(kept) == len(animation.get("channels", [])):
+            continue
+        used = sorted({channel["sampler"] for channel in kept})
+        index = {old: new for new, old in enumerate(used)}
+        animation["samplers"] = [animation["samplers"][old] for old in used]
+        for channel in kept:
+            channel["sampler"] = index[channel["sampler"]]
+        animation["channels"] = kept
+    if removed:
+        _write_glb(out, document, binary)
+    return removed
+
+
+def _align_rotation_signs(out, objects, scene):
+    """Write every rotation key of each action in the sign the action keys it (the rest rotation times
+    the keyed basis quaternion): Blender blends quaternion components as keyed. A bone the action does not
+    key, which moves only as Blender evaluates it (an IK chain, a bone not inheriting its parent's
+    rotation), has no keyed sign: its keys are written in the sign nearest its rest, so two actions'
+    poses of it blend the short way. A bone keyed in Euler angles or axis-angle is left as written
+    (named by _euler_bones).
+
+    THE KEYED LENGTH: between keys far apart Blender interpolates a quaternion's four components, whose
+    length falls below 1, and its NLA blends those unnormalised components. The channel stays unit
+    quaternions, as glTF requires; where the keyed length departs from 1, its length at every key is
+    written beside it as a float accessor, named in the animation's `STD_animation_blending.rotationLengths`
+    ({channel index: accessor index}), so a reader that layers actions rebuilds `length * q` as Blender
+    blends it, and one that ignores it still reads valid rotations.
+
+    Answers how many keys were turned, how many shared outputs were split, how many channels carry their
+    lengths and the bytes those add."""
+    armatures = [o for o in objects if o.type == "ARMATURE" and o.pose is not None]
+    if not armatures:
+        return {"turned": 0, "split": 0, "lengths": 0, "lengthBytes": 0}
+    data, length, document, binary = _glb_parts(out)
+    rate = _key_rate(scene)
+    nodes = document.get("nodes", [])
+    accessors, views = document.get("accessors", []), document.get("bufferViews", [])
+
+    def floats(index):
+        accessor = accessors[index]
+        view = views[accessor["bufferView"]]
+        start = view.get("byteOffset", 0) + accessor.get("byteOffset", 0)
+        width = {"SCALAR": 1, "VEC3": 3, "VEC4": 4}[accessor["type"]]
+        return start, list(struct.unpack_from("<%df" % (accessor["count"] * width), binary, start))
+
+    wanted = {}   # output accessor -> list of (sampler dict, per-key flips)
+    by_sampler = {}
+    lengthed = []  # (animation, channel index, the keyed length at each key)
+    for animation in document.get("animations", []):
+        action = bpy.data.actions.get(animation.get("name", ""))
+        if action is None:
+            continue
+        for channel_index, channel in enumerate(animation.get("channels", [])):
+            target = channel.get("target", {})
+            if target.get("path") != "rotation" or "node" not in target:
+                continue
+            bone = nodes[target["node"]].get("name", "")
+            owner = next((a for a in armatures if a.pose.bones.get(bone) is not None), None)
+            if owner is None:
+                continue
+            quaternion = owner.pose.bones[bone].rotation_mode == "QUATERNION"
+            curves = _keyed_quaternion_curves(action, bone) if quaternion else None
+            keyed_curves = curves is not None
+            if curves is None:
+                if _keys_bone_rotation(action, bone):
+                    continue
+                curves = [None, None, None, None]   # evaluated only: the sign nearest rest
+            rest = nodes[target["node"]].get("rotation", [0.0, 0.0, 0.0, 1.0])
+            rest = mathutils.Quaternion((rest[3], rest[0], rest[1], rest[2]))
+            sampler = animation["samplers"][channel["sampler"]]
+            _, times = floats(sampler["input"])
+            _, values = floats(sampler["output"])
+            flips, lengths = [], []
+            slide = _action_slide(action)
+            for k, seconds in enumerate(times):
+                frame = seconds * rate + slide
+                keyed = mathutils.Quaternion([curves[i].evaluate(frame) if curves[i] is not None else (1.0 if i == 0 else 0.0)
+                                              for i in range(4)])
+                lengths.append(keyed.magnitude)
+                reference = rest @ keyed
+                x, y, z, w = values[4 * k:4 * k + 4]
+                flips.append(w * reference.w + x * reference.x + y * reference.y + z * reference.z < 0.0)
+            if keyed_curves and max(abs(value - 1.0) for value in lengths) > 1e-4:
+                lengthed.append((animation, channel_index, lengths))
+            # One sampler serving two channels that need different signs cannot be written for both.
+            known = by_sampler.get(id(sampler))
+            if known is not None and known != flips:
+                raise RuntimeError("the exporter shares one sampler between rotation channels that need different signs "
+                                   "(%s, bone %s): the keyed signs cannot be kept" % (animation.get("name"), bone))
+            if known is None:
+                by_sampler[id(sampler)] = flips
+                wanted.setdefault(sampler["output"], []).append((sampler, flips))
+    turned = split = 0
+    for output, uses in wanted.items():
+        start, values = floats(output)
+        # The first use's signs are written in place; a use that needs other signs gets its own copy.
+        groups = {}
+        for sampler, flips in uses:
+            groups.setdefault(tuple(flips), []).append(sampler)
+        for index, (flips, samplers) in enumerate(sorted(groups.items(), key=lambda item: -len(item[1]))):
+            turned_values = list(values)
+            for k, flip in enumerate(flips):
+                if flip:
+                    for i in range(4):
+                        turned_values[4 * k + i] = -turned_values[4 * k + i]
+            packed = struct.pack("<%df" % len(turned_values), *turned_values)
+            if index == 0:
+                binary[start:start + len(packed)] = packed
+            else:
+                binary.extend(b"\0" * ((4 - len(binary) % 4) % 4))
+                views.append({"buffer": 0, "byteOffset": len(binary), "byteLength": len(packed)})
+                binary.extend(packed)
+                accessors.append(dict(accessors[output], bufferView=len(views) - 1, byteOffset=0))
+                for sampler in samplers:
+                    sampler["output"] = len(accessors) - 1
+                split += 1
+            turned += sum(1 for flip in flips if flip) * len(samplers)
+    added = 0
+    # Each animation's lengths in one buffer view, an accessor per channel into it.
+    by_animation = {}
+    for animation, channel_index, lengths in lengthed:
+        by_animation.setdefault(id(animation), (animation, []))[1].append((channel_index, lengths))
+    for animation, entries in by_animation.values():
+        binary.extend(b"\0" * ((4 - len(binary) % 4) % 4))
+        start = len(binary)
+        views.append({"buffer": 0, "byteOffset": start, "byteLength": 0})
+        named = _blending(document, animation).setdefault("rotationLengths", {})
+        for channel_index, lengths in entries:
+            packed = struct.pack("<%df" % len(lengths), *lengths)
+            accessors.append({"bufferView": len(views) - 1, "byteOffset": len(binary) - start, "componentType": 5126,
+                              "count": len(lengths), "type": "SCALAR"})
+            binary.extend(packed)
+            named[str(channel_index)] = len(accessors) - 1
+            added += len(packed)
+        views[-1]["byteLength"] = len(binary) - start
+    if turned == 0 and not lengthed:
+        return {"turned": 0, "split": 0, "lengths": 0, "lengthBytes": 0}
+    if split == 0 and not lengthed:
+        # Only key signs changed: the file keeps its JSON, its new binary is written in place.
+        data[28 + length:28 + length + len(binary)] = binary
+        with open(out, "wb") as handle:
+            handle.write(bytes(data))
+    else:
+        document["buffers"][0]["byteLength"] = len(binary) + (4 - len(binary) % 4) % 4
+        _write_glb(out, document, binary)
+    return {"turned": turned, "split": split, "lengths": len(lengthed), "lengthBytes": added}
+
+
+def _pose_channels(objects):
+    """Every pose bone's channels of the armatures among `objects`, exactly as the document stores them: its
+    rotation mode, location, quaternion, Euler angles, axis-angle and scale, each as written (an Euler past 180
+    degrees, a quaternion with a negative w or off unit length, a negative scale), for _put_back."""
+    return [(bone, bone.rotation_mode, tuple(bone.location), tuple(bone.rotation_quaternion), tuple(bone.rotation_euler),
+             tuple(bone.rotation_axis_angle), tuple(bone.scale))
+            for obj in objects if obj.type == "ARMATURE" and obj.pose is not None for bone in obj.pose.bones]
+
+
+def _put_back(held):
+    """Write each bone's channels back bit for bit: the mode first (changing it converts the rotation), then
+    every channel as it was. Never through matrix_basis, which wraps angles, flips and normalises quaternions
+    and folds a negative scale into the rotation."""
+    for bone, mode, location, quaternion, euler, axis_angle, scale in held:
+        if bone.rotation_mode != mode:
+            bone.rotation_mode = mode
+        bone.location, bone.rotation_quaternion, bone.rotation_euler = location, quaternion, euler
+        bone.rotation_axis_angle, bone.scale = axis_angle, scale
+
+
+def _clear_pose(objects):
+    """Each pose bone at its rest, in whatever rotation mode it has: what clearing its basis gives, written
+    channel by channel."""
+    for obj in objects:
+        if obj.type == "ARMATURE" and obj.pose is not None:
+            for bone in obj.pose.bones:
+                bone.location, bone.scale = (0.0, 0.0, 0.0), (1.0, 1.0, 1.0)
+                bone.rotation_quaternion, bone.rotation_euler = (1.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0)
+                bone.rotation_axis_angle = (0.0, 0.0, 1.0, 0.0)
+
+
+def _at_rest(objects, run):
+    """Run with every pose bone of the armatures among `objects` at its rest, then put their channels back
+    exactly. Blender's exporter clears the pose when it switches to an action, but not for the action already
+    playing: without this, a bone that action does not key would carry whatever pose the file was saved with
+    (RFC 0007 §1: each action is sampled from the rest pose)."""
+    held = _pose_channels(objects)
+    try:
+        _clear_pose(objects)
+        return run()
+    finally:
+        _put_back(held)
+
+
+_ANIMATION_FIELDS = ("action", "action_slot", "use_nla", "use_tweak_mode", "action_blend_type", "action_influence",
+                     "action_extrapolation", "last_slot_identifier")
+
+
+def _raw(value):
+    """A stored value as it is, comparable bit for bit (repr keeps -0.0 apart from 0.0)."""
+    try:
+        return tuple(value) if not isinstance(value, str) and hasattr(value, "__len__") else value
+    except TypeError:
+        return value
+
+
+def _same(a, b):
+    return repr(a) == repr(b)
+
+
+def _animated_ids(scene):
+    """Every data-block of the scene an action may animate: its objects, their data, shape keys and materials,
+    the scene and its world."""
+    found, seen = [], set()
+
+    def add(idb):
+        if idb is not None and isinstance(idb, bpy.types.ID) and idb.as_pointer() not in seen:
+            seen.add(idb.as_pointer())
+            found.append(idb)
+    add(scene)
+    add(scene.world)
+    for obj in scene.objects:
+        add(obj)
+        data = obj.data
+        add(data)
+        add(getattr(data, "shape_keys", None))
+        for slot in obj.material_slots:
+            add(slot.material)
+    return found
+
+
+def _paths_by_type():
+    """Every property path any action keys (its F-curves' data paths), by the type of data-block its slot animates."""
+    from bpy_extras import anim_utils
+    found = {}
+    for action in bpy.data.actions:
+        for slot in action.slots:
+            bag = anim_utils.action_get_channelbag_for_slot(action, slot)
+            if bag is not None:
+                found.setdefault(slot.target_id_type, set()).update(c.data_path for c in bag.fcurves)
+    return found
+
+
+def _owner(idb, path):
+    """The struct a data path ends on and the property's name there, and whether it is a custom property."""
+    if path.endswith('"]'):
+        head, _, key = path.rpartition('["')
+        return (idb.path_resolve(head) if head else idb), key[:-2], True
+    head, _, name = path.rpartition(".")
+    return (idb.path_resolve(head) if head else idb), name, False
+
+
+def _keyed_values(scene):
+    """The raw value of every property an action keys on the scene's data-blocks, the active action's or not:
+    switching actions writes what each evaluates, and nothing else writes them back."""
+    held = []
+    paths = _paths_by_type()
+    for idb in _animated_ids(scene):
+        for path in paths.get(idb.id_type, ()):
+            try:
+                owner, name, custom = _owner(idb, path)
+                value = owner[name] if custom else getattr(owner, name)
+            except (ValueError, KeyError, AttributeError, TypeError):
+                continue
+            if isinstance(value, (bpy.types.ID, bpy.types.bpy_struct)):
+                continue
+            held.append((owner, name, custom, _raw(value)))
+    return held
+
+
+def _put_back_values(held):
+    for owner, name, custom, value in held:
+        try:
+            now = _raw(owner[name] if custom else getattr(owner, name))
+            if _same(now, value):
+                continue
+            if custom:
+                owner[name] = value
+            else:
+                setattr(owner, name, value)
+        except (ValueError, KeyError, AttributeError, TypeError):
+            continue
+
+
+def _kept_document(scene, run):
+    """AN EXPORT NEVER CHANGES THE DOCUMENT. Run, then put back everything an export (Blender's exporter or this
+    script's passes) may touch, exactly as it was, raw:
+    - every object's transform channels (its rotation mode, location, quaternion, Euler, axis-angle, scale and
+      their deltas), never through a matrix;
+    - every armature's pose channels;
+    - every shape key's value;
+    - every property any action keys, the active action's or another's;
+    - the animation data of every data-block that has it (objects, their data, shape keys, materials, the
+      scene, the world): its action and slot, the NLA's flags, each track's mute and solo;
+    - every constraint's mute, and the scene's frame.
+    Only what differs is written back, and the scene is evaluated again at its own frame."""
+    objects = list(scene.objects)
+    pose = _pose_channels(objects)
+    transforms = [(obj, obj.rotation_mode, [(name, _raw(getattr(obj, name))) for name in _OBJECT_CHANNELS]) for obj in objects]
+    shapes = [(block, _raw(block.value)) for idb in _animated_ids(scene) if isinstance(idb, bpy.types.Key)
+              for block in idb.key_blocks]
+    keyed = _keyed_values(scene)
+    animation = []
+    for idb in _animated_ids(scene):
+        data = getattr(idb, "animation_data", None)
+        if data is None:
+            continue
+        fields = {name: getattr(data, name) for name in _ANIMATION_FIELDS}
+        animation.append((data, fields, [(track, track.mute, track.is_solo) for track in data.nla_tracks]))
+    mutes = [(c, c.mute) for obj in objects for c in obj.constraints]
+    mutes += [(c, c.mute) for obj in objects if obj.type == "ARMATURE" and obj.pose is not None
+              for bone in obj.pose.bones for c in bone.constraints]
+    frame, subframe = scene.frame_current, scene.frame_subframe
+    try:
+        return run()
+    finally:
+        for constraint, mute in mutes:
+            if constraint.mute != mute:
+                constraint.mute = mute
+        for data, fields, tracks in animation:
+            tweak = fields.pop("use_tweak_mode")
+            if data.use_tweak_mode and not tweak:
+                data.use_tweak_mode = False
+            for name in ("action", "action_slot", "last_slot_identifier", "use_nla", "action_blend_type",
+                         "action_influence", "action_extrapolation"):
+                if getattr(data, name) != fields[name] and not data.is_property_readonly(name):
+                    try:
+                        setattr(data, name, fields[name])
+                    except (AttributeError, TypeError, RuntimeError):  # (a slot the restored action does not hold)
+                        pass
+            for track, mute, solo in tracks:
+                if track.mute != mute:
+                    track.mute = mute
+                if track.is_solo != solo:
+                    track.is_solo = solo
+            if tweak and not data.use_tweak_mode:
+                try:
+                    data.use_tweak_mode = True
+                except Exception:  # noqa: BLE001 (no strip to tweak any more)
+                    pass
+        _put_back(pose)
+        for obj, mode, channels in transforms:
+            if obj.rotation_mode != mode:
+                obj.rotation_mode = mode
+            for name, value in channels:
+                if not _same(_raw(getattr(obj, name)), value):
+                    setattr(obj, name, value)
+        for block, value in shapes:
+            if not _same(_raw(block.value), value):
+                block.value = value
+        _put_back_values(keyed)
+        # Evaluated again at its own frame, so the poses the document holds (and saves) are its own again.
+        scene.frame_set(frame, subframe=subframe)
+
+
+def _muted(runtime, run):
+    """Run with the runtime constraints muted, so the sampled clips do not bake them."""
+    held = [(c, c.mute) for constraints in runtime.values() for c in constraints]
+    try:
+        for constraint, _ in held:
+            constraint.mute = True
+        return run()
+    finally:
+        for constraint, was in held:
+            constraint.mute = was
+
+
+def _display_key(scene):
+    """What the display LUT depends on: the view transform, look, display device and curve, and the LUT's
+    own format. Two scenes with the same key share one file."""
+    view, display = scene.view_settings, scene.display_settings
+    curve = []
+    if view.use_curve_mapping:
+        mapping = view.curve_mapping
+        curve = [[round(p.location[0], 6), round(p.location[1], 6)] for c in mapping.curves for p in c.points]
+    ocio = getattr(bpy.app, "ocio", None)
+    basis = json.dumps({"format": LUT_FORMAT, "size": LUT_SIZE, "domain": LUT_DOMAIN, "view": view.view_transform,
+                        "look": view.look, "device": display.display_device, "curve": curve,
+                        "blender": bpy.app.version_string, "ocio": getattr(ocio, "version_string", None)}, sort_keys=True)
+    return hashlib.sha256(basis.encode("utf-8")).hexdigest()[:16]
+
+
+def _display_dir(out):
+    """`.volter/export/display`, beside the kinds' folders."""
+    return os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(out))), "display")
+
+
+def _display_description(key):
+    lo, hi = LUT_DOMAIN
+    return {"file": "../display/%s.cube" % key, "key": key, "size": LUT_SIZE,
+            "shaper": {"type": "log2-offset", "min": lo, "max": hi},
+            "input": "scene-linear Rec.709", "output": "display-encoded"}
+
+
+def _display_lut_for(scene, out, luts):
+    """The display LUT for this scene's view settings: baked into `.volter/export/display/<key>.cube`
+    only when no file for them exists (`luts`, the keys the caller holds intact, each with its recorded
+    SHA-256, when it holds the project's
+    files; else the folder beside `out`). Answers the baked file (None when it stood) and the
+    description."""
+    key = _display_key(scene)
+    cube = os.path.join(_display_dir(out), key + ".cube")
+    exists = (key in luts) if luts is not None else os.path.isfile(cube)
+    if exists:
+        return None, _display_description(key)
+    _display_lut(scene, cube)
+    return cube, _display_description(key)
+
+
+def _display_lut(scene, cube):
+    """Bake the scene's display transform into a 3D LUT at `cube`.
+
+    The lattice is LUT_SIZE^3 scene-linear Rec.709 colours, 2^(lo + t (hi - lo)) - 2^lo per channel
+    (0 at t = 0), red fastest (the Cube format's order). Blender draws them through the scene's view transform, look and
+    display device with `save_render`, at exposure 0 and gamma 1 (carried as numbers, applied by a
+    host), into a 16-bit PNG read back as raw values. Pure Python, so the editor's Blender needs no
+    numpy. The scene is left as it was."""
+    import array
+    import tempfile
+
+    n, (lo, hi) = LUT_SIZE, LUT_DOMAIN
+    axis = [2.0 ** (lo + (hi - lo) * i / (n - 1)) - 2.0 ** lo for i in range(n)]
+    width, height = n * n, n
+    pixels = array.array("f", bytes(4 * 4 * width * height))
+    at = 0
+    for b in range(n):
+        for g in range(n):
+            for r in range(n):
+                pixels[at], pixels[at + 1], pixels[at + 2], pixels[at + 3] = axis[r], axis[g], axis[b], 1.0
+                at += 4
+    render, view = scene.render, scene.view_settings
+    settings = render.image_settings
+    kept = {"format": settings.file_format, "mode": settings.color_mode, "depth": settings.color_depth,
+            "management": settings.color_management, "dither": render.dither_intensity,
+            "exposure": view.exposure, "gamma": view.gamma}
+    lattice = written = None
+    path = os.path.join(tempfile.gettempdir(), "volter-display-lut-%d.png" % os.getpid())
+    try:
+        settings.file_format, settings.color_mode, settings.color_depth = "PNG", "RGB", "16"
+        settings.color_management = "FOLLOW_SCENE"
+        render.dither_intensity = 0.0
+        view.exposure, view.gamma = 0.0, 1.0
+        lattice = bpy.data.images.new("__volter_display_lut", width, height, float_buffer=True, alpha=False)
+        lattice.colorspace_settings.name = "Linear Rec.709"
+        lattice.pixels.foreach_set(pixels)
+        lattice.save_render(path, scene=scene)
+        written = bpy.data.images.load(path)
+        written.colorspace_settings.name = "Non-Color"
+        shown = array.array("f", bytes(4 * len(written.pixels)))
+        written.pixels.foreach_get(shown)
+    finally:
+        settings.file_format, settings.color_mode, settings.color_depth = kept["format"], kept["mode"], kept["depth"]
+        settings.color_management = kept["management"]
+        render.dither_intensity = kept["dither"]
+        view.exposure, view.gamma = kept["exposure"], kept["gamma"]
+        for image in (lattice, written):
+            if image is not None:
+                bpy.data.images.remove(image)
+        if os.path.exists(path):
+            os.remove(path)
+    channels = len(shown) // (width * height)
+    lines = ["TITLE \"%s %s on %s\"" % (view.view_transform, view.look, scene.display_settings.display_device),
+             "# Input: scene-linear Rec.709 encoded as (log2(x + 2^%g) - %g) / %g per channel; output: display values." % (lo, lo, hi - lo),
+             "LUT_3D_SIZE %d" % n, "DOMAIN_MIN 0 0 0", "DOMAIN_MAX 1 1 1"]
+    for index in range(width * height):
+        base = index * channels
+        lines.append("%.6f %.6f %.6f" % (shown[base], shown[base + 1], shown[base + 2]))
+    os.makedirs(os.path.dirname(cube), exist_ok=True)
+    with open(cube, "w", encoding="utf-8", newline="\n") as handle:
+        handle.write("\n".join(lines) + "\n")
+
+
+def _authoring(obj):
+    return any(c.name in AUTHORING for c in obj.users_collection)
+
+
+def _authoring_collections(scene):
+    found = set()
+
+    def walk(collection, inside):
+        here = inside or collection.name in AUTHORING
+        if here:
+            found.add(collection.name_full)
+        for child in collection.children:
+            walk(child, here)
+
+    walk(scene.collection, False)
+    return found
+
+
+def _fcurves(idblock):
+    data = getattr(idblock, "animation_data", None)
+    if data is None or data.action is None:
+        return []
+    action = data.action
+    from bpy_extras import anim_utils
+    bag = anim_utils.action_get_channelbag_for_slot(action, data.action_slot)
+    return list(bag.fcurves) if bag is not None else []
+
+
+def _manifest_path(out):
+    return os.path.splitext(out)[0] + ".json"
+
+
+def _current(out, blend_sha, version, settings, previous):
+    """The earlier export's manifest when it still stands: the same `.blend`, exporter and settings,
+    and its file intact. `previous` is that manifest and the file's SHA-256 as a caller holding the
+    files reads them (the editor, whose project files are not in Blender's filesystem); without it,
+    both are read beside `out`."""
+    if previous is not None:
+        manifest, file_sha = previous.get("manifest"), previous.get("sha256")
+        if not isinstance(manifest, dict):
+            return None
+    else:
+        path = _manifest_path(out)
+        if not (os.path.isfile(path) and os.path.isfile(out)):
+            return None
+        try:
+            with open(path, "r", encoding="utf-8") as handle:
+                manifest = json.load(handle)
+        except (OSError, ValueError):
+            return None
+        file_sha = _sha256(out)
+    if (manifest.get("format") != FORMAT or manifest.get("blendSha256") != blend_sha
+            or manifest.get("exporter") != version or manifest.get("settings") != settings):
+        return None
+    if manifest.get("sha256") != file_sha:
+        return None
+    return manifest
+
+
+def _lut_sha(out, key, luts):
+    """The display LUT's SHA-256: of its file beside the export, or, when the caller holds the project's files
+    (the editor), as the caller recorded it (`luts`: {key: SHA-256})."""
+    path = os.path.join(_display_dir(out), key + ".cube")
+    if os.path.isfile(path):
+        return _sha256(path)
+    return luts.get(key) if isinstance(luts, dict) else None
+
+
+def _lut_missing(manifest, out, luts):
+    """The display LUT a current export names, when its file is gone (it is baked again alone)."""
+    key = (manifest.get("display") or {}).get("lut")
+    if not key:
+        return None
+    if luts is not None:
+        return None if key in luts else key
+    path = os.path.join(_display_dir(out), key + ".cube")
+    recorded = (manifest.get("display") or {}).get("sha256")
+    # Gone, or not the file this export wrote (damaged): baked again.
+    if not os.path.isfile(path) or (recorded and _sha256(path) != recorded):
+        return key
+    return None
+
+
+def _color_inputs(node):
+    """A colour Mix factor and its two colour inputs for ShaderNodeMix and ShaderNodeMixRGB."""
+    if node.bl_idname == "ShaderNodeMix" and node.data_type == "RGBA":
+        colours = [i for i in node.inputs if i.type == "RGBA" and i.enabled]
+        factor = next((i for i in node.inputs if i.name == "Factor" and i.enabled), None)
+        return (factor, colours[0], colours[1]) if len(colours) == 2 else None
+    if node.bl_idname == "ShaderNodeMixRGB":
+        return node.inputs["Fac"], node.inputs["Color1"], node.inputs["Color2"]
+    return None
+
+
+def _multiply(node):
+    return _color_inputs(node) is not None and node.blend_type == "MULTIPLY"
+
+
+def _from(socket):
+    return socket.links[0].from_node if socket.is_linked else None
+
+
+def _occluded_base(material):
+    """Recover Base Color multiplied by a Color Attribute through a Mix node when the glTF exporter omits that factor. Return the colour or texture, attribute name and multiply strength."""
+    # (the exporter also hands this hook node trees that are no Material, e.g. Blender 5's InlineShaderNodes)
+    tree = getattr(material, "node_tree", None)
+    if tree is None:
+        return None
+    bsdf = next((n for n in tree.nodes if n.type == "BSDF_PRINCIPLED"), None)
+    mix = _from(bsdf.inputs["Base Color"]) if bsdf is not None else None
+    if mix is None or not _multiply(mix):
+        return None
+    strength, first, second = _color_inputs(mix)
+    for colour, other in ((first, second), (second, first)):
+        attribute = _from(colour)
+        if attribute is None or attribute.bl_idname not in ("ShaderNodeVertexColor", "ShaderNodeAttribute"):
+            continue
+        name = attribute.layer_name if attribute.bl_idname == "ShaderNodeVertexColor" else attribute.attribute_name
+        level = float(strength.default_value) if strength is not None and not strength.is_linked else 1.0
+        source = _from(other)
+        if source is None:
+            return list(other.default_value), name, level
+        if source.bl_idname == "ShaderNodeTexImage":
+            return None, name, level
+        if _multiply(source):
+            factor, a, b = _color_inputs(source)
+            if factor is not None and not factor.is_linked and abs(float(factor.default_value) - 1.0) < 1e-6:
+                for texture, constant in ((a, b), (b, a)):
+                    if (_from(texture) is not None and _from(texture).bl_idname == "ShaderNodeTexImage"
+                            and not constant.is_linked):
+                        return list(constant.default_value), name, level
+        return None
+    return None
+
+
+class _Hooks:
+    """The exporter's own extension hooks, for one call."""
+    is_critical = True
+
+    def __init__(self, nodes, scene_extras, visibility, collections=None, runtime=None, scene_extensions=None, volumes=None):
+        self.nodes = nodes                # Blender object name -> {"name": ..., "extras": {...}, "tracks": {...}}
+        self.scene_extras = scene_extras  # what the scene's extras gain (a level's timeline, its key rate)
+        self.scene_extensions = scene_extensions or {}  # the scene's std extensions (display, environment, render)
+        self.volumes = volumes or {}      # Blender object name -> its STD_volume (a bounded volume's domain)
+        self.visibility = visibility      # Blender object name -> render-visible
+        self.collections = collections or {}  # Blender object name -> the collections holding it
+        self.runtime = runtime or {}      # (armature, bone) -> its runtime constraints' data
+        self.extension = _extension_class()
+        self.used_visibility = 0
+        self.kept_moved = {}              # action -> bones kept because they leave rest without a key
+        self.occluded = {}                # material name -> its base colour restored from behind a Color Attribute multiply
+        self.slide_mismatch = []
+        self._rests = {}
+        self._scene_bones = {}
+
+    def _extend(self, owner, name, data):
+        """`data` as the owner's std extension `name` (listed in `extensionsUsed`, never required)."""
+        if owner.extensions is None:
+            owner.extensions = {}
+        owner.extensions[name] = self.extension(name=name, extension=data, required=False)
+
+    def animation_action_hook(self, gltf2_animation, blender_object, action_data, export_settings):
+        # Use the actual action before the add-on merges/renames animations. This also runs for
+        # placement-action sidecars, whose export_extras=False suppresses user properties only.
+        _animation_keyed_bones(gltf2_animation, _action_keyed_bones(action_data.action))
+
+    def gather_gltf_hook(self, active_scene, scenes, animations, export_settings):
+        # SCENE mode has no single action and bypasses animation_action_hook. Its one animation
+        # carries the union of the exported rigs' authored actions, not every baked joint.
+        scene_mode = export_settings.get("gltf_animation_mode") == "SCENE"
+        for animation in animations:
+            namespace = (animation.extras or {}).get("std")
+            if scene_mode or not isinstance(namespace, dict) or "keyedBones" not in namespace:
+                _animation_keyed_bones(animation, self._scene_bones.get(animation.name, ()))
+
+    def gather_node_hook(self, gltf2_node, blender_object, export_settings):
+        if blender_object is None:
+            return
+        name = blender_object.name
+        entry = self.nodes.get(name)
+        if entry is not None:
+            gltf2_node.name = entry["name"]
+            extras = dict(gltf2_node.extras or {})
+            extras.update(entry["extras"])
+            gltf2_node.extras = extras
+            if entry.get("tracks"):
+                self._extend(gltf2_node, "STD_animation_tracks", entry["tracks"])
+        held = self.collections.get(name)
+        if held and entry is None:
+            extras = dict(gltf2_node.extras or {})
+            extras["collections"] = held
+            gltf2_node.extras = extras
+        if getattr(blender_object, "type", None) == "ARMATURE" and entry is None:
+            # ITS CLIP AND ITS NLA (`STD_animation_tracks`): the action the file has the armature play (so a
+            # component shows the pose Blender shows), the frame each clip's time 0 is at, its tracks and settings.
+            tracks = _tracks(blender_object)
+            slides = _action_slides()
+            data = dict(_nla_settings(blender_object))
+            if blender_object.animation_data is not None and blender_object.animation_data.action is not None:
+                data["clip"] = blender_object.animation_data.action.name
+            if slides:
+                data["clipOffsets"] = slides
+            if tracks:
+                data["tracks"] = tracks
+            if data:
+                self._extend(gltf2_node, "STD_animation_tracks", data)
+        flags = {key: _pick(blender_object, "visible_" + name) for key, name in RAY_VISIBILITY}
+        if any(value is False for value in flags.values()):
+            # WHAT THE OBJECT IS SEEN BY in Blender's render (its ray visibility): an object kept out of
+            # shadows (scattered pebbles, flora) must not cast one in a host either.
+            self._extend(gltf2_node, "STD_ray_visibility", {key: value for key, value in flags.items() if value is not None})
+        if name in self.volumes:
+            self._extend(gltf2_node, "STD_volume", self.volumes[name])
+        if getattr(blender_object, "type", None) == "LIGHT":
+            # WHAT KHR_lights_punctual CAN'T SAY of the light: its units, its shadow and softness, and an AREA
+            # light, which glTF has no light for at all (rule G: a host that can draw it gets it).
+            self._extend(gltf2_node, "STD_light", _light(blender_object.data))
+        if self.visibility.get(name, True) is False:
+            if gltf2_node.extensions is None:
+                gltf2_node.extensions = {}
+            gltf2_node.extensions["KHR_node_visibility"] = self.extension(
+                name="KHR_node_visibility", extension={"visible": False}, required=False)
+            self.used_visibility += 1
+
+    def animation_channels_armature_sampled(self, channels, blender_object, blender_action, slot_identifier, cache_key,
+                                            export_settings):
+        # AN ACTION CARRIES WHAT IT MOVES: a bone property stays when the action keys it, or when what
+        # Blender evaluated with this action alone (constraints live) leaves the rest pose; channels on
+        # the armature node itself and morph weights always stay.
+        if blender_action is None or blender_object is None or blender_object.type != "ARMATURE":
+            return
+        keyed = _keyed_bone_channels(blender_action)
+        rest = self._rests.get(blender_object.name)
+        if rest is None:
+            rest = self._rests[blender_object.name] = _rest_channels(blender_object)
+        bones = set(rest)
+        kept = []
+        for channel in channels:
+            target = channel.target
+            node = target.node if target is not None else None
+            name = node.name if node is not None else None
+            if name not in bones or target.path not in ("translation", "rotation", "scale"):
+                kept.append(channel)
+                continue
+            if (name, target.path) in keyed:
+                kept.append(channel)
+                continue
+            values = _sampled_values(channel)
+            if values is not None and _leaves_rest(target.path, values, rest[name][target.path]):
+                kept.append(channel)
+                self.kept_moved.setdefault(blender_action.name, set()).add(name)
+        channels[:] = kept
+        # The mapping from clip time to action frame the sign pass and the sampler use: the exporter's.
+        vtree = export_settings.get("vtree")
+        uuid = next((u for u, n in vtree.nodes.items() if getattr(n, "blender_object", None) == blender_object), None) if vtree else None
+        exported = export_settings.get("slide", {}).get(uuid, {}).get(blender_action.name, 0.0) if uuid is not None else 0.0
+        if abs(float(exported) - _action_slide(blender_action)) > 1e-6:
+            self.slide_mismatch.append("%s: the exporter slid it by %s, the artifact says %s" % (blender_action.name, exported, _action_slide(blender_action)))
+
+    def gather_joint_hook(self, gltf2_node, blender_bone, export_settings):
+        constraints = self.runtime.get((blender_bone.id_data.name, blender_bone.name))
+        if constraints:
+            extras = dict(gltf2_node.extras or {})
+            extras["constraints"] = constraints
+            gltf2_node.extras = extras
+
+    def gather_material_hook(self, gltf2_material, blender_material, export_settings):
+        # WHICH FACES CAST SHADOWS (RFC 0007 §2, `STD_material_shadow`): both, unless the material culls its back
+        # faces for shadows; then only the front.
+        if isinstance(blender_material, bpy.types.Material) and blender_material.use_backface_culling_shadow:
+            self._extend(gltf2_material, "STD_material_shadow", {"side": "front"})
+        # Restore a base colour behind a Color Attribute multiply (`_occluded_base`) when the
+        # exporter's factor is absent or white, preserving its alpha for blended materials.
+        occluded = _occluded_base(blender_material)
+        pbr = gltf2_material.pbr_metallic_roughness
+        sent = None if pbr is None else pbr.base_color_factor
+        if (occluded is not None and occluded[0] is not None and pbr is not None
+                and (sent is None or [float(v) for v in sent[:3]] == [1.0, 1.0, 1.0])):
+            factor = [float(v) for v in occluded[0]][:3] + [float(sent[3]) if sent is not None and len(sent) > 3 else 1.0]
+            if factor != [float(v) for v in (sent or [1.0, 1.0, 1.0, 1.0])]:
+                pbr.base_color_factor = factor
+                self.occluded[getattr(blender_material, "name", gltf2_material.name)] = {"factor": [round(v, 6) for v in factor],
+                                                        "attribute": occluded[1], "strength": occluded[2]}
+
+    def gather_scene_hook(self, gltf2_scene, blender_scene, export_settings):
+        if export_settings.get("gltf_animation_mode") == "SCENE":
+            # Capture this scene while its filtered tree is current: the final glTF hook runs
+            # after all scenes, when vtree describes only the last one.
+            bones = self._scene_bones.setdefault(blender_scene.name, set())
+            tree = export_settings["vtree"]
+            for uuid in tree.get_all_objects():
+                node = tree.nodes[uuid]
+                obj = node.blender_object
+                # A removed armature object still exports its joints. Filtered-out rigs with
+                # no exported joints remain in the virtual tree too; they contribute no mask.
+                if obj is not None and obj.type == "ARMATURE" and (node.node is not None or node.bones):
+                    for action, _strip in _scene_actions(obj):
+                        bones.update(_action_keyed_bones(action))
+        for name, data in self.scene_extensions.items():
+            if data is not None:
+                self._extend(gltf2_scene, name, data)
+        if not self.scene_extras:
+            return
+        extras = dict(gltf2_scene.extras or {})
+        extras.update(self.scene_extras)
+        gltf2_scene.extras = extras
+
+
+def _with_hooks(hooks, run):
+    module = types.ModuleType(_HOOK_MODULE)
+    module.glTF2ExportUserExtension = lambda: hooks
+    sys.modules[_HOOK_MODULE] = module
+    addons = bpy.context.preferences.addons
+    entry = addons.new()
+    entry.module = _HOOK_MODULE
+    try:
+        return run()
+    finally:
+        try:
+            addons.remove(entry)
+        finally:
+            sys.modules.pop(_HOOK_MODULE, None)
+
+
+def _export_set(scene, view_layer, objects, run):
+    """Export exactly `objects` (and nothing that is not in the view layer), through a temporary
+    collection made the active one, then take the collection away again."""
+    holder = bpy.data.collections.new(_HOLDER)
+    scene.collection.children.link(holder)
+    previous = view_layer.active_layer_collection
+    try:
+        for obj in objects:
+            if holder.objects.get(obj.name) is None:
+                holder.objects.link(obj)
+        layer = view_layer.layer_collection.children.get(holder.name)
+        if layer is None:
+            raise RuntimeError("The export collection did not join the view layer.")
+        view_layer.active_layer_collection = layer
+        return run()
+    finally:
+        try:
+            view_layer.active_layer_collection = previous
+        finally:
+            scene.collection.children.unlink(holder)
+            bpy.data.collections.remove(holder)
+
+
+class _Steps:
+    """Where an export's time goes, step by step (in its answer and the runner's line, never in the
+    manifest, which carries no time)."""
+
+    def __init__(self):
+        self.ms = {}
+
+    def run(self, name, fn):
+        started = time.perf_counter()
+        try:
+            return fn()
+        finally:
+            self.ms[name] = self.ms.get(name, 0) + round((time.perf_counter() - started) * 1000)
+
+
+def _gltf(out, settings):
+    os.makedirs(os.path.dirname(out) or ".", exist_ok=True)
+    export = lambda: bpy.ops.export_scene.gltf(filepath=out, use_active_collection=True,
+                                               use_active_collection_with_nested=False, **settings)
+    if settings.get("export_animation_mode") != "SCENE":
+        result = export()
+    elif tuple(getattr(_gltf_addon(), "bl_info", {}).get("version", ())) in SAMPLING_READ_FROM:
+        result = _sampling_what_moves(export)
+    else:
+        print("gltf_export: the glTF add-on %s is not one whose scene bake _sampling_what_moves was read against (%s): "
+              "every object is baked, as the add-on does" % (getattr(_gltf_addon(), "bl_info", {}).get("version"),
+                                                             ", ".join(".".join(map(str, v)) for v in SAMPLING_READ_FROM)), file=sys.stderr)
+        result = export()
+    if "FINISHED" not in result:
+        raise RuntimeError("Blender's glTF exporter did not finish: %s" % sorted(result))
+
+
+def _holds_still(obj, seen=None):
+    """Whether an object's transform stays as it is over the timeline, relative to the exported node above it: it,
+    and every object above it, holds still by its own account (`_moves`). A parent's motion would leave a child where
+    it is relative to the parent, which is what a glTF node's transform says, but the add-on's bake of the child
+    carries it (and a curve's path moves its children along it), so a child of anything that moves is baked."""
+    seen = set() if seen is None else seen
+    at = obj
+    while at is not None:
+        if at in seen:
+            # (asked already further up this question: a constraint's target cycle, or a parent asked again)
+            return True
+        seen.add(at)
+        if _moves(at, seen):
+            return False
+        at = at.parent
+    return True
+
+
+def _animated(block):
+    """Whether an ID is keyed or driven: an action, an NLA strip or a driver on it."""
+    animation = getattr(block, "animation_data", None) if block is not None else None
+    return animation is not None and (animation.action is not None or len(animation.drivers) > 0
+                                      or any(len(track.strips) > 0 for track in animation.nla_tracks))
+
+
+def _targets(constraint):
+    """The objects a constraint reads: its target, its pole target, an Armature constraint's targets."""
+    found = []
+    for name in ("target", "pole_target"):
+        target = getattr(constraint, name, None)
+        if isinstance(target, bpy.types.Object):
+            found.append(target)
+    for one in getattr(constraint, "targets", ()) or ():
+        target = getattr(one, "target", None)
+        if isinstance(target, bpy.types.Object):
+            found.append(target)
+    return found
+
+
+def _moves(obj, seen):
+    """Whether something of the object's own may move it (or its children) over the timeline:
+    - it is keyed or driven (an action, an NLA strip or a driver on it);
+    - its data is keyed or driven, or its data's shape keys are: a curve's `eval_time` (the path its children
+      follow, which Ctrl+P > Follow Path keys) or its points, a light's or a camera's settings, a mesh's keys;
+    - it is a curve whose path its children follow (`use_path`), which hooks and shape keys change too;
+    - a constraint moves it: one that is on, or one whose target moves (each constraint's targets are asked);
+    - it follows a vertex (which a deforming parent moves), or a simulation (a rigid body).
+    Armatures (their bones) and meshes with shape keys are never counted still. Materials are not asked: their
+    animation is exported, if at all, apart from the objects' bake this step narrows."""
+    if obj.type == "ARMATURE":
+        return True
+    data = obj.data
+    if obj.type == "MESH" and data is not None and data.shape_keys is not None:
+        return True
+    if _animated(obj) or _animated(data) or _animated(getattr(data, "shape_keys", None)):
+        return True
+    if obj.type == "CURVE" and data is not None and data.use_path:
+        return True
+    for constraint in obj.constraints:
+        if constraint.enabled or any(not _holds_still(target, seen) for target in _targets(constraint)):
+            return True
+    if obj.parent is not None and obj.parent_type in ("VERTEX", "VERTEX_3"):
+        return True
+    return obj.rigid_body is not None
+
+
+def _evaluating_what_exports(view_layer, placements, exported, run):
+    """The level's placements out of the view layer while Blender's exporter bakes the scene, where nothing
+    exported needs them: the add-on's own "Disable Viewport for Other Objects, for performance", which it does only
+    in its other modes. Their markers stand in for them in the file and carry their motion (already keyed), so every
+    frame the bake sets evaluates the level without the placement rigs and skins absent from the output. A placement
+    something exported uses (a parent, a constraint's or a driver's target, a modifier's object), or that such a
+    placement uses in turn, stays. Put back as it was after the export."""
+    exported_ids = set(exported)
+    for obj in exported:
+        if obj.data is not None:
+            exported_ids.add(obj.data)
+    members = {}
+    for collection in placements:
+        for obj in collection.all_objects:
+            members.setdefault(obj, collection)
+    users = bpy.data.user_map(subset=set(members))
+    needed = set()
+    grew = True
+    while grew:
+        grew = False
+        for obj in members:
+            if obj not in needed and any(user in exported_ids or user in needed for user in users.get(obj, ())):
+                needed.add(obj)
+                grew = True
+    kept = {members[obj] for obj in needed}
+    excluded = []
+
+    def walk(layer):
+        for child in layer.children:
+            if child.collection in placements:
+                if child.collection not in kept and not child.exclude:
+                    excluded.append(child)
+            else:
+                walk(child)
+    walk(view_layer.layer_collection)
+    for layer in excluded:
+        layer.exclude = True
+    try:
+        return run()
+    finally:
+        for layer in excluded:
+            layer.exclude = False
+
+
+# Apply the scene-bake optimization only to the glTF add-on versions with matching sampling
+# internals. Other versions use the add-on’s complete bake.
+SAMPLING_READ_FROM = ((5, 2, 39), (5, 2, 40))
+
+
+def _sampling_what_moves(run):
+    """Bake only scene objects that may move, including descendants of moving nodes.
+    Wrap the exporter’s gather and cache functions for this call and restore them afterwards.
+    Preserve its sampled values and output bytes."""
+    from io_scene_gltf2.blender.exp.animation import scene_animation
+    from io_scene_gltf2.blender.exp.animation.sampled import sampling_cache
+    from io_scene_gltf2.blender.exp.tree import VExportNode
+    gather, caching = scene_animation.gather_object_sampled_channels, sampling_cache.object_caching
+    known = {}
+
+    def still(uuid, export_settings):
+        """The node and every node above it hold still. (A child of a moving node keeps its place relative to it,
+        but the add-on's bake of it carries the rounding of the parent's motion, which it keeps: such a child is
+        baked as the add-on bakes it, so the file stays the same.)"""
+        if uuid in known:
+            return known[uuid]
+        nodes = export_settings["vtree"].nodes
+        node = nodes[uuid]
+        if node.blender_type == VExportNode.COLLECTION:
+            answer = True
+        elif node.blender_type == VExportNode.BONE or node.blender_object is None:
+            answer = False
+        else:
+            answer = _holds_still(node.blender_object)
+        if answer and node.parent_uuid is not None:
+            answer = still(node.parent_uuid, export_settings)
+        known[uuid] = answer
+        return answer
+
+    def gather_moving(uuid, *rest):
+        if still(uuid, rest[-1]):
+            return None, None
+        return gather(uuid, *rest)
+
+    def caching_moving(data, uuids, *rest):
+        export_settings = rest[-1]
+        return caching(data, [uuid for uuid in uuids if not still(uuid, export_settings)], *rest)
+
+    scene_animation.gather_object_sampled_channels = gather_moving
+    sampling_cache.object_caching = caching_moving
+    try:
+        return run()
+    finally:
+        scene_animation.gather_object_sampled_channels = gather
+        sampling_cache.object_caching = caching
+
+
+def _contents(out):
+    """What the written GLB holds, read from its JSON chunk."""
+    with open(out, "rb") as handle:
+        header = handle.read(20)
+        length = int.from_bytes(header[12:16], "little")
+        document = json.loads(handle.read(length).decode("utf-8"))
+    return {
+        "nodes": len(document.get("nodes", [])),
+        "meshes": len(document.get("meshes", [])),
+        "skins": len(document.get("skins", [])),
+        "animations": [a.get("name", "") for a in document.get("animations", [])],
+        "extensionsUsed": document.get("extensionsUsed", []),
+    }
+
+
+def _finish(kind, out, project, blend_sha, version, settings, extra, started, sidecars, steps):
+    finishing = time.perf_counter()
+    body = {
+        "format": FORMAT,
+        "kind": kind,
+        "blend": _project_relative(bpy.data.filepath, project),
+        "blendSha256": blend_sha,
+        "exporter": version,
+        "settings": settings,
+        "file": os.path.basename(out),
+        "sha256": _sha256(out),
+        "bytes": os.path.getsize(out),
+    }
+    if sidecars:
+        body["sidecars"] = [{"file": os.path.basename(path), "sha256": _sha256(path)} for path in sidecars]
+    body.update(_contents(out))
+    body.update(extra)
+    with open(_manifest_path(out), "w", encoding="utf-8", newline="\n") as handle:
+        json.dump(body, handle, indent=2, sort_keys=False)
+        handle.write("\n")
+    steps.ms["manifest"] = round((time.perf_counter() - finishing) * 1000)
+    return {"current": False, "ms": round((time.perf_counter() - started) * 1000), "manifest": body,
+            "steps": steps.ms,
+            "sidecars": [os.path.abspath(path) for path in sidecars]}
+
+
+def _current_answer(out, current, started, luts):
+    """A current export; its display LUT baked again alone when its file is gone."""
+    missing = _lut_missing(current, out, luts)
+    sidecars = []
+    if missing is not None:
+        cube, description = _display_lut_for(bpy.context.scene, out, luts)
+        if cube is not None and description["key"] == missing:
+            sidecars.append(os.path.abspath(cube))
+    return {"current": True, "ms": round((time.perf_counter() - started) * 1000), "manifest": current, "sidecars": sidecars}
+
+
+def export_component(out, project=None, force=False, previous=None, blend_sha=None, luts=None):
+    started = time.perf_counter()
+    scene, view_layer = bpy.context.scene, bpy.context.view_layer
+    blend_sha = blend_sha or _sha256(bpy.data.filepath)
+    version = exporter_version()
+    settings = dict(COMPONENT_SETTINGS)
+    if not force:
+        current = _current(out, blend_sha, version, settings, previous)
+        if current is not None:
+            return _current_answer(out, current, started, luts)
+    authoring = _authoring_collections(scene)
+    collections = [c.name for c in scene.collection.children if c.name_full not in authoring]
+    hidden = _hidden_collections(scene)
+    objects = [o for o in view_layer.objects if not _authoring(o) and not any(c.name_full in authoring for c in o.users_collection)]
+    visibility = {o.name: _render_visible(o, hidden) for o in objects}
+    warnings = []
+    if len(collections) != 1:
+        warnings.append("a component holds one collection named after it; this file has %d: %s"
+                        % (len(collections), ", ".join(collections) or "none"))
+    warnings.extend(_hidden_over_visible(objects, visibility))
+    warnings.extend(_area_lights(objects, visibility))
+    warnings.extend(_strip_warnings(objects))
+    warnings.extend(_euler_bones(objects))
+    warnings.extend(_object_only_armature_actions(objects))
+    warnings.extend(_evaluated_bones(objects))
+    warnings.extend(_driven_shape_keys(objects))
+    world, world_gaps = _world(scene)
+    warnings.extend(world_gaps)
+    volumes, volume_warnings = _object_volumes(objects, visibility)
+    warnings.extend(volume_warnings)
+    for name in volumes:
+        visibility[name] = False
+    runtime, runtime_data, runtime_warnings = _runtime_constraints(objects)
+    warnings.extend(runtime_warnings)
+    steps = _Steps()
+    candidates = steps.run("subframeMeasure", lambda: _subframe_candidates(objects))
+    cube, lut = steps.run("displayLut", lambda: _display_lut_for(scene, out, luts))
+    hooks = _Hooks({}, {"keyRate": _key_rate(scene), "collections": _collection_tree(scene, authoring)}, visibility,
+                   _node_collections(objects, _collection_ancestors(scene)), runtime_data,
+                   scene_extensions={"STD_display": _display(scene, lut), "STD_environment": world, "STD_render": _render(scene)},
+                   volumes=volumes)
+    steps.run("gltfExporter", lambda: _with_hooks(hooks, lambda: _muted(runtime, lambda: _at_rest(objects, lambda: _export_set(
+        scene, view_layer, objects, lambda: _gltf(out, settings))))))
+    duplicates = steps.run("uniqueChannels", lambda: _unique_channels(out))
+    weights = steps.run("weightsKeyed", lambda: _weights_keyed(out))
+    dense = steps.run("subframeSampling", lambda: _muted(runtime, lambda: _densify_subframes(out, objects, scene, candidates)))
+    warnings.extend(_subframe_warnings(dense, candidates))
+    signs = steps.run("rotationSigns", lambda: _align_rotation_signs(out, objects, scene))
+    warnings.extend("an action's frames are mapped differently from the exporter's: " + one for one in hooks.slide_mismatch)
+    return _finish("component", out, project, blend_sha, version, settings,
+                   {"collections": collections, "hiddenNodes": hooks.used_visibility, "warnings": warnings,
+                    "display": {"lut": lut["key"], "sha256": _lut_sha(out, lut["key"], luts)},
+                    "runtimeConstraints": sum(len(c) for c in runtime.values()), "rotationKeysTurned": signs["turned"],
+                    "rotationOutputsSplit": signs["split"], "duplicateChannelsRemoved": duplicates,
+                    "rotationLengths": {"channels": signs["lengths"], "bytes": signs["lengthBytes"]},
+                    "weightsKeyed": weights,
+                    "subframeSampling": _subframe_manifest(dense),
+                    "movedWithoutKeys": {action: sorted(bones) for action, bones in sorted(hooks.kept_moved.items())}},
+                   started, [cube] if cube else [], steps)
+
+
+def _marker_component(component):
+    """What a marker names (RFC 0007 §2, §4): its component's exported file beside the level's folder
+    (`../components/<stem>.glb`, as assembly resolves it) and its collection; never the .blend."""
+    stem = os.path.splitext(os.path.basename(component["file"]))[0]
+    return {"uri": "../components/%s.glb" % stem, "collection": component["collection"]}
+
+
+def _placement_root(collection):
+    members = set(collection.all_objects)
+    roots = [o for o in collection.all_objects if o.parent is None or o.parent not in members]
+    roots.sort(key=lambda o: (o.type != "ARMATURE", o.name))
+    return roots[0] if roots else None, roots
+
+
+def _tint(root):
+    if "tint" in root.keys():
+        value = root["tint"]
+        try:
+            return [round(float(x), 6) for x in value]
+        except TypeError:
+            return value if isinstance(value, str) else None
+    reference = root.override_library.reference if root.override_library else None
+    if reference is not None and tuple(root.color) != tuple(reference.color):
+        return [round(float(x), 6) for x in root.color]
+    return None
+
+
+def _unsupported_edits(collection):
+    counts = {}
+    for obj in collection.all_objects:
+        library = obj.override_library
+        if library is None:
+            continue
+        for prop in library.properties:
+            path = prop.rna_path
+            # (the placement's NLA is carried: extras.tracks, and its own motion keyed on the marker)
+            if path in CARRIED or path in STRUCTURAL or path.startswith(("modifiers[", "animation_data.nla_tracks",
+                                                                          "animation_data.action_slot")):
+                continue
+            key = path.split("[")[0] if path.startswith("pose.bones") else path
+            key = "pose.bones" if key.startswith("pose.bones") else key
+            counts["%s:%s" % (obj.name, key)] = counts.get("%s:%s" % (obj.name, key), 0) + 1
+    return ["%s (%d)" % (key, n) for key, n in sorted(counts.items())]
+
+
+def _keyed_visibility(obj):
+    keys = []
+    for curve in _fcurves(obj):
+        if curve.data_path == "hide_render":
+            keys.extend([float(p.co[0]), not bool(round(p.co[1]))] for p in curve.keyframe_points)
+    return sorted(keys)
+
+
+def export_level(out, project=None, force=False, previous=None, blend_sha=None, luts=None):
+    started = time.perf_counter()
+    scene, view_layer = bpy.context.scene, bpy.context.view_layer
+    blend_sha = blend_sha or _sha256(bpy.data.filepath)
+    version = exporter_version()
+    settings = dict(LEVEL_SETTINGS)
+    if not force:
+        current = _current(out, blend_sha, version, settings, previous)
+        # (a placement's own actions are beside the level: gone, the level is exported again)
+        if current is not None and (previous is not None or all(
+                os.path.isfile(os.path.join(os.path.dirname(out), entry["file"]))
+                for entry in (current.get("placementActions") or {}).values())):
+            return _current_answer(out, current, started, luts)
+    authoring = _authoring_collections(scene)
+    hidden = _hidden_collections(scene)
+    in_layer = set(view_layer.objects)
+    # THE PLACEMENTS: the outermost override collections in the scene, and the instancers of
+    # linked collections.
+    overrides = []
+
+    def walk(collection, inside):
+        for child in collection.children:
+            if child.name_full in authoring:
+                continue
+            is_override = child.override_library is not None and child.override_library.reference is not None \
+                and child.override_library.reference.library is not None
+            if is_override and not inside:
+                overrides.append(child)
+            walk(child, inside or is_override)
+
+    walk(scene.collection, False)
+    placed = set()
+    for collection in overrides:
+        placed.update(collection.all_objects)
+    instancers = [o for o in view_layer.objects if o.instance_type == "COLLECTION" and o.instance_collection is not None
+                  and o.instance_collection.library is not None and o not in placed and not _authoring(o)]
+    objects = [o for o in view_layer.objects
+               if o not in placed and o.override_library is None and o.library is None and not _authoring(o)
+               and not any(c.name_full in authoring for c in o.users_collection)]
+    markers, nodes, unsupported, warnings = [], {}, [], []
+    ancestors = _collection_ancestors(scene)
+    components = {}
+    made = []
+    moving = []
+    motion = []
+    companions = []
+    companion_results = {}
+    switched = []
+    stranded = sorted(o.name for o in objects if o.parent is not None and o.parent in placed)
+    if stranded:
+        warnings.append("objects parented to a placement stand where they are now, without its motion: " + ", ".join(stranded))
+    try:
+        for index, collection in enumerate(overrides):
+            root, roots = _placement_root(collection)
+            if root is None:
+                warnings.append("override %s holds no object; it has no marker" % collection.name)
+                continue
+            reference = root.override_library.reference if root.override_library else None
+            placement = root.matrix_world.copy()
+            if reference is not None:
+                placement = root.matrix_world @ reference.matrix_world.inverted()
+            for other in roots[1:]:
+                other_ref = other.override_library.reference if other.override_library else None
+                if other_ref is None:
+                    continue
+                expected = placement @ other_ref.matrix_world
+                if any(abs(a - b) > 1e-4 for row_a, row_b in zip(expected, other.matrix_world) for a, b in zip(row_a, row_b)):
+                    unsupported.append({"placement": collection.name, "edit": "%s is moved apart from %s" % (other.name, root.name)})
+            library_collection = collection.override_library.reference
+            component = {"file": _library_file(library_collection.library, project), "collection": library_collection.name}
+            components[(component["file"], component["collection"])] = component
+            tracks = {}
+            action = root.animation_data.action.name if root.animation_data and root.animation_data.action else None
+            visible = any(o.type == "MESH" and _render_visible(o, hidden) for o in collection.all_objects) \
+                and collection.name_full not in hidden
+            extras = {"component": _marker_component(component)}
+            held = _collections_of([collection.name], ancestors)
+            if held:
+                extras["collections"] = held
+            # The placement's active action as Blender plays it, `false` when it has none (an override may
+            # clear the component's: then only its NLA plays). Not null: the glTF writer drops a null, and the
+            # placement would then play its component's clip.
+            if root.type == "ARMATURE":
+                tracks["clip"] = action if action is not None else False
+            # THE PLACEMENT'S OWN NLA, as authored on the override (its tracks over the component's):
+            # it plays on the placed clone in a cutscene (RFC 0007 §3).
+            own = _level_actions(root)
+            if own:
+                extras["actions"] = {"file": _companion(out, collection.name)}
+                companions.append((root, own, os.path.join(os.path.dirname(out), extras["actions"]["file"]), collection.name))
+            placement_tracks = _tracks(root) if root.type == "ARMATURE" else None
+            if placement_tracks and any(t.get("strips") for t in placement_tracks):
+                tracks["tracks"] = placement_tracks
+                tracks.update(_nla_settings(root))
+            tint = _tint(root)
+            if tint is not None:
+                extras["tint"] = tint
+            marker = bpy.data.objects.new("__volter_marker.%d" % index, None)
+            marker.empty_display_type = "PLAIN_AXES"
+            made.append(marker)
+            if root.parent is not None and root.parent not in placed and root.parent in in_layer:
+                marker.parent = root.parent
+            marker.matrix_world = placement
+            nodes[marker.name] = {"name": collection.name, "extras": extras, "tracks": tracks}
+            markers.append({"name": collection.name, "component": component, "action": action, "visible": visible,
+                            "tint": tint, "parent": marker.parent.name if marker.parent else None})
+            for edit in _unsupported_edits(collection):
+                unsupported.append({"placement": collection.name, "edit": edit})
+            if _moves_itself(root):
+                moving.append((marker, root, reference.matrix_world.inverted() if reference is not None else mathutils.Matrix()))
+        for obj in instancers:
+            linked = obj.instance_collection
+            component = {"file": _library_file(linked.library, project), "collection": linked.name}
+            components[(component["file"], component["collection"])] = component
+            if tuple(linked.instance_offset) != (0.0, 0.0, 0.0):
+                unsupported.append({"placement": obj.name, "edit": "the collection's instance offset %s is not carried"
+                                    % tuple(round(v, 4) for v in linked.instance_offset)})
+            extras = {"component": _marker_component(component)}
+            held = _collections_of([c.name for c in obj.users_collection], ancestors)
+            if held:
+                extras["collections"] = held
+            tint = obj["tint"] if "tint" in obj.keys() else None
+            if tint is not None:
+                extras["tint"] = [float(x) for x in tint] if not isinstance(tint, str) else tint
+            nodes[obj.name] = {"name": obj.name, "extras": extras}
+            markers.append({"name": obj.name, "component": component, "action": None,
+                            "visible": _render_visible(obj, hidden), "tint": extras.get("tint"), "parent": obj.parent.name if obj.parent else None})
+            switched.append(obj)
+            obj.instance_type = "NONE"
+        visibility = {o.name: _render_visible(o, hidden) for o in objects}
+        for marker in made:
+            entry = next(m for m in markers if m["name"] == nodes[marker.name]["name"])
+            visibility[marker.name] = entry["visible"]
+        fps = scene.render.fps / (scene.render.fps_base or 1.0)
+        timeline = {
+            "fps": round(fps, 6),
+            "keyRate": _key_rate(scene),
+            "start": scene.frame_start,
+            "end": scene.frame_end,
+            "current": scene.frame_current,
+            "camera": scene.camera.name if scene.camera else None,
+            "markers": [{"name": m.name, "frame": m.frame, "camera": m.camera.name if m.camera else None}
+                        for m in sorted(scene.timeline_markers, key=lambda m: (m.frame, m.name))],
+        }
+        warnings.extend(_hidden_over_visible(objects, visibility))
+        keyed = {o.name: _keyed_visibility(o) for o in objects}
+        keyed = {name: keys for name, keys in keyed.items() if keys}
+        if keyed:
+            timeline["visibility"] = keyed
+        exported = objects + made
+        frame, subframe = scene.frame_current, scene.frame_subframe
+        steps = _Steps()
+        moving_names = sorted(nodes[marker.name]["name"] for marker, _root, _inverse in moving)
+        try:
+            motion = steps.run("placementMotion", lambda: _bake_placement_motion(scene, moving))
+        finally:
+            scene.frame_set(frame, subframe=subframe)
+        # HOW THE LEVEL IS SEEN AND RENDERED: its colour management (without which a renderer cannot
+        # draw its emission and highlights as Blender does: AgX maps an emission of 8 to a pale tint,
+        # where no tone mapping clips it white), its world and its render settings.
+        warnings.extend(_area_lights(objects, visibility))
+        warnings.extend(_strip_warnings(objects + [c for c in placed if c.type == "ARMATURE"]))
+        warnings.extend(_euler_bones(objects))
+        warnings.extend(_object_only_armature_actions(objects))
+        warnings.extend(_evaluated_bones(objects))
+        warnings.extend(_driven_shape_keys(objects))
+        scene_worst = steps.run("subframeMeasure", lambda: _scene_subframe_worst(
+            objects + [root for _marker, root, _inverse in moving], scene))
+        warnings.extend(_scene_subframe_warnings(scene_worst))
+        world, world_gaps = _world(scene)
+        warnings.extend(world_gaps)
+        volumes, volume_warnings = _object_volumes(objects, visibility)
+        warnings.extend(volume_warnings)
+        for name in volumes:
+            visibility[name] = False
+        runtime, runtime_data, runtime_warnings = _runtime_constraints(objects)
+        warnings.extend(runtime_warnings)
+        cube, lut = steps.run("displayLut", lambda: _display_lut_for(scene, out, luts))
+        hooks = _Hooks(nodes, {"timeline": timeline, "keyRate": _key_rate(scene), "collections": _collection_tree(scene, authoring)},
+                       visibility, _node_collections(objects, ancestors), runtime_data,
+                       scene_extensions={"STD_display": _display(scene, lut), "STD_environment": world, "STD_render": _render(scene)},
+                   volumes=volumes)
+        try:
+            steps.run("gltfExporter", lambda: _with_hooks(hooks, lambda: _muted(runtime, lambda: _export_set(
+                scene, view_layer, exported, lambda: _evaluating_what_exports(
+                    view_layer, overrides, exported, lambda: _gltf(out, settings))))))
+            for root, own, path, name in companions:
+                companion = steps.run("placementActions", lambda root=root, own=own, path=path: _export_placement_actions(
+                    scene, view_layer, root, own, path))
+                companion_results[name] = companion
+                warnings.extend("placement %s's own actions: %s" % (name, one) for one in companion["warnings"])
+        finally:
+            scene.frame_set(frame, subframe=subframe)
+    finally:
+        for obj in switched:
+            obj.instance_type = "COLLECTION"
+        for marker in made:
+            bpy.data.objects.remove(marker, do_unlink=True)
+        for action in motion:
+            bpy.data.actions.remove(action)
+    if hooks.occluded:
+        attributes = sorted({(row["attribute"], row["strength"]) for row in hooks.occluded.values()})
+        warnings.append("%d material(s) multiply their base colour by a Color Attribute (%s); their base colour is "
+                        "carried, the multiply is not (glTF draws only COLOR_0, as a factor of 1)" % (
+                            len(hooks.occluded), ", ".join("%r at %g" % pair for pair in attributes)))
+    return _finish("level", out, project, blend_sha, version, settings, {
+        "markers": markers,
+        "components": sorted(components.values(), key=lambda c: (c["file"], c["collection"])),
+        "unsupported": unsupported,
+        "movingPlacements": moving_names,
+        "placementActions": {name: {"file": os.path.basename(path), "actions": sorted(a.name for a in own),
+                                    "subframeSampling": companion_results[name]["subframeSampling"]}
+                             for _root, own, path, name in companions},
+        "hiddenNodes": hooks.used_visibility,
+        # The base colours put back from behind a Color Attribute multiply (`_occluded_base`), by material.
+        "occludedBaseColors": hooks.occluded,
+        "warnings": warnings,
+        "display": {"lut": lut["key"], "sha256": _lut_sha(out, lut["key"], luts)},
+        "runtimeConstraints": sum(len(c) for c in runtime.values()),
+        "sceneBetweenFrames": {"degrees": round(scene_worst[0][0], 4), "degreesAt": list(scene_worst[0][1:]),
+                               "metres": round(scene_worst[1][0], 6), "metresAt": list(scene_worst[1][1:])},
+    }, started, ([cube] if cube else []) + [path for _root, _own, path, _name in companions], steps)
+
+
+def export(kind, out, project=None, force=False, previous=None, blend_sha=None, luts=None):
+    """Export the open `.blend` as a component or a level to `out` (a `.glb`), its manifest beside
+    it, and answer `{current, ms, manifest}`; `current` when the earlier export still stands.
+    `blend_sha` is the `.blend`'s SHA-256 when the caller holds the file (the editor, where Blender
+    reads the document from a stream and keeps no copy); without it the file is read here."""
+    if not bpy.data.filepath:
+        raise RuntimeError("Save the model as a .blend in the project before exporting it.")
+    if kind not in ("component", "level"):
+        raise ValueError("kind is component or level, not %r" % (kind,))
+    run = export_component if kind == "component" else export_level
+    return _kept_document(bpy.context.scene, lambda: run(out, project, force, previous, blend_sha, luts))
+
+
+if __name__ == "__main__" and "--" in sys.argv:
+    arguments = sys.argv[sys.argv.index("--") + 1:]
+    kind, out = arguments[0], os.path.abspath(arguments[1])
+    project = arguments[2] if len(arguments) > 2 and not arguments[2].startswith("--") else None
+    answer = export(kind, out, project, force="--force" in arguments)
+    manifest = answer["manifest"]
+    print("@@GLTF-EXPORT " + json.dumps({"current": answer["current"], "ms": answer["ms"], "steps": answer.get("steps", {}), "file": manifest["file"],
+                                         "bytes": manifest["bytes"], "nodes": manifest["nodes"],
+                                         "animations": len(manifest["animations"]),
+                                         "markers": len(manifest.get("markers", [])),
+                                         "unsupported": len(manifest.get("unsupported", [])),
+                                         "warnings": manifest.get("warnings", [])}))