@opensip-cli/dashboard 0.1.0

package/dist/code-paths/graph-view-model.d.ts

@@ -0,0 +1,120 @@
+/**
+ * View-model projection for the Code Graph "Visualization" view.
+ *
+ * Projects the raw graph `GraphCatalog` (consumed by JSON shape from
+ * `@opensip-cli/contracts` — never from `@opensip-cli/graph`) into
+ * the slim, embed-ready `GraphViewModel` the Cytoscape renderer consumes.
+ *
+ * PACKAGE-LEVEL projection (item 10): the visualization renders a
+ * node-link graph at *package* granularity, NOT function granularity.
+ * Function-level catalogs on real repos contain thousands of function
+ * nodes — unusable in a node-link layout. This projector aggregates the
+ * function call graph up to packages:
+ *
+ *  - Node  = one package (id = label = package name via the same
+ *    attribution the Coupling view uses — see `packageOf` below, which
+ *    mirrors `pkgOf` in `path-utils.ts`).
+ *  - Edge  = caller-package → callee-package, with `weight` = the number
+ *    of underlying function→function call edges between those packages.
+ *
+ * This is intentionally the same package→package data the Coupling grid
+ * shows — a node-link rendering of it rather than a matrix. Every OTHER
+ * consumer (Coupling drilldown, Functions table, rules, …) still reads
+ * the function-level catalog directly; only THIS view aggregates up.
+ *
+ * This module is the bundle-size budget enforcement point: the report
+ * ships what this projector emits, not the catalog's storage shape.
+ *
+ * Architecture decisions:
+ *  - Projection runs at report-generation time (server-side, in
+ *    `generator.ts`) and the result is embedded as a JSON blob, mirroring
+ *    the existing `graph-catalog` blob.
+ *  - Cross-package cycles are detected with Tarjan's SCC over the package
+ *    graph (cheap at package granularity — tens of nodes, not thousands).
+ *    The engine's SCC implementation is off-limits to this package (the
+ *    catalog-decoupling rule §2.4); the local replica lives in the sibling
+ *    `graph-scc.ts` module.
+ */
+import type { GraphCatalog, GraphFunctionOccurrence } from '@opensip-cli/contracts';
+/**
+ * Slim, embed-ready projection of a graph catalog for the dashboard's
+ * Visualization view. Produced by {@link projectCatalogToGraphViewModel}
+ * and consumed by `view-graph.ts`.
+ *
+ * Aggregated to PACKAGE granularity — one node per package, one edge per
+ * directed package→package coupling.
+ */
+export interface GraphViewModel {
+    /**
+     * Catalog-level language (e.g. `'typescript'`). Copied here so the view
+     * doesn't need a separate handle on `graphCatalog`. The catalog is
+     * single-language; this is NOT a per-node filter.
+     */
+    readonly language: string;
+    readonly nodes: readonly GraphViewModelNode[];
+    readonly edges: readonly GraphViewModelEdge[];
+}
+export interface GraphViewModelNode {
+    /** Stable handle AND display label — the package name. */
+    readonly id: string;
+    /** Display label — the package name (same as {@link id}). */
+    readonly label: string;
+    /**
+     * Total coupling degree = fan-in + fan-out call count (sum of incident
+     * edge weights). Drives node *size* — hub packages render larger.
+     * Pre-computed here so the renderer can size without re-iterating edges.
+     */
+    readonly totalCoupling: number;
+    /**
+     * SCC membership over the PACKAGE graph. `null` = not in a non-trivial
+     * package-level cycle. Non-null = string id shared by every package in
+     * the same cyclic cluster. Drives cross-package-cycle highlighting.
+     */
+    readonly sccId: string | null;
+}
+export interface GraphViewModelEdge {
+    /** Source package name (caller). */
+    readonly source: string;
+    /** Target package name (callee). */
+    readonly target: string;
+    /**
+     * Number of underlying function→function call edges from the source
+     * package into the target package. Drives edge *thickness*.
+     */
+    readonly weight: number;
+    /**
+     * `true` iff this edge participates in a package-level cycle (both
+     * endpoints in the same non-null `sccId`). Highlights cross-package
+     * cycle backbones in concert with the node `sccId` grouping.
+     */
+    readonly isCycleEdge: boolean;
+}
+/** Thrown when the catalog is structurally unusable for projection. */
+export declare class GraphViewModelError extends Error {
+    constructor(message: string);
+}
+/**
+ * Project a graph catalog into the slim, PACKAGE-LEVEL {@link GraphViewModel}.
+ *
+ * Pure function — no I/O, no side effects. Four passes:
+ *  - Pass A: map every function `bodyHash` to its package (so call targets,
+ *    which are bodyHashes, can be resolved to a package).
+ *  - Pass B: walk function call edges, aggregate to package→package edges
+ *    keyed by `caller→callee`, accumulating a call-count `weight`.
+ *  - Pass C: derive package nodes (one per package seen) and accumulate
+ *    `totalCoupling` (fan-in + fan-out weight) on each.
+ *  - Pass D: Tarjan SCC over the package graph — stamp `sccId` on cyclic
+ *    packages and `isCycleEdge` on edges whose endpoints share an `sccId`.
+ *
+ * @throws {GraphViewModelError} when `catalog` or `catalog.functions` is missing.
+ */
+export declare function projectCatalogToGraphViewModel(catalog: GraphCatalog): GraphViewModel;
+/**
+ * The package a function occurrence belongs to. Mirrors `pkgOf` in
+ * `path-utils.ts` (the browser-side helper the Coupling view uses) so the
+ * server-side projection and the client-side coupling matrix attribute
+ * functions to packages identically: prefer the build-time-stamped
+ * `occurrence.package` (scope-stripped), else the path heuristic.
+ */
+export declare function packageOf(occ: GraphFunctionOccurrence): string;
+//# sourceMappingURL=graph-view-model.d.ts.map

package/dist/code-paths/graph-view-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-view-model.d.ts","sourceRoot":"","sources":["../../src/code-paths/graph-view-model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAEpF;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,QAAQ,CAAC,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC9C,QAAQ,CAAC,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAC/C;AAED,MAAM,WAAW,kBAAkB;IACjC,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB;;;;OAIG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAE/B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,kBAAkB;IACjC,oCAAoC;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,oCAAoC;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B;AAED,uEAAuE;AACvE,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI5B;AAcD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,YAAY,GAAG,cAAc,CA4BpF;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,uBAAuB,GAAG,MAAM,CAK9D"}

package/dist/code-paths/graph-view-model.js

@@ -0,0 +1,199 @@
+/**
+ * View-model projection for the Code Graph "Visualization" view.
+ *
+ * Projects the raw graph `GraphCatalog` (consumed by JSON shape from
+ * `@opensip-cli/contracts` — never from `@opensip-cli/graph`) into
+ * the slim, embed-ready `GraphViewModel` the Cytoscape renderer consumes.
+ *
+ * PACKAGE-LEVEL projection (item 10): the visualization renders a
+ * node-link graph at *package* granularity, NOT function granularity.
+ * Function-level catalogs on real repos contain thousands of function
+ * nodes — unusable in a node-link layout. This projector aggregates the
+ * function call graph up to packages:
+ *
+ *  - Node  = one package (id = label = package name via the same
+ *    attribution the Coupling view uses — see `packageOf` below, which
+ *    mirrors `pkgOf` in `path-utils.ts`).
+ *  - Edge  = caller-package → callee-package, with `weight` = the number
+ *    of underlying function→function call edges between those packages.
+ *
+ * This is intentionally the same package→package data the Coupling grid
+ * shows — a node-link rendering of it rather than a matrix. Every OTHER
+ * consumer (Coupling drilldown, Functions table, rules, …) still reads
+ * the function-level catalog directly; only THIS view aggregates up.
+ *
+ * This module is the bundle-size budget enforcement point: the report
+ * ships what this projector emits, not the catalog's storage shape.
+ *
+ * Architecture decisions:
+ *  - Projection runs at report-generation time (server-side, in
+ *    `generator.ts`) and the result is embedded as a JSON blob, mirroring
+ *    the existing `graph-catalog` blob.
+ *  - Cross-package cycles are detected with Tarjan's SCC over the package
+ *    graph (cheap at package granularity — tens of nodes, not thousands).
+ *    The engine's SCC implementation is off-limits to this package (the
+ *    catalog-decoupling rule §2.4); the local replica lives in the sibling
+ *    `graph-scc.ts` module.
+ */
+import { buildAdjacency, tarjanSccIds } from './graph-scc.js';
+/** Thrown when the catalog is structurally unusable for projection. */
+export class GraphViewModelError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'GraphViewModelError';
+    }
+}
+/**
+ * Project a graph catalog into the slim, PACKAGE-LEVEL {@link GraphViewModel}.
+ *
+ * Pure function — no I/O, no side effects. Four passes:
+ *  - Pass A: map every function `bodyHash` to its package (so call targets,
+ *    which are bodyHashes, can be resolved to a package).
+ *  - Pass B: walk function call edges, aggregate to package→package edges
+ *    keyed by `caller→callee`, accumulating a call-count `weight`.
+ *  - Pass C: derive package nodes (one per package seen) and accumulate
+ *    `totalCoupling` (fan-in + fan-out weight) on each.
+ *  - Pass D: Tarjan SCC over the package graph — stamp `sccId` on cyclic
+ *    packages and `isCycleEdge` on edges whose endpoints share an `sccId`.
+ *
+ * @throws {GraphViewModelError} when `catalog` or `catalog.functions` is missing.
+ */
+export function projectCatalogToGraphViewModel(catalog) {
+    if (!catalog || typeof catalog !== 'object' || !catalog.functions) {
+        throw new GraphViewModelError('catalog is missing or has no functions map');
+    }
+    const packageByHash = mapHashesToPackages(catalog); // Pass A
+    const edgeByKey = aggregatePackageEdges(catalog, packageByHash); // Pass B
+    const { nodes, edges } = deriveNodesAndEdges(packageByHash, edgeByKey); // Pass C
+    // Pass D: Tarjan SCC over the package graph. Self-loops (intra-package
+    // calls — the matrix diagonal) are excluded so a single package with
+    // internal calls is NOT flagged as a cycle; only genuine multi-package
+    // cycles (A→B→A) earn an sccId.
+    const adjacency = buildAdjacency(nodes, edges.filter((e) => e.source !== e.target));
+    const sccByNode = tarjanSccIds(nodes.map((n) => n.id), adjacency);
+    for (const node of nodes)
+        node.sccId = sccByNode.get(node.id) ?? null;
+    return {
+        language: catalog.language,
+        nodes: nodes.map(toViewModelNode),
+        edges: edges.map((e) => toViewModelEdge(e, sccByNode)),
+    };
+}
+/**
+ * The package a function occurrence belongs to. Mirrors `pkgOf` in
+ * `path-utils.ts` (the browser-side helper the Coupling view uses) so the
+ * server-side projection and the client-side coupling matrix attribute
+ * functions to packages identically: prefer the build-time-stamped
+ * `occurrence.package` (scope-stripped), else the path heuristic.
+ */
+export function packageOf(occ) {
+    if (occ && typeof occ.package === 'string' && occ.package.length > 0) {
+        return shortPackage(occ.package);
+    }
+    return packageOfPath(occ ? occ.filePath : '');
+}
+/** Strip an npm scope for display: "@opensip-cli/lang-typescript" → "lang-typescript". */
+function shortPackage(name) {
+    if (typeof name !== 'string')
+        return '<unknown>';
+    return name.codePointAt(0) === 64 /* @ */ ? name.slice(name.indexOf('/') + 1) : name;
+}
+/** Path-only fallback (first segment under `packages/`). */
+function packageOfPath(filePath) {
+    if (typeof filePath !== 'string' || filePath.length === 0)
+        return '<unknown>';
+    const m = /^packages\/([^/]+)\//.exec(filePath);
+    return m ? m[1] : '<unknown>';
+}
+/** Pass A — bodyHash → package name (last write wins, mirroring buildIndexes). */
+function mapHashesToPackages(catalog) {
+    const packageByHash = new Map();
+    for (const name of Object.keys(catalog.functions)) {
+        const occs = catalog.functions[name] ?? [];
+        for (const occ of occs)
+            packageByHash.set(occ.bodyHash, packageOf(occ));
+    }
+    return packageByHash;
+}
+/**
+ * Pass B — aggregate function call edges to directed package→package edges
+ * keyed by `callercallee`, accumulating a call-count `weight`. Call
+ * targets whose bodyHash is not an in-project function are dropped (matching
+ * the function-level projector's handling of unresolved/external calls).
+ * Self-package edges (intra-package calls) are kept — they show up as
+ * self-loops, consistent with the Coupling matrix diagonal.
+ */
+function aggregatePackageEdges(catalog, packageByHash) {
+    const edgeByKey = new Map();
+    for (const name of Object.keys(catalog.functions)) {
+        for (const occ of catalog.functions[name] ?? []) {
+            accumulateOccurrenceEdges(occ, packageByHash, edgeByKey);
+        }
+    }
+    return edgeByKey;
+}
+/** Add one weighted package edge per resolved call target of `occ`. */
+function accumulateOccurrenceEdges(occ, packageByHash, edgeByKey) {
+    const callerPkg = packageByHash.get(occ.bodyHash);
+    if (callerPkg === undefined)
+        return;
+    for (const edge of occ.calls ?? []) {
+        for (const target of edge.to ?? []) {
+            const calleePkg = packageByHash.get(target);
+            if (calleePkg === undefined)
+                continue; // external / unresolved
+            bumpEdge(edgeByKey, callerPkg, calleePkg);
+        }
+    }
+}
+/** Increment (or create) the weighted edge for a caller-to-callee package pair. */
+function bumpEdge(edgeByKey, source, target) {
+    // Newline delimiter: package names never contain one, so caller+callee keys
+    // can't collide (unlike empty-string concat).
+    const key = source + '\n' + target;
+    const existing = edgeByKey.get(key);
+    if (existing)
+        existing.weight += 1;
+    else
+        edgeByKey.set(key, { source, target, weight: 1 });
+}
+/**
+ * Pass C — derive one node per package (every package that appears as a
+ * function's package OR as an edge endpoint) and accumulate `totalCoupling`
+ * (sum of incident edge weights) on each.
+ */
+function deriveNodesAndEdges(packageByHash, edgeByKey) {
+    const nodeById = new Map();
+    // @fitness-ignore-next-line toctou-race-condition -- synchronous single-pass projector; `nodeById` is a local Map with no async/concurrent access, so there is no time-of-check/time-of-use window between the get and the set.
+    const ensure = (id) => {
+        let n = nodeById.get(id);
+        if (!n) {
+            n = { id, totalCoupling: 0, sccId: null };
+            nodeById.set(id, n);
+        }
+        return n;
+    };
+    // Every package that hosts a function is a node, even if it has no edges.
+    for (const pkg of packageByHash.values())
+        ensure(pkg);
+    const edges = [...edgeByKey.values()];
+    for (const e of edges) {
+        ensure(e.source).totalCoupling += e.weight;
+        ensure(e.target).totalCoupling += e.weight;
+    }
+    return { nodes: [...nodeById.values()], edges };
+}
+function toViewModelNode(n) {
+    return { id: n.id, label: n.id, totalCoupling: n.totalCoupling, sccId: n.sccId };
+}
+function toViewModelEdge(e, sccByNode) {
+    const sourceScc = sccByNode.get(e.source);
+    const targetScc = sccByNode.get(e.target);
+    return {
+        source: e.source,
+        target: e.target,
+        weight: e.weight,
+        isCycleEdge: sourceScc != null && sourceScc === targetScc,
+    };
+}
+//# sourceMappingURL=graph-view-model.js.map

package/dist/code-paths/graph-view-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-view-model.js","sourceRoot":"","sources":["../../src/code-paths/graph-view-model.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,18 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,54 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,28 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,97 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,15 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,47 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,14 @@
+/**
+ * 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

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