Skip to content

armgit / xerj

Public Imported from GitHub
0

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.

86.4 KB
Raw Blame
// ============================================================
// 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();