@funpixel/tools 0.0.0-stage → 0.1.0

package/bench/handlers/audit_clips.py

@@ -0,0 +1,351 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""`audit_clips` — play every clip and measure what it does. Read-only.
+
+`inspect` reads a clip's NAME and curve count; that says a clip exists, not
+that it works. The harness games found the rest by eye, one at a time:
+
+  * a clip that holds one pose — keyed, exported, "animated", and the character
+    stands still (a rig whose Walk is its bind pose, twice);
+  * root motion nobody asked for — the clip walks the character forward and the
+    game moves it forward too, so it runs at double speed and then snaps back;
+  * a planted foot that SLIDES — the feet skate over the ground while the body
+    walks, which is the first thing a player sees.
+
+So each clip that drives the armature is evaluated frame by frame and three
+things are measured, in metres of the model as imported:
+
+  root motion   how far the rig's root travels, start to end, across the ground
+                (and up); under ~5 cm (or 5% of the rig's height) it is in place
+  foot slide    while a foot is on the ground (within a few cm of its lowest
+                point in the clip), how far it travels across the ground in one
+                contact. An IN-PLACE locomotion clip (a treadmill walk) slides by
+                design — the game moves the body — so it is reported, not judged
+  static        every bone within 0.5 degrees and 1 mm of its first frame
+
+Two more numbers a game needs to PLAY a clip rather than just to trust it:
+
+  loop seam     how far the last frame's pose is from the first (the largest
+                bone turn, degrees). A cycle (a clip named idle, walk or run,
+                as `prune_clips` reads names) that does not come back to where
+                it started pops once a loop
+  ground speed  the speed the body must travel for a planted foot to stay put:
+                an in-place walk's treadmill speed (how fast a foot sweeps
+                back while it is the lower one, the median), or a clip's own
+                root travel over its length. Move the character at this speed
+                (or scale the clip's time by speed / ground speed) and the feet
+                do not skate
+
+NOT MEASURED IS -1, NEVER 0 — a rig with no foot bones has no foot slide.
+"""
+import math
+import os
+
+import bpy
+from . import scene
+
+# At most this many samples per clip: a long clip is sampled evenly rather than
+# every frame, so one pathological 10,000-frame action cannot hold the bench.
+MAX_SAMPLES = 240
+MAX_CLIPS = 64
+STATIC_ROTATION_DEG = 0.5
+STATIC_LOCATION_M = 0.001
+FOOT_WORDS = ("foot", "ankle")
+# A cycle whose last frame is this far from its first pops once a loop.
+SEAM_DEG = 5.0
+CYCLE_WORDS = ("idle", "walk", "run")
+
+
+def _turn(m0, m1):
+    """The rotation between two bone matrices, radians, the short way round
+    (a quaternion difference reports 359 degrees for a 1 degree turn)."""
+    a = m0.to_quaternion().rotation_difference(m1.to_quaternion()).angle
+    return min(a, 2.0 * math.pi - a)
+
+
+def _named(name, words):
+    tail = name.split("|")[-1].lower()
+    return any(tail == w or tail.endswith("_" + w) for w in words)
+
+
+def _is_cycle(name):
+    return _named(name, CYCLE_WORDS)
+
+
+def _is_travel(name):
+    return _named(name, ("walk", "run"))
+
+
+def _drives(action, bone_names):
+    return any(
+        'pose.bones["' in fc.data_path and fc.data_path.split('"')[1] in bone_names
+        for fc in action.fcurves
+        if '"' in fc.data_path
+    )
+
+
+def _assign(arm, action):
+    """Make `action` the one clip the armature plays, NLA muted."""
+    ad = arm.animation_data or arm.animation_data_create()
+    for track in ad.nla_tracks:
+        track.mute = True
+    ad.action = action
+    # Blender 4.4+ plays an action through a SLOT; an assignment that picked
+    # none plays nothing, and every clip would read as static.
+    if hasattr(ad, "action_slot") and ad.action_slot is None and len(action.slots):
+        ad.action_slot = action.slots[0]
+
+
+def _frames(start, end):
+    span = max(end - start, 0.0)
+    n = min(MAX_SAMPLES, int(math.floor(span)) + 1)
+    if n <= 1:
+        return [start]
+    return [start + span * i / (n - 1) for i in range(n)]
+
+
+def _set_frame(sc, f):
+    whole = int(math.floor(f))
+    sc.frame_set(whole, subframe=f - whole)
+
+
+def _feet(arm):
+    feet = []
+    for b in arm.pose.bones:
+        n = b.name.lower()
+        if any(w in n for w in FOOT_WORDS) and not n.endswith("_end") and "toe" not in n:
+            feet.append(b)
+    return feet[:4]
+
+
+def _root(arm):
+    """The top-level bone the rest hang from; the first, when there are several."""
+    tops = [b for b in arm.pose.bones if b.parent is None]
+    return tops[0] if tops else None
+
+
+def _rig_height(arm):
+    meshes = scene.mesh_objects()
+    b = scene.world_bounds(meshes) if meshes else None
+    if b is None:
+        pts = [arm.matrix_world @ bone.head_local for bone in arm.data.bones]
+        pts += [arm.matrix_world @ bone.tail_local for bone in arm.data.bones]
+        if not pts:
+            return -1.0
+        return max(p.z for p in pts) - min(p.z for p in pts)
+    return b["max"][2] - b["min"][2]
+
+
+def _stance_speed(track, frames, fps):
+    """How fast a treadmill foot sweeps back while it carries the body: the body's speed.
+
+    The foot runs back and forth along one line. Split its steps by direction; the
+    stance is the direction taken LOWER (the foot on the ground), and its median
+    speed is the ground speed. A contact band would not do: a short-legged rig
+    shuffles with its feet inside any band, and every step would read as contact.
+    """
+    if len(track) < 6:
+        return None
+    xs = [p.x for p in track]
+    ys = [p.y for p in track]
+    dx, dy = max(xs) - min(xs), max(ys) - min(ys)
+    ax = (1.0, 0.0) if dx >= dy else (0.0, 1.0)
+    steps = []
+    for i in range(1, len(track)):
+        dt = (frames[i] - frames[i - 1]) / fps
+        if dt <= 0:
+            continue
+        a, b = track[i - 1], track[i]
+        v = ((b.x - a.x) * ax[0] + (b.y - a.y) * ax[1]) / dt
+        steps.append((v, (a.z + b.z) / 2.0))
+    fwd = [s for s in steps if s[0] > 0]
+    back = [s for s in steps if s[0] < 0]
+    if len(fwd) < 2 or len(back) < 2:
+        return None
+    low = lambda group: sum(z for _, z in group) / len(group)
+    stance = fwd if low(fwd) < low(back) else back
+    speeds = sorted(abs(v) for v, _ in stance)
+    return speeds[len(speeds) // 2]
+
+
+def _flat(v):
+    return math.hypot(v.x, v.y)
+
+
+def _measure(sc, arm, action, height):
+    """Play one clip and measure it. Blender is Z-up: the ground is XY."""
+    _assign(arm, action)
+    start, end = (float(x) for x in action.frame_range)
+    frames = _frames(start, end)
+    root = _root(arm)
+    feet = _feet(arm)
+    bones = list(arm.pose.bones)
+
+    first = None
+    mats = []
+    prev = None
+    # The largest bone turn from one sample to the next, per step: a loop's
+    # seam is only a pop when it is bigger than the clip's own frame-to-frame motion.
+    steps = []
+    max_rot = 0.0
+    max_loc = 0.0
+    root_track = []
+    foot_tracks = [[] for _ in feet]
+    for f in frames:
+        _set_frame(sc, f)
+        mats = [b.matrix.copy() for b in bones]
+        world = arm.matrix_world.copy()
+        if first is None:
+            first = (mats, world)
+        if prev is not None:
+            steps.append(max((_turn(a, b) for a, b in zip(prev, mats)), default=0.0))
+        prev = mats
+        for m0, m in zip(first[0], mats):
+            max_rot = max(max_rot, _turn(m0, m))
+            max_loc = max(max_loc, (m.translation - m0.translation).length)
+        # The object itself may carry the motion (an action keying `location`).
+        max_loc = max(max_loc, (world.translation - first[1].translation).length)
+        if root is not None:
+            root_track.append(world @ root.head)
+        for i, foot in enumerate(feet):
+            foot_tracks[i].append(world @ foot.head)
+
+    unit = max(height, 0.0)
+    static = math.degrees(max_rot) < STATIC_ROTATION_DEG and max_loc < max(
+        STATIC_LOCATION_M, 0.001 * unit
+    )
+
+    root_motion, root_rise, in_place = -1.0, -1.0, True
+    if len(root_track) >= 2:
+        d = root_track[-1] - root_track[0]
+        root_motion, root_rise = _flat(d), d.z
+        in_place = root_motion < max(0.05, 0.05 * unit)
+
+    fps = sc.render.fps / (sc.render.fps_base or 1.0)
+    # A clip named for travel is locomotion whatever its stride: a treadmill
+    # walk's feet may range less than a quarter of a tall rig's height.
+    slide, locomotion = -1.0, _is_travel(action.name)
+    if foot_tracks and len(frames) >= 2:
+        slide = 0.0
+        contact_band = max(0.02, 0.03 * unit)
+        for track in foot_tracks:
+            low = min(p.z for p in track)
+            xs = [p.x for p in track]
+            ys = [p.y for p in track]
+            if math.hypot(max(xs) - min(xs), max(ys) - min(ys)) > 0.25 * unit:
+                locomotion = True
+            span_start = None
+            for i, p in enumerate(track + [None]):
+                if p is not None and p.z <= low + contact_band:
+                    if span_start is None:
+                        span_start = (i, p)
+                    slide = max(slide, _flat(p - span_start[1]))
+                    continue
+                span_start = None
+
+    seconds = (end - start) / fps if fps > 0 else -1.0
+    ground_speed = -1.0
+    if locomotion and not in_place and seconds > 0:
+        ground_speed = root_motion / seconds
+    elif locomotion and fps > 0:
+        speeds = [v for v in (_stance_speed(t, frames, fps) for t in foot_tracks) if v is not None]
+        if speeds:
+            ground_speed = sorted(speeds)[len(speeds) // 2]
+    seam = math.degrees(max((_turn(a, b) for a, b in zip(first[0], mats)), default=0.0))
+    step = math.degrees(sorted(steps)[len(steps) // 2]) if steps else 0.0
+    findings = []
+    if end - start < 1.0:
+        findings.append("has no length: it is one frame")
+    elif static:
+        findings.append(
+            "holds one pose: no bone moves over its %d frames — the character will stand still"
+            % int(round(end - start))
+        )
+    else:
+        slide_limit = max(0.02, 0.02 * unit)
+        judged = not (in_place and locomotion)
+        if slide > slide_limit and judged:
+            findings.append(
+                "a planted foot slides %.0f cm across the ground" % (slide * 100.0)
+            )
+        # A last frame one step short of the first is how most loops are cut;
+        # only a jump well past the clip's own step pops.
+        if _is_cycle(action.name) and seam > max(SEAM_DEG, 2.0 * step):
+            findings.append(
+                "does not loop cleanly: its last frame is %.0f degrees from its first "
+                "(a frame moves about %.0f) — a visible pop every cycle" % (seam, step)
+            )
+    return {
+        "name": action.name,
+        "drives_armature": True,
+        "frame_start": start,
+        "frame_end": end,
+        "seconds": seconds,
+        "loop_seam_deg": seam,
+        "ground_speed_mps": ground_speed,
+        "fcurves": len(action.fcurves),
+        "static": static,
+        "max_rotation_deg": math.degrees(max_rot),
+        "root_motion_m": root_motion,
+        "root_rise_m": root_rise,
+        "in_place": in_place,
+        "locomotion": locomotion,
+        "foot_slide_m": slide,
+        "findings": findings,
+    }
+
+
+def run(args):
+    path = args.get("model_path") or ""
+    if not path or not os.path.isfile(path):
+        raise ValueError("model_path does not exist")
+
+    scene.import_model(path, args.get("format") or "")
+    actions = list(bpy.data.actions)
+    if not actions:
+        raise ValueError("the model carries no animations — there are no clips to audit")
+
+    sc = bpy.context.scene
+    arm = scene.armature_object()
+    bone_names = {b.name for b in arm.data.bones} if arm else set()
+    height = _rig_height(arm) if arm else -1.0
+    fps = sc.render.fps / (sc.render.fps_base or 1.0)
+
+    clips = []
+    for action in actions[:MAX_CLIPS]:
+        if arm is not None and _drives(action, bone_names):
+            clips.append(_measure(sc, arm, action, height))
+            continue
+        start, end = (float(x) for x in action.frame_range)
+        clips.append(
+            {
+                "name": action.name,
+                "drives_armature": False,
+                "frame_start": start,
+                "frame_end": end,
+                "seconds": (end - start) / fps if fps > 0 else -1.0,
+                "fcurves": len(action.fcurves),
+                "static": False,
+                "max_rotation_deg": -1.0,
+                "loop_seam_deg": -1.0,
+                "ground_speed_mps": -1.0,
+                "root_motion_m": -1.0,
+                "root_rise_m": -1.0,
+                "in_place": True,
+                "locomotion": False,
+                "foot_slide_m": -1.0,
+                "findings": (
+                    ["drives nothing on the rig: exported payload that animates no bone"]
+                    if arm is not None
+                    else []
+                ),
+            }
+        )
+
+    return {
+        "fps": fps,
+        "rig_height_m": height,
+        "root_bone": (_root(arm).name if arm and _root(arm) else ""),
+        "foot_bones": [b.name for b in _feet(arm)] if arm else [],
+        "clips": clips,
+        "clips_total": len(actions),
+    }

package/bench/handlers/author_clips.py

@@ -0,0 +1,297 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""`author_clips` — key Idle/Walk/Attack/Death onto a rigged-but-unanimated model.
+
+A port of `rust-hollow/tools/animate-creature.py`, whose opening states the
+problem this verb exists for:
+
+    The model ships a full named skeleton (arms, legs, feet, mouth, eyes) and
+    ZERO clips — "rigged" on an asset site means bones exist, not that anyone
+    posed them. Rather than settle for a static mesh or a whole-body bob, this
+    keys the limbs directly.
+
+TWO SIZE EXPLOSIONS ARE DESIGNED OUT, not warned about. Both are recorded in the
+source script and both produce a file that loads, renders, and is catastrophic:
+
+  1. "Blender's exporter writes a sampler for EVERY bone that has any channel,
+     and the second creature's rig is 300+ bones (every vein is a bone) — keying
+     all of them produced 1.5 GB of animation data for four short clips."
+     → `new_action` resets the whole pose but only KEYS the handful below, and
+       the export selects only the bones actually posed.
+
+  2. "The second model arrives with 65 leftover object-level actions
+     ('Cube.021|PlaneAction' and friends) which the exporter happily writes out
+     — 42 MB of GLB, none of it animating the rig."
+     → every action that is not ours is removed before export.
+
+BONES ARE MATCHED BY NAME PREFIX, NEVER BY INDEX. From the script: "the two
+creatures have different bone counts, and an index-based rig breaks silently on
+the second model by rotating whatever bone happens to sit at that slot." Silent
+is the operative word — an index-matched rig produces a character that animates
+confidently and wrongly.
+
+A MISSING BONE IS SKIPPED, NOT FATAL. Not every rig has a jaw. `key()` returns
+without complaint, and the result REPORTS which bones were found, so the caller
+can see that a clip drove four bones rather than nine instead of discovering it
+in the game.
+"""
+import math
+import os
+
+import bpy
+
+from . import scene
+
+FPS = 24
+
+# What the runtime looks for, in the order a caller most often wants them. The
+# names are the bare verbs the script settled on, so a runtime lookup does not
+# depend on a pack's "AlienArmature|AlienArmature|Alien_Walk" naming.
+DEFAULT_CLIPS = ("idle", "walk", "attack", "death")
+
+# Name PREFIXES, tried in order. Two rigs from the same site disagree about
+# capitalisation and separators, so matching is case-insensitive and takes the
+# first hit — the script's approach, widened with the common alternates.
+BONE_PREFIXES = {
+    "l_arm": ("arm.L_", "arm_L", "upperarm.L", "upper_arm.L", "shoulder.L", "arm.l"),
+    "r_arm": ("arm.R_", "arm_R", "upperarm.R", "upper_arm.R", "shoulder.R", "arm.r"),
+    "l_leg": ("leg.L_", "leg_L", "thigh.L", "upperleg.L", "leg.l"),
+    "r_leg": ("leg.R_", "leg_R", "thigh.R", "upperleg.R", "leg.r"),
+    "l_foot": ("foot.L_", "foot_L", "foot.l"),
+    "r_foot": ("foot.R_", "foot_R", "foot.r"),
+    "hips": ("hips", "pelvis", "Bone_0", "root"),
+    "spine": ("spine", "Bone.002", "Bone.001", "chest", "torso"),
+    "jaw": ("mouth.Bottom", "jaw", "mandible"),
+}
+
+
+def _find(arm, names, prefixes):
+    """First pose bone whose name starts with any prefix. None if absent."""
+    for p in prefixes:
+        for n in names:
+            if n.lower().startswith(p.lower()):
+                return arm.pose.bones[n]
+    return None
+
+
+def _key(bone, frame, rx=0.0, ry=0.0, rz=0.0):
+    """Key a bone's euler rotation. A missing bone is skipped, not fatal."""
+    if bone is None:
+        return
+    bone.rotation_mode = "XYZ"
+    bone.rotation_euler = (rx, ry, rz)
+    bone.keyframe_insert("rotation_euler", frame=frame)
+
+
+def _new_action(arm, name):
+    """Start a clip with the whole pose reset, but nothing keyed yet.
+
+    The reset matters and the NOT-keying matters more: the exporter writes a
+    sampler for every bone carrying any channel, so keying a 300-bone rig to
+    "reset" it is exactly how four short clips became 1.5 GB.
+    """
+    act = bpy.data.actions.new(name)
+    arm.animation_data.action = act
+    for b in arm.pose.bones:
+        b.rotation_mode = "XYZ"
+        b.rotation_euler = (0, 0, 0)
+        b.location = (0, 0, 0)
+    return act
+
+
+def _finish(act, length, loop=True):
+    """Close the loop by copying frame 0 onto the last frame."""
+    if loop:
+        for fc in act.fcurves:
+            first = next((k for k in fc.keyframe_points if k.co.x == 0), None)
+            if first is not None:
+                fc.keyframe_points.insert(length, first.co.y)
+    act.use_frame_range = True
+    act.frame_start, act.frame_end = 0, length
+    act.use_fake_user = True
+
+
+def _idle(arm, b):
+    """Breathing, arms hanging with a slight sway.
+
+    Deliberately small: "this is what the creature does when it has not seen
+    you, and big motion here reads as agitation."
+    """
+    act = _new_action(arm, "idle")
+    length = 72
+    for f, t in ((0, 0.0), (18, 1.0), (36, 0.0), (54, -1.0)):
+        _key(b["spine"], f, rx=0.035 * t)
+        _key(b["l_arm"], f, rz=0.06 * t)
+        _key(b["r_arm"], f, rz=-0.06 * t)
+        _key(b["hips"], f, rx=0.012 * t)
+    _finish(act, length)
+    return act
+
+
+def _walk(arm, b):
+    """A real contralateral gait — left leg forward with RIGHT arm forward.
+
+    The hips counter-rotate and the body dips twice per cycle, once per
+    footfall, "which is what sells weight". A same-side gait reads as a
+    marionette and is the single most common tell of a scripted walk.
+    """
+    act = _new_action(arm, "walk")
+    length = 32
+    swing = 0.55
+    for i, f in enumerate((0, 8, 16, 24)):
+        phase = i * math.pi / 2
+        s = math.sin(phase)
+        _key(b["l_leg"], f, rx=swing * s)
+        _key(b["r_leg"], f, rx=-swing * s)
+        _key(b["l_arm"], f, rx=-swing * 0.7 * s)
+        _key(b["r_arm"], f, rx=swing * 0.7 * s)
+        # Feet plant flat rather than pointing through the swing.
+        _key(b["l_foot"], f, rx=-swing * 0.4 * s)
+        _key(b["r_foot"], f, rx=swing * 0.4 * s)
+        _key(b["hips"], f, ry=0.16 * s, rx=abs(math.cos(phase)) * 0.05)
+        _key(b["spine"], f, ry=-0.12 * s)
+    _finish(act, length)
+    return act
+
+
+def _attack(arm, b):
+    """The telegraph. Whole-body rear-back and lunge, not a wrist flick.
+
+    "It has to be legible at corridor distance" — a player reads the wind-up,
+    not the strike.
+    """
+    act = _new_action(arm, "attack")
+    length = 26
+    _key(b["spine"], 0, rx=0.0)
+    _key(b["spine"], 8, rx=-0.32)   # rear back
+    _key(b["spine"], 14, rx=0.22)   # snap forward
+    _key(b["spine"], 26, rx=0.0)
+    for name, sign in (("l_arm", 1), ("r_arm", -1)):
+        _key(b[name], 0, rx=0.0)
+        _key(b[name], 8, rx=-0.9, rz=0.25 * sign)
+        _key(b[name], 14, rx=0.5, rz=0.1 * sign)
+        _key(b[name], 26, rx=0.0)
+    _key(b["jaw"], 0, rx=0.0)
+    _key(b["jaw"], 8, rx=0.45)
+    _key(b["jaw"], 14, rx=0.6)
+    _key(b["jaw"], 26, rx=0.0)
+    _finish(act, length, loop=False)
+    return act
+
+
+def _death(arm, b):
+    """Buckle at the legs, fold forward, arms go slack.
+
+    Does NOT loop — the runtime clamps it on the last frame and sinks the body
+    from there. A looping death is a character that stands back up.
+    """
+    act = _new_action(arm, "death")
+    length = 34
+    _key(b["spine"], 0, rx=0.0)
+    _key(b["spine"], 10, rx=-0.25)  # a last flinch upright
+    _key(b["spine"], 22, rx=1.15)   # fold
+    _key(b["spine"], 34, rx=1.45)
+    _key(b["hips"], 0, rx=0.0)
+    _key(b["hips"], 22, rx=0.5)
+    _key(b["hips"], 34, rx=0.75)
+    for name in ("l_leg", "r_leg"):
+        _key(b[name], 0, rx=0.0)
+        _key(b[name], 14, rx=0.35)
+        _key(b[name], 34, rx=0.9)
+    for name, sign in (("l_arm", 1), ("r_arm", -1)):
+        _key(b[name], 0, rx=0.0)
+        _key(b[name], 12, rx=-0.5, rz=0.4 * sign)
+        _key(b[name], 34, rx=0.7, rz=0.1 * sign)
+    _key(b["jaw"], 0, rx=0.0)
+    _key(b["jaw"], 12, rx=0.55)
+    _key(b["jaw"], 34, rx=0.2)
+    _finish(act, length, loop=False)
+    return act
+
+
+_AUTHORS = {
+    "idle": _idle,
+    "walk": _walk,
+    "attack": _attack,
+    "death": _death,
+}
+
+
+def run(args):
+    path = args.get("model_path") or ""
+    out_path = args.get("out_path") or ""
+    if not path or not os.path.isfile(path):
+        raise ValueError("model_path does not exist")
+    if not out_path:
+        raise ValueError("out_path is required — this verb writes a new model")
+
+    requested = args.get("clips") or list(DEFAULT_CLIPS)
+    if not isinstance(requested, list):
+        raise ValueError("clips must be a list of names")
+    unknown = [c for c in requested if c not in _AUTHORS]
+    if unknown:
+        # Name the alternatives rather than failing with "not found".
+        raise ValueError(
+            "unknown clip(s) %s; known: %s"
+            % (", ".join(map(str, unknown)), ", ".join(sorted(_AUTHORS)))
+        )
+
+    scene.import_model(path, args.get("format") or "")
+    arm = scene.armature_object()
+    if arm is None:
+        raise ValueError(
+            "the model has no armature — author_clips animates a rig, it does not create one"
+        )
+
+    bpy.context.view_layer.objects.active = arm
+    arm.animation_data_create()
+    bpy.context.scene.render.fps = FPS
+
+    names = [b.name for b in arm.pose.bones]
+    bones = {slot: _find(arm, names, prefixes) for slot, prefixes in BONE_PREFIXES.items()}
+    found = sorted(slot for slot, b in bones.items() if b is not None)
+    if not found:
+        raise ValueError(
+            "no recognisable bones: matched none of %s against %d bone names"
+            % (", ".join(sorted(BONE_PREFIXES)), len(names))
+        )
+
+    authored = []
+    for clip in requested:
+        act = _AUTHORS[clip](arm, bones)
+        authored.append(
+            {
+                "name": act.name,
+                "frame_start": float(act.frame_start),
+                "frame_end": float(act.frame_end),
+                "fcurves": len(act.fcurves),
+            }
+        )
+
+    # ── drop everything that is not ours ────────────────────────────────────
+    # The 42 MB fix: "the second model arrives with 65 leftover object-level
+    # actions which the exporter happily writes out — none of it animating the
+    # rig."
+    ours = {a["name"] for a in authored}
+    dropped = 0
+    for a in list(bpy.data.actions):
+        if a.name not in ours:
+            bpy.data.actions.remove(a)
+            dropped += 1
+
+    # ── select ONLY the bones we posed ──────────────────────────────────────
+    # The 1.5 GB fix: without this the exporter samples the whole armature,
+    # "which on a 300-bone rig is most of the file and moves nothing."
+    posed = {b.name for b in bones.values() if b is not None}
+    for b in arm.pose.bones:
+        b.bone.select = b.name in posed
+
+    scene.export_glb(out_path, optimise_animation=True)
+
+    return {
+        "out_path": out_path,
+        "clips": authored,
+        "bones_posed": sorted(posed),
+        "bones_missing": sorted(slot for slot, b in bones.items() if b is None),
+        "actions_dropped": dropped,
+        "bytes_after": os.path.getsize(out_path),
+    }