@jagilber-org/index-server 1.19.1

package/dist/dashboard/client/js/admin.monitor.js

@@ -0,0 +1,181 @@
+/* eslint-disable */
+// Lightweight monitoring module extracted from admin.html
+(function(){
+    // Toggle synthetic traces wrapper visibility
+    function toggleSyntheticTraceVisibility(){
+        const wrap = document.getElementById('synthetic-traces-wrapper');
+        const chk = document.getElementById('synthetic-trace-toggle');
+        if(!wrap||!chk) return;
+        wrap.style.display = chk.checked ? 'block':'none';
+    }
+
+    // Run synthetic activity (keeps a faster monitoring poll while running)
+    async function runSyntheticActivity() {
+        const iter = parseInt(document.getElementById('synthetic-iterations').value, 10) || 10;
+        const conc = parseInt(document.getElementById('synthetic-concurrency').value, 10) || 2;
+        const wantTrace = document.getElementById('synthetic-trace-toggle')?.checked !== false; // default true
+        const btn = document.getElementById('synthetic-run-btn');
+        const output = document.getElementById('synthetic-output');
+        if(btn) { btn.disabled = true; btn.textContent = 'Running…'; }
+        if(output) output.textContent = 'Executing synthetic activity...';
+        const tracesBody = document.getElementById('synthetic-traces-body');
+        if(tracesBody) tracesBody.innerHTML = '';
+        // Accelerate monitoring poll during run
+        let previousInterval = window.monitoringInterval;
+        if (window.monitoringInterval) { clearInterval(window.monitoringInterval); window.monitoringInterval=null; }
+        window.monitoringInterval = setInterval(()=>{
+            if (document.getElementById('monitoring-section')?.classList.contains('hidden')) return;
+            loadMonitoringData();
+            updateActiveSyntheticRequests();
+        }, 1000); // fast poll while running
+        let statusTimer = setInterval(updateActiveSyntheticRequests, 1000);
+        try {
+            const url = '/api/admin/synthetic/activity?debug=1'+(wantTrace?'&trace=1&stream=1':'');
+            const res = await fetch(url, { method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify({ iterations: iter, concurrency: conc }) });
+            const rawText = await res.text();
+            let data = null; try { data = JSON.parse(rawText); } catch { /* ignore */ }
+            if (!res.ok || !data) {
+                throw new Error(data && (data.error || data.message) ? (data.error || data.message) : `HTTP ${res.status} (non-JSON)`);
+            }
+            if (!data.success) {
+                throw new Error(data.error || data.message || 'Unknown failure');
+            }
+            const metaLine = `Executed ${data.executed}/${data.iterationsRequested} (errors:${data.errors}) in ${data.durationMs}ms @c=${data.concurrency} tools:${data.availableCount}`;
+            if(output) output.textContent = metaLine + (data.available ? `\nSample: ${data.available.slice(0,5).join(', ')}` : '');
+            const lastMeta = document.getElementById('synthetic-last-meta');
+            if (lastMeta) lastMeta.textContent = `Last run: ${new Date().toLocaleTimeString()} ${metaLine}`;
+            if (wantTrace && tracesBody) {
+                if (Array.isArray(data.traces) && data.traces.length) {
+                    const rows = data.traces.map((t,i)=>{
+                        const clr = t.success ? '#0a0' : '#a00';
+                        const err = t.error ? String(t.error).slice(0,80) : '';
+                        const skipped = t.skipped ? ' (skipped)' : '';
+                        return `<tr>
+                            <td style="padding:2px 4px; border-bottom:1px solid #eee;">${i+1}</td>
+                            <td style="padding:2px 4px; border-bottom:1px solid #eee; font-family:monospace;">${t.method}${skipped}</td>
+                            <td style="padding:2px 4px; border-bottom:1px solid #eee; color:${clr};">${t.success?'✓':'✗'}</td>
+                            <td style="padding:2px 4px; border-bottom:1px solid #eee;">${t.durationMs}ms</td>
+                            <td style="padding:2px 4px; border-bottom:1px solid #eee; color:${t.error?'#b55':'#666'};">${err}</td>
+                        </tr>`;
+                    }).join('');
+                    tracesBody.innerHTML = rows;
+                } else {
+                    const reason = data.traceReason || 'no traces captured';
+                    tracesBody.innerHTML = `<tr><td colspan="5" style="padding:4px; font-style:italic;">${reason}</td></tr>`;
+                }
+                document.getElementById('synthetic-traces-wrapper').style.display = 'block';
+            }
+            // Refresh overview + monitoring for updated metrics
+            loadOverviewData();
+            loadMonitoringData();
+        } catch (err) {
+            const emsg = (err && err.message) || 'unknown error';
+            if(output) output.textContent = `Synthetic activity failed: ${emsg}`;
+            if (/No safe tools/i.test(emsg)) {
+                if(output) output.textContent += '\nHint: Ensure server started after tool handlers registered (import order)';
+            }
+        } finally {
+            if(btn) { btn.disabled = false; btn.textContent = 'Run Synthetic Activity'; }
+            // Restore slower poll cadence
+            if (window.monitoringInterval) { clearInterval(window.monitoringInterval); window.monitoringInterval=null; }
+            if (statusTimer) { clearInterval(statusTimer); statusTimer=null; }
+            if (!previousInterval) { // restart default if monitoring tab visible
+                ensureMonitoringPoll();
+            }
+            // One last status refresh to clear active counter
+            updateActiveSyntheticRequests();
+        }
+    }
+
+    // Fetch active synthetic request count and inject into monitoring panel if present
+    async function updateActiveSyntheticRequests(){
+        try {
+            const res = await fetch('/api/admin/synthetic/status');
+            const data = await res.json();
+            if (!data.success) return;
+            const active = data.activeRequests || 0;
+            // Find monitoring panel metric list and append/update a synthetic active row
+            const container = document.getElementById('monitoring-data');
+            if (container && container.innerHTML.includes('Throughput')) {
+                const id = 'active-synth-requests-row';
+                let el = document.getElementById(id);
+                if (!el) {
+                    const div = document.createElement('div');
+                    div.className='stat-row';
+                    div.id = id;
+                    div.innerHTML = '<span class="stat-label">Active Synthetic Requests</span><span class="stat-value">0</span>';
+                    container.insertBefore(div, container.firstChild.nextSibling); // after first row
+                    el = div;
+                }
+                const valSpan = el.querySelector('.stat-value');
+                if (valSpan) valSpan.textContent = String(active);
+            }
+        } catch { /* ignore */ }
+    }
+
+    // Monitoring data fetch
+    async function loadMonitoringData() {
+        try {
+            const [perfRes, sysRes, alertsRes] = await Promise.all([
+                fetch('/api/performance/detailed').catch(e=>e),
+                fetch('/api/system/health').catch(e=>e),
+                fetch('/api/alerts/active').catch(e=>e)
+            ]);
+            const [perfData, sysData, alertsData] = await Promise.all([
+                perfRes?.json ? perfRes.json().catch(()=>({})) : {},
+                sysRes?.json ? sysRes.json().catch(()=>({})) : {},
+                alertsRes?.json ? alertsRes.json().catch(()=>({})) : {}
+            ]);
+            const perf = perfData.data || {};
+            const sys = sysData.data || {};
+            const alerts = (alertsData.data || []).slice(0,5);
+                        const html = `
+                            <div class="metrics-list">
+                                <div class="metrics-row"><span class="label">Throughput (rpm)</span><span class="value">${perf.requestThroughput ?? '—'}</span></div>
+                                <div class="metrics-row"><span class="label">Avg Response</span><span class="value">${perf.averageResponseTime?.toFixed ? perf.averageResponseTime.toFixed(1)+'ms':'—'}</span></div>
+                                <div class="metrics-row"><span class="label">P95</span><span class="value">${perf.p95ResponseTime ?? '—'}ms</span></div>
+                                <div class="metrics-row"><span class="label">Error Rate</span><span class="value">${perf.errorRate?.toFixed ? perf.errorRate.toFixed(2)+'%':'—'}</span></div>
+                                <div class="metrics-row"><span class="label">Active Connections</span><span class="value">${perf.concurrentConnections ?? '—'}</span></div>
+                                <div class="metrics-row"><span class="label">System Health</span><span class="value">${sys.status || '—'}</span></div>
+                            </div>
+                            <div style="margin-top:12px; font-size:12px;">
+                                <div class="metrics-section-title">Active Alerts (${alerts.length})</div>
+                                <ul style="margin:4px 0 0 18px;">${alerts.map(a=>`<li>${a.type} (${a.severity}) - ${a.message}</li>`).join('') || '<li style="opacity:.7;">No active alerts</li>'}</ul>
+                            </div>`;
+            const el = document.getElementById('monitoring-data');
+            if (el) el.innerHTML = html;
+            // Update nav badge if sessions already loaded
+            if (typeof updateSessionsNavBadge === 'function') updateSessionsNavBadge();
+        } catch (e) {
+            const el = document.getElementById('monitoring-data');
+            if (el) el.innerHTML = '<div class="error">Failed to load monitoring data</div>';
+        }
+    }
+
+    // Periodic refresh when Monitoring tab visible
+    window.monitoringInterval = window.monitoringInterval || null;
+    function ensureMonitoringPoll(){
+        if (document.getElementById('monitoring-section')?.classList.contains('hidden')) return;
+        if (window.monitoringInterval) return; // already
+        window.monitoringInterval = setInterval(()=>{
+            if (document.getElementById('monitoring-section')?.classList.contains('hidden')) { clearInterval(window.monitoringInterval); window.monitoringInterval=null; return; }
+            loadMonitoringData();
+        }, 5000);
+    }
+
+    // Expose functions to global scope for compatibility with admin.html
+    window.toggleSyntheticTraceVisibility = toggleSyntheticTraceVisibility;
+    window.runSyntheticActivity = runSyntheticActivity;
+    window.updateActiveSyntheticRequests = updateActiveSyntheticRequests;
+    window.loadMonitoringData = loadMonitoringData;
+    window.ensureMonitoringPoll = ensureMonitoringPoll;
+
+    // Wire synthetic run button if present (some refactors removed inline onclick)
+    document.addEventListener('DOMContentLoaded', function(){
+        const btn = document.getElementById('synthetic-run-btn');
+        if(btn && !btn.__wired){
+            btn.addEventListener('click', function(ev){ ev.preventDefault(); runSyntheticActivity(); });
+            Object.defineProperty(btn,'__wired',{value:true});
+        }
+    });
+})();

package/dist/dashboard/client/js/admin.overview.js

@@ -0,0 +1,221 @@
+/* eslint-disable */
+// Extracted overview functions from admin.html
+(function(){
+    // rely on global helpers: formatUptime, formatBytes, showError
+    window.statsAvailable = false;
+
+    async function loadOverviewData(){
+        try {
+            const [statsRes, maintenanceRes, healthRes] = await Promise.allSettled([
+                fetch('/api/admin/stats'),
+                fetch('/api/admin/maintenance'),
+                fetch('/api/system/health')
+            ]);
+            const statsData = statsRes.status==='fulfilled' ? await statsRes.value.json().catch(()=> ({})) : {};
+            const maintenanceData = maintenanceRes.status==='fulfilled' ? await maintenanceRes.value.json().catch(()=> ({})) : {};
+            const healthData = healthRes.status==='fulfilled' ? await healthRes.value.json().catch(()=> ({})) : {};
+            if(statsData?.success && statsData.stats){
+                window.statsAvailable = true; displaySystemStats(statsData.stats);
+            } else {
+                window.statsAvailable = false; const statsEl = document.getElementById('system-stats'); if(statsEl) statsEl.innerHTML = '<div class="error-message">Stats unavailable</div>';
+            }
+            if(maintenanceData?.success && maintenanceData.maintenance && typeof displayMaintenanceInfo==='function'){
+                try { displayMaintenanceInfo(maintenanceData.maintenance); } catch(e){ console.warn('displayMaintenanceInfo failed:', e); }
+            }
+            if(healthData && (healthData.success || ['ok','healthy','degraded'].includes(healthData.status))){
+                displaySystemHealth(healthData.systemHealth || healthData.maintenance?.systemHealth || healthData);
+            }
+        } catch(err){
+            console.error('Error loading overview data:', err);
+            showError('Failed to load overview data');
+        }
+    }
+
+    function displaySystemStats(stats) {
+        try { window.lastSystemStats = stats; } catch(e) { /* ignore */ }
+        const html = `
+            <div class="stat-row">
+                <span class="stat-label">Uptime</span>
+                <span class="stat-value">${formatUptime(stats.uptime)}</span>
+            </div>
+            <div class="stat-row">
+                <span class="stat-label">Active Connections (WS)</span>
+                <span class="stat-value">${stats.activeConnections}</span>
+            </div>
+            <div class="stat-row">
+                <span class="stat-label">Admin Sessions</span>
+                <span class="stat-value">${stats.adminActiveSessions ?? '0'}</span>
+            </div>
+            <div class="stat-row">
+                <span class="stat-label">Total Requests</span>
+                <span class="stat-value">${stats.totalRequests.toLocaleString()}</span>
+            </div>
+            <div class="stat-row">
+                <span class="stat-label">Error Rate</span>
+                <span class="stat-value">${stats.errorRate.toFixed(2)}%</span>
+            </div>
+            <div class="stat-row">
+                <span class="stat-label">Avg Response Time</span>
+                <span class="stat-value">${stats.avgResponseTime.toFixed(1)}ms</span>
+            </div>
+            <hr style="opacity:.15;margin:6px 0;"/>
+            <div class="stat-row">
+                <span class="stat-label" style="opacity:.8">index Accepted</span>
+                <span class="stat-value">${stats.indexStats?.acceptedInstructions ?? stats.indexStats?.totalInstructions ?? '—'}</span>
+            </div>
+            <div class="stat-row" title="Physical *.json files discovered (raw). May exceed accepted due to validation skips">
+                <span class="stat-label" style="opacity:.8">index Files</span>
+                <span class="stat-value">${stats.indexStats?.rawFileCount ?? '—'}</span>
+            </div>
+            <div class="stat-row" title="Rejected/skipped after validation/normalization">
+                <span class="stat-label" style="opacity:.8">index Skipped</span>
+                <span class="stat-value">${stats.indexStats?.skippedInstructions ?? '—'}</span>
+            </div>
+            <div class="stat-row">
+                <span class="stat-label" style="opacity:.8">index Version</span>
+                <span class="stat-value">${stats.indexStats?.version ?? '—'}</span>
+            </div>
+            <div class="stat-row">
+                <span class="stat-label" style="opacity:.8">Schema Version</span>
+                <span class="stat-value">${stats.indexStats?.schemaVersion ?? 'unknown'}</span>
+            </div>
+            <div class="stat-row">
+                <span class="stat-label" style="opacity:.8">Last Updated</span>
+                <span class="stat-value">${stats.indexStats?.lastUpdated ? new Date(stats.indexStats.lastUpdated).toLocaleString() : 'N/A'}</span>
+            </div>
+        `;
+        const el = document.getElementById('system-stats'); if(el) el.innerHTML = html;
+
+        const perfParts = [];
+        perfParts.push(`
+            <div class="stat-row">
+                <span class="stat-label">Total Connections</span>
+                <span class="stat-value">${stats.totalConnections.toLocaleString()}</span>
+            </div>
+            <div class="stat-row">
+                <span class="stat-label">Error Rate</span>
+                <span class="stat-value">${stats.errorRate.toFixed(2)}%</span>
+            </div>
+            <div class="stat-row">
+                <span class="stat-label">Response Time</span>
+                <span class="stat-value">${stats.avgResponseTime.toFixed(1)}ms</span>
+            </div>`);
+        try {
+            if(window.__resourceTrendCache){
+                const t = window.__resourceTrendCache;
+                perfParts.push(`
+                    <div class="stat-row">
+                        <span class="stat-label">Window</span>
+                        <span class="stat-value">${t.windowSec}s (${t.sampleCount} samples)</span>
+                    </div>
+                    <div class="stat-row">
+                        <span class="stat-label">Memory Usage</span>
+                        <span class="stat-value">${formatBytes(stats.memoryUsage.heapUsed)} / ${formatBytes(stats.memoryUsage.heapLimit || stats.memoryUsage.heapTotal)}</span>
+                    </div>`);
+            }
+        } catch(e) { /* ignore */ }
+        const perfEl = document.getElementById('performance-stats'); if(perfEl) perfEl.innerHTML = perfParts.join('');
+
+        displayToolMetrics(stats);
+    }
+
+    function displayToolMetrics(stats) {
+        const toolMetricsEl = document.getElementById('tool-metrics');
+        if (!toolMetricsEl || !stats.toolMetrics) {
+            if (toolMetricsEl) toolMetricsEl.innerHTML = '<div class="error-message">Tool metrics unavailable</div>';
+            return;
+        }
+        const tools = Object.entries(stats.toolMetrics);
+        tools.sort(([,a], [,b]) => b.callCount - a.callCount);
+
+        let html = '<div class="tool-metrics-grid">';
+        tools.forEach(([toolName, metrics]) => {
+            const avgResponseTime = metrics.callCount > 0 ? (metrics.totalResponseTime / metrics.callCount).toFixed(1) : '0.0';
+            const successRate = metrics.callCount > 0 ? ((metrics.successCount / metrics.callCount) * 100).toFixed(1) : '100.0';
+            html += `
+                <div class="tool-metric-card">
+                    <div class="tool-name">${toolName}</div>
+                    <div class="tool-stats">
+                        <div class="stat-row">
+                            <span class="stat-label">Total Calls</span>
+                            <span class="stat-value">${metrics.callCount.toLocaleString()}</span>
+                        </div>
+                        <div class="stat-row">
+                            <span class="stat-label">Success Rate</span>
+                            <span class="stat-value ${parseFloat(successRate) < 95 ? 'warning' : ''}">${successRate}%</span>
+                        </div>
+                        <div class="stat-row">
+                            <span class="stat-label">Avg Response</span>
+                            <span class="stat-value">${avgResponseTime}ms</span>
+                        </div>
+                    </div>
+                </div>`;
+        });
+        html += '</div>';
+        toolMetricsEl.innerHTML = html;
+    }
+
+    // expose for other scripts and inline handlers
+    window.loadOverviewData = loadOverviewData;
+    window.displaySystemStats = displaySystemStats;
+    window.displayToolMetrics = displayToolMetrics;
+
+    // Usage Signals panel
+    async function loadUsageSignals() {
+        const panel = document.getElementById('usage-signals-panel');
+        if (!panel) return;
+        try {
+            const res = await fetch('/api/usage/snapshot');
+            if (!res.ok) throw new Error('http ' + res.status);
+            const data = await res.json();
+            const snap = data.snapshot || {};
+            const entries = Object.entries(snap).filter(function(e) { return e[1] && (e[1].lastSignal || e[1].usageCount); });
+            if (!entries.length) { panel.innerHTML = '<div style="opacity:.6;">No usage signals recorded yet.</div>'; return; }
+
+            // Summary counts
+            var signalCounts = {};
+            var totalUsage = 0;
+            var withSignal = 0;
+            entries.forEach(function(e) {
+                var rec = e[1];
+                totalUsage += rec.usageCount || 0;
+                if (rec.lastSignal) { withSignal++; signalCounts[rec.lastSignal] = (signalCounts[rec.lastSignal] || 0) + 1; }
+            });
+
+            var colors = { 'outdated': '#f2495c', 'not-relevant': '#ff9830', 'helpful': '#73bf69', 'applied': '#5794f2' };
+            var summaryHtml = '<div class="stat-row"><span class="stat-label">Instructions with Usage</span><span class="stat-value">' + entries.length + '</span></div>';
+            summaryHtml += '<div class="stat-row"><span class="stat-label">Total Usage Count</span><span class="stat-value">' + totalUsage + '</span></div>';
+            summaryHtml += '<div class="stat-row"><span class="stat-label">Instructions with Signals</span><span class="stat-value">' + withSignal + '</span></div>';
+            summaryHtml += '<hr style="opacity:.15;margin:6px 0;"/>';
+            Object.keys(signalCounts).sort().forEach(function(sig) {
+                var c = colors[sig] || '#888';
+                summaryHtml += '<div class="stat-row"><span class="stat-label"><span style="display:inline-block;width:8px;height:8px;border-radius:50%;background:' + c + ';margin-right:6px;"></span>' + sig + '</span><span class="stat-value">' + signalCounts[sig] + '</span></div>';
+            });
+
+            // Top 10 most signaled
+            var signaled = entries.filter(function(e) { return e[1].lastSignal; }).sort(function(a, b) { return (b[1].usageCount || 0) - (a[1].usageCount || 0); }).slice(0, 10);
+            if (signaled.length) {
+                summaryHtml += '<hr style="opacity:.15;margin:6px 0;"/>';
+                summaryHtml += '<div style="font-weight:600;font-size:11px;margin-bottom:4px;">Top Signaled Instructions</div>';
+                signaled.forEach(function(e) {
+                    var id = e[0]; var rec = e[1];
+                    var c = colors[rec.lastSignal] || '#888';
+                    var badge = '<span style="background:' + c + '22;color:' + c + ';border:1px solid ' + c + '44;padding:1px 6px;border-radius:3px;font-size:10px;font-weight:600;">' + rec.lastSignal + '</span>';
+                    var comment = rec.lastComment ? ' <span style="opacity:.5;font-size:10px;" title="' + (rec.lastComment || '').replace(/"/g, '&quot;').slice(0,200) + '">💬</span>' : '';
+                    summaryHtml += '<div style="display:flex;justify-content:space-between;align-items:center;padding:2px 0;font-size:11px;"><span style="overflow:hidden;text-overflow:ellipsis;white-space:nowrap;max-width:60%;" title="' + id + '">' + id + '</span><span>' + badge + ' <span style="opacity:.6;">(' + (rec.usageCount || 0) + ' uses)</span>' + comment + '</span></div>';
+                });
+            }
+
+            panel.innerHTML = '<div class="metrics-list">' + summaryHtml + '</div>';
+        } catch (e) {
+            panel.innerHTML = '<div class="error-message">Failed to load usage signals: ' + (e.message || e) + '</div>';
+        }
+    }
+
+    // Hook into overview load
+    var origLoadOverview = window.loadOverviewData;
+    window.loadOverviewData = async function() {
+        await Promise.all([origLoadOverview(), loadUsageSignals()]);
+    };
+    window.loadUsageSignals = loadUsageSignals;
+})();

package/dist/dashboard/client/js/admin.performance.js

@@ -0,0 +1,61 @@
+/* eslint-disable */
+// Extracted from admin.html: Resource Trend (CPU/Mem) helpers
+(function(){
+    (function initResourceTrendMerge(){
+        async function fetchResourceTrends(){
+            try {
+                const res = await fetch('/api/system/resources?limit=300');
+                if(!res.ok) throw new Error('http '+res.status);
+                const json = await res.json();
+                const samples = json?.data?.samples || [];
+                const trend = json?.data?.trend || { cpuSlope:0, memSlope:0 };
+                if(samples.length === 0){
+                    window.__resourceTrendCache = { windowSec:0, sampleCount:0, latestCpu:0, latestHeap:0, cpuSlope:0, memSlope:0, spark:'' };
+                    return;
+                }
+                const latest = samples[samples.length-1];
+                const first = samples[0];
+                const durationSec = ((latest.timestamp - first.timestamp)/1000).toFixed(0);
+                const tail = samples.slice(-40);
+                const spark = tail.map(s=>{
+                    const v = Math.min(100, Math.max(0, s.cpuPercent));
+                    const idx = Math.round(v/12.5);
+                    const blocks = ['▁','▂','▃','▄','▅','▆','▇','█'];
+                    return blocks[Math.min(blocks.length-1, idx)];
+                }).join('');
+                const minCpu = tail.reduce((m,s)=> s.cpuPercent<m? s.cpuPercent:m, tail[0].cpuPercent);
+                const maxCpu = tail.reduce((m,s)=> s.cpuPercent>m? s.cpuPercent:m, tail[0].cpuPercent);
+                const maxHeap = tail.reduce((m,s)=> s.heapUsed>m?s.heapUsed:m,0) || 1;
+                const minHeap = tail.reduce((m,s)=> s.heapUsed<m?s.heapUsed:m, tail[0].heapUsed);
+                const memSpark = tail.map(s=>{
+                    const ratio = Math.min(1, Math.max(0, s.heapUsed / maxHeap));
+                    const idx = Math.round(ratio*7);
+                    const blocks = ['▁','▂','▃','▄','▅','▆','▇','█'];
+                    return blocks[Math.min(blocks.length-1, idx)];
+                }).join('');
+                window.__resourceTrendCache = {
+                    windowSec: durationSec,
+                    sampleCount: samples.length,
+                    latestCpu: latest.cpuPercent,
+                    latestHeap: latest.heapUsed,
+                    minCpu,
+                    maxCpu,
+                    minHeap,
+                    maxHeap,
+                    cpuSlope: trend.cpuSlope || 0,
+                    memSlope: trend.memSlope || 0,
+                    spark,
+                    memSpark
+                };
+                try {
+                    if(typeof window.lastSystemStats === 'object') displaySystemStats(window.lastSystemStats);
+                    if(typeof window.lastSystemHealth === 'object') displaySystemHealth(window.lastSystemHealth);
+                } catch(e){/*ignore*/}
+            } catch(e){
+                // ignore failures
+            }
+        }
+        fetchResourceTrends();
+        setInterval(fetchResourceTrends, 10000);
+    })();
+})();