@loadbare/app 0.6.0 → 0.7.0

package/dist/tests/helpers/hub.js

@@ -1,151 +0,0 @@
-/**
- * A window for tier 4 — see docs/testing.md.
- *
- * Tier 3 needed no globals: the landing code is handed a root and calls
- * methods on it. The hub is the opposite. It extends `HTMLElement`, it
- * registers itself with `customElements` when its module loads, and it
- * reaches `document`, `history` and `location` on its own. So the window has
- * to exist before the module does, which is why the hub is imported
- * dynamically, after `installWindow()` has run:
- *
- *     installWindow();
- *     await import("../hub/lb-hub.browser");
- *
- * One window per test file, since registration is global and permanent.
- *
- * Two things the hub reaches for do not exist in jsdom 25 and are supplied
- * here. `fetch` is absent, and a scripted one is what a test wants in any
- * case. `HTMLDialogElement.showModal` is absent, so it is recorded rather
- * than performed. Everything else — `history.pushState`, `popstate`, event
- * delegation, form controls — is jsdom's own.
- */
-import { JSDOM, VirtualConsole } from "jsdom";
-/** The globals the hub reaches for as it loads and runs. */
-const GLOBALS = [
-    "window",
-    "document",
-    "customElements",
-    "HTMLElement",
-    "HTMLFormElement",
-    "HTMLInputElement",
-    "HTMLSelectElement",
-    "HTMLTextAreaElement",
-    "HTMLTemplateElement",
-    "HTMLDialogElement",
-    "HTMLAnchorElement",
-    "Element",
-    "Node",
-    "Event",
-    "CustomEvent",
-    "MouseEvent",
-    "DocumentFragment",
-    "history",
-    "location",
-];
-/** The scripted server every test in a file shares. */
-export const server = { sent: [], answer: {} };
-export function installWindow() {
-    // jsdom reports a real anchor's navigation as an unimplemented feature.
-    // That is the point of the test that clicks one — the hub left it to the
-    // browser — so the complaint is dropped rather than printed.
-    const quiet = new VirtualConsole();
-    quiet.sendTo(console, { omitJSDOMErrors: true });
-    const { window } = new JSDOM(`<!doctype html><body></body>`, {
-        url: "http://localhost/",
-        virtualConsole: quiet,
-    });
-    for (const name of GLOBALS) {
-        globalThis[name] = window[name];
-    }
-    // The hub registers `popstate` on the global rather than on a window it
-    // was handed, so the global's listener registry has to be the window's.
-    globalThis.addEventListener = window.addEventListener.bind(window);
-    globalThis.removeEventListener = window.removeEventListener.bind(window);
-    // Recorded, not performed: jsdom has <dialog> but none of its behavior.
-    // The hub only ever asks whether it is open and opens it, so that pair is
-    // the whole of what a test needs.
-    const dialog = window.HTMLDialogElement.prototype;
-    dialog.showModal = function () {
-        this.setAttribute("open", "");
-    };
-    dialog.close = function () {
-        this.removeAttribute("open");
-    };
-    server.sent = [];
-    server.answer = {};
-    delete server.fail;
-    globalThis.fetch = (async (url, init) => {
-        server.sent.push({
-            page: new URL(url, "http://localhost/").searchParams.get("page") ?? "",
-            request: JSON.parse(init.body),
-        });
-        if (server.fail)
-            throw new Error(server.fail);
-        return {
-            ok: true,
-            json: async () => server.answer,
-        };
-    });
-}
-/**
- * Put a built document in place and hand back the hub in it.
- *
- * `pages` are the page hosts the builder would have written, keyed by stub —
- * see build/assemble.ts. `chrome` is what goes inside `<lb-hub>` beside
- * `<main>`. `path` is where the browser is when the hub connects, and it is
- * reset for every mount so no test inherits where the last one navigated to.
- *
- * Connecting the hub is what runs `connectedCallback`, and that navigates,
- * so the caller awaits the first round trip before asserting.
- */
-export async function mountHub(chrome, pages = { index: "" }, path = "/") {
-    history.replaceState(null, "", path);
-    const hosts = Object.entries(pages)
-        .map(([name, html]) => `<template lb-page="${name}">${html}</template>`)
-        .join("");
-    document.body.innerHTML = `<lb-hub><main></main>${chrome}</lb-hub>${hosts}`;
-    await settle();
-    return document.body.firstElementChild;
-}
-/**
- * Let the hub's pending round trip finish.
- *
- * `navigate` is async and nothing hands a test its promise, so a test waits
- * on the microtask queue the way the page does. Two turns: one for the fetch
- * and one for reading its body.
- */
-export async function settle() {
-    for (let i = 0; i < 4; i++)
-        await Promise.resolve();
-    await new Promise((r) => setTimeout(r, 0));
-}
-/**
- * Step back and let the hub answer.
- *
- * `history.back()` is queued rather than synchronous, so a test waits for
- * the `popstate` the hub is listening for and then for the round trip it
- * starts.
- */
-export async function back() {
-    const stepped = new Promise((resolve) => {
-        globalThis.addEventListener("popstate", () => resolve(), { once: true });
-    });
-    history.back();
-    await stepped;
-    await settle();
-}
-/** Fire the event a person's click fires. */
-export async function click(el) {
-    el.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
-    await settle();
-}
-/** Fire the event a form's submit fires. */
-export async function submit(form) {
-    form.dispatchEvent(new Event("submit", { bubbles: true, cancelable: true }));
-    await settle();
-}
-/** Dispatch a request the way a widget does. */
-export async function send(el, detail) {
-    el.dispatchEvent(new CustomEvent("lb-request", { bubbles: true, detail }));
-    await settle();
-}

package/dist/tests/lb-apply.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * Landing data on a live host — see docs/testing.md, tier 3.
- *
- * hub/lb-apply.ts is pure DOM: no fetch, no widget upgrade, no history.
- * jsdom is real evidence for it, which is not true one file further on.
- */
-export {};
-//# sourceMappingURL=lb-apply.test.d.ts.map

package/dist/tests/lb-apply.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lb-apply.test.d.ts","sourceRoot":"","sources":["../../tests/lb-apply.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/tests/lb-apply.test.js

@@ -1,177 +0,0 @@
-/**
- * Landing data on a live host — see docs/testing.md, tier 3.
- *
- * hub/lb-apply.ts is pure DOM: no fetch, no widget upgrade, no history.
- * jsdom is real evidence for it, which is not true one file further on.
- */
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { applyData, applyRow } from "../hub/lb-apply";
-import { body, one } from "./helpers/dom";
-import { captured } from "./helpers/console";
-// --- One row into one scope ---------------------------------------------
-describe("applyRow", () => {
-    it("gives a native element its value as text", () => {
-        const scope = one(`<div><span lb-cell="name"></span></div>`);
-        applyRow(scope, { name: "Ada" });
-        assert.equal(scope.querySelector("span").textContent, "Ada");
-    });
-    it("gives a widget its value as an attribute", () => {
-        // A custom element owns whatever control it wraps, so it receives the
-        // value and renders it itself. The test is lexical — a hyphen in the tag
-        // name — and the hub holds no knowledge of any particular element.
-        const scope = one(`<div><lb-input lb-cell="name"></lb-input></div>`);
-        applyRow(scope, { name: "Ada" });
-        const widget = scope.querySelector("lb-input");
-        assert.equal(widget.getAttribute("lb-value"), "Ada");
-        assert.equal(widget.textContent, "", "the widget's children are its own");
-    });
-    it("counts the root as a cell when it carries one", () => {
-        // <option>'s content model is text, so an option row has to be the cell
-        // it displays. Requiring a wrapper would require an element HTML does
-        // not allow.
-        const scope = one(`<option lb-cell="name"></option>`);
-        applyRow(scope, { name: "Ada" });
-        assert.equal(scope.textContent, "Ada");
-    });
-    it("fills every element naming the same cell", () => {
-        const scope = one(`<div><b lb-cell="name"></b><i lb-cell="name"></i></div>`);
-        applyRow(scope, { name: "Ada" });
-        assert.equal(scope.querySelector("b").textContent, "Ada");
-        assert.equal(scope.querySelector("i").textContent, "Ada");
-    });
-    it("empties a native root that is a cell, children and all", () => {
-        // A root that is a cell is a leaf, and a native one lands its value as
-        // text — so the children go, because setting textContent is what
-        // replacing an element's content means.
-        //
-        // The case this is for cannot hit it: <option> is a leaf by content
-        // model. But nothing stops an author writing a cell on a <tr> that has
-        // cells inside it, and this is what they would get.
-        const scope = body(`<table><tbody><tr lb-cell="line"><td lb-cell="amount"></td></tr></tbody></table>`).querySelector("tr");
-        applyRow(scope, { line: "Total", amount: "10" });
-        assert.equal(scope.textContent, "Total");
-        assert.equal(scope.children.length, 0, "the amount cell is gone");
-    });
-    it("keeps the children of a widget root that is a cell", () => {
-        // The same shape with a hyphen in the tag name is unharmed, because a
-        // widget receives its value as an attribute and renders it itself. The
-        // asymmetry follows from what a cell means on each kind of element.
-        const scope = one(`<lb-input lb-cell="line"><input /></lb-input>`);
-        applyRow(scope, { line: "Total" });
-        assert.equal(scope.getAttribute("lb-value"), "Total");
-        assert.equal(scope.children.length, 1);
-    });
-    it("leaves a cell the row did not name alone", () => {
-        const scope = one(`<div><span lb-cell="name">Ada</span><span lb-cell="role">lead</span></div>`);
-        applyRow(scope, { role: "staff" });
-        assert.equal(scope.querySelector(`[lb-cell="name"]`).textContent, "Ada");
-        assert.equal(scope.querySelector(`[lb-cell="role"]`).textContent, "staff");
-    });
-    it("says nothing about a cell with nowhere to land", () => {
-        const scope = one(`<div><span lb-cell="name"></span></div>`);
-        assert.doesNotThrow(() => applyRow(scope, { absent: "x" }));
-    });
-    it("lands a value as text, so data cannot become markup", () => {
-        // The same guarantee expansion makes at build time, made here at run
-        // time and by the same means: the DOM API rather than a string.
-        const scope = one(`<div><span lb-cell="name"></span></div>`);
-        applyRow(scope, { name: `<img src=x onerror=alert(1)>` });
-        assert.equal(scope.querySelectorAll("img").length, 0);
-        assert.equal(scope.querySelector("span").textContent, `<img src=x onerror=alert(1)>`);
-    });
-    it("lands the empty string as the empty string", () => {
-        const scope = one(`<div><span lb-cell="name">Ada</span></div>`);
-        applyRow(scope, { name: "" });
-        assert.equal(scope.querySelector("span").textContent, "");
-    });
-});
-// --- A whole response ----------------------------------------------------
-describe("applyData", () => {
-    it("lands each result in the scope its name binds", () => {
-        const root = body(`<div lb-row="greeting"><span lb-cell="text"></span></div>` +
-            `<div lb-row="count"><span lb-cell="n"></span></div>`);
-        applyData(root, { greeting: { text: "hello" }, count: { n: "3" } });
-        assert.equal(root.querySelector(`[lb-row="greeting"] span`).textContent, "hello");
-        assert.equal(root.querySelector(`[lb-row="count"] span`).textContent, "3");
-    });
-    it("fills every scope naming the same name", () => {
-        // One name shown in two places: the hub resolves by name and does not
-        // care how many places asked.
-        const root = body(`<div lb-row="total"><span lb-cell="n"></span></div>` +
-            `<p lb-row="total"><span lb-cell="n"></span></p>`);
-        applyData(root, { total: { n: "7" } });
-        for (const el of root.querySelectorAll("span")) {
-            assert.equal(el.textContent, "7");
-        }
-    });
-    it("reports a name with no scope, and lands the rest anyway", async () => {
-        const root = body(`<div lb-row="count"><span lb-cell="n"></span></div>`);
-        const { warn } = await captured(() => applyData(root, { ghost: { x: "1" }, count: { n: "3" } }));
-        assert.match(warn.join("\n"), /no scope for 'ghost', skipping/);
-        assert.equal(root.querySelector("span").textContent, "3");
-    });
-    it("reconciles a list scope, with no widget in it at all", () => {
-        // The repeater widget is gone: a plain element carrying lb-list and a
-        // row template inside it is the whole of a list.
-        const root = body(`<ul lb-list="members">` +
-            `<template lb-key="id"><li lb-cell="name"></li></template>` +
-            `</ul>`);
-        applyData(root, {
-            members: [
-                { id: "1", name: "Ada" },
-                { id: "2", name: "Bab" },
-            ],
-        });
-        assert.deepEqual([...root.querySelectorAll("li")].map((el) => el.textContent), ["Ada", "Bab"]);
-    });
-    it("lands a patch in a list scope, because the name declared the shape", () => {
-        // A patch and a row are both objects. What tells them apart is the
-        // attribute that asked, not the value that arrived.
-        const root = body(`<ul lb-list="members">` +
-            `<template lb-key="id"><li lb-cell="name"></li></template>` +
-            `</ul>`);
-        applyData(root, { members: [{ id: "1", name: "Ada" }] });
-        applyData(root, { members: { rows: [{ id: "2", name: "Bab" }] } });
-        assert.deepEqual([...root.querySelectorAll("li")].map((el) => el.textContent), ["Ada", "Bab"]);
-    });
-    it("refuses a name bound as a list in one place and a row in another", async () => {
-        // Cardinality is a property of the name, so this is a mistake in the
-        // markup rather than a case to reconcile.
-        const root = body(`<ul lb-list="members">` +
-            `<template lb-key="id"><li lb-cell="name"></li></template>` +
-            `</ul>` +
-            `<div lb-row="members"><span lb-cell="name"></span></div>`);
-        const { error } = await captured(() => applyData(root, { members: [{ id: "1", name: "Ada" }] }));
-        assert.match(error.join("\n"), /a list in one place and a row in another/);
-        assert.equal(root.querySelectorAll("li").length, 0, "nothing landed");
-    });
-    it("refuses rows arriving at a row scope", async () => {
-        const root = body(`<div lb-row="members"><span lb-cell="n"></span></div>`);
-        const { error } = await captured(() => applyData(root, { members: [{ id: "1" }] }));
-        assert.match(error.join("\n"), /bound with lb-row but answered with rows/);
-    });
-    it("does not carry a row into a nested scope", () => {
-        // A nested scope of either kind begins a new one, so a cell named alike
-        // inside it belongs to the inner name.
-        const root = body(`<div lb-row="outer"><span lb-cell="name"></span>` +
-            `<p lb-row="inner"><span lb-cell="name"></span></p></div>`);
-        applyData(root, { inner: { name: "in" }, outer: { name: "out" } });
-        const [first, second] = root.querySelectorAll("span");
-        assert.equal(first.textContent, "out");
-        assert.equal(second.textContent, "in");
-    });
-    it("lands a column called op like any other", () => {
-        // It used to be reserved, because the hub read it to tell a row from a
-        // set. Cardinality is declared now, so nothing inspects a value and no
-        // column name is spoken for.
-        const root = body(`<div lb-row="thing"><span lb-cell="op"></span></div>`);
-        applyData(root, { thing: { op: "rows" } });
-        assert.equal(root.querySelector("span").textContent, "rows");
-    });
-    it("does nothing with an empty response", () => {
-        const root = body(`<div lb-row="count"><span lb-cell="n">3</span></div>`);
-        applyData(root, {});
-        assert.equal(root.querySelector("span").textContent, "3");
-    });
-});

package/dist/tests/lb-express.test.d.ts

@@ -1,14 +0,0 @@
-/**
- * The Express adapter — see docs/testing.md, tier 2.
- *
- * server/lb-express.ts is the only file that knows both HTTP and Hub. What
- * it owes is small and exact: one endpoint and no second, the page from the
- * query string, and an operation it does not yet handle refused rather than
- * half-handled.
- *
- * It is tested against a listening server rather than a mocked request,
- * because the things it can get wrong — a body that never parsed, a route
- * that swallows another — are things a mock would agree with.
- */
-export {};
-//# sourceMappingURL=lb-express.test.d.ts.map

package/dist/tests/lb-express.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lb-express.test.d.ts","sourceRoot":"","sources":["../../tests/lb-express.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/tests/lb-express.test.js

@@ -1,243 +0,0 @@
-/**
- * The Express adapter — see docs/testing.md, tier 2.
- *
- * server/lb-express.ts is the only file that knows both HTTP and Hub. What
- * it owes is small and exact: one endpoint and no second, the page from the
- * query string, and an operation it does not yet handle refused rather than
- * half-handled.
- *
- * It is tested against a listening server rather than a mocked request,
- * because the things it can get wrong — a body that never parsed, a route
- * that swallows another — are things a mock would agree with.
- */
-import assert from "node:assert/strict";
-import { after, before, describe, it } from "node:test";
-import express from "express";
-import { LB_ENDPOINT } from "../core/lb-constants";
-import { hubRoutes } from "../server/lb-express";
-import { captured } from "./helpers/console";
-const calls = [];
-let contexts = 0;
-const engine = {
-    async dataForPage(page, ctx) {
-        calls.push({ kind: "data", page, ctx });
-        return { greeting: { text: "hello" } };
-    },
-    async runAction(page, name, where, ctx) {
-        calls.push({ kind: "action", page, name, where, ctx });
-        if (name === "explode")
-            throw new Error("application code failed");
-        return { count: { n: "2" } };
-    },
-    async runCellChange(page, where, ctx) {
-        calls.push({ kind: "cell-change", page, where, ctx });
-        return { members: { n: "3" } };
-    },
-    async runRowDelete(page, where, ctx) {
-        calls.push({ kind: "tuple-delete", page, where, ctx });
-        return { members: { n: "4" } };
-    },
-    async runRowInsert(page, where, ctx) {
-        calls.push({ kind: "tuple-insert", page, where, ctx });
-        return { members: { n: "5" } };
-    },
-    async runRowUpdate(page, where, ctx) {
-        calls.push({ kind: "tuple-update", page, where, ctx });
-        return { members: { n: "6" } };
-    },
-};
-let base;
-let server;
-before(async () => {
-    const app = express();
-    app.use(hubRoutes(engine, () => {
-        contexts += 1;
-        return {};
-    }));
-    await new Promise((done) => {
-        server = app.listen(0, "127.0.0.1", () => done());
-    });
-    base = `http://127.0.0.1:${server.address().port}`;
-});
-after(() => void server.close());
-function post(page, body, raw) {
-    return fetch(`${base}${LB_ENDPOINT}?page=${page}`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: raw ?? JSON.stringify(body),
-    });
-}
-describe("a request with no action", () => {
-    it("runs the page named in the query string", async () => {
-        calls.length = 0;
-        const res = await post("hello", {});
-        assert.equal(res.status, 200);
-        assert.deepEqual(await res.json(), { greeting: { text: "hello" } });
-        assert.equal(calls.length, 1);
-        assert.equal(calls[0].kind, "data");
-        assert.equal(calls[0].page, "hello");
-    });
-    it("names the empty page when the query string does not", async () => {
-        // The engine answers for a page it does not have; the route's job is only
-        // to pass on what it was given rather than to invent a default.
-        calls.length = 0;
-        await fetch(`${base}${LB_ENDPOINT}`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: "{}",
-        });
-        assert.equal(calls[0].page, "");
-    });
-});
-describe("a request carrying an action", () => {
-    it("runs the action, with where the interaction happened", async () => {
-        calls.length = 0;
-        const res = await post("roster", {
-            action: "pick",
-            list: "members",
-            key: "7",
-            cell: "role",
-            value: "lead",
-        });
-        assert.equal(res.status, 200);
-        assert.deepEqual(await res.json(), { count: { n: "2" } });
-        assert.deepEqual(calls[0].where, {
-            list: "members",
-            row: undefined,
-            key: "7",
-            cell: "role",
-            value: "lead",
-        });
-        assert.equal(calls[0].name, "pick");
-        assert.equal(calls[0].page, "roster");
-    });
-    it("passes on an action carrying no binding at all", async () => {
-        // A button carries no value and may sit outside any scope. Undefined
-        // stays undefined rather than becoming the empty string.
-        calls.length = 0;
-        await post("counter", { action: "bump" });
-        assert.deepEqual(calls[0].where, {
-            list: undefined,
-            row: undefined,
-            key: undefined,
-            cell: undefined,
-            value: undefined,
-        });
-    });
-    it("refuses a reserved name it does not implement, rather than guessing", async () => {
-        calls.length = 0;
-        const { result: res, warn } = await captured(() => post("roster", { action: "lb-row-upsert", list: "members", key: "1" }));
-        assert.equal(res.status, 400);
-        assert.deepEqual(await res.json(), {});
-        assert.deepEqual(calls, [], "the engine was never reached");
-        assert.match(warn.join("\n"), /operation 'lb-row-upsert' not implemented/);
-    });
-    it("runs a cell-change, with where the interaction happened", async () => {
-        calls.length = 0;
-        const res = await post("roster", {
-            action: "lb-cell-change",
-            list: "members",
-            key: "7",
-            cell: "name",
-            value: "Ada",
-        });
-        assert.equal(res.status, 200);
-        assert.deepEqual(await res.json(), { members: { n: "3" } });
-        assert.deepEqual(calls[0].where, {
-            list: "members",
-            key: "7",
-            cell: "name",
-            value: "Ada",
-        });
-        assert.equal(calls[0].kind, "cell-change");
-        assert.equal(calls[0].page, "roster");
-    });
-    it("runs a tuple-delete, with the key of the row", async () => {
-        calls.length = 0;
-        const res = await post("roster", {
-            action: "lb-row-delete",
-            list: "members",
-            key: "7",
-        });
-        assert.equal(res.status, 200);
-        assert.deepEqual(await res.json(), { members: { n: "4" } });
-        assert.deepEqual(calls[0].where, { list: "members", key: "7" });
-        assert.equal(calls[0].kind, "tuple-delete");
-        assert.equal(calls[0].page, "roster");
-    });
-    it("runs a tuple-insert, with the gathered values", async () => {
-        calls.length = 0;
-        const res = await post("roster", {
-            action: "lb-row-insert",
-            list: "members",
-            values: { name: "Ada", role: "Analyst" },
-        });
-        assert.equal(res.status, 200);
-        assert.deepEqual(await res.json(), { members: { n: "5" } });
-        assert.deepEqual(calls[0].where, {
-            list: "members",
-            values: { name: "Ada", role: "Analyst" },
-        });
-        assert.equal(calls[0].kind, "tuple-insert");
-        assert.equal(calls[0].page, "roster");
-    });
-    it("runs a tuple-update, with the key and the gathered values", async () => {
-        calls.length = 0;
-        const res = await post("roster", {
-            action: "lb-row-update",
-            list: "members",
-            key: "7",
-            values: { name: "Ada", role: "Analyst" },
-        });
-        assert.equal(res.status, 200);
-        assert.deepEqual(await res.json(), { members: { n: "6" } });
-        assert.deepEqual(calls[0].where, {
-            list: "members",
-            key: "7",
-            values: { name: "Ada", role: "Analyst" },
-        });
-        assert.equal(calls[0].kind, "tuple-update");
-        assert.equal(calls[0].page, "roster");
-    });
-    it("refuses a body with no op", async () => {
-        calls.length = 0;
-        const { result: res } = await captured(() => post("roster", { name: "pick" }));
-        assert.equal(res.status, 400);
-        assert.deepEqual(calls, []);
-    });
-    it("survives an operation that throws, rather than crashing", async () => {
-        calls.length = 0;
-        const { result: res, error } = await captured(() => post("roster", { action: "explode", list: "members" }));
-        assert.equal(res.status, 500);
-        assert.deepEqual(await res.json(), {});
-        assert.match(error.join("\n"), /'explode' threw/);
-        // And the process is still serving.
-        const next = await post("hello", {});
-        assert.equal(next.status, 200);
-    });
-    it("survives a body that is not JSON", async () => {
-        calls.length = 0;
-        const res = await post("roster", null, "{ not json");
-        assert.ok(res.status >= 400, `expected a refusal, got ${res.status}`);
-        assert.deepEqual(calls, []);
-        // And the process is still serving. A parse failure is one request's
-        // problem, not the server's.
-        const next = await post("hello", {});
-        assert.equal(next.status, 200);
-    });
-});
-describe("the context", () => {
-    it("is built once per request, by the application", async () => {
-        // Hub's only requirement is that the context is built per request,
-        // after whatever establishes identity. Holding one for the life of the
-        // process is the mistake this asserts against.
-        contexts = 0;
-        calls.length = 0;
-        await post("hello", {});
-        await post("hello", {});
-        await post("counter", { action: "bump" });
-        assert.equal(contexts, 3);
-        assert.notEqual(calls[0].ctx, calls[1].ctx);
-        assert.notEqual(calls[1].ctx, calls[2].ctx);
-    });
-});

package/dist/tests/lb-hub.test.d.ts

@@ -1,14 +0,0 @@
-/**
- * The hub element — see hub/lb-hub.browser.ts and docs/testing.md.
- *
- * Tier 4. jsdom is evidence for what the hub does to the document it is
- * already holding: which element an event came from, what request that
- * produces, which attributes land where, and which page host a path selects.
- * A real network and a real frame belong to the browser tier, which is not
- * built.
- *
- * The hub registers itself as its module loads, so the window goes in first
- * and the module is imported after it.
- */
-export {};
-//# sourceMappingURL=lb-hub.test.d.ts.map

package/dist/tests/lb-hub.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lb-hub.test.d.ts","sourceRoot":"","sources":["../../tests/lb-hub.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}