unitytk 0.0.15__tar.gz → 0.2.0__tar.gz

{unitytk-0.0.15 → unitytk-0.2.0}/MANIFEST.in

@@ -1,4 +1,4 @@
 include LICENSE
 include docs/README.md
 include pyproject.toml
-recursive-include unitytk *.ui *.gif *.png *.json *.txt *.cs *.hlsl *.shader *.asmdef
+recursive-include unitytk *.ui *.gif *.png *.json *.txt *.cs *.hlsl *.shader *.asmdef *.meta

{unitytk-0.0.15/unitytk.egg-info → unitytk-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitytk
-Version: 0.0.15
+Version: 0.2.0
 Summary: A modular Python toolkit for Unity interaction.
 Author-email: Ryan Simpson <m3trik@outlook.com>
 License: MIT
@@ -13,7 +13,7 @@ Classifier: Operating System :: POSIX :: Linux
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pythontk>=0.12.0
+Requires-Dist: pythontk>=0.13.1
 Dynamic: license-file
 
 [![Tests](https://img.shields.io/badge/Tests-146%20passed-brightgreen.svg)](../test/)

{unitytk-0.0.15 → unitytk-0.2.0}/pyproject.toml

@@ -17,12 +17,17 @@ classifiers = [
 ]
 # The floor is HAND-RATCHETED: unitytk is off-chain from m3trik/push.ps1, so no
 # release cascade bumps it.
-# pythontk 0.12.0, the release this one ships and was tested with. The hard
-# minimum is 0.8.84: UnityFinder.find_editors scans through
-# `AppLauncher.scan_install_dirs` (new in 0.8.72) and needs its pattern order to
-# be a priority (0.8.84), so the Hub's chosen install location wins over the
-# default. Below 0.8.72 the scan fails, is logged, and no editor is found.
-dependencies = ["pythontk>=0.12.0"]
+# pythontk 0.13.1, the release this one ships and was tested with: an FBX
+# deliverable carries the files its records name through
+# `FbxMedia.embed_dependencies` (new in 0.13.1; on 0.13.0 the copy deliverer
+# ships the FBX without its maps), and the suite holds the templates to its
+# `Conformance` cases and its articulation solve's halving step (0.13.0). The hard minimum is 0.11.3:
+# TemplateDeployer builds its deprecation notices at import through
+# `Deprecation.values(..., since=)` (new in 0.11.3). UnityFinder.find_editors
+# needs 0.8.84: it scans through `AppLauncher.scan_install_dirs` (new in
+# 0.8.72) and needs its pattern order to be a priority (0.8.84), so the Hub's
+# chosen install location wins over the default.
+dependencies = ["pythontk>=0.13.1"]
 
 [project.urls]
 Homepage = "https://github.com/m3trik/unitytk"
@@ -37,7 +42,7 @@ where = ["."]
 include = ["unitytk*"]
 
 [tool.setuptools.package-data]
-"*" = ["*.ui", "*.json", "*.txt", "*.md", "*.cs", "*.hlsl", "*.shader", "*.asmdef"]
+"*" = ["*.ui", "*.json", "*.txt", "*.md", "*.cs", "*.hlsl", "*.shader", "*.asmdef", "*.meta"]
 
 [tool.pytest.ini_options]
 testpaths = ["test"]

{unitytk-0.0.15 → unitytk-0.2.0}/test/test_articulated_rig_runtime.py

@@ -58,6 +58,7 @@ import os
 import random
 import re
 import shutil
+import struct
 import subprocess
 import unittest
 import logging
@@ -69,6 +70,7 @@ from base_test import EnvSkip, TempProjects, UnityEnv
 
 import pythontk as ptk
 from unitytk import UnityLauncher, UnityFinder, TemplateDeployer
+from unitytk.template_deployer import UPM_PACKAGE_NAME
 
 
 def _unity_available() -> bool:
@@ -433,9 +435,17 @@ class ControllerScenario:
                 }
             )
         s_end = self.path_states()[-1]
+
+        def cut_short(**field):
+            """The record with one joint's ``t`` or ``q`` cut short."""
+            rig = json.loads(json.dumps(self.rig))
+            rig["joints"][1].update(field)
+            return json.dumps(dict(self.payload, rigs=[rig]))
+
         return {
             "record": json.dumps(self.payload),
             "record_newer": json.dumps(dict(self.payload, version=2)),
+            "records_short": [cut_short(t=[1.0]), cut_short(q=[0.0, 0.0])],
             "root": {
                 "p": list(self.ROOT["p"]),
                 "q": list(self.ROOT["q"]),
@@ -553,6 +563,151 @@ class FixtureScenario:
         return out
 
 
+class BindingScenario:
+    """Hierarchies that put the controller's name binding to the test, with
+    the GLB applier as the reference: pythontk's
+    ``MeshConvert.apply_glb_articulation`` binds a joint to the one node of
+    its name -- exactly, else by namespace-stripped leaf -- and a grab part
+    to the one of its name UNDER its joint, and refuses an ambiguous name.
+    The two deliverables of one export must pose the same parts, so each
+    case is also written as a GLB of the same nodes and bound there
+    (:meth:`glb_binding`).
+
+    A case is ``{"nodes": [[name, parent index or None], ...], "record"}``;
+    ``None`` hangs a node off the model root.
+    """
+
+    class Tree:
+        """A node list under construction."""
+
+        def __init__(self):
+            self.nodes = []
+
+        def add(self, name, parent=None):
+            self.nodes.append([name, parent])
+            return len(self.nodes) - 1
+
+        def rig(self, rig, group, ns=""):
+            """*rig*'s joints under a group node, every name prefixed with
+            *ns*; returns joint index -> node index."""
+            ids = {}
+            parent = self.add(ns + group)
+            for index, joint in enumerate(rig["joints"]):
+                up = parent if joint["parent"] is None else ids[joint["parent"]]
+                ids[index] = self.add(ns + joint["name"], up)
+            return ids
+
+    def __init__(self, doc):
+        arm, tree = doc["rigs"]["arm"], doc["rigs"]["tree"]
+        self.cases = {}
+        # Parts named alike under sibling joints: each grab entry takes the
+        # one under ITS joint.
+        t = self.Tree()
+        ids = t.rig(tree, "tree_RIG")
+        t.add("cap_geo", ids[1])
+        t.add("cap_geo", ids[3])
+        self._case(t, tree, "repeated_part", ("cap_geo", 1), ("cap_geo", 3))
+        # A namespaced export of a rig the record names bare; one part
+        # namespaced on both sides, one only in the record.
+        t = self.Tree()
+        ids = t.rig(arm, "arm_RIG", ns="lamp:")
+        t.add("lamp:head_geo", ids[4])
+        t.add("elbow_geo", ids[1])
+        self._case(t, arm, "namespaced", ("lamp:head_geo", 4), ("rig:elbow_geo", 1))
+        # A joint's exact name twice: the rig is refused, not bound to the first.
+        t = self.Tree()
+        t.rig(arm, "arm_RIG")
+        t.add("elbow", t.add("props"))
+        self._case(t, arm, "duplicate_joint")
+        # Two namespaced instances of the rig: every bare name matches both.
+        t = self.Tree()
+        t.rig(arm, "arm_RIG", ns="A:")
+        t.rig(arm, "arm_RIG", ns="B:")
+        self._case(t, arm, "two_instances")
+        # Two parts of one name under one joint: that part is not grabbable,
+        # the rest of the rig binds.
+        t = self.Tree()
+        ids = t.rig(arm, "arm_RIG")
+        t.add("head_geo", ids[4])
+        t.add("head_geo", ids[4])
+        t.add("elbow_geo", ids[1])
+        self._case(t, arm, "ambiguous_part", ("head_geo", 4), ("elbow_geo", 1))
+        # Namesakes ahead of the real joints -- one differing only by case,
+        # one by namespace -- never steal an exact match.
+        t = self.Tree()
+        t.add("Elbow")
+        t.add("NS:base")
+        t.rig(arm, "arm_RIG")
+        self._case(t, arm, "exact_wins")
+        # Two root joints under different nodes: a rig is solved in ONE space,
+        # its roots' parent -- refused by the page, the GLB applier and here.
+        split = json.loads(json.dumps(arm))
+        split["joints"][1]["parent"] = None
+        t = self.Tree()
+        spaces = (t.add("arm_RIG"), t.add("other_RIG"))
+        ids = {}
+        for index, joint in enumerate(split["joints"]):
+            if joint["parent"] is None:
+                up = spaces[min(index, 1)]
+            else:
+                up = ids[joint["parent"]]
+            ids[index] = t.add(joint["name"], up)
+        self._case(t, split, "split_roots")
+
+    def _case(self, tree, rig, name, *grab):
+        record = dict(rig, grab=[{"node": n, "joint": j} for n, j in grab])
+        self.cases[name] = {
+            "nodes": tree.nodes,
+            "record": json.dumps({"version": 1, "rigs": [record]}),
+        }
+
+    @staticmethod
+    def glb_binding(case, path):
+        """What the GLB applier binds of *case*: ``{"joints": [path, ...],
+        "grabs": {path: joint}}`` (paths below the model root), or None when
+        it refuses the rig. Writes a JSON-only GLB of the case's nodes plus
+        a ``data_export`` carrier to *path* and runs the applier on it."""
+        nodes = [{"name": name} for name, _parent in case["nodes"]]
+        roots = []
+        for index, (_name, parent) in enumerate(case["nodes"]):
+            if parent is None:
+                roots.append(index)
+            else:
+                nodes[parent].setdefault("children", []).append(index)
+        nodes.append(
+            {"name": "data_export", "extras": {"articulation": case["record"]}}
+        )
+        roots.append(len(nodes) - 1)
+        gltf = {
+            "asset": {"version": "2.0"},
+            "scene": 0,
+            "scenes": [{"nodes": roots}],
+            "nodes": nodes,
+        }
+        payload = json.dumps(gltf).encode("utf-8")
+        payload += b" " * (-len(payload) % 4)
+        with open(path, "wb") as fh:
+            fh.write(struct.pack("<4sII", b"glTF", 2, 20 + len(payload)))
+            fh.write(struct.pack("<I4s", len(payload), b"JSON"))
+            fh.write(payload)
+        manifest = ptk.MeshConvert.apply_glb_articulation(path)
+        if not manifest:
+            return None
+
+        def path_of(index):
+            names = []
+            while index is not None:
+                names.append(case["nodes"][index][0])
+                index = case["nodes"][index][1]
+            return "/".join(reversed(names))
+
+        rig = manifest["rigs"][0]
+        return {
+            "joints": [path_of(j["node"]) for j in rig["joints"]],
+            "grabs": {path_of(g["node"]): g["joint"] for g in rig["grab"]},
+        }
+
+
 #: A real DCC export of an articulated rig (an FBX carrying the
 #: ``articulation`` record and a baked clip). Machine-local and never checked
 #: in: unset (or missing) = the live-export tests env-skip.
@@ -784,11 +939,13 @@ public class ArticulatedRigVerifier
         catch (Exception e) { Put("inputs_error", S(e.ToString())); }
         if (inputs != null)
         {
+            Run("guids", () => Guids(L(inputs["guids"])));
             Run("conformance", () => Conformance(O(inputs["doc"])));
             Run("invalid", () => Invalid(L(inputs["invalid"])));
             Run("boundary", () => Boundary(O(inputs["boundary"])));
             Run("hierarchy", () => Hierarchy(O(inputs["doc"]), O(inputs["hierarchy"])));
             Run("controller", () => Controller(O(inputs["controller"])));
+            Run("binding", () => Binding(O(inputs["binding"])));
             Run("animator", () => AnimatorOverride(O(inputs["controller"])));
             Run("importer", () => Importer(O(inputs["importer"])));
             if (inputs.ContainsKey("live")) Run("live", () => Live(O(inputs["live"])));
@@ -806,6 +963,15 @@ public class ArticulatedRigVerifier
         catch (Exception e) { Put(section + "_error", S(e.ToString())); }
     }
 
+    // ---- 0. fixed GUIDs ---------------------------------------------------
+    // The editor's own answer, per deployed asset path (files and folders):
+    // the GUID committed in the bundle's .meta, unless Unity re-minted it.
+    static void Guids(IList<object> paths)
+    {
+        var rows = paths.Select(p => S((string)p) + ": " + S(AssetDatabase.AssetPathToGUID((string)p)));
+        Put("guids", "{" + string.Join(", ", rows) + "}");
+    }
+
     // ---- 1. conformance ---------------------------------------------------
     static void Conformance(IDictionary<string, object> doc)
     {
@@ -1113,9 +1279,86 @@ public class ArticulatedRigVerifier
         var futureCtrl = future.AddComponent<ArticulatedRigController>();
         futureCtrl.record = (string)c["record_newer"];
         Put("ctrl_newer", "{\"resolved\": " + B(futureCtrl.Resolve()) + ", \"rigs\": " + futureCtrl.RigCount + "}");
+
+        // A joint whose t or q is cut short is refused with a warning, never
+        // thrown out of Resolve (the importer calls it: the import would fail).
+        var cutRows = new List<string>();
+        foreach (var raw in L(c["records_short"]))
+        {
+            var cut = new GameObject("CutShortModel");
+            cut.transform.SetParent(root, false);
+            var cutCtrl = cut.AddComponent<ArticulatedRigController>();
+            cutCtrl.record = (string)raw;
+            try { cutRows.Add("{\"resolved\": " + B(cutCtrl.Resolve()) + ", \"rigs\": " + cutCtrl.RigCount + "}"); }
+            catch (Exception thrown) { cutRows.Add("{\"threw\": " + S(thrown.GetType().Name) + "}"); }
+        }
+        Put("ctrl_short", "[" + string.Join(",", cutRows) + "]");
         UnityEngine.Object.DestroyImmediate(root.gameObject);
     }
 
+    // ---- 3a. binding by name (the GLB applier's rules) ----------------------
+    // Each case: a hierarchy of named transforms under a model root ([name,
+    // parent index], null = the root) and a record. Reported: what the
+    // controller bound, as paths below the root (null joints = the rig is not
+    // bound), and the [ArticulatedRig] errors / warnings Resolve logged.
+    static string RelPath(Transform root, Transform t)
+    {
+        if (t == null) return null;
+        var names = new List<string>();
+        for (var p = t; p != null && p != root; p = p.parent) names.Add(p.name);
+        names.Reverse();
+        return string.Join("/", names);
+    }
+
+    static void Binding(IDictionary<string, object> cases)
+    {
+        var rows = new List<string>();
+        foreach (var kv in cases)
+        {
+            var c = O(kv.Value);
+            var root = new GameObject("BindingModel").transform;
+            var made = new List<Transform>();
+            foreach (var raw in L(c["nodes"]))
+            {
+                var n = L(raw);
+                var t = new GameObject((string)n[0]).transform;
+                t.SetParent(n[1] == null ? root : made[(int)D(n[1])], false);
+                made.Add(t);
+            }
+            var errors = new List<string>();
+            var warnings = new List<string>();
+            Application.LogCallback hook = (message, stack, type) =>
+            {
+                if (!message.StartsWith("[ArticulatedRig]")) return;
+                if (type == LogType.Error) errors.Add(message);
+                else if (type == LogType.Warning) warnings.Add(message);
+            };
+            var ctrl = root.gameObject.AddComponent<ArticulatedRigController>();
+            ctrl.record = (string)c["record"];
+            bool resolved;
+            Application.logMessageReceived += hook;
+            try { resolved = ctrl.Resolve(); }
+            finally { Application.logMessageReceived -= hook; }
+            string joints = "null", grabs = "{}";
+            if (ctrl.IsBound(0))
+            {
+                var model = ctrl.GetModel(0);
+                joints = "[" + string.Join(",", Enumerable.Range(0, model.JointCount)
+                    .Select(j => S(RelPath(root, ctrl.GetJoint(0, j))))) + "]";
+                grabs = "{" + string.Join(",", ctrl.GetGrabNodes().Select(t =>
+                {
+                    ctrl.FindGrab(t, out int rig, out int joint, out Transform node);
+                    return S(RelPath(root, t)) + ": " + joint;
+                })) + "}";
+            }
+            rows.Add(S(kv.Key) + ": {\"resolved\": " + B(resolved) + ", \"joints\": " + joints
+                + ", \"grabs\": " + grabs + ", \"errors\": [" + string.Join(",", errors.Select(S))
+                + "], \"warnings\": [" + string.Join(",", warnings.Select(S)) + "]}");
+            UnityEngine.Object.DestroyImmediate(root.gameObject);
+        }
+        Put("binding", "{" + string.Join(",\n", rows) + "}");
+    }
+
     // ---- 3b. the Animator override (edit mode, no play mode) ---------------
     // A frame is driven by hand: Animator.Update(dt) -- which evaluates the
     // controller's clip and writes the transforms in edit mode -- then the
@@ -1407,6 +1650,22 @@ def _compile_errors(log_path: str) -> str:
     return "\n".join(errors[:20])
 
 
+#: The embedded package's root as an AssetDatabase path.
+_PACKAGE_ASSET_ROOT = f"Packages/{UPM_PACKAGE_NAME}"
+
+
+def _bundle_assets():
+    """Every deployed bundle file and folder, as "/"-joined package paths."""
+    names = TemplateDeployer._bundle_names()
+    return list(names) + TemplateDeployer._folders(names)
+
+
+def _committed_meta(name):
+    """Bundle asset *name*'s committed .meta, LF (as the deployer writes it)."""
+    ref = TemplateDeployer._bundle_ref(name + ".meta")
+    return ref.read_bytes().replace(b"\r\n", b"\n")
+
+
 def _run_unity(test, temp_dir, execute_method, prepare, timeout=600):
     """Create a project, let *prepare(project_path)* stage it, run the
     verifier; returns the parsed results (or skips on the license wall)."""
@@ -1466,6 +1725,7 @@ class TestArticulatedRigRuntime(unittest.TestCase):
         cls.doc = ptk.ArticulationConformance.cases(seed=SEED, per_rig=PER_RIG)
         cls.scenario = ControllerScenario(cls.doc)
         cls.fixture = FixtureScenario(cls.doc)
+        cls.binding = BindingScenario(cls.doc)
         rng = random.Random(5)
         cls.boundary = {
             "k": 0.037,
@@ -1552,11 +1812,13 @@ class TestArticulatedRigRuntime(unittest.TestCase):
                 variants[key] = os.path.join(cls.temp_dir, f"fixture_{key}.fbx.txt")
                 cls.fixture.fbx(**kwargs).write(variants[key])
             inputs = {
+                "guids": [f"{_PACKAGE_ASSET_ROOT}/{n}" for n in _bundle_assets()],
                 "doc": cls.doc,
                 "invalid": _invalid_rigs(),
                 "boundary": cls.boundary,
                 "hierarchy": cls.hierarchy,
                 "controller": cls.scenario.inputs(),
+                "binding": cls.binding.cases,
                 "importer": dict(variants, asset=f"Assets/{fixture_name}"),
             }
             live = _live_fbx()
@@ -1586,6 +1848,34 @@ class TestArticulatedRigRuntime(unittest.TestCase):
         cls.unity = unity
         logger.info("Unity %s", unity.get("unity_version"))
 
+    @EnvSkip.unless(_unity_available(), "no Unity editor found")
+    def test_01b_the_editor_reads_the_committed_guids(self):
+        """Fixed GUIDs, proven by the editor rather than by reading files:
+        AssetDatabase names every deployed script, shader, asmdef, the README
+        and every component folder (the XR sub-assembly's included) by the
+        GUID committed in the bundle's .meta -- and the import left those
+        .meta files byte-identical, so a project never churns them."""
+        got = self._section("guids")
+        expected = {
+            f"{_PACKAGE_ASSET_ROOT}/{name}": re.search(
+                rb"^guid: ([0-9a-f]{32})$", _committed_meta(name), re.M
+            )
+            .group(1)
+            .decode()
+            for name in _bundle_assets()
+        }
+        self.assertEqual(got, expected, "Unity named a deployed asset differently")
+        package = TemplateDeployer.package_dir(
+            os.path.join(self.temp_dir, "UnityProject")
+        )
+        rewritten = []
+        for name in _bundle_assets():
+            path = os.path.join(package, *name.split("/")) + ".meta"
+            with open(path, "rb") as fh:
+                if fh.read() != _committed_meta(name):
+                    rewritten.append(name)
+        self.assertEqual(rewritten, [], "Unity rewrote these .meta files on import")
+
     # ---- Step 2: conformance -------------------------------------------------
 
     def _conformance(self):
@@ -1714,7 +2004,7 @@ class TestArticulatedRigRuntime(unittest.TestCase):
 
     @EnvSkip.unless(_unity_available(), "no Unity editor found")
     def test_09_controller_binds_and_measures(self):
-        """Joints bind by leaf name, rig space is the rig group, the unit
+        """Joints bind by name, rig space is the rig group, the unit
         scale is MEASURED (0.37), grab parts get convex colliders, and the
         state reads back off the float transforms."""
         unity = self._results()
@@ -1739,6 +2029,103 @@ class TestArticulatedRigRuntime(unittest.TestCase):
             "a transform outside every grab part is refused",
         )
 
+    # ---- Step 4a: binding by name ----------------------------------------------
+
+    def _binding(self, case):
+        got = self._section("binding")
+        self.assertIn(case, got, "no such binding case in the Unity results")
+        return got[case]
+
+    @EnvSkip.unless(_unity_available(), "no Unity editor found")
+    def test_09b_binding_matches_the_glb_applier(self):
+        """Every hierarchy binds in Unity exactly as pythontk's GLB applier
+        binds a GLB of the same nodes: the same joints, the same grab parts,
+        the same rigs refused -- the two deliverables of one export pose the
+        same parts."""
+        for case, spec in self.binding.cases.items():
+            glb = BindingScenario.glb_binding(
+                spec, os.path.join(self.temp_dir, f"binding_{case}.glb")
+            )
+            got = self._binding(case)
+            self.assertEqual(got["joints"], glb and glb["joints"], f"{case}: joints")
+            self.assertEqual(
+                got["grabs"], glb["grabs"] if glb else {}, f"{case}: grab parts"
+            )
+
+    @EnvSkip.unless(_unity_available(), "no Unity editor found")
+    def test_09c_a_repeated_part_name_binds_under_its_own_joint(self):
+        """Two parts share a name under sibling joints: each grab entry takes
+        the one under its own joint, and both are grabbable."""
+        got = self._binding("repeated_part")
+        self.assertTrue(got["resolved"])
+        self.assertEqual(
+            got["grabs"],
+            {"tree_RIG/hub/left/cap_geo": 1, "tree_RIG/hub/right/tip/cap_geo": 3},
+        )
+        self.assertEqual(got["errors"], [])
+
+    @EnvSkip.unless(_unity_available(), "no Unity editor found")
+    def test_09d_namespaced_names_bind_by_their_leaf(self):
+        """A namespaced export binds a record that names its joints bare, and
+        a grab part namespaced on either side binds by its leaf."""
+        got = self._binding("namespaced")
+        self.assertTrue(got["resolved"])
+        chain = "lamp:arm_RIG/lamp:base/lamp:elbow"
+        self.assertEqual(got["joints"][1], chain)
+        self.assertEqual(
+            got["grabs"],
+            {
+                f"{chain}/lamp:collar/lamp:extend/lamp:head/lamp:head_geo": 4,
+                f"{chain}/elbow_geo": 1,
+            },
+        )
+        self.assertEqual(got["errors"], [])
+
+    @EnvSkip.unless(_unity_available(), "no Unity editor found")
+    def test_09e_an_ambiguous_name_is_refused_with_an_error(self):
+        """A joint name that matches several transforms -- exactly, or by leaf
+        across two namespaced instances -- leaves the rig unbound; two parts
+        of one name under one joint leave that part ungrabbable while the rig
+        binds. Each logs an error naming what was ambiguous, never a guess."""
+        for case, named, bound in (
+            ("duplicate_joint", "joint 'elbow'", False),
+            ("two_instances", "joint 'base'", False),
+            ("ambiguous_part", "grab part 'head_geo'", True),
+        ):
+            got = self._binding(case)
+            self.assertEqual(got["resolved"], bound, case)
+            self.assertTrue(
+                any(named in e and "ambiguous" in e for e in got["errors"]),
+                f"{case}: no error naming {named}: {got['errors']}",
+            )
+        self.assertIsNone(self._binding("duplicate_joint")["joints"])
+        self.assertEqual(
+            self._binding("ambiguous_part")["grabs"],
+            {"arm_RIG/base/elbow/elbow_geo": 1},
+        )
+
+    @EnvSkip.unless(_unity_available(), "no Unity editor found")
+    def test_09g_a_rig_whose_roots_hang_apart_is_refused(self):
+        """Root joints under different nodes leave no one space to solve the
+        rig in: it is not wired, with an error saying why -- as the page and
+        the GLB applier refuse it (test_09b holds the GLB half)."""
+        got = self._binding("split_roots")
+        self.assertFalse(got["resolved"])
+        self.assertTrue(
+            any("different nodes" in e for e in got["errors"]), got["errors"]
+        )
+
+    @EnvSkip.unless(_unity_available(), "no Unity editor found")
+    def test_09f_an_exact_name_wins_over_its_namesakes(self):
+        """Transforms ahead of the joints that differ only by case
+        (``Elbow``) or namespace (``NS:base``) never take an exact match."""
+        got = self._binding("exact_wins")
+        chain = ["arm_RIG/base"]
+        for name in ("elbow", "collar", "extend", "head"):
+            chain.append(f"{chain[-1]}/{name}")
+        self.assertEqual(got["joints"], chain)
+        self.assertEqual(got["errors"], [])
+
     def _solve(self, state, joint, local, target, rotation):
         return self.scenario.model.solve(state, joint, local, target, rotation)
 
@@ -2082,6 +2469,17 @@ class TestArticulatedRigRuntime(unittest.TestCase):
         in): nothing binds."""
         self.assertEqual(self._section("ctrl_newer"), {"resolved": False, "rigs": 0})
 
+    @EnvSkip.unless(_unity_available(), "no Unity editor found")
+    def test_16c_controller_refuses_a_joint_cut_short(self):
+        """A joint whose ``t`` holds fewer than 3 values, or ``q`` fewer than
+        4, is a rig the runtime refuses with a warning: nothing binds, and
+        nothing is thrown out of ``Resolve``, which the importer calls. The
+        reference has no such check (a short ``q`` is an IndexError there), so
+        this is the port's own contract, not a ``_invalid_rigs`` case."""
+        self.assertEqual(
+            self._section("ctrl_short"), [{"resolved": False, "rigs": 0}] * 2
+        )
+
     @EnvSkip.unless(_unity_available(), "no Unity editor found")
     def test_17_xr_adapter_inert_without_xri(self):
         """Without the XR Interaction Toolkit the XR assembly is excluded by