Skip to content

Free, open-source 3D sculpting for Linux, macOS and Windows: dense meshes, remeshing, painting, built-in AI (image/text to 3D), Send to Unreal, game-ready LODs, Gaussian splats and OpenUSD.

24.8 KB
Raw Blame
// SculptForge - open source digital sculpting
// SPDX-License-Identifier: GPL-3.0-or-later
//
// Maya Live (#42): the file side's debounce, mesh hash, echo guard and manifest writer id (io/MayaBridge.h), and
// the Live link (link/MayaLink.h): strict frames (round trips, then malformed and random input refused without
// a crash), Points folding, and a real server on a per-user socket that pairs only with its code.
#include "TestHarness.h"

#include "core/Commands.h"
#include "core/Primitives.h"
#include "io/MayaBridge.h"
#include "io/MayaCommands.h"
#include "io/ObjIO.h"
#include "link/MayaLink.h"

#include <chrono>
#include <cmath>
#include <cstdlib>
#include <fstream>
#include <functional>
#include <iterator>
#include <limits>
#include <filesystem>
#include <random>
#include <thread>

using namespace sf;

namespace {

namespace fs = std::filesystem;

link::MayaLinkMesh quadMesh() {
    link::MayaLinkMesh m;
    m.name = "pPlane1";
    m.positions = {0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 2, 0, 0};
    m.faceSizes = {4, 3};
    m.indices = {0, 1, 2, 3, 1, 4, 2};
    m.uvs = {0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1};
    return m;
}

std::string payloadOf(const std::string& frame) { return frame.substr(link::kMayaLinkHeaderBytes); }

bool waitFor(const std::function<bool()>& f, int ms = 3000) {
    for (int i = 0; i < ms / 5; ++i) {
        if (f()) return true;
        std::this_thread::sleep_for(std::chrono::milliseconds(5));
    }
    return f();
}

void setTestEnv(const char* name, const std::string& value) {
#ifdef _WIN32
    _putenv_s(name, value.c_str());
#else
    if (value.empty()) unsetenv(name);
    else setenv(name, value.c_str(), 1);
#endif
}

bool readFrame(link::AiLinkConn& c, link::MayaLinkType& type, std::string& payload) {
    char header[link::kMayaLinkHeaderBytes];
    size_t got = 0;
    while (got < sizeof header) {
        const long long n = c.readBytes(header + got, sizeof header - got, 3000);
        if (n <= 0) return false;
        got += size_t(n);
    }
    uint64_t length = 0;
    std::string error;
    if (!link::parseMayaLinkHeader(header, type, length, error)) return false;
    payload.assign(size_t(length), '\0');
    for (size_t at = 0; at < payload.size();) {
        const long long n = c.readBytes(payload.data() + at, payload.size() - at, 3000);
        if (n <= 0) return false;
        at += size_t(n);
    }
    return true;
}

} // namespace

TEST(maya_live_debounce_and_hash) {
    MayaLiveDebounce d;
    CHECK(!d.pending() && !d.due(1'000'000'000ull, false));
    d.changed(1'000'000'000ull);
    CHECK(d.pending() && !d.due(1'100'000'000ull, false));                    // 100 ms: still waiting
    CHECK(!d.due(1'400'000'000ull, true));                                    // still, but mid-stroke: never
    CHECK(d.due(1'300'000'000ull, false) && d.due(1'400'000'000ull, false)); // 300 ms of stillness
    d.changed(1'350'000'000ull);                                              // another edit restarts the wait
    CHECK(!d.due(1'400'000'000ull, false) && d.due(1'650'000'000ull, false));
    d.clear();
    CHECK(!d.pending());

    Mesh a = makeCube(2);
    a.uvs.assign(a.triangleCount() * 3, glm::vec2(0.5f));
    Mesh b = mayaSendCopy(a);
    CHECK(b.positions == a.positions && b.triangles == a.triangles && b.uvs == a.uvs && b.hasQuads() == a.hasQuads());
    CHECK(b.layers.empty() && !b.hasFaceGroups() && !b.texture);
    CHECK(mayaMeshHash(a) == mayaMeshHash(b));
    b.positions[3].x += 1e-4f;
    CHECK(mayaMeshHash(a) != mayaMeshHash(b));

    // The echo guard: OBJ's rounding is the same mesh; a real move or other faces are not.
    Mesh c = a;
    for (glm::vec3& p : c.positions) p += glm::vec3(3e-7f);
    CHECK(mayaMeshesMatch(a, c));
    c.positions[0].y += 0.01f;
    CHECK(!mayaMeshesMatch(a, c));
    CHECK(!mayaMeshesMatch(a, makeCube(3)));
}

TEST(maya_live_manifest_writer_and_echo) {
    MayaManifest m;
    m.revision = 7;
    m.sender = "sculptforge";
    m.writer = mayaNewWriterId();
    m.live = true;
    CHECK(m.writer.size() == 16 && m.writer != mayaNewWriterId());
    MayaManifest back;
    std::string err;
    CHECK(parseMayaManifest(writeMayaManifest(m), back, err));
    CHECK(back.writer == m.writer && back.live && back.revision == 7);
    // Older manifests (no writer) still read; a writer that isn't a short string is refused.
    CHECK(parseMayaManifest(R"({"format": "sculptforge-maya", "version": 1, "revision": 1, "objects": []})", back, err) &&
          back.writer.empty() && !back.live);
    CHECK(!parseMayaManifest(R"({"format": "sculptforge-maya", "version": 1, "revision": 1, "writer": 5, "objects": []})", back, err));

    // A Live send: writer and live in the manifest, files renamed into place (no .tmp left).
    const fs::path root = fs::temp_directory_path() / "sf_maya_live";
    fs::remove_all(root);
    fs::create_directories(root);
    Mesh cube = makeCube(2);
    std::string msg;
    std::vector<std::string> names;
    CHECK(mayaSend({{"Body", &cube}}, root.string(), msg, &names, nullptr, m.writer, true));
    CHECK(msg.rfind("Live: sent 1 object", 0) == 0);
    CHECK(readMayaManifest(mayaManifestPath(mayaOutbox(root.string())), back, err) && back.writer == m.writer && back.live);
    for (const auto& e : fs::directory_iterator(root / "sculptforge_to_maya"))
        CHECK(e.path().extension() != ".tmp");

    // maya_receive skips what Maya sends back unchanged (no undo step), loads what changed.
    CommandRegistry reg;
    Document doc = makeDoc(makeCube(2));
    doc.bridgeName = "Body";
    const fs::path inbox = root / "maya_to_sculptforge";
    fs::create_directories(inbox);
    CHECK(saveObj((inbox / "r1_000.obj").string(), doc.mesh, err));
    std::ofstream(inbox / "manifest.json") << R"({"format": "sculptforge-maya", "version": 1, "revision": 1,
        "objects": [{"name": "Body", "file": "r1_000.obj"}]})";
    CommandResult r = reg.execute(doc, "maya_receive", {{"folder", root.string()}});
    CHECK(r.ok && r.message.find("unchanged") != std::string::npos && !doc.undo.canUndo());
    Mesh moved = doc.mesh;
    for (glm::vec3& p : moved.positions) p.x += 0.5f;
    CHECK(saveObj((inbox / "r2_000.obj").string(), moved, err));
    std::ofstream(inbox / "manifest.json") << R"({"format": "sculptforge-maya", "version": 1, "revision": 2,
        "objects": [{"name": "Body", "file": "r2_000.obj"}]})";
    r = reg.execute(doc, "maya_receive", {{"folder", root.string()}});
    CHECK(r.ok && r.message.find("Received 1 object") != std::string::npos && doc.undo.canUndo());
    fs::remove_all(root);
}

TEST(maya_link_frames_round_trip) {
    using namespace link;
    const std::string code = mayaLinkNewCode();
    CHECK(code.size() == kMayaLinkCodeChars && code != mayaLinkNewCode());
    const std::string shown = mayaLinkShowCode(code);
    CHECK(shown.size() == 35 && shown[8] == '-');
    CHECK(mayaLinkCodeMatches(shown, code) && mayaLinkCodeMatches(code, code));
    CHECK(!mayaLinkCodeMatches(mayaLinkNewCode(), code) && !mayaLinkCodeMatches("", code) &&
          !mayaLinkCodeMatches(code.substr(0, 31), code) && !mayaLinkCodeMatches(code + "0", code));
    CHECK(mayaLinkPairingText(code, "/run/x/maya-link.sock") == "sflink1 " + shown + " /run/x/maya-link.sock");

    std::string c, client, err;
    CHECK(parseMayaLinkHello(payloadOf(encodeMayaLinkHello(code, "Maya 2026")), c, client, err) && c == code &&
          client == "Maya 2026");

    const MayaLinkMesh m = quadMesh();
    const std::string f = encodeMayaLinkMesh(m);
    MayaLinkType type{};
    uint64_t length = 0;
    CHECK(parseMayaLinkHeader(f.data(), type, length, err) && type == MayaLinkType::Mesh && length == f.size() - 16);
    MayaLinkMesh back;
    CHECK(parseMayaLinkMesh(payloadOf(f), back, err));
    CHECK(back.name == m.name && back.positions == m.positions && back.faceSizes == m.faceSizes &&
          back.indices == m.indices && back.uvs == m.uvs);

    // To a SculptForge mesh and back: a quad stays a quad, the triangle a triangle, UVs per corner.
    Mesh mesh;
    CHECK(mayaLinkMeshTo(back, mesh, err));
    CHECK(mesh.vertexCount() == 5 && mesh.triangleCount() == 3 && mesh.quadCount() == 1 && mesh.uvs.size() == 9);
    const MayaLinkMesh again = mayaLinkMeshFrom("pPlane1", mesh);
    CHECK(again.faceSizes.size() == 2 && again.indices.size() == 7 && again.uvs.size() == 14);

    MayaLinkPoints p = mayaLinkPointsBetween("pPlane1", mesh.positions, mesh.positions);
    CHECK(p.indices.empty() && p.vertexCount == 5);
    std::vector<glm::vec3> now = mesh.positions;
    now[1].z = 0.5f;
    now[4].z = -0.5f;
    p = mayaLinkPointsBetween("pPlane1", mesh.positions, now);
    CHECK((p.indices == std::vector<uint32_t>{1, 4}) && p.positions.size() == 6);
    MayaLinkPoints pb;
    CHECK(parseMayaLinkPoints(payloadOf(encodeMayaLinkPoints(p)), pb, err) && pb.indices == p.indices &&
          pb.positions == p.positions && pb.vertexCount == 5);

    // Folding: the union of the vertices, the later positions winning.
    MayaLinkPoints later = p;
    later.indices = {4, 2};
    later.positions = {9, 9, 9, 7, 7, 7};
    mergeMayaLinkPoints(p, later);
    CHECK((p.indices == std::vector<uint32_t>{1, 4, 2}) && p.positions[3] == 9.0f && p.positions[6] == 7.0f &&
          p.positions[0] == now[1].x);
}

// The shelf script's encoder wrote these (tests/maya/data; tests/maya/test_sculptforge_maya.py checks it still
// writes the same bytes): both sides speak one format.
TEST(maya_link_reads_the_shelf_scripts_frames) {
    using namespace link;
    auto read = [](const char* name) {
        std::ifstream f(fs::path(SF_TEST_DATA_DIR) / ".." / "maya" / "data" / name, std::ios::binary);
        return std::string((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
    };
    const std::string mesh = read("link_mesh.bin");
    CHECK(mesh == encodeMayaLinkMesh(quadMesh()));
    MayaLinkType type{};
    uint64_t length = 0;
    std::string err;
    MayaLinkMesh m;
    CHECK(mesh.size() > 16 && parseMayaLinkHeader(mesh.data(), type, length, err) && type == MayaLinkType::Mesh &&
          parseMayaLinkMesh(payloadOf(mesh), m, err) && m.name == "pPlane1" && m.faceSizes.size() == 2);
    const std::string points = read("link_points.bin");
    MayaLinkPoints p;
    CHECK(points.size() > 16 && parseMayaLinkPoints(payloadOf(points), p, err) && p.name == "Body" && p.vertexCount == 5 &&
          (p.indices == std::vector<uint32_t>{1, 4}) && p.positions[0] == 0.5f && p.positions[5] == 4.0f);
}

TEST(maya_link_refuses_malformed) {
    using namespace link;
    std::string err;
    MayaLinkType type{};
    uint64_t length = 0;
    auto header = [](const char* magic, uint16_t version, uint16_t t, uint64_t n) {
        std::string h(magic, 4);
        h += char(version & 0xff);
        h += char(version >> 8);
        h += char(t & 0xff);
        h += char(t >> 8);
        for (int i = 0; i < 8; ++i) h += char((n >> (8 * i)) & 0xff);
        return h;
    };
    CHECK(!parseMayaLinkHeader(header("GET ", 1, 3, 10).data(), type, length, err)); // (HTTP, a browser: refused)
    CHECK(!parseMayaLinkHeader(header("SFML", 2, 3, 10).data(), type, length, err));
    CHECK(!parseMayaLinkHeader(header("SFML", 1, 0, 10).data(), type, length, err));
    CHECK(!parseMayaLinkHeader(header("SFML", 1, 9, 10).data(), type, length, err));
    CHECK(!parseMayaLinkHeader(header("SFML", 1, 3, kMayaLinkMaxPayload + 1).data(), type, length, err));
    CHECK(parseMayaLinkHeader(header("SFML", 1, 3, 10).data(), type, length, err));

    MayaLinkMesh out;
    auto refused = [&](MayaLinkMesh m) { return !parseMayaLinkMesh(payloadOf(encodeMayaLinkMesh(m)), out, err); };
    MayaLinkMesh m = quadMesh();
    m.indices[2] = 5; // out of range
    CHECK(refused(m));
    m = quadMesh();
    m.faceSizes = {2, 5}; // a face of 2
    CHECK(refused(m));
    m = quadMesh();
    m.faceSizes = {4, 4}; // faces that don't add up
    CHECK(refused(m));
    m = quadMesh();
    m.positions[4] = std::nanf("");
    CHECK(refused(m));
    m = quadMesh();
    m.uvs[3] = std::numeric_limits<float>::infinity();
    CHECK(refused(m));
    for (const char* name : {"", "../x", "a b", "1abc", "C:\\x"}) {
        m = quadMesh();
        m.name = name;
        CHECK(refused(m));
    }
    const std::string good = payloadOf(encodeMayaLinkMesh(quadMesh()));
    CHECK(!parseMayaLinkMesh(good + "x", out, err));                 // a byte too many
    CHECK(!parseMayaLinkMesh(good.substr(0, good.size() - 1), out, err)); // one too few
    for (size_t cut = 0; cut < good.size(); ++cut) CHECK(!parseMayaLinkMesh(good.substr(0, cut), out, err));

    // Fuzz: random bytes, and the good payload with random bytes changed, never crash or read out of bounds (run
    // under the sanitizers in CI); whatever parses still holds only in-range indices and finite numbers.
    std::mt19937 rng(42);
    for (int i = 0; i < 20000; ++i) {
        std::string s = i % 2 ? good : std::string(size_t(rng() % 96), '\0');
        if (i % 2 == 0)
            for (char& ch : s) ch = char(rng());
        else
            for (int k = 0; k < 1 + int(rng() % 4); ++k) s[rng() % s.size()] = char(rng());
        MayaLinkMesh fm;
        if (parseMayaLinkMesh(s, fm, err)) {
            for (uint32_t v : fm.indices) CHECK(v < fm.positions.size() / 3);
            for (float x : fm.positions) CHECK(std::isfinite(x));
        }
        MayaLinkPoints fp;
        if (parseMayaLinkPoints(s, fp, err))
            for (uint32_t v : fp.indices) CHECK(v < fp.vertexCount);
        std::string c, cl;
        parseMayaLinkHello(s, c, cl, err);
        if (s.size() >= kMayaLinkHeaderBytes) parseMayaLinkHeader(s.data(), type, length, err);
    }
    // Counts that claim more than the payload holds (a 4 GB allocation attempt) are refused before allocating.
    std::string huge;
    huge += char(1);
    huge += char(0);
    huge += 'a';
    for (int i = 0; i < 3; ++i) huge += std::string("\xff\xff\xff\x03", 4);
    huge += char(0);
    CHECK(!parseMayaLinkMesh(huge, out, err));
}

TEST(maya_link_server_pairs_and_streams) {
    using namespace link;
    const fs::path dir = fs::temp_directory_path() / ("sf_maya_link_" + std::to_string(std::random_device{}() % 100000));
    fs::create_directories(dir);
    setTestEnv("SF_AI_LIVE_DIR", dir.string());
    std::string err;
    const std::string endpoint = localEndpoint("maya-link", err);
    CHECK(!endpoint.empty() && endpoint.find("maya-link") != std::string::npos);
    MayaLinkServer server;
    CHECK(server.start(endpoint, err));
#ifndef _WIN32
    CHECK(aiLinkFileMode(endpoint) == 0600);
#endif
    // A second server on the same endpoint: refused (another window has it on).
    MayaLinkServer second;
    CHECK(!second.start(endpoint, err));

    // A wrong code: the connection closes, nothing connected.
    {
        AiLinkConn c;
        CHECK(aiLinkConnect(c, endpoint, err));
        const std::string hello = encodeMayaLinkHello(mayaLinkNewCode(), "intruder");
        CHECK(c.writeAll(hello.data(), hello.size()));
        MayaLinkType t{};
        std::string p;
        CHECK(!readFrame(c, t, p) || t == MayaLinkType::Bye);
        CHECK(waitFor([&] { return server.refused() == 1; }) && !server.connected());
    }
    // Something that isn't the link at all (an HTTP request): refused too.
    {
        AiLinkConn c;
        CHECK(aiLinkConnect(c, endpoint, err));
        const std::string http = "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n";
        CHECK(c.writeAll(http.data(), http.size()));
        CHECK(waitFor([&] { return server.refused() == 2; }) && !server.connected());
    }
    // Before pairing, a header claiming 1 GiB is refused on the claim: nothing near that size is allocated.
    {
        AiLinkConn c;
        CHECK(aiLinkConnect(c, endpoint, err));
        std::string big = mayaLinkFrame(MayaLinkType::Hello, {});
        for (int i = 0; i < 8; ++i) big[8 + size_t(i)] = char(((1ull << 30) >> (8 * i)) & 0xff);
        CHECK(c.writeAll(big.data(), big.size()));
        CHECK(waitFor([&] { return server.refused() == 3; }) && !server.connected());
        CHECK(server.largestBuffer() <= kMayaLinkMaxHello);
    }
    // The right code: Welcome, then meshes both ways.
    AiLinkConn c;
    CHECK(aiLinkConnect(c, endpoint, err));
    const std::string hello = encodeMayaLinkHello(mayaLinkShowCode(server.code()), "Maya 2026");
    CHECK(c.writeAll(hello.data(), hello.size()));
    MayaLinkType t{};
    std::string p;
    CHECK(readFrame(c, t, p) && t == MayaLinkType::Welcome);
    CHECK(waitFor([&] { return server.connected(); }) && server.clientName() == "Maya 2026");
    std::string e;
    for (int i = 0; i < 4 && e != "connected"; ++i) e = server.takeEvent();
    CHECK(e == "connected");

    const std::string mesh = encodeMayaLinkMesh(quadMesh());
    CHECK(c.writeAll(mesh.data(), mesh.size()));
    std::vector<MayaLinkMesh> got;
    CHECK(waitFor([&] {
        for (auto& m : server.takeReceived()) got.push_back(std::move(m));
        return !got.empty();
    }));
    CHECK(got.size() == 1 && got[0].name == "pPlane1" && got[0].indices.size() == 7);

    // App -> Maya: Points queued together fold into one frame.
    MayaLinkPoints a;
    a.name = "Body";
    a.vertexCount = 100;
    a.indices = {1};
    a.positions = {1, 2, 3};
    server.send(a);
    MayaLinkMesh whole = quadMesh();
    whole.name = "Body2";
    server.send(whole);
    CHECK(readFrame(c, t, p));
    CHECK(t == MayaLinkType::Points || t == MayaLinkType::Mesh);

    // Maya says Bye: the server is free for the next client.
    const std::string bye = mayaLinkFrame(MayaLinkType::Bye, {});
    CHECK(c.writeAll(bye.data(), bye.size()));
    CHECK(waitFor([&] { return !server.connected(); }));

    // After pairing, a frame claiming 1 GiB that sends 10 bytes and stalls: it times out, and the buffer never grew
    // past one read chunk (the claim isn't allocated up front).
    server.setFrameTimeoutMs(300);
    {
        AiLinkConn s;
        CHECK(aiLinkConnect(s, endpoint, err));
        const std::string h = encodeMayaLinkHello(server.code(), "staller");
        CHECK(s.writeAll(h.data(), h.size()));
        CHECK(readFrame(s, t, p) && t == MayaLinkType::Welcome);
        CHECK(waitFor([&] { return server.connected(); }));
        std::string big = mayaLinkFrame(MayaLinkType::Mesh, std::string(10, 'x'));
        for (int i = 0; i < 8; ++i) big[8 + size_t(i)] = char(((1ull << 30) >> (8 * i)) & 0xff);
        CHECK(s.writeAll(big.data(), big.size()));
        CHECK(waitFor([&] { return !server.connected(); }, 5000));
        CHECK(server.largestBuffer() <= 10 + kMayaLinkReadChunk); // (at most one chunk ahead of what arrived)
        std::string last, ev;
        while (!(ev = server.takeEvent()).empty()) last = ev;
        CHECK(last == "disconnected: timed out");
    }
    server.stop();
#ifndef _WIN32
    CHECK(aiLinkFileMode(endpoint) < 0); // the socket file is gone when the link is off
#endif
    setTestEnv("SF_AI_LIVE_DIR", "");
    fs::remove_all(dir);
}

#ifdef SF_PYTHON_EXE
// The Maya shelf script's own client (tests/maya/link_peer.py: LinkClient over the Unix socket, or on Windows the
// named pipe through PeekNamedPipe) against the app's server: pairing, a mesh from "Maya", streamed Points back.
TEST(maya_link_python_client) {
    using namespace link;
    const fs::path dir = fs::temp_directory_path() / ("sf_maya_peer_" + std::to_string(std::random_device{}() % 100000));
    fs::create_directories(dir);
    setTestEnv("SF_AI_LIVE_DIR", dir.string());
    std::string err;
    const std::string endpoint = localEndpoint("maya-link", err);
    MayaLinkServer server;
    CHECK(server.start(endpoint, err));
    const fs::path script = fs::path(SF_TEST_DATA_DIR) / ".." / "maya" / "link_peer.py";
    const std::string pairing = mayaLinkPairingText(server.code(), endpoint);
    int exitCode = -1;
    std::thread peer([&] {
        std::string cmd = std::string("\"") + SF_PYTHON_EXE + "\" -I \"" + script.string() + "\" \"" + pairing + "\"";
#ifdef _WIN32
        cmd = "\"" + cmd + "\""; // (cmd /c drops the outer pair of quotes)
#endif
        exitCode = std::system(cmd.c_str());
    });
    std::vector<MayaLinkMesh> got;
    CHECK(waitFor([&] {
        for (auto& m : server.takeReceived()) got.push_back(std::move(m));
        return !got.empty();
    }, 20000));
    CHECK(got.size() == 1 && got[0].name == "pCube1" && got[0].faceSizes.size() == 6);
    CHECK(server.clientName() == "link_peer");
    // Two Points for the same object, then a third: the client folds what it hasn't applied yet.
    for (uint32_t k = 0; k < 3; ++k) {
        MayaLinkPoints p;
        p.name = "pCube1";
        p.vertexCount = 8;
        p.indices = {k, 7};
        p.positions = {float(k), 0, 0, 9, 9, float(k)};
        server.send(p);
    }
    peer.join();
    CHECK(exitCode == 0);
    server.stop();
    setTestEnv("SF_AI_LIVE_DIR", "");
    fs::remove_all(dir);
}
#endif

#ifndef _WIN32
// SF_MAYA_BENCH=1 sculptforge_tests maya_live_bench: what each way costs on a 1M-triangle and a Lucy-size
// (28M-triangle) quad mesh with UVs: the folder (OBJ write, read) and the link (encode, carry through the real
// socket, parse, rebuild), and a stroke's Points (2% of the vertices). Not part of the suite (it times).
TEST(maya_live_bench) {
    if (!std::getenv("SF_MAYA_BENCH")) return;
    using namespace link;
    using Clock = std::chrono::steady_clock;
    auto ms = [](Clock::time_point a) { return std::chrono::duration<double, std::milli>(Clock::now() - a).count(); };
    for (int res : {289, 1528}) {
        Mesh mesh = makeCube(res);
        mesh.uvs.assign(size_t(mesh.triangleCount()) * 3, glm::vec2(0.5f));
        std::printf("\n%u triangles, %zu vertices\n", mesh.triangleCount(), mesh.positions.size());
        const fs::path root = fs::temp_directory_path() / "sf_maya_bench";
        fs::remove_all(root);
        fs::create_directories(root);
        std::string msg, err;
        auto t = Clock::now();
        Mesh copy = mayaSendCopy(mesh);
        std::printf("  copy for the worker     %8.1f ms\n", ms(t));
        t = Clock::now();
        const uint64_t h = mayaMeshHash(copy);
        std::printf("  hash                    %8.1f ms (%llx)\n", ms(t), (unsigned long long)(h & 0xffff));
        t = Clock::now();
        CHECK(mayaSend({{"Body", &copy}}, root.string(), msg, nullptr, nullptr, "bench", true));
        std::printf("  folder: OBJ write       %8.1f ms (%.0f MB)\n", ms(t),
                    double(fs::file_size(root / "sculptforge_to_maya" / "r1_000.obj")) / 1e6);
        fs::rename(root / "sculptforge_to_maya", root / "maya_to_sculptforge");
        std::vector<MeshObject> back;
        t = Clock::now();
        CHECK(mayaReceive(root.string(), back, nullptr, msg));
        std::printf("  folder: OBJ read        %8.1f ms\n", ms(t));
        t = Clock::now();
        CHECK(back.size() == 1 && mayaMeshesMatch(mesh, back[0].mesh));
        std::printf("  echo check              %8.1f ms\n", ms(t));
        back.clear();
        fs::remove_all(root);

        t = Clock::now();
        const MayaLinkMesh lm = mayaLinkMeshFrom("Body", mesh);
        const std::string frame = encodeMayaLinkMesh(lm);
        std::printf("  link: encode            %8.1f ms (%.0f MB)\n", ms(t), double(frame.size()) / 1e6);
        // Carried through a real link: this test plays Maya, sending to the app's server.
        const fs::path dir = fs::temp_directory_path() / "sf_maya_bench_link";
        fs::create_directories(dir);
        setTestEnv("SF_AI_LIVE_DIR", dir.string());
        const std::string endpoint = localEndpoint("maya-link", err);
        MayaLinkServer server;
        CHECK(server.start(endpoint, err));
        AiLinkConn c;
        CHECK(aiLinkConnect(c, endpoint, err));
        const std::string hello = encodeMayaLinkHello(server.code(), "bench");
        c.writeAll(hello.data(), hello.size());
        MayaLinkType type{};
        std::string p;
        CHECK(readFrame(c, type, p) && type == MayaLinkType::Welcome);
        std::vector<MayaLinkMesh> got;
        t = Clock::now();
        std::thread writer([&] { c.writeAll(frame.data(), frame.size()); });
        CHECK(waitFor([&] {
            for (auto& m : server.takeReceived()) got.push_back(std::move(m));
            return !got.empty();
        }, 120000));
        writer.join();
        std::printf("  link: carry + parse     %8.1f ms\n", ms(t));
        t = Clock::now();
        Mesh rebuilt;
        CHECK(!got.empty() && mayaLinkMeshTo(got[0], rebuilt, err));
        std::printf("  link: rebuild mesh      %8.1f ms\n", ms(t));
        got.clear();

        std::vector<glm::vec3> moved = mesh.positions;
        for (size_t i = 0; i < moved.size(); i += 50) moved[i].y += 0.01f;
        t = Clock::now();
        const MayaLinkPoints pts = mayaLinkPointsBetween("Body", mesh.positions, moved);
        std::printf("  stroke: diff (%zu moved) %7.1f ms\n", pts.indices.size(), ms(t));
        t = Clock::now();
        const std::string pf = encodeMayaLinkPoints(pts);
        MayaLinkPoints pb;
        CHECK(parseMayaLinkPoints(payloadOf(pf), pb, err));
        std::printf("  stroke: Points encode+parse %4.1f ms (%.1f MB)\n", ms(t), double(pf.size()) / 1e6);
        server.stop();
        setTestEnv("SF_AI_LIVE_DIR", "");
        fs::remove_all(dir);
    }
}
#endif