@adia-ai/a2ui-compose 0.7.19 → 0.7.21

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog — @adia-ai/a2ui-compose
 
+## [0.7.21] — 2026-06-10
+
+### Maintenance
+- **Lockstep version bump only.** No source changes in this package; bumped to maintain the 9-package version coherence enforced by `scripts/release/check-lockstep.mjs`. Substantive v0.7.21 work shipped in corpus harvester scope expansion (gated web-components examples root) + 26 curated chunks (368->394). See `packages/a2ui/corpus/CHANGELOG.md#0721--2026-06-10` for details.
+
+## [0.7.20] — 2026-06-10
+
+### Fixed
+- **Corpus retrieval works on STATICALLY-served sites (no vite).** The browser corpus loaders (`strategies/zettel/composition-library.js`, `strategies/_shared/chunk-loader.js`) used `import.meta.glob` — a vite-only mechanism — so the corpus-first path silently loaded 0 chunks on the deployed static site and every intent fell through to the LLM. New **third runtime branch** (Node / vite-glob / **static-fetch**): one `_index.json` request carries the full scoring metadata; matched chunk bodies hydrate lazily. Detection = attempting the glob *call* in try/catch (`typeof import.meta.glob` is undefined in BOTH vite-dev and raw ESM — only the rewritten call discriminates). A parity guard in `generator-adapter` keeps static results identical to Node (template-less partials fall through instead of emitting empty surfaces). Verified: a plain static server with **no LLM** retrieves `contact-form-card` verbatim (4 labeled fields, 92/100, ~8 ms).
+
+### Added
+- **Anti-pattern fold-in for generated output** — `foldInAntiPatterns(messages, validation)` projects the flat component messages into an HTML sketch (via the runtime tag registry), runs the anti-pattern registry over it, and folds violations into the validation result (one warning each + a 10-point score dock). Wired into all monolithic generate paths (instant / thinking / pro — 5 call sites), so the canvas's validation badge now reflects anti-patterns: the incident's junk contact form scores 65 with 3 named violations instead of badging clean. Fails open — the fold-in can never break generation.
+
 ## [0.7.19] — 2026-06-10
 
 ### Maintenance

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adia-ai/a2ui-compose",
-  "version": "0.7.19",
+  "version": "0.7.21",
   "description": "AdiaUI A2UI compose engine \u2014 framework-agnostic. Takes natural-language intents + a catalog and produces A2UI protocol messages. Pairs with `@adia-ai/a2ui-retrieval` (intent classification, catalog lookup) and `@adia-ai/a2ui-validator` (schema + semantic checks).",
   "type": "module",
   "exports": {

package/strategies/_shared/chunk-loader.js

@@ -28,7 +28,13 @@ let _state = null;       // { chunks: Map<name, record>, byKind: Map<kind, Set<n
 let _loadPromise = null;
 
 // ── Browser glob ───────────────────────────────────────────────────
-// Vite resolves this at build time; in Node the variable is unused.
+// Vite rewrites this CALL at transform time. On the static deploy (raw
+// source, no Vite) the call hits the real `import.meta.glob` — which is
+// undefined at runtime — and throws → caught → `_globModules` null → fetch
+// branch. `import.meta.glob` is a compile-time macro, NOT a runtime
+// function, so `typeof import.meta.glob` is undefined in BOTH Vite and
+// static — the only reliable discriminator is whether this CALL yielded
+// loaders. See composition-library.js for the full tri-mode rationale.
 let _globModules = null;
 if (!IS_NODE) {
   try {
@@ -37,9 +43,18 @@ if (!IS_NODE) {
       import: 'default',
     });
   } catch {
-    // Not in a Vite context — fall back to empty corpus
+    // No Vite transform here (static deploy) — fall back to the fetch branch.
   }
 }
+const HAS_VITE_GLOB =
+  !IS_NODE && !!_globModules && Object.keys(_globModules).length > 0;
+
+// Relative-to-module corpus base for the static branch (same path the glob
+// trusts; mount-point-independent). Verified 2026-06-10.
+const _CORPUS_CHUNKS_BASE =
+  !IS_NODE && !HAS_VITE_GLOB
+    ? new URL('../../../corpus/chunks/', import.meta.url)
+    : null;
 
 // ── Public API ─────────────────────────────────────────────────────
 async function _load() {
@@ -48,14 +63,55 @@ async function _load() {
   _loadPromise = (async () => {
     if (IS_NODE) {
       _state = await _loadNode();
-    } else {
+    } else if (HAS_VITE_GLOB) {
       _state = await _loadBrowser();
+    } else {
+      _state = await _loadStatic();
     }
     return _state;
   })();
   return _loadPromise;
 }
 
+/**
+ * Static-browser loader — fetch `_index.json` for keyword scoring. The
+ * index carries name/kind/primary/nested/pages (everything `searchChunks`
+ * ranks on); chunk BODIES (html / template) are fetched lazily by
+ * `getChunk` so page-load is one request, not 339. Degrades to an empty
+ * corpus (not a throw) on fetch / parse failure.
+ */
+async function _loadStatic() {
+  const chunks = new Map();
+  const byKind = new Map();
+  if (!_CORPUS_CHUNKS_BASE) return { chunks, byKind };
+  let index;
+  try {
+    const res = await fetch(new URL('_index.json', _CORPUS_CHUNKS_BASE));
+    if (!res.ok) return { chunks, byKind };
+    index = await res.json();
+  } catch {
+    return { chunks, byKind };
+  }
+  const entries = Array.isArray(index?.chunks) ? index.chunks : [];
+  for (const entry of entries) {
+    if (!entry?.name) continue;
+    // Normalize the index entry to the per-chunk record shape `searchChunks`
+    // expects: `pages` (array) → `source`/`page` (string). `_bodyUrl` +
+    // `_hydrated` mark the record for lazy body-fetch in getChunk.
+    const rec = {
+      ...entry,
+      source: Array.isArray(entry.pages) ? entry.pages[0] : (entry.source || entry.page || ''),
+      _bodyUrl: new URL(`${entry.name}.json`, _CORPUS_CHUNKS_BASE).href,
+      _hydrated: false,
+    };
+    chunks.set(rec.name, rec);
+    const kind = rec.kind || 'block';
+    if (!byKind.has(kind)) byKind.set(kind, new Set());
+    byKind.get(kind).add(rec.name);
+  }
+  return { chunks, byKind };
+}
+
 async function _loadNode() {
   const fs = await import(/* @vite-ignore */ 'node:fs/promises');
   const path = await import(/* @vite-ignore */ 'node:path');
@@ -174,7 +230,24 @@ export async function searchChunks(query, { kind, limit = 20 } = {}) {
 export async function getChunk(name) {
   if (!name) return null;
   const { chunks } = await _load();
-  return chunks.get(name) || null;
+  const rec = chunks.get(name) || null;
+  if (!rec) return null;
+  // Static-browser: the record came from `_index.json` (scoring fields only).
+  // Fetch + merge the full body (html / template / slots / attrs) on first
+  // access, then cache. No-op in Node / Vite (full record already loaded).
+  if (rec._bodyUrl && !rec._hydrated) {
+    try {
+      const res = await fetch(rec._bodyUrl);
+      if (res.ok) {
+        const body = await res.json();
+        Object.assign(rec, body);
+      }
+    } catch {
+      // Leave the scoring-only record; consumers must tolerate a missing body.
+    }
+    rec._hydrated = true; // don't retry on every access, even if the fetch failed
+  }
+  return rec;
 }
 
 /**

package/strategies/monolithic/_shared.js

@@ -8,6 +8,8 @@
  */
 
 import { listPatterns } from '../../core/reference.js';
+import { resolveTag } from '../../../runtime/registry.js';
+import { checkAllAntiPatterns } from '../../../retrieval/anti-patterns.js';
 import { store } from '../../core/state.js';
 import { checkIntentAlignment } from '../../../retrieval/intent/intent-alignment.js';
 import { composeSubtasks } from '../../../retrieval/intent/decomposer.js';
@@ -1560,3 +1562,58 @@ function prettyComponentName(name) {
   const article = /^[aeiou]/i.test(spaced) ? 'an' : 'a';
   return `${article} ${spaced}`;
 }
+
+/**
+ * Anti-pattern fold-in for generated output (the gen-UI contact-form
+ * incident, 2026-06-10): validateSchema scores structure but never ran the
+ * anti-pattern registry, so a generated form with a text-ui "label" inside
+ * field-ui, display="none" attributes, and input-ui[type=textarea] badged
+ * a clean score in the canvas.
+ *
+ * Projects the flat component messages into a light HTML sketch (open tags
+ * + attrs, tree-ordered via children id refs) — enough surface for the
+ * regex/function checks in retrieval/anti-patterns.js — runs
+ * checkAllAntiPatterns over it, then folds violations into the validation
+ * object: one warning per violation and a 10-point score dock each
+ * (floored at 0). Mutates + returns `validation`.
+ *
+ * @param {object[]} messages — A2UI messages (flat adjacency components)
+ * @param {{score: number, warnings?: string[]}} validation — from validateSchema
+ * @returns {typeof validation}
+ */
+export function foldInAntiPatterns(messages, validation) {
+  try {
+    const components = (messages || []).flatMap((m) => m.components || []);
+    if (!components.length || !validation) return validation;
+    const byId = new Map(components.map((c) => [c.id, c]));
+    const referenced = new Set(components.flatMap((c) => c.children || []));
+    const roots = components.filter((c) => !referenced.has(c.id));
+    const sketch = [];
+    const emit = (c, depth) => {
+      if (!c || depth > 12) return;
+      const tag = resolveTag(c.type) || String(c.type || '').toLowerCase();
+      const attrs = Object.entries(c.props || {})
+        .filter(([, v]) => v !== false && v != null && typeof v !== 'object')
+        .map(([k, v]) => ` ${k}="${String(v).replace(/"/g, '"')}"`)
+        .join('');
+      sketch.push(`<${tag}${attrs}>`);
+      if (typeof (c.props || {}).textContent === 'string') sketch.push((c.props || {}).textContent);
+      for (const id of c.children || []) emit(byId.get(id), depth + 1);
+      sketch.push(`</${tag}>`);
+    };
+    for (const r of roots) emit(r, 0);
+    const violations = checkAllAntiPatterns(sketch.join('\n'));
+    if (violations.length) {
+      validation.warnings = [
+        ...(validation.warnings || []),
+        ...violations.map((v) => `anti-pattern ${v.name}: ${v.description} Fix: ${v.fix}`),
+      ];
+      validation.antiPatterns = violations.map((v) => v.name);
+      validation.score = Math.max(0, (validation.score || 0) - 10 * violations.length);
+    }
+    return validation;
+  } catch {
+    // The fold-in must never break generation — fail open.
+    return validation;
+  }
+}

package/strategies/monolithic/generate-instant.js

@@ -13,8 +13,7 @@ import { feedbackStore } from '../../../retrieval/feedback/feedback-store.js';
 import { store, engine } from '../../core/state.js';
 import { isRecording } from '../../../retrieval/feedback/dialog-recorder.js';
 import {
-  generateSuggestions,
-} from './_shared.js';
+  generateSuggestions, foldInAntiPatterns } from './_shared.js';
 
 export async function generateInstant({ intent, executionId, storeId, analysis, priorComponentsFromPayload, context }) {
   // Forward-compat: instant mode is pattern-match-only and doesn't iterate
@@ -168,7 +167,7 @@ export async function generateInstant({ intent, executionId, storeId, analysis,
   });
 
   // ── Validate stage ──
-  const validation = validateSchema(messages, { intent, context });
+  const validation = foldInAntiPatterns(messages, validateSchema(messages, { intent, context }));
   engine.submitStage(execId, 'validate', {
     ...validation,
     confidence: validation.score / 100,

package/strategies/monolithic/generate-pro.js

@@ -22,8 +22,7 @@ import {
   buildCanvasDiffPrompt,
   parseA2UIResponse,
   buildRepairPrompt,
-  generateSuggestions,
-} from './_shared.js';
+  generateSuggestions, foldInAntiPatterns } from './_shared.js';
 
 export async function generatePro({ intent, executionId, storeId, llmAdapter, analysis, priorComponentsFromPayload, context }) {
   const execId = executionId;
@@ -404,7 +403,7 @@ ${buildCanvasDiffPrompt(intent, priorComponents, { originalIntent })}`;
   });
 
   // ── Stage 5: Validate + repair ──
-  let validation = validateSchema(messages, { intent, context });
+  let validation = foldInAntiPatterns(messages, validateSchema(messages, { intent, context }));
   if (!validation.valid) {
     try {
       const failedChecks = validation.checks.filter(c => !c.passed);
@@ -413,7 +412,7 @@ ${buildCanvasDiffPrompt(intent, priorComponents, { originalIntent })}`;
         systemPrompt,
       });
       messages = parseA2UIResponse(repairResponse.content, { executionId: execId, intent, mode: 'pro', stopReason: repairResponse.stopReason });
-      validation = validateSchema(messages, { intent, context });
+      validation = foldInAntiPatterns(messages, validateSchema(messages, { intent, context }));
     } catch { /* keep original */ }
   }
   engine.submitStage(execId, 'validate', { ...validation, confidence: validation.score / 100 });

package/strategies/monolithic/generate-thinking.js

@@ -18,8 +18,7 @@ import {
   buildChatMessages,
   parseA2UIResponse,
   buildRepairPrompt,
-  generateSuggestions,
-} from './_shared.js';
+  generateSuggestions, foldInAntiPatterns } from './_shared.js';
 
 export async function generateThinking({ intent, executionId, storeId, llmAdapter, analysis, priorComponentsFromPayload, context }) {
   // Note: thinking mode currently composes from scratch each turn. The
@@ -129,7 +128,7 @@ export async function generateThinking({ intent, executionId, storeId, llmAdapte
   // Either failing triggers a repair attempt. Catalog failures are typically
   // small (unknown prop, wrong enum, missing required id) and fix cleanly in
   // one repair round. Three-attempt cap preserved from the original loop.
-  let validation = validateSchema(messages, { intent, context });
+  let validation = foldInAntiPatterns(messages, validateSchema(messages, { intent, context }));
   let catalogValidation = await validateCatalog(messages);
   let attempts = 0;
 
@@ -146,7 +145,7 @@ export async function generateThinking({ intent, executionId, storeId, llmAdapte
       });
       messages = parseA2UIResponse(repairResponse.content, { executionId: execId, mode: 'thinking', intent, stopReason: repairResponse.stopReason });
       if (isRecording()) { lastRawResponse = repairResponse.content; lastTokens = repairResponse.usage || lastTokens; }
-      validation = validateSchema(messages, { intent, context });
+      validation = foldInAntiPatterns(messages, validateSchema(messages, { intent, context }));
       catalogValidation = await validateCatalog(messages);
     } catch {
       break; // stop repair loop on adapter error

package/strategies/zettel/composition-library.js

@@ -28,6 +28,31 @@
 // `import 'node:fs'` poisoned the browser bundle the moment any
 // app/playground reached `core/reference.js` → composition-library.
 // Pattern mirrors `retrieval/component-catalog.js`.
+//
+// 2026-06-10: TRI-mode loader. The original dual-mode pattern assumed
+// every browser context is a Vite dev server. The STATIC deploy
+// (ui-kit.exe.xyz) serves the raw source JS — there is no Vite to transform
+// the glob — so the glob `try/catch` swallowed silently and loaded 0 chunks.
+// Every canvas intent then "composition-retrieval missed" on prod even
+// though the chunk scored 66 in Node. Third branch: static-browser → fetch
+// the corpus over HTTP.
+//   - Node (fs)             — server / eval / smoke
+//   - Vite browser (glob)   — `npm run dev`
+//   - Static browser (fetch)— deployed dist (no Vite, no /api/generate)
+//
+// CRUX — how we tell Vite-browser from static-browser (2026-06-10):
+// `import.meta.glob` is a Vite **compile-time macro on the CALL expression**,
+// NOT a runtime function. Vite rewrites `import.meta.glob('…')` into an
+// object literal at transform time, but a bare reference like
+// `typeof import.meta.glob` is left untouched — so at RUNTIME
+// `import.meta.glob` is `undefined` in BOTH Vite-dev and static contexts
+// (verified empirically 2026-06-10). The only reliable discriminator is to
+// ATTEMPT the call in a try/catch: in Vite it was already rewritten to the
+// object literal (succeeds, returns N loaders); on the raw static site the
+// call hits the real `import.meta.glob` which is undefined → throws
+// `import.meta.glob is not a function` → caught → we take the fetch branch.
+// (This is parse-safe: `import.meta` is a real object in every ES module;
+// the throw is a runtime TypeError, not a SyntaxError.)
 const IS_NODE =
   typeof process !== 'undefined' &&
   typeof process.versions?.node === 'string';
@@ -35,7 +60,8 @@ const IS_NODE =
 /** @type {Map<string, object>} */
 const compositions = new Map();
 
-// Vite resolves this at build time; at runtime in Node the variable is unused.
+// Vite rewrites this call at transform time; on the static site the call
+// throws (no Vite) → `_globChunkModules` stays null → fetch branch runs.
 let _globChunkModules = null;
 if (!IS_NODE) {
   try {
@@ -45,20 +71,27 @@ if (!IS_NODE) {
       eager: false,
     });
   } catch {
-    // Not in a Vite context — no chunk data in this realm.
+    // No Vite transform here (static deploy) — fall through to the fetch branch.
   }
 }
+// `HAS_VITE_GLOB` is now decided by whether the glob CALL produced loaders,
+// not by an (always-undefined-at-runtime) `typeof` probe.
+const HAS_VITE_GLOB =
+  !IS_NODE && !!_globChunkModules && Object.keys(_globChunkModules).length > 0;
 
 /**
  * Promote an annotated chunk record to composition shape. Lifts
  * `metadata.{domain,description,keywords,related,tags}` to top-level
  * fields so the existing searchAll scorer can read them uniformly.
  */
-function chunkToComposition(chunkDoc, sourcePath) {
+function chunkToComposition(chunkDoc, sourcePath, { bodyUrl = null } = {}) {
   const meta = chunkDoc.metadata || {};
   return {
     _kind: 'annotated-chunk',
     _sourceFile: sourcePath,
+    // Static-browser only: URL to fetch the chunk body (template) on demand.
+    // null in Node / Vite, where `template` is already populated eagerly.
+    _bodyUrl: bodyUrl,
     name: chunkDoc.name,
     kind: 'composition', // honest with the searchAll filter
     domain: meta.domain,
@@ -66,7 +99,7 @@ function chunkToComposition(chunkDoc, sourcePath) {
     keywords: meta.keywords || [],
     related: meta.related || [],
     tags: meta.tags || {},
-    template: chunkDoc.template,
+    template: chunkDoc.template ?? null,
   };
 }
 
@@ -91,6 +124,28 @@ function registerChunk(doc, sourcePath) {
   return 1;
 }
 
+/**
+ * Static-browser only: register a chunk from its `_index.json` entry for
+ * SCORING (name + metadata.{domain,description,keywords} — verified at
+ * 2026-06-10 to be byte-identical to the per-chunk file's metadata). The
+ * `template` is NOT in the index; it is fetched lazily by
+ * `hydrateComposition(name)` when a strong match is actually emitted, so
+ * page-load costs one request (the 281 KB index) instead of 339.
+ *
+ * Index entries carry no `template`, so the eager `registerChunk` gate
+ * (which requires a non-empty template) would reject every one. We apply
+ * the SAME metadata gate (domain OR keywords present) but defer the
+ * template requirement to hydration time.
+ */
+function registerIndexEntry(entry, bodyUrl) {
+  if (!entry?.metadata || !entry.name) return 0;
+  const meta = entry.metadata;
+  if (!meta.domain && !(meta.keywords && meta.keywords.length > 0)) return 0;
+  // template: null here — hydrated on demand. searchAll never reads it.
+  compositions.set(entry.name, chunkToComposition(entry, entry.name, { bodyUrl }));
+  return 1;
+}
+
 async function _loadAllNode() {
   const fs = await import(/* @vite-ignore */ 'node:fs');
   const path = await import(/* @vite-ignore */ 'node:path');
@@ -141,14 +196,61 @@ async function _loadAllBrowser() {
   return annotatedChunkCount;
 }
 
+// Base URL for the corpus on a static deploy. Relative-to-module
+// (`import.meta.url`) — NOT an absolute `/packages/...` path — deliberately:
+//   1. It is the SAME path the Vite glob trusts ('../../../corpus/chunks/*'),
+//      so dev and prod resolve through one mental model.
+//   2. It is mount-point-independent: works whether dist is served at `/`,
+//      under a sub-path, or via the dist symlink layout
+//      (dist/node_modules/@adia-ai/a2ui-compose → packages/a2ui/compose),
+//      because `import.meta.url` always reflects the actually-served path.
+//      Verified 2026-06-10: `new URL('../../../corpus/chunks/_index.json',
+//      import.meta.url)` → `<root>/packages/a2ui/corpus/chunks/_index.json`.
+const _CORPUS_CHUNKS_BASE =
+  !IS_NODE && !HAS_VITE_GLOB
+    ? new URL('../../../corpus/chunks/', import.meta.url)
+    : null;
+
+/**
+ * Static-browser loader. Fetches `_index.json` ONCE and registers every
+ * chunk for scoring. Bodies (templates) are fetched lazily by
+ * `hydrateComposition` so page-load stays at a single request, not 339.
+ *
+ * Degrades to 0 chunks (not a throw) on any fetch / parse failure — same
+ * graceful-empty contract as the Node and Vite branches.
+ */
+async function _loadAllStatic() {
+  if (!_CORPUS_CHUNKS_BASE) return 0;
+  let index;
+  try {
+    const res = await fetch(new URL('_index.json', _CORPUS_CHUNKS_BASE));
+    if (!res.ok) return 0;
+    index = await res.json();
+  } catch {
+    return 0;
+  }
+  const entries = Array.isArray(index?.chunks) ? index.chunks : [];
+  let count = 0;
+  for (const entry of entries) {
+    if (!entry?.name) continue;
+    const bodyUrl = new URL(`${entry.name}.json`, _CORPUS_CHUNKS_BASE).href;
+    count += registerIndexEntry(entry, bodyUrl);
+  }
+  return count;
+}
+
 /**
  * Load all annotated chunks into the in-memory map. Returns a stats
- * snapshot. In Node, runs synchronously via `fs.readFileSync`; in the
- * browser, dispatches the Vite glob loaders in parallel.
+ * snapshot. In Node, runs synchronously via `fs.readFileSync`; in the Vite
+ * browser, dispatches the glob loaders in parallel; on a static deploy,
+ * fetches the index (bodies lazy-loaded on emit).
  */
 export async function loadAll() {
   compositions.clear();
-  const annotatedChunkCount = IS_NODE ? await _loadAllNode() : await _loadAllBrowser();
+  let annotatedChunkCount;
+  if (IS_NODE) annotatedChunkCount = await _loadAllNode();
+  else if (HAS_VITE_GLOB) annotatedChunkCount = await _loadAllBrowser();
+  else annotatedChunkCount = await _loadAllStatic();
   _autoLoaded = true;
   _loadStats = {
     compositionCount: compositions.size,
@@ -158,6 +260,40 @@ export async function loadAll() {
   return _loadStats;
 }
 
+/**
+ * Ensure a composition's `template` (body) is loaded before a consumer
+ * resolves it. No-op in Node / Vite (the eager load already populated
+ * `template`). On a static deploy, fetches `<name>.json` once, patches the
+ * in-memory record's `template`, and caches it for subsequent calls.
+ *
+ * The zettel adapter's STRONG-MATCH branch awaits this immediately before
+ * `getComposition(name)` so verbatim emission has a body. Index-only
+ * scoring + lazy single-body hydration is what keeps the static page-load
+ * to one request — `searchAll` itself never needs the template.
+ *
+ * @param {string} name
+ * @returns {Promise<object|undefined>} the (now-hydrated) composition record
+ */
+export async function hydrateComposition(name) {
+  const rec = compositions.get(name);
+  if (!rec) return undefined;
+  // Already has a body (Node / Vite, or a prior hydration) — done.
+  if (Array.isArray(rec.template) && rec.template.length > 0) return rec;
+  if (!rec._bodyUrl) return rec; // not a static-deferred record; nothing to fetch
+  try {
+    const res = await fetch(rec._bodyUrl);
+    if (!res.ok) return rec;
+    const doc = await res.json();
+    if (Array.isArray(doc?.template) && doc.template.length > 0) {
+      rec.template = doc.template;
+    }
+  } catch {
+    // Leave template null — resolveComposition handles an empty template
+    // (emits nothing) rather than throwing.
+  }
+  return rec;
+}
+
 // Eager top-level load so synchronous getters (getComposition,
 // getAllCompositions, searchAll) work for consumers that don't call
 // loadAll themselves — test harnesses, smoke scripts, and the
@@ -172,6 +308,10 @@ if (IS_NODE && !_autoLoaded) {
   await loadAll();
 } else if (!IS_NODE && !_autoLoaded) {
   // Fire-and-forget; do not block module import on the network round-trips.
+  // Covers BOTH browser branches (Vite glob + static fetch). Consumers that
+  // need the map populated before a synchronous searchAll MUST `await
+  // loadAll()` (or await the adapter's own boot). The canvas does: its
+  // generateViaZettel awaits a fresh loadAll on the static-browser path.
   loadAll().catch(() => { /* swallow; browsers that don't need this path won't trip */ });
 }
 

package/strategies/zettel/generator-adapter.js

@@ -29,6 +29,7 @@
  */
 import {
   getComposition,
+  hydrateComposition,
   searchAll,
 } from './composition-library.js';
 import { resolveComposition, templateToMessages } from './composer.js';
@@ -121,8 +122,25 @@ export async function generateZettel({ intent, mode = 'instant', llmAdapter = nu
 
   // ── Strong retrieval match: emit verbatim (turn 1 only — iteration branch above handles repeats) ──
   if (strongMatch) {
+    // On a static deploy the composition was registered from `_index.json`
+    // for SCORING only — its `template` is fetched lazily here, right before
+    // we resolve it. No-op in Node / Vite (template already populated). This
+    // keeps the static page-load to a single index request; only the
+    // actually-emitted match pays for its body. 2026-06-10.
+    await hydrateComposition(composition.name);
     const comp = getComposition(composition.name);
     const template = resolveComposition(comp);
+    // Parity guard: Node's `registerChunk` excludes template-less chunks, so
+    // they never reach this branch server-side. The static index-scoring gate
+    // is looser (it can't see templates in `_index.json`), so a handful of
+    // body-less partials (auth-card-header, onb-step-*, …) COULD surface as a
+    // strong match on a static deploy. If hydration produced no usable
+    // template, treat it as a non-match and fall through — keeping the
+    // static result identical to what Node would emit (synthesis / atoms),
+    // never an empty verbatim surface.
+    if (!Array.isArray(template) || template.length === 0) {
+      // fall through to the weak/no-match paths below
+    } else {
     const messages = toUpdateComponentsMessages(template);
     const validation = validateSchema(messages, { intent });
     const rank = hits.findIndex((h) => h.type === 'composition' && h.name === composition.name) + 1;
@@ -147,6 +165,7 @@ export async function generateZettel({ intent, mode = 'instant', llmAdapter = nu
       candidates: hits,
       sessionTurns: priorTurns.length + 1,
     };
+    } // end else (template present)
   }
 
   // ── Weak/no retrieval: bridge to chunk-zettel synthesis (the §37 successor) ──