AI search engine and MCP server for bots and agents. One Rust binary indexes code, docs, logs, JSONL/CSV and PDFs for BM25 full-text, vector and hybrid search, code search without grep, agent memory and RAG. Elasticsearch-compatible API; Corpus Hub serves hundreds of reference memory corpora.
Rust agent-memoryai-agentsbm25claude-codeclicode-searchcursordatabaseelasticsearchfull-text-searchhybrid-searchjsonllocal-firstmcpmcp-servermodel-context-protocolragrustsearch-enginevector-search
// ============================================================
// XERJ.ai — Bootstrap + router + layout engine
//
// One render loop. Edit mode layers drag/resize/remove/add on
// top of the same render — no separate editor routes.
// ============================================================
import { registry, defaults, SECTIONS, DASHBOARD_GROUPS, dashboardsInSection } from './dashboards/registry.js';
import { Nav, SceneHeader, TimeCtrl, RefreshCtrl, FilterBar, ClusterCtrl, SavedViews, Footer, MobileCtrl } from './ux/chrome.js';
import { query, dataSourceStatus } from './data/query.js';
import { chartTypes, chartTypeList } from './ux/chart-types.js';
import { esc } from './ux/text.js';
import { hitsToCsv, downloadText, svgToPng } from './data/export.js';
import {
mergedDashboards, renameDashboard, reorderDashboards, setHidden,
createUserDashboard, deleteUserDashboard, isUserDash, resetAll as resetDashboards,
getDoc, patchPanels, setOnChange,
} from './data/dashboard-store.js';
import { renderDeclarativePanel } from './ux/panel-render.js';
import { panelResult, fetchPanel, onPanelData } from './data/panel-query.js';
import {
listClusters, listIndices, listFields, listClustersSync,
defaultClusterId, setDefaultCluster,
} from './data/data-sources.js';
import { sbBrainsPresent } from './data/brains-probe.js';
import { dataFeaturesPresent, emptyDataFeatures } from './data/data-probe.js';
import { indexNames } from './data/schema.js';
import { mount } from './ux/safe-dom.js';
import { renderCorpus, renderRelations, renderCapabilities } from './ux/corpus-render.js';
import { ReaderView, parseReaderRoute } from './ux/reader-view.js';
import { readerHref } from './ux/reader-render.js';
import { makeReaderApi } from './data/reader-api.js';
import { makeConsoleTransport } from './data/transport-console.js';
import { activeBackendId, backendBaseUrl } from './data/backends/index.js';
// ---------- state -----------------------------------------
const LS = {
theme: 'xerj.theme',
time: 'xerj.time',
edit: 'xerj.edit',
search: 'xerj.search',
refresh: 'xerj.refresh',
cluster: 'xerj.cluster',
views: 'xerj.views',
filters: (dashId) => 'xerj.filters.' + dashId,
layout: (dashId) => 'xerj.layout.' + dashId,
};
function loadJSON(key, fallback) {
try { const raw = localStorage.getItem(key); return raw ? JSON.parse(raw) : fallback; }
catch { return fallback; }
}
function loadSearch() { return loadJSON(LS.search, null); }
function loadAllFilters() {
const out = {};
for (const k of Object.keys(localStorage)) {
if (k.startsWith('xerj.filters.')) {
const id = k.slice('xerj.filters.'.length);
try { out[id] = JSON.parse(localStorage.getItem(k)) || {}; } catch {}
}
}
return out;
}
const _initial = parseRoute();
const _urlState = parseUrlState();
const state = {
section: _initial.section,
route: _initial.route,
time: _urlState.time || localStorage.getItem(LS.time) || '24H',
timeCustom: {
from: _urlState.tfrom || localStorage.getItem('xerj.timeFrom') || '',
to: _urlState.tto || localStorage.getItem('xerj.timeTo') || '',
},
cluster: _urlState.cluster || defaultClusterId(),
refresh: parseInt(localStorage.getItem(LS.refresh) || '0', 10), // ms; 0 = off
refreshTimer: null,
fetchedAt: null, // ISO string of last successful query
fetchMs: null, // last fetch duration in ms
fetchErr: null, // last fetch error message
loading: false,
filters: loadAllFilters(), // { [dashId]: { field: value } }
theme: document.documentElement.getAttribute('data-theme') || 'night',
edit: localStorage.getItem(LS.edit) === '1',
mobile: localStorage.getItem('xerj.mobile') === '1',
layouts: loadAllLayouts(),
search: (() => {
const loaded = loadSearch() || {};
return {
q: loaded.q || '',
type: loaded.type || 'match',
index: loaded.index || '*',
filters: loaded.filters || {},
sort: loaded.sort || { field: '_score', dir: 'desc' },
showTime: loaded.showTime !== false,
result: null,
};
})(),
_focusSelector: null, // set by handlers that need focus restored
// Live-gated features: a dashboard whose registry entry sets
// `requiresLive: '<key>'` only appears in the NAV once the matching
// key here is true (fed by a probe against the live engine). Routes
// and MANAGE are never filtered — a deep link must always resolve.
liveFeatures: { brains: false, ...emptyDataFeatures() },
// Real index names on the engine (from the mapping), fed by the live probe
// so the search UI aligns to what's actually indexed instead of a hardcoded
// demo list.
indices: [],
// The Corpus home's last payload (backends/xerj.js#liveCorpus) — kept so the
// Reader's index picker lists the catalogued datasets first.
corpus: null,
};
// The Reader (ux/reader-view.js) owns its own state and fetching; the shell
// only hands it a mount point after each render and the parsed route on each
// hash change. It renders through ux/safe-dom.js — record data never passes
// through this file's HTML strings.
const readerView = new ReaderView({
api: makeReaderApi(makeConsoleTransport()),
guest: false,
indices: () => {
const fromCatalog = (state.corpus?.datasets || []).map((d) => d.index);
const rest = state.indices.filter((n) => !fromCatalog.includes(n));
return [...fromCatalog, ...rest];
},
onStatus: ({ kind, label }) => {
if (state.section !== 'reader') return;
state.sourceKind = kind; state.sourceLabel = label;
const pill = document.querySelector('[data-nav-status]');
if (pill) pill.textContent = navStatus();
},
});
// Merge any URL-seeded filters into the current dashboard's filter set.
if (_urlState.filters) {
state.filters[_initial.route] = { ...(state.filters[_initial.route] || {}), ..._urlState.filters };
saveFilters(_initial.route);
}
// ---------- filters, URL state, refresh -------------------
function currentFilters() {
return state.filters[state.route] || {};
}
function saveFilters(dashId) {
const v = state.filters[dashId];
if (v && Object.keys(v).length) localStorage.setItem(LS.filters(dashId), JSON.stringify(v));
else localStorage.removeItem(LS.filters(dashId));
}
// Toggle a filter value. Multi-value semantics: clicking the same
// value twice removes it; clicking a new value on an existing field
// appends to the OR list.
function setFilter(field, value) {
const dashId = state.route;
const cur = { ...(state.filters[dashId] || {}) };
const existing = cur[field];
if (existing == null) {
cur[field] = value;
} else if (Array.isArray(existing)) {
const idx = existing.indexOf(value);
if (idx >= 0) {
const next = existing.filter((v) => v !== value);
if (next.length === 0) delete cur[field];
else if (next.length === 1) cur[field] = next[0];
else cur[field] = next;
} else {
cur[field] = [...existing, value];
}
} else {
if (existing === value) delete cur[field];
else cur[field] = [existing, value];
}
state.filters[dashId] = cur;
saveFilters(dashId);
writeUrlState();
}
// Remove one value from a field (used by pill ✕ click on a specific
// chip inside a multi-value filter).
function removeFilterValue(field, value) {
const dashId = state.route;
const cur = { ...(state.filters[dashId] || {}) };
const existing = cur[field];
if (existing == null) return;
if (Array.isArray(existing)) {
const next = existing.filter((v) => v !== value);
if (next.length === 0) delete cur[field];
else if (next.length === 1) cur[field] = next[0];
else cur[field] = next;
} else if (existing === value) {
delete cur[field];
}
state.filters[dashId] = cur;
saveFilters(dashId);
writeUrlState();
}
// KQL-lite parser: tokenize `field:value field:"multi word" foo`.
// Free-text tokens become a synthetic `q` filter; repeat fields
// turn into OR arrays.
function parseKql(text) {
const out = {};
const add = (k, v) => {
if (!v) return;
if (out[k] == null) out[k] = v;
else if (Array.isArray(out[k])) out[k].push(v);
else out[k] = [out[k], v];
};
// Match field:"quoted value" OR field:value OR loose token
const re = /([a-zA-Z_][\w.]*):"([^"]*)"|([a-zA-Z_][\w.]*):(\S+)|"([^"]+)"|(\S+)/g;
let m;
while ((m = re.exec(text)) !== null) {
if (m[1] != null) add(m[1], m[2]);
else if (m[3] != null) add(m[3], m[4]);
else if (m[5] != null) add('q', m[5]);
else if (m[6] != null) add('q', m[6]);
}
return out;
}
// Inverse of parseKql — render a filter object as a KQL string that
// re-parses to the same shape. Used to keep the input box in sync.
function serializeKql(filters) {
const parts = [];
for (const [k, v] of Object.entries(filters || {})) {
const values = Array.isArray(v) ? v : [v];
for (const x of values) {
const needsQuote = /\s/.test(String(x));
if (k === 'q') {
parts.push(needsQuote ? `"${x}"` : String(x));
} else {
parts.push(needsQuote ? `${k}:"${x}"` : `${k}:${x}`);
}
}
}
return parts.join(' ');
}
function applyKqlInput(text) {
const dashId = state.route;
state.filters[dashId] = parseKql(text);
saveFilters(dashId);
writeUrlState();
}
function clearFilters() {
const dashId = state.route;
state.filters[dashId] = {};
saveFilters(dashId);
writeUrlState();
}
// URL state: ?t=24H&f=service:auth,level:error&c=prod-us
// Filters are encoded as repeated `f` params so URLSearchParams can
// handle escaping cleanly: ?f=service:nginx&f=level:error. Multi-value
// (OR) filters repeat the same key: ?f=service:auth&f=service:web.
function parseUrlState() {
const qs = location.search.slice(1);
if (!qs) return {};
const out = {};
const params = new URLSearchParams(qs);
if (params.get('t')) out.time = params.get('t').toUpperCase();
if (params.get('tfrom')) out.tfrom = params.get('tfrom');
if (params.get('tto')) out.tto = params.get('tto');
if (params.get('c')) out.cluster = params.get('c');
const all = params.getAll('f');
if (all.length) {
out.filters = {};
for (const pair of all) {
const idx = pair.indexOf(':');
if (idx > 0) {
const k = pair.slice(0, idx);
const v = pair.slice(idx + 1);
const existing = out.filters[k];
if (existing == null) out.filters[k] = v;
else if (Array.isArray(existing)) existing.push(v);
else out.filters[k] = [existing, v];
}
}
}
return out;
}
function writeUrlState() {
const params = new URLSearchParams();
if (state.time && state.time !== '24H') params.set('t', state.time);
if (state.time === 'CUSTOM' && state.timeCustom) {
if (state.timeCustom.from) params.set('tfrom', state.timeCustom.from);
if (state.timeCustom.to) params.set('tto', state.timeCustom.to);
}
if (state.cluster) params.set('c', state.cluster);
for (const [k, v] of Object.entries(currentFilters())) {
if (Array.isArray(v)) for (const x of v) params.append('f', `${k}:${x}`);
else params.append('f', `${k}:${v}`);
}
const qs = params.toString();
const url = location.pathname + (qs ? '?' + qs : '') + location.hash;
history.replaceState(null, '', url);
}
function setRefreshInterval(ms) {
state.refresh = ms;
localStorage.setItem(LS.refresh, String(ms));
if (state.refreshTimer) { clearInterval(state.refreshTimer); state.refreshTimer = null; }
if (ms > 0) {
state.refreshTimer = setInterval(() => {
probeLiveFeatures();
if (state.section === 'dashboards' || state.section === 'discover') render();
}, ms);
}
}
// ---------- live-feature probes ---------------------------
// Some dashboards only earn a nav entry once the engine actually has
// data for them (registry `requiresLive` flag). This asks the probes,
// updates `state.liveFeatures`, and re-renders on a change so the nav
// entry appears/disappears without a reload. The probe module caches
// per baseUrl (~30 s), so calling this on every refresh tick is cheap,
// and a backend/base-URL change naturally re-probes the new target.
let _probingLive = false;
async function probeLiveFeatures() {
if (_probingLive) return;
_probingLive = true;
try {
const base = backendBaseUrl(activeBackendId());
// Two cheap probes: brains (.xerj-memory-*-edges) + the data-plane classes
// (chat-events, vector-ops, agent-memory, anomalies, logs-*). Each dashboard
// gates its nav entry on its own key so a fresh / brain-only engine never
// advertises a mock-filled telemetry dashboard.
const [brains, dataFeat, idxNames] = await Promise.all([
sbBrainsPresent(base),
dataFeaturesPresent(base),
indexNames(base),
]);
const next = { brains, ...dataFeat };
let changed = false;
for (const k of Object.keys(next)) {
if (next[k] !== state.liveFeatures[k]) { state.liveFeatures[k] = next[k]; changed = true; }
}
// Real index list. Re-render if it changed so the index picker targets
// actual data.
if (JSON.stringify(idxNames) !== JSON.stringify(state.indices)) { state.indices = idxNames || []; changed = true; }
// If the selected index no longer exists (stale localStorage, renamed or
// deleted index), fall back to a real one so the console lands on actual
// data instead of an empty/erroring result. `*` is kept (backend resolves
// it to the primary index).
if (state.indices.length && state.search.index !== '*' && !state.indices.includes(state.search.index)) {
state.search.index = state.indices[0];
state.search.result = null;
changed = true;
}
if (changed) {
// Same guards as the store/panel re-render hooks: never nuke an
// in-flight drag gesture or steal focus from a form field.
const ae = document.activeElement;
const typing = ae && (ae.tagName === 'INPUT' || ae.tagName === 'SELECT' || ae.isContentEditable);
if (!geomDrag && !typing) render();
}
} finally {
_probingLive = false;
}
}
// ---------- saved views -----------------------------------
// A saved view is a snapshot of (dashId, time, cluster, filters).
// Click it to land on that dashboard with the same context.
function loadViews() { return loadJSON(LS.views, []); }
function saveViews(views) { localStorage.setItem(LS.views, JSON.stringify(views)); }
function saveCurrentView() {
const dashId = state.route;
const all = loadViews();
const name = prompt('Save view as:', 'View ' + (all.length + 1));
if (!name) return;
const id = 'v-' + Date.now().toString(36);
all.push({
id,
name,
dashId,
time: state.time,
cluster: state.cluster,
filters: currentFilters(),
savedAt: new Date().toISOString(),
});
saveViews(all);
}
function deleteView(id) {
saveViews(loadViews().filter((v) => v.id !== id));
}
function applyView(id) {
const v = loadViews().find((x) => x.id === id);
if (!v) return;
state.time = v.time;
state.cluster = v.cluster || state.cluster;
state.filters[v.dashId] = { ...(v.filters || {}) };
saveFilters(v.dashId);
localStorage.setItem(LS.time, state.time);
location.hash = '#/dashboards/' + v.dashId;
}
function relTime(iso) {
if (!iso) return '';
const delta = Date.now() - new Date(iso).getTime();
if (delta < 2000) return 'just now';
if (delta < 60_000) return Math.round(delta / 1000) + 's ago';
if (delta < 3600_000) return Math.round(delta / 60_000) + 'm ago';
return Math.round(delta / 3600_000) + 'h ago';
}
function navStatus() {
if (state.loading) return 'LOADING…';
if (state.fetchErr) return 'ERROR · ' + state.fetchErr.slice(0, 40);
const bits = [];
// Prefer the label of the CURRENTLY-RENDERED view (state.sourceLabel, set
// from that view's own fetch below). The module-global dataSourceStatus() is
// a last-writer-wins value that any background/other-dashboard query can
// overwrite — reading it here is what let a live page show a stale/other
// dashboard's "MOCK FALLBACK". Fall back to it only before the first fetch.
bits.push(state.sourceLabel
|| (typeof dataSourceStatus === 'function' ? dataSourceStatus() : String(dataSourceStatus)));
if (state.fetchedAt) bits.push('UPDATED ' + relTime(state.fetchedAt).toUpperCase());
if (state.fetchMs != null) bits.push(state.fetchMs + 'MS');
return bits.join(' · ');
}
function runSearchNow() {
// No optimistic placeholder: until the engine answers, the table says
// SEARCHING and holds nothing. This function used to seed the result with
// mockSearch() — fabricated service/host/level hits — and keep them on any
// backend error, so a failed search showed invented documents under a LIVE
// pill (#923 review finding 5). Every outcome is now one of: pending, the
// engine's hits, or an explicit error with zero rows.
const seq = (state.search._seq = (state.search._seq || 0) + 1);
const prev = state.search.result;
state.search.result = { hits: [], total: 0, facets: {}, roles: prev?.roles || null, pending: true };
query({
dashId: 'search-discover',
range: state.time,
customRange: state.time === 'CUSTOM' ? state.timeCustom : null,
cluster: state.cluster,
filters: state.search.filters,
search: {
q: state.search.q,
type: state.search.type,
index: state.search.index,
sort: state.search.sort,
},
})
.then((res) => {
if (seq !== state.search._seq) return; // a newer search owns the table
const live = res?.data || {};
state.search.result = live.error
? { hits: [], total: 0, facets: {}, roles: live.roles || null, error: String(live.error),
resolvedIndex: live.resolvedIndex ?? null, narrowed: !!live.narrowed, request: live.request || null }
: {
hits: live.hits || [],
total: live.total ?? (live.hits?.length ?? 0),
tookMs: live.took ?? 0,
maxScore: live.max_score ?? null,
facets: live.facets || {},
histogram: live.histogram || null,
histogramField: live.histogramField || null,
roles: live.roles || null,
resolvedIndex: live.resolvedIndex ?? null,
narrowed: !!live.narrowed,
request: live.request || null,
_live: true,
};
state.fetchedAt = res.meta?.fetchedAt || Date.now();
state.fetchMs = res.meta?.durationMs ?? state.fetchMs;
// Only relabel if we're still on the search-driven view — a late search
// resolving after you've navigated away must not repaint the new view.
if (res.meta?.sourceLabel && state.section === 'discover') {
state.sourceLabel = res.meta.sourceLabel; state.sourceKind = res.meta.sourceKind;
}
if (state.section === 'discover') render();
})
.catch((err) => {
if (seq !== state.search._seq) return;
state.search.result = { hits: [], total: 0, facets: {}, roles: null, error: String(err && err.message || err) };
if (state.section === 'discover') render();
});
// Persist the inputs (not the result — it rebuilds on demand)
localStorage.setItem(LS.search, JSON.stringify({
q: state.search.q,
type: state.search.type,
index: state.search.index,
filters: state.search.filters,
sort: state.search.sort,
showTime: state.search.showTime,
}));
}
/**
* Parse the hash into { section, route }. Routes come in three shapes:
*
* #/ → section=dashboards, route=<first dashboard>
* #/dashboards → section=dashboards, route=<first dashboard>
* #/dashboards/:id → section=dashboards, route=:id
* #/<section> → section=<section>, route=<view id for that section>
*
* Backward compat: legacy `#/ai-overview` (bare dashboard id) gets
* auto-routed into `#/dashboards/ai-overview`, and legacy `#/manage`
* redirects to `#/settings`.
*/
function parseRoute() {
// Route = the hash *path* only. A `?query` tail inside the hash (e.g.
// `#/second-brain?brain=notes`, the deep link `xerj brain` prints) is
// view state owned by the dashboard, never part of the route.
const raw = (location.hash || '').replace(/^#\/?/, '').split('?')[0];
const parts = raw.split('/').filter(Boolean);
const merged = mergedDashboards(defaults, { includeHidden: true });
// Helper: find the default view id for a section.
const firstOfSection = (sectionId) => {
const list = dashboardsInSection(sectionId, merged);
return list[0]?.id;
};
// Empty hash → the Corpus home: what is indexed on this engine. It reads
// the live catalog and has an honest empty state (one command), so it is a
// safe landing on any engine — unlike a telemetry dashboard, it has nothing
// to fall back to.
if (!parts.length) {
return { section: 'corpus', route: 'corpus' };
}
// Legacy: #/manage → settings
if (parts[0] === 'manage') return { section: 'settings', route: 'settings' };
// Section-level route: #/section or #/section/:id
const sectionIds = new Set(SECTIONS.map((s) => s.id));
if (sectionIds.has(parts[0])) {
if (parts[0] === 'dashboards') {
const id = parts[1] || firstOfSection('dashboards') || 'ai-overview';
// Only accept real dashboards in this section
const known = merged.find((d) => d.id === id && (d.section || 'dashboards') === 'dashboards');
if (known) return { section: 'dashboards', route: id };
return { section: 'dashboards', route: firstOfSection('dashboards') || 'ai-overview' };
}
// Non-dashboards sections have exactly one view: firstOfSection
const first = firstOfSection(parts[0]);
if (first) return { section: parts[0], route: first };
}
// Legacy bare route: #/ai-overview → #/dashboards/ai-overview
if (merged.some((d) => d.id === parts[0])) {
const d = merged.find((x) => x.id === parts[0]);
const section = d.section || 'dashboards';
return { section, route: parts[0] };
}
// Fallback
return { section: 'dashboards', route: firstOfSection('dashboards') || 'ai-overview' };
}
// Build the data context that the section views (DATA / SETTINGS)
// need. Async because the reads hit the console's data-sources facade
// (data/data-sources.js — real-only; an unreachable engine yields
// empty lists, never seeded rows).
async function buildSectionData(sectionId) {
if (sectionId === 'data') {
const clusters = await listClusters();
const indicesByCluster = {};
const fieldsByIndex = {};
for (const c of clusters) {
indicesByCluster[c.id] = await listIndices(c.id);
}
const active = defaultClusterId();
for (const i of indicesByCluster[active] || []) {
fieldsByIndex[i.name] = await listFields(i.name);
}
return {
clusters,
indicesByCluster,
fieldsByIndex,
activeCluster: active,
focusIndex: state._focusIndex || (indicesByCluster[active] || [])[0]?.name,
};
}
if (sectionId === 'settings') {
return {
dashboards: mergedDashboards(defaults, { includeHidden: true }),
views: loadViews(),
};
}
return {};
}
function loadAllLayouts() {
// Iterate ALL `xerj.layout.*` keys — not just registry ids — so
// layouts synced down from /prefs.layouts (which may include ids this
// build doesn't ship, or default-dashboard overrides hydrated on
// another machine) are picked up instead of silently dropped.
const out = {};
const prefix = 'xerj.layout.';
for (const k of Object.keys(localStorage)) {
if (!k.startsWith(prefix)) continue;
const id = k.slice(prefix.length);
try {
const raw = localStorage.getItem(k);
if (raw) out[id] = JSON.parse(raw);
} catch { /* ignore corrupt */ }
}
return out;
}
function saveLayout(dashId) {
const v = state.layouts[dashId];
if (!v) localStorage.removeItem(LS.layout(dashId));
else localStorage.setItem(LS.layout(dashId), JSON.stringify(v));
}
function applyTheme(t) {
state.theme = t;
document.documentElement.setAttribute('data-theme', t);
localStorage.setItem(LS.theme, t);
}
// ---------- layout engine ---------------------------------
/**
* Merge a dashboard's default panels with the user's stored override.
* Returns a flat ordered array of panel objects ready to render.
*/
function mergeLayout(defaultPanels, override) {
if (!override) return defaultPanels.map((p) => ({ ...p, source: 'default' }));
const byId = Object.fromEntries(defaultPanels.map((p) => [p.id, p]));
const hidden = new Set(override.hidden || []);
const out = [];
const seen = new Set();
const order = override.order || defaultPanels.map((p) => p.id);
for (const id of order) {
if (hidden.has(id)) { seen.add(id); continue; }
const base = byId[id];
if (base) {
const cols = override.cols?.[id] ?? base.cols;
out.push({ ...base, cols, source: 'default' });
seen.add(id);
} else {
// Maybe a user-added panel.
const added = (override.added || []).find((a) => a.id === id);
if (added) {
const cols = override.cols?.[id] ?? added.cols;
out.push({ ...added, cols, source: 'added' });
seen.add(id);
}
}
}
// Append defaults missing from order (new panels added since override was saved).
for (const p of defaultPanels) {
if (!seen.has(p.id) && !hidden.has(p.id)) {
const cols = override.cols?.[p.id] ?? p.cols;
out.push({ ...p, cols, source: 'default' });
}
}
// Append user-added panels missing from order (freshly added).
for (const added of (override.added || [])) {
if (!seen.has(added.id)) {
const cols = override.cols?.[added.id] ?? added.cols;
out.push({ ...added, cols, source: 'added' });
}
}
return out;
}
function ensureOverride(dashId, defaultPanels) {
if (state.layouts[dashId]) return state.layouts[dashId];
const fresh = {
order: defaultPanels.map((p) => p.id),
cols: {},
hidden: [],
added: [],
};
state.layouts[dashId] = fresh;
return fresh;
}
function mutate(dashId, defaultPanels, fn) {
const ov = ensureOverride(dashId, defaultPanels);
fn(ov);
saveLayout(dashId);
}
// ---------- render ----------------------------------------
// Quick-size presets kept as a panel-toolbar convenience (the 6 discrete
// spans are no longer the ONLY resize path — declarative user panels get
// free w×h drag-resize; see the pointer handlers below).
const SIZES = [3, 4, 6, 8, 12];
const GRID_COLS = 12;
const ROW_H = 132; // px per grid row-unit in declarative canvases
const DEFAULT_GEOM = { x: 0, y: 0, w: 6, h: 2 };
// ---- declarative geometry helpers ------------------------
function clampInt(v, lo, hi) { v = Math.round(Number(v) || 0); return Math.max(lo, Math.min(hi, v)); }
function panelGeom(p) {
const g = p.geometry || {};
const w = clampInt(g.w ?? DEFAULT_GEOM.w, 1, GRID_COLS);
return {
x: clampInt(g.x ?? DEFAULT_GEOM.x, 0, GRID_COLS - w),
y: Math.max(0, Math.round(Number(g.y) || 0)),
w,
h: Math.max(1, Math.round(Number(g.h) || DEFAULT_GEOM.h)),
};
}
/** Next free row below everything, full-width-ish default slot. */
function nextGeometry(panels) {
let maxBottom = 0;
for (const p of panels || []) {
const g = panelGeom(p);
maxBottom = Math.max(maxBottom, g.y + g.h);
}
return { x: 0, y: maxBottom, w: 6, h: 2 };
}
/** Kibana-style vertical compaction: push overlapping panels down so no
* two panels occupy the same cell. Stable by (y, x). */
function compact(panels) {
const sorted = panels
.map((p, i) => ({ p, g: panelGeom(p), i }))
.sort((a, b) => (a.g.y - b.g.y) || (a.g.x - b.g.x) || (a.i - b.i));
const placed = [];
const overlaps = (a, b) => a.x < b.x + b.w && b.x < a.x + a.w && a.y < b.y + b.h && b.y < a.y + a.h;
for (const item of sorted) {
const g = { ...item.g };
let moved = true;
while (moved) {
moved = false;
for (const q of placed) {
if (overlaps(g, q.g)) { g.y = q.g.y + q.g.h; moved = true; }
}
}
placed.push({ p: item.p, g });
}
return placed.map(({ p, g }) => ({ ...p, geometry: g }));
}
// ---- builder (per-panel configurator) state --------------
const builder = {
open: false,
editingId: null, // panel id when editing an existing panel, else null
viz: 'topn',
index: '',
kind: 'terms',
field: 'level',
metric: 'count',
size: 8,
interval: '1h',
q: '',
title: '',
time: false,
preview: null, // { status, html } cache of the live preview
previewKey: '',
};
let BUILDER_INDICES = []; // cached index list for the picker
let BUILDER_FIELDS = []; // cached field list for the current index
function renderEditChrome(p) {
const sizes = SIZES.map((s) =>
`<button type="button" data-panel="${esc(p.id)}" data-size="${s}" class="${p.cols === s ? 'active' : ''}" aria-pressed="${p.cols === s}">${s}</button>`
).join('');
// Compact single-line toolbar so it fits the reserved 24px strip even on
// dense 2-col tiles (Issue 3): a small n/12 readout + size presets + ✕.
return `
<span class="panel-grip" aria-hidden="true">⠿</span>
<div class="panel-edit" aria-label="Edit panel">
<span class="wh mono">${p.cols}<span class="x">/</span>12</span>
<span class="sizes">${sizes}</span>
<button type="button" class="remove" data-panel="${esc(p.id)}" data-remove aria-label="Remove">✕</button>
</div>`;
}
// Declarative user-panel chrome: a top-left drag GRIP + a top-right
// toolbar (never in title flow) + SE/E/S resize handles.
function renderUserPanelChrome(p) {
const g = panelGeom(p);
const presets = SIZES.map((s) =>
`<button type="button" data-user-size="${s}" data-panel="${esc(p.id)}" class="${g.w === s ? 'active' : ''}">${s}</button>`
).join('<span class="sep">·</span>');
return `
<span class="panel-grip" data-grip="${esc(p.id)}" title="Drag to move" aria-label="Move panel">⠿</span>
<div class="panel-edit user" aria-label="Edit panel">
<span class="wh mono">${g.w}<span class="x">×</span>${g.h}</span>
<span class="sizes">${presets}</span>
<button type="button" class="cfg" data-user-config="${esc(p.id)}" title="Edit query / viz">QUERY</button>
<button type="button" class="remove" data-user-remove="${esc(p.id)}" aria-label="Remove">✕</button>
</div>
<span class="panel-resize e" data-resize="e" data-panel="${esc(p.id)}" aria-hidden="true"></span>
<span class="panel-resize s" data-resize="s" data-panel="${esc(p.id)}" aria-hidden="true"></span>
<span class="panel-resize se" data-resize="se" data-panel="${esc(p.id)}" aria-hidden="true"></span>`;
}
function renderPanel(p, data, editMode, ctx) {
// Declarative user panels: explicit x/y/w/h placement + per-panel live
// query (data/panel-query.js) rendered through the shared chart
// catalog (ux/panel-render.js). Chrome is out of title flow.
if (p.source === 'user') {
const g = panelGeom(p);
let inner;
try {
inner = renderDeclarativePanel(p, panelResult(p, ctx || {}));
} catch (err) {
inner = `<div class="panel-empty mono faint">PANEL ERROR · ${esc((err.message || err) + '').slice(0, 80)}</div>`;
}
const style = `grid-column:${g.x + 1}/span ${g.w}; grid-row:${g.y + 1}/span ${g.h};`;
const chrome = editMode ? renderUserPanelChrome(p) : '';
return `
<section class="panel user-panel${editMode ? ' edit' : ''}" data-panel="${esc(p.id)}" data-user-panel="1" style="${style}">
${chrome}
${p.title ? `<div class="key">${esc(p.title)}</div>` : ''}
${inner}
</section>`;
}
let inner = '';
try {
if (p.source === 'added') {
const t = chartTypes[p.type] || chartTypes.markdown;
inner = t.render(data);
} else if (typeof p.render === 'function') {
inner = p.render({ data });
} else {
inner = '';
}
// Empty-state fallback: if the render produced nothing meaningful,
// show a typography-first placeholder so users see WHY the slot is
// blank (e.g. filtered everything out) rather than a broken panel.
// A safe-mount panel (Corpus, Reader) is an EMPTY element on purpose:
// mountSafePanels() fills it with DOM nodes after this string is parsed.
const stripped = String(inner || '').replace(/<[^>]+>/g, '').trim();
if (!stripped && !/\sdata-safe-mount="/.test(String(inner))) {
inner = `<div class="panel-empty mono faint">NO DATA · ADJUST FILTERS OR TIME RANGE</div>`;
}
} catch (err) {
inner = `<div class="panel-empty mono faint">PANEL ERROR · ${esc((err.message || err) + '').slice(0, 80)}</div>`;
}
const editAttrs = editMode ? ' draggable="true"' : '';
const editChrome = editMode ? renderEditChrome(p) : '';
// A panel that declares `drilldown: { to: <dashId> }` adds a
// data attribute the global click handler uses to route clicks
// to the target dashboard with the clicked filter preserved.
const drillAttr = p.drilldown?.to ? ` data-drilldown-to="${esc(p.drilldown.to)}"` : '';
const drillHint = p.drilldown?.to ? `<span class="drill-hint mono faint">→ ${esc(p.drilldown.to.toUpperCase())}</span>` : '';
return `
<section class="panel${editMode ? ' edit' : ''}" data-panel="${esc(p.id)}" style="grid-column: span ${p.cols};"${editAttrs}${drillAttr}>
${editChrome}
${p.eyebrow ? `<div class="key">${esc(p.eyebrow)}${drillHint}</div>` : ''}
${inner}
</section>`;
}
function renderAddPicker(dash) {
// Declarative user dashboards get the real builder: + ADD PANEL opens
// an inline configurator (viz type → index/query → live preview).
if (dash && dash.declarative) {
if (builder.open) return renderBuilder();
return `
<div class="add-picker">
<button type="button" class="add-panel-btn" data-builder-open>+ ADD PANEL</button>
<span class="mono faint">BUILD A PANEL FROM ANY INDEX · PICK A VISUALIZATION + QUERY</span>
</div>`;
}
// Default (code) dashboards keep the quick chart-type add picker.
const items = chartTypeList.map((t) =>
`<button type="button" data-add="${esc(t.id)}" title="${esc(t.describe || '')}">${esc(t.name)}</button>`
).join('<span class="sep">·</span>');
return `
<div class="add-picker">
<span class="key" style="color:var(--z-accent);">+ ADD PANEL</span>
<span class="types">${items}</span>
</div>`;
}
// Build a declarative panel object from the current builder state.
function builderPanelDraft() {
const autoTitle = (builder.field
? `${builder.field} · ${chartTypes[builder.viz]?.name || builder.viz}`
: (chartTypes[builder.viz]?.name || builder.viz)).toUpperCase();
return {
id: builder.editingId || ('p-' + Date.now().toString(36) + Math.random().toString(36).slice(2, 5)),
title: (builder.title || autoTitle),
viz: { type: builder.viz, options: {} },
query: {
index: builder.index,
kind: builder.kind,
q: builder.q || '',
field: builder.field || '',
metric: builder.metric || 'count',
size: Number(builder.size) || 8,
interval: builder.interval || '1h',
time: !!builder.time,
},
geometry: builder._geometry || null,
};
}
const VIZ_LIST = ['metric', 'spark', 'gauge', 'line', 'bar', 'histogram', 'dist', 'topn', 'treemap', 'table', 'events'];
const KINDS = ['count', 'metric', 'timeseries', 'terms', 'search'];
const METRICS = ['count', 'sum', 'avg', 'max', 'min'];
// The inline configurator rendered in place of the ADD picker.
function renderBuilder() {
const b = builder;
const vizTiles = VIZ_LIST.map((id) =>
`<button type="button" data-builder-viz="${id}" class="${b.viz === id ? 'active' : ''}" title="${esc(chartTypes[id]?.describe || '')}">${esc(chartTypes[id]?.name || id)}</button>`
).join('');
const idxDatalist = BUILDER_INDICES.map((i) => `<option value="${esc(i.name)}"></option>`).join('');
const kindBtns = KINDS.map((k) =>
`<button type="button" data-builder-kind="${k}" class="${b.kind === k ? 'active' : ''}">${k.toUpperCase()}</button>`).join('<span class="sep">·</span>');
const metricBtns = METRICS.map((m) =>
`<button type="button" data-builder-metric="${m}" class="${b.metric === m ? 'active' : ''}">${m.toUpperCase()}</button>`).join('<span class="sep">·</span>');
const fieldList = BUILDER_FIELDS.map((f) => `<option value="${esc(f.name)}"></option>`).join('');
const needsField = b.kind === 'terms' || b.kind === 'metric' || (b.kind === 'timeseries' && b.metric !== 'count');
const needsSize = b.kind === 'terms';
const needsInterval = b.kind === 'timeseries';
const preview = b.preview && b.preview.html
? b.preview.html
: `<div class="panel-empty mono faint">${b.preview && b.preview.status === 'loading' ? 'RUNNING PREVIEW…' : 'PREVIEW APPEARS HERE'}</div>`;
return `
<div class="builder" role="dialog" aria-label="Configure panel">
<div class="builder-head">
<span class="key" style="color:var(--z-accent);">${b.editingId ? 'EDIT PANEL' : '+ NEW PANEL'}</span>
<button type="button" class="builder-x" data-builder-cancel aria-label="Close">✕</button>
</div>
<div class="builder-grid">
<div class="builder-col builder-form">
<label class="builder-field">
<span class="key">1 · VISUALIZATION</span>
<span class="viz-tiles">${vizTiles}</span>
</label>
<label class="builder-field">
<span class="key">2 · INDEX</span>
<input type="text" data-builder-index list="builder-indices" value="${esc(b.index)}" placeholder="e.g. logs-prod" class="builder-input" />
<datalist id="builder-indices">${idxDatalist}</datalist>
</label>
<label class="builder-field">
<span class="key">3 · QUERY KIND</span>
<span class="btn-row">${kindBtns}</span>
</label>
${needsField ? `
<label class="builder-field">
<span class="key">FIELD</span>
<input type="text" data-builder-field list="builder-fields" value="${esc(b.field)}" placeholder="e.g. level" class="builder-input" />
<datalist id="builder-fields">${fieldList}</datalist>
</label>` : ''}
${(b.kind === 'metric' || b.kind === 'timeseries' || b.kind === 'terms') ? `
<label class="builder-field">
<span class="key">METRIC</span>
<span class="btn-row">${metricBtns}</span>
</label>` : ''}
${needsSize ? `
<label class="builder-field">
<span class="key">TOP N</span>
<input type="number" min="1" max="50" data-builder-size value="${esc(b.size)}" class="builder-input short" />
</label>` : ''}
${needsInterval ? `
<label class="builder-field">
<span class="key">INTERVAL</span>
<input type="text" data-builder-interval value="${esc(b.interval)}" placeholder="1h" class="builder-input short" />
</label>` : ''}
<label class="builder-field">
<span class="key">FILTER (KQL)</span>
<input type="text" data-builder-q value="${esc(b.q)}" placeholder="optional · e.g. level:error" class="builder-input" />
</label>
<label class="builder-field">
<span class="key">TITLE</span>
<input type="text" data-builder-title value="${esc(b.title)}" placeholder="auto" class="builder-input" />
</label>
<div class="builder-actions">
<button type="button" class="builder-save" data-builder-save>${b.editingId ? 'SAVE CHANGES' : 'ADD PANEL'}</button>
<button type="button" class="builder-cancel" data-builder-cancel>CANCEL</button>
</div>
</div>
<div class="builder-col builder-preview">
<span class="key">LIVE PREVIEW</span>
<div class="builder-preview-box">${preview}</div>
</div>
</div>
</div>`;
}
// render() is async (it awaits the route's data) and is called from many
// places — boot, hashchange, the live-feature probe, the dashboard store,
// per-panel settles — with nothing serialising them. Without a guard the
// LAST render to finish wins, not the last one STARTED: a slow #/corpus fetch
// begun just before a route change resolves after the new route has painted
// and paints the old view (and its LIVE pill) back over it, with no further
// render to correct it (issue #1425). Each render takes a generation number;
// after every await, a render that has been superseded stops without touching
// state or the DOM — the newer render owns both.
let renderGen = 0;
async function render() {
const gen = ++renderGen;
const superseded = () => gen !== renderGen;
const app = document.getElementById('app');
// Resolve the active dashboard from either the default registry or
// the user metadata store. User-cloned dashboards inherit their
// render from their clonedFrom template.
const allDash = mergedDashboards(defaults, { includeHidden: true });
// NAV list only: hide live-gated dashboards until their probe says the engine
// holds their data (Second Brain before any `xerj brain`; the telemetry
// dashboards before anything is ingested). `allDash` stays unfiltered so a
// deep link resolves instantly; the nav catches up on the next probe tick.
const navDash = mergedDashboards(defaults)
.filter((d) => !d.requiresLive || state.liveFeatures[d.requiresLive]);
const dashboardsForSection = dashboardsInSection('dashboards', navDash);
// Secondary nav: drop dashboard GROUPS that have no visible members, so an
// empty "Logs" group doesn't linger on a brain-only engine.
const activeGroups = DASHBOARD_GROUPS.filter((g) => dashboardsForSection.some((d) => d.group === g.id));
// Which dashboard to RENDER. An explicit deep link — one that NAMES a
// dashboard in the hash, `#/dashboards/<id>` or the bare `#/<id>[?…]` form
// `xerj brain` prints (`#/second-brain?brain=<name>`) — resolves even if that
// id is currently gated: the link must open before the probe confirms the
// brain, and on an auth-enabled engine the brains probe is refused (401)
// outright, which used to send the printed link to the System dashboard's
// SAMPLE DATA (PR #945 review). But the DEFAULT landing (`#/dashboards`, or a
// stale route) must never open a gated, mock-filled dashboard: fall through
// to the first VISIBLE one (Second Brain on a brain-only engine, or System —
// always-on — on a truly empty engine).
const hashPath = ((typeof location !== 'undefined' && location.hash) || '')
.replace(/^#\/?/, '').split('?')[0].split('/').filter(Boolean);
const routed = allDash.find((d) => d.id === state.route);
const explicitDeepLink = !!routed && hashPath.length > 0 && hashPath[hashPath.length - 1] === routed.id;
const routedGated = routed && routed.requiresLive && !state.liveFeatures[routed.requiresLive];
// Deliberately NOT synced back to state.route: keeping the (gated) default
// route means the fallthrough re-resolves to the first VISIBLE dashboard on
// every render, so the landing follows the probe — System on an empty engine,
// then Second Brain the moment a `xerj brain` run registers a brain. An
// explicit deep link sets state.route itself and takes the first branch.
const dash = (routed && (explicitDeepLink || !routedGated))
? routed
: (dashboardsInSection(state.section, navDash)[0] || navDash[0] || registry['system']);
// For the SEARCH dashboard, eagerly run the search so panels see hits.
if (dash.id === 'search-discover' && !state.search.result) {
runSearchNow();
}
const activeFilters = currentFilters();
// A declarative (net-new) user dashboard runs a live query PER PANEL
// (data/panel-query.js) rather than a single whole-dashboard fetch.
const isDeclarative = !!(dash.isUser && dash.declarative);
const panelCtx = {
range: state.time,
customRange: state.time === 'CUSTOM' ? state.timeCustom : null,
cluster: state.cluster,
};
let data;
let fetchErr = null;
// Section-level views (data/settings/users/alerts) get their own
// context builder. Everything else goes through the regular query.
if (isDeclarative) {
data = {};
state.fetchErr = null;
// A user dashboard fetches per-panel (panel-query.js) and never touches the
// shared query() path, so stamp its own label here — otherwise navStatus
// would inherit the previously-viewed dashboard's pill.
state.sourceLabel = 'LIVE · XERJ · CUSTOM PANELS';
state.sourceKind = 'live';
// NOTE: index priming happens in openBuilder(), NOT here — calling it
// per-render would re-enter render() and loop.
} else if (state.section === 'data' || state.section === 'settings') {
try {
data = await buildSectionData(state.section);
if (superseded()) return;
// DATA is built from the live index inventory (_cat/indices); SETTINGS is
// local browser state. Label the pill honestly for each.
state.sourceLabel = state.section === 'settings' ? 'LOCAL · SETTINGS' : 'LIVE · XERJ · INDEX INVENTORY';
state.sourceKind = state.section === 'settings' ? 'local' : 'live';
} catch (err) {
if (superseded()) return;
data = {};
fetchErr = err;
// Surface the failure in the pill instead of leaving the prior view's
// label on a section that loaded nothing.
state.fetchErr = err.message || String(err);
state.sourceLabel = `${state.section.toUpperCase()}: LOAD FAILED`;
state.sourceKind = 'live-error';
}
} else {
state.loading = true;
try {
const result = await query({
dashId: dash.id,
range: state.time,
customRange: state.time === 'CUSTOM' ? state.timeCustom : null,
cluster: state.cluster,
filters: activeFilters,
});
if (superseded()) return;
data = result.data;
if (dash.id === 'corpus') state.corpus = data;
state.fetchedAt = result.meta.fetchedAt;
state.fetchMs = result.meta.durationMs;
// Tie the nav pill to THIS dashboard's fetch, not a global last-writer.
state.sourceLabel = result.meta.sourceLabel;
state.sourceKind = result.meta.sourceKind;
// The Reader fetches for itself; between its searches the pill shows
// what IT last reported, not query()'s placeholder.
if (dash.id === 'reader' && readerView.lastStatus) {
state.sourceLabel = readerView.lastStatus.label;
state.sourceKind = readerView.lastStatus.kind;
}
state.fetchErr = null;
} catch (err) {
if (superseded()) return;
state.fetchErr = err.message || String(err);
fetchErr = err;
} finally {
// The newer render set loading=true for its own pending fetch; leave it.
if (!superseded()) state.loading = false;
}
if (fetchErr) {
app.innerHTML = `
${Nav({ sections: SECTIONS, activeSection: state.section, dashboards: dashboardsForSection, groups: activeGroups, activeDash: dash.id, theme: state.theme, edit: state.edit, status: navStatus() })}
<div class="scene"><div class="key" style="margin-bottom:12px;">ERROR</div><h1 class="h-scene">CANNOT LOAD</h1></div>
<pre class="mono faint" style="white-space:pre-wrap; font-size:var(--fs-13);">${esc((fetchErr && fetchErr.stack) || fetchErr)}</pre>
<div style="margin-top:var(--sp-6);"><button type="button" data-retry class="text-btn">RETRY</button></div>`;
return;
}
}
const view = dash.render({ data, time: state.time, search: state.search, indices: state.indices });
// Let a user rename override the scene title. User-cloned dashboards
// always use the user-chosen name; defaults only override if the user
// has explicitly set an xerj.dashboards.names entry.
try {
const store = JSON.parse(localStorage.getItem('xerj.dashboards') || '{}');
if (dash.isUser || (store.names && store.names[dash.id])) {
view.title = (dash.name || view.title || '').toUpperCase();
}
} catch {}
let panelsHtml;
let panelCount;
if (isDeclarative) {
// Geometry lives IN the panels (x/y/w/h) — no separate layout
// override. Compact so a stale overlap never hides a panel.
const panels = compact(view.panels || []);
panelCount = panels.length;
panelsHtml = panels.length
? panels.map((p) => renderPanel(p, data, state.edit, panelCtx)).join('')
: `<div class="empty-dash mono faint" style="grid-column:1/span 12;">${
state.edit
? 'EMPTY DASHBOARD · CLICK <span class="accent">+ ADD PANEL</span> BELOW TO BUILD YOUR FIRST PANEL'
: 'EMPTY DASHBOARD · TOGGLE <span class="accent">EDIT</span> TO ADD PANELS'
}</div>`;
} else {
const merged = mergeLayout(view.panels, state.layouts[dash.id]);
panelCount = merged.length;
panelsHtml = merged.length
? merged.map((p) => renderPanel(p, data, state.edit, panelCtx)).join('')
: `<div class="mono faint" style="grid-column: span 12; padding:var(--sp-6) 0;">All panels hidden. Click RESET to restore defaults.</div>`;
}
// Edit chrome. The EDIT-MODE top strip now lives in NORMAL FLOW
// (sticky) right below the sub-nav so it never overlaps the dashboard
// sub-nav row (Issue 3). The dashed frame + numbered bottom strip stay
// as fixed, non-interactive overlays behind the panels.
const editTips = isDeclarative
? 'DRAG THE <span class="key-bind">⠿</span> GRIP TO MOVE · DRAG AN EDGE / CORNER TO RESIZE · <span class="key-bind">QUERY</span> TO RECONFIGURE'
: 'DRAG PANEL TO REORDER · CLICK A <span class="key-bind">NUMBER</span> TO RESIZE · <span class="key-bind">✕</span> TO REMOVE';
const editStripFlow = state.edit ? `
<div class="edit-strip-top" role="status">
<span class="marker">EDIT MODE</span>
<span class="tips">${editTips}</span>
<span class="meta">${esc(dash.name.toUpperCase())} · ${panelCount} PANELS</span>
</div>` : '';
const editFrame = state.edit ? `
<div class="edit-frame" aria-hidden="true"></div>
<div class="edit-strip-bottom" aria-hidden="true">${
Array.from({ length: 12 }, (_, i) => `<span>${String(i + 1).padStart(2, '0')}</span>`).join('')
}</div>
` : '';
const gridOverlay = state.edit
? `<div class="edit-grid" aria-hidden="true">${'<span></span>'.repeat(12)}</div>`
: '';
const addHtml = state.edit ? renderAddPicker(dash) : '';
// Section-level views (alerts, data, users, settings) don't show the
// inline time control — the time range is a dashboards-section concept.
const hideTimeCtrl = state.section !== 'dashboards' && state.section !== 'discover';
// Declarative user dashboards query per-panel; the dashboard-level KQL
// bar / saved views don't apply, so hide them (time range still does).
const showFilterBar = state.section === 'dashboards' && !isDeclarative;
const filterBarHtml = showFilterBar
? FilterBar({ filters: activeFilters, kql: serializeKql(activeFilters) })
: '';
const refreshHtml = hideTimeCtrl
? ''
: RefreshCtrl({ active: state.refresh });
const clusterHtml = hideTimeCtrl
? ''
: ClusterCtrl({ clusters: listClustersSync(), active: state.cluster });
const savedViewsHtml = showFilterBar
? SavedViews({ views: loadViews(), dashId: dash.id })
: '';
app.innerHTML = `
${Nav({
sections: SECTIONS,
activeSection: state.section,
dashboards: dashboardsForSection,
groups: activeGroups,
activeDash: dash.id,
theme: state.theme,
edit: state.edit,
mobile: state.mobile,
status: navStatus(),
})}
${state.mobile ? '<div class="iphone-frame"><div class="iphone-notch"></div><div class="iphone-screen">' : ''}
${SceneHeader({
title: view.title, kicker: view.kicker || 'OBSERVE', meta: view.meta || [state.time],
editable: state.edit, dashId: dash.id,
})}
${view.caption ? `<p class="caption">${esc(view.caption)}</p>` : ''}
${hideTimeCtrl ? '' : `<div class="dash-ctrls">${TimeCtrl({ active: state.time, custom: state.timeCustom })}${refreshHtml}${clusterHtml}</div>`}
${filterBarHtml}
${savedViewsHtml}
${editStripFlow}
<main class="canvas${state.edit ? ' edit' : ''}${isDeclarative ? ' declarative' : ''}" aria-label="${esc(dash.name)}">${gridOverlay}${panelsHtml}</main>
${addHtml}
${state.mobile ? '</div><div class="iphone-home-bar"></div></div>' : ''}
${Footer()}
${editFrame}
`;
app.setAttribute('aria-busy', 'false');
mountSafePanels(dash, data);
// Restore focus on the search input (if we're on the search dashboard).
if (state._focusSelector) {
const el = document.querySelector(state._focusSelector);
if (el) {
el.focus();
if (el.tagName === 'INPUT') {
const v = el.value;
el.setSelectionRange(v.length, v.length);
}
}
state._focusSelector = null;
}
}
/**
* Fill the panels that show document-derived content. Their `render()` emits
* only an empty `<div data-safe-mount="…">`; the content is built here as DOM
* nodes (ux/safe-dom.js), so nothing a document says can be parsed as markup.
* Runs after every shell render, because the shell replaces #app wholesale.
*/
function mountSafePanels(dash, data) {
const corpusEl = document.querySelector('[data-safe-mount="corpus"]');
if (corpusEl) {
const st = data && data.status ? data : { status: 'error', error: (data && data.error) || 'the catalog returned nothing' };
mount(corpusEl, renderCorpus(st, { guest: false }));
}
// The knowledge surface's other two panels — the relations autoindex
// inferred and the capability strip. Same rule as the grid above: nodes
// only, and an honest empty state rather than an omission.
const relsEl = document.querySelector('[data-safe-mount="corpus-relations"]');
if (relsEl) mount(relsEl, renderRelations(data || {}));
const capsEl = document.querySelector('[data-safe-mount="corpus-capabilities"]');
if (capsEl) mount(capsEl, renderCapabilities(data || {}));
const readerEl = document.querySelector('[data-safe-mount="reader"]');
if (readerEl) {
readerView.attach(readerEl);
readerView.setRoute(parseReaderRoute(location.hash));
} else {
readerView.detach();
}
void dash;
}
// ==========================================================
// Declarative (net-new) user-dashboard subsystem
// • panel builder (viz + index/query + live preview)
// • per-panel mutation → PATCH panels[]
// • free-form pointer drag-move + edge/corner resize
// ==========================================================
/** The active dashboard IF it's a declarative user dashboard, else null. */
function activeUserDash() {
const all = mergedDashboards(defaults, { includeHidden: true });
const d = all.find((x) => x.id === state.route);
return d && d.isUser && d.declarative ? d : null;
}
/** Clone the doc's panels[], apply fn, compact, persist (optimistic) + render. */
function userPanelsMutate(id, fn) {
const doc = getDoc(id);
if (!doc) return;
const panels = (Array.isArray(doc.panels) ? doc.panels : []).map((p) => ({ ...p }));
const next = fn(panels) || panels;
patchPanels(id, compact(next));
render();
}
// ---- panel builder ---------------------------------------
let BUILDER_INDICES_LOADED = false;
async function ensureBuilderIndices(force) {
if (BUILDER_INDICES_LOADED && !force) return;
// Mark loaded BEFORE the await so a concurrent/re-entrant render can't
// spawn a second fetch → render → fetch loop.
BUILDER_INDICES_LOADED = true;
try {
const list = await listIndices(defaultClusterId());
BUILDER_INDICES = (list || []).filter((i) => i && i.name);
if (!builder.index && BUILDER_INDICES.length) builder.index = BUILDER_INDICES[0].name;
if (builder.open) render();
} catch {
BUILDER_INDICES_LOADED = false; // allow a later retry
}
}
async function ensureBuilderFields(index) {
if (!index) { BUILDER_FIELDS = []; return; }
try {
// Populate the field datalist silently — do NOT render() here, or a
// render mid-keystroke in the index input would steal focus. The new
// suggestions surface on the next natural render (viz/kind click, etc).
BUILDER_FIELDS = (await listFields(index)) || [];
} catch { BUILDER_FIELDS = []; }
}
function openBuilder(editingId) {
const dash = activeUserDash();
if (!dash) return;
builder.open = true;
builder.editingId = editingId || null;
builder.preview = null;
builder._geometry = null;
if (editingId) {
const p = (getDoc(dash.id)?.panels || []).find((x) => x.id === editingId);
if (p) {
builder.viz = p.viz?.type || 'topn';
builder.index = p.query?.index || builder.index;
builder.kind = p.query?.kind || 'terms';
builder.field = p.query?.field || '';
builder.metric = p.query?.metric || 'count';
builder.size = p.query?.size || 8;
builder.interval = p.query?.interval || '1h';
builder.q = p.query?.q || '';
builder.title = p.title || '';
builder.time = !!p.query?.time;
builder._geometry = p.geometry || null;
}
} else {
builder.viz = builder.viz || 'topn';
builder.kind = builder.kind || 'terms';
builder.field = builder.field || 'level';
builder.metric = builder.metric || 'count';
builder.q = '';
builder.title = '';
}
ensureBuilderIndices();
ensureBuilderFields(builder.index);
render();
previewNow();
}
function closeBuilder() {
builder.open = false;
builder.editingId = null;
builder.preview = null;
render();
}
let previewSeq = 0;
let previewTimer = null;
function previewSoon() { clearTimeout(previewTimer); previewTimer = setTimeout(previewNow, 250); }
function paintPreview() {
const box = document.querySelector('.builder-preview-box');
if (!box) return;
if (builder.preview && builder.preview.html) box.innerHTML = builder.preview.html;
else if (builder.preview && builder.preview.status === 'loading') box.innerHTML = '<div class="panel-empty mono faint">RUNNING PREVIEW…</div>';
}
async function previewNow() {
clearTimeout(previewTimer);
const draft = builderPanelDraft();
if (!draft.query.index || !draft.query.kind) { builder.preview = null; paintPreview(); return; }
ensureBuilderFields(draft.query.index); // refresh field suggestions (debounced via previewNow)
const my = ++previewSeq;
builder.preview = { status: 'loading', html: '' };
paintPreview();
try {
const res = await fetchPanel(draft, { range: state.time });
if (my !== previewSeq) return;
builder.preview = { status: 'ready', html: renderDeclarativePanel(draft, { status: 'ready', data: res }) };
} catch (e) {
if (my !== previewSeq) return;
builder.preview = { status: 'error', html: `<div class="panel-empty mono faint">PREVIEW ERROR · ${esc(String(e.message || e)).slice(0, 80)}</div>` };
}
paintPreview();
}
function commitBuilder() {
const dash = activeUserDash();
if (!dash) return;
const draft = builderPanelDraft();
if (!draft.query.index) return;
builder.open = false;
builder.editingId = null;
builder.preview = null;
userPanelsMutate(dash.id, (panels) => {
const idx = panels.findIndex((p) => p.id === draft.id);
if (idx >= 0) {
draft.geometry = draft.geometry || panels[idx].geometry || nextGeometry(panels);
panels[idx] = draft;
} else {
draft.geometry = draft.geometry || nextGeometry(panels);
panels.push(draft);
}
return panels;
});
requestAnimationFrame(() => {
try {
const el = document.querySelector(`.panel[data-panel="${CSS.escape(draft.id)}"]`);
if (el) el.scrollIntoView({ behavior: 'smooth', block: 'center' });
} catch { /* ignore */ }
});
}
// Click handling for builder + user-panel chrome. Returns true if handled.
function handleDeclClick(e) {
if (e.target.closest('[data-builder-open]')) { openBuilder(); return true; }
if (e.target.closest('[data-builder-cancel]')) { closeBuilder(); return true; }
const viz = e.target.closest('[data-builder-viz]');
if (viz) { builder.viz = viz.getAttribute('data-builder-viz'); render(); previewNow(); return true; }
const kind = e.target.closest('[data-builder-kind]');
if (kind) { builder.kind = kind.getAttribute('data-builder-kind'); render(); previewNow(); return true; }
const metric = e.target.closest('[data-builder-metric]');
if (metric) { builder.metric = metric.getAttribute('data-builder-metric'); render(); previewNow(); return true; }
if (e.target.closest('[data-builder-save]')) { commitBuilder(); return true; }
const cfg = e.target.closest('[data-user-config]');
if (cfg) { openBuilder(cfg.getAttribute('data-user-config')); return true; }
const rm = e.target.closest('[data-user-remove]');
if (rm) {
const id = rm.getAttribute('data-user-remove');
const dash = activeUserDash();
if (dash) userPanelsMutate(dash.id, (panels) => panels.filter((p) => p.id !== id));
return true;
}
const usz = e.target.closest('[data-user-size]');
if (usz) {
const pid = usz.getAttribute('data-panel');
const w = clampInt(usz.getAttribute('data-user-size'), 1, GRID_COLS);
const dash = activeUserDash();
if (dash) userPanelsMutate(dash.id, (panels) => {
const idx = panels.findIndex((p) => p.id === pid);
if (idx >= 0) {
const g = panelGeom(panels[idx]);
panels[idx] = { ...panels[idx], geometry: { ...g, w, x: Math.min(g.x, GRID_COLS - w) } };
}
return panels;
});
return true;
}
return false;
}
// Text-input handling for the builder (no full re-render → focus preserved).
function handleDeclInput(e) {
const t = e.target;
if (!t || !t.matches) return false;
if (t.matches('[data-builder-index]')) { builder.index = t.value.trim(); previewSoon(); return true; }
if (t.matches('[data-builder-field]')) { builder.field = t.value; previewSoon(); return true; }
if (t.matches('[data-builder-size]')) { builder.size = t.value; previewSoon(); return true; }
if (t.matches('[data-builder-interval]')) { builder.interval = t.value; previewSoon(); return true; }
if (t.matches('[data-builder-q]')) { builder.q = t.value; previewSoon(); return true; }
if (t.matches('[data-builder-title]')) { builder.title = t.value; return true; }
return false;
}
// ---- free-form pointer drag-move + resize ----------------
let geomDrag = null;
function cellMetrics(canvasEl) {
const rect = canvasEl.getBoundingClientRect();
const cs = getComputedStyle(canvasEl);
const colGap = parseFloat(cs.columnGap) || 16;
const rowGap = parseFloat(cs.rowGap) || 16;
const colW = (rect.width - colGap * (GRID_COLS - 1)) / GRID_COLS;
return { pitchX: colW + colGap, pitchY: ROW_H + rowGap };
}
function startGeomDrag(e, mode, panelId) {
if (!state.edit) return;
// `panelId` identifies the panel; the doc is the ACTIVE DASHBOARD's doc
// (getDoc/userPanelsMutate are keyed by dashboard id, not panel id).
const dash = activeUserDash();
if (!dash) return;
const doc = getDoc(dash.id);
const panelEl = e.target.closest('.panel');
const canvasEl = panelEl && panelEl.closest('.canvas');
if (!panelEl || !canvasEl || !doc) return;
const p = (doc.panels || []).find((x) => x.id === panelId);
if (!p) return;
e.preventDefault();
const m = cellMetrics(canvasEl);
geomDrag = {
dashId: dash.id, panelId, mode, panelEl,
startX: e.clientX, startY: e.clientY,
startGeom: panelGeom(p),
pitchX: m.pitchX, pitchY: m.pitchY,
cur: panelGeom(p),
};
panelEl.classList.add('dragging-geom');
try { e.target.setPointerCapture(e.pointerId); } catch { /* ignore */ }
}
function moveGeomDrag(e) {
if (!geomDrag) return;
const d = geomDrag;
const dCol = Math.round((e.clientX - d.startX) / d.pitchX);
const dRow = Math.round((e.clientY - d.startY) / d.pitchY);
const g = { ...d.startGeom };
if (d.mode === 'move') {
g.x = clampInt(d.startGeom.x + dCol, 0, GRID_COLS - d.startGeom.w);
g.y = Math.max(0, d.startGeom.y + dRow);
} else {
if (d.mode === 'e' || d.mode === 'se') g.w = clampInt(d.startGeom.w + dCol, 1, GRID_COLS - d.startGeom.x);
if (d.mode === 's' || d.mode === 'se') g.h = Math.max(1, d.startGeom.h + dRow);
}
d.cur = g;
d.panelEl.style.gridColumn = `${g.x + 1}/span ${g.w}`;
d.panelEl.style.gridRow = `${g.y + 1}/span ${g.h}`;
const wh = d.panelEl.querySelector('.panel-edit .wh');
if (wh) wh.innerHTML = `${g.w}<span class="x">×</span>${g.h}`;
}
function endGeomDrag() {
if (!geomDrag) return;
const d = geomDrag;
geomDrag = null;
d.panelEl.classList.remove('dragging-geom');
const g = d.cur;
const s = d.startGeom;
if (g.x !== s.x || g.y !== s.y || g.w !== s.w || g.h !== s.h) {
userPanelsMutate(d.dashId, (panels) => {
const idx = panels.findIndex((p) => p.id === d.panelId);
if (idx >= 0) panels[idx] = { ...panels[idx], geometry: g };
return panels;
});
}
}
document.addEventListener('pointerdown', (e) => {
const grip = e.target.closest('[data-grip]');
if (grip) { startGeomDrag(e, 'move', grip.getAttribute('data-grip')); return; }
const rz = e.target.closest('[data-resize]');
if (rz) { startGeomDrag(e, rz.getAttribute('data-resize'), rz.getAttribute('data-panel')); }
});
document.addEventListener('pointermove', moveGeomDrag);
document.addEventListener('pointerup', endGeomDrag);
document.addEventListener('pointercancel', endGeomDrag);
// Builder text inputs (input event — no re-render, keeps focus).
document.addEventListener('input', (e) => { handleDeclInput(e); });
// ---------- event delegation ------------------------------
let dragSrcId = null;
document.addEventListener('click', (e) => {
// Corpus cards. The attribute values are DATA written by
// ux/corpus-render.js; they are parsed, validated and turned into state —
// never evaluated and never put back into markup.
const cq = e.target.closest && e.target.closest('[data-corpus-query]');
if (cq) {
e.preventDefault();
let spec = null;
try { spec = JSON.parse(cq.getAttribute('data-corpus-query')); } catch { spec = null; }
if (spec && typeof spec.index === 'string' && typeof spec.q === 'string') {
readerView.setQuery({ q: spec.q, type: String(spec.type || 'match'), field: typeof spec.field === 'string' ? spec.field : null });
location.hash = readerHref({ index: spec.index });
}
return;
}
const cb = e.target.closest && e.target.closest('[data-corpus-browse]');
if (cb) {
e.preventDefault();
const idx = cb.getAttribute('data-corpus-browse');
if (idx) { state.search.index = idx; state.search.filters = {}; state.search.result = null; }
location.hash = '#/discover';
return;
}
// Declarative user-dashboard chrome (builder + user-panel toolbar).
// Handled first so its specific data-* attrs never fall through to the
// default-dashboard handlers below.
if (handleDeclClick(e)) { e.preventDefault(); return; }
// Primary nav: top-level product section
const secA = e.target.closest('[data-section]');
if (secA) {
e.preventDefault();
const sid = secA.getAttribute('data-section');
if (sid === 'dashboards') {
location.hash = '#/dashboards';
} else {
location.hash = '#/' + sid;
}
return;
}
// Secondary nav: a specific dashboard inside the dashboards section
const dashA = e.target.closest('[data-dash]');
if (dashA) {
e.preventDefault();
const id = dashA.getAttribute('data-dash');
location.hash = '#/dashboards/' + id;
return;
}
// Secondary nav: a collapsed group tab — switch groups by landing
// on the group's first dashboard.
const groupBtn = e.target.closest('[data-dash-group]');
if (groupBtn) {
e.preventDefault();
const firstId = groupBtn.getAttribute('data-dash-group-first');
if (firstId) location.hash = '#/dashboards/' + firstId;
return;
}
// Time range
const tb = e.target.closest('[data-time]');
if (tb) {
state.time = tb.getAttribute('data-time');
localStorage.setItem(LS.time, state.time);
// When switching INTO custom and we have no stored endpoints,
// seed a sensible default (now − 24h → now).
if (state.time === 'CUSTOM' && !state.timeCustom.from) {
const now = new Date();
const prev = new Date(now.getTime() - 24 * 3600 * 1000);
const fmt = (d) => d.toISOString().slice(0, 16);
state.timeCustom = { from: fmt(prev), to: fmt(now) };
localStorage.setItem('xerj.timeFrom', state.timeCustom.from);
localStorage.setItem('xerj.timeTo', state.timeCustom.to);
}
writeUrlState();
render();
return;
}
// Refresh interval
const rf = e.target.closest('[data-refresh]');
if (rf) {
setRefreshInterval(parseInt(rf.getAttribute('data-refresh'), 10));
render();
return;
}
// Manual retry on error
if (e.target.closest('[data-retry]')) {
render();
return;
}
// Global filter bar: click-to-filter (used by FilterBar pills and
// any click-to-filter affordance inside a panel — TopN rows, Dist
// segments, heatmap cells).
const fAdd = e.target.closest('[data-filter-add]');
if (fAdd) {
const raw = fAdd.getAttribute('data-filter-add');
const idx = raw.indexOf(':');
if (idx > 0) {
const field = raw.slice(0, idx);
const value = raw.slice(idx + 1);
// Drilldown takes precedence when the panel declares one.
const drillHost = fAdd.closest('[data-drilldown-to]');
if (drillHost) {
const toId = drillHost.getAttribute('data-drilldown-to');
// Seed the target dashboard's filters with this value before
// navigating so the destination renders pre-filtered. The
// search-discover dashboard has its own filter store
// (state.search.filters) — seed that one instead.
if (toId === 'search-discover') {
state.search.filters = { ...(state.search.filters || {}), [field]: value };
state.search.result = null; // force re-run on render
} else {
state.filters[toId] = { ...(state.filters[toId] || {}), [field]: value };
try { localStorage.setItem(LS.filters(toId), JSON.stringify(state.filters[toId])); } catch {}
}
// Resolve the target's actual section — some targets (like
// search-discover) live outside the 'dashboards' section and
// need a different hash shape (#/discover rather than
// #/dashboards/search-discover).
const all = mergedDashboards(defaults, { includeHidden: true });
const target = all.find((d) => d.id === toId);
const sectionId = target?.section || 'dashboards';
location.hash = sectionId === 'dashboards' ? `#/dashboards/${toId}` : `#/${sectionId}`;
return;
}
setFilter(field, value);
render();
}
return;
}
// Remove one chip from a filter pill (multi-value OR filters).
const fRem = e.target.closest('[data-filter-remove]');
if (fRem) {
const raw = fRem.getAttribute('data-filter-remove');
const idx = raw.indexOf(':');
if (idx > 0) {
removeFilterValue(raw.slice(0, idx), raw.slice(idx + 1));
render();
}
return;
}
if (e.target.closest('[data-filter-clear]')) {
clearFilters();
render();
return;
}
// Cluster selector
const cset = e.target.closest('[data-cluster-set]');
if (cset) {
state.cluster = cset.getAttribute('data-cluster-set');
setDefaultCluster(state.cluster);
writeUrlState();
render();
return;
}
// Save current view
if (e.target.closest('[data-view-save]')) {
saveCurrentView();
render();
return;
}
// Apply a saved view
const vApply = e.target.closest('[data-view-apply]');
if (vApply) {
applyView(vApply.getAttribute('data-view-apply'));
return;
}
// Delete a saved view
const vDel = e.target.closest('[data-view-delete]');
if (vDel) {
const id = vDel.getAttribute('data-view-delete');
if (confirm('Delete this view?')) {
deleteView(id);
render();
}
return;
}
// Theme
const th = e.target.closest('[data-theme-set]');
if (th) {
applyTheme(th.getAttribute('data-theme-set'));
render();
return;
}
// Mobile preview toggle
if (e.target.closest('[data-mobile-toggle]')) {
state.mobile = !state.mobile;
localStorage.setItem('xerj.mobile', state.mobile ? '1' : '0');
document.documentElement.classList.toggle('mobile-preview', state.mobile);
render();
return;
}
// Edit toggle
if (e.target.closest('[data-edit-toggle]')) {
state.edit = !state.edit;
localStorage.setItem(LS.edit, state.edit ? '1' : '0');
render();
return;
}
// Reset layout
if (e.target.closest('[data-reset-layout]')) {
const id = state.route;
delete state.layouts[id];
saveLayout(id);
render();
return;
}
// Resize (click a size number)
const sz = e.target.closest('[data-size]');
if (sz) {
const pid = sz.getAttribute('data-panel');
const cols = parseInt(sz.getAttribute('data-size'), 10);
const dash = registry[state.route];
const view = dash.render({ data: {}, time: state.time });
mutate(state.route, view.panels, (ov) => { ov.cols[pid] = cols; });
render();
return;
}
// Remove panel
const rm = e.target.closest('[data-remove]');
if (rm) {
const pid = rm.getAttribute('data-panel');
const dash = registry[state.route];
const view = dash.render({ data: {}, time: state.time });
mutate(state.route, view.panels, (ov) => {
if (!ov.hidden.includes(pid)) ov.hidden.push(pid);
const idx = (ov.added || []).findIndex((a) => a.id === pid);
if (idx >= 0) ov.added.splice(idx, 1);
});
render();
return;
}
// Search: query type
const qt = e.target.closest('[data-query-type]');
if (qt) {
state.search.type = qt.getAttribute('data-query-type');
runSearchNow();
state._focusSelector = '[data-search-input]';
render();
return;
}
// Search: index
const si = e.target.closest('[data-search-index]');
if (si) {
state.search.index = si.getAttribute('data-search-index');
runSearchNow();
state._focusSelector = '[data-search-input]';
render();
return;
}
// Facet apply (click-to-filter) — also drives the click-to-filter on Hit
// row values and the ✕ on filter pills (clicking an active value removes).
const fa = e.target.closest('[data-facet-apply]');
if (fa) {
const raw = fa.getAttribute('data-facet-apply');
const colonIdx = raw.indexOf(':');
const field = raw.slice(0, colonIdx);
const value = raw.slice(colonIdx + 1);
const cur = state.search.filters[field];
if (cur === value) delete state.search.filters[field];
else state.search.filters[field] = value;
runSearchNow();
render();
return;
}
// Clear all filters
if (e.target.closest('[data-facet-clear]')) {
state.search.filters = {};
runSearchNow();
render();
return;
}
// Sort a Hits column (GH#696 / GH#737)
const sortBtn = e.target.closest('[data-sort-field]');
if (sortBtn) {
state.search.sort = {
field: sortBtn.getAttribute('data-sort-field'),
dir: sortBtn.getAttribute('data-sort-dir'),
};
runSearchNow();
render();
return;
}
// Toggle time-column visibility (GH#3319)
if (e.target.closest('[data-toggle-time]')) {
state.search.showTime = !state.search.showTime;
runSearchNow();
render();
return;
}
// Export Hits as CSV (GH#1992 — the #1 ask of all time)
if (e.target.closest('[data-export-csv]')) {
const hits = state.search.result?.hits || [];
const cols = state.search.showTime
? ['_index', '_id', '_score', '_ts', '_source']
: ['_index', '_id', '_score', '_source'];
downloadText('xerj-search-' + new Date().toISOString().slice(0, 19).replace(/[:T]/g, '-') + '.csv',
'text/csv', hitsToCsv(hits, cols));
return;
}
// Export a panel chart as PNG (GH#1366 — 178 reactions)
const pngBtn = e.target.closest('[data-export-png]');
if (pngBtn) {
const sec = pngBtn.closest('.panel');
const svg = sec?.querySelector('svg.chart, svg.series');
if (svg) {
const id = sec.getAttribute('data-panel') || 'panel';
svgToPng(svg, { filename: 'xerj-' + id + '.png' }).catch((err) =>
console.error('PNG export failed', err));
}
return;
}
// --- MANAGE view click handlers -------------------------
const mgUp = e.target.closest('[data-mg-up]');
if (mgUp) {
const id = mgUp.getAttribute('data-mg-up');
const list = mergedDashboards(defaults, { includeHidden: true });
const i = list.findIndex((d) => d.id === id);
if (i > 0) {
const order = list.map((d) => d.id);
[order[i - 1], order[i]] = [order[i], order[i - 1]];
reorderDashboards(order);
render();
}
return;
}
const mgDown = e.target.closest('[data-mg-down]');
if (mgDown) {
const id = mgDown.getAttribute('data-mg-down');
const list = mergedDashboards(defaults, { includeHidden: true });
const i = list.findIndex((d) => d.id === id);
if (i >= 0 && i < list.length - 1) {
const order = list.map((d) => d.id);
[order[i + 1], order[i]] = [order[i], order[i + 1]];
reorderDashboards(order);
render();
}
return;
}
const mgRename = e.target.closest('[data-mg-rename]');
if (mgRename) {
const id = mgRename.getAttribute('data-mg-rename');
const current = mergedDashboards(defaults, { includeHidden: true }).find((d) => d.id === id);
const name = prompt('Rename "' + (current?.name || id) + '":', current?.name || '');
if (name != null) {
renameDashboard(id, name);
render();
}
return;
}
const mgHide = e.target.closest('[data-mg-hide]');
if (mgHide) {
const id = mgHide.getAttribute('data-mg-hide');
const list = mergedDashboards(defaults, { includeHidden: true });
const cur = list.find((d) => d.id === id);
setHidden(id, !cur?.hidden);
render();
return;
}
const mgClone = e.target.closest('[data-mg-clone]');
if (mgClone) {
const id = mgClone.getAttribute('data-mg-clone');
const current = mergedDashboards(defaults, { includeHidden: true }).find((d) => d.id === id);
// POST a real durable doc, then route to it in edit mode. Rename is
// inline (contenteditable scene title) — no window.prompt.
(async () => {
const newId = await createUserDashboard({ name: (current?.name || 'Untitled') + ' (copy)', fromId: id });
state.edit = true; localStorage.setItem(LS.edit, '1');
location.hash = '#/dashboards/' + newId;
})();
return;
}
const mgDelete = e.target.closest('[data-mg-delete]');
if (mgDelete) {
const id = mgDelete.getAttribute('data-mg-delete');
if (isUserDash(id) && confirm('Delete user dashboard "' + id + '"? This cannot be undone.')) {
deleteUserDashboard(id);
if (state.route === id) {
location.hash = '#/settings';
} else {
render();
}
}
return;
}
const mgNew = e.target.closest('[data-mg-new]');
if (mgNew) {
const fromId = mgNew.getAttribute('data-mg-new') || null;
// Net-new = declarative shell (empty panels[]) → POST a real doc,
// route to it in edit mode, and auto-open the panel builder. Naming
// is inline via the contenteditable scene title (no window.prompt).
(async () => {
const newId = await createUserDashboard({ name: fromId ? 'Copy of ' + fromId : 'Untitled dashboard', fromId });
state.edit = true; localStorage.setItem(LS.edit, '1');
location.hash = '#/dashboards/' + newId;
if (!fromId) setTimeout(() => { if (activeUserDash()) openBuilder(); }, 80);
})();
return;
}
const mgCluster = e.target.closest('[data-mg-cluster]');
if (mgCluster) {
setDefaultCluster(mgCluster.getAttribute('data-mg-cluster'));
state._focusIndex = null;
render();
return;
}
const mgIndex = e.target.closest('[data-mg-index]');
if (mgIndex) {
state._focusIndex = mgIndex.getAttribute('data-mg-index');
render();
return;
}
if (e.target.closest('[data-mg-reset-all]')) {
if (confirm('Reset ALL saved state? This wipes dashboards, layouts, theme, filters.')) {
for (const k of Object.keys(localStorage)) {
if (k.startsWith('xerj.')) localStorage.removeItem(k);
}
resetDashboards();
location.reload();
}
return;
}
// Add panel (from ADD picker)
const add = e.target.closest('[data-add]');
if (add) {
const typeId = add.getAttribute('data-add');
const t = chartTypes[typeId];
if (!t) return;
const dash = registry[state.route];
const view = dash.render({ data: {}, time: state.time });
mutate(state.route, view.panels, (ov) => {
ov.added = ov.added || [];
const newId = typeId + '-' + Date.now().toString(36);
ov.added.push({
id: newId,
type: typeId,
eyebrow: t.name + ' · NEW',
cols: t.cols || 6,
});
ov.order = ov.order || view.panels.map((p) => p.id);
ov.order.push(newId);
});
render();
// scroll to bottom so the new panel is visible
requestAnimationFrame(() => window.scrollTo({ top: document.body.scrollHeight, behavior: 'smooth' }));
return;
}
});
// ---------- search input (Enter to run) -------------------
document.addEventListener('keydown', (e) => {
// KQL-lite input on dashboards
const kq = e.target.closest && e.target.closest('[data-kql-input]');
if (kq) {
if (e.key === 'Enter') {
e.preventDefault();
applyKqlInput(kq.value);
state._focusSelector = '[data-kql-input]';
render();
} else if (e.key === 'Escape') {
e.preventDefault();
kq.value = '';
applyKqlInput('');
state._focusSelector = '[data-kql-input]';
render();
}
return;
}
const si = e.target.closest && e.target.closest('[data-search-input]');
if (si) {
if (e.key === 'Enter') {
e.preventDefault();
state.search.q = si.value;
runSearchNow();
state._focusSelector = '[data-search-input]';
render();
} else if (e.key === 'Escape') {
si.value = '';
state.search.q = '';
state.search.filters = {};
runSearchNow();
state._focusSelector = '[data-search-input]';
render();
}
return;
}
// Inline rename of the scene title in edit mode (contenteditable h1)
const rn = e.target.closest && e.target.closest('[data-rename-dash]');
if (rn) {
if (e.key === 'Enter') {
e.preventDefault();
const id = rn.getAttribute('data-rename-dash');
const name = rn.textContent.trim();
renameDashboard(id, name);
rn.blur();
render();
} else if (e.key === 'Escape') {
e.preventDefault();
rn.blur();
render();
}
}
});
// Custom time range — FROM/TO datetime-local inputs
document.addEventListener('change', (e) => {
const tf = e.target.closest && e.target.closest('[data-time-from]');
const tt = e.target.closest && e.target.closest('[data-time-to]');
if (tf || tt) {
state.timeCustom = {
from: document.querySelector('[data-time-from]')?.value || '',
to: document.querySelector('[data-time-to]')?.value || '',
};
localStorage.setItem('xerj.timeFrom', state.timeCustom.from);
localStorage.setItem('xerj.timeTo', state.timeCustom.to);
writeUrlState();
render();
}
});
// blur-save for inline rename (clicking outside the title also commits)
document.addEventListener('blur', (e) => {
const rn = e.target.closest && e.target.closest('[data-rename-dash]');
if (!rn) return;
const id = rn.getAttribute('data-rename-dash');
const newName = rn.textContent.trim();
renameDashboard(id, newName);
}, true);
// ---------- drag and drop ---------------------------------
document.addEventListener('dragstart', (e) => {
if (!state.edit) return;
const sec = e.target.closest('.panel.edit');
if (!sec) return;
dragSrcId = sec.getAttribute('data-panel');
sec.classList.add('dragging');
try {
e.dataTransfer.effectAllowed = 'move';
e.dataTransfer.setData('text/plain', dragSrcId);
} catch {}
});
document.addEventListener('dragover', (e) => {
if (!state.edit || !dragSrcId) return;
const sec = e.target.closest('.panel.edit');
if (!sec) return;
e.preventDefault();
document.querySelectorAll('.drop-before, .drop-after').forEach((el) => el.classList.remove('drop-before', 'drop-after'));
const rect = sec.getBoundingClientRect();
const after = e.clientX > rect.left + rect.width / 2;
sec.classList.add(after ? 'drop-after' : 'drop-before');
});
document.addEventListener('dragleave', (e) => {
const sec = e.target.closest('.panel.edit');
if (sec && !sec.contains(e.relatedTarget)) sec.classList.remove('drop-before', 'drop-after');
});
document.addEventListener('drop', (e) => {
if (!state.edit || !dragSrcId) return;
const sec = e.target.closest('.panel.edit');
if (!sec) return;
e.preventDefault();
const targetId = sec.getAttribute('data-panel');
const insertAfter = sec.classList.contains('drop-after');
document.querySelectorAll('.drop-before, .drop-after').forEach((el) => el.classList.remove('drop-before', 'drop-after'));
if (!targetId || targetId === dragSrcId) return;
const dash = registry[state.route];
const view = dash.render({ data: {}, time: state.time });
mutate(state.route, view.panels, (ov) => {
const fullOrder = ov.order && ov.order.length ? ov.order.slice() : view.panels.map((p) => p.id);
// Make sure both src and target are in the order list (they should be).
const have = new Set(fullOrder);
if (!have.has(dragSrcId)) fullOrder.push(dragSrcId);
if (!have.has(targetId)) fullOrder.push(targetId);
const from = fullOrder.indexOf(dragSrcId);
fullOrder.splice(from, 1);
let to = fullOrder.indexOf(targetId);
if (insertAfter) to += 1;
fullOrder.splice(to, 0, dragSrcId);
ov.order = fullOrder;
});
render();
});
document.addEventListener('dragend', () => {
document.querySelectorAll('.dragging').forEach((el) => el.classList.remove('dragging'));
document.querySelectorAll('.drop-before, .drop-after').forEach((el) => el.classList.remove('drop-before', 'drop-after'));
dragSrcId = null;
});
// ---------- route changes ---------------------------------
window.addEventListener('hashchange', () => {
const parsed = parseRoute();
state.section = parsed.section;
state.route = parsed.route;
// A URL with query string (e.g. from a share link) should reapply.
const urlState = parseUrlState();
if (urlState.time) state.time = urlState.time;
if (urlState.cluster) state.cluster = urlState.cluster;
if (urlState.filters) {
state.filters[state.route] = { ...(state.filters[state.route] || {}), ...urlState.filters };
saveFilters(state.route);
}
writeUrlState();
// Route changes also re-ask the live-feature probes (cached ~30 s):
// with the auto-refresh interval off, this is what lets the nav
// catch up after a `xerj brain` run — e.g. when the user opens the
// deep link the CLI printed.
probeLiveFeatures();
render();
});
// Boot the refresh interval if the user had one saved.
if (state.refresh > 0) setRefreshInterval(state.refresh);
// Probe live-gated features once at boot (re-render happens inside on
// change, same pattern as the setOnChange hook below). Re-probes ride
// the refresh interval; the probe's per-baseUrl cache handles a
// backend/base-URL change without an explicit invalidation hook.
probeLiveFeatures();
// Restore mobile preview class if it was active.
if (state.mobile) document.documentElement.classList.add('mobile-preview');
// Re-render when the dashboard store reconciles (e.g. a 409 re-GET, or a
// late hydrate refresh) so the nav / panels reflect the durable set.
setOnChange(() => { if (!geomDrag) render(); });
// Re-render when a per-panel query settles — but never while the user is
// mid drag/resize or typing in the builder (that would nuke the gesture
// or steal input focus).
onPanelData(() => {
if (geomDrag) return;
const ae = document.activeElement;
if (ae && (ae.tagName === 'INPUT' || ae.tagName === 'SELECT' || ae.isContentEditable)) return;
render();
});
render();