gina 0.3.16-alpha.2 → 0.4.0

package/framework/{v0.3.16-alpha.2 → v0.4.0}/core/asset/plugin/dist/vendor/gina/inspector/inspector.js

@@ -675,32 +675,40 @@
     // ── Engine badge ──────────────────────────────────────────────────────
 
     /**
-     * Detect the template engine name from view data.
-     * Inspects `view.layout` path and `view.ext` to distinguish between
-     * template engines. Does NOT use `env.engine` (that is the HTTP server
-     * engine — isaac/express — not the template engine).
+     * Detect the template engine and version from server-emitted environment
+     * data, with a heuristic fallback from view layout/ext when the field is
+     * absent (legacy renders, test stubs, render-v1.js path).
+     *
+     * Does NOT use `env.engine` — that is the HTTP server engine (isaac/express),
+     * not the template engine.
+     *
      * @inner
-     * @param {Object} view - View data from `__ginaData.user.view`
-     * @param {Object} env - Environment data from `__ginaData.user.environment`
-     * @returns {string} Template engine name (e.g. `'Swig'`, `'Nunjucks'`)
+     * @param   {Object} view - View data from `__ginaData.user.view`
+     * @param   {Object} env  - Environment data from `__ginaData.user.environment`
+     * @returns {{name: (string|null), version: (string|null)}}
      */
     function detectEngine(view, env) {
-        // Detect the TEMPLATE engine, not the HTTP engine.
-        // env.engine is the HTTP server engine (isaac/express) — do not use it here.
-        // The template engine is determined by the view layout path or file extension.
+        // Server-emitted field wins — render-swig.js / render-nunjucks.js
+        // populate env.templateEngine = { name, version } from the resolver
+        // decision cache.
+        if (env && env.templateEngine && typeof env.templateEngine === 'object') {
+            return {
+                name:    env.templateEngine.name || null,
+                version: env.templateEngine.version || null
+            };
+        }
 
-        // Try to detect from view.layout path (e.g. "swig/html/default")
+        // Fallback heuristic — view.layout path then view.ext.
+        var name = null;
         if (view && typeof view.layout === 'string') {
-            if (/swig[\/\\]/i.test(view.layout)) return 'Swig';
-            if (/nunjucks[\/\\]|njk[\/\\]/i.test(view.layout)) return 'Nunjucks';
+            if (/swig[\/\\]/i.test(view.layout)) name = 'Swig';
+            else if (/nunjucks[\/\\]|njk[\/\\]/i.test(view.layout)) name = 'Nunjucks';
         }
-        // Try from view.ext
-        if (view && typeof view.ext === 'string') {
-            if (view.ext === '.njk') return 'Nunjucks';
-            if (view.ext === '.html') return 'Swig';
+        if (!name && view && typeof view.ext === 'string') {
+            if (view.ext === '.njk') name = 'Nunjucks';
+            else if (view.ext === '.html') name = 'Swig';
         }
-        // Default: render-swig.js handles all current rendering
-        return 'Swig';
+        return { name: name || 'Swig', version: null };
     }
 
     // ── Page metrics (weight, load time, paint time) ───────────────────────
@@ -732,7 +740,22 @@
      * @returns {PageMetrics} Metrics object (all numeric fields may be `null`)
      */
     function getPageMetrics(isXhr) {
-        var m = { weight: null, resourceSize: null, loadMs: null, transferMs: null, fcpMs: null, source: 'page' };
+        var m = {
+            weight: null, resourceSize: null, loadMs: null, transferMs: null, fcpMs: null, source: 'page',
+            // Server-emitted fallback values (populated below from env.metrics).
+            // These survive the COOP/no-opener case where window.opener is null
+            // and the Performance API path returns the all-null skeleton.
+            serverWeight: null, serverLoadMs: null
+        };
+        // Read server-side metrics from the env payload first — independent of
+        // whether the opener is reachable.
+        try {
+            var _envMetrics = (ginaData && ginaData.user && ginaData.user.environment && ginaData.user.environment.metrics) || null;
+            if (_envMetrics) {
+                if (typeof _envMetrics.weightBytes === 'number') m.serverWeight = _envMetrics.weightBytes;
+                if (typeof _envMetrics.serverMs    === 'number') m.serverLoadMs = _envMetrics.serverMs;
+            }
+        } catch (e) { /* defensive — leave server values null */ }
         try {
             var win = (source && source !== 'localStorage') ? source : null;
             if (!win || !win.performance) return m;
@@ -964,12 +987,20 @@
         var keys = Object.keys(view);
         keys.sort();
 
-        // Empty state — no view data and no page metrics (JSON-only API)
+        // Empty state — no view data and no page metrics (JSON-only API).
+        // Server-side metrics survive the COOP/no-opener case, so the
+        // empty-state guard must also consider env.metrics; otherwise the
+        // View tab would falsely render "No views attached" when only the
+        // server-side fallback values are populated.
         var _emptyMetrics = true;
         try {
             if (source && source !== 'localStorage' && source.performance) {
                 _emptyMetrics = false;
             }
+            var _emSrvMet = (ginaData && ginaData.user && ginaData.user.environment && ginaData.user.environment.metrics) || null;
+            if (_emSrvMet && (typeof _emSrvMet.weightBytes === 'number' || typeof _emSrvMet.serverMs === 'number')) {
+                _emptyMetrics = false;
+            }
         } catch (e) {}
         if (keys.length === 0 && _emptyMetrics) {
             return '<div class="bm-tab-empty">'
@@ -1019,7 +1050,9 @@
 
         // Engine + metrics badges (floating right row)
         var env = (ginaData && ginaData.user && ginaData.user.environment) || {};
-        var engine = detectEngine(view, env);
+        var engineInfo    = detectEngine(view, env);
+        var engine        = engineInfo.name;
+        var engineVersion = engineInfo.version;
         var u = ginaData && ginaData.user ? ginaData.user : {};
         var isXhr = typeof u['view-xhr'] !== 'undefined';
         var metrics = getPageMetrics(isXhr);
@@ -1030,58 +1063,96 @@
         var _anomMap = {};
         for (var _ai = 0; _ai < _anomalies.length; _ai++) _anomMap[_anomalies[_ai].metric] = _anomalies[_ai];
         updateViewDot(_anomalies);
-        var hasBadges = engine || metrics.weight || metrics.loadMs || metrics.transferMs || metrics.fcpMs;
+        var hasBadges = engine
+            || metrics.weight  || metrics.serverWeight
+            || metrics.loadMs  || metrics.transferMs || metrics.serverLoadMs
+            || metrics.fcpMs;
         if (hasBadges) {
             h += '<div class="bm-view-badges">';
             if (engine) {
-                h += '<span class="bm-vbadge bm-vbadge-engine" title="Template engine">'
+                var _engineTitle = 'Template engine'
+                    + (engineVersion ? ': ' + engine + ' ' + engineVersion : '');
+                h += '<span class="bm-vbadge bm-vbadge-engine" title="' + escHtml(_engineTitle) + '">'
                     + '<svg viewBox="0 0 16 16"><path d="M5.854 4.854a.5.5 0 10-.708-.708l-3.5 3.5a.5.5 0 000 .708l3.5 3.5a.5.5 0 00.708-.708L2.707 8l3.147-3.146zm4.292 0a.5.5 0 01.708-.708l3.5 3.5a.5.5 0 010 .708l-3.5 3.5a.5.5 0 01-.708-.708L13.293 8l-3.147-3.146z"/></svg>'
-                    + escHtml(engine) + '</span>';
+                    + escHtml(engine);
+                if (engineVersion) {
+                    h += '<span class="bm-vbadge-sep">|</span>'
+                        + '<span class="bm-vbadge-ver">' + escHtml(engineVersion) + '</span>';
+                }
+                h += '</span>';
             }
-            if (metrics.weight) {
-                var _res = metrics.resourceSize;
-                var _xfr = metrics.weight;
-                var _showDual = _res && _res !== _xfr;
-                var weightTitle = _showDual
-                    ? 'Resource: ' + formatBytes(_res) + ' | Transfer: ' + formatBytes(_xfr)
-                    : (isXhr ? 'XHR response transfer size' : 'Page transfer size (document)');
-                var _aw = _anomMap['weight'];
-                h += '<span class="bm-vbadge bm-vbadge-weight' + (_aw ? ' bm-perf-' + _aw.level : '') + '" title="' + weightTitle + (_aw ? '\n\u26a0 ' + _aw.label : '') + '">'
-                    + '<svg viewBox="0 0 16 16"><path d="M3.5 1h9l2.5 14H1zM4.8 2.5h6.4l2 11H2.8z"/></svg>';
-                if (_showDual) {
-                    var _rp = splitBytes(_res), _xp = splitBytes(_xfr);
+            // Weight badge \u2014 dual rendering rules:
+            //   1. server + client \u2192 server dimmed | client primary (most informative)
+            //   2. client only with differing resourceSize \u2192 resource | transfer (legacy)
+            //   3. server only \u2192 server primary (COOP / no-opener fallback)
+            //   4. client only (no resource diff) \u2192 transfer single
+            if (metrics.weight || metrics.serverWeight) {
+                var _clientW = metrics.weight;
+                var _serverW = metrics.serverWeight;
+                var _res     = metrics.resourceSize;
+                var _aw      = _anomMap['weight'];
+                var _wtTitle, _wtBody;
+                if (_clientW && _serverW) {
+                    _wtTitle = 'Server: ' + formatBytes(_serverW) + ' (response body) | Client: ' + formatBytes(_clientW) + ' (browser transferSize)';
+                    _wtBody  = '<span class="bm-vbadge-svr">' + formatBytes(_serverW) + '</span>'
+                             + '<span class="bm-vbadge-sep">|</span>'
+                             + formatBytes(_clientW);
+                } else if (_clientW && _res && _res !== _clientW) {
+                    _wtTitle = 'Resource: ' + formatBytes(_res) + ' | Transfer: ' + formatBytes(_clientW);
+                    var _rp = splitBytes(_res), _xp = splitBytes(_clientW);
                     if (_rp.unit === _xp.unit) {
-                        h += '<span class="bm-vbadge-res">' + _rp.num + '</span>'
-                            + '<span class="bm-vbadge-sep">|</span>'
-                            + _xp.num + _xp.unit;
+                        _wtBody = '<span class="bm-vbadge-res">' + _rp.num + '</span>'
+                                + '<span class="bm-vbadge-sep">|</span>'
+                                + _xp.num + _xp.unit;
                     } else {
-                        h += '<span class="bm-vbadge-res">' + formatBytes(_res) + '</span>'
-                            + '<span class="bm-vbadge-sep">|</span>'
-                            + formatBytes(_xfr);
+                        _wtBody = '<span class="bm-vbadge-res">' + formatBytes(_res) + '</span>'
+                                + '<span class="bm-vbadge-sep">|</span>'
+                                + formatBytes(_clientW);
                     }
+                } else if (_clientW) {
+                    _wtTitle = isXhr ? 'XHR response transfer size' : 'Page transfer size (document)';
+                    _wtBody  = formatBytes(_clientW);
                 } else {
-                    h += formatBytes(_xfr);
+                    _wtTitle = 'Server response body size (client transferSize unavailable \u2014 window.opener.performance is null, e.g. under Cross-Origin-Opener-Policy)';
+                    _wtBody  = formatBytes(_serverW);
                 }
-                h += '</span>';
+                h += '<span class="bm-vbadge bm-vbadge-weight' + (_aw ? ' bm-perf-' + _aw.level : '') + '" title="' + _wtTitle + (_aw ? '\n\u26a0 ' + _aw.label : '') + '">'
+                    + '<svg viewBox="0 0 16 16"><path d="M3.5 1h9l2.5 14H1zM4.8 2.5h6.4l2 11H2.8z"/></svg>'
+                    + _wtBody
+                    + '</span>';
             }
-            if (metrics.loadMs || metrics.transferMs) {
-                var _ld = metrics.loadMs;
-                var _tf = metrics.transferMs;
-                var _showDualTime = _ld && _tf && _ld !== _tf;
-                var timeTitle = _showDualTime
-                    ? 'Load: ' + fmtMs(_ld) + ' | Transfer: ' + fmtMs(_tf)
-                    : (isXhr ? 'XHR round-trip duration' : (_ld ? 'Page load time' : 'Document transfer time (requestStart \u2192 responseEnd)'));
-                var _al = _anomMap['load'];
-                h += '<span class="bm-vbadge bm-vbadge-load' + (_al ? ' bm-perf-' + _al.level : '') + '" title="' + timeTitle + (_al ? '\n\u26a0 ' + _al.label : '') + '">'
-                    + '<svg viewBox="0 0 16 16"><path d="M8 3.5a.5.5 0 00-1 0V8a.5.5 0 00.252.434l3.5 2a.5.5 0 00.496-.868L8 7.71V3.5z"/><path d="M8 16A8 8 0 108 0a8 8 0 000 16zm7-8A7 7 0 111 8a7 7 0 0114 0z"/></svg>';
-                if (_showDualTime) {
-                    h += '<span class="bm-vbadge-res">' + fmtMs(_ld) + '</span>'
-                        + '<span class="bm-vbadge-sep">|</span>'
-                        + fmtMs(_tf);
+            // Load badge \u2014 same four-way rules, applied to load time:
+            //   1. server + client load \u2192 server dimmed | client primary
+            //   2. client load + differing transfer time \u2192 load | transfer (legacy)
+            //   3. server only \u2192 server primary (COOP / no-opener fallback)
+            //   4. client only \u2192 load OR transfer single
+            if (metrics.loadMs || metrics.transferMs || metrics.serverLoadMs) {
+                var _ld     = metrics.loadMs;
+                var _tf     = metrics.transferMs;
+                var _srvLd  = metrics.serverLoadMs;
+                var _al     = _anomMap['load'];
+                var _ltTitle, _ltBody;
+                if (_ld && _srvLd) {
+                    _ltTitle = 'Server: ' + fmtMs(_srvLd) + ' (backend processing) | Client: ' + fmtMs(_ld) + ' (full page load: network + parse + paint)';
+                    _ltBody  = '<span class="bm-vbadge-svr">' + fmtMs(_srvLd) + '</span>'
+                             + '<span class="bm-vbadge-sep">|</span>'
+                             + fmtMs(_ld);
+                } else if (_ld && _tf && _ld !== _tf) {
+                    _ltTitle = 'Load: ' + fmtMs(_ld) + ' | Transfer: ' + fmtMs(_tf);
+                    _ltBody  = '<span class="bm-vbadge-res">' + fmtMs(_ld) + '</span>'
+                             + '<span class="bm-vbadge-sep">|</span>'
+                             + fmtMs(_tf);
+                } else if (_ld || _tf) {
+                    _ltTitle = isXhr ? 'XHR round-trip duration' : (_ld ? 'Page load time' : 'Document transfer time (requestStart \u2192 responseEnd)');
+                    _ltBody  = fmtMs(_ld || _tf);
                 } else {
-                    h += fmtMs(_ld || _tf);
+                    _ltTitle = 'Server processing time (client load time unavailable \u2014 window.opener.performance is null, e.g. under Cross-Origin-Opener-Policy)';
+                    _ltBody  = fmtMs(_srvLd);
                 }
-                h += '</span>';
+                h += '<span class="bm-vbadge bm-vbadge-load' + (_al ? ' bm-perf-' + _al.level : '') + '" title="' + _ltTitle + (_al ? '\n\u26a0 ' + _al.label : '') + '">'
+                    + '<svg viewBox="0 0 16 16"><path d="M8 3.5a.5.5 0 00-1 0V8a.5.5 0 00.252.434l3.5 2a.5.5 0 00.496-.868L8 7.71V3.5z"/><path d="M8 16A8 8 0 108 0a8 8 0 000 16zm7-8A7 7 0 111 8a7 7 0 0114 0z"/></svg>'
+                    + _ltBody
+                    + '</span>';
             }
             if (metrics.fcpMs) {
                 var _af = _anomMap['fcp'];
@@ -1836,9 +1907,15 @@
      * Looks up the connector:database key in _liveIndexes, then resolves by
      * extracting the target table from the statement.
      *
+     * #QI Phase C.3 — descriptors are CLONED and stamped with a per-query
+     * `covers` flag (leftmost-prefix vs `q.whereColumns`), mirroring the
+     * server-side sql-parser annotateCoverage so the live (no indexes.sql) path
+     * renders the same bm-idx-uncovered badge as the declared-index path. The
+     * shared _liveIndexes cache is never mutated.
+     *
      * @inner
      * @param {object} q - Query entry with `q.indexes === null`
-     * @returns {?Array<{name: string, primary: boolean}>} Resolved indexes, or null
+     * @returns {?Array<{name: string, primary: boolean, columns: Array<string>, covers: boolean}>} Resolved indexes (cloned), [] when the table has none, or null when unresolvable
      */
     function resolveLiveIndexes(q) {
         if (!_liveIndexes || !_liveIndexes.connectors) return null;
@@ -1857,7 +1934,24 @@
         // Use the table field if available; otherwise extract from statement
         var tbl = q.table || extractTableFromStatement(q.statement);
         if (!tbl) return null;
-        return tables[tbl] || [];
+        var live = tables[tbl];
+        if (!live) return [];
+        // Clone each descriptor (never mutate the shared cache — two queries on the
+        // same table may filter different columns) and stamp `covers` via the
+        // leftmost-prefix rule: an index serves the filter only if its FIRST column
+        // is among the query's WHERE columns. Same logic as sql-parser annotateCoverage.
+        var wc  = q.whereColumns || [];
+        var out = [];
+        for (var i = 0; i < live.length; i++) {
+            var cols = live[i].columns || [];
+            out.push({
+                name    : live[i].name,
+                primary : !!live[i].primary,
+                columns : cols.slice(),
+                covers  : (cols.length > 0 && wc.length > 0 && wc.indexOf(cols[0]) > -1)
+            });
+        }
+        return out;
     }
 
     /**
@@ -2321,15 +2415,34 @@
                         indexHtml = '<span class="bm-query-idx bm-idx-none" title="No index used — full bucket scan">'
                             + _svgIdxWarn + ' no index</span>';
                     } else {
-                        for (var ix = 0; ix < q.indexes.length; ix++) {
-                            var idx = q.indexes[ix];
-                            var idxCls = idx.primary ? 'bm-idx-primary' : 'bm-idx-secondary';
-                            var idxTip = (idx.primary ? 'Primary index scan (consider adding a secondary index)' : 'Secondary index')
-                                + ' — click to copy';
-                            indexHtml += '<span class="bm-query-idx bm-idx-copy ' + idxCls + '" title="' + idxTip
-                                + '" data-idx-name="' + escHtml(idx.name) + '">'
-                                + (idx.primary ? _svgIdxWarn : _svgIdx) + ' '
-                                + escHtml(idx.name) + '</span>';
+                        // #QI Phase C — the table has indexes; if none lead with a
+                        // filtered column (leftmost-prefix), this query's filter
+                        // cannot use them — surface that gap rather than implying
+                        // coverage. covers/whereColumns are heuristic (declared
+                        // indexes vs WHERE columns), not a planner verdict.
+                        var _hasWhere  = q.whereColumns && q.whereColumns.length > 0;
+                        var _anyCovers = false;
+                        if (_hasWhere) {
+                            for (var _ci = 0; _ci < q.indexes.length; _ci++) {
+                                if (q.indexes[_ci].covers) { _anyCovers = true; break; }
+                            }
+                        }
+                        if (_hasWhere && !_anyCovers) {
+                            var _wc = q.whereColumns.join(', ');
+                            indexHtml = '<span class="bm-query-idx bm-idx-uncovered" title="Indexes exist on this table, but none lead with a filtered column ('
+                                + escHtml(_wc) + ') — this query cannot use them. Add an index starting with one of these columns.">'
+                                + _svgIdxWarn + ' no index for filter</span>';
+                        } else {
+                            for (var ix = 0; ix < q.indexes.length; ix++) {
+                                var idx = q.indexes[ix];
+                                var idxCls = idx.primary ? 'bm-idx-primary' : 'bm-idx-secondary';
+                                var idxTip = (idx.primary ? 'Primary index scan (consider adding a secondary index)' : 'Secondary index')
+                                    + ' — click to copy';
+                                indexHtml += '<span class="bm-query-idx bm-idx-copy ' + idxCls + '" title="' + idxTip
+                                    + '" data-idx-name="' + escHtml(idx.name) + '">'
+                                    + (idx.primary ? _svgIdxWarn : _svgIdx) + ' '
+                                    + escHtml(idx.name) + '</span>';
+                            }
                         }
                     }
                 } else if (q.connector) {
@@ -3648,6 +3761,15 @@
         target = target.replace(/\/+$/, '');
         var url = target + '/_gina/agent';
 
+        // #INS9b — when the target bundle's agent endpoint is auth-gated
+        // (settings.json inspector.agent.enabled outside dev mode), pass the key
+        // via ?key=. EventSource cannot set request headers, so the browser path
+        // is the query param. Optional — omitted when no key was supplied.
+        var agentKey = params.get('key');
+        if (agentKey) {
+            url += '?key=' + encodeURIComponent(agentKey);
+        }
+
         source = 'agent';
         qs('#bm-dot').className = 'bm-dot warn';
         qs('#bm-label').textContent = 'Connecting\u2026';
@@ -4812,6 +4934,14 @@
                     raw = raw.replace(/\/+$/, '');
                     // Navigate with ?target= to activate agent mode
                     var loc = window.location.pathname + '?target=' + encodeURIComponent(raw);
+                    // #INS9b — append the optional inspector key (?key=) for an
+                    // auth-gated agent endpoint. Kept in the URL only (ephemeral);
+                    // never persisted to localStorage.
+                    var keyInput = qs('#bm-connect-key');
+                    var keyRaw = keyInput ? (keyInput.value || '').trim() : '';
+                    if (keyRaw) {
+                        loc += '&key=' + encodeURIComponent(keyRaw);
+                    }
                     window.location.href = loc;
                 });
             }