@crewhaus/hangar-ui 0.5.6 → 0.5.8

package/assets/js/views/library.js

@@ -6,7 +6,7 @@
  */
 
 import { api } from "../api.js";
-import { asOf, clear, copyBtn, dot, el, emptyState, skeleton, toast } from "../dom.js";
+import { asOf, clear, copyBtn, dot, el, emptyState, skeleton, toast, withTip } from "../dom.js";
 import { hrefHarness } from "../router.js";
 import { shapeAccent, shapeLabel } from "../shapes.js";
 import { procStatePill } from "../supervision.js";
@@ -27,7 +27,8 @@ import { renderOnboarding, shouldOnboard } from "./onboarding.js";
 const state = {
   sortKey: "name",
   sortDir: "asc",
-  filter: { kind: "all" }, // {kind:"all"} | {kind:"group",name} | {kind:"smart",id}
+  // {kind:"all"} | {kind:"group",name} | {kind:"smart",id} | {kind:"hidden"}
+  filter: { kind: "all" },
   query: "",
 };
 
@@ -122,13 +123,19 @@ function normalizeGroups(payload, rows) {
 }
 
 function applyFilter(rows, nowMs) {
-  let out = rows;
+  // Hidden rows are curation, not data loss: they stay registered but stay
+  // OUT of every view except the explicit Hidden bucket — "don't show all
+  // harnesses unless added".
+  let out =
+    state.filter.kind === "hidden"
+      ? rows.filter((r) => r.hidden === true)
+      : rows.filter((r) => r.hidden !== true);
   if (state.filter.kind === "group") {
     const name = state.filter.name;
     out = out.filter((r) => r.groups.includes(name));
   } else if (state.filter.kind === "smart") {
     const smart = deriveSmartGroups(rows, nowMs).find((g) => g.id === state.filter.id);
-    out = smart ? smart.rows : [];
+    out = smart ? smart.rows.filter((r) => r.hidden !== true) : [];
   }
   if (state.query !== "") {
     const q = state.query.toLowerCase();
@@ -200,16 +207,28 @@ function renderRail(rows, groups, nowMs, redraw, reload) {
     );
     return btn;
   };
+  const hiddenCount = rows.filter((r) => r.hidden === true).length;
   rail.appendChild(
-    item("All harnesses", rows.length, state.filter.kind === "all", null, () => {
+    item("All harnesses", rows.length - hiddenCount, state.filter.kind === "all", null, () => {
       state.filter = { kind: "all" };
       redraw();
     }),
   );
+  // The curated-out entries get their own bucket rather than vanishing:
+  // hiding is reversible, and a bucket with a count is how you find them.
+  if (hiddenCount > 0) {
+    rail.appendChild(
+      item("Hidden", hiddenCount, state.filter.kind === "hidden", null, () => {
+        state.filter = { kind: "hidden" };
+        redraw();
+      }),
+    );
+  }
 
+  const shown = rows.filter((r) => r.hidden !== true);
   if (groups.length > 0) rail.appendChild(el("div", { class: "rail-head", text: "Groups" }));
   for (const g of groups) {
-    const count = rows.filter((r) => r.groups.includes(g.name)).length;
+    const count = shown.filter((r) => r.groups.includes(g.name)).length;
     const active = state.filter.kind === "group" && state.filter.name === g.name;
     rail.appendChild(
       item(g.name, count, active, g.color || null, () => {
@@ -229,7 +248,7 @@ function renderRail(rows, groups, nowMs, redraw, reload) {
   rail.appendChild(newBtn);
 
   rail.appendChild(el("div", { class: "rail-head", text: "Smart groups" }));
-  for (const g of deriveSmartGroups(rows, nowMs)) {
+  for (const g of deriveSmartGroups(shown, nowMs)) {
     const active = state.filter.kind === "smart" && state.filter.id === g.id;
     rail.appendChild(
       item(g.label, g.rows.length, active, null, () => {
@@ -307,10 +326,104 @@ function renderToolbar(reload) {
     dirInput.focus();
   };
 
-  const scanBtn = el("button", { class: "btn", type: "button", text: "Scan" });
+  const findBtn = withTip(
+    el("button", { class: "btn", type: "button", text: "Find harnesses…" }),
+    "Discovery WITHOUT registration: walks the scan roots and lists the harnesses that are not yet added, each one an Add away — the Library only shows what you add.",
+  );
+  const scanBtn = withTip(
+    el("button", { class: "btn btn-ghost", type: "button", text: "Scan (add all)" }),
+    "The bulk fallback: registers EVERY harness found under the scan roots. Prefer Find harnesses to pick which ones join the Library.",
+  );
   const rootBtn = el("button", { class: "btn", type: "button", text: "Add scan root…" });
-  const addBtn = el("button", { class: "btn", type: "button", text: "Add harness…" });
-  const bar = el("div", { class: "toolbar" }, [search, scanBtn, rootBtn, addBtn]);
+  const addBtn = withTip(
+    el("button", { class: "btn btn-primary", type: "button", text: "Add harness…" }),
+    "Register one harness by its directory — the default gesture.",
+  );
+  const bar = el("div", { class: "toolbar" }, [search, addBtn, findBtn, rootBtn, scanBtn]);
+
+  // The find panel: candidates from GET /api/registry/discover, each with an
+  // Add. Only one open at a time, sharing the openedForm slot with the two
+  // dir forms.
+  findBtn.addEventListener("click", async () => {
+    if (openedForm !== null) openedForm.remove();
+    findBtn.disabled = true;
+    let found = null;
+    try {
+      found = await api.discover();
+    } catch (err) {
+      toast(`Find failed: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      findBtn.disabled = false;
+    }
+    if (found === null) return;
+    const panel = el("div", { class: "card" });
+    const candidates = Array.isArray(found.candidates) ? found.candidates : [];
+    if (found.roots === 0) {
+      toast("No scan roots configured — add one and discovery can search this machine", "info");
+      panel.remove();
+      rootBtn.click();
+      return;
+    }
+    panel.appendChild(
+      el("div", { class: "rollup" }, [
+        el("strong", {
+          text: `Found ${candidates.length} unregistered harness${candidates.length === 1 ? "" : "es"}`,
+        }),
+        el("span", {
+          class: "muted",
+          text: ` under ${found.roots} scan root${found.roots === 1 ? "" : "s"} (${Number(found.alreadyRegistered ?? 0)} already added)`,
+        }),
+        el("button", {
+          class: "btn btn-ghost",
+          type: "button",
+          text: "Close",
+          onClick: () => panel.remove(),
+        }),
+      ]),
+    );
+    if (candidates.length === 0) {
+      panel.appendChild(emptyState(String(found.note ?? "Nothing new under the scan roots")));
+    }
+    for (const candidate of candidates) {
+      const addOne = el("button", { class: "btn btn-primary", type: "button", text: "Add" });
+      addOne.addEventListener("click", () => {
+        addOne.disabled = true;
+        tryWrite("Add harness", () => api.addHarness(candidate.dir), reload);
+      });
+      panel.appendChild(
+        el("div", { class: "find-row" }, [
+          el("strong", { text: String(candidate.specName ?? "") }),
+          el("span", { class: "chip", text: String(candidate.target ?? "unknown") }),
+          el("span", {
+            class: "mono muted",
+            title: String(candidate.dir ?? ""),
+            text: String(candidate.dir ?? ""),
+          }),
+          addOne,
+        ]),
+      );
+    }
+    if (candidates.length > 1) {
+      const addAll = el("button", {
+        class: "btn",
+        type: "button",
+        text: `Add all ${candidates.length}`,
+      });
+      addAll.addEventListener("click", () => {
+        addAll.disabled = true;
+        tryWrite(
+          "Add all",
+          async () => {
+            for (const candidate of candidates) await api.addHarness(candidate.dir);
+          },
+          reload,
+        );
+      });
+      panel.appendChild(el("div", { class: "missing-actions" }, [addAll]));
+    }
+    bar.after(panel);
+    openedForm = panel;
+  });
 
   scanBtn.addEventListener("click", async () => {
     scanBtn.disabled = true;
@@ -567,9 +680,21 @@ function editorRow(row, groups, reload) {
     cb.checked = row.groups.includes(g.name);
     return { name: g.name, cb };
   });
+  const hiddenCb = el("input", { type: "checkbox", "aria-label": "hide from the library" });
+  hiddenCb.checked = row.hidden === true;
   const form = el("form", { class: "row-editor" }, [
     el("label", { class: "field" }, [el("span", { text: "Tags" }), tags]),
     el("label", { class: "field" }, [el("span", { text: "Notes" }), notes]),
+    el("div", { class: "field" }, [
+      el("span", { text: "Visibility" }),
+      withTip(
+        el("label", { class: "check" }, [
+          hiddenCb,
+          el("span", { text: "Hidden — keep registered, out of the default view" }),
+        ]),
+        "Hiding is curation, not removal: state, groups and history survive, and the Hidden bucket in the rail lists it until you bring it back.",
+      ),
+    ]),
     el("div", { class: "field" }, [
       el("span", { text: groups.length > 0 ? "Groups" : "Groups (none defined yet)" }),
       el(
@@ -589,13 +714,16 @@ function editorRow(row, groups, reload) {
       .map((t) => t.trim())
       .filter((t) => t !== "");
     const groupList = checks.filter((c) => c.cb.checked).map((c) => c.name);
-    // The server's registry writes are per-field PUTs; save all three.
+    // The server's registry writes are per-field PUTs; save all four.
     tryWrite(
       "Save",
       async () => {
         await api.setTags(row.id, tagList);
         await api.setNotes(row.id, notes.value);
         await api.setGroups(row.id, groupList);
+        if (hiddenCb.checked !== (row.hidden === true)) {
+          await api.setHidden(row.id, hiddenCb.checked);
+        }
       },
       reload,
     );

package/dist/embed-suite.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/embed-suite.js

@@ -0,0 +1,289 @@
+/**
+ * The embed-map completeness + asset-hygiene suite.
+ *
+ * DELIBERATELY NOT NAMED `*.test.ts`: this suite must run in its OWN
+ * process (`bun test ./src/embed-suite.ts`, the second half of the package
+ * test script). Importing `./index` loads every asset file as TEXT
+ * (`with { type: "text" }`), and bun's module registry keys a module by
+ * path alone — the import attribute is not part of the key — so in a
+ * process that ALSO imports an asset as an ES module (every view test),
+ * whichever load happens first poisons the other: the ESM side dies with
+ * "Export not found", or this side with "Missing 'default' export",
+ * depending on nothing but file order. Two processes, two registries, no
+ * collision — and `bun test src` skips this file because the name is off
+ * the test glob.
+ */
+import { describe, expect, test } from "bun:test";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { CONTENT_TYPES, contentTypeFor, hangarAssets } from "./index";
+const ASSETS_DIR = join(import.meta.dir, "..", "assets");
+/** Walk assets/ and return every file's path relative to it (posix slashes). */
+function walkAssets(dir = ASSETS_DIR, prefix = "") {
+    const out = [];
+    for (const name of readdirSync(dir).sort()) {
+        const full = join(dir, name);
+        const rel = prefix === "" ? name : `${prefix}/${name}`;
+        if (statSync(full).isDirectory())
+            out.push(...walkAssets(full, rel));
+        else
+            out.push(rel);
+    }
+    return out;
+}
+/** The serve path an asset file is expected to appear under. */
+function servePathFor(rel) {
+    return rel === "index.html" ? "/" : `/assets/${rel}`;
+}
+describe("embed map completeness", () => {
+    const files = walkAssets();
+    test("assets tree is non-trivial", () => {
+        expect(files.length).toBeGreaterThanOrEqual(10);
+        expect(files).toContain("index.html");
+        expect(files).toContain("hangar.css");
+        expect(files).toContain("js/app.js");
+    });
+    test("every M2 screen ships as an embedded module with the js content type", () => {
+        const m2 = [
+            "/assets/js/supervision.js",
+            "/assets/js/views/proc.js",
+            "/assets/js/views/runs.js",
+            "/assets/js/views/control.js",
+            "/assets/js/views/schedulers.js",
+            "/assets/js/views/approvals.js",
+            "/assets/js/views/review.js",
+            "/assets/js/views/inbox.js",
+            "/assets/js/views/activity.js",
+            "/assets/js/views/jobs.js",
+            "/assets/js/views/deploy.js",
+        ];
+        for (const key of m2) {
+            const entry = hangarAssets[key];
+            expect(`${key}:${entry !== undefined}`).toBe(`${key}:true`);
+            expect(`${key}:${entry?.contentType}`).toBe(`${key}:text/javascript; charset=utf-8`);
+            expect(`${key}:${(entry?.body.length ?? 0) > 0}`).toBe(`${key}:true`);
+        }
+    });
+    test("every M3 area ships a view module (one per implementer area)", () => {
+        const m3 = [
+            "/assets/js/views/spec-edit.js",
+            "/assets/js/views/memory-fabric.js",
+            "/assets/js/views/evals-lab.js",
+            "/assets/js/views/data.js",
+            "/assets/js/views/feedback.js",
+            "/assets/js/views/creds.js",
+            "/assets/js/views/channels.js",
+            "/assets/js/views/security.js",
+            "/assets/js/views/thredz.js",
+            "/assets/js/views/inspect.js",
+            "/assets/js/views/runtime.js",
+        ];
+        for (const key of m3) {
+            const entry = hangarAssets[key];
+            expect(`${key}:${entry !== undefined}`).toBe(`${key}:true`);
+            expect(`${key}:${entry?.contentType}`).toBe(`${key}:text/javascript; charset=utf-8`);
+            expect(`${key}:${(entry?.body.length ?? 0) > 0}`).toBe(`${key}:true`);
+        }
+    });
+    test("every file under assets/ is embedded under its serve path with exact bytes", () => {
+        for (const rel of files) {
+            const key = servePathFor(rel);
+            const entry = hangarAssets[key];
+            expect(entry).toBeDefined();
+            const onDisk = readFileSync(join(ASSETS_DIR, rel), "utf8");
+            expect(entry?.body).toBe(onDisk);
+        }
+    });
+    test("the map holds nothing that is not on disk (no stale keys)", () => {
+        const expected = files.map(servePathFor).sort();
+        expect(Object.keys(hangarAssets).sort()).toEqual(expected);
+    });
+    test("content types are right per extension", () => {
+        expect(hangarAssets["/"]?.contentType).toBe("text/html; charset=utf-8");
+        expect(hangarAssets["/assets/hangar.css"]?.contentType).toBe("text/css; charset=utf-8");
+        for (const [key, entry] of Object.entries(hangarAssets)) {
+            if (key.endsWith(".js"))
+                expect(entry.contentType).toBe("text/javascript; charset=utf-8");
+        }
+    });
+    test("every body is non-empty", () => {
+        for (const entry of Object.values(hangarAssets)) {
+            expect(entry.body.length).toBeGreaterThan(0);
+        }
+    });
+});
+describe("contentTypeFor", () => {
+    test("known extensions", () => {
+        expect(contentTypeFor("/assets/js/app.js")).toBe("text/javascript; charset=utf-8");
+        expect(contentTypeFor("x.css")).toBe("text/css; charset=utf-8");
+        expect(contentTypeFor("index.html")).toBe("text/html; charset=utf-8");
+        expect(contentTypeFor("a.svg")).toBe("image/svg+xml");
+    });
+    test("unknown/none falls back to octet-stream", () => {
+        expect(contentTypeFor("noext")).toBe("application/octet-stream");
+        expect(contentTypeFor("weird.wasm")).toBe("application/octet-stream");
+    });
+    test("CONTENT_TYPES covers every embedded extension", () => {
+        for (const key of Object.keys(hangarAssets)) {
+            if (key === "/")
+                continue;
+            const dot = key.lastIndexOf(".");
+            expect(dot).toBeGreaterThan(0);
+            expect(CONTENT_TYPES[key.slice(dot)]).toBeDefined();
+        }
+    });
+});
+describe("shell wiring", () => {
+    test("index.html references the stylesheet and the module entry by serve path", () => {
+        const html = hangarAssets["/"]?.body ?? "";
+        expect(html).toContain('href="/assets/hangar.css"');
+        expect(html).toContain('src="/assets/js/app.js"');
+        expect(html).toContain('type="module"');
+    });
+    test("index.html defaults to the dark theme", () => {
+        expect(hangarAssets["/"]?.body ?? "").toContain('data-theme="dark"');
+    });
+});
+describe("js module hygiene", () => {
+    const jsEntries = Object.entries(hangarAssets).filter(([key]) => key.endsWith(".js"));
+    test("every js asset parses as a valid module (zero-build means no compile step to catch this)", () => {
+        const transpiler = new Bun.Transpiler({ loader: "js" });
+        for (const [key, entry] of jsEntries) {
+            let failed = "";
+            try {
+                transpiler.transformSync(entry.body);
+            }
+            catch (err) {
+                failed = `${key}: ${err instanceof Error ? err.message : String(err)}`;
+            }
+            expect(failed).toBe("");
+        }
+    });
+    test("no innerHTML anywhere (injection-safe DOM building only)", () => {
+        for (const [key, entry] of jsEntries) {
+            expect(`${key}:${entry.body.includes("innerHTML")}`).toBe(`${key}:false`);
+        }
+    });
+    test("no markup-string assignment of any kind (the ban is wider than innerHTML)", () => {
+        // Built from parts so this test file cannot itself trip a scanner.
+        const banned = [
+            "outer" + "HTML",
+            "insertAdjacent" + "HTML",
+            "document." + "write",
+            "createContextual" + "Fragment",
+        ];
+        for (const [key, entry] of jsEntries) {
+            for (const needle of banned) {
+                expect(`${key}:${needle}:${entry.body.includes(needle)}`).toBe(`${key}:${needle}:false`);
+            }
+        }
+    });
+    test("srcdoc appears in exactly one module, and only alongside a sandbox", () => {
+        // M4 (HM-179) introduces the ONE deliberate exception to the
+        // markup-string ban: a plugin pane's document is handed to an iframe via
+        // `srcdoc`. That is safe precisely because the string never joins THIS
+        // document — the frame gets an opaque origin (no `allow-same-origin`)
+        // and a CSP. Both halves are load-bearing, so the exception is pinned to
+        // one file and to the presence of the sandbox attribute beside it; a
+        // second module reaching for `srcdoc` fails here.
+        const users = jsEntries
+            .filter(([, entry]) => entry.body.includes("srcdoc"))
+            .map(([key]) => key);
+        expect(users).toEqual(["/assets/js/views/panes.js"]);
+        const panes = hangarAssets["/assets/js/views/panes.js"]?.body ?? "";
+        expect(panes).toContain("sandbox:");
+        // …and it is the ONLY module allowed to build an iframe at all: the
+        // sandbox is what makes the exception safe, so a frame appearing
+        // elsewhere would be one nobody had to think about.
+        const frames = jsEntries
+            .filter(([, entry]) => entry.body.includes('el("iframe"'))
+            .map(([key]) => key);
+        expect(frames).toEqual(["/assets/js/views/panes.js"]);
+        // The sandbox token list itself (never `allow-same-origin` alongside
+        // `allow-scripts`) is proven behaviourally in `m4-views.test.ts`, where
+        // `paneSandbox` is called with a payload that tries to widen it.
+    });
+    test("no module hardcodes a `harness scan-root` verb (the CLI has none)", () => {
+        // The console's CLI twins are its trust affordance: a command shown
+        // beside a button has to be one a terminal accepts. `crewhaus harness`
+        // takes list|show|add|remove|relocate|group|tag|pin|scan|preflight — a
+        // scan root is added by `harness scan --root <dir>`, which remembers the
+        // root before it walks it. A twin nobody can paste teaches the opposite
+        // of what the discipline is for, and the first-boot screen is where an
+        // operator learns whether to believe them.
+        for (const [key, entry] of jsEntries) {
+            expect(`${key}:${entry.body.includes("scan-root add")}`).toBe(`${key}:false`);
+        }
+    });
+    test("the evaluating notifications GET has exactly one caller, and the app runs it", () => {
+        // `GET /api/notifications` IS the rules evaluation (HM-183: the manager
+        // runs no timer). Every delivery it returns is added to the server's
+        // dedupe set and never returned again — so a second caller does not read
+        // the same state, it CONSUMES it, and the toast for whatever it ate can
+        // never appear again in that manager process. One caller, therefore, and
+        // every screen that needs the state goes through it.
+        const callers = jsEntries
+            .filter(([, entry]) => entry.body.includes("api.notifications("))
+            .map(([key]) => key);
+        expect(callers).toEqual(["/assets/js/notify.js"]);
+        // …and the app must actually START that loop: a poll nobody runs is the
+        // boot-time read this whole arrangement exists to replace.
+        expect(hangarAssets["/assets/js/app.js"]?.body ?? "").toContain("notifications.start()");
+    });
+    test("every relative import resolves to another embedded asset (import-graph closure)", () => {
+        const importRe = /import\s+[^"']*?["']([^"']+)["']/g;
+        for (const [key, entry] of jsEntries) {
+            const dir = key.slice(0, key.lastIndexOf("/"));
+            for (const match of entry.body.matchAll(importRe)) {
+                const spec = match[1] ?? "";
+                expect(spec.startsWith("./") || spec.startsWith("../")).toBe(true);
+                const resolved = resolvePosix(dir, spec);
+                expect(hangarAssets[resolved]).toBeDefined();
+            }
+        }
+    });
+    test("no orphaned module is shipped (every js asset is reachable from the shell entry)", () => {
+        // R-20: `pending.js` — the stub-era "not built yet" screen — outlived its
+        // last importer and was still embedded, served over HTTP and compiled
+        // into the single-binary CLI, with a docblock telling readers that
+        // eleven live screens "have no data behind them yet". A dead module in a
+        // zero-build tree has nothing to catch it: the transpiler, the
+        // completeness check and the import-graph closure above all pass on code
+        // nobody imports. Reachability is the check that does not.
+        const entry = "/assets/js/app.js";
+        const importRe = /import\s+[^"']*?["']([^"']+)["']/g;
+        const seen = new Set([entry]);
+        const queue = [entry];
+        while (queue.length > 0) {
+            const key = queue.pop();
+            const body = hangarAssets[key]?.body ?? "";
+            const dir = key.slice(0, key.lastIndexOf("/"));
+            for (const match of body.matchAll(importRe)) {
+                const resolved = resolvePosix(dir, match[1] ?? "");
+                if (seen.has(resolved))
+                    continue;
+                seen.add(resolved);
+                queue.push(resolved);
+            }
+        }
+        const orphans = jsEntries.map(([key]) => key).filter((key) => !seen.has(key));
+        expect(orphans).toEqual([]);
+    });
+    test("browser modules never import bun/node builtins", () => {
+        for (const [key, entry] of jsEntries) {
+            expect(`${key}:${/from\s+["'](?:bun|node:)/.test(entry.body)}`).toBe(`${key}:false`);
+        }
+    });
+});
+function resolvePosix(fromDir, spec) {
+    const parts = fromDir.split("/").filter((p) => p !== "");
+    for (const seg of spec.split("/")) {
+        if (seg === "" || seg === ".")
+            continue;
+        if (seg === "..")
+            parts.pop();
+        else
+            parts.push(seg);
+    }
+    return `/${parts.join("/")}`;
+}

package/dist/index.js

@@ -37,6 +37,7 @@ import shapesJs from "../assets/js/shapes.js" with { type: "text" };
 import supervisionJs from "../assets/js/supervision.js" with { type: "text" };
 import utilJs from "../assets/js/util.js" with { type: "text" };
 import activityViewJs from "../assets/js/views/activity.js" with { type: "text" };
+import advisorViewJs from "../assets/js/views/advisor.js" with { type: "text" };
 import approvalsViewJs from "../assets/js/views/approvals.js" with { type: "text" };
 import channelsViewJs from "../assets/js/views/channels.js" with { type: "text" };
 import controlViewJs from "../assets/js/views/control.js" with { type: "text" };
@@ -110,6 +111,7 @@ export const hangarAssets = {
     "/assets/js/supervision.js": asset(supervisionJs, "supervision.js"),
     "/assets/js/util.js": asset(utilJs, "util.js"),
     "/assets/js/views/activity.js": asset(activityViewJs, "activity.js"),
+    "/assets/js/views/advisor.js": asset(advisorViewJs, "advisor.js"),
     "/assets/js/views/approvals.js": asset(approvalsViewJs, "approvals.js"),
     "/assets/js/views/channels.js": asset(channelsViewJs, "channels.js"),
     "/assets/js/views/control.js": asset(controlViewJs, "control.js"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewhaus/hangar-ui",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "type": "module",
   "description": "The Hangar web console's static UI — zero-build, dependency-free browser ES modules embedded as text assets for the single-binary CLI to hand to the hangar server",
   "main": "dist/index.js",
@@ -12,7 +12,7 @@
     }
   },
   "scripts": {
-    "test": "bun test src"
+    "test": "bun test src && bun test ./src/embed-suite.ts"
   },
   "license": "Apache-2.0",
   "author": {