@valancex/cli 0.13.0 → 0.15.0

package/README.md

@@ -153,7 +153,7 @@ Templates are MPRX. Conditional and repeated parts are blocks: `{#if cond}…{:e
 | `prev`, `next` | `{ href, label }`, empty `href` when there is none |
 | `viewport` | How much room the page has: `"compact"` (under 600 px), `"medium"` (600 to 839) or `"expanded"` (840 and up), kept current as the window changes. `{#if viewport == "compact"}` chooses markup for a phone. The server renders `expanded`; the browser corrects it as soon as it starts. |
 
-Tags you may use: `shell` (`class`, `theme`), `div`, `header`, `footer`, `nav` (`class`, `label`), `aside`, `section`, `article`, `main` (`id`, `tabindex`), `h1`–`h3` (`id`), `para`, `quote`, `list`, `olist`, `item`, `pre`, `code`, `strong`, `em`, `span`, `image`, `a` (`href`), `link` (`href`, `class`, `current`), `button` (`class`, `pressed`, `on.click`), plus your components and the built-ins (`blocks`, `block`, `heading`, `list-block`, `list-items`, `runs`, `inline`). A prop a tag declares must be written wherever the tag is used; that is why there are many narrow tags rather than a few wide ones. The attribute each prop becomes is in [`src/primitives.ts`](src/primitives.ts).
+Tags you may use: `shell` (`class`, `theme`), `div`, `header`, `footer`, `nav` (`class`, `label`), `aside`, `section`, `article`, `main` (`id`, `tabindex`), `h1`–`h3` (`id`), `paragraph`, `blockquote`, `list`, `olist`, `listitem`, `pre`, `code`, `strong`, `em`, `span`, `image`, `a` (`href`), `link` (`href`, `class`, `current`), `button` (`class`, `pressed`, `on.click`), `toggle`, `checkbox`, `textfield`, `radiogroup`, `radio`, `label`, `status`, `alert` (the full list, with roles and names, is [the primitives](../../docs/use/primitives.md)), plus your components and the built-ins (`blocks`, `block`, `heading`, `list-block`, `list-items`, `runs`, `inline`). The tags `para`, `item` and `quote` are now `paragraph`, `listitem` and `blockquote` (the ARIA names, which the Desktop already used); a template that writes the old one is told the new one. A prop a tag declares must be written wherever the tag is used; that is why there are many narrow tags rather than a few wide ones. The attribute each prop becomes is in [`src/primitives.ts`](src/primitives.ts).
 
 ## The components
 
@@ -173,20 +173,22 @@ export default defineApp({
 
 ```ts
 // src/theme-toggle.ts: the component states its own interface, where it is defined
-import { component } from "@valancex/common";
+import { component, field } from "@valancex/common";
 import { Schema } from "effect";
 import template from "./theme-toggle.mprx";
 
 export default component(template, {
-  props: { theme: Schema.Literal("light", "dark") },
+  props: { theme: field(Schema.Literal("light", "dark"), "light") },
   events: { toggle: Schema.Void },
 });
 ```
 
 - `import x from "./x.mprx"` names a template file; `component(x, …)` defines it. The tag is the file's name (`theme-toggle.mprx` is `<theme-toggle>`). Register it once, in `components`.
 - **Which components a template uses is read from the template.** Write `<theme-toggle … />` in the layout (or in another component) and it is used; there is no list of uses to keep in step. A registered component no template writes yet is not part of the program, and is not an error. A file under `src/` that is not registered is an error (`template-unused`).
-- **The contract.** `props` maps a prop name to its Effect Schema and `events` an event name to its payload Schema (`Schema.Void` is no payload). Declare either and the contract is exactly what you wrote (an omitted side is none), overriding inference; declare neither and MESH infers it from the template and where it is used. Schemas are converted by the same rules as state; a prop is optional when its schema admits `undefined`, and props have no defaults. A schema with no MESH type is a diagnostic at the declaration (`component-schema`). MESH reports an undeclared or missing prop, a prop of the wrong type and a handler for an undeclared event at the use. The layout takes no contract (`layout-contract`). That declared interface is where an editor takes you from `on.toggle=` or `theme=` at a use, and where *Find All References* starts.
+- **The contract.** `props` maps a prop name to its Effect Schema and `events` an event name to its payload Schema (`Schema.Void` is no payload). Declare either and the contract is exactly what you wrote (an omitted side is none), overriding inference; declare neither and MESH infers it from the template and where it is used. Schemas are converted by the same rules as state; a prop is optional when its schema admits `undefined`. A **string-literal union is a closed set**: `Schema.Literal("info", "danger")` becomes the MESH type `"info" | "danger"`, and MESH reports any other literal written for the prop at the use (`unknown-variant`, with a did-you-mean when one is close); a number or boolean literal keeps its primitive type. A prop gets a **default** with `field(schema, value)` (`props: { tone: field(Schema.Literal("info", "danger"), "info") }`): a use of the component that leaves the prop out gets the value, the prop may then be left out, and TypeScript refuses a default that is not a member. A default is for a component with a template; on a primitive it is ignored. A schema with no MESH type, for example a union of a string literal and a number, or a default that is not a value of the prop's type, is a diagnostic at the declaration (`component-schema`). Both need MESH 0.14 or later (`@valancex/mesh-compiler` `^0.14.0`, which the packages depend on). MESH reports an undeclared or missing prop, a prop of the wrong type and a handler for an undeclared event at the use. The layout takes no contract (`layout-contract`). That declared interface is where an editor takes you from `on.toggle=` or `theme=` at a use, and where *Find All References* starts.
 - `override: [component(runs, { props: { spans: … } })]` replaces a built-in (`runs`, `heading-block`, …) with your template of the same name.
+- **One MESH runtime.** `vlx build` (never `vlx dev`) stops with `runtime-duplicate` when the packages resolve more than one copy of `@valancex/mesh-runtime`: each copy is a 765 KB WebAssembly module (171 KB of brotli) that the site would ship and the browser fetch. The message names each copy, its version and who uses it, and says to add an `overrides` entry (npm; `pnpm.overrides`, or `resolutions` with yarn) so there is one. `@valancex/common`, `@valancex/valance` and `@valancex/nexus` accept the same range (`^0.12.0`) so a plain install has one.
+- **One name is one component.** Two registered files with the same name (for example `a/disclosure.mprx` and `b/disclosure.mprx`, whether yours or from two libraries) are `template-duplicate`, and a registered component named like a built-in is `template-builtin` unless it is in `override`: neither silently replaces the other, and the first one listed does not win. Rename one of the files; qualified ids for a library's components (`acme-ui/disclosure`, decision K14) are not built yet. `override` is only for built-ins: for any other name it is `override-unknown`, and the component belongs in `components`.
 - `layout` is optional; without it the built-in layout draws the page. Its template must be named `layout.mprx`.
 
 ### Children and slots
@@ -202,13 +204,38 @@ A component places the content its caller writes inside it with `<mesh-slot />`,
 
 <!-- where it is used -->
 <card>
-  <mesh-fill slot="head"><para class="title">Title</para></mesh-fill>
-  <para class="body">The body goes to the unnamed slot.</para>
+  <mesh-fill slot="head"><paragraph class="title">Title</paragraph></mesh-fill>
+  <paragraph class="body">The body goes to the unnamed slot.</paragraph>
 </card>
 ```
 
 The children are the caller's: `{x}` in them is the caller's `x`, never the card's. `vlx generate component` writes the single, unnamed slot for you. The rules (where a slot may be, what a fill is, the errors) are in MESH's [templates manual](https://github.com/ValanceX/Mesh/blob/main/docs/manual/templates.md#children-and-the-slot).
 
+### Snippets as props
+
+A prop can be a piece of template (MESH 0.14). Declare it with `snippet(…)`, the types of its parameters in order, and read it in the component's template with `{@render name(args)}`:
+
+```
+// src/panel.ts and src/item-list.ts
+component(panel, { props: { title: Schema.String, children: snippet() } });
+component(itemList, { props: { items: Schema.Array(Item), row: snippet(Item, Schema.String) } });
+```
+
+```
+<!-- src/panel.mprx -->
+<section><strong>{title}</strong>{@render children()}</section>
+
+<!-- where they are used: loose content is `children`; a {#snippet} that is a direct child is the prop of its name -->
+<panel title="Totals"><span class="count">{count}</span></panel>
+<item-list items={items} label="row">{#snippet row(item, tag)}<span class="row">{tag}:{item.name}</span>{/snippet}</item-list>
+```
+
+- `children` is reserved for the content between the tags: it must be `snippet()` (no parameters), and `children={…}` with content is `children-conflict`. A snippet is not data: it has no `field` default, is never optional, and is not a record field or an event's payload.
+- A snippet reads the scope of the template that **wrote** it (`count` above is the layout's, not the panel's), so a node that renders one is redrawn when that scope changes though its own props did not.
+- The arity and the types are checked: `snippet-arity-mismatch` in the composite's template when `{@render row(item)}` passes too few, and a member the parameter does not have is reported where the snippet is written.
+- **Optional.** `snippet(…).optional()` (and `children: snippet().optional()`) is one an occurrence may leave out: it is `snippet<…>?` in the model, and an absent one draws nothing. Rendering it is `possibly-absent-snippet` unless it is inside the first branch of an `{#if has(name)}` (`&&` allowed), so `{#if has(header)}{@render header()}{/if}` is how a template uses one.
+- Slots (`mesh-slot`, `mesh-fill`) keep working for a component that does not declare `children`.
+
 ### Typed template imports
 
 `vlx sync` (and `check`, `dev` and `build`) write `.valance/types/<template>.d.mprx.ts`, so a component's declaration is checked against the names its template uses: `component(template, { props: { thme: … } })` is a compile-time error. This needs two options in your `tsconfig.json`:

package/dist/budgets.json

@@ -0,0 +1,175 @@
+{
+  "version": 1,
+  "about": "The ecosystem's budgets, as data (Bet 3; decisions W1 to W24). `project` is what `vlx build` holds an application to when its valance.json sets none (W14). `framework` is what the release check holds the reference applications and the runtime to (scripts/check-budgets.mjs, over the output of scripts/measure-footprint.mjs). Brotli bytes, because that is what travels (W2).",
+  "rule": "A ceiling is the baseline plus 5 percent, rounded up to the next 100 bytes (the next 10 under 1,000), then ratcheted down (W3). A ceiling above that needs `analysis`: the path of a size analysis that says why (W23a), and a decision row. The check refuses a raised ceiling without one.",
+  "project": {
+    "budgets": [
+      {
+        "type": "initial",
+        "warning": 105200,
+        "error": 210400
+      },
+      {
+        "type": "runtime",
+        "error": 192900
+      }
+    ],
+    "note": "W14: the framework's own start-up ceilings. `initial` warns above the largest reference application's JavaScript and CSS ceiling (docs-app) and fails at twice that; `runtime` is the WebAssembly runtime, the same for every application, so a growth of it fails the build of whoever upgrades."
+  },
+  "framework": {
+    "baseline": "docs/direction/baselines/2026-10-24-wp8-before.md",
+    "ceilings": [
+      {
+        "id": "counter.javascript",
+        "what": "Counter application, JavaScript, brotli",
+        "path": "counter.deduped.js.brotli",
+        "unit": "bytes",
+        "baseline": 93722,
+        "ceiling": 98500,
+        "previousCeiling": 92400,
+        "analysis": "docs/direction/evidence/measurement/size-2026-10-24.md"
+      },
+      {
+        "id": "counter.css",
+        "what": "Counter application, CSS, brotli",
+        "path": "counter.deduped.css.brotli",
+        "unit": "bytes",
+        "baseline": 1053,
+        "ceiling": 1200
+      },
+      {
+        "id": "runtime.wasm",
+        "what": "The WebAssembly runtime, brotli",
+        "path": "counter.deduped.wasm.brotli",
+        "unit": "bytes",
+        "baseline": 183629,
+        "ceiling": 192900,
+        "previousCeiling": 179400,
+        "analysis": "docs/direction/evidence/measurement/size-2026-10-24.md"
+      },
+      {
+        "id": "counter.transferred",
+        "what": "Counter application, everything the browser transfers, brotli",
+        "path": "browser.deduped.noThrottling.bytesTransferredBrotli",
+        "unit": "bytes",
+        "baseline": 279594,
+        "ceiling": 293600,
+        "previousCeiling": 274100,
+        "analysis": "docs/direction/evidence/measurement/size-2026-10-24.md"
+      },
+      {
+        "id": "docsApp.javascript",
+        "what": "docs-app, JavaScript, brotli",
+        "path": "docsApp.js.brotli",
+        "unit": "bytes",
+        "baseline": 98520,
+        "ceiling": 103500,
+        "previousCeiling": 97400,
+        "analysis": "docs/direction/evidence/measurement/size-2026-10-24.md"
+      },
+      {
+        "id": "docsApp.css",
+        "what": "docs-app, CSS, brotli",
+        "path": "docsApp.css.brotli",
+        "unit": "bytes",
+        "baseline": 1542,
+        "ceiling": 1700
+      },
+      {
+        "id": "docsApp.perPage",
+        "what": "Client JavaScript each added page costs, raw",
+        "path": "docsApp.perAddedPage.jsRawPerPage",
+        "unit": "bytes",
+        "baseline": 2471.5,
+        "ceiling": 2600,
+        "previousCeiling": 2600
+      },
+      {
+        "id": "counter.heap",
+        "what": "Counter, JavaScript heap after 200 updates",
+        "path": "browser.deduped.noThrottling.afterUpdates.jsHeapUsedBytes",
+        "unit": "bytes",
+        "baseline": 4575160,
+        "ceiling": 4630800,
+        "previousCeiling": 4630800,
+        "note": "W24: the 1,000-update heap gate stays off"
+      },
+      {
+        "id": "counter.wasmMemory",
+        "what": "Counter, WebAssembly memory after 200 updates",
+        "path": "browser.deduped.noThrottling.afterUpdates.wasmMemoryBytes",
+        "unit": "bytes",
+        "baseline": 1310720,
+        "ceiling": 1376300,
+        "previousCeiling": 4885800,
+        "note": "ratcheted down: W21 fixed the growth, the memory is flat"
+      },
+      {
+        "id": "docsApp.wasmMemory",
+        "what": "docs-app, WebAssembly memory after 200 updates",
+        "path": "browser.docsApp.noThrottling.afterUpdates.wasmMemoryBytes",
+        "unit": "bytes",
+        "baseline": 2293760,
+        "ceiling": 2408500
+      }
+    ],
+    "exact": [
+      {
+        "id": "wire.patch",
+        "what": "Bytes a PORT is sent for one changed item of 1,000 rows, as patches",
+        "path": "wire.1000.patchBytes",
+        "unit": "bytes",
+        "max": 202
+      }
+    ],
+    "ratios": [
+      {
+        "id": "counter.interactiveAt",
+        "what": "Counter, time until a click is handled, unthrottled",
+        "path": "browser.deduped.noThrottling.interactiveAtMs",
+        "max": 2
+      },
+      {
+        "id": "counter.interactiveAt4x",
+        "what": "Counter, time until a click is handled, 4x CPU",
+        "path": "browser.deduped.cpu4x.interactiveAtMs",
+        "max": 2
+      },
+      {
+        "id": "counter.firstPaint",
+        "what": "Counter, first paint, unthrottled",
+        "path": "browser.deduped.noThrottling.firstPaintMs",
+        "max": 2
+      },
+      {
+        "id": "update.10000",
+        "what": "`update`, 10,000 items, one changed",
+        "path": "update.10000.updateMs",
+        "max": 1.5
+      },
+      {
+        "id": "updateFromChanges.10000",
+        "what": "`update` from changes, 10,000 items",
+        "path": "update.10000.updateFromChangesMs",
+        "max": 1.5
+      }
+    ],
+    "known": [
+      {
+        "id": "wire.wholeTree",
+        "what": "Bytes a PORT is sent for one changed item of 1,000 rows, whole tree",
+        "path": "wire.1000.wholeTreeBytes",
+        "reason": "the Desktop protocol sends the whole tree on every update; patches are Bet 3's own work item, not WP8",
+        "owner": "unassigned"
+      },
+      {
+        "id": "installability",
+        "what": "The newest published @valancex set, with the release being measured, installs together",
+        "path": "newestInstallsTogether.installs",
+        "expect": true,
+        "reason": "Was red from MESH 0.16 until VALANCE 0.14: NEXUS 0.14 and PORT 0.12 stopped their MESH peer range at 0.15. With --tree the release candidate's own tarballs stand in for the published VALANCE packages, so a release is held to installing beside the newest of the others before it is published (a published VALANCE, the previous release, would gate a release on its predecessor)",
+        "owner": "WP8"
+      }
+    ]
+  }
+}

package/dist/build.d.ts

@@ -1,8 +1,14 @@
 import type { TargetId } from "./targets.js";
+import type { BudgetResult, SizeReport } from "./size.js";
 export interface Built {
     readonly dir: string;
     readonly files: ReadonlyArray<string>;
     readonly pages: ReadonlyArray<string>;
+    /** The web build's start-up and after-start sets, measured, and each budget it was held to (a production build only). */
+    readonly size?: SizeReport;
+    readonly budgets?: ReadonlyArray<BudgetResult>;
+    /** The size report as the lines a terminal prints. */
+    readonly report?: ReadonlyArray<string>;
 }
 /** The file a pathname is written to in the site: `/` → `index.html`, `/guide/x` → `guide/x/index.html`, relative to the base. */
 export declare const fileOf: (pathname: string, base: string) => string;
@@ -13,5 +19,7 @@ export interface BuildOptions {
     readonly onStage?: (stage: BuildStage) => void;
     /** Which of the project's targets to build; all of them by default. */
     readonly targets?: ReadonlyArray<TargetId>;
+    /** Called with the size report as soon as the bundle is measured, before a budget error stops the build (a terminal prints it). */
+    readonly onReport?: (lines: ReadonlyArray<string>) => void;
 }
 export declare const build: (root: string, options?: BuildOptions) => Promise<Built>;

package/dist/build.js

@@ -1,6 +1,7 @@
 // `vlx build`: the project → a static site in `dist/web/`. The stages, in order: configuration, content, templates, the browser bundle, then one document per page (and a 404 page, a sitemap
 // when the site has a published address). Everything is generated under `.valance/` first; `dist/` holds only what is built.
-import { build as bundle } from "vite";
+import { build as bundle, defaultServerConditions } from "vite";
+import { CONDITION } from "./libraries.js";
 import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
@@ -10,6 +11,8 @@ import { headersFile } from "./security.js";
 import { AppError } from "./diagnostics.js";
 import { generateContent, generateEntries, generateProgram } from "./emit.js";
 import { OUTPUT_DIR } from "./project.js";
+import { check, DEFAULT_BUDGETS, failure, lines, measure } from "./size.js";
+import { assertOneRuntime } from "./runtime-guard.js";
 import { baseConfig, createLoader, SERVER_ENTRY, templates } from "./vite.js";
 import { GENERATED_DIR } from "./project.js";
 /** The file a pathname is written to in the site: `/` → `index.html`, `/guide/x` → `guide/x/index.html`, relative to the base. */
@@ -35,14 +38,17 @@ const buildDesktop = async (root) => {
         logLevel: "warn",
         plugins: [templates(root)],
         cacheDir: join(root, GENERATED_DIR, "cache"),
-        ssr: { noExternal: true, target: "node" },
+        // the desktop engine is one file: everything is bundled, and a library resolves by its `valance` condition (K4)
+        resolve: { conditions: [CONDITION, ...defaultServerConditions] },
+        ssr: { noExternal: true, target: "node", resolve: { conditions: [CONDITION, ...defaultServerConditions] } },
+        esbuild: { keepNames: true },
         build: {
             ssr: join(root, GENERATED_DIR, "desktop.ts"),
             outDir: out,
             emptyOutDir: true,
             target: "node22",
-            minify: false,
-            chunkSizeWarningLimit: 4000,
+            // W10: the engine is minified (half the bytes; start-up measured no worse, 2026-10-24). Names are kept: errors and their `_tag` are read by name.
+            minify: "esbuild",
             rollupOptions: {
                 output: {
                     format: "es",
@@ -61,7 +67,7 @@ const buildDesktop = async (root) => {
     return { dir: out, files: ["desktop/engine.mjs", "desktop/mesh-runtime.wasm"], pages: [] };
 };
 /** The web build: the browser bundle into `out`, then one document per page. The loader is the one the templates were compiled with. */
-const buildWeb = async (root, config, loader, content, out, prefix, stage) => {
+const buildWeb = async (root, config, loader, content, out, prefix, stage, onReport) => {
     // The browser bundle first: it empties its directory, and the documents are written into it after.
     stage("bundle");
     await bundle({ ...baseConfig(root, config, out), mode: "production" });
@@ -74,7 +80,22 @@ const buildWeb = async (root, config, loader, content, out, prefix, stage) => {
             throw new AppError([{ file: out, line: 0, column: 0, code: "build-entry", message: "the bundle has no entry chunk" }]);
         }
         rmSync(join(dist, ".vite"), { recursive: true, force: true }); // the bundler's bookkeeping is not part of the site
-        const built = { script: `${config.web.base}${entry.file}`, styles: (entry.css ?? []).map((file) => `${config.web.base}${file}`) };
+        // The WebAssembly runtime is in the start-up set (H7): the head starts compiling it while the page's script downloads (W11).
+        const wasm = Object.values(manifest).find((chunk) => chunk.file.endsWith(".wasm"))?.file;
+        const built = {
+            script: `${config.web.base}${entry.file}`,
+            styles: (entry.css ?? []).map((file) => `${config.web.base}${file}`),
+            ...(wasm === undefined ? {} : { wasm: `${config.web.base}${wasm}` }),
+        };
+        // The size report: the start-up set and the after-start set, held to the project's budgets or the framework's (W9, W14). Production only.
+        const size = measure(dist, manifest, wasm);
+        const budgets = check(size, config.budgets ?? DEFAULT_BUDGETS);
+        const report = lines(size, budgets);
+        onReport(report);
+        const over = failure(budgets);
+        if (over !== undefined) {
+            throw over;
+        }
         const files = [];
         const write = (relative, text) => {
             mkdirSync(dirname(join(dist, relative)), { recursive: true });
@@ -95,7 +116,7 @@ const buildWeb = async (root, config, loader, content, out, prefix, stage) => {
         if (config.web.headers) {
             write("_headers", headersFile(config));
         }
-        return { dir: dist, files: files.map((file) => `${prefix}${file}`), pages };
+        return { dir: dist, files: files.map((file) => `${prefix}${file}`), pages, size, budgets, report };
     }
 };
 export const build = async (root, options = {}) => {
@@ -115,6 +136,8 @@ export const build = async (root, options = {}) => {
             },
         ]);
     }
+    // Production only (`vlx dev` does not build through here): one copy of the MESH runtime, or the site ships its WebAssembly module more than once (W20).
+    assertOneRuntime(root);
     generateEntries(root, config);
     stage("content");
     const content = generateContent(root, config);
@@ -125,7 +148,7 @@ export const build = async (root, options = {}) => {
         await generateProgram(root, await loadAuthor(loader, root), config, selected);
         // Each target writes to a directory of its own, whatever else the project has: dist/web/ and dist/desktop/.
         if (selected.includes("web")) {
-            built.push(await buildWeb(root, config, loader, content, `${OUTPUT_DIR}/web`, "web/", stage));
+            built.push(await buildWeb(root, config, loader, content, `${OUTPUT_DIR}/web`, "web/", stage, options.onReport ?? (() => undefined)));
         }
         if (selected.includes("desktop")) {
             stage("bundle");
@@ -135,5 +158,11 @@ export const build = async (root, options = {}) => {
     finally {
         await loader.close();
     }
-    return { dir: join(root, OUTPUT_DIR), files: built.flatMap((each) => each.files), pages: built.flatMap((each) => each.pages) };
+    const web = built.find((each) => each.size !== undefined);
+    return {
+        dir: join(root, OUTPUT_DIR),
+        files: built.flatMap((each) => each.files),
+        pages: built.flatMap((each) => each.pages),
+        ...(web?.size === undefined ? {} : { size: web.size, budgets: web.budgets, report: web.report }),
+    };
 };

package/dist/check.js

@@ -1,6 +1,7 @@
 import { AppError } from "./diagnostics.js";
 import { loadAuthor } from "./author.js";
 import { loadConfig } from "./config.js";
+import { librariesOf } from "./libraries.js";
 import { generateContent, generateEntries, generateProgram } from "./emit.js";
 import { createLoader } from "./vite.js";
 const collect = async (into, work) => {
@@ -22,6 +23,8 @@ export const check = async (root) => {
     if (config === undefined) {
         return { diagnostics: problems, pages: 0, components: [] };
     }
+    // a library whose marker is wrong is reported first: when the application cannot even be loaded, it is the likely reason (a package the build does not process)
+    problems.push(...librariesOf(root).problems);
     generateEntries(root, config);
     const content = await collect(problems, () => generateContent(root, config));
     const server = await createLoader(root, config);
@@ -29,7 +32,9 @@ export const check = async (root) => {
         const author = await collect(problems, () => loadAuthor(server, root));
         const failedAuthor = problems.some((each) => each.file === "src/main.ts");
         const components = failedAuthor ? undefined : await collect(problems, () => generateProgram(root, author, config));
-        return { diagnostics: problems, pages: content?.pages.length ?? 0, components: components ?? [] };
+        // (the templates stage reports the same marker problems; once is enough)
+        const once = problems.filter((each, index) => problems.findIndex((other) => other.file === each.file && other.code === each.code && other.message === each.message) === index);
+        return { diagnostics: once, pages: content?.pages.length ?? 0, components: components ?? [] };
     }
     finally {
         await server.close();