brane 0.0.2 → 0.3.0

package/dist/test/daemon-client.test.js

@@ -0,0 +1,109 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { createTestDb } from "./helpers.js";
+import { buildDaemonBaseUrl, readDaemonAddress, daemonRequest, } from "../daemon/client.js";
+const TS_HOST = "myhost.tailnet.ts.net";
+function setMeta(db, key, value) {
+    db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run(key, value);
+}
+describe("buildDaemonBaseUrl", () => {
+    it("uses loopback on the primary port when TLS is off", () => {
+        assert.equal(buildDaemonBaseUrl({ port: "7777", tls: false }), "http://127.0.0.1:7777");
+    });
+    it("prefers the HTTP fallback port under TLS (the cert never covers 127.0.0.1)", () => {
+        assert.equal(buildDaemonBaseUrl({ port: "8443", tls: true, httpPort: "9001", tailscaleHost: TS_HOST }), "http://127.0.0.1:9001");
+    });
+    it("falls back to the Tailscale hostname when no HTTP port is recorded yet", () => {
+        assert.equal(buildDaemonBaseUrl({ port: "8443", tls: true, tailscaleHost: TS_HOST }), `https://${TS_HOST}:8443`);
+    });
+    it("refuses to guess when TLS is on and neither route is available", () => {
+        assert.throws(() => buildDaemonBaseUrl({ port: "8443", tls: true }), /TLS/);
+    });
+});
+describe("readDaemonAddress", () => {
+    let db;
+    before(() => {
+        db = createTestDb();
+    });
+    after(() => {
+        db.close();
+    });
+    it("reports a plain-HTTP daemon and ignores any stale fallback port", () => {
+        setMeta(db, "daemon_tls", "false");
+        setMeta(db, "daemon_http_port", "9001");
+        const addr = readDaemonAddress(db, "7777", { tailscaleHost: TS_HOST });
+        assert.equal(addr.tls, false);
+        assert.equal(addr.httpPort, undefined);
+        assert.equal(addr.tailscaleHost, undefined);
+    });
+    it("carries the fallback port and cert hostname for a TLS daemon", () => {
+        setMeta(db, "daemon_tls", "true");
+        setMeta(db, "daemon_http_port", "9001");
+        const addr = readDaemonAddress(db, "8443", { tailscaleHost: TS_HOST });
+        assert.deepEqual(addr, {
+            port: "8443",
+            tls: true,
+            httpPort: "9001",
+            tailscaleHost: TS_HOST,
+        });
+    });
+});
+describe("daemonRequest", () => {
+    let server;
+    let endpoint;
+    const seen = [];
+    before(async () => {
+        server = createServer((req, res) => {
+            let body = "";
+            req.on("data", (c) => (body += c));
+            req.on("end", () => {
+                seen.push({
+                    method: req.method ?? "",
+                    url: req.url ?? "",
+                    auth: req.headers.authorization,
+                    body,
+                });
+                if (req.url === "/api/spawn") {
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ narrative: { id: "claude-abc12345" } }));
+                }
+                else if (req.url === "/api/boom") {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Not a fold: ~/nope. Run `brane fold` first." }));
+                }
+                else {
+                    res.writeHead(404, { "Content-Type": "text/plain" });
+                    res.end("nope");
+                }
+            });
+        });
+        await new Promise((r) => server.listen(0, "127.0.0.1", r));
+        const port = server.address().port;
+        endpoint = { baseUrl: `http://127.0.0.1:${port}`, token: "tok", port: String(port) };
+    });
+    after(async () => {
+        await new Promise((r) => server.close(() => r()));
+    });
+    it("POSTs JSON with a bearer token and returns the parsed body", async () => {
+        const result = await daemonRequest(endpoint, "/api/spawn", {
+            method: "POST",
+            body: { agent: "claude", fold_path: "~/dev/brane" },
+        });
+        assert.equal(result.narrative.id, "claude-abc12345");
+        const req = seen.find((r) => r.url === "/api/spawn");
+        assert.equal(req?.method, "POST");
+        assert.equal(req?.auth, "Bearer tok");
+        assert.deepEqual(JSON.parse(req?.body ?? "{}"), {
+            agent: "claude",
+            fold_path: "~/dev/brane",
+        });
+    });
+    it("surfaces the daemon's own error string verbatim", async () => {
+        await assert.rejects(() => daemonRequest(endpoint, "/api/boom", { method: "POST", body: {} }), /^Error: Not a fold: ~\/nope\. Run `brane fold` first\.$/);
+    });
+    it("falls back to a status-code message when the body carries no error", async () => {
+        await assert.rejects(() => daemonRequest(endpoint, "/api/missing"), /404/);
+    });
+});
+//# sourceMappingURL=daemon-client.test.js.map

package/dist/test/daemon-socket.test.js

@@ -0,0 +1,293 @@
+/**
+ * `daemon.sock`: the CLI reaches the daemon over its Unix socket when it has
+ * one, falls back to TCP only when the socket refuses the connection, and a
+ * request that arrives over the socket counts as loopback. Stale-socket
+ * cleanup removes only a socket nothing answers on.
+ */
+import { describe, it, after } from "node:test";
+import assert from "node:assert/strict";
+import { createServer as createHttpServer } from "node:http";
+import { createServer as createNetServer, connect as netConnect } from "node:net";
+import Database from "better-sqlite3";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, writeFileSync, lstatSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { WebSocket, WebSocketServer } from "ws";
+import { daemonRequest, daemonStream, readDaemonSocket } from "../daemon/client.js";
+import { mcpDialTarget } from "../commands/mcp.js";
+import { SCHEMA_SQL, applyMigrations } from "../db/schema.js";
+import { createTestDb } from "./helpers.js";
+import { clearStaleSocket, connectionLabel, getSocketPath, listenOnLocalSocket, markUnixConnection, MAX_SOCKET_PATH } from "../daemon/local-socket.js";
+import { samePlace, UNIX_SOCKET_SIGHTING } from "../db/tokens.js";
+import { isLoopbackRequest } from "../daemon/server.js";
+function tempDir() {
+    return mkdtempSync(join(tmpdir(), "brane-sock-"));
+}
+/** A socket file whose process exited without closing it, as a crash
+ *  leaves one: connects to it are refused. */
+function crashedSocket(path = join(tempDir(), "daemon.sock")) {
+    const r = spawnSync(process.execPath, [
+        "-e",
+        `require("node:net").createServer().listen(${JSON.stringify(path)}, () => process.exit(0))`,
+    ]);
+    assert.equal(r.status, 0);
+    return path;
+}
+function listenUnix(path, handler) {
+    const server = createHttpServer((req, res) => {
+        let body = "";
+        req.on("data", (c) => (body += c));
+        req.on("end", () => {
+            const [status, out] = handler(req, body);
+            res.writeHead(status, { "Content-Type": "application/json" });
+            res.end(out);
+        });
+    });
+    server.on("connection", (socket) => markUnixConnection(socket));
+    return new Promise((r) => server.listen(path, () => r(server)));
+}
+describe("the CLI over daemon.sock", () => {
+    const closers = [];
+    after(async () => {
+        for (const close of closers)
+            await close();
+    });
+    it("sends requests to the socket, with the bearer token, never to baseUrl", async () => {
+        const socketPath = join(tempDir(), "daemon.sock");
+        const seen = [];
+        const server = await listenUnix(socketPath, (req, body) => {
+            seen.push({ url: req.url, auth: req.headers.authorization, body, loopback: isLoopbackRequest(req) });
+            return [200, JSON.stringify({ ok: "yes" })];
+        });
+        closers.push(() => new Promise((r) => server.close(() => r())));
+        // Port 1 answers nothing: success means the socket carried it.
+        const endpoint = { baseUrl: "http://127.0.0.1:1", token: "tok", port: "1", socketPath };
+        const result = await daemonRequest(endpoint, "/api/folds", { method: "POST", body: { path: "/x" } });
+        assert.equal(result.ok, "yes");
+        assert.deepEqual(seen, [{ url: "/api/folds", auth: "Bearer tok", body: '{"path":"/x"}', loopback: true }]);
+    });
+    it("reports the daemon's error string from the socket as it does over TCP", async () => {
+        const socketPath = join(tempDir(), "daemon.sock");
+        const server = await listenUnix(socketPath, () => [403, JSON.stringify({ error: "nope" })]);
+        closers.push(() => new Promise((r) => server.close(() => r())));
+        const endpoint = { baseUrl: "http://127.0.0.1:1", token: "tok", port: "1", socketPath };
+        await assert.rejects(daemonRequest(endpoint, "/api/x"), /^Error: nope$/);
+    });
+    it("streams NDJSON from the socket", async () => {
+        const socketPath = join(tempDir(), "daemon.sock");
+        const server = await listenUnix(socketPath, () => [200, '{"n":1}\n{"n":2}\n']);
+        closers.push(() => new Promise((r) => server.close(() => r())));
+        const endpoint = { baseUrl: "http://127.0.0.1:1", token: "tok", port: "1", socketPath };
+        const lines = [];
+        await daemonStream(endpoint, "/api/absorb", { method: "POST", body: {} }, (l) => lines.push(l));
+        assert.deepEqual(lines, [{ n: 1 }, { n: 2 }]);
+    });
+    it("falls back to TCP when the socket is gone", async () => {
+        const tcp = createHttpServer((req, res) => {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ via: "tcp", loopback: isLoopbackRequest(req) }));
+        });
+        await new Promise((r) => tcp.listen(0, "127.0.0.1", r));
+        closers.push(() => new Promise((r) => tcp.close(() => r())));
+        const port = tcp.address().port;
+        const endpoint = {
+            baseUrl: `http://127.0.0.1:${port}`,
+            token: "tok",
+            port: String(port),
+            socketPath: join(tempDir(), "daemon.sock"),
+        };
+        assert.deepEqual(await daemonRequest(endpoint, "/api/status"), { via: "tcp", loopback: true });
+    });
+});
+describe("the MCP bridge's dial target", () => {
+    it("keeps the socket path out of the URL, so any home directory dials", async () => {
+        // A space, non-ASCII and a colon: each broke the old ws+unix URL.
+        const dir = mkdtempSync(join(tmpdir(), "brane sock josé:x-"));
+        const socketPath = join(dir, "daemon.sock");
+        const target = mcpDialTarget({ port: "4000", tls: true, token: "t/k", socketPath });
+        assert.deepEqual(target, { url: "ws://localhost/ws/mcp?token=t%2Fk", socketPath });
+        const wss = new WebSocketServer({ noServer: true });
+        const server = createHttpServer();
+        const seen = [];
+        server.on("connection", (socket) => markUnixConnection(socket));
+        server.on("upgrade", (req, socket, head) => {
+            seen.push({ url: req.url, loopback: isLoopbackRequest(req) });
+            wss.handleUpgrade(req, socket, head, (ws) => ws.close());
+        });
+        await new Promise((r) => server.listen(socketPath, r));
+        try {
+            // What the bridge's connect() does with it: append its params, swap in
+            // a session token, and hand the socket to ws as the connection.
+            const u = new URL(`${target.url}&nid=claude-x`);
+            u.searchParams.set("token", "agent");
+            await new Promise((resolve, reject) => {
+                const ws = new WebSocket(u.toString(), { createConnection: () => netConnect(target.socketPath) });
+                ws.on("close", () => resolve());
+                ws.on("error", reject);
+            });
+            assert.deepEqual(seen, [{ url: "/ws/mcp?token=agent&nid=claude-x", loopback: true }]);
+        }
+        finally {
+            await new Promise((r) => server.close(() => r()));
+        }
+    });
+    it("dials TCP on loopback when there is no socket", () => {
+        assert.deepEqual(mcpDialTarget({ port: "4000", tls: true, token: "t" }), { url: "wss://localhost:4000/ws/mcp?token=t" });
+        assert.deepEqual(mcpDialTarget({ port: "4000", tls: false, token: "t" }), { url: "ws://localhost:4000/ws/mcp?token=t" });
+    });
+});
+describe("falling back to TCP before anything was sent", () => {
+    async function tcpEndpoint(socketPath) {
+        const tcp = createHttpServer((_req, res) => {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ via: "tcp" }));
+        });
+        await new Promise((r) => tcp.listen(0, "127.0.0.1", r));
+        after(() => new Promise((r) => tcp.close(() => r())));
+        const port = tcp.address().port;
+        return { baseUrl: `http://127.0.0.1:${port}`, token: "tok", port: String(port), socketPath };
+    }
+    it("when the socket refuses (a crashed daemon's file)", async () => {
+        const path = crashedSocket();
+        assert.deepEqual(await daemonRequest(await tcpEndpoint(path), "/api/status"), { via: "tcp" });
+    });
+    it("when the path is not a socket", async () => {
+        const path = join(tempDir(), "daemon.sock");
+        writeFileSync(path, "not a socket");
+        assert.deepEqual(await daemonRequest(await tcpEndpoint(path), "/api/status"), { via: "tcp" });
+    });
+});
+describe("a failure after the socket connected", () => {
+    it("is reported, never retried over TCP, so a POST cannot run twice", async () => {
+        let tcpHits = 0;
+        const tcp = createHttpServer((_req, res) => {
+            tcpHits++;
+            res.end("{}");
+        });
+        await new Promise((r) => tcp.listen(0, "127.0.0.1", r));
+        const port = tcp.address().port;
+        const socketPath = join(tempDir(), "daemon.sock");
+        // Accepts, reads the request, and drops the connection without answering.
+        const dropper = createNetServer((sock) => sock.once("data", () => sock.destroy()));
+        await new Promise((r) => dropper.listen(socketPath, r));
+        try {
+            const endpoint = { baseUrl: `http://127.0.0.1:${port}`, token: "t", port: String(port), socketPath };
+            await assert.rejects(daemonRequest(endpoint, "/api/spawn", { method: "POST", body: { agent: "claude" } }));
+            assert.equal(tcpHits, 0);
+        }
+        finally {
+            await new Promise((r) => dropper.close(() => r()));
+            await new Promise((r) => tcp.close(() => r()));
+        }
+    });
+});
+describe("readDaemonSocket", () => {
+    it("names the socket only while its file is there", () => {
+        const db = createTestDb();
+        const path = join(tempDir(), "daemon.sock");
+        db.prepare("INSERT INTO meta (key, value) VALUES ('daemon_socket', ?)").run(path);
+        assert.equal(readDaemonSocket(db), undefined);
+        writeFileSync(path, "");
+        assert.equal(readDaemonSocket(db), path);
+    });
+});
+describe("connectionLabel", () => {
+    it("is daemon.sock on the socket, else the remote address", () => {
+        const unix = {};
+        markUnixConnection(unix);
+        assert.equal(connectionLabel(unix), UNIX_SOCKET_SIGHTING);
+        assert.equal(connectionLabel({ remoteAddress: "100.64.0.7" }), "100.64.0.7");
+        assert.equal(connectionLabel({}), null);
+    });
+});
+describe("listenOnLocalSocket", () => {
+    function fileDb(dir = tempDir()) {
+        const db = new Database(join(dir, "brane.db"));
+        db.exec(SCHEMA_SQL);
+        applyMigrations(db);
+        return db;
+    }
+    it("listens 0600 beside the database, advertises it, marks its connections, and removes it on close", async () => {
+        const db = fileDb();
+        const path = getSocketPath(db);
+        const seen = [];
+        const server = createHttpServer((req, res) => {
+            seen.push(isLoopbackRequest(req));
+            res.end("{}");
+        });
+        assert.equal(await listenOnLocalSocket(server, db), true);
+        assert.equal(lstatSync(path).mode & 0o777, 0o600);
+        assert.equal(readDaemonSocket(db), path);
+        await daemonRequest({ baseUrl: "http://127.0.0.1:1", token: "t", port: "1", socketPath: path }, "/api/status");
+        assert.deepEqual(seen, [true]);
+        await new Promise((r) => server.close(() => r()));
+        assert.equal(existsSync(path), false);
+    });
+    it("takes over a crashed daemon's socket", async () => {
+        const dir = tempDir();
+        crashedSocket(join(dir, "daemon.sock"));
+        const db = fileDb(dir);
+        const server = createHttpServer();
+        assert.equal(await listenOnLocalSocket(server, db), true);
+        await new Promise((r) => server.close(() => r()));
+    });
+    it("leaves anything else at the path alone, and says so", async () => {
+        const dir = tempDir();
+        writeFileSync(join(dir, "daemon.sock"), "mine");
+        const db = fileDb(dir);
+        const lines = [];
+        assert.equal(await listenOnLocalSocket(createHttpServer(), db, (l) => lines.push(l)), false);
+        assert.equal(readFileSync(join(dir, "daemon.sock"), "utf8"), "mine");
+        assert.equal(readDaemonSocket(db), undefined);
+        assert.match(lines[0], /in use or not a socket/);
+    });
+    it("skips a path too long for bind(2)", async () => {
+        let dir = tempDir();
+        while (Buffer.byteLength(join(dir, "daemon.sock")) <= MAX_SOCKET_PATH) {
+            dir = join(dir, "d".repeat(20));
+            mkdirSync(dir);
+        }
+        const db = fileDb(dir);
+        const lines = [];
+        assert.equal(await listenOnLocalSocket(createHttpServer(), db, (l) => lines.push(l)), false);
+        assert.match(lines[0], /too long/);
+    });
+});
+describe("clearStaleSocket", () => {
+    it("frees a path with nothing at it", async () => {
+        assert.equal(await clearStaleSocket(join(tempDir(), "daemon.sock")), true);
+    });
+    it("removes a socket nothing answers on, as a crashed daemon leaves", async () => {
+        const path = crashedSocket();
+        assert.equal(lstatSync(path).isSocket(), true);
+        assert.equal(await clearStaleSocket(path), true);
+        assert.equal(existsSync(path), false);
+    });
+    it("leaves a live socket alone", async () => {
+        const path = join(tempDir(), "daemon.sock");
+        const live = createNetServer((s) => s.end());
+        await new Promise((r) => live.listen(path, r));
+        try {
+            assert.equal(await clearStaleSocket(path), false);
+            assert.equal(existsSync(path), true);
+        }
+        finally {
+            await new Promise((r) => live.close(() => r()));
+        }
+    });
+    it("never touches a file that is not a socket", async () => {
+        const path = join(tempDir(), "daemon.sock");
+        writeFileSync(path, "not a socket");
+        assert.equal(await clearStaleSocket(path), false);
+        assert.equal(existsSync(path), true);
+    });
+});
+describe("a token seen on daemon.sock and on loopback TCP", () => {
+    it("is seen in one place, not flagged as a copy", () => {
+        assert.equal(samePlace(UNIX_SOCKET_SIGHTING, "127.0.0.1"), true);
+        assert.equal(samePlace("::1", UNIX_SOCKET_SIGHTING), true);
+        assert.equal(samePlace(UNIX_SOCKET_SIGHTING, "100.64.0.7"), false);
+    });
+});
+//# sourceMappingURL=daemon-socket.test.js.map

package/dist/test/diagram-arrows.test.js

@@ -0,0 +1,205 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { parseDiagram } from "../diagram/parse.js";
+import { layoutDiagram, projectAttachment, faceOffset } from "../diagram/layout.js";
+import { basisPath } from "../diagram/svg.js";
+// Why these assertions exist.
+//
+// dagre picks an edge's terminal point by intersecting the node's box with the
+// chord from the node's *centre* to the first bend. That chord is diagonal, so
+// the edge is handed a diagonal start and the arrowhead arrives tilted — before
+// any curve is fitted. On the LIVE loop diagram it attaches `Listen ->
+// Interpret` 28px to the left of where the edge is actually heading.
+//
+// Four curve-side fixes were built and measured against it. Every one bought a
+// square arrival by adding inflections, and inflections are what make a diagram
+// read as busy: clamped-tangent Hermite reached 3.3° mean arrival, basis with
+// normal stubs reached 0.0°, and both looked worse than untouched `curveBasis`
+// at 31.4°. Moving the *attachment point* and leaving the curve alone reaches
+// 8.7° with the inflection count unchanged at zero.
+//
+// So the property under test is not "the curve is smooth" — it is "the terminal
+// point lines up with the bend the edge is heading for". That is what these
+// pin, because it is the thing that would silently regress if someone
+// reasonably decided to hand dagre's own points straight to the renderer.
+const LIVE = [
+    "flowchart TD",
+    "    L[Listen] --> I[Interpret]",
+    "    I --> V[Vocalize] & E[Execute]",
+    "    V --> E",
+    "    E --> V",
+    "    V --> L",
+].join("\n");
+function place(src) {
+    const p = parseDiagram(src);
+    assert.equal(p.ok, true);
+    return layoutDiagram(p.ok ? p.ir : undefined);
+}
+const node = (over = {}) => ({
+    id: "N", lines: ["N"], runs: [[{ text: "N" }]], shape: "rect", classes: [],
+    x: 100, y: 100, width: 80, height: 40, ...over,
+});
+describe("faceOffset follows the shape, not the bounding box", () => {
+    it("is flat across a rectangle", () => {
+        assert.equal(faceOffset("rect", 20, 40, 0), 20);
+        assert.equal(faceOffset("rect", 20, 40, 39), 20);
+    });
+    it("falls away linearly on a diamond, so an edge lands on the slope", () => {
+        assert.equal(faceOffset("diamond", 20, 40, 0), 20);
+        assert.equal(faceOffset("diamond", 20, 40, 20), 10);
+        assert.equal(faceOffset("diamond", 20, 40, 40), 0);
+    });
+    it("follows the ellipse on a circle", () => {
+        assert.equal(faceOffset("circle", 20, 40, 0), 20);
+        assert.ok(Math.abs(faceOffset("circle", 20, 40, 40)) < 1e-9);
+        assert.ok(faceOffset("circle", 20, 40, 20) > 17);
+    });
+    it("never returns a negative offset, whatever the lateral overshoot", () => {
+        for (const shape of ["rect", "diamond", "circle", "hexagon"]) {
+            assert.ok(faceOffset(shape, 20, 40, 1000) >= 0, shape);
+        }
+    });
+});
+describe("projectAttachment lines the terminal point up with the bend", () => {
+    it("slides along the face toward the bend", () => {
+        const n = node(); // box 60..140 x 80..120
+        const dagrePoint = { x: 112, y: 120 }; // dagre's chord result
+        const bend = { x: 132, y: 150 }; // where the edge is going
+        const p = projectAttachment(n, dagrePoint, bend);
+        assert.equal(p.y, 120, "stays on the face it was on");
+        assert.equal(p.x, 132, "moves under the bend");
+    });
+    it("holds off the corner rather than hanging an edge from the tip", () => {
+        const n = node();
+        const p = projectAttachment(n, { x: 139, y: 120 }, { x: 400, y: 150 });
+        assert.ok(p.x < 140, "inside the right edge");
+        assert.ok(p.x >= 130, "but not pulled far in");
+    });
+    it("uses the vertical face when that is the one the point sits on", () => {
+        const n = node();
+        const p = projectAttachment(n, { x: 140, y: 104 }, { x: 260, y: 96 });
+        assert.equal(p.x, 140, "stays on the right face");
+        assert.equal(p.y, 96, "moves level with the bend");
+    });
+    it("puts a diamond's attachment on the slope, not floating off it", () => {
+        const n = node({ shape: "diamond" });
+        const p = projectAttachment(n, { x: 100, y: 120 }, { x: 120, y: 160 });
+        // Half-way out along the bottom face of a diamond is half-way up its side.
+        assert.equal(p.x, 120);
+        assert.ok(p.y > 100 && p.y < 120, `expected the slope, got y=${p.y}`);
+    });
+});
+/** The angle, in degrees, between an edge's final direction and the inward
+ *  normal of the face it lands on. 0 is a perfectly square arrival. */
+function arrivalAngle(placed, e) {
+    const dst = placed.nodes.find((n) => n.id === e.to);
+    const end = e.points[e.points.length - 1];
+    const prev = e.points[e.points.length - 2];
+    const dx = end.x - prev.x, dy = end.y - prev.y;
+    const len = Math.hypot(dx, dy) || 1;
+    // Inward normal of the nearest face.
+    const hx = dst.width / 2, hy = dst.height / 2;
+    const cand = [
+        { n: { x: 0, y: 1 }, d: Math.abs(end.y - (dst.y - hy)) },
+        { n: { x: 0, y: -1 }, d: Math.abs(end.y - (dst.y + hy)) },
+        { n: { x: 1, y: 0 }, d: Math.abs(end.x - (dst.x - hx)) },
+        { n: { x: -1, y: 0 }, d: Math.abs(end.x - (dst.x + hx)) },
+    ].sort((a, b) => a.d - b.d)[0].n;
+    const dot = (dx / len) * cand.x + (dy / len) * cand.y;
+    return (Math.acos(Math.max(-1, Math.min(1, dot))) * 180) / Math.PI;
+}
+describe("the LIVE loop diagram, laid out", () => {
+    const placed = place(LIVE);
+    it("places all four nodes and routes all six edges", () => {
+        assert.equal(placed.nodes.length, 4);
+        assert.equal(placed.edges.length, 6);
+        for (const e of placed.edges)
+            assert.ok(e.points.length >= 2, `${e.from}->${e.to}`);
+    });
+    it("gives every edge a finite path inside a finite canvas", () => {
+        assert.ok(placed.width > 0 && Number.isFinite(placed.width));
+        assert.ok(placed.height > 0 && Number.isFinite(placed.height));
+        for (const e of placed.edges) {
+            for (const p of e.points) {
+                assert.ok(Number.isFinite(p.x) && Number.isFinite(p.y), `${e.from}->${e.to}`);
+            }
+        }
+    });
+    it("arrives square on every bent edge", () => {
+        // The measured figure for face-projected attachment on this diagram is
+        // 8.7° mean / 32.6° worst, against dagre's own 31.4° / 52.0°. The bound is
+        // set above the former and well below the latter, so it catches a
+        // regression to raw dagre points without being a brittle pin on a number.
+        const bent = placed.edges.filter((e) => !e.selfLoop && e.points.length > 2);
+        assert.ok(bent.length >= 3, "expected the diagram to have bent edges");
+        const angles = bent.map((e) => arrivalAngle(placed, e));
+        const mean = angles.reduce((a, b) => a + b, 0) / angles.length;
+        assert.ok(mean < 20, `mean arrival ${mean.toFixed(1)}° should be well under dagre's 31.4°`);
+    });
+    it("ends every edge on the boundary of its target, not inside it", () => {
+        for (const e of placed.edges) {
+            if (e.selfLoop)
+                continue;
+            const dst = placed.nodes.find((n) => n.id === e.to);
+            const end = e.points[e.points.length - 1];
+            const inX = Math.abs(end.x - dst.x) < dst.width / 2 - 0.5;
+            const inY = Math.abs(end.y - dst.y) < dst.height / 2 - 0.5;
+            assert.ok(!(inX && inY), `${e.from}->${e.to} ends inside ${e.to}`);
+        }
+    });
+});
+describe("self-loops", () => {
+    // dagre returns a degenerate path for `A --> A`: duplicated points that
+    // double back and start outside the node. It is never given one.
+    const placed = place("flowchart TD\n A --> A\n A --> B");
+    it("draws a loop with real geometry", () => {
+        const loop = placed.edges.find((e) => e.selfLoop);
+        assert.ok(loop, "the self-loop survived layout");
+        assert.ok(loop.points.length >= 4);
+        const xs = new Set(loop.points.map((p) => `${p.x},${p.y}`));
+        assert.equal(xs.size, loop.points.length, "no duplicated points");
+    });
+    it("keeps the loop inside the reported canvas", () => {
+        const loop = placed.edges.find((e) => e.selfLoop);
+        for (const p of loop.points) {
+            assert.ok(p.x <= placed.width && p.y <= placed.height, `loop point ${p.x},${p.y} outside ${placed.width}x${placed.height}`);
+        }
+    });
+});
+describe("basisPath is d3's curveBasis", () => {
+    // Ported rather than depended on — 25 lines against a package — so the
+    // equivalence is worth stating. These expectations come from d3-shape's own
+    // output for the same inputs, including two real corridors dagre produced
+    // for the LIVE loop diagram.
+    it("draws a straight line through two points", () => {
+        assert.equal(basisPath([{ x: 0, y: 0 }, { x: 10, y: 10 }]), "M0,0L10,10");
+    });
+    it("matches d3 on a three-point corridor", () => {
+        // d3-shape emits
+        //   M128,44L132.667,48.167C137.333,52.333,146.667,60.667,151.333,69
+        //          C156,77.333,156,85.667,156,89.833L156,94
+        // for this input. Ours is that to 2dp — coordinates are rounded on the way
+        // out, because a diagram is not measured in thousandths of a pixel and the
+        // saved bytes go into every event that carries a fence.
+        assert.equal(basisPath([{ x: 128, y: 44 }, { x: 156, y: 69 }, { x: 156, y: 94 }]), "M128,44L132.67,48.17C137.33,52.33,146.67,60.67,151.33,69C156,77.33,156,85.67,156,89.83L156,94");
+    });
+    it("matches d3 on a four-point corridor", () => {
+        assert.equal(basisPath([{ x: 160, y: 130 }, { x: 166, y: 155 }, { x: 166, y: 198 }, { x: 134, y: 266 }]), "M160,130L161,134.17C162,138.33,164,146.67,165,158C166,169.33,166,183.67,160.67,202.17" +
+            "C155.33,220.67,144.67,243.33,139.33,254.67L134,266");
+    });
+    it("reaches both endpoints exactly", () => {
+        // A basis spline does *not* pass through its interior control points, and
+        // it is often said not to reach its ends either. d3 duplicates the
+        // terminals, so it does — which is why the tilt this module's layout
+        // corrects was never the curve's fault.
+        const pts = [{ x: 160, y: 130 }, { x: 166, y: 155 }, { x: 166, y: 198 }, { x: 134, y: 266 }];
+        const d = basisPath(pts);
+        assert.ok(d.startsWith("M160,130"), d.slice(0, 20));
+        assert.ok(d.endsWith("L134,266"), d.slice(-20));
+    });
+    it("degrades safely on empty and single-point input", () => {
+        assert.equal(basisPath([]), "");
+        assert.equal(basisPath([{ x: 3, y: 4 }]), "M3,4");
+    });
+});
+//# sourceMappingURL=diagram-arrows.test.js.map