@adia-ai/a2ui-compose 0.4.2 → 0.4.4

package/strategies/zettel/synthesizer.js

@@ -1,343 +1,22 @@
 /**
- * LLM-powered composition synthesis for zettel.
+ * Composition synthesizer — RETIRED (§37, 2026-05-12).
  *
- * When pure retrieval fails (no composition match or weak top score), ask an
- * LLM to assemble a composition from the fragment catalog. The LLM gets:
- *   - the intent
- *   - the fragment catalog (name, semantic_role, shape, slots, description)
- *   - 2–3 existing compositions as in-context examples
+ * Previously: when zettel retrieval was weak, this called the LLM to
+ * assemble a NEW composition from the fragment catalog (technique B/C
+ * fragment-graph synthesis). Fragments are retired and there's no
+ * fragment catalog to draw from anymore. The deterministic path
+ * (`resolveComposition` on a retrieved composition) still works.
  *
- * It must return JSON matching the composition schema — a template array where
- * nodes either declare a component inline OR reference a fragment via $fragment
- * with bindings. We validate the output against slots (required bindings present,
- * fragment names exist) before feeding it to the composer.
- *
- * This is the reasoning layer on top of pure retrieval. It turns fragments into
- * the LLM's typed vocabulary — smaller, more structured than a 97-pattern corpus.
- */
-
-import { getAllFragments, getAllCompositions } from './fragment-library.js';
-import { resolveComposition, templateToMessages } from './composer.js';
-
-/**
- * Build a fragment catalog summary for the LLM prompt — name, role, shape,
- * slot contract, description, AND the internal template so the LLM can inline
- * the fragment if it needs to edit interior nodes (technique B in the prompt).
- */
-function buildFragmentCatalog() {
-  const frags = getAllFragments();
-  return frags.map((f) => ({
-    name: f.name,
-    semantic_role: f.semantic_role,
-    shape: f.shape,
-    description: f.description,
-    keywords: f.keywords || [],
-    slots: (f.slots || []).map((s) => ({
-      name: s.name,
-      attribute: s.attribute,
-      required: !!s.required,
-      defaultValue: s.defaultValue,
-      description: s.description,
-    })),
-    template: f.template,
-  }));
-}
-
-/**
- * Pick 2–3 in-context example compositions. We want variety (different domains)
- * so the LLM sees the composition shape across intents.
- */
-function buildExamples(count = 3) {
-  const comps = getAllCompositions();
-  const byDomain = new Map();
-  for (const c of comps) {
-    if (!byDomain.has(c.domain)) byDomain.set(c.domain, c);
-    if (byDomain.size >= count) break;
-  }
-  return [...byDomain.values()].map((c) => ({
-    name: c.name,
-    domain: c.domain,
-    description: c.description,
-    template: c.template,
-  }));
-}
-
-const SYSTEM_PROMPT = `You are a UI composer. Given a user intent, you assemble a UI composition from a catalog of reusable fragments.
-
-⚠️ ABSOLUTE OUTPUT CONTRACT ⚠️
-Your ENTIRE response must be a single JSON object. No prose before or after. No clarifying
-questions. No "I'll add..." narration. No markdown fences. Just JSON.
-If a user request is ambiguous, make a best-guess decision and emit the JSON. Never ask.
-
-A composition is a flat-adjacency array of A2UI nodes. Each node either:
-  (a) declares a component inline:
-      { "id": "foo", "component": "Column", "children": ["a","b"], "gap": "3" }
-  (b) references a fragment by name with slot bindings:
-      { "id": "foo", "$fragment": "labeled-input",
-        "bindings": { "label": "Email", "name": "email", "type": "email" } }
-
-Rules:
-  1. Exactly one root node with id "root". Other nodes reference it via children arrays.
-  2. Every $fragment ref must name a fragment that exists in the catalog. Never invent fragment names.
-  3. Every required slot on a referenced fragment MUST appear in bindings.
-  4. Prefer fragments over inline nodes when an atom fits — they carry semantics and reuse.
-  5. Use inline nodes (Column/Row/Card/Section/Text/Button/etc.) for layout, glue, and gaps between fragments.
-  6. Keep compositions compact — 6 to 15 nodes is typical. Don't over-engineer.
-
-EXTENDING FRAGMENTS — four techniques when a fragment almost fits but needs more.
-STRONGLY PREFER technique (A) for "add X above/below the heading" requests — those
-are structurally OUTSIDE the header slot grid, not inside it.
-
-  A) Place content ABOVE/BELOW a fragment (outside it — MOST ROBUST).
-     When the user says "add a logo above the heading" in a form, place a new node
-     BEFORE the header fragment at the composition root:
-       { "id": "root", "component": "Card", "children": ["brand", "hdr", "sec", "ftr"] }
-       { "id": "brand", "component": "Row", "children": ["logo"], "justify": "center" }
-       { "id": "logo", "component": "Image", "src": "/logo.svg", "alt": "Brand" }
-       { "id": "hdr", "$fragment": "card-header-with-description", "bindings": { … } }
-     ⚠️ BUT: Card direct children are restricted to <header>, <section>, <footer>.
-     For logos above the header, prefer technique B (inline the header) OR slot
-     the logo into the header with slot="icon" via technique C.
-
-  B) Inject extra children INTO a fragment's root WITH a slot declaration.
-     A $fragment node can declare prependChildren or appendChildren (arrays of node
-     ids). Injected children should declare slot="…" when the host uses slot-grid
-     layout. Example — add a logo to a card-header:
-       { "id": "hdr", "$fragment": "card-header-with-description",
-         "bindings": { "heading": "Sign in", "description": "..." },
-         "prependChildren": ["logo"] }
-       { "id": "logo", "component": "Image", "src": "/logo.svg", "alt": "Brand",
-         "slot": "icon" }
-     Common host slots:
-       - Card <header>:   icon | heading | description | action
-       - Card <section>:  (default)
-       - Card <footer>:   (default)
-     Without a slot attribute, children flow to the default slot and may not lay
-     out as expected on slot-grid hosts.
-
-  C) Inline the fragment (when you need to edit INTERIOR nodes or restructure the
-     layout). Copy the fragment's own template nodes into your composition with
-     fresh ids. Bindings and slot indirection go away. Each fragment in the catalog
-     below shows its internal template so you know what to copy. Inlined nodes lose
-     reuse; use only when (A) and (B) can't solve the problem.
-
-  D) Compose fragments side by side (two fragments together make the shape).
-     Place multiple $fragment refs as siblings inside a layout node.
-
-When HISTORY is provided, the user is building on PRIOR turns. You MUST:
-  - Treat the latest turn's template as the starting point.
-  - Apply the user's new instruction as a MODIFICATION to that template (add, remove, replace, or edit bindings on existing nodes).
-  - Preserve node ids from the prior template wherever possible so the canvas edits look incremental, not regenerated from scratch.
-  - For additive requests inside a fragment ("add X"), prefer technique (B) WITH a slot declaration matching the host's slot vocabulary. If the host has no matching slot, fall back to (C) inlining.
-  - For structural/interior edits, use technique (C) inlining.
-  - Only generate a fully fresh template if the new intent is clearly a topic change.
-
-Return ONLY a JSON object: { "template": [...nodes] }. No prose, no markdown fences.`;
-
-function buildUserPrompt(intent, fragmentCatalog, examples, historySummary = null) {
-  const fragLines = fragmentCatalog.map((f) => {
-    const slotStr = f.slots.length
-      ? f.slots.map((s) => `${s.name}${s.required ? '*' : ''}`).join(', ')
-      : '(no slots)';
-    // Compact template skeleton for technique (B) — ids + component types only
-    const tpl = (f.template || []).map((n) => {
-      const bits = { id: n.id, component: n.component };
-      if (n.children) bits.children = n.children;
-      return bits;
-    });
-    return `  - ${f.name} [${f.semantic_role}] — ${f.description}
-    slots: ${slotStr}
-    template: ${JSON.stringify(tpl)}`;
-  }).join('\n');
-
-  const exLines = examples.map((ex) => {
-    return `--- example: ${ex.name} (${ex.domain}) ---\n${ex.description}\n${JSON.stringify({ template: ex.template }, null, 2)}`;
-  }).join('\n\n');
-
-  const historyBlock = historySummary
-    ? `\nHISTORY (most recent turn last — build on this):\n${historySummary}\n\n`
-    : '\n';
-
-  return `INTENT: ${intent}
-${historyBlock}FRAGMENT CATALOG:
-${fragLines}
-
-EXAMPLES:
-${exLines}
-
-Compose a UI for the intent. If HISTORY is present, build on the latest turn's template. Return { "template": [...] } only.`;
-}
-
-/**
- * Extract the FIRST top-level JSON object from a possibly-messy LLM response.
- * Handles markdown fences and leading/trailing prose.
- */
-function extractJSON(text) {
-  if (!text) return null;
-  // Strip markdown fences
-  let t = text.trim();
-  const fence = t.match(/^```(?:json)?\s*([\s\S]*?)```$/m);
-  if (fence) t = fence[1].trim();
-  // Find first { and its matching }
-  const start = t.indexOf('{');
-  if (start === -1) return null;
-  let depth = 0;
-  let inStr = false;
-  let esc = false;
-  for (let i = start; i < t.length; i++) {
-    const c = t[i];
-    if (esc) { esc = false; continue; }
-    if (c === '\\') { esc = true; continue; }
-    if (c === '"') { inStr = !inStr; continue; }
-    if (inStr) continue;
-    if (c === '{') depth++;
-    else if (c === '}') {
-      depth--;
-      if (depth === 0) {
-        try { return JSON.parse(t.slice(start, i + 1)); } catch { return null; }
-      }
-    }
-  }
-  return null;
-}
-
-/**
- * Validate a synthesized template before we try to resolve it. Returns
- * { ok: true, errors: [] } or { ok: false, errors: [msg, ...] }.
- */
-function validateSynthesis(template, fragmentsByName) {
-  const errors = [];
-  if (!Array.isArray(template) || template.length === 0) {
-    return { ok: false, errors: ['template is empty or not an array'] };
-  }
-  const root = template.find((n) => n.id === 'root');
-  if (!root) errors.push('no node with id "root"');
-
-  const ids = new Set(template.map((n) => n.id).filter(Boolean));
-  for (const node of template) {
-    if (!node.id) errors.push('node is missing id');
-    if (node.$fragment) {
-      const frag = fragmentsByName.get(node.$fragment);
-      if (!frag) {
-        errors.push(`unknown $fragment: ${node.$fragment} (node ${node.id})`);
-        continue;
-      }
-      const bindings = node.bindings || {};
-      for (const slot of frag.slots || []) {
-        if (slot.required && !(slot.name in bindings) && slot.defaultValue === undefined) {
-          errors.push(`missing required binding "${slot.name}" on fragment ${node.$fragment} (node ${node.id})`);
-        }
-      }
-    } else if (node.component) {
-      // Inline node — children refs must resolve
-      const childArrays = [
-        node.children,
-      ];
-      for (const arr of childArrays) {
-        if (Array.isArray(arr)) {
-          for (const c of arr) {
-            if (typeof c === 'string' && !ids.has(c)) {
-              errors.push(`child "${c}" on node "${node.id}" does not resolve`);
-            }
-          }
-        }
-      }
-    } else {
-      errors.push(`node "${node.id}" has neither $fragment nor component`);
-    }
-    // prependChildren / appendChildren on fragment refs must resolve too
-    for (const key of ['prependChildren', 'appendChildren']) {
-      const arr = node[key];
-      if (!Array.isArray(arr)) continue;
-      for (const c of arr) {
-        if (typeof c === 'string' && !ids.has(c)) {
-          errors.push(`${key} ref "${c}" on node "${node.id}" does not resolve`);
-        }
-      }
-    }
-  }
-
-  return { ok: errors.length === 0, errors };
-}
-
-/**
- * Main entry: synthesize a composition from an intent using an LLM.
- *
- * @param {object} opts
- * @param {string} opts.intent
- * @param {object} opts.llmAdapter — must expose `complete({ messages, systemPrompt })`
- * @param {string} [opts.historySummary] — optional prior-turn context (see session-store.js)
- * @param {number} [opts.maxAttempts=2] — retry with feedback on validation failure
- * @returns {Promise<{ template: Array, messages: Array, synthesis: object }>}
- *          `synthesis` contains llmRawResponse, attempts, finalValidation for debugging.
+ * Until a chunk-based synthesis fallback lands, this export throws on
+ * call. Callers should catch and fall through to monolithic-pro's
+ * generation path. generator-adapter.js handles this gracefully.
  */
-export async function synthesizeComposition({ intent, llmAdapter, historySummary = null, maxAttempts = 3 }) {
-  if (!llmAdapter?.complete) {
-    throw new Error('synthesizeComposition requires an llmAdapter with .complete()');
-  }
-
-  const fragmentCatalog = buildFragmentCatalog();
-  const fragmentsByName = new Map(getAllFragments().map((f) => [f.name, f]));
-  const examples = buildExamples(3);
-
-  const userPrompt = buildUserPrompt(intent, fragmentCatalog, examples, historySummary);
-  let lastError = null;
-  const attempts = [];
-
-  for (let i = 0; i < maxAttempts; i++) {
-    const retryNudge = lastError
-      ? `\n\nPREVIOUS ATTEMPT FAILED: ${lastError}. Return ONLY a JSON object shaped as { "template": [...] }. No prose, no questions, no clarifications — just JSON.`
-      : '';
-    const messages = [{ role: 'user', content: userPrompt + retryNudge }];
-    const response = await llmAdapter.complete({ messages, systemPrompt: SYSTEM_PROMPT });
-    const raw = response?.content || response?.text || (typeof response === 'string' ? response : '');
-    attempts.push({ attempt: i + 1, raw });
-
-    const parsed = extractJSON(raw);
-    if (!parsed || !Array.isArray(parsed.template)) {
-      // Detect prose / clarification-style responses specifically
-      const isProse = /^(I['’]ll |Sure|Certainly|To do this|Here's)/i.test(raw.trim());
-      lastError = isProse
-        ? 'Response was conversational prose, not JSON. Do not ask questions. Emit the composition directly with your best-guess defaults.'
-        : 'Response was not valid JSON with a template array.';
-      continue;
-    }
-
-    const { ok, errors } = validateSynthesis(parsed.template, fragmentsByName);
-    if (!ok) {
-      lastError = errors.slice(0, 3).join('; ');
-      continue;
-    }
-
-    // Resolve via the composer
-    try {
-      const resolved = resolveComposition({ template: parsed.template });
-      const messagesOut = [{
-        type: 'updateComponents',
-        components: resolved.map((n) => {
-          const {
-            id, component, children,
-            $fragment, bindings,
-            prependChildren, appendChildren,
-            ...rest
-          } = n;
-          return { id, component, children: children || [], ...rest };
-        }),
-      }];
-      return {
-        template: parsed.template,
-        messages: messagesOut,
-        synthesis: {
-          attempts: i + 1,
-          attemptsLog: attempts,
-          validation: { ok: true, errors: [] },
-          usedHistory: !!historySummary,
-        },
-      };
-    } catch (e) {
-      lastError = `Composer failed to resolve: ${e.message}`;
-    }
-  }
 
-  throw new Error(`Synthesis failed after ${maxAttempts} attempts: ${lastError}`);
+export async function synthesizeComposition() {
+  const err = new Error(
+    'synthesizeComposition is retired (§37 fragment retirement). ' +
+    'Use chunk-zettel or monolithic-pro for LLM-driven composition.'
+  );
+  err.code = 'SYNTHESIZER_RETIRED';
+  throw err;
 }

package/transpiler/transpiler-maps.js

@@ -68,7 +68,7 @@ export const HTML_TAG_MAP = {
   summary:    { type: 'Text', props: { variant: 'h5' } },
   dialog:     { type: 'Modal' },
   hr:         { type: 'Divider' },
-  a:          { type: 'Button', props: { variant: 'ghost' } },
+  a:          { type: 'Link' },  // §47 — was: Button + variant=ghost (button.yaml line 60: "for inline navigation use `<link-ui>` instead")
   header:     { type: 'Header' },
   footer:     { type: 'Footer' },
   section:    { type: 'Section' },
@@ -163,11 +163,18 @@ export function extractProps(el, a2uiType) {
     else if (cls.includes('danger')) props.variant = 'danger';
     else if (cls.includes('ghost')) props.variant = 'ghost';
     else if (cls.includes('outline')) props.variant = 'outline';
-    // Link href
-    if (el.tagName?.toLowerCase() === 'a') {
-      const href = attr('href');
-      if (href) props.href = href;
-    }
+  }
+
+  // ── Link ── (§47 — <a> tags map to Link, not Button; carries href, target, rel)
+  if (a2uiType === 'Link') {
+    const text = (el.textContent || '').trim().replace(/\s+/g, ' ');
+    if (text) props.text = text;
+    const href = attr('href');
+    if (href) props.href = href;
+    const target = attr('target');
+    if (target) props.target = target;
+    const rel = attr('rel');
+    if (rel) props.rel = rel;
   }
 
   // ── TextField / Input ──

package/strategies/zettel/fragment-library.js

@@ -1,209 +0,0 @@
-/**
- * Fragment Library — zettel-style loader for A2UI fragments.
- *
- * Loads all /a2ui/fragments/**\/*.json into memory, builds a backlink graph,
- * and exposes typed retrieval helpers. Fragments ARE A2UI chunks — the library
- * preserves their flat-adjacency template verbatim.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import url from 'node:url';
-
-const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-const FRAGMENTS_ROOT = path.resolve(__dirname, '../../../corpus/fragments');
-const COMPOSITIONS_ROOT = path.resolve(__dirname, '../../../corpus/compositions');
-
-/** @type {Map<string, object>} */
-const fragments = new Map();
-/** @type {Map<string, object>} */
-const compositions = new Map();
-
-function walk(dir, cb) {
-  if (!fs.existsSync(dir)) return;
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    const p = path.join(dir, entry.name);
-    if (entry.isDirectory()) walk(p, cb);
-    else if (entry.name.endsWith('.json') && !entry.name.startsWith('_')) cb(p);
-  }
-}
-
-export function loadAll() {
-  fragments.clear();
-  compositions.clear();
-
-  walk(FRAGMENTS_ROOT, (p) => {
-    const doc = JSON.parse(fs.readFileSync(p, 'utf8'));
-    if (doc.kind !== 'fragment') return;
-    doc._sourceFile = p;
-    fragments.set(doc.name, doc);
-  });
-
-  walk(COMPOSITIONS_ROOT, (p) => {
-    const doc = JSON.parse(fs.readFileSync(p, 'utf8'));
-    if (doc.kind !== 'composition') return;
-    doc._sourceFile = p;
-    compositions.set(doc.name, doc);
-  });
-
-  buildBacklinks();
-  return { fragmentCount: fragments.size, compositionCount: compositions.size };
-}
-
-/** Walk every composition and every fragment, populate `used_by` backlinks. */
-function buildBacklinks() {
-  for (const f of fragments.values()) {
-    f.links = f.links || {};
-    f.links.used_by = [];
-  }
-
-  // compositions -> fragments they reference
-  for (const comp of compositions.values()) {
-    for (const node of comp.template || []) {
-      if (node.$fragment) {
-        const frag = fragments.get(node.$fragment);
-        if (frag) frag.links.used_by.push({ type: 'composition', name: comp.name });
-      }
-    }
-  }
-
-  // fragments -> other fragments they embed (future: nested fragment refs)
-  for (const f of fragments.values()) {
-    for (const node of f.template || []) {
-      if (node.$fragment) {
-        const target = fragments.get(node.$fragment);
-        if (target) target.links.used_by.push({ type: 'fragment', name: f.name });
-      }
-    }
-  }
-}
-
-export function getFragment(name) { return fragments.get(name); }
-export function getComposition(name) { return compositions.get(name); }
-export function getAllFragments() { return [...fragments.values()]; }
-export function getAllCompositions() { return [...compositions.values()]; }
-
-/**
- * Keyword search across fragments AND compositions.
- *
- * Ranking design (v2 — fixes false-positive matching):
- *   1. Tokenize query, drop generic UI stop-words ("form", "page", "view"…)
- *      so they can't be the sole evidence for a match.
- *   2. Whole-word match, not substring — prevents "form" matching "login-form".
- *   3. Require ≥2 content-token hits for compositions (they're concrete
- *      templates — promiscuous matching is expensive). Fragments can match on 1
- *      content token since they're meant to be widely reused.
- *   4. Tiered weights: name hit > keyword hit > semantic_role hit > description.
- *   5. Small leverage bias for fragments (reused fragments are more likely
- *      relevant when multiple candidates tie).
- */
-const STOP_WORDS = new Set([
-  'a', 'an', 'the', 'and', 'or', 'but', 'of', 'to', 'in', 'on', 'at', 'for', 'with',
-  'form', 'forms', 'page', 'pages', 'view', 'views', 'screen', 'screens',
-  'ui', 'component', 'components', 'widget', 'widgets', 'block', 'blocks',
-  'section', 'sections', 'layout', 'layouts',
-]);
-
-function tokenize(str) {
-  return (str || '')
-    .toLowerCase()
-    .split(/[^a-z0-9]+/)
-    .filter((t) => t.length >= 2);
-}
-
-function contentTokens(str) {
-  return tokenize(str).filter((t) => !STOP_WORDS.has(t));
-}
-
-export function searchAll(query, { limit = 20 } = {}) {
-  const q = (query || '').trim();
-  if (!q) return [];
-  const queryTokens = tokenize(q);
-  const queryContent = queryTokens.filter((t) => !STOP_WORDS.has(t));
-
-  const scoreDoc = (doc, isComposition) => {
-    const nameTokens = new Set(tokenize(doc.name));
-    const roleTokens = new Set(tokenize(doc.semantic_role || ''));
-    const keywordTokens = new Set((doc.keywords || []).flatMap((k) => tokenize(k)));
-    const descTokens = new Set(tokenize(doc.description || ''));
-    const tagTokens = new Set(
-      Object.values(doc.tags || {}).flat().flatMap((v) => tokenize(String(v))),
-    );
-
-    let contentHits = 0; // distinct non-stop-word tokens that matched anywhere
-    let s = 0;
-    const contentMatched = new Set();
-
-    for (const t of queryTokens) {
-      const isStop = STOP_WORDS.has(t);
-      let matched = false;
-      if (nameTokens.has(t))    { s += isStop ? 1 : 12; matched = true; }
-      if (keywordTokens.has(t)) { s += isStop ? 1 : 8;  matched = true; }
-      if (roleTokens.has(t))    { s += isStop ? 1 : 6;  matched = true; }
-      if (tagTokens.has(t))     { s += isStop ? 0 : 3;  matched = true; }
-      if (descTokens.has(t))    { s += isStop ? 0 : 2;  matched = true; }
-      if (matched && !isStop) {
-        contentMatched.add(t);
-      }
-    }
-    contentHits = contentMatched.size;
-
-    // Gate: compositions normally require ≥2 content-token hits to avoid
-    // noisy matches. Exception: a direct name-token match (the query contains
-    // the composition's primary concept word, e.g. "weather" → weather-widget)
-    // is strong enough on its own.
-    const nameHit = queryTokens.some((t) => !STOP_WORDS.has(t) && nameTokens.has(t));
-    if (isComposition && contentHits < 2 && !nameHit) return 0;
-    // Fragments require ≥1 content-token hit — never match on stop-words alone.
-    if (!isComposition && contentHits < 1) return 0;
-
-    // Coverage bonus: more distinct content tokens matched = better match
-    s += contentHits * 3;
-
-    // Small leverage bias for fragments (reused ones slightly preferred on ties)
-    if (!isComposition && doc.metrics?.leverage) {
-      s += Math.min(doc.metrics.leverage / 20, 2);
-    }
-
-    return s;
-  };
-
-  const all = [
-    ...getAllFragments().map((d) => ({ doc: d, type: 'fragment' })),
-    ...getAllCompositions().map((d) => ({ doc: d, type: 'composition' })),
-  ];
-
-  return all
-    .map((x) => ({ ...x, score: scoreDoc(x.doc, x.type === 'composition') }))
-    .filter((x) => x.score > 0)
-    .sort((a, b) => b.score - a.score)
-    .slice(0, limit)
-    .map((x) => ({
-      type: x.type,
-      name: x.doc.name,
-      score: Math.round(x.score * 100) / 100,
-      description: x.doc.description,
-      semantic_role: x.doc.semantic_role,
-      domain: x.doc.domain,
-    }));
-}
-
-/** Return the full graph for inspection / visualization. */
-export function getGraph() {
-  return {
-    fragments: getAllFragments().map((f) => ({
-      name: f.name,
-      role: f.semantic_role,
-      uses_components: f.links?.uses_components || [],
-      used_by: f.links?.used_by || [],
-      leverage: f.metrics?.leverage || 0,
-    })),
-    compositions: getAllCompositions().map((c) => ({
-      name: c.name,
-      domain: c.domain,
-      uses_fragments: (c.template || [])
-        .filter((n) => n.$fragment)
-        .map((n) => n.$fragment),
-    })),
-  };
-}