@opensip-cli/dashboard 0.1.0

package/dist/shared/pagination.js

@@ -0,0 +1,113 @@
+/**
+ * Pagination helpers — `paginateTable`, `paginateGroupedRows`, and the
+ * page-button renderer.
+ *
+ * Every data-table in the dashboard paginates at 10 rows/page (or
+ * 10 groups/page when expander rows are present). The grouped variant
+ * keeps a data row and its trailing `.expander-row` together so they
+ * page as one unit.
+ *
+ * `renderPageButtons` is shared between both paginators; the checks
+ * catalog declares its own paginator inline that also calls this
+ * helper, so it must be in scope before any caller.
+ */
+export function dashboardPaginationJs() {
+    return String.raw `
+// =======================================================
+// PAGINATION HELPERS
+// =======================================================
+
+function renderPageButtons(container, currentPage, totalPages, goToPage) {
+  container.appendChild(el('button', {class:'pagination-btn' + (currentPage === 0 ? ' disabled' : ''), text:'← Prev', onclick: () => { if (currentPage > 0) goToPage(currentPage - 1); }}));
+
+  const pages = [];
+  for (let p = 0; p < totalPages; p++) {
+    if (p < 2 || p >= totalPages - 2 || Math.abs(p - currentPage) <= 1) {
+      pages.push(p);
+    } else if (pages.length > 0 && pages[pages.length - 1] !== -1) {
+      pages.push(-1);
+    }
+  }
+
+  pages.forEach(p => {
+    if (p === -1) {
+      container.appendChild(el('span', {style:'color:var(--text-dim);padding:4px 4px;font-size:12px', text:'…'}));
+    } else {
+      container.appendChild(el('button', {class:'pagination-btn' + (p === currentPage ? ' active' : ''), text: ''+(p+1), onclick: () => goToPage(p)}));
+    }
+  });
+
+  container.appendChild(el('button', {class:'pagination-btn' + (currentPage >= totalPages-1 ? ' disabled' : ''), text:'Next →', onclick: () => { if (currentPage < totalPages-1) goToPage(currentPage + 1); }}));
+}
+
+function paginateTable(tbody, paginationContainer, pageSize) {
+  const rows = Array.from(tbody.children);
+  let currentPage = 0;
+  const totalPages = Math.max(1, Math.ceil(rows.length / pageSize));
+
+  function renderPage() {
+    const start = currentPage * pageSize;
+    const end = start + pageSize;
+    rows.forEach((row, i) => { row.style.display = (i >= start && i < end) ? '' : 'none'; });
+
+    while (paginationContainer.firstChild) paginationContainer.removeChild(paginationContainer.firstChild);
+    if (rows.length <= pageSize) return;
+
+    const info = el('div', {class:'pagination-info', text: 'Showing ' + (start+1) + '-' + Math.min(end, rows.length) + ' of ' + rows.length});
+    paginationContainer.appendChild(info);
+
+    const btns = el('div', {class:'pagination-btns'});
+    renderPageButtons(btns, currentPage, totalPages, (p) => { currentPage = p; renderPage(); });
+    paginationContainer.appendChild(btns);
+  }
+
+  renderPage();
+}
+
+function paginateGroupedRows(tbody, paginationContainer, pageSize) {
+  const allRows = Array.from(tbody.children);
+  const groups = [];
+  for (let i = 0; i < allRows.length; i++) {
+    const row = allRows[i];
+    if (row.classList.contains('expander-row')) continue;
+    const group = [row];
+    if (i + 1 < allRows.length && allRows[i+1].classList.contains('expander-row')) {
+      group.push(allRows[i+1]);
+    }
+    groups.push(group);
+  }
+
+  let currentPage = 0;
+  const totalPages = Math.max(1, Math.ceil(groups.length / pageSize));
+
+  function renderPage() {
+    const start = currentPage * pageSize;
+    const end = start + pageSize;
+    groups.forEach((group, i) => {
+      const visible = i >= start && i < end;
+      group.forEach(row => {
+        if (row.classList.contains('expander-row')) {
+          row.dataset.paged = visible ? 'yes' : 'no';
+          if (!visible) row.style.display = 'none';
+        } else {
+          row.style.display = visible ? '' : 'none';
+        }
+      });
+    });
+
+    while (paginationContainer.firstChild) paginationContainer.removeChild(paginationContainer.firstChild);
+    if (groups.length <= pageSize) return;
+
+    const info = el('div', {class:'pagination-info', text: 'Showing ' + (start+1) + '-' + Math.min(end, groups.length) + ' of ' + groups.length + ' checks'});
+    paginationContainer.appendChild(info);
+
+    const btns = el('div', {class:'pagination-btns'});
+    renderPageButtons(btns, currentPage, totalPages, (p) => { currentPage = p; renderPage(); });
+    paginationContainer.appendChild(btns);
+  }
+
+  renderPage();
+}
+`;
+}
+//# sourceMappingURL=pagination.js.map

package/dist/shared/pagination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.js","sourceRoot":"","sources":["../../src/shared/pagination.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,qBAAqB;IACnC,OAAO,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgGlB,CAAC;AACF,CAAC"}

package/dist/shared/sortable.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Sortable-table activation.
+ *
+ * `makeSortable(table)` wires click handlers to each `<th>` so columns
+ * can be sorted asc/desc with a numeric/date/string fallback. Keeps
+ * any trailing `.expander-row` glued to its parent during sort.
+ *
+ * After all rendering, a `setTimeout(0)` pass scans the DOM for
+ * `.data-table.sortable` elements and activates each — this catches
+ * tables created during the synchronous render but defers the
+ * activation until after `renderXxxTab()` calls have returned.
+ */
+export declare function dashboardSortableJs(): string;
+//# sourceMappingURL=sortable.d.ts.map

package/dist/shared/sortable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortable.d.ts","sourceRoot":"","sources":["../../src/shared/sortable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAuF5C"}

package/dist/shared/sortable.js

@@ -0,0 +1,101 @@
+/**
+ * Sortable-table activation.
+ *
+ * `makeSortable(table)` wires click handlers to each `<th>` so columns
+ * can be sorted asc/desc with a numeric/date/string fallback. Keeps
+ * any trailing `.expander-row` glued to its parent during sort.
+ *
+ * After all rendering, a `setTimeout(0)` pass scans the DOM for
+ * `.data-table.sortable` elements and activates each — this catches
+ * tables created during the synchronous render but defers the
+ * activation until after `renderXxxTab()` calls have returned.
+ */
+export function dashboardSortableJs() {
+    return String.raw `
+// =======================================================
+// SORTABLE TABLE COLUMNS
+// =======================================================
+
+function makeSortable(table) {
+  const thead = table.querySelector('thead');
+  const tbody = table.querySelector('tbody');
+  if (!thead || !tbody) return;
+
+  const headers = Array.from(thead.querySelectorAll('th'));
+  let sortCol = -1;
+  let sortAsc = true;
+
+  headers.forEach((th, colIdx) => {
+    if (!th.textContent.trim()) return; // skip empty headers (arrow column)
+    th.style.cursor = 'pointer';
+    th.style.userSelect = 'none';
+    th.addEventListener('click', () => {
+      if (sortCol === colIdx) {
+        sortAsc = !sortAsc;
+      } else {
+        sortCol = colIdx;
+        sortAsc = true;
+      }
+
+      // Update sort indicators
+      headers.forEach(h => { h.dataset.sort = ''; });
+      th.dataset.sort = sortAsc ? 'asc' : 'desc';
+
+      // Collect data rows with their expander rows
+      const allRows = Array.from(tbody.children);
+      const groups = [];
+      for (let i = 0; i < allRows.length; i++) {
+        const row = allRows[i];
+        if (row.classList.contains('expander-row')) continue;
+        const group = [row];
+        if (i + 1 < allRows.length && allRows[i+1].classList.contains('expander-row')) {
+          group.push(allRows[i+1]);
+        }
+        groups.push(group);
+      }
+
+      groups.sort((a, b) => {
+        const aText = (a[0].children[colIdx]?.textContent || '').trim();
+        const bText = (b[0].children[colIdx]?.textContent || '').trim();
+        // Try numeric comparison
+        const aNum = parseFloat(aText);
+        const bNum = parseFloat(bText);
+        if (!isNaN(aNum) && !isNaN(bNum)) {
+          return sortAsc ? aNum - bNum : bNum - aNum;
+        }
+        // Date detection (contains / or -)
+        const aDate = Date.parse(aText);
+        const bDate = Date.parse(bText);
+        if (!isNaN(aDate) && !isNaN(bDate)) {
+          return sortAsc ? aDate - bDate : bDate - aDate;
+        }
+        // String comparison
+        return sortAsc ? aText.localeCompare(bText) : bText.localeCompare(aText);
+      });
+
+      // Reorder DOM — append each group (data row + optional expander)
+      groups.forEach(group => {
+        group.forEach(row => tbody.appendChild(row));
+      });
+
+      // Re-paginate if a pagination container exists after the table
+      const pagContainer = table.parentElement?.querySelector('.pagination');
+      if (pagContainer) {
+        const hasExpanders = groups.some(g => g.length > 1);
+        if (hasExpanders) {
+          paginateGroupedRows(tbody, pagContainer, 10);
+        } else {
+          paginateTable(tbody, pagContainer, 10);
+        }
+      }
+    });
+  });
+}
+
+// After all rendering: init sorting
+setTimeout(() => {
+  document.querySelectorAll('.data-table.sortable').forEach(t => makeSortable(t));
+}, 0);
+`;
+}
+//# sourceMappingURL=sortable.js.map

package/dist/shared/sortable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortable.js","sourceRoot":"","sources":["../../src/shared/sortable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,mBAAmB;IACjC,OAAO,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqFlB,CAAC;AACF,CAAC"}

package/dist/shared/tab-activators.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Tab activator registry — runtime side.
+ *
+ * Decouples cross-tab navigation from "tab X is loaded into the page"
+ * guards. The Overview row-click handler asks the registry to
+ * activate the tab for a given session; each tab tooling (Code Paths
+ * today; future tabs like fit-detail, sim-detail, etc.) registers
+ * its activator at module init.
+ *
+ * New tabs that need session-aware deep-linking should call
+ * `registerTabActivator(<session.tool>, fn)` at the top of their
+ * JS-string emitter — the same place `dashboardCodePathsJs()` does
+ * for `'graph'`.
+ */
+export declare function dashboardTabActivatorsJs(): string;
+//# sourceMappingURL=tab-activators.d.ts.map

package/dist/shared/tab-activators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab-activators.d.ts","sourceRoot":"","sources":["../../src/shared/tab-activators.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAiBjD"}

package/dist/shared/tab-activators.js

@@ -0,0 +1,33 @@
+/**
+ * Tab activator registry — runtime side.
+ *
+ * Decouples cross-tab navigation from "tab X is loaded into the page"
+ * guards. The Overview row-click handler asks the registry to
+ * activate the tab for a given session; each tab tooling (Code Paths
+ * today; future tabs like fit-detail, sim-detail, etc.) registers
+ * its activator at module init.
+ *
+ * New tabs that need session-aware deep-linking should call
+ * `registerTabActivator(<session.tool>, fn)` at the top of their
+ * JS-string emitter — the same place `dashboardCodePathsJs()` does
+ * for `'graph'`.
+ */
+export function dashboardTabActivatorsJs() {
+    return String.raw `
+// =======================================================
+// TAB ACTIVATOR REGISTRY
+// =======================================================
+const tabActivators = {};
+function registerTabActivator(key, fn) {
+  tabActivators[key] = fn;
+}
+function activateTabForSession(session) {
+  if (!session) return false;
+  const fn = tabActivators[session.tool];
+  if (typeof fn !== 'function') return false;
+  fn(session.id);
+  return true;
+}
+`;
+}
+//# sourceMappingURL=tab-activators.js.map

package/dist/shared/tab-activators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab-activators.js","sourceRoot":"","sources":["../../src/shared/tab-activators.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,wBAAwB;IACtC,OAAO,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;CAelB,CAAC;AACF,CAAC"}

package/dist/shared/tab-bar.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Top-level tab-bar click handler.
+ *
+ * Wires the `#tab-bar` click event to toggle the `active` class on
+ * both the `.tab` headers and the `.tab-panel` containers.
+ */
+export declare function dashboardTabBarJs(): string;
+//# sourceMappingURL=tab-bar.d.ts.map

package/dist/shared/tab-bar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab-bar.d.ts","sourceRoot":"","sources":["../../src/shared/tab-bar.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAY1C"}

package/dist/shared/tab-bar.js

@@ -0,0 +1,20 @@
+/**
+ * Top-level tab-bar click handler.
+ *
+ * Wires the `#tab-bar` click event to toggle the `active` class on
+ * both the `.tab` headers and the `.tab-panel` containers.
+ */
+export function dashboardTabBarJs() {
+    return String.raw `
+// Tab switching
+document.getElementById('tab-bar').addEventListener('click', e => {
+  const tab = e.target.closest('.tab');
+  if (!tab) return;
+  document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
+  document.querySelectorAll('.tab-panel').forEach(p => p.classList.remove('active'));
+  tab.classList.add('active');
+  document.getElementById('panel-' + tab.dataset.tab).classList.add('active');
+});
+`;
+}
+//# sourceMappingURL=tab-bar.js.map

package/dist/shared/tab-bar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab-bar.js","sourceRoot":"","sources":["../../src/shared/tab-bar.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB;IAC/B,OAAO,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;CAUlB,CAAC;AACF,CAAC"}

package/dist/shared.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Shared dashboard JS — concatenates the per-concern emitters in
+ * `shared/`.
+ *
+ * Pre-F9 this was a 237-line `String.raw` blob covering five
+ * concerns. Each concern now lives in its own file and is composed
+ * here in the order downstream emitters depend on:
+ *
+ *   1. tab-bar      — top-level tab switching
+ *   2. tab-activators — cross-tab session-aware navigation registry
+ *   3. el           — `el(tag, attrs, children)` DOM helper used by
+ *                     every subsequent emitter
+ *   4. pagination   — `paginateTable` / `paginateGroupedRows` /
+ *                     `renderPageButtons`
+ *   5. sortable     — `makeSortable` plus the global setTimeout(0)
+ *                     scan that activates `.data-table.sortable`
+ *
+ * Any change to the order should be considered carefully — the
+ * pagination helpers reference `el`, the sortable helper references
+ * the pagination helpers, and the global activation pass at the end
+ * fires after every preceding emitter has declared its top-level
+ * names. New shared concerns should pick a slot rather than be
+ * appended blindly.
+ */
+export declare function dashboardSharedJs(): string;
+//# sourceMappingURL=shared.d.ts.map

package/dist/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../src/shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAQH,wBAAgB,iBAAiB,IAAI,MAAM,CAQ1C"}

package/dist/shared.js

@@ -0,0 +1,39 @@
+/**
+ * Shared dashboard JS — concatenates the per-concern emitters in
+ * `shared/`.
+ *
+ * Pre-F9 this was a 237-line `String.raw` blob covering five
+ * concerns. Each concern now lives in its own file and is composed
+ * here in the order downstream emitters depend on:
+ *
+ *   1. tab-bar      — top-level tab switching
+ *   2. tab-activators — cross-tab session-aware navigation registry
+ *   3. el           — `el(tag, attrs, children)` DOM helper used by
+ *                     every subsequent emitter
+ *   4. pagination   — `paginateTable` / `paginateGroupedRows` /
+ *                     `renderPageButtons`
+ *   5. sortable     — `makeSortable` plus the global setTimeout(0)
+ *                     scan that activates `.data-table.sortable`
+ *
+ * Any change to the order should be considered carefully — the
+ * pagination helpers reference `el`, the sortable helper references
+ * the pagination helpers, and the global activation pass at the end
+ * fires after every preceding emitter has declared its top-level
+ * names. New shared concerns should pick a slot rather than be
+ * appended blindly.
+ */
+import { dashboardElJs } from './shared/el.js';
+import { dashboardPaginationJs } from './shared/pagination.js';
+import { dashboardSortableJs } from './shared/sortable.js';
+import { dashboardTabActivatorsJs } from './shared/tab-activators.js';
+import { dashboardTabBarJs } from './shared/tab-bar.js';
+export function dashboardSharedJs() {
+    return [
+        dashboardTabBarJs(),
+        dashboardTabActivatorsJs(),
+        dashboardElJs(),
+        dashboardPaginationJs(),
+        dashboardSortableJs(),
+    ].join('\n');
+}
+//# sourceMappingURL=shared.js.map

package/dist/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.js","sourceRoot":"","sources":["../src/shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,MAAM,UAAU,iBAAiB;IAC/B,OAAO;QACL,iBAAiB,EAAE;QACnB,wBAAwB,EAAE;QAC1B,aAAa,EAAE;QACf,qBAAqB,EAAE;QACvB,mBAAmB,EAAE;KACtB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}

package/dist/subtab-bar.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Subtab-bar Strategy — JS-string emitter for the shared subtab pattern.
+ *
+ * Both the fit/sim Tool Tab (Sessions / Catalog / Recipes — three
+ * subtabs) and the Code Paths Tab (Sessions / Explore — two subtabs)
+ * need the same DOM/click-delegation behaviour: a `.subtab-bar` of
+ * clickable headers, a stack of `.subtab-panel` containers, and a
+ * single click handler that toggles the `active` class on both.
+ *
+ * Pre-F2, both call sites duplicated the same 20-line block. This
+ * emitter declares one runtime helper, `renderSubtabBar(panel,
+ * subtabs)`, that both consumers call. The Strategy is the
+ * `subtabs` array — each entry is `{ id, label, render(panel) }` —
+ * and `renderSubtabBar` returns the panel-element map so callers can
+ * still reach into specific subpanels if they need to (Code Paths
+ * does not, fit/sim's `renderToolTab` does not either after F2).
+ *
+ * The emitter must be concatenated BEFORE any caller (i.e. before
+ * `dashboardToolTabsJs` and `dashboardCodePathsJs`) since both rely
+ * on `renderSubtabBar` being declared in scope.
+ */
+export declare function dashboardSubtabBarJs(): string;
+//# sourceMappingURL=subtab-bar.d.ts.map

package/dist/subtab-bar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtab-bar.d.ts","sourceRoot":"","sources":["../src/subtab-bar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAsD7C"}

package/dist/subtab-bar.js

@@ -0,0 +1,77 @@
+/**
+ * Subtab-bar Strategy — JS-string emitter for the shared subtab pattern.
+ *
+ * Both the fit/sim Tool Tab (Sessions / Catalog / Recipes — three
+ * subtabs) and the Code Paths Tab (Sessions / Explore — two subtabs)
+ * need the same DOM/click-delegation behaviour: a `.subtab-bar` of
+ * clickable headers, a stack of `.subtab-panel` containers, and a
+ * single click handler that toggles the `active` class on both.
+ *
+ * Pre-F2, both call sites duplicated the same 20-line block. This
+ * emitter declares one runtime helper, `renderSubtabBar(panel,
+ * subtabs)`, that both consumers call. The Strategy is the
+ * `subtabs` array — each entry is `{ id, label, render(panel) }` —
+ * and `renderSubtabBar` returns the panel-element map so callers can
+ * still reach into specific subpanels if they need to (Code Paths
+ * does not, fit/sim's `renderToolTab` does not either after F2).
+ *
+ * The emitter must be concatenated BEFORE any caller (i.e. before
+ * `dashboardToolTabsJs` and `dashboardCodePathsJs`) since both rely
+ * on `renderSubtabBar` being declared in scope.
+ */
+export function dashboardSubtabBarJs() {
+    return String.raw `
+// =======================================================
+// SUBTAB BAR (Strategy — shared by tool tabs and Code Paths)
+// =======================================================
+//
+// renderSubtabBar(panel, subtabs)
+//   panel    — host element (e.g. document.getElementById('panel-fitness'))
+//   subtabs  — Array<{ id: string, label: string, render(panel): void }>
+//
+// Builds the .subtab-bar (with the first subtab .active), creates one
+// .subtab-panel per entry, mounts them, wires up click delegation,
+// and finally invokes each entry's render(panel) to populate it.
+//
+// Returns the { id → panel } map so callers can reach into a specific
+// subpanel by id if they need to (rare; both first-party callers
+// don't).
+function renderSubtabBar(panel, subtabs) {
+  const subtabBar = el('div', { class: 'subtab-bar' });
+  const panels = {};
+  subtabs.forEach((t, i) => {
+    const subtab = el('div', {
+      class: 'subtab' + (i === 0 ? ' active' : ''),
+      'data-subtab': t.id,
+      text: t.label,
+    });
+    subtabBar.appendChild(subtab);
+
+    const subpanel = el('div', {
+      class: 'subtab-panel' + (i === 0 ? ' active' : ''),
+      id: panel.id + '-' + t.id,
+    });
+    panels[t.id] = subpanel;
+  });
+
+  panel.appendChild(subtabBar);
+  subtabs.forEach(t => panel.appendChild(panels[t.id]));
+
+  subtabBar.addEventListener('click', e => {
+    const tab = e.target.closest('.subtab');
+    if (!tab) return;
+    subtabBar.querySelectorAll('.subtab').forEach(t => t.classList.remove('active'));
+    tab.classList.add('active');
+    subtabs.forEach(t => panels[t.id].classList.remove('active'));
+    panels[tab.dataset.subtab].classList.add('active');
+  });
+
+  // Render each subpanel's body. Done after mounting so renderers can
+  // safely measure their host (the panel is in the document).
+  subtabs.forEach(t => t.render(panels[t.id]));
+
+  return panels;
+}
+`;
+}
+//# sourceMappingURL=subtab-bar.js.map

package/dist/subtab-bar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtab-bar.js","sourceRoot":"","sources":["../src/subtab-bar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDlB,CAAC;AACF,CAAC"}

package/dist/tool-tab-registry.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Tool tab registry — the extension point for top-level tabs.
+ *
+ * `generator.ts` walks the registry to emit (1) the tab buttons in the
+ * top-level `.tab-bar`, (2) the per-tab `<div id="panel-…">` containers,
+ * (3) the per-tab `render*Tab()` calls in the inlined `<script>`, and
+ * (4) Overview's `tool → tab` and badge-style maps. Adding a new tool
+ * tab is a `defineToolTab` call plus shipping the tool's `render*Tab`
+ * JS-string emitter — no central-dispatcher edits.
+ *
+ * Mirrors `defineRankedView` (Code Paths) and `tabActivators`
+ * (cross-tab navigation): a single descriptor type + a registry +
+ * iteration in the generator.
+ *
+ * The Overview tab is intentionally NOT in this registry — it is a
+ * cross-tool aggregate by design and lives outside the per-tool
+ * abstraction.
+ *
+ * **Why not Registry<T>?** Per the runscope+registry plan's Phase 0
+ * Task 0.1 decision (D6), `ToolTabRegistry` deliberately stays an
+ * append-only `ToolTabDescriptor[]` — it has no `id+name+tags` shape,
+ * no duplicate-handling semantics, and is registration-order-sensitive
+ * (tab-bar order matters). The kernel's `Registry<T>` would add no
+ * value here. The cross-cutting T2 audit explicitly noted that this
+ * registry has "a different shape and may stay separate."
+ */
+/**
+ * Descriptor for a top-level tool tab (Fitness, Simulation, Code
+ * Paths, …). All fields are required to keep the registry shape
+ * predictable; tools that don't carry per-session state (e.g. a
+ * future "audit" tool with no detail view) still supply a `tool`
+ * key — Overview's row-click handler uses it for the tabMap.
+ */
+export interface ToolTabDescriptor {
+    /**
+     * The DOM tab id, used for `data-tab="<id>"` and `panel-<id>`.
+     * Examples: `'fitness'`, `'simulation'`, `'code-paths'`.
+     */
+    id: string;
+    /**
+     * The `StoredSession.tool` key whose sessions belong on this tab.
+     * Examples: `'fit'`, `'sim'`, `'graph'`. Used by Overview to map
+     * a session to a tab and by `tabActivators` for deep-link routing.
+     */
+    tool: string;
+    /** Tab label, e.g. `'Fitness'`. */
+    label: string;
+    /** SVG markup for the tab icon. Spliced verbatim into the `.tab` div. */
+    icon: string;
+    /**
+     * Inline `style` value for the `.badge` element rendered for this
+     * tool in Overview's Recent Activity table. Example:
+     * `'background:rgba(124,160,104,0.15);color:var(--accent-fitness)'`.
+     */
+    badgeStyle: string;
+    /**
+     * Name of the JS-side `render*Tab()` function the tool's emitter
+     * declares. The generator emits a call to this name in the inlined
+     * `<script>` after all emitters run. Must be a plain identifier
+     * (no parentheses) — the generator appends `();`.
+     */
+    renderFunctionName: string;
+}
+/**
+ * Register a top-level tool tab. Called at module load by every tool
+ * that ships a tab (today: fit, sim, graph). Order of registration
+ * controls tab-bar order; the existing fit/sim/graph order is what
+ * pre-F1 hard-coded, so callers should preserve it.
+ */
+export declare function defineToolTab(descriptor: ToolTabDescriptor): void;
+/**
+ * Snapshot of the current registry. Returned as a fresh array so
+ * callers can iterate without worrying about concurrent registration.
+ */
+export declare function listToolTabs(): ToolTabDescriptor[];
+//# sourceMappingURL=tool-tab-registry.d.ts.map

package/dist/tool-tab-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-tab-registry.d.ts","sourceRoot":"","sources":["../src/tool-tab-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,EAAE,EAAE,MAAM,CAAC;IACX;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAID;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI,CAEjE;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,iBAAiB,EAAE,CAElD"}

package/dist/tool-tab-registry.js

@@ -0,0 +1,44 @@
+/**
+ * Tool tab registry — the extension point for top-level tabs.
+ *
+ * `generator.ts` walks the registry to emit (1) the tab buttons in the
+ * top-level `.tab-bar`, (2) the per-tab `<div id="panel-…">` containers,
+ * (3) the per-tab `render*Tab()` calls in the inlined `<script>`, and
+ * (4) Overview's `tool → tab` and badge-style maps. Adding a new tool
+ * tab is a `defineToolTab` call plus shipping the tool's `render*Tab`
+ * JS-string emitter — no central-dispatcher edits.
+ *
+ * Mirrors `defineRankedView` (Code Paths) and `tabActivators`
+ * (cross-tab navigation): a single descriptor type + a registry +
+ * iteration in the generator.
+ *
+ * The Overview tab is intentionally NOT in this registry — it is a
+ * cross-tool aggregate by design and lives outside the per-tool
+ * abstraction.
+ *
+ * **Why not Registry<T>?** Per the runscope+registry plan's Phase 0
+ * Task 0.1 decision (D6), `ToolTabRegistry` deliberately stays an
+ * append-only `ToolTabDescriptor[]` — it has no `id+name+tags` shape,
+ * no duplicate-handling semantics, and is registration-order-sensitive
+ * (tab-bar order matters). The kernel's `Registry<T>` would add no
+ * value here. The cross-cutting T2 audit explicitly noted that this
+ * registry has "a different shape and may stay separate."
+ */
+const registry = [];
+/**
+ * Register a top-level tool tab. Called at module load by every tool
+ * that ships a tab (today: fit, sim, graph). Order of registration
+ * controls tab-bar order; the existing fit/sim/graph order is what
+ * pre-F1 hard-coded, so callers should preserve it.
+ */
+export function defineToolTab(descriptor) {
+    registry.push(descriptor);
+}
+/**
+ * Snapshot of the current registry. Returned as a fresh array so
+ * callers can iterate without worrying about concurrent registration.
+ */
+export function listToolTabs() {
+    return [...registry];
+}
+//# sourceMappingURL=tool-tab-registry.js.map

package/dist/tool-tab-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-tab-registry.js","sourceRoot":"","sources":["../src/tool-tab-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAwCH,MAAM,QAAQ,GAAwB,EAAE,CAAC;AAEzC;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,UAA6B;IACzD,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;AAC5B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY;IAC1B,OAAO,CAAC,GAAG,QAAQ,CAAC,CAAC;AACvB,CAAC"}