@opensip-cli/dashboard 0.1.6 → 0.1.8

package/dist/code-paths/graph-stylesheet.js

@@ -1,121 +0,0 @@
-/**
- * @fileoverview Cytoscape stylesheet for the Code Graph "Visualization" view.
- *
- * A render helper (registers no view), extracted from `view-graph.ts` to keep
- * that emitter under the file-length budget and deliberately named out of the
- * `view-*` namespace so it stays clear of the views-disjoint architecture
- * rule. Emits the `gvStylesheet()` browser function as a JS string; the main
- * emitter interpolates it into its `<script>` body.
- *
- * PACKAGE granularity (item 10): nodes are packages, not functions. The
- * visual encoding is therefore simpler than the function-level original —
- * uniform round-rectangle nodes sized by total coupling degree, edges
- * thickened by call-count weight, plus the cross-package SCC accent and the
- * shared selection/search/impact highlight classes.
- */
-/**
- * Emit the `gvStylesheet()` browser function as a JS string. No leading or
- * trailing newline, so the main emitter can interpolate it where the inline
- * function used to sit.
- */
-export function dashboardViewGraphStylesheetJs() {
-    return String.raw `function gvStylesheet() {
-  return [
-    {
-      selector: 'node',
-      style: {
-        'background-color': '#c4956a',
-        'border-color': function(ele) { return ele.data('sccColor') || '#8a8a8a'; },
-        'border-width': function(ele) { return ele.data('sccId') ? 3 : 1; },
-        'shape': 'round-rectangle',
-        // Size by total coupling degree (fan-in + fan-out call count). The
-        // log-ish clamp keeps a megabus package from dwarfing the canvas.
-        'width': function(ele) { return 22 + Math.min(56, Math.sqrt(ele.data('totalCoupling') || 0) * 6); },
-        'height': function(ele) { return 22 + Math.min(56, Math.sqrt(ele.data('totalCoupling') || 0) * 6); },
-        'label': function(ele) { return ele.data('label') || ''; },
-        'font-size': 9,
-        'color': '#ddd',
-        'text-valign': 'bottom',
-        'text-halign': 'center',
-        'text-margin-y': 2,
-        'text-wrap': 'none',
-      },
-    },
-    {
-      selector: 'edge',
-      style: {
-        // Thickness by call-count weight (clamped). A solid uniform style —
-        // resolution/confidence encoding is function-level and not meaningful
-        // once edges are aggregated to packages.
-        'width': function(ele) { return 1 + Math.min(7, Math.sqrt(ele.data('weight') || 1) * 1.2); },
-        'line-color': '#5a5a5a',
-        'target-arrow-color': '#5a5a5a',
-        'target-arrow-shape': 'triangle',
-        'arrow-scale': 0.8,
-        'curve-style': 'bezier',
-      },
-    },
-    {
-      selector: 'edge[?isCycleEdge]',
-      style: { 'line-color': '#d46a6a', 'target-arrow-color': '#d46a6a' },
-    },
-    // Function-level "+ cross-package" mode only: a callee that lives OUTSIDE
-    // the selected package is drawn as a faded ellipse so the boundary reads
-    // at a glance. Package-level view-models never set 'external', so this
-    // selector is inert there.
-    {
-      selector: 'node[?external]',
-      style: { 'background-color': '#3a3a3a', 'border-color': '#666', 'color': '#9a9a9a', 'shape': 'ellipse', 'opacity': 0.55 },
-    },
-    {
-      selector: 'node.gv-search-hit',
-      style: { 'background-color': '#e0a96d', 'border-color': '#fff', 'border-width': 3, 'opacity': 1 },
-    },
-    {
-      selector: 'node.gv-search-fade',
-      style: { 'opacity': 0.12 },
-    },
-    {
-      selector: 'edge.gv-search-fade',
-      style: { 'opacity': 0.05 },
-    },
-    // Impact highlight (adapted to packages): clicking a package lights its
-    // direct caller packages (upstream) and callee packages (downstream).
-    // Accent palette mirrors the dashboard theme: --accent (selected),
-    // --accent-fitness (downstream), --accent-sim (upstream). Hard-coded
-    // because the Cytoscape canvas can't read CSS custom properties.
-    {
-      selector: 'node.gv-selected',
-      style: { 'background-color': '#e0a96d', 'border-color': '#fff', 'border-width': 4, 'opacity': 1 },
-    },
-    {
-      selector: 'node.gv-upstream',
-      style: { 'background-color': '#6a9bd4', 'opacity': 1 },
-    },
-    {
-      selector: 'node.gv-downstream',
-      style: { 'background-color': '#7ec47e', 'opacity': 1 },
-    },
-    {
-      selector: '.gv-dimmed',
-      style: { 'opacity': 0.1 },
-    },
-    // Cross-package cycle highlight (folded-in "Cycles / SCCs" affordance).
-    // Cycle members get a bright accent fill; cycle edges turn red and
-    // thicken; the acyclic remainder fades so multi-package cycles stand out.
-    {
-      selector: 'node.gv-scc-member',
-      style: { 'background-color': '#d46a6a', 'border-color': '#fff', 'border-width': 3, 'opacity': 1 },
-    },
-    {
-      selector: 'edge.gv-scc-edge',
-      style: { 'line-color': '#d46a6a', 'target-arrow-color': '#d46a6a', 'width': 3, 'opacity': 1 },
-    },
-    {
-      selector: '.gv-scc-dimmed',
-      style: { 'opacity': 0.08 },
-    },
-  ];
-}`;
-}
-//# sourceMappingURL=graph-stylesheet.js.map

package/dist/code-paths/graph-stylesheet.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"graph-stylesheet.js","sourceRoot":"","sources":["../../src/code-paths/graph-stylesheet.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;GAIG;AACH,MAAM,UAAU,8BAA8B;IAC5C,OAAO,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiGjB,CAAC;AACH,CAAC"}

package/dist/code-paths/help-drawer.d.ts

@@ -1,18 +0,0 @@
-/**
- * Right-side help drawer — explains a single Explore view.
- *
- * Each view-*.ts puts a `help` field on its View literal:
- *   { title: string, sections: { heading: string, body: string }[] }
- * Clicking the ⓘ icon next to a tab opens this drawer with that
- * view's help. Clicking the backdrop, the × button, or pressing
- * Escape closes it. There is one drawer at a time.
- *
- * The drawer resolves help dynamically via `getView(viewId).help` — there is
- * NO static per-view help map. So the Plan B Code Paths restructure
- * (dropping `big`/`hot`/`wide`/`untested`/`sccs` and folding cycle guidance
- * into the graph view's help) needs no edit here: the drawer simply renders
- * whatever views are registered. The SCC explanation now lives on the graph
- * view's `help` ("Cycles / SCCs" section, view-graph.ts).
- */
-export declare function dashboardHelpDrawerJs(): string;
-//# sourceMappingURL=help-drawer.d.ts.map

package/dist/code-paths/help-drawer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"help-drawer.d.ts","sourceRoot":"","sources":["../../src/code-paths/help-drawer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,wBAAgB,qBAAqB,IAAI,MAAM,CAoC9C"}

package/dist/code-paths/help-drawer.js

@@ -1,54 +0,0 @@
-/**
- * Right-side help drawer — explains a single Explore view.
- *
- * Each view-*.ts puts a `help` field on its View literal:
- *   { title: string, sections: { heading: string, body: string }[] }
- * Clicking the ⓘ icon next to a tab opens this drawer with that
- * view's help. Clicking the backdrop, the × button, or pressing
- * Escape closes it. There is one drawer at a time.
- *
- * The drawer resolves help dynamically via `getView(viewId).help` — there is
- * NO static per-view help map. So the Plan B Code Paths restructure
- * (dropping `big`/`hot`/`wide`/`untested`/`sccs` and folding cycle guidance
- * into the graph view's help) needs no edit here: the drawer simply renders
- * whatever views are registered. The SCC explanation now lives on the graph
- * view's `help` ("Cycles / SCCs" section, view-graph.ts).
- */
-export function dashboardHelpDrawerJs() {
-    return String.raw `
-function openHelpDrawer(viewId) {
-  const view = (typeof getView === 'function') ? getView(viewId) : null;
-  if (!view || !view.help) return;
-  closeHelpDrawer();
-  const overlay = el('div', { class: 'help-drawer-overlay', id: 'help-drawer-overlay' });
-  overlay.addEventListener('click', e => { if (e.target === overlay) closeHelpDrawer(); });
-  const drawer = el('aside', { class: 'help-drawer', role: 'dialog', 'aria-label': view.help.title || view.label });
-  const header = el('div', { class: 'help-drawer-header' });
-  header.appendChild(el('h3', { text: view.help.title || view.label }));
-  const closeBtn = el('button', { class: 'help-drawer-close', 'aria-label': 'Close', text: '×', onclick: closeHelpDrawer });
-  header.appendChild(closeBtn);
-  drawer.appendChild(header);
-  const body = el('div', { class: 'help-drawer-body' });
-  for (const section of (view.help.sections || [])) {
-    body.appendChild(el('h4', { text: section.heading }));
-    body.appendChild(el('p', { text: section.body }));
-  }
-  drawer.appendChild(body);
-  overlay.appendChild(drawer);
-  document.body.appendChild(overlay);
-  // Animate in on next frame so the CSS transition takes effect.
-  requestAnimationFrame(() => overlay.classList.add('open'));
-  closeBtn.focus();
-}
-
-function closeHelpDrawer() {
-  const existing = document.getElementById('help-drawer-overlay');
-  if (existing && existing.parentNode) existing.parentNode.removeChild(existing);
-}
-
-document.addEventListener('keydown', e => {
-  if (e.key === 'Escape' && document.getElementById('help-drawer-overlay')) closeHelpDrawer();
-});
-`;
-}
-//# sourceMappingURL=help-drawer.js.map

package/dist/code-paths/help-drawer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"help-drawer.js","sourceRoot":"","sources":["../../src/code-paths/help-drawer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,UAAU,qBAAqB;IACnC,OAAO,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkClB,CAAC;AACF,CAAC"}

package/dist/code-paths/indexes.d.ts

@@ -1,28 +0,0 @@
-/**
- * Browser-side `Indexes` builder — emitted as a JS string for the
- * inlined dashboard script. Mirrors v0.2's `pipeline/indexes.ts`
- * but ported to vanilla JS that runs in the page.
- *
- * The catalog persists only `functions[name][i].calls[].to[]`. v0.2's
- * O(1) `Indexes` is in-memory only; the dashboard rebuilds it on
- * panel-init time. Output: { byBodyHash, occurrencesByHash,
- * bySimpleName, callees, callers }.
- *
- * Blast radius is no longer computed here. The engine's features stage
- * (`pipeline/features.ts`, Plan C) is the single canonical home for the
- * bounded reverse-BFS blast score; a dashboard-bound run materializes it
- * into `catalog.features.function[bodyHash].blast` and the Hot view reads
- * it from there (falling back to the raw inbound-caller count when the
- * catalog carries no features). This builder now only assembles the
- * adjacency the views need for navigation and member resolution.
- *
- * Also emits `resolveCalleeOcc(target, callerOcc, indexes)` — the shared
- * call-target → callee-occurrence resolver. It lives here (not in any single
- * view) because more than one view needs it: the Coupling drilldown AND the
- * function-level Visualization both resolve a call target's bodyHash to the
- * occurrence the caller can actually reach, disambiguating body-hash
- * collisions across packages. Emitting it in the prelude (ahead of every
- * view) removes the load-bearing cross-view emission order it used to imply.
- */
-export declare function dashboardIndexesJs(): string;
-//# sourceMappingURL=indexes.d.ts.map

package/dist/code-paths/indexes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"indexes.d.ts","sourceRoot":"","sources":["../../src/code-paths/indexes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,wBAAgB,kBAAkB,IAAI,MAAM,CAqE3C"}

package/dist/code-paths/indexes.js

@@ -1,97 +0,0 @@
-/**
- * Browser-side `Indexes` builder — emitted as a JS string for the
- * inlined dashboard script. Mirrors v0.2's `pipeline/indexes.ts`
- * but ported to vanilla JS that runs in the page.
- *
- * The catalog persists only `functions[name][i].calls[].to[]`. v0.2's
- * O(1) `Indexes` is in-memory only; the dashboard rebuilds it on
- * panel-init time. Output: { byBodyHash, occurrencesByHash,
- * bySimpleName, callees, callers }.
- *
- * Blast radius is no longer computed here. The engine's features stage
- * (`pipeline/features.ts`, Plan C) is the single canonical home for the
- * bounded reverse-BFS blast score; a dashboard-bound run materializes it
- * into `catalog.features.function[bodyHash].blast` and the Hot view reads
- * it from there (falling back to the raw inbound-caller count when the
- * catalog carries no features). This builder now only assembles the
- * adjacency the views need for navigation and member resolution.
- *
- * Also emits `resolveCalleeOcc(target, callerOcc, indexes)` — the shared
- * call-target → callee-occurrence resolver. It lives here (not in any single
- * view) because more than one view needs it: the Coupling drilldown AND the
- * function-level Visualization both resolve a call target's bodyHash to the
- * occurrence the caller can actually reach, disambiguating body-hash
- * collisions across packages. Emitting it in the prelude (ahead of every
- * view) removes the load-bearing cross-view emission order it used to imply.
- */
-export function dashboardIndexesJs() {
-    return String.raw `
-function buildIndexes(catalog) {
-  const byBodyHash = new Map();
-  // All occurrences per body. byBodyHash keeps only one (last-writer-wins),
-  // collapsing identical bodies across packages; occurrencesByHash preserves
-  // every occurrence so coupling can attribute a callee to the correct
-  // package instead of the collision winner.
-  const occurrencesByHash = new Map();
-  const bySimpleName = new Map();
-  const callees = new Map();
-  const callers = new Map();
-  if (!catalog || !catalog.functions) {
-    return { byBodyHash, occurrencesByHash, bySimpleName, callees, callers };
-  }
-  // Pass 1: byBodyHash + occurrencesByHash + bySimpleName.
-  for (const name of Object.keys(catalog.functions)) {
-    const occs = catalog.functions[name] || [];
-    for (const occ of occs) {
-      byBodyHash.set(occ.bodyHash, occ);
-      let all = occurrencesByHash.get(occ.bodyHash);
-      if (!all) { all = []; occurrencesByHash.set(occ.bodyHash, all); }
-      all.push(occ);
-      let bucket = bySimpleName.get(name);
-      if (!bucket) { bucket = []; bySimpleName.set(name, bucket); }
-      bucket.push(occ.bodyHash);
-    }
-  }
-  // Pass 2: callees (forward) + callers (reverse). Edges that resolve
-  // to a hash not in byBodyHash are dropped; this mirrors v0.2's
-  // behavior for unresolved/external targets.
-  for (const occ of byBodyHash.values()) {
-    const out = [];
-    for (const edge of (occ.calls || [])) {
-      for (const target of (edge.to || [])) {
-        if (!byBodyHash.has(target)) continue;
-        out.push(target);
-        let inb = callers.get(target);
-        if (!inb) { inb = []; callers.set(target, inb); }
-        inb.push(occ.bodyHash);
-      }
-    }
-    if (out.length > 0) callees.set(occ.bodyHash, out);
-  }
-  return { byBodyHash, occurrencesByHash, bySimpleName, callees, callers };
-}
-
-// Resolve a call target (a bodyHash) to the callee occurrence the caller can
-// reach, disambiguating body-hash collisions across packages. byBodyHash
-// keeps only one occurrence per hash (the collision winner), which
-// mis-attributes the callee's package; occurrencesByHash preserves all, so we
-// prefer the caller's own package, else fall back deterministically (lowest
-// qualifiedName). The dashboard catalog carries no import set, so this mirrors
-// the engine's fast-mode (same-package-only) attribution. Used by the Coupling
-// drilldown and the function-level Visualization projection.
-function resolveCalleeOcc(target, callerOcc, indexes) {
-  const candidates = (indexes.occurrencesByHash && indexes.occurrencesByHash.get(target)) || null;
-  if (!candidates || candidates.length === 0) return indexes.byBodyHash.get(target);
-  if (candidates.length === 1) return candidates[0];
-  const callerPkg = pkgOf(callerOcc);
-  let samePkg = null;
-  let lowest = candidates[0];
-  for (const c of candidates) {
-    if (!samePkg && pkgOf(c) === callerPkg) samePkg = c;
-    if (c.qualifiedName < lowest.qualifiedName) lowest = c;
-  }
-  return samePkg || lowest;
-}
-`;
-}
-//# sourceMappingURL=indexes.js.map

package/dist/code-paths/indexes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"indexes.js","sourceRoot":"","sources":["../../src/code-paths/indexes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,UAAU,kBAAkB;IAChC,OAAO,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmElB,CAAC;AACF,CAAC"}

package/dist/code-paths/path-utils.d.ts

@@ -1,15 +0,0 @@
-/**
- * Path / name display helpers shared across the Explore views.
- *
- * - pkgOf:         the package an occurrence belongs to — prefers the
- *   build-time-stamped `occurrence.package` (nearest package.json name, shown
- *   scope-stripped), falling back to the path heuristic for old catalogs.
- * - packageOfPath: path-only fallback (first segment under packages/).
- * - displayName:   collapse synthetic graph names like
- *   "<arrow:packages/.../foo.ts:234:45>" into a short tag the table
- *   can render without horizontal overflow. The underlying simpleName
- *   is preserved as the identity (data-body-hash); only the cell text
- *   is shortened.
- */
-export declare function dashboardPathUtilsJs(): string;
-//# sourceMappingURL=path-utils.d.ts.map

package/dist/code-paths/path-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"path-utils.d.ts","sourceRoot":"","sources":["../../src/code-paths/path-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,wBAAgB,oBAAoB,IAAI,MAAM,CAgC7C"}

package/dist/code-paths/path-utils.js

@@ -1,47 +0,0 @@
-/**
- * Path / name display helpers shared across the Explore views.
- *
- * - pkgOf:         the package an occurrence belongs to — prefers the
- *   build-time-stamped `occurrence.package` (nearest package.json name, shown
- *   scope-stripped), falling back to the path heuristic for old catalogs.
- * - packageOfPath: path-only fallback (first segment under packages/).
- * - displayName:   collapse synthetic graph names like
- *   "<arrow:packages/.../foo.ts:234:45>" into a short tag the table
- *   can render without horizontal overflow. The underlying simpleName
- *   is preserved as the identity (data-body-hash); only the cell text
- *   is shortened.
- */
-export function dashboardPathUtilsJs() {
-    return String.raw `
-function packageOfPath(filePath) {
-  if (typeof filePath !== 'string' || filePath.length === 0) return '<unknown>';
-  const m = /^packages\/([^/]+)\//.exec(filePath);
-  return m ? m[1] : '<unknown>';
-}
-
-// Strip an npm scope for display: "@opensip-cli/lang-typescript" -> "lang-typescript".
-function shortPkg(name) {
-  if (typeof name !== 'string') return '<unknown>';
-  return name.charCodeAt(0) === 64 /* @ */ ? name.slice(name.indexOf('/') + 1) : name;
-}
-
-// The package an occurrence belongs to. Prefers the build-time-stamped
-// occurrence.package (accurate for any repo layout); falls back to the path
-// heuristic for legacy catalogs. Scope-stripped for compact display.
-function pkgOf(occ) {
-  if (occ && typeof occ.package === 'string' && occ.package.length > 0) return shortPkg(occ.package);
-  return packageOfPath(occ ? occ.filePath : '');
-}
-
-function displayName(simpleName) {
-  if (typeof simpleName !== 'string') return '';
-  // Synthetic names from the graph tool are angle-bracketed:
-  //   <arrow:path:line:col>, <fn-expr:path:line:col>, <module-init:path>, <default>
-  // Render just the kind tag — file:line is shown in the File column.
-  const m = /^<([a-z-]+)(?::|>)/.exec(simpleName);
-  if (m) return '<' + m[1] + '>';
-  return simpleName;
-}
-`;
-}
-//# sourceMappingURL=path-utils.js.map

package/dist/code-paths/path-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"path-utils.js","sourceRoot":"","sources":["../../src/code-paths/path-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,UAAU,oBAAoB;IAClC,OAAO,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BlB,CAAC;AACF,CAAC"}

package/dist/code-paths/search.d.ts

@@ -1,14 +0,0 @@
-/**
- * Substring-with-character-skip fuzzy match for the persistent search
- * input and View 7. Pure algorithm emitted as a JS string.
- *
- * Algorithm: each character of the query must appear in the candidate
- * in order, but not necessarily contiguously. Score is built from:
- *   - prefix match (start at index 0): +50
- *   - exact-case bonus per matched char: +1
- *   - contiguous-run bonus (matched-after-matched): +2 per
- *   - shorter candidate preferred: -length * 0.01
- * Returns top matches sorted by score desc, score >= 0.
- */
-export declare function dashboardSearchJs(): string;
-//# sourceMappingURL=search.d.ts.map

package/dist/code-paths/search.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/code-paths/search.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,wBAAgB,iBAAiB,IAAI,MAAM,CAwC1C"}

package/dist/code-paths/search.js

@@ -1,54 +0,0 @@
-/**
- * Substring-with-character-skip fuzzy match for the persistent search
- * input and View 7. Pure algorithm emitted as a JS string.
- *
- * Algorithm: each character of the query must appear in the candidate
- * in order, but not necessarily contiguously. Score is built from:
- *   - prefix match (start at index 0): +50
- *   - exact-case bonus per matched char: +1
- *   - contiguous-run bonus (matched-after-matched): +2 per
- *   - shorter candidate preferred: -length * 0.01
- * Returns top matches sorted by score desc, score >= 0.
- */
-export function dashboardSearchJs() {
-    return String.raw `
-function fuzzyMatch(query, names) {
-  const q = (query || '').trim();
-  if (q.length === 0) return [];
-  const qLower = q.toLowerCase();
-  const out = [];
-  for (const name of names) {
-    const score = fuzzyScore(qLower, q, name);
-    if (score < 0) continue;
-    out.push({ name, score });
-  }
-  out.sort((a, b) => b.score - a.score);
-  return out;
-}
-
-function fuzzyScore(qLower, q, name) {
-  if (typeof name !== 'string' || name.length === 0) return -1;
-  const nameLower = name.toLowerCase();
-  let qi = 0;
-  let score = 0;
-  let lastMatchIdx = -2;
-  for (let i = 0; i < name.length && qi < qLower.length; i++) {
-    if (nameLower[i] === qLower[qi]) {
-      // Exact-case bonus.
-      if (name[i] === q[qi]) score += 1;
-      // Contiguous-run bonus.
-      if (i === lastMatchIdx + 1) score += 2;
-      // Prefix bonus when matching the very first char at index 0.
-      if (i === 0 && qi === 0) score += 50;
-      lastMatchIdx = i;
-      qi++;
-    }
-  }
-  if (qi < qLower.length) return -1;
-  // Shorter is better.
-  score -= name.length * 0.01;
-  return score;
-}
-`;
-}
-//# sourceMappingURL=search.js.map

package/dist/code-paths/search.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"search.js","sourceRoot":"","sources":["../../src/code-paths/search.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,UAAU,iBAAiB;IAC/B,OAAO,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsClB,CAAC;AACF,CAAC"}

package/dist/code-paths/trace.d.ts

@@ -1,11 +0,0 @@
-/**
- * BFS from inferred entry-point set to a target bodyHash.
- *
- * Entry-point heuristic mirrors v0.2's: any function in
- * `packages/cli/src/index.ts`, plus any exported function with no
- * callers in catalog. Returns the shortest path as a bodyHash[]
- * starting at an entry point and ending at the target. Returns null
- * when no entry point reaches the target.
- */
-export declare function dashboardTraceJs(): string;
-//# sourceMappingURL=trace.d.ts.map

package/dist/code-paths/trace.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../src/code-paths/trace.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,wBAAgB,gBAAgB,IAAI,MAAM,CAiDzC"}

package/dist/code-paths/trace.js

@@ -1,60 +0,0 @@
-/**
- * BFS from inferred entry-point set to a target bodyHash.
- *
- * Entry-point heuristic mirrors v0.2's: any function in
- * `packages/cli/src/index.ts`, plus any exported function with no
- * callers in catalog. Returns the shortest path as a bodyHash[]
- * starting at an entry point and ending at the target. Returns null
- * when no entry point reaches the target.
- */
-export function dashboardTraceJs() {
-    return String.raw `
-function inferEntryPointHashes(catalog, indexes) {
-  const entries = [];
-  if (!catalog || !catalog.functions) return entries;
-  for (const occ of indexes.byBodyHash.values()) {
-    const isCli = occ.filePath === 'packages/cli/src/index.ts';
-    const callerList = indexes.callers.get(occ.bodyHash) || [];
-    const isExportedRoot = occ.visibility === 'exported' && callerList.length === 0;
-    if (isCli || isExportedRoot) entries.push(occ.bodyHash);
-  }
-  return entries;
-}
-
-function traceFromEntry(targetHash, catalog, indexes) {
-  if (!targetHash || !indexes || !indexes.byBodyHash.has(targetHash)) return null;
-  const entries = inferEntryPointHashes(catalog, indexes);
-  if (entries.length === 0) return null;
-  // BFS over the forward (callees) graph; record predecessors so we
-  // can reconstruct the path on the first hit.
-  const queue = [];
-  const visited = new Set();
-  const parent = new Map();
-  for (const e of entries) {
-    queue.push(e);
-    visited.add(e);
-  }
-  while (queue.length > 0) {
-    const v = queue.shift();
-    if (v === targetHash) {
-      const path = [];
-      let cur = v;
-      while (cur !== undefined) {
-        path.unshift(cur);
-        cur = parent.get(cur);
-      }
-      return path;
-    }
-    const adj = indexes.callees.get(v) || [];
-    for (const w of adj) {
-      if (visited.has(w)) continue;
-      visited.add(w);
-      parent.set(w, v);
-      queue.push(w);
-    }
-  }
-  return null;
-}
-`;
-}
-//# sourceMappingURL=trace.js.map

package/dist/code-paths/trace.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"trace.js","sourceRoot":"","sources":["../../src/code-paths/trace.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,UAAU,gBAAgB;IAC9B,OAAO,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+ClB,CAAC;AACF,CAAC"}

package/dist/code-paths/view-coupling.d.ts

@@ -1,22 +0,0 @@
-/**
- * View 4 — "Package coupling heat map".
- *
- * Reads the engine-emitted `catalog.features.edge` rows (Plan C — the
- * dashboard no longer re-aggregates call edges client-side); each row is a
- * { callerPackage, calleePackage, count } directed coupling edge. Renders a
- * per-package N×N table with text-shaded density (CSS custom property
- * --coupling-density).
- *
- * The matrix is the WHOLE-GRAPH (unfiltered) coupling matrix — the filter
- * chips no longer narrow it (it is a whole-graph insight). When the catalog
- * carries no `edge` feature (a non-dashboard run) the view shows a no-data
- * empty state.
- *
- * Empty cells (no calls in this direction) show '·' and are not
- * clickable. Non-empty cells render the count; click → opens a
- * Function Card list of the actual call sites for that pair (the drilldown
- * keeps its own per-call-site walk, which the aggregate edge feature can't
- * provide).
- */
-export declare function dashboardViewCouplingJs(): string;
-//# sourceMappingURL=view-coupling.d.ts.map

package/dist/code-paths/view-coupling.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"view-coupling.d.ts","sourceRoot":"","sources":["../../src/code-paths/view-coupling.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,wBAAgB,uBAAuB,IAAI,MAAM,CAoMhD"}