unitytk 0.1.0__tar.gz → 0.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitytk
-Version: 0.1.0
+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.13.0
+Requires-Dist: pythontk>=0.13.1
 Dynamic: license-file
 
 [![Tests](https://img.shields.io/badge/Tests-146%20passed-brightgreen.svg)](../test/)

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

@@ -17,15 +17,17 @@ classifiers = [
 ]
 # The floor is HAND-RATCHETED: unitytk is off-chain from m3trik/push.ps1, so no
 # release cascade bumps it.
-# pythontk 0.13.0, the release this one ships and was tested with: the suite
-# holds the templates to its `Conformance` cases and its articulation solve's
-# halving step (both new in 0.13.0). The hard minimum is 0.11.3:
+# 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.0"]
+dependencies = ["pythontk>=0.13.1"]
 
 [project.urls]
 Homepage = "https://github.com/m3trik/unitytk"

{unitytk-0.1.0 → 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
@@ -562,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.
@@ -799,6 +945,7 @@ public class ArticulatedRigVerifier
             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"])));
@@ -1149,6 +1296,69 @@ public class ArticulatedRigVerifier
         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
@@ -1515,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,
@@ -1607,6 +1818,7 @@ class TestArticulatedRigRuntime(unittest.TestCase):
                 "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()
@@ -1792,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()
@@ -1817,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)
 

{unitytk-0.1.0 → unitytk-0.2.0}/test/test_asset_delivery.py

@@ -1,10 +1,12 @@
 # !/usr/bin/python
 # coding=utf-8
 """Tests for unitytk.CopyToAssetsDeliverer -- copy-to-Assets hand-off Strategy (no DCC)."""
+import json
 import os
+import struct
 import unittest
 
-from pythontk import HandoffRequest, Payload, TempArtifacts
+from pythontk import FbxMedia, HandoffRequest, Payload, TempArtifacts
 from unitytk.asset_delivery import (
     CopyToAssetsDeliverer,
     FileToUnityBridge,
@@ -12,21 +14,80 @@ from unitytk.asset_delivery import (
 
 
 class _Logger:
-    """Minimal logger capturing messages by level."""
+    """Minimal logger capturing messages by level (``%``-args formatted)."""
 
     def __init__(self):
         self.errors = []
         self.warnings = []
         self.infos = []
 
-    def error(self, m):
-        self.errors.append(m)
-
-    def warning(self, m):
-        self.warnings.append(m)
+    def error(self, m, *args):
+        self.errors.append(m % args if args else m)
+
+    def warning(self, m, *args):
+        self.warnings.append(m % args if args else m)
+
+    def info(self, m, *args):
+        self.infos.append(m % args if args else m)
+
+
+def _carrier_fbx(path: str, channels) -> str:
+    """A binary FBX (7700 layout) whose ``data_export`` carrier holds
+    *channels* ``{record key: payload}`` -- what a DCC export hands over."""
+
+    def prop(value):
+        if isinstance(value, int):
+            return b"L" + struct.pack("<q", value)
+        return b"S" + struct.pack("<I", len(value)) + value
+
+    def record(name, props, children, offset):
+        body_props = b"".join(prop(p) for p in props)
+        head = 24 + 1 + len(name)
+        body, at = b"", offset + head + len(body_props)
+        for child in children:
+            chunk = record(*child, at)
+            body, at = body + chunk, at + len(chunk)
+        if children:
+            body += b"\0" * 25
+        end = offset + head + len(body_props) + len(body)
+        return (
+            struct.pack("<QQQB", end, len(props), len(body_props), len(name))
+            + name
+            + body_props
+            + body
+        )
 
-    def info(self, m):
-        self.infos.append(m)
+    p70 = [
+        (b"P", [k.encode(), b"KString", b"", b"U", json.dumps(v).encode()], [])
+        for k, v in channels.items()
+    ]
+    roots = [
+        (
+            b"Objects",
+            [],
+            [
+                (b"Model", [1001, b"Crate\x00\x01Model", b"Mesh"], []),
+                (
+                    b"Model",
+                    [1002, b"data_export\x00\x01Model", b"Null"],
+                    [(b"Properties70", [], p70)],
+                ),
+            ],
+        ),
+        (b"Connections", [], [(b"C", [b"OO", 1001, 0], [])]),
+    ]
+    magic = b"Kaydara FBX Binary  \x00\x1a\x00"
+    body, offset = b"", len(magic) + 4
+    for root in roots:
+        chunk = record(*root, offset)
+        body, offset = body + chunk, offset + len(chunk)
+    at = offset + 25 + 16
+    pad = ((at + 15) & ~15) - at or 16
+    footer = bytes(range(16)) + b"\0" * pad + b"\0" * 4 + struct.pack("<I", 7700)
+    tail = b"\0" * 120 + bytes(16)
+    with open(path, "wb") as fh:
+        fh.write(magic + struct.pack("<I", 7700) + body + b"\0" * 25 + footer + tail)
+    return path
 
 
 class _StubBridge:
@@ -281,6 +342,126 @@ class DeliveryTest(unittest.TestCase):
             )
 
 
+class _HostBridge(_StubBridge):
+    """A DCC bridge: it says where its host keeps the maps the records name
+    (the ``lightmap_search_dirs`` hook every DCC export mixin answers)."""
+
+    def __init__(self, project_path, search_dirs):
+        super().__init__(project_path)
+        self._dirs = search_dirs
+
+    def lightmap_search_dirs(self):
+        return list(self._dirs)
+
+
+class SelfContainedDeliveryTest(unittest.TestCase):
+    """The FBX lands in Assets/ carrying every file its records name, so the
+    Unity importers find them with nothing copied beside it (the user's
+    decision of 2026-10-05: every dependency embedded, zero sidecar files)."""
+
+    RECORDS = {
+        "lightmap_metadata": {
+            "version": 1,
+            "objects": [{"name": "Crate", "map": "Crate_Lightmap.exr", "uvIndex": 1}],
+            "probe": {"map": "Room_Probe.exr", "position": [0, 0, 0], "unit_scale": 0.01},
+        },
+        "shadow_metadata": {
+            "version": 2,
+            "planes": [
+                {
+                    "name": "Crate_shadow",
+                    "texture": "Crate_shadow.png",
+                    "horizon": {"texture": "Crate_horizon.png"},
+                }
+            ],
+        },
+    }
+
+    def setUp(self):
+        store = TempArtifacts("unitytk_delivery_embed", policy="scoped")
+        self.addCleanup(store.cleanup)
+        self.tmp = store.dir_path()
+        self.project = os.path.join(self.tmp, "MyUnityProj")
+        os.makedirs(os.path.join(self.project, "Assets"))
+        self.maps = os.path.join(self.tmp, "sourceimages")
+        os.makedirs(self.maps)
+        self.bytes = {}
+        for name in ("Crate_Lightmap.exr", "Room_Probe.exr", "Crate_shadow.png", "Crate_horizon.png"):
+            self.bytes[name] = name.encode() * 8
+            with open(os.path.join(self.maps, name), "wb") as fh:
+                fh.write(self.bytes[name])
+        self.fbx = _carrier_fbx(os.path.join(self.tmp, "export.fbx"), self.RECORDS)
+        with open(self.fbx, "rb") as fh:
+            self.source = fh.read()
+        self.deliverer = CopyToAssetsDeliverer()
+
+    def _deliver(self, bridge):
+        return self.deliverer.deliver(bridge, _payload(self.fbx, "Crate"), _request({}))
+
+    def test_the_fbx_carries_every_file_its_records_name(self):
+        bridge = _HostBridge(self.project, [self.maps])
+        result = self._deliver(bridge)
+        dest = result["asset"]
+        self.assertEqual(
+            {row["name"]: row["bytes"] for row in FbxMedia.embedded(dest)},
+            {name: len(data) for name, data in self.bytes.items()},
+        )
+        # Nothing ships beside it, and the source is the file it was.
+        self.assertEqual(os.listdir(os.path.dirname(dest)), ["Crate.fbx"])
+        with open(self.fbx, "rb") as fh:
+            self.assertEqual(fh.read(), self.source)
+        self.assertFalse(bridge.logger.warnings, bridge.logger.warnings)
+
+    def test_a_bridge_without_a_host_answer_looks_beside_the_source(self):
+        """The file-driven bridge has no host: the maps beside the picked FBX."""
+        for name, data in self.bytes.items():
+            with open(os.path.join(self.tmp, name), "wb") as fh:
+                fh.write(data)
+        result = self._deliver(_StubBridge(self.project))
+        self.assertEqual(
+            sorted(row["name"] for row in FbxMedia.embedded(result["asset"])),
+            sorted(self.bytes),
+        )
+
+    def test_a_map_found_nowhere_is_warned_and_the_fbx_still_ships(self):
+        os.remove(os.path.join(self.maps, "Crate_horizon.png"))
+        bridge = _HostBridge(self.project, [self.maps])
+        result = self._deliver(bridge)
+        self.assertTrue(os.path.isfile(result["asset"]))
+        self.assertIn("Crate_horizon.png", "\n".join(bridge.logger.warnings))
+        self.assertNotIn(
+            "Crate_horizon.png", [r["name"] for r in FbxMedia.embedded(result["asset"])]
+        )
+
+    def test_an_embed_pass_that_fails_ships_the_fbx_as_exported(self):
+        """The pass is an addition to the send, never a reason to fail it: a
+        file it cannot read (a pythontk before the truncated-file fix raised
+        ``struct.error``) ships as exported, with a warning."""
+        from unittest.mock import patch
+
+        bridge = _HostBridge(self.project, [self.maps])
+        with patch.object(
+            FbxMedia, "embed_dependencies", side_effect=struct.error("cut short")
+        ):
+            result = self._deliver(bridge)
+        with open(result["asset"], "rb") as fh:
+            self.assertEqual(fh.read(), self.source)
+        self.assertIn("cut short", "\n".join(bridge.logger.warnings))
+
+    def test_a_truncated_fbx_ships_as_it_is(self):
+        """The magic but not the body: nothing to embed into, the copy stands."""
+        from pythontk.file_utils.mesh_convert.fbx_file import FBX_MAGIC
+
+        cut = FBX_MAGIC + struct.pack("<I", 7700) + b"\x10" * 20
+        with open(self.fbx, "wb") as fh:
+            fh.write(cut)
+        bridge = _HostBridge(self.project, [self.maps])
+        result = self._deliver(bridge)
+        with open(result["asset"], "rb") as fh:
+            self.assertEqual(fh.read(), cut)
+        self.assertTrue(bridge.logger.warnings)
+
+
 class FileToUnityBridgeTest(unittest.TestCase):
     """The DCC-free file-driven bridge: pick a model file -> copy into Assets/."""