@loadbare/app 0.6.0 → 0.7.0

package/docs/reference/widgets.md

@@ -27,9 +27,9 @@ for where a listed package sits in the cascade.
 
 Wraps an `<input>`. `lb-value` sets the input's `.value`. The widget sends
 nothing on its own: `lb-action` names what the input's `change` sends. The
-reserved `lb-cell-change` sends `lb-cell-change`, addressed by the widget's own
-`lb-list`/`lb-key-value`/`lb-cell` coordinates; any other name sends that
-action with the input's value.
+reserved `lb-cell-change` sends `lb-cell-change`; any other name sends that
+action. Either carries the input's value, and the hub adds the scope the
+input sits in.
 
 An input inside an `lb-row-insert` or `lb-row-update` form leaves the attribute off.
 The form reads every `lb-cell` in it on submit and sends one request for all

package/docs/theory.md

@@ -344,4 +344,117 @@ I wrote Loadbare originally in 2003, as "Andromeda", before Node existed
 and even 4 years before we had JQuery.  Andromeda was not nearly as
 optimized as Loadbare is now, but the principles were the same then as 
 they are now.  It has always worked for me, and I hope that it will work
-for you.
+for you.
+
+## A Consistency Model
+
+> **LLM-authored, not yet revised by a person.**  Drafted by Claude on
+> 2026-09-13, from a design session against `@loadbare/app` 0.6.0.  Treat
+> it as a proposal for this essay, not as the author's statement.
+
+### From a subjective claim to a checkable one
+
+Whether Loadbare carries less accidental complexity than another tool will
+always be disputable.  A developer fluent in React has muscle memory for its
+rules and will see Loadbare's rules as foreign, and foreign work feels
+accidental.  That objection is about familiarity, and familiarity is a cost
+paid once, in the same way this essay treats the Express boilerplate.
+
+A stronger claim can be checked, and a single counterexample in markup
+would refute it.  The model for applying data to HTML is:
+
+1. **Internally consistent.**  A few rules, each applied the same way
+   everywhere, with no exceptions.
+2. **Consistent with HTML.**  Each rule has a counterpart in how HTML
+   already behaves, and none contradicts it.
+3. **Consistent with relational data.**  What the server sends is the shape
+   a SQL query already returns, so nothing is translated on the way.
+
+### Where the vocabulary comes from
+
+This essay says the vocabulary is small because the operations a database
+affords are small and coherent.  A sharper statement is that the vocabulary
+sits where two systems that are already coherent meet: the relational model
+and HTML's containment model.  Each attribute is a relational idea placed on
+an element.
+
+| Loadbare                                 | Relational                                   | HTML precedent                                               |
+| ---------------------------------------- | -------------------------------------------- | ------------------------------------------------------------ |
+| `lb-list`                                | a relation, a set of rows                    | `<select>`, `<ul>`: a container whose contents are its items |
+| `lb-row`                                 | a single row                                 | `<form>`: one record of fields                               |
+| `lb-cell`                                | a column                                     | `name` on a control: which field this is                     |
+| `lb-key`, `lb-key-value`                 | the primary key                              | `value` on `<option>`: identity apart from the label         |
+| `lb-action`                              | a closed set of writes, and named procedures | `action` on `<form>`: where a submission goes                |
+| scope from ancestors                     |                                              | form ownership, `lang`, `<fieldset disabled>`                |
+| a nested scope begins a new one          |                                              | a nested element owns its own contents                       |
+| `lb-row-count`, `lb-pending`, `lb-error` |                                              | state attributes such as `open` on `<details>`               |
+
+### The rules
+
+1. **An element's own attributes describe what it displays.  Its ancestors
+   describe where it belongs.**  A picker carrying `lb-list` displays that
+   list, and its choice is addressed to the row it sits in, the way a
+   `<select>` displays its options and submits to the form around it.
+2. **A name answers with one shape, a row or a set of rows, and a cell holds
+   one value.**  Master-detail is a row and a list under two names.  Many
+   masters with their details is one list of joined rows, grouped for
+   display.
+3. **A value lands where the element shows its state, and a form gathers
+   from the same places.**  A widget receives `lb-value`, a form control its
+   `value`, and any other element its text.
+4. **A request is an action and a position.**  The hub supplies the position
+   from the document.  Only an interaction supplies a value.
+5. **The hub owns position and reconciliation.  A widget owns interaction and
+   placement.**
+
+### Evidence
+
+The following decisions each removed an exception or a conflict, and none
+added an attribute.  Over the same span the model gained pickers inside rows,
+native selects that show their own state, and nested lists that do not
+destroy each other.
+
+| Decision                                                      | Removed                                                                              |
+| ------------------------------------------------------------- | ------------------------------------------------------------------------------------ |
+| The hub scopes every request                                  | Native requests were scoped and widget requests were not                             |
+| Scope comes from ancestors, never the element's own `lb-list` | `lb-list` meant "display" in one place and "address" in another                      |
+| A form control receives its value as `value`                  | A `<select>` was treated as text, against HTML, and landing did not mirror gathering |
+| Row and template lookups stop at a nested scope               | Cells respected nesting while rows and templates did not                             |
+| Master-detail is a row and a list                             | An open question born of document-shaped data                                        |
+| `lb-value` on every cell                                      | Only a widget's landed value was visible to a stylesheet                             |
+
+Two signs suggest these are rules rather than patches.  Fixing where a
+request's scope comes from also fixed an unrelated console error about insert
+forms, which was never worked on directly.  Making rows respect nested scopes
+needed no change to the reference, which already described that behavior.
+
+### Where the claim is not yet proven
+
+- **Parameters and view state.**  A query takes no argument from the
+  browser, so there is nowhere to put which record is selected, a filter, a
+  sort, or a collapsed section.  The model is incomplete here rather than
+  inconsistent.  If the answer is HTML's own, the URL, in the way
+  `<form method="get">` puts its fields in the query string, the claim grows
+  stronger.  If it needs a state mechanism with no HTML precedent, that will
+  be the model's first real exception.
+- **Checkboxes and radio buttons.**  HTML's boolean convention is presence or
+  absence, as with `checked`, `hidden` and `disabled`.  A rule following it
+  would avoid inventing truthiness, though it still touches data types.
+- **Data types.**  HTML attributes are strings, so comparing values as strings
+  in a stylesheet is consistent with HTML.  What is not yet reconciled is
+  that a database's typed values arrive untyped.
+- **A nested list shows the same rows in every outer row.**  That follows
+  from the second rule: one name is one relation.  Only a new outer row
+  starting with an empty nested list is a mechanical gap.
+
+### A test for every change
+
+Before a change is made, ask:
+
+- Does it remove an exception, or add one?
+- Does it have an HTML precedent?
+- Does it have a relational counterpart?
+
+Stamping every column of a row onto the row element as `data-*` fails the
+first two: attributes nobody wrote, with no precedent in HTML.  Writing
+`lb-value` on every cell passes all three.

package/docs/tutorials/072-inserting-into-a-list.md

@@ -8,20 +8,23 @@ that allows a user to add a note.
 ```html
 <!-- src/pages/about.page.html -->
 <h2>Notes</h2>
-<form lb-action="lb-row-insert" lb-list="notes">
-  <input lb-cell="text" placeholder="Write a note" />
-  <button type="submit">Add</button>
-</form>
-
-<ul lb-list="notes">
-  <template lb-key="id">
-    <li lb-cell="text"></li>
-  </template>
-</ul>
+<section lb-list="notes">
+  <form lb-action="lb-row-insert">
+    <input lb-cell="text" placeholder="Write a note" />
+    <button type="submit">Add</button>
+  </form>
+
+  <ul>
+    <template lb-key="id">
+      <li lb-cell="text"></li>
+    </template>
+  </ul>
+</section>
 ```
 
 `lb-action="lb-row-insert"` on a `<form>` gathers its `lb-cell`s into a values
-map on submit and sends them against `lb-list`. The name is one of
+map on submit and sends them against the `lb-list` around it, the way an
+`<input>` belongs to the `<form>` around it. The name is one of
 Loadbare's reserved ones — every value beginning with `lb-` is — so it
 needs no declaring, and nothing of yours may be called that. There's no `lb-key-value` — there's no row
 yet.

package/docs/tutorials/080-widget-requests.md

@@ -9,11 +9,9 @@ changes.
 
 ## Writing the widget
 
-Our new custom input will no longer rely on Loadbare's form handling,
-and so it must reimplement the data scoping logic that is in
-Loadbare.  This reimplementation approach is neither encouraged nor
-discouraged.  This tutorial shows only that it is possible, and exposes
-how Loadbare internals work.
+Our new custom input will no longer rely on Loadbare's form handling.  It
+says what happened and what its value is.  Where it sits, the list, the row
+and the cell, is added by the hub.
 
 ```html
 <!-- src/note-input.html -->
@@ -22,13 +20,7 @@ how Loadbare internals work.
 
 ```ts
 // src/note-input.browser.ts
-import {
-  ATTR_CELL,
-  ATTR_KEY_VALUE,
-  ATTR_LIST,
-  ATTR_VALUE,
-  LB_EVENT_NAME,
-} from "@loadbare/app/constants";
+import { ATTR_VALUE, LB_EVENT_NAME } from "@loadbare/app/constants";
 
 class NoteInput extends HTMLElement {
   static observedAttributes = [ATTR_VALUE];
@@ -42,20 +34,10 @@ class NoteInput extends HTMLElement {
     this.addEventListener("change", () => {
       const input = this.querySelector("input");
       if (!input) return;
-      const list = this.closest(`[${ATTR_LIST}]`)?.getAttribute(ATTR_LIST);
-      const key = this.closest(`[${ATTR_KEY_VALUE}]`)?.getAttribute(ATTR_KEY_VALUE);
-      const cell = this.getAttribute(ATTR_CELL);
-      if (!list || !key || !cell) return;
       this.dispatchEvent(
         new CustomEvent(LB_EVENT_NAME, {
           bubbles: true,
-          detail: {
-            action: "lb-cell-change",
-            list,
-            key,
-            cell,
-            value: input.value,
-          },
+          detail: { action: "lb-cell-change", value: input.value },
         }),
       );
     });
@@ -66,9 +48,10 @@ customElements.define("note-input", NoteInput);
 ```
 
 A widget with both a `.html` and a `.browser.ts` file shares one tag name; the
-build finds each half independently. On change, it reads its own
-`lb-list`/`lb-key-value`/`lb-cell` coordinates and dispatches a `lb-cell-change`
-request itself, the way `lb-row-update` does for a whole form.
+build finds each half independently. On change, it dispatches a
+`lb-cell-change` carrying the input's value. The hub adds the list, the key
+of the row it is in and its own `lb-cell`, the same way it does for a
+`lb-row-update` form.
 
 ## Using it
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loadbare/app",
   "description": "High performance web app framework for server-bound applications",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "files": [
     "dist",
@@ -32,7 +32,7 @@
     "prebuild": "node --eval \"fs.rmSync('dist',{recursive:true,force:true})\" --input-type=module",
     "build:server": "tsc --project tsconfig.build.json",
     "build": "npm run build:server",
-    "postbuild": "node --eval \"fs.chmodSync('dist/build/cli.js', 0o755)\" --input-type=module",
+    "postbuild": "node --eval \"fs.chmodSync('dist/build/cli.js', 0o755)\" --input-type=module && node ../../scripts/check-dist-imports.mjs",
     "test": "tsx --test \"tests/**/*.test.ts\"",
     "typecheck": "tsc --noEmit",
     "format": "prettier --write .",

package/dist/tests/assemble.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * Assembling a chrome file and its pages — see build/assemble.ts.
- *
- * The chrome and pages together are one write to a temp tree per test,
- * since assemble() reads from disk rather than taking sources in memory.
- */
-export {};
-//# sourceMappingURL=assemble.test.d.ts.map

package/dist/tests/assemble.test.d.ts.map

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

package/dist/tests/assemble.test.js

@@ -1,210 +0,0 @@
-/**
- * Assembling a chrome file and its pages — see build/assemble.ts.
- *
- * The chrome and pages together are one write to a temp tree per test,
- * since assemble() reads from disk rather than taking sources in memory.
- */
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { assemble } from "../build/assemble";
-import { resolveLocations } from "../build/locations";
-import { scanAll } from "../build/origins";
-async function tree(files) {
-    const dir = await mkdtemp(path.join(tmpdir(), "loadbare-assemble-"));
-    for (const [name, content] of Object.entries(files)) {
-        const file = path.join(dir, name);
-        await mkdir(path.dirname(file), { recursive: true });
-        await writeFile(file, content, "utf-8");
-    }
-    return dir;
-}
-async function scansFor(locations) {
-    return scanAll(locations, locations.srcDir, locations.importsFile);
-}
-describe("assemble", () => {
-    it("expands a widget written in the chrome, not only in pages", async () => {
-        const src = await tree({
-            "chrome.html": `<!doctype html><body><lb-nav exp-label="Site"><a href="/a">A</a></lb-nav><lb-hub><main></main></lb-hub></body>`,
-            "lb-nav.html": `<nav aria-label="{{label}}" lb-slot></nav>`,
-        });
-        try {
-            const locations = await resolveLocations({ src, out: `${src}/dist` });
-            const { html, usedTags } = await assemble({
-                ...locations,
-                scans: await scansFor(locations),
-            });
-            assert.match(html, /<nav aria-label="Site"><a href="\/a">A<\/a><\/nav>/);
-            assert.ok(usedTags.has("lb-nav"));
-        }
-        finally {
-            await rm(src, { recursive: true, force: true });
-        }
-    });
-    it("reports a chrome widget with no definition as a used tag, for elements.ts to refuse", async () => {
-        // Expansion leaves an undefined tag alone; whether it can do anything is
-        // one rule in one place — see build/elements.ts.
-        const src = await tree({
-            "chrome.html": `<!doctype html><body><lb-nope></lb-nope></body>`,
-        });
-        try {
-            const locations = await resolveLocations({ src, out: `${src}/dist` });
-            const { html, usedTags } = await assemble({
-                ...locations,
-                scans: await scansFor(locations),
-            });
-            assert.match(html, /<lb-nope><\/lb-nope>/);
-            assert.ok(usedTags.has("lb-nope"));
-        }
-        finally {
-            await rm(src, { recursive: true, force: true });
-        }
-    });
-});
-describe("the unknown-page dialog", () => {
-    it("accepts a chrome that declares none", async () => {
-        const src = await tree({
-            "chrome.html": `<!doctype html><body><lb-hub><main></main></lb-hub></body>`,
-        });
-        try {
-            const locations = await resolveLocations({ src, out: `${src}/dist` });
-            const { html } = await assemble({
-                ...locations,
-                scans: await scansFor(locations),
-            });
-            assert.doesNotMatch(html, /lb-unknown-page/);
-        }
-        finally {
-            await rm(src, { recursive: true, force: true });
-        }
-    });
-    it("refuses the attribute on anything but a <dialog>", async () => {
-        const src = await tree({
-            "chrome.html": `<!doctype html><body><lb-hub><main></main><div lb-unknown-page></div></lb-hub></body>`,
-        });
-        try {
-            const locations = await resolveLocations({ src, out: `${src}/dist` });
-            const scans = await scansFor(locations);
-            await assert.rejects(() => assemble({ ...locations, scans }), /lb-unknown-page on <div>, must be a <dialog>/);
-        }
-        finally {
-            await rm(src, { recursive: true, force: true });
-        }
-    });
-    it("refuses a dialog outside the hub, where the hub cannot reach it", async () => {
-        const src = await tree({
-            "chrome.html": `<!doctype html><body><dialog lb-unknown-page></dialog><lb-hub><main></main></lb-hub></body>`,
-        });
-        try {
-            const locations = await resolveLocations({ src, out: `${src}/dist` });
-            const scans = await scansFor(locations);
-            await assert.rejects(() => assemble({ ...locations, scans }), /lb-unknown-page outside <lb-hub>/);
-        }
-        finally {
-            await rm(src, { recursive: true, force: true });
-        }
-    });
-});
-/**
- * The binding vocabulary, checked against the finished document rather than
- * discovered one console error at a time in a browser — see walkBinding in
- * build/assemble.ts. Every case here is a build that must not produce output.
- */
-describe("the binding check", () => {
-    const CHROME = `<!doctype html><body><lb-hub><main></main></lb-hub></body>`;
-    /** Assemble a chrome and one page, and hand back whatever it did. */
-    async function build(files) {
-        const src = await tree({ "chrome.html": CHROME, ...files });
-        try {
-            const locations = await resolveLocations({ src, out: `${src}/dist` });
-            const scans = await scansFor(locations);
-            return await assemble({ ...locations, scans });
-        }
-        finally {
-            await rm(src, { recursive: true, force: true });
-        }
-    }
-    async function refuses(page, pattern) {
-        await assert.rejects(() => build({ "a.page.html": page }), pattern);
-    }
-    it("refuses both scope attributes on one element", async () => {
-        await refuses(`<ul lb-list="roster" lb-row="prefs"></ul>`, /carries both lb-list and lb-row/);
-    });
-    it("refuses a cell with no scope around it", async () => {
-        await refuses(`<p><span lb-cell="name"></span></p>`, /carries lb-cell="name" with no lb-list or lb-row scope/);
-    });
-    it("refuses a cell whose only scope is inside a template with none around it", async () => {
-        // A template's children are walked in the scope enclosing the template,
-        // because a row template's clones land in the list around it.
-        await refuses(`<template><span lb-cell="name"></span></template>`, /carries lb-cell="name" with no lb-list or lb-row scope/);
-    });
-    it("refuses lb-key on anything but a template", async () => {
-        await refuses(`<ul lb-list="roster"><li lb-key="id"></li></ul>`, /<li> carries lb-key; it names the column/);
-    });
-    it("refuses lb-key on a template outside any list scope", async () => {
-        await refuses(`<div lb-row="prefs"><template lb-key="id"><p></p></template></div>`, /carries lb-key outside any lb-list scope/);
-    });
-    it("refuses a template carrying lb-key with no scope at all", async () => {
-        await refuses(`<template lb-key="id"><p></p></template>`, /carries lb-key outside any lb-list scope/);
-    });
-    it("reports every problem in one build, not the first", async () => {
-        await refuses(`<span lb-cell="name"></span><ul lb-list="a" lb-row="b"></ul>`, /no lb-list or lb-row scope[\s\S]*carries both lb-list and lb-row/);
-    });
-    it("names the file the problem is in", async () => {
-        await refuses(`<span lb-cell="name"></span>`, /a\.page\.html' binding:/);
-    });
-    it("checks the chrome as well as the pages", async () => {
-        const src = await tree({
-            "chrome.html": `<!doctype html><body><lb-hub><main></main><span lb-cell="name"></span></lb-hub></body>`,
-        });
-        try {
-            const locations = await resolveLocations({ src, out: `${src}/dist` });
-            const scans = await scansFor(locations);
-            await assert.rejects(() => assemble({ ...locations, scans }), /chrome\.html' binding:/);
-        }
-        finally {
-            await rm(src, { recursive: true, force: true });
-        }
-    });
-    it("accepts a cell in either kind of scope", async () => {
-        const { html } = await build({
-            "a.page.html": `
-        <div lb-row="prefs"><span lb-cell="theme"></span></div>
-        <ul lb-list="roster">
-          <template lb-key="id"><li lb-cell="name"></li></template>
-        </ul>`,
-        });
-        assert.match(html, /lb-cell="theme"/);
-        assert.match(html, /lb-cell="name"/);
-    });
-    it("accepts a nested scope, which begins a scope of its own", async () => {
-        const { html } = await build({
-            "a.page.html": `
-        <div lb-row="prefs">
-          <ul lb-list="roster">
-            <template lb-key="id"><li lb-cell="name"></li></template>
-          </ul>
-        </div>`,
-        });
-        assert.match(html, /lb-cell="name"/);
-    });
-    it("scopes a template's content by the scope the template itself carries", async () => {
-        // A template with no scope of its own is walked in the scope enclosing
-        // it, which is what makes a row template's cells legal. One that carries
-        // a scope establishes it for its own content instead. That is today's
-        // behavior, and this is the test that flips if it changes.
-        const { html } = await build({
-            "a.page.html": `<template lb-row="prefs"><span lb-cell="theme"></span></template>`,
-        });
-        assert.match(html, /lb-cell="theme"/);
-    });
-    it("accepts a list scope with no row template, which displays nothing", async () => {
-        // An insert form names the list it adds to and has no rows of its own.
-        const { html } = await build({
-            "a.page.html": `<form lb-list="roster" lb-action="lb-row-insert"></form>`,
-        });
-        assert.match(html, /lb-list="roster"/);
-    });
-});

package/dist/tests/elements.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * Resolving a used tag to the script that registers it — see build/elements.ts.
- *
- * Fixtures under tests/fixtures/elements/ each stand in for one <src> tree,
- * the same role tests/fixtures/definitions plays for expand.ts.
- */
-export {};
-//# sourceMappingURL=elements.test.d.ts.map

package/dist/tests/elements.test.d.ts.map

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

package/dist/tests/elements.test.js

@@ -1,118 +0,0 @@
-/**
- * Resolving a used tag to the script that registers it — see build/elements.ts.
- *
- * Fixtures under tests/fixtures/elements/ each stand in for one <src> tree,
- * the same role tests/fixtures/definitions plays for expand.ts.
- */
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { fileURLToPath } from "node:url";
-import { customElementTags } from "../build/expand";
-import { loadElementManifest, resolveElements } from "../build/elements";
-import { packageInfo } from "../build/locations";
-import { scanOrigin } from "../build/origins";
-const FIXTURES = fileURLToPath(new URL("./fixtures/elements", import.meta.url));
-/**
- * The cascade resolveElements reads, built here rather than by
- * build/origins.ts's buildOrigins: these fixtures name packages that are not
- * installed, and resolution is what is under test, not package lookup.
- */
-async function scansFor(src, packageDir) {
-    const info = await packageInfo();
-    const origins = [
-        {
-            name: info.packageName,
-            dirs: [info.builtinHubDir],
-            specifier: () => info.packageName,
-        },
-        ...(packageDir ? [{ name: "@acme/widget", dirs: [packageDir] }] : []),
-        { name: src, dirs: [src] },
-    ];
-    return Promise.all(origins.map(scanOrigin));
-}
-describe("customElementTags", () => {
-    it("collects every hyphenated tag, native elements excluded", () => {
-        const tags = customElementTags(`<div><lb-input></lb-input><app-box>hi</app-box><span></span></div>`);
-        assert.deepEqual([...tags].sort(), ["app-box", "lb-input"]);
-    });
-    it("reaches into template content", () => {
-        const tags = customElementTags(`<template><acme-widget></acme-widget></template>`);
-        assert.deepEqual([...tags], ["acme-widget"]);
-    });
-});
-describe("loadElementManifest", () => {
-    it("returns the declared package list", async () => {
-        const declared = await loadElementManifest(`${FIXTURES}/manifest/imports.ts`);
-        assert.deepEqual(declared, ["@acme/widget"]);
-    });
-    it("returns empty when there is no imports.ts", async () => {
-        const declared = await loadElementManifest(`${FIXTURES}/local/imports.ts`);
-        assert.deepEqual(declared, []);
-    });
-    it("rejects a default export that is not an array", async () => {
-        await assert.rejects(() => loadElementManifest(`${FIXTURES}/manifest-not-array/imports.ts`), /must default-export an array of package names/);
-    });
-    it("rejects an entry that is not a package name", async () => {
-        await assert.rejects(() => loadElementManifest(`${FIXTURES}/manifest-bad-entry/imports.ts`), /every entry must be a package name/);
-    });
-});
-describe("resolveElements", () => {
-    it("resolves lb-hub to the package itself, the one built-in", async () => {
-        const { resolved } = resolveElements({
-            used: new Set(["lb-hub"]),
-            scans: await scansFor(`${FIXTURES}/local`),
-        });
-        assert.deepEqual(resolved.get("lb-hub"), {
-            kind: "specifier",
-            value: "@loadbare/app",
-        });
-    });
-    it("resolves a local tag to its file in <src>", async () => {
-        const { resolved } = resolveElements({
-            used: new Set(["app-box"]),
-            scans: await scansFor(`${FIXTURES}/local`),
-        });
-        assert.equal(resolved.get("app-box")?.kind, "file");
-        assert.match(resolved.get("app-box").value, /local\/widgets\/app-box\.browser$/);
-    });
-    it("resolves a tag found by scanning a declared package", async () => {
-        const { resolved } = resolveElements({
-            used: new Set(["acme-widget"]),
-            scans: await scansFor(`${FIXTURES}/manifest`, `${FIXTURES}/pkg`),
-        });
-        assert.equal(resolved.get("acme-widget")?.kind, "file");
-        assert.match(resolved.get("acme-widget").value, /pkg\/acme-widget\.browser$/);
-    });
-    it("needs no script for a tag with only an .html definition", async () => {
-        const { resolved } = resolveElements({
-            used: new Set(["lb-nav"]),
-            scans: await scansFor(`${FIXTURES}/markup-only`),
-        });
-        assert.equal(resolved.size, 0);
-    });
-    it("names the unmarked file when a tag's script forgot to say .browser", async () => {
-        await assert.rejects(async () => resolveElements({
-            used: new Set(["app-box"]),
-            scans: await scansFor(`${FIXTURES}/unmarked`),
-        }), (err) => {
-            assert.match(err.message, /<app-box> has no script/);
-            assert.match(err.message, /widgets[/\\]app-box\.ts' is named after it/);
-            assert.match(err.message, /rename it 'app-box\.browser\.ts'/);
-            return true;
-        });
-    });
-    it("throws when a used tag registers nothing", async () => {
-        await assert.rejects(async () => resolveElements({
-            used: new Set(["nowhere-widget"]),
-            scans: await scansFor(`${FIXTURES}/local`),
-        }), /<nowhere-widget> has neither a script nor a definition/);
-    });
-    it("lets src win over a package that has the same tag", async () => {
-        const { resolved } = resolveElements({
-            used: new Set(["acme-widget"]),
-            scans: await scansFor(`${FIXTURES}/collision`, `${FIXTURES}/pkg`),
-        });
-        assert.equal(resolved.get("acme-widget")?.kind, "file");
-        assert.match(resolved.get("acme-widget").value, /collision\/widgets\/acme-widget\.browser$/);
-    });
-});

package/dist/tests/expand.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * Expansion — see docs/reference/custom-elements.md and docs/testing.md, tier 1.
- *
- * Definitions are written inline here because `expand` takes them as a map
- * and a two-line definition beside its assertion reads better than a file
- * reference. The cases that genuinely need files — the checks `loadDefinitions`
- * runs, and directory ordering — use tests/fixtures/definitions.
- */
-export {};
-//# sourceMappingURL=expand.test.d.ts.map

package/dist/tests/expand.test.d.ts.map

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