gina 0.3.6 → 0.3.7-alpha.2

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

@@ -100,6 +100,8 @@
     var CUSTOM_ORDER_KEY = '__gina_inspector_tab_layout_custom';
     /** @constant {string} localStorage key — hidden tabs in custom layout (JSON array of tab names) */
     var HIDDEN_TABS_KEY = '__gina_inspector_tab_layout_hidden';
+    /** @constant {string} localStorage key — Reveal toggle state for Data tab (#R7 reveal) */
+    var REVEAL_STORAGE_KEY = '__gina_inspector_reveal';
 
     /**
      * Tab order definitions for each layout preset.
@@ -150,6 +152,10 @@
     var logs    = [];
     /** @type {number} Read offset into `source.__ginaLogs` for client-side polling */
     var logsOff = 0;
+    /** @type {?Array} Last-seen `source.__ginaLogs` array reference — used to detect
+     *  opener navigation, which replaces the array with a fresh empty one. When the
+     *  reference changes, {@link logsOff} must be reset to 0. */
+    var _lastLogsRef = null;
     /** @type {boolean} When true, new log entries are not appended */
     var paused  = false;
     /** @type {string} JSON.stringify of last processed ginaData — for change detection */
@@ -164,6 +170,15 @@
     var autoExpand = false;
     /** @type {?number} Timeout ID for the coalesced log render timer */
     var _renderTimer = null;
+    /** @type {boolean} When true, the Data tab uses the unredacted snapshot fetched from `/_gina/reveal` (#R7 reveal) */
+    var _revealActive = false;
+    /** @type {?Object} Cached unredacted Inspector payload from `/_gina/reveal` (local scope only) */
+    var _revealedData = null;
+    /** @type {?EventSource} Passive `/_gina/agent` subscription used alongside opener
+     *  polling to receive pushed data/log frames from SPA (pushState/XHR) navigations
+     *  that do not rewrite `window.__ginaData`. Null when no opener is available
+     *  or when agent mode (`?target=`) is the primary source. */
+    var _passiveAgentEs = null;
 
     // ── Log row selection ──────────────────────────────────────────────────
     /** @type {Set<number>} IDs of currently selected log rows */
@@ -1666,8 +1681,12 @@
 
         captureFoldState(name);
 
-        var u = ginaData.user || {};
-        var g = ginaData.gina || {};
+        // #R7 reveal — when active, swap in the unredacted payload fetched from
+        // /_gina/reveal. Only Data/View/Forms/Query/Flow render from `u`/`g`,
+        // so a single source swap covers every visible field.
+        var src = (_revealActive && _revealedData) ? _revealedData : ginaData;
+        var u = src.user || {};
+        var g = src.gina || {};
         var content = '';
         var hasXhr = typeof u['data-xhr'] !== 'undefined';
 
@@ -1731,7 +1750,8 @@
      */
     function renderRaw(treeEl) {
         if (!ginaData) { treeEl.innerHTML = '<span class="bm-hint">No data to display</span>'; return; }
-        var u = ginaData.user || {};
+        var src = (_revealActive && _revealedData) ? _revealedData : ginaData;
+        var u = src.user || {};
         var data = u['data-xhr'] || u.data;
         treeEl.innerHTML = '<pre class="bm-raw-view">' + escHtml(JSON.stringify(data, null, 2)) + '</pre>';
     }
@@ -2866,6 +2886,108 @@
         captureFoldState('data');
     }
 
+    // ── Reveal toggle (Data tab only — local scope only) ──────────────────
+
+    /**
+     * Show or hide the Reveal button based on the current scope. The button is
+     * only available when the source bundle is running in `local` scope — the
+     * server-side endpoint enforces the same gate, this is just the UI mirror.
+     * Called after every data poll since scope can change when switching
+     * sources via the standalone Inspector `?target=` mode.
+     * @inner
+     */
+    function updateRevealVisibility() {
+        var btn = qs('#bm-reveal');
+        if (!btn) return;
+        var scope = (ginaData && ginaData.gina && ginaData.gina.environment)
+            ? ginaData.gina.environment.scope : null;
+        if (scope === 'local') {
+            btn.classList.remove('bm-hidden');
+        } else {
+            btn.classList.add('bm-hidden');
+            // If we previously revealed in local and the source flipped to a
+            // non-local scope, drop the cache and visual state immediately.
+            if (_revealActive) {
+                _revealActive = false;
+                _revealedData = null;
+                btn.classList.remove('active');
+                try { localStorage.removeItem(REVEAL_STORAGE_KEY); } catch (e) {}
+            }
+        }
+    }
+
+    /**
+     * Toggle the Data tab reveal state. When activated, fetches the unredacted
+     * payload from `/_gina/reveal` and re-renders the Data tab. The endpoint
+     * is scope-gated server-side — a 403 means the bundle is no longer in
+     * local scope and the toggle is forced off.
+     * @inner
+     */
+    function toggleReveal() {
+        var btn = qs('#bm-reveal');
+        if (!btn) return;
+        if (_revealActive) {
+            _revealActive = false;
+            _revealedData = null;
+            btn.classList.remove('active');
+            try { localStorage.removeItem(REVEAL_STORAGE_KEY); } catch (e) {}
+            renderTab('data');
+            return;
+        }
+        // Resolve the reveal URL. Three modes:
+        //   1. Standalone (`?target=<bundle_url>`) — route to the explicit target.
+        //   2. Opener (same-origin) — use the opener's pathname as the prefix so
+        //      the request routes to the bundle that rendered the current page.
+        //      Critical in proxy-routed multi-bundle setups where bare
+        //      `/_gina/reveal` hits the proxy's default bundle instead of the
+        //      one that produced the snapshot.
+        //   3. Fallback — strip `_gina/inspector` from the Inspector's own
+        //      pathname (same approach as tryServerLogs).
+        var base = '';
+        try {
+            var params = new URLSearchParams(window.location.search);
+            var target = (params.get('target') || '').replace(/\/+$/, '');
+            if (target) {
+                base = target;
+            } else if (window.opener && window.opener.location) {
+                base = (window.opener.location.pathname || '').replace(/\/+$/, '');
+            } else {
+                base = window.location.pathname.replace(/\/_gina\/inspector.*$/, '').replace(/\/+$/, '');
+            }
+        } catch (e) {
+            base = window.location.pathname.replace(/\/_gina\/inspector.*$/, '').replace(/\/+$/, '');
+        }
+        var url = base + '/_gina/reveal';
+        var xhr  = new XMLHttpRequest();
+        try {
+            xhr.open('GET', url, true);
+            xhr.onreadystatechange = function () {
+                if (xhr.readyState !== 4) return;
+                if (xhr.status === 200) {
+                    try {
+                        _revealedData = JSON.parse(xhr.responseText);
+                        _revealActive = true;
+                        btn.classList.add('active');
+                        try { localStorage.setItem(REVEAL_STORAGE_KEY, '1'); } catch (e) {}
+                        renderTab('data');
+                    } catch (e) {
+                        _revealedData = null;
+                        _revealActive = false;
+                        btn.classList.remove('active');
+                    }
+                } else if (xhr.status === 403) {
+                    // Scope flipped server-side — sync the UI.
+                    btn.classList.add('bm-hidden');
+                    btn.classList.remove('active');
+                    _revealActive = false;
+                    _revealedData = null;
+                    try { localStorage.removeItem(REVEAL_STORAGE_KEY); } catch (e) {}
+                }
+            };
+            xhr.send();
+        } catch (e) { /* network error — leave state untouched */ }
+    }
+
     // ── Download modal ────────────────────────────────────────────────────
 
     /**
@@ -2875,7 +2997,8 @@
      */
     function openDownloadModal() {
         if (!ginaData || !ginaData.user) return;
-        var u = ginaData.user;
+        var src = (_revealActive && _revealedData) ? _revealedData : ginaData;
+        var u = src.user || {};
         var dataObj = u['data-xhr'] || u.data;
         if (!dataObj || typeof dataObj !== 'object') return;
 
@@ -2902,7 +3025,8 @@
      */
     function doDownload() {
         if (!ginaData || !ginaData.user) return;
-        var u = ginaData.user;
+        var src = (_revealActive && _revealedData) ? _revealedData : ginaData;
+        var u = src.user || {};
         var dataObj = u['data-xhr'] || u.data;
         var checks = qsa('#bm-dl-checks input:checked');
         var result = {};
@@ -3080,6 +3204,7 @@
             }
             qs('#bm-no-source').classList.add('hidden');
             renderEnvironmentInfo();
+            updateRevealVisibility();
             var tab = activeTab();
             if (tab !== 'logs') renderTab(tab);
             // Always update query tab badge regardless of active tab
@@ -3214,7 +3339,16 @@
         try {
             if (source === 'localStorage' || !source) return;
             var src = source.__ginaLogs;
-            if (!src || !Array.isArray(src) || src.length <= logsOff) return;
+            if (!src || !Array.isArray(src)) return;
+            // Detect opener navigation: the new page installs a fresh __ginaLogs
+            // array, so the array identity differs from the one we last polled
+            // (or its length is smaller than our offset). Reset the offset so
+            // new entries on the new page are picked up.
+            if (src !== _lastLogsRef || src.length < logsOff) {
+                _lastLogsRef = src;
+                logsOff = 0;
+            }
+            if (src.length <= logsOff) return;
         } catch (e) { return; }
 
         var fresh = src.slice(logsOff);
@@ -3536,6 +3670,7 @@
                     document.title = 'Inspector — ' + (env.bundle || '?') + '@' + (env.env || '?');
                     qs('#bm-no-source').classList.add('hidden');
                     renderEnvironmentInfo();
+                    updateRevealVisibility();
                     var tab = activeTab();
                     if (tab !== 'logs') renderTab(tab);
                     if (tab !== 'query') {
@@ -3587,6 +3722,125 @@
         return true;
     }
 
+    // ── Passive /_gina/agent subscription (opener mode) ──────────────────
+
+    /**
+     * Open a parallel `/_gina/agent` SSE subscription alongside opener polling.
+     *
+     * Opener polling alone misses SPA (pushState) and XHR navigations because
+     * those paths do not rewrite `window.__ginaData` — only full HTML renders
+     * do. `render-json.js` however emits `process.emit('inspector#data', ...)`
+     * on every JSON render when `process.gina._inspectorActive` is true, and
+     * `/_gina/agent` forwards those emits as `event: data` SSE frames.
+     *
+     * This function subscribes to that same stream in the background while
+     * `source` stays set to the opener window. The data handler updates the
+     * Inspector UI but does NOT change `source`, so opener-driven behaviour
+     * (reveal URL derivation, pollData fallback, log polling) is unchanged.
+     *
+     * Server-side logs arrive on this stream too (`event: log`), so when
+     * passive mode succeeds `tryServerLogs()` is skipped to avoid duplicates.
+     *
+     * @inner
+     * @returns {boolean} `true` when a subscription was opened, `false` when
+     *   the environment is unsupported or the URL cannot be derived.
+     */
+    function tryAgentPassive() {
+        if (typeof EventSource === 'undefined') return false;
+        // Agent mode already covers data + logs via the primary tryAgent stream.
+        if (source === 'agent') return false;
+
+        // Derive the bundle URL the same way toggleReveal() does: prefer the
+        // opener's pathname so multi-bundle proxy setups route to the bundle
+        // that rendered the current page, falling back to stripping the
+        // inspector path.
+        var base = '';
+        try {
+            if (window.opener && window.opener.location) {
+                base = (window.opener.location.pathname || '').replace(/\/+$/, '');
+            } else {
+                base = window.location.pathname.replace(/\/_gina\/inspector.*$/, '').replace(/\/+$/, '');
+            }
+        } catch (e) {
+            base = window.location.pathname.replace(/\/_gina\/inspector.*$/, '').replace(/\/+$/, '');
+        }
+        var url = base + '/_gina/agent';
+
+        try {
+            var es = new EventSource(url);
+            _passiveAgentEs = es;
+
+            es.addEventListener('data', function (ev) {
+                try {
+                    var gd = JSON.parse(ev.data);
+                    if (!gd) return;
+                    var str = JSON.stringify(gd);
+                    if (str === lastGdStr) return;
+                    showLoader();
+                    lastGdStr = str;
+                    ginaData = gd;
+                    var env = (gd.user && gd.user.environment) || {};
+                    qs('#bm-label').textContent = (env.bundle || '?') + '@' + (env.env || '?');
+                    qs('#bm-dot').className = 'bm-dot ok';
+                    try {
+                        var _pageUrl = (window.opener && window.opener.location)
+                            ? window.opener.location.pathname + window.opener.location.search
+                            : null;
+                        document.title = _pageUrl
+                            ? 'Inspector — ' + _pageUrl
+                            : 'Inspector — ' + (env.bundle || '?') + '@' + (env.env || '?');
+                    } catch (e) {
+                        document.title = 'Inspector — ' + (env.bundle || '?') + '@' + (env.env || '?');
+                    }
+                    qs('#bm-no-source').classList.add('hidden');
+                    renderEnvironmentInfo();
+                    updateRevealVisibility();
+                    var tab = activeTab();
+                    if (tab !== 'logs') renderTab(tab);
+                    if (tab !== 'query') {
+                        var _u = gd.user || {};
+                        var _hasXhr = typeof _u['data-xhr'] !== 'undefined';
+                        var _qd = _hasXhr && _u['data-xhr'] && _u['data-xhr'].queries
+                            ? _u['data-xhr'].queries : _u.queries;
+                        updateQueryToolbar(_qd || null);
+                    }
+                    if (tab !== 'view') {
+                        var _u2 = gd.user || {};
+                        var _isXhr2 = typeof _u2['view-xhr'] !== 'undefined';
+                        var _vm = getPageMetrics(_isXhr2);
+                        var _dxhr = typeof _u2['data-xhr'] !== 'undefined';
+                        var _vq = _dxhr && _u2['data-xhr'] && _u2['data-xhr'].queries
+                            ? _u2['data-xhr'].queries : _u2.queries;
+                        updateViewDot(checkPerfAnomalies(_vm, _vq || []));
+                    }
+                    hideLoader();
+                } catch (e) {}
+            });
+
+            es.addEventListener('log', function (ev) {
+                if (paused) return;
+                try {
+                    var entry = JSON.parse(ev.data);
+                    entry._id = ++_logIdCounter;
+                    logs.push(entry);
+                    if (logs.length > MAX_LOG_ENTRIES) logs.shift();
+                    updateLogDot([entry]);
+                    scheduleRender();
+                } catch (e) {}
+            });
+
+            es.onerror = function () {
+                // EventSource reconnects automatically. Opener polling is the
+                // primary source here, so no UI state change is needed.
+            };
+        } catch (e) {
+            _passiveAgentEs = null;
+            return false;
+        }
+
+        return true;
+    }
+
     // ── Copy to clipboard ──────────────────────────────────────────────────
 
     /**
@@ -4117,6 +4371,23 @@
         }
         var dlBtn = qs('#bm-download');
         if (dlBtn) dlBtn.addEventListener('click', openDownloadModal);
+        var revealBtn = qs('#bm-reveal');
+        if (revealBtn) {
+            revealBtn.addEventListener('click', toggleReveal);
+            // Restore the previously-saved Reveal state on init: if it was on
+            // and the source is still local, fetch the unredacted snapshot.
+            try {
+                if (localStorage.getItem(REVEAL_STORAGE_KEY) === '1') {
+                    // Defer one tick so ginaData is populated by the first poll.
+                    setTimeout(function () {
+                        var scope = (ginaData && ginaData.gina && ginaData.gina.environment)
+                            ? ginaData.gina.environment.scope : null;
+                        if (scope === 'local') toggleReveal();
+                        else { try { localStorage.removeItem(REVEAL_STORAGE_KEY); } catch (e) {} }
+                    }, 250);
+                }
+            } catch (e) {}
+        }
         var dlCancel = qs('#bm-dl-cancel');
         if (dlCancel) dlCancel.addEventListener('click', function () { qs('#bm-dl-modal').classList.add('hidden'); });
         var dlConfirm = qs('#bm-dl-confirm');
@@ -4432,12 +4703,68 @@
         setupScrollToTop();
 
         // ── Refresh button — force immediate re-poll ────────────────────────
+        // Click        = soft refresh (data, live indexes, reveal snapshot,
+        //                passive agent stream).
+        // Shift+click  = also reload the inspected page via window.opener.
         var refreshBtn = qs('#bm-refresh');
         if (refreshBtn) {
-            refreshBtn.addEventListener('click', function () {
+            refreshBtn.addEventListener('click', function (ev) {
                 lastGdStr = '';
                 refreshBtn.classList.add('spinning');
                 pollData();
+
+                // Bypass the cache guard in fetchLiveIndexes().
+                _liveIndexes = null;
+                _liveIndexesFetching = false;
+                fetchLiveIndexes();
+
+                if (_revealActive) {
+                    var base = '';
+                    try {
+                        var params = new URLSearchParams(window.location.search);
+                        var target = (params.get('target') || '').replace(/\/+$/, '');
+                        if (target) {
+                            base = target;
+                        } else if (window.opener && window.opener.location) {
+                            base = (window.opener.location.pathname || '').replace(/\/+$/, '');
+                        } else {
+                            base = window.location.pathname.replace(/\/_gina\/inspector.*$/, '').replace(/\/+$/, '');
+                        }
+                    } catch (e) {
+                        base = window.location.pathname.replace(/\/_gina\/inspector.*$/, '').replace(/\/+$/, '');
+                    }
+                    try {
+                        var xhr = new XMLHttpRequest();
+                        xhr.open('GET', base + '/_gina/reveal', true);
+                        xhr.onreadystatechange = function () {
+                            if (xhr.readyState !== 4) return;
+                            if (xhr.status === 200) {
+                                try {
+                                    _revealedData = JSON.parse(xhr.responseText);
+                                    renderTab('data');
+                                } catch (e) {}
+                            }
+                        };
+                        xhr.send();
+                    } catch (e) {}
+                }
+
+                // Reopen the passive /_gina/agent stream if it has closed.
+                if (source !== 'agent'
+                    && (!_passiveAgentEs || _passiveAgentEs.readyState === 2)) {
+                    try { if (_passiveAgentEs) _passiveAgentEs.close(); } catch (e) {}
+                    _passiveAgentEs = null;
+                    tryAgentPassive();
+                }
+
+                if (ev.shiftKey) {
+                    try {
+                        if (window.opener && !window.opener.closed && window.opener.location) {
+                            window.opener.location.reload();
+                        }
+                    } catch (e) {}
+                }
+
                 refreshBtn.addEventListener('animationend', function onEnd() {
                     refreshBtn.classList.remove('spinning');
                     refreshBtn.removeEventListener('animationend', onEnd);
@@ -4490,7 +4817,13 @@
             }
 
             tryEngineIO();
-            tryServerLogs();
+            // Subscribe to /_gina/agent in parallel with opener polling. Opener
+            // polling alone misses SPA (pushState) and XHR renders because
+            // those paths never rewrite window.__ginaData. The passive agent
+            // stream delivers pushed data + log frames from those renders.
+            // It also supersedes tryServerLogs() (same `event: log` frames).
+            var _passiveAgentActive = tryAgentPassive();
+            if (!_passiveAgentActive) tryServerLogs();
         }
 
         // ── Persist window geometry on resize/move ──────────────────────────

package/framework/{v0.3.6 → v0.3.7-alpha.2}/core/config.js

@@ -810,7 +810,13 @@ function Config(opt, contextResetNeeded) {
                     // loading env if exists
                     if ( self.isCacheless() ) {
                         if (exists) {
-                            delete require.cache[require.resolve(_(filename, true))];
+                            try {
+                                delete require.cache[require.resolve(_(filename, true))];
+                            } catch (_cacheErr) {
+                                // requireJSON reads via fs.readFileSync and evicts its own cache.
+                                // Filesystem races (e.g. OrbStack bind mount) can make require.resolve()
+                                // throw EINVAL on readlink for freshly re-symlinked bundles dirs — non-fatal.
+                            }
                         }
                     }
                     // if (new RegExp('\.'+ env +'\.json$').test(fName)) {
@@ -839,7 +845,11 @@ function Config(opt, contextResetNeeded) {
                     try {
 
                         if (isCacheless && exists) {
-                            delete require.cache[require.resolve(_(filename, true))];
+                            try {
+                                delete require.cache[require.resolve(_(filename, true))];
+                            } catch (_cacheErr) {
+                                // See note above — EINVAL/ENOENT on require.resolve from symlink races is non-fatal.
+                            }
                         }
 
                         if (exists) {

package/framework/{v0.3.6 → v0.3.7-alpha.2}/core/controller/controller.js

@@ -53,7 +53,13 @@ var routingLib      = lib.routing;
 // removed: Domain import + domainLib instantiation — domainLib was never used in active code
 // (only usage at line 508 is commented out); re-instantiating Domain on every dev-mode request
 // via refreshCoreDependencies() caused [DOMAIN] PSL Loaded ×2 noise per request
-var swig            = require('@rhinostone/swig');
+// Swig is resolved through lib.swigResolver (process-cached on
+// process.gina._swig). Server.js's initSwigEngine() populates the cache
+// during bundle startup; controller.js is re-required on every request
+// in dev mode via refreshCoreDependencies(), so this getter sees the
+// already-loaded instance without re-running the resolver. Falls back to
+// require('@rhinostone/swig') when no bundle has loaded yet (tests, etc).
+var swig            = lib.swigResolver.get();
 const { type }      = require('node:os');
 var SwigFilters     = lib.SwigFilters;
 var statusCodes     = requireJSON( _( getPath('gina').core + '/status.codes') );
@@ -1037,12 +1043,38 @@ function SuperController(options) {
             if (_hints) self.setEarlyHints(_hints);
         }
 
+        // Dispatch to the render delegate matching the bundle's configured
+        // template engine. `settings.json > render.engine` defaults to "swig"
+        // so existing bundles see zero change; "nunjucks" routes through
+        // controller.render-nunjucks.js (MVP — see that file for the list of
+        // deferred features relative to render-swig). The render-nunjucks
+        // delegate fetches the nunjucks module itself via
+        // `lib.nunjucksResolver.get()`, so the `swig` / `SwigFilters` deps
+        // passed below are harmless when unused.
+        var _engine = 'swig';
+        try {
+            var _settings = local.options
+                && local.options.conf
+                && local.options.conf.content
+                && local.options.conf.content.settings;
+            if (_settings && _settings.render && _settings.render.engine) {
+                _engine = _settings.render.engine;
+            }
+        } catch (e) { /* fall back to default 'swig' */ }
+
+        var _delegate = (_engine === 'nunjucks')
+            ? '/controller.render-nunjucks'
+            : '/controller.render-swig';
+
         if  (this.isCacheless() ) {
             delete require.cache[require.resolve( _(__dirname + '/controller.render-v1', true))];
             delete require.cache[require.resolve( _(__dirname + '/controller.render-swig', true))];
+            try {
+                delete require.cache[require.resolve( _(__dirname + '/controller.render-nunjucks', true))];
+            } catch (e) { /* nunjucks delegate may not exist on older framework dirs */ }
         }
 
-        return require( _(__dirname + '/controller.render-swig', true) )(userData, displayInspector, errOptions, {
+        return require( _(__dirname + _delegate, true) )(userData, displayInspector, errOptions, {
             self        : self,
             local       : local,
             getData     : getData,
@@ -3196,30 +3228,64 @@ if ( /^local$/i.test(process.env.NODE_SCOPE) ) {
             client.setTimeout(0); // disable the default timeout to keep session active
 
             client.on('error', (error) => {
-                if (_pingInterval) { clearInterval(_pingInterval); _pingInterval = null; }
-                console.error( '`'+ options[':path']+ '` : '+ error.stack||error.message);
-                cache.delete(sessKey);
-                var _errIdx = self.serverInstance._http2Sessions.indexOf(sessKey);
-                if (_errIdx !== -1) self.serverInstance._http2Sessions.splice(_errIdx, 1);
-                _errIdx = null;
-                if (
-                    typeof(error.cause) != 'undefined' && typeof(error.cause.code) != 'undefined' && /ECONNREFUSED|ECONNRESET/.test(error.cause.code)
-                    || /ECONNREFUSED|ECONNRESET/.test(error.code)
-                ) {
-
-                    var port = getContext('gina').ports[options.protocol][options.scheme.replace(/\:/, '')][ options.port ];
-                    if ( typeof(port) != 'undefined' ) {
-                        error.accessPoint = port;
-                        error.message = 'Could not connect to [ ' + error.accessPoint + ' ].\nThe `'+port.split(/\@/)[0]+'` bundle is offline or unreachable.\n';
+                // #H9 — the whole listener body is wrapped in try/catch so that a throw
+                // from enhancement (undefined options.protocol/scheme), cache mutation,
+                // or self.throwError cannot escape an 'error' event and become an
+                // uncaughtException that crashes the bundle.
+                try {
+                    if (_pingInterval) { clearInterval(_pingInterval); _pingInterval = null; }
+                    try { console.error( '`'+ (options && options[':path']) +'` : '+ (error && (error.stack || error.message) || error)); } catch (_logErr) {}
+                    try {
+                        cache.delete(sessKey);
+                        var _errIdx = self.serverInstance._http2Sessions.indexOf(sessKey);
+                        if (_errIdx !== -1) self.serverInstance._http2Sessions.splice(_errIdx, 1);
+                        _errIdx = null;
+                    } catch (_cleanupErr) {
+                        console.error('[HTTP2] Session cleanup failed in error handler: ' + (_cleanupErr.stack || _cleanupErr.message));
                     }
+                    if (
+                        error && (
+                            (typeof(error.cause) != 'undefined' && typeof(error.cause.code) != 'undefined' && /ECONNREFUSED|ECONNRESET/.test(error.cause.code))
+                            || /ECONNREFUSED|ECONNRESET/.test(error.code)
+                        )
+                    ) {
+                        // #H9 — safe-navigate the port lookup; callers sometimes pass a bare
+                        // hostname so options.protocol/options.scheme are undefined and the
+                        // original `ports[undefined][undefined.replace(...)]` chain threw a
+                        // TypeError from inside this error listener.
+                        try {
+                            var _ginaCtx = (typeof getContext === 'function') ? getContext('gina') : null;
+                            var _portsMap = (_ginaCtx && _ginaCtx.ports && options && options.protocol)
+                                ? _ginaCtx.ports[options.protocol] : null;
+                            var _schemeKey = (options && options.scheme && typeof options.scheme.replace === 'function')
+                                ? options.scheme.replace(/\:/, '') : null;
+                            var _schemeMap = (_portsMap && _schemeKey) ? _portsMap[_schemeKey] : null;
+                            var port = (_schemeMap && options) ? _schemeMap[options.port] : undefined;
+                            if ( typeof(port) != 'undefined' && port !== null ) {
+                                error.accessPoint = port;
+                                var _bundleName = (typeof port === 'string') ? port.split(/\@/)[0] : String(port);
+                                error.message = 'Could not connect to [ ' + error.accessPoint + ' ].\nThe `'+ _bundleName +'` bundle is offline or unreachable.\n';
+                            }
+                        } catch (_enhErr) {
+                            console.error('[HTTP2] Error while enhancing connect-error message: ' + (_enhErr.stack || _enhErr.message));
+                        }
+                    }
+                    // local.req/res may be null when the error fires outside a request context
+                    // (background socket event) — log and return instead of crashing
+                    if (!local.req || !local.res) {
+                        console.error('[HTTP2] Session error outside request context — cannot send error response.\n' + (error && (error.stack || error.message) || error));
+                        return;
+                    }
+                    try {
+                        self.throwError(error);
+                    } catch (_throwErr) {
+                        console.error('[HTTP2] self.throwError failed in error handler: ' + (_throwErr.stack || _throwErr.message));
+                    }
+                } catch (_handlerErr) {
+                    // Last-resort swallow — throwing from an 'error' listener crashes the
+                    // process. Log and return so the session failure stays contained.
+                    try { console.error('[HTTP2] Uncaught failure inside error listener: ' + (_handlerErr.stack || _handlerErr.message)); } catch (_) {}
                 }
-                // local.req/res may be null when the error fires outside a request context
-                // (background socket event) — log and return instead of crashing
-                if (!local.req || !local.res) {
-                    console.error('[HTTP2] Session error outside request context — cannot send error response.\n' + (error.stack || error.message));
-                    return;
-                }
-                self.throwError(error);
                 return;
             });
 

package/framework/{v0.3.6 → v0.3.7-alpha.2}/core/controller/controller.render-json.js

@@ -278,14 +278,30 @@ module.exports = function renderJSON(jsonObj, deps) {
             // The resolved redact config is exposed under `gina.inspectorRedact`
             // so the standalone Inspector can mirror the same rules client-side.
             var _jsonRedactConf = inspectorRedact.getConfig(local.options.conf);
+            // #INS8 — expose the standalone Inspector URL (null when unset).
+            var _jsonInspUrl = null;
+            try {
+                var _jsonConfSource = local.options.conf || {};
+                if (_jsonConfSource.content && _jsonConfSource.content.settings
+                    && _jsonConfSource.content.settings.inspector
+                    && _jsonConfSource.content.settings.inspector.url) {
+                    _jsonInspUrl = _jsonConfSource.content.settings.inspector.url;
+                }
+            } catch (e) { /* leave null */ }
             var __gdPayload = {
                 gina : { environment: _env, inspectorRedact: {
                     patterns    : _jsonRedactConf.patterns,
                     types       : _jsonRedactConf.types,
                     replacement : _jsonRedactConf.replacement
-                }},
+                }, inspectorUrl: _jsonInspUrl },
                 user : _gdUser
             };
+            // #R7 — JSON renders do NOT write _lastGinaDataUnredacted. The
+            // Reveal UX unmasks the Data tab, which always shows the HTML
+            // render payload (sourced from window.opener.__ginaData). JSON
+            // polling endpoints would otherwise clobber the HTML snapshot
+            // with tiny session/ping payloads between page load and click.
+            // Only render-swig.js writes the unredacted slot.
             __gdPayload = inspectorRedact.redact(__gdPayload, {
                 compiledPatterns : _jsonRedactConf.compiledPatterns,
                 replacement      : _jsonRedactConf.replacement