gina 0.6.2 → 0.6.3

package/framework/{v0.6.2 → v0.6.3}/core/asset/plugin/dist/vendor/gina/inspector/inspector.js

@@ -62,6 +62,14 @@
     // ── Constants ──────────────────────────────────────────────────────────
     /** @type {number} Data poll interval in ms — adjustable via Settings panel */
     var pollDataMs  = 2000;
+    /** @constant {number} Liveness-handshake window in ms for an ADOPTED bound
+     *  channel (#B231): after `_adoptAdvertisedChannel()` binds the
+     *  statusbar-advertised tab channel (which posts `{type:'request'}` on bind),
+     *  a `{type:'data'}` reply must land within this window — a stale advert
+     *  (its tab closed; localStorage outlives tabs) would otherwise strand the
+     *  window on a silent channel. On expiry the adopt path tears down and hands
+     *  over to the legacy bundle-global acquisition. */
+    var ADOPT_HANDSHAKE_MS = 1500;
     /** @constant {number} Log poll interval in ms */
     var POLL_LOGS_MS = 1000;
     /** @constant {number} Maximum retained log entries before oldest are dropped */
@@ -199,6 +207,20 @@
      *  rendered before a bundle restart) cannot override live data. Null in pure
      *  opener/localStorage mode, which leaves the guard inert. */
     var _livePid = null;
+    /** @type {?string} Normalised webroot of the bundle that established {@link _livePid}
+     *  (recorded by {@link _noteLivePid}). Lets {@link _isStaleSource} tell a stale
+     *  same-bundle snapshot (same webroot, older pid) from a payload of a DIFFERENT
+     *  bundle of a proxy-routed multi-bundle project (different webroot — the monitored
+     *  tab legitimately crossed a bundle boundary, not staleness). Null until known. (#B205) */
+    var _livePidWebroot = null;
+    /** @type {?EventSource} Live `/_gina/logs` SSE stream — kept module-level so
+     *  {@link _followBundleChannels} can close and re-open it against another bundle's
+     *  base when the monitored tab navigates across bundles. (#B205) */
+    var _serverLogsEs = null;
+    /** @type {?string} Normalised base path the server-side channels (`/_gina/logs` and
+     *  the passive `/_gina/agent` stream) are currently pointed at. Compared against each
+     *  applied payload's webroot by {@link _followBundleChannels}. (#B205) */
+    var _channelBase = null;
     /** @type {boolean} When true, Data tab renders raw JSON instead of a tree */
     var rawMode = false;
     /** @type {string} Highest severity level received since last clear (drives log-dot) */
@@ -1568,8 +1590,12 @@
             var raw = localStorage.getItem(CUSTOM_ORDER_KEY);
             if (raw) {
                 var arr = JSON.parse(raw);
-                // Accept arrays of 1-6 known tab names (tabs may be hidden)
-                if (Array.isArray(arr) && arr.length >= 1 && arr.length <= 6) return arr;
+                // Accept 1..N tab names where N is the full preset roster
+                // (tabs may be hidden, so shorter is fine). #B194 — this bound
+                // was a stale literal 6: once the roster grew to 8 tabs, a
+                // custom order saved with 7-8 visible tabs was rejected here
+                // on every read and never survived a reload.
+                if (Array.isArray(arr) && arr.length >= 1 && arr.length <= TAB_LAYOUTS.balanced.length) return arr;
             }
         } catch (e) {}
         return null;
@@ -1654,6 +1680,45 @@
         }
     }
 
+    /**
+     * Restore a single hidden tab in custom layout mode — the per-tab
+     * inverse of {@link hideTab}, wired to the dimmed preview pills (see
+     * {@link renderLayoutPreview}): the struck-through pill is the removed
+     * tab's only remaining representative, so clicking it brings the tab
+     * back without touching the others (Reset stays the bulk path).
+     *
+     * Removes the tab from the hidden list, shows its button again at the
+     * END of the visible tabs — hiding dropped it from the saved custom
+     * order and applyTabLayout parks hidden buttons at the FRONT of the
+     * nav (only ordered visible tabs are appended), so the explicit
+     * appendChild is what makes the landing spot deterministic; drag-mode
+     * is active right there for repositioning — then persists the new
+     * order and re-renders the preview.
+     *
+     * Deliberately does NOT activate the restored tab: the user is
+     * mid-layout-editing, so the tab reappearing in the bar and its pill
+     * un-dimming is the whole feedback — no panel switch.
+     *
+     * @inner
+     * @param {string} tabName - Tab name to restore (e.g. 'view', 'forms')
+     */
+    function restoreTab(tabName) {
+        var hidden = getHiddenTabs();
+        var idx = hidden.indexOf(tabName);
+        if (idx === -1) return;
+        hidden.splice(idx, 1);
+        saveHiddenTabs(hidden);
+
+        var btn = qs('.bm-tab[data-tab="' + tabName + '"]');
+        var nav = qs('.bm-tabs');
+        if (btn) {
+            btn.style.display = '';
+            if (nav) nav.appendChild(btn);
+        }
+        saveCustomOrder();
+        renderLayoutPreview('custom');
+    }
+
     /**
      * Restore all hidden tabs in custom layout mode. Shows all tab buttons,
      * clears the hidden list from localStorage, and rebuilds the custom order
@@ -1727,7 +1792,9 @@
         logs:  'var(--text-dim)',
         forms: 'var(--warn)',
         query: 'var(--num)',
-        flow:  'var(--accent)'
+        flow:  'var(--accent)',
+        stream: 'var(--str)',
+        events: 'var(--warn)'
     };
 
     /**
@@ -1737,9 +1804,37 @@
      */
     var TAB_PREVIEW_LABELS = {
         data: 'Data', view: 'View', logs: 'Logs',
-        forms: 'Forms', query: 'Query', flow: 'Flow'
+        forms: 'Forms', query: 'Query', flow: 'Flow',
+        stream: 'Stream', events: 'Events'
     };
 
+    /**
+     * Resolve a tab's preview-pill label. #B194 — the two newer tabs (stream,
+     * events) were added to every TAB_LAYOUTS preset but not to the preview
+     * maps, so their pills rendered the literal string "undefined". The maps
+     * now carry them, and this fallback humanizes any FUTURE tab that misses
+     * the map (capitalized tab name), so the class cannot fire again.
+     *
+     * @inner
+     * @param {string} tab - Tab name (e.g. 'query')
+     * @returns {string} Display label for the preview pill
+     */
+    function pillLabel(tab) {
+        return TAB_PREVIEW_LABELS[tab] || (tab.charAt(0).toUpperCase() + tab.slice(1));
+    }
+
+    /**
+     * Resolve a tab's preview-pill color, falling back to the neutral dim
+     * color for a tab absent from the map (see {@link pillLabel} — #B194).
+     *
+     * @inner
+     * @param {string} tab - Tab name
+     * @returns {string} CSS color value for the pill's --pill-color
+     */
+    function pillColor(tab) {
+        return TAB_PREVIEW_COLORS[tab] || 'var(--text-dim)';
+    }
+
     /**
      * Render a row of tiny colored pills into `#bm-layout-preview` showing
      * the tab order for the given layout preset.  Each pill is color-coded
@@ -1766,16 +1861,22 @@
             var isHidden = hidden.indexOf(tab) !== -1;
             if (!isHidden) {
                 if (!visibleFirst) html += '<span class="bm-lp-arrow">\u203A</span>';
-                html += '<span class="bm-lp-pill" style="--pill-color:' + TAB_PREVIEW_COLORS[tab] + '">'
-                      + TAB_PREVIEW_LABELS[tab] + '</span>';
+                html += '<span class="bm-lp-pill" style="--pill-color:' + pillColor(tab) + '">'
+                      + pillLabel(tab) + '</span>';
                 visibleFirst = false;
             }
         }
-        // Append hidden tabs as dimmed pills
+        // Append hidden tabs as dimmed pills \u2014 each is a click-to-restore
+        // control (delegated on #bm-layout-preview): it carries data-tab for
+        // the handler, a native Restore tooltip, and a leading + glyph as
+        // the visible affordance. Visible pills stay a passive readout.
         for (var h = 0; h < hidden.length; h++) {
             if (!visibleFirst) html += '<span class="bm-lp-arrow bm-lp-arrow-dim">\u203A</span>';
-            html += '<span class="bm-lp-pill bm-lp-pill-hidden" style="--pill-color:' + TAB_PREVIEW_COLORS[hidden[h]] + '">'
-                  + TAB_PREVIEW_LABELS[hidden[h]] + '</span>';
+            html += '<span class="bm-lp-pill bm-lp-pill-hidden" data-tab="' + hidden[h] + '"'
+                  + ' title="Restore ' + pillLabel(hidden[h]) + ' tab"'
+                  + ' style="--pill-color:' + pillColor(hidden[h]) + '">'
+                  + '<span class="bm-lp-pill-add">+</span>'
+                  + pillLabel(hidden[h]) + '</span>';
             visibleFirst = false;
         }
         el.innerHTML = html;
@@ -2221,7 +2322,12 @@
     /**
      * #QI2 — Fetch live index data from the /_gina/indexes endpoint.
      * Called when the Query tab renders queries with N/A index badges.
-     * On success, caches the result and re-renders the Query tab.
+     * On success, caches the result and re-renders the Query tab's tree
+     * root (`#tree-query`) — the container {@link renderTab} owns. It must
+     * never replace the scroll wrapper's children instead: `#tree-query`
+     * lives INSIDE the wrapper, so a wrapper-level write destroys it and
+     * every later `renderTab('query')` bails on the missing container —
+     * freezing the Query pane and badge until the Inspector reloads (#B222).
      *
      * @inner
      */
@@ -2241,13 +2347,27 @@
                 if (xhr.status === 200) {
                     try {
                         _liveIndexes = JSON.parse(xhr.responseText);
-                        // Re-render query tab if we have queries
-                        if (_lastQueries) {
-                            var el = document.getElementById('tab-query');
-                            if (el) {
-                                var content = el.querySelector('.bm-scroll-area');
-                                if (content) content.innerHTML = renderQueryContent(_lastQueries);
-                            }
+                        // Re-render query tab if we have queries — into
+                        // #tree-query, the container renderTab() owns (#B222).
+                        // Writing the scroll wrapper here instead destroyed
+                        // #tree-query (a child of the wrapper), after which
+                        // every later renderTab('query') bailed on the missing
+                        // container and the Query pane froze until reload.
+                        // #B225 — the queries derive from the live payload
+                        // exactly as renderTab('query') does (reveal swap
+                        // included), never from the module query cache: the
+                        // cache survives overlay eras that ended while the
+                        // Query tab was inactive, so a cached repaint after
+                        // the forced refetch resurrected dead queries and
+                        // rewrote the badge over the truthful one.
+                        var src = (_revealActive && _revealedData) ? _revealedData : ginaData;
+                        var u = (src && src.user) || {};
+                        var hasXhr = typeof u['data-xhr'] !== 'undefined';
+                        var queryData = hasXhr && u['data-xhr'] && u['data-xhr'].queries
+                            ? u['data-xhr'].queries : u.queries;
+                        if (queryData && queryData.length) {
+                            var panel = qs('#tree-query');
+                            if (panel) panel.innerHTML = renderQueryContent(queryData);
                         }
                     } catch (e) { _liveIndexes = { connectors: {} }; }
                 }
@@ -3573,6 +3693,101 @@
         return true;
     }
 
+    /**
+     * Adopt the statusbar-advertised tab channel when no usable `?ch=` was
+     * given (#B231).
+     *
+     * Every dev page's statusbar advertises its per-tab channel id in
+     * `localStorage['__gina_last_tab_ch']` on each publish, so an embedded
+     * Inspector opened WITHOUT `?ch=` (direct URL, bookmark, a window predating
+     * bound mode) can still bind to the most-recently-published tab instead of
+     * falling back to the bundle-global channels (opener/localStorage polling +
+     * the passive `/_gina/agent` SSE), where ANY background request to the
+     * bundle overwrites the page-scoped popin/XHR overlay within seconds.
+     *
+     * A liveness handshake guards the adopt: `setupBoundChannel()` posts
+     * `{type:'request'}` on bind; if no `{type:'data'}` reply lands within
+     * {@link ADOPT_HANDSHAKE_MS} (stale advert — its tab is closed, and
+     * localStorage outlives tabs), the bound channel AND the `/_gina/logs`
+     * stream the caller opened alongside it are torn down, and `onDead` runs
+     * the legacy acquisition (leaving the logs stream open would double-deliver
+     * log entries once the legacy path's passive agent stream attaches).
+     *
+     * Multi-tab semantics: adopts the LAST tab that published (last-writer-wins
+     * on the advert) — a deliberate approximation of "the tab the user is on",
+     * strictly narrower than the bundle-global fallback it replaces.
+     *
+     * @inner
+     * @param   {function} onDead - Legacy acquisition to run when the adopted
+     *   channel never delivers (the init's `_startLegacyAcquisition`).
+     * @returns {boolean} `true` when an advertised channel was adopted (bound
+     *   mode claimed; the handshake timer is armed).
+     */
+    function _adoptAdvertisedChannel(onDead) {
+        var ad = null;
+        try { ad = localStorage.getItem('__gina_last_tab_ch'); } catch (e) { ad = null; }
+        if (!ad || !setupBoundChannel(ad)) return false;
+        setTimeout(function () {
+            // Proven live (a data frame arrived) or re-claimed by another mode.
+            if (source !== 'broadcast' || _bcLatest !== null) return;
+            try { if (_boundChannel) _boundChannel.close(); } catch (e) {}
+            _boundChannel = null;
+            if (_serverLogsEs) {
+                try { _serverLogsEs.close(); } catch (e) {}
+                _serverLogsEs = null;
+            }
+            source = null;
+            if (typeof onDead === 'function') onDead();
+        }, ADOPT_HANDSHAKE_MS);
+        return true;
+    }
+
+    /**
+     * Render the footer data-source mode badge (#B231).
+     *
+     * Surfaces WHICH kind of channel feeds the data tabs, so a degraded mode
+     * is visible instead of silent:
+     *  - `bound`  — per-tab statusbar channel (#INS15): page-scoped, immune to
+     *    other tabs' / background renders.
+     *  - `agent`  — explicit `?target=` bundle stream (standalone mode).
+     *  - `global` — legacy fallback (opener/localStorage polling + the passive
+     *    bundle-wide `/_gina/agent` SSE): ANY request to the bundle can
+     *    overwrite the data tabs — warn-tinted, and the tooltip points at the
+     *    statusbar link that yields bound mode.
+     *
+     * Called from `pollData()` (every tick + every bound-channel apply) and at
+     * the end of the init acquisition, so a mode transition (e.g. an adopted
+     * channel handing over to the legacy fallback) surfaces within one tick.
+     *
+     * @inner
+     */
+    function updateSourceModeBadge() {
+        var el = qs('#bm-source-mode');
+        if (!el) return;
+        var mode = null;
+        var cls  = 'bm-source-mode';
+        var tip  = '';
+        if (source === 'agent') {
+            mode = 'agent';
+            tip  = 'Data from the ?target= bundle stream (/_gina/agent).';
+        } else if (source === 'broadcast') {
+            mode = 'bound';
+            tip  = 'Data bound to one page tab (statusbar channel). Other tabs and background requests cannot overwrite it.';
+        } else if (source === 'localStorage' || (source && typeof source === 'object')) {
+            mode = 'global';
+            cls += ' bm-source-mode-warn';
+            tip  = 'Bundle-global fallback: any tab or background request to this bundle can overwrite the data tabs. Open the Inspector from the page statusbar link to get bound (per-tab) mode.';
+        }
+        if (mode === null) {
+            el.hidden = true;
+            return;
+        }
+        el.hidden = false;
+        el.textContent = mode;
+        el.className = cls;
+        el.title = tip;
+    }
+
     // ── Settings — environment info + memory gauge ────────────────────────
 
     /**
@@ -3648,17 +3863,53 @@
         } catch (e) { return null; }
     }
 
+    /**
+     * Extract the bundle webroot from a `__ginaData` payload, reading
+     * `gina.environment` first then falling back to `user.environment`
+     * (mirrors {@link _gdPid}). Both render delegates emit it.
+     *
+     * @inner
+     * @param   {?Object} gd  A parsed `__ginaData` payload.
+     * @returns {?string} The webroot (e.g. `'/'` or `'/admin'`), or null when absent.
+     */
+    function _gdWebroot(gd) {
+        try {
+            var e = (gd && gd.gina && gd.gina.environment)
+                 || (gd && gd.user && gd.user.environment) || null;
+            var w = e ? e.webroot : null;
+            return (typeof w === 'string') ? w : null;
+        } catch (e) { return null; }
+    }
+
+    /**
+     * Normalise a webroot/base path for comparison and URL building: strip
+     * every trailing slash so `'/'` and `''` both mean the root and
+     * `'/admin/'` equals `'/admin'`. Non-strings normalise to null (unknown).
+     *
+     * @inner
+     * @param   {?string} w  A webroot or base path.
+     * @returns {?string} The normalised base (`''` for the root), or null.
+     */
+    function _normWebroot(w) {
+        return (typeof w === 'string') ? w.replace(/\/+$/, '') : null;
+    }
+
     /**
      * Record the live bundle pid from an agent-delivered payload. The agent
      * (SSE/WS) channel always reflects the running process, so its pid is the
      * freshness reference {@link _isStaleSource} compares polled snapshots against.
+     * Also records which bundle the pid belongs to ({@link _livePidWebroot}) so
+     * the guard can tell a restart from a bundle crossing (#B205).
      *
      * @inner
      * @param {?Object} gd  A parsed `__ginaData` payload from the agent channel.
      */
     function _noteLivePid(gd) {
         var p = _gdPid(gd);
-        if (p) _livePid = p;
+        if (p) {
+            _livePid = p;
+            _livePidWebroot = _normWebroot(_gdWebroot(gd));
+        }
     }
 
     /**
@@ -3671,6 +3922,13 @@
      * Inert (returns false) until an agent pid is known, preserving the pure
      * opener/localStorage behaviour.
      *
+     * A pid mismatch only means "stale" WITHIN one bundle: in a proxy-routed
+     * multi-bundle project, a payload from another bundle (different webroot,
+     * necessarily a different process/pid) is the monitored tab legitimately
+     * crossing a bundle boundary — it must pass so the Inspector can follow
+     * ({@link _followBundleChannels}). Only same-webroot pid mismatches are
+     * treated as stale (#B205).
+     *
      * @inner
      * @param   {?Object} gd  The polled `__ginaData` payload.
      * @returns {boolean} True when `gd` belongs to a different (stale) process.
@@ -3678,7 +3936,12 @@
     function _isStaleSource(gd) {
         if (!_livePid) return false;
         var p = _gdPid(gd);
-        return !!(p && p !== _livePid);
+        if (!p || p === _livePid) return false;
+        // #B205 — a different pid under a DIFFERENT webroot is another bundle,
+        // not a stale snapshot of this one: let it through.
+        var wr = _normWebroot(_gdWebroot(gd));
+        if (wr !== null && _livePidWebroot !== null && wr !== _livePidWebroot) return false;
+        return true;
     }
 
     /**
@@ -3693,10 +3956,15 @@
      * If the source is lost (e.g. bundle restart killed the opener page),
      * attempts to re-acquire it via {@link tryOpener} or {@link tryLocalStorage}.
      *
+     * Each applied payload also drives {@link _followBundleChannels}, which
+     * re-points the server-side SSE channels when the monitored tab crossed
+     * onto another bundle of the project (#B205).
+     *
      * @inner
      */
     function pollData() {
         try {
+            updateSourceModeBadge();
             var gd;
             if (source === 'agent') {
                 // Agent mode — data is pushed via SSE; nothing to poll.
@@ -3740,6 +4008,12 @@
             lastGdStr = str;
             ginaData = gd;
             var env = (gd.user && gd.user.environment) || {};
+            // #B205 — follow the monitored tab across bundles: when this payload
+            // belongs to another bundle (different webroot), re-point the
+            // server-side channels at it. Hitting its Inspector endpoints also
+            // activates that bundle's dev capture, so Flow/Query data starts
+            // flowing for its pages.
+            _followBundleChannels(gd);
             qs('#bm-label').textContent = (env.bundle || '?') + '@' + (env.env || '?');
             qs('#bm-dot').className = 'bm-dot ok';
             // Update window title with the inspected page URL
@@ -4141,20 +4415,36 @@
      * log entries from the bundle process. Entries are merged into the same logs[]
      * array used by client-side console capture and engine.io push.
      *
+     * At most one stream is live: a re-point ({@link _followBundleChannels})
+     * closes the previous stream before connecting to the new bundle (#B205).
+     *
      * @inner
      * @private
+     * @param {string} [baseOverride]  Explicit bundle base to connect to —
+     *   passed by the bundle-follow re-point; omitted at init, where the
+     *   shared resolver derives the base.
      */
-    function tryServerLogs() {
+    function tryServerLogs(baseOverride) {
         if (typeof EventSource === 'undefined') return;
 
         // Derive the SSE URL via the shared 3-fallback resolver so /_gina/logs
         // reaches the monitored bundle in proxy-routed multi-bundle setups (was a
         // bare pathname strip that misrouted to the proxy's default bundle).
         var base = resolveBundleBase();
+        // #B205 — bundle-follow re-points pass the target base explicitly.
+        if (typeof baseOverride === 'string') base = baseOverride;
         var url  = base + '/_gina/logs';
 
+        // #B205 — single live stream: close the previous one on re-point.
+        if (_serverLogsEs) {
+            try { _serverLogsEs.close(); } catch (e) {}
+            _serverLogsEs = null;
+        }
+
         try {
             var es = new EventSource(url);
+            _serverLogsEs = es;
+            _channelBase  = base;
             es.onmessage = function (ev) {
                 if (paused) return;
                 try {
@@ -4172,6 +4462,46 @@
         } catch (e) {}
     }
 
+    // ── Bundle-follow: re-point server channels on bundle crossing (#B205) ──
+
+    /**
+     * Follow the monitored tab across the bundles of a proxy-routed
+     * multi-bundle project. Every applied `__ginaData` payload names its
+     * bundle's webroot; when it differs from the base the server-side channels
+     * are pointed at ({@link _channelBase}), the live `/_gina/logs` SSE and/or
+     * the passive `/_gina/agent` SSE are closed and re-opened against the new
+     * bundle's base, so that:
+     *
+     *  - server logs stream from the bundle actually serving the monitored
+     *    page (they previously stayed pinned to the open-time bundle), and
+     *  - the new bundle's dev capture activates: its Inspector endpoints latch
+     *    the per-process activation flag that gates the request timeline
+     *    (Flow tab) and the query log (Query tab). Without the re-point, a
+     *    bundle the Inspector was never opened from kept rendering with no
+     *    flow/queries — the Flow tab showed "No timeline data for this
+     *    request." for every page that bundle served.
+     *
+     * The page that evidences the crossing rendered BEFORE the new bundle's
+     * capture activated, so its own timeline is unavoidably absent — Flow and
+     * Query data appear from the next render on. Agent mode (`?target=`) is an
+     * explicit binding and is never re-pointed.
+     *
+     * @inner
+     * @param {?Object} gd  The just-applied `__ginaData` payload.
+     */
+    function _followBundleChannels(gd) {
+        if (source === 'agent') return;
+        var wr = _normWebroot(_gdWebroot(gd));
+        if (wr === null || wr === _channelBase) return;
+        var hadPassive = !!_passiveAgentEs;
+        var hadLogs    = !!_serverLogsEs;
+        // Adopt the new base even when no channel is open (e.g. EventSource
+        // unsupported), so the comparison above stays meaningful.
+        _channelBase = wr;
+        if (hadPassive) tryAgentPassive(wr);
+        if (hadLogs)    tryServerLogs(wr);
+    }
+
     // ── Remote data source via /_gina/agent SSE ─────────────────────────
 
     /**
@@ -4444,10 +4774,13 @@
      * passive mode succeeds `tryServerLogs()` is skipped to avoid duplicates.
      *
      * @inner
+     * @param {string} [baseOverride]  Explicit bundle base to connect to —
+     *   passed by the bundle-follow re-point ({@link _followBundleChannels})
+     *   and the refresh-button reopen; omitted at init.
      * @returns {boolean} `true` when a subscription was opened, `false` when
      *   the environment is unsupported or the URL cannot be derived.
      */
-    function tryAgentPassive() {
+    function tryAgentPassive(baseOverride) {
         if (typeof EventSource === 'undefined') return false;
         // Agent mode already covers data + logs via the primary tryAgent stream.
         if (source === 'agent') return false;
@@ -4457,11 +4790,20 @@
         // tryAgentPassive only runs when source !== 'agent' (i.e. no ?target=),
         // so this falls through to the opener-pathname fallback as before.
         var base = resolveBundleBase();
+        // #B205 — bundle-follow re-points pass the target base explicitly.
+        if (typeof baseOverride === 'string') base = baseOverride;
         var url = base + '/_gina/agent';
 
+        // #B205 — single live stream: close the previous one on re-point.
+        if (_passiveAgentEs) {
+            try { _passiveAgentEs.close(); } catch (e) {}
+            _passiveAgentEs = null;
+        }
+
         try {
             var es = new EventSource(url);
             _passiveAgentEs = es;
+            _channelBase = base;
 
             es.addEventListener('data', function (ev) {
                 try {
@@ -4708,6 +5050,20 @@
             resetBtn.addEventListener('click', function () { restoreAllTabs(); });
         }
 
+        // Per-tab restore — clicking a dimmed (hidden) preview pill restores
+        // just that tab. Delegated on the container: the pill row is rebuilt
+        // via innerHTML on every renderLayoutPreview(), so per-pill listeners
+        // would not survive; the container does.
+        var previewEl = qs('#bm-layout-preview');
+        if (previewEl) {
+            previewEl.addEventListener('click', function (e) {
+                var pill = e.target && e.target.closest ? e.target.closest('.bm-lp-pill-hidden') : null;
+                if (!pill) return;
+                var name = pill.getAttribute('data-tab');
+                if (name) restoreTab(name);
+            });
+        }
+
         // ── Tab drag-to-reorder (custom layout mode) ──────────────────────
         setupTabDrag();
     }
@@ -5293,10 +5649,20 @@
 
         // Query tab toolbar — filter and search handlers
         function rerenderQueries() {
-            if (!_lastQueries) return;
+            // #B225 — derive from the live payload exactly as renderTab('query')
+            // does (reveal swap included), never from the module query cache:
+            // the cache survives overlay eras that ended while the Query tab
+            // was inactive, so a cached repaint resurrects dead queries and
+            // rewrites the badge over the truthful one.
+            var src = (_revealActive && _revealedData) ? _revealedData : ginaData;
+            var u = (src && src.user) || {};
+            var hasXhr = typeof u['data-xhr'] !== 'undefined';
+            var queryData = hasXhr && u['data-xhr'] && u['data-xhr'].queries
+                ? u['data-xhr'].queries : u.queries;
+            if (!queryData || !queryData.length) return;
             var panel = qs('#tree-query');
             if (panel) {
-                panel.innerHTML = renderQueryContent(_lastQueries);
+                panel.innerHTML = renderQueryContent(queryData);
             }
         }
 
@@ -5441,11 +5807,19 @@
                 }
 
                 // Reopen the passive /_gina/agent stream if it has closed.
-                if (source !== 'agent'
+                // #B225 — never in bound mode: a broadcast-driven window takes
+                // its data from the statusbar publisher (#INS15), and a passive
+                // stream opened here applies bundle-wide payloads over the
+                // page-scoped ones (the measured badge blink at every later XHR
+                // overlay); a later _noteLivePid could also retro-arm the leak
+                // on bound applies.
+                if (source !== 'agent' && source !== 'broadcast'
                     && (!_passiveAgentEs || _passiveAgentEs.readyState === 2)) {
                     try { if (_passiveAgentEs) _passiveAgentEs.close(); } catch (e) {}
                     _passiveAgentEs = null;
-                    tryAgentPassive();
+                    // #B205 — keep the re-opened stream on the currently-followed
+                    // bundle instead of re-deriving from the opener's deep path.
+                    tryAgentPassive(_channelBase !== null ? _channelBase : undefined);
                 }
 
                 if (ev.shiftKey) {
@@ -5487,10 +5861,31 @@
             // it severs window.opener). Server logs still arrive via the SSE.
             var _boundCh = (typeof URLSearchParams !== 'undefined')
                 ? new URLSearchParams(window.location.search).get('ch') : null;
-            if (setupBoundChannel(_boundCh)) {
+            if (setupBoundChannel(_boundCh)
+                // #B231 — no usable ?ch=: adopt the statusbar's advertised tab
+                // channel (bound mode) instead of the bundle-global fallback; a
+                // dead advert hands over to _startLegacyAcquisition via the
+                // liveness-handshake timer inside _adoptAdvertisedChannel().
+                || _adoptAdvertisedChannel(_startLegacyAcquisition)) {
                 qs('#bm-no-source').classList.add('hidden');
                 tryServerLogs();   // server logs only; data via the bound channel
             } else {
+                _startLegacyAcquisition();
+            }
+            updateSourceModeBadge();
+
+            /**
+             * Legacy bundle-global acquisition — opener/localStorage polling +
+             * the passive `/_gina/agent` SSE (+ engine.io + the "No source"
+             * connect form). Runs when neither an explicit `?ch=` nor an
+             * adopted advertised channel yields bound mode — and again from
+             * `_adoptAdvertisedChannel`'s handshake timer when an adopted
+             * channel turns out dead (#B231). Body unchanged from the
+             * pre-#B231 inline `else` block; only the connect-form wiring
+             * moved into the nested `_wireConnectForm()` below.
+             * @inner
+             */
+            function _startLegacyAcquisition() {
                 var ok = tryOpener() || tryLocalStorage();
                 if (!ok) {
                     hideLoader();
@@ -5499,6 +5894,18 @@
                     qs('#bm-label').textContent = 'No source';
                 }
 
+                _wireConnectForm();
+
+                tryEngineIO();
+                // 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();
+                updateSourceModeBadge();
+
                 /**
                  * Manual connect form on the "No source" overlay.
                  *
@@ -5512,38 +5919,31 @@
                  *
                  * @inner
                  */
-                var connectForm = qs('#bm-connect-form');
-                if (connectForm) {
-                    connectForm.addEventListener('submit', function (ev) {
-                        ev.preventDefault();
-                        var urlInput = qs('#bm-connect-url');
-                        var raw = (urlInput.value || '').trim();
-                        if (!raw) return;
-                        // Normalise: add scheme if missing, strip trailing slash
-                        if (!/^https?:\/\//i.test(raw)) raw = 'http://' + raw;
-                        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;
-                    });
+                function _wireConnectForm() {
+                    var connectForm = qs('#bm-connect-form');
+                    if (connectForm) {
+                        connectForm.addEventListener('submit', function (ev) {
+                            ev.preventDefault();
+                            var urlInput = qs('#bm-connect-url');
+                            var raw = (urlInput.value || '').trim();
+                            if (!raw) return;
+                            // Normalise: add scheme if missing, strip trailing slash
+                            if (!/^https?:\/\//i.test(raw)) raw = 'http://' + raw;
+                            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;
+                        });
+                    }
                 }
-
-                tryEngineIO();
-                // 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();
             }
         }