πΊοΈ Map Controls
@@ -553,6 +566,19 @@
}
}
+ // Check for pending path inspector route (cross-page navigation from Path Inspector).
+ if (window._pendingPathInspectorRoute) {
+ var pending = window._pendingPathInspectorRoute;
+ delete window._pendingPathInspectorRoute;
+ if (pending.path && pending.path.length > 0) {
+ if (window.routeLayer) window.routeLayer.clearLayers();
+ drawPacketRoute(pending.path.slice(1), pending.path[0]);
+ }
+ }
+
+ // Wire up map side pane (Path Inspector embedded - spec Β§2.7).
+ initMapSidePane();
+
// Don't fitBounds on initial load β respect the Bay Area default or saved view
// Only fitBounds on subsequent data refreshes if user hasn't manually panned
} catch (e) {
@@ -981,6 +1007,122 @@
map.fitBounds(bounds, { padding: [50, 50], maxZoom: 14 });
}
+ // === Map Side Pane β Path Inspector (spec Β§2.7) ===
+ function initMapSidePane() {
+ var pane = document.getElementById('mapSidePane');
+ var toggle = document.getElementById('mapPaneToggle');
+ var input = document.getElementById('mapPiInput');
+ var btn = document.getElementById('mapPiSubmit');
+ if (!pane || !toggle) return;
+
+ toggle.addEventListener('click', function () {
+ pane.classList.toggle('expanded');
+ toggle.textContent = pane.classList.contains('expanded') ? 'βΆ' : 'β';
+ // Invalidate map size after transition.
+ setTimeout(function () { if (map) map.invalidateSize(); }, 220);
+ });
+
+ if (btn && input) {
+ btn.addEventListener('click', function () { mapPiSubmit(input.value); });
+ input.addEventListener('keydown', function (e) {
+ if (e.key === 'Enter') mapPiSubmit(input.value);
+ });
+ }
+
+ // Auto-open if URL has prefixes param while on map.
+ var params = new URLSearchParams(location.hash.split('?')[1] || '');
+ var prefixParam = params.get('prefixes');
+ if (prefixParam && input) {
+ pane.classList.add('expanded');
+ toggle.textContent = 'βΆ';
+ input.value = prefixParam;
+ setTimeout(function () { if (map) map.invalidateSize(); }, 220);
+ mapPiSubmit(prefixParam);
+ }
+ }
+
+ function mapPiSubmit(raw) {
+ var errDiv = document.getElementById('mapPiError');
+ var resultsDiv = document.getElementById('mapPiResults');
+ if (!errDiv || !resultsDiv) return;
+ errDiv.textContent = '';
+ resultsDiv.innerHTML = '';
+
+ // Reuse PathInspector validation if available.
+ var prefixes = raw.trim().split(/[\s,]+/).filter(function (s) { return s.length > 0; }).map(function (s) { return s.toLowerCase(); });
+ var err = (window.PathInspector && window.PathInspector.validatePrefixes) ? window.PathInspector.validatePrefixes(prefixes) : null;
+ if (!err && prefixes.length === 0) err = 'Enter at least one prefix.';
+ if (err) { errDiv.textContent = err; return; }
+
+ resultsDiv.innerHTML = '
Loading...
';
+ fetch('/api/paths/inspect', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ prefixes: prefixes })
+ })
+ .then(function (r) {
+ if (r.status === 503) return r.json().then(function () { throw new Error('Service warming up, retry shortly.'); });
+ if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || 'Request failed'); });
+ return r.json();
+ })
+ .then(function (data) { renderMapPiResults(data, resultsDiv); })
+ .catch(function (e) { resultsDiv.innerHTML = ''; errDiv.textContent = e.message; });
+ }
+
+ function renderMapPiResults(data, div) {
+ if (!data.candidates || data.candidates.length === 0) {
+ div.innerHTML = '
No candidates found.
';
+ return;
+ }
+ var html = '
# Score Path ';
+ for (var i = 0; i < data.candidates.length; i++) {
+ var c = data.candidates[i];
+ var rowClass = c.speculative ? 'speculative-row' : '';
+ html += '';
+ html += '' + (i + 1) + ' ';
+ html += '' + c.score.toFixed(2) + (c.speculative ? ' β ' : '') + ' ';
+ html += '' + safeEsc(c.names.slice(0, 3).join('β')) + (c.names.length > 3 ? 'β¦' : '') + ' ';
+ html += 'π ';
+ // Per-hop evidence (collapsed).
+ html += '';
+ if (c.evidence && c.evidence.perHop) {
+ for (var j = 0; j < c.evidence.perHop.length; j++) {
+ var h = c.evidence.perHop[j];
+ html += '
Hop ' + (j+1) + ': ' + h.prefix + ' (Γ' + h.candidatesConsidered + ') w=' + h.edgeWeight.toFixed(2);
+ if (h.alternatives && h.alternatives.length > 0) {
+ html += ' [+' + h.alternatives.length + ' alt] ';
+ }
+ html += '
';
+ }
+ }
+ html += '
';
+ div.innerHTML = html;
+
+ // Wire buttons.
+ div.querySelectorAll('button[data-idx]').forEach(function (btn) {
+ btn.addEventListener('click', function () {
+ var idx = parseInt(btn.dataset.idx);
+ var cand = data.candidates[idx];
+ if (routeLayer) routeLayer.clearLayers();
+ drawPacketRoute(cand.path.slice(1), cand.path[0]);
+ });
+ });
+ // Expand evidence on row click.
+ div.querySelectorAll('.path-inspector-table tbody tr:not(.evidence-row)').forEach(function (row) {
+ row.style.cursor = 'pointer';
+ row.addEventListener('click', function (e) {
+ if (e.target.tagName === 'BUTTON') return;
+ var b = row.querySelector('button[data-idx]');
+ if (!b) return;
+ var ev = div.querySelector('tr[data-evidence="' + b.dataset.idx + '"]');
+ if (ev) ev.classList.toggle('collapsed');
+ });
+ });
+ }
+
function destroy() {
if (wsHandler) offWS(wsHandler);
wsHandler = null;
diff --git a/public/packets.js b/public/packets.js
index f0b2db8a..a169461e 100644
--- a/public/packets.js
+++ b/public/packets.js
@@ -468,6 +468,9 @@
// Check if new packets pass current filters
const filtered = newPkts.filter(p => {
+ // When user pinned a hash, accept ONLY that exact packet β bypass all
+ // other filters (window/region/type/observer/node).
+ if (filters.hash) return p.hash === filters.hash;
// Respect time window filter β drop packets outside the selected window
const windowMin = savedTimeWindowMin;
if (windowMin > 0) {
@@ -477,7 +480,6 @@
}
if (filters.type) { const types = filters.type.split(',').map(Number); if (!types.includes(p.payload_type)) return false; }
if (filters.observer) { const obsSet = new Set(filters.observer.split(',')); if (!obsSet.has(p.observer_id) && !(p._children && p._children.some(c => obsSet.has(String(c.observer_id))))) return false; }
- if (filters.hash && p.hash !== filters.hash) return false;
if (RegionFilter.getRegionParam()) {
const selectedRegions = RegionFilter.getRegionParam().split(',');
const obs = observerMap.get(p.observer_id);
@@ -610,27 +612,52 @@
} catch {}
}
- async function loadPackets() {
- try {
- const params = new URLSearchParams();
- const selectedWindow = Number(document.getElementById('fTimeWindow')?.value);
- const windowMin = Number.isFinite(selectedWindow) ? selectedWindow : savedTimeWindowMin;
- if (windowMin > 0 && !filters.hash) {
- const since = new Date(Date.now() - windowMin * 60000).toISOString();
- params.set('since', since);
- }
- params.set('limit', String(PACKET_LIMIT));
- const regionParam = RegionFilter.getRegionParam();
- if (regionParam) params.set('region', regionParam);
- if (filters.hash) params.set('hash', filters.hash);
- if (filters.node) params.set('node', filters.node);
- if (filters.observer) params.set('observer', filters.observer);
- if (filters.channel) params.set('channel', filters.channel);
+ // Build URLSearchParams for /api/packets given UI state. Pure function for
+ // testability β returns the params object the next call to /api/packets
+ // would use. The hash filter is an exact identifier: when present it
+ // suppresses ALL other filters (region, time window, observer, node,
+ // channel). The user is asking for THAT packet regardless of saved
+ // selections.
+ function buildPacketsParams({ filters, regionParam, windowMin, groupByHash, limit }) {
+ const params = new URLSearchParams();
+ if (filters.hash) {
+ params.set('hash', filters.hash);
+ params.set('limit', String(limit));
if (groupByHash) {
params.set('groupByHash', 'true');
} else {
params.set('expand', 'observations');
}
+ return params;
+ }
+ if (windowMin > 0) {
+ const since = new Date(Date.now() - windowMin * 60000).toISOString();
+ params.set('since', since);
+ }
+ params.set('limit', String(limit));
+ if (regionParam) params.set('region', regionParam);
+ if (filters.node) params.set('node', filters.node);
+ if (filters.observer) params.set('observer', filters.observer);
+ if (filters.channel) params.set('channel', filters.channel);
+ if (groupByHash) {
+ params.set('groupByHash', 'true');
+ } else {
+ params.set('expand', 'observations');
+ }
+ return params;
+ }
+
+ async function loadPackets() {
+ try {
+ const selectedWindow = Number(document.getElementById('fTimeWindow')?.value);
+ const windowMin = Number.isFinite(selectedWindow) ? selectedWindow : savedTimeWindowMin;
+ const params = buildPacketsParams({
+ filters,
+ regionParam: RegionFilter.getRegionParam(),
+ windowMin,
+ groupByHash,
+ limit: PACKET_LIMIT,
+ });
const data = await api('/packets?' + params.toString());
packets = data.packets || [];
@@ -1647,7 +1674,14 @@
// Filter to claimed/favorited nodes β pure client-side filter (no server round-trip)
let displayPackets = packets;
- if (filters.myNodes) {
+
+ // When loading a specific packet by hash, bypass ALL client-side filters
+ // (myNodes, type, observer, packet-filter-expression). The user is asking
+ // for THAT exact packet β saved type/observer/expression filters must not
+ // hide it. Hash filter is the exact identifier; nothing else applies.
+ const hashOnly = !!filters.hash;
+
+ if (!hashOnly && filters.myNodes) {
const myNodes = JSON.parse(localStorage.getItem('meshcore-my-nodes') || '[]');
const myKeys = myNodes.map(n => n.pubkey).filter(Boolean);
const favs = getFavorites();
@@ -1663,11 +1697,11 @@
}
// Client-side type/observer filtering
- if (filters.type) {
+ if (!hashOnly && filters.type) {
const types = filters.type.split(',').map(Number);
displayPackets = displayPackets.filter(p => types.includes(p.payload_type));
}
- if (filters.observer) {
+ if (!hashOnly && filters.observer) {
const obsIds = new Set(filters.observer.split(','));
displayPackets = displayPackets.filter(p => {
if (obsIds.has(p.observer_id)) return true;
@@ -1678,7 +1712,7 @@
// Packet Filter Language
const pfCount = document.getElementById('packetFilterCount');
- if (filters._packetFilter) {
+ if (!hashOnly && filters._packetFilter) {
const beforeCount = displayPackets.length;
displayPackets = displayPackets.filter(filters._packetFilter);
if (pfCount) {
@@ -2563,6 +2597,7 @@
buildGroupRowHtml,
buildFlatRowHtml,
_calcVisibleRange,
+ buildPacketsParams,
};
}
diff --git a/public/path-inspector.js b/public/path-inspector.js
new file mode 100644
index 00000000..e1e940af
--- /dev/null
+++ b/public/path-inspector.js
@@ -0,0 +1,202 @@
+// Path Inspector β prefix candidate scoring with map overlay (issue #944).
+// IIFE; exports window.PathInspector for testability.
+(function () {
+ 'use strict';
+
+ var container = null;
+ var currentResults = null;
+
+ function init(app) {
+ container = app;
+ var params = new URLSearchParams(location.hash.split('?')[1] || '');
+ var prefixParam = params.get('prefixes') || '';
+
+ container.innerHTML =
+ '
' +
+ '
Path Inspector ' +
+ '
Enter comma or space-separated hex prefixes (1-3 bytes each, e.g. 2C,A1,F4 or 2C A1 F4).
' +
+ '
' +
+ 'Inspect ' +
+ '
' +
+ '
' +
+ '
' +
+ '
';
+
+ var input = document.getElementById('path-inspector-input');
+ var btn = document.getElementById('path-inspector-submit');
+ btn.addEventListener('click', function () { submit(input.value); });
+ input.addEventListener('keydown', function (e) {
+ if (e.key === 'Enter') submit(input.value);
+ });
+
+ // Auto-run if prefixes in URL.
+ if (prefixParam) submit(prefixParam);
+ }
+
+ function destroy() {
+ container = null;
+ currentResults = null;
+ }
+
+ function parsePrefixes(raw) {
+ // Accept comma or space separated.
+ var parts = raw.trim().split(/[\s,]+/).filter(function (s) { return s.length > 0; });
+ return parts.map(function (p) { return p.toLowerCase(); });
+ }
+
+ function validatePrefixes(prefixes) {
+ if (prefixes.length === 0) return 'Enter at least one prefix.';
+ if (prefixes.length > 64) return 'Too many prefixes (max 64).';
+ var hexRe = /^[0-9a-f]+$/;
+ var byteLen = -1;
+ for (var i = 0; i < prefixes.length; i++) {
+ var p = prefixes[i];
+ if (!hexRe.test(p)) return 'Invalid hex: ' + p;
+ if (p.length % 2 !== 0) return 'Odd-length prefix: ' + p;
+ var bl = p.length / 2;
+ if (bl > 3) return 'Prefix too long (max 3 bytes): ' + p;
+ if (byteLen === -1) byteLen = bl;
+ else if (bl !== byteLen) return 'Mixed prefix lengths not allowed.';
+ }
+ return null;
+ }
+
+ function submit(raw) {
+ var errDiv = document.getElementById('path-inspector-error');
+ var resultsDiv = document.getElementById('path-inspector-results');
+ errDiv.textContent = '';
+ resultsDiv.innerHTML = '';
+
+ var prefixes = parsePrefixes(raw);
+ var err = validatePrefixes(prefixes);
+ if (err) {
+ errDiv.textContent = err;
+ return;
+ }
+
+ // Update URL.
+ var base = '#/tools/path-inspector';
+ if (location.hash.indexOf(base) === 0) {
+ history.replaceState(null, '', base + '?prefixes=' + prefixes.join(','));
+ }
+
+ resultsDiv.innerHTML = '
Loading...
';
+ fetch('/api/paths/inspect', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ prefixes: prefixes })
+ })
+ .then(function (r) {
+ if (r.status === 503) return r.json().then(function (d) { throw new Error('Service warming up, retry in a few seconds.'); });
+ if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || 'Request failed'); });
+ return r.json();
+ })
+ .then(function (data) {
+ currentResults = data;
+ renderResults(data, resultsDiv);
+ })
+ .catch(function (e) {
+ resultsDiv.innerHTML = '';
+ errDiv.textContent = e.message;
+ });
+ }
+
+ function renderResults(data, div) {
+ if (!data.candidates || data.candidates.length === 0) {
+ div.innerHTML = '
No candidates found. The prefixes may not match any known path-eligible nodes.
';
+ return;
+ }
+
+ var html = '
' +
+ '# Score Path Action ' +
+ ' ';
+
+ for (var i = 0; i < data.candidates.length; i++) {
+ var c = data.candidates[i];
+ var rowClass = c.speculative ? 'speculative-row' : '';
+ html += '';
+ html += '' + (i + 1) + ' ';
+ html += '' +
+ c.score.toFixed(3) +
+ (c.speculative ? ' β ' : '') +
+ ' ';
+ html += '' + escapeHtml(c.names.join(' β ')) + ' ';
+ html += 'Show on Map ';
+
+ // Per-hop evidence (collapsed).
+ html += '';
+ for (var j = 0; j < c.evidence.perHop.length; j++) {
+ var h = c.evidence.perHop[j];
+ html += '
Hop ' + (j + 1) + ': prefix=' + h.prefix +
+ ', candidates=' + h.candidatesConsidered +
+ ', edge=' + h.edgeWeight.toFixed(3);
+ if (h.alternatives && h.alternatives.length > 0) {
+ html += '
';
+ for (var k = 0; k < h.alternatives.length; k++) {
+ var alt = h.alternatives[k];
+ html += '
β³ ' + escapeHtml(alt.name || alt.publicKey.substring(0, 8)) + ' (score=' + alt.score.toFixed(3) + ')
';
+ }
+ html += '
';
+ }
+ html += '
';
+ }
+ html += '
';
+ html += '
Beam width: ' + data.stats.beamWidth +
+ ' | Expansions: ' + data.stats.expansionsRun +
+ ' | Elapsed: ' + data.stats.elapsedMs + 'ms
';
+
+ div.innerHTML = html;
+
+ // Wire up Show on Map buttons.
+ div.querySelectorAll('button[data-idx]').forEach(function (btn) {
+ btn.addEventListener('click', function () {
+ var idx = parseInt(btn.dataset.idx);
+ showOnMap(data.candidates[idx]);
+ });
+ });
+
+ // Wire up row expand for evidence.
+ div.querySelectorAll('.path-inspector-table tbody tr:not(.evidence-row)').forEach(function (row) {
+ row.style.cursor = 'pointer';
+ row.addEventListener('click', function (e) {
+ if (e.target.tagName === 'BUTTON') return;
+ var idx = row.querySelector('button[data-idx]');
+ if (!idx) return;
+ var evidenceRow = div.querySelector('tr[data-evidence="' + idx.dataset.idx + '"]');
+ if (evidenceRow) evidenceRow.classList.toggle('collapsed');
+ });
+ });
+ }
+
+ function showOnMap(candidate) {
+ // Store pending route for map init to pick up.
+ window._pendingPathInspectorRoute = candidate;
+ // Switch to map page if not there; map init will draw the route.
+ if (location.hash.indexOf('#/map') !== 0) {
+ location.hash = '#/map';
+ } else {
+ // Already on map β draw directly.
+ delete window._pendingPathInspectorRoute;
+ if (window.routeLayer) window.routeLayer.clearLayers();
+ var hops = candidate.path.slice(1);
+ var origin = candidate.path[0] || null;
+ if (window.drawPacketRoute) window.drawPacketRoute(hops, origin);
+ }
+ }
+
+ function escapeAttr(s) {
+ return s.replace(/&/g, '&').replace(/"/g, '"').replace(//g, '>');
+ }
+
+ window.PathInspector = { init: init, destroy: destroy, parsePrefixes: parsePrefixes, validatePrefixes: validatePrefixes };
+ if (typeof registerPage === 'function') registerPage('path-inspector', { init: init, destroy: destroy });
+})();
diff --git a/public/style.css b/public/style.css
index b07a458f..b5a8ed90 100644
--- a/public/style.css
+++ b/public/style.css
@@ -16,6 +16,7 @@
--status-amber: #f59e0b;
--status-amber-light: #fef3c7;
--status-amber-text: #92400e;
+ --path-inspector-speculative: #d97706;
--role-observer: #8b5cf6;
--accent-hover: #6db3ff;
--text: #1a1a2e;
@@ -52,6 +53,7 @@
--status-amber: #f59e0b;
--status-amber-light: #422006;
--status-amber-text: #fcd34d;
+ --path-inspector-speculative: #f59e0b;
--surface-0: #0f0f23;
--surface-1: #1a1a2e;
--surface-2: #232340;
@@ -2309,3 +2311,37 @@ th.sort-active { color: var(--accent, #60a5fa); }
.clock-filter-btn { font-size: 12px; padding: 3px 8px; border: 1px solid var(--border); border-radius: 4px; background: var(--card-bg, #fff); color: var(--text); cursor: pointer; margin-right: 4px; }
.clock-filter-btn.active { background: var(--accent); color: #fff; border-color: var(--accent); }
+
+/* === Path Inspector (issue #944) === */
+.path-inspector-page { padding: 16px; max-width: 900px; margin: 0 auto; }
+.path-inspector-input-row { display: flex; gap: 8px; margin-bottom: 12px; }
+.path-inspector-input-row .input { flex: 1; }
+.path-inspector-error { color: var(--status-red, #ef4444); font-size: 13px; margin-bottom: 8px; }
+.path-inspector-table { width: 100%; border-collapse: collapse; font-size: 13px; }
+.path-inspector-table th,
+.path-inspector-table td { padding: 6px 10px; border-bottom: 1px solid var(--border); text-align: left; }
+.path-inspector-table th { background: var(--card-bg); font-weight: 600; }
+.speculative-warning { color: var(--path-inspector-speculative, #d97706); font-weight: 600; }
+.speculative-badge { cursor: help; }
+.speculative-row { background: color-mix(in srgb, var(--path-inspector-speculative, #d97706) 8%, transparent); }
+.evidence-row { font-size: 12px; color: var(--text-muted); }
+.evidence-row.collapsed { display: none; }
+.evidence-detail { padding: 4px 10px; }
+.hop-evidence { margin: 2px 0; }
+.path-inspector-stats { margin-top: 12px; font-size: 12px; color: var(--text-muted); }
+.no-results { color: var(--text-muted); font-style: italic; }
+
+/* Map side pane for path inspector */
+.map-side-pane { flex: 0 0 32px; overflow: hidden; transition: flex-basis 0.2s; border-left: 1px solid var(--border); background: var(--card-bg); }
+.map-side-pane.expanded { flex: 0 0 320px; overflow-y: auto; padding: 12px; }
+.map-side-pane .pane-toggle { cursor: pointer; padding: 8px; font-size: 14px; text-align: center; }
+.map-side-pane .pane-content { display: none; }
+.map-side-pane.expanded .pane-content { display: block; }
+
+/* Tools landing page */
+.tools-landing { padding: 24px; max-width: 600px; }
+.tools-menu { display: flex; flex-direction: column; gap: 12px; margin-top: 16px; }
+.tools-card { display: block; padding: 16px; border-radius: 8px; border: 1px solid var(--border); background: var(--card-bg); color: var(--text); text-decoration: none; transition: border-color 0.2s; }
+.tools-card:hover { border-color: var(--primary); }
+.tools-card h3 { margin: 0 0 4px 0; font-size: 16px; }
+.tools-card p { margin: 0; font-size: 13px; color: var(--text-muted); }
diff --git a/test-aging.js b/test-aging.js
index eb8801bf..80e8476c 100644
--- a/test-aging.js
+++ b/test-aging.js
@@ -59,118 +59,7 @@ test('null lastSeenMs β stale', () => assert.strictEqual(getNodeStatus('repeat
test('undefined lastSeenMs β stale', () => assert.strictEqual(getNodeStatus('repeater', undefined), 'stale'));
test('0 lastSeenMs β stale', () => assert.strictEqual(getNodeStatus('repeater', 0), 'stale'));
-// === getStatusInfo tests (inline since nodes.js has too many DOM deps) ===
-console.log('\n=== getStatusInfo (logic validation) ===');
-// Simulate getStatusInfo logic
-function mockGetStatusInfo(n) {
- const ROLE_COLORS = ctx.window.ROLE_COLORS;
- const role = (n.role || '').toLowerCase();
- const roleColor = ROLE_COLORS[n.role] || '#6b7280';
- const lastHeardTime = n._lastHeard || n.last_heard || n.last_seen;
- const lastHeardMs = lastHeardTime ? new Date(lastHeardTime).getTime() : 0;
- const status = getNodeStatus(role, lastHeardMs);
- const statusLabel = status === 'active' ? 'π’ Active' : 'βͺ Stale';
- const isInfra = role === 'repeater' || role === 'room';
-
- let explanation = '';
- if (status === 'active') {
- explanation = 'Last heard recently';
- } else {
- const reason = isInfra
- ? 'repeaters typically advertise every 12-24h'
- : 'companions only advertise when user initiates, this may be normal';
- explanation = 'Not heard β ' + reason;
- }
- return { status, statusLabel, roleColor, explanation, role };
-}
-
-test('active repeater β π’ Active, red color', () => {
- const info = mockGetStatusInfo({ role: 'repeater', last_seen: new Date(now - 1*h).toISOString() });
- assert.strictEqual(info.status, 'active');
- assert.strictEqual(info.statusLabel, 'π’ Active');
- assert.strictEqual(info.roleColor, '#dc2626');
-});
-
-test('stale companion β βͺ Stale, explanation mentions "this may be normal"', () => {
- const info = mockGetStatusInfo({ role: 'companion', last_seen: new Date(now - 25*h).toISOString() });
- assert.strictEqual(info.status, 'stale');
- assert.strictEqual(info.statusLabel, 'βͺ Stale');
- assert(info.explanation.includes('this may be normal'), 'should mention "this may be normal"');
-});
-
-test('missing last_seen β stale', () => {
- const info = mockGetStatusInfo({ role: 'repeater' });
- assert.strictEqual(info.status, 'stale');
-});
-
-test('missing role β defaults to empty string, uses node threshold', () => {
- const info = mockGetStatusInfo({ last_seen: new Date(now - 25*h).toISOString() });
- assert.strictEqual(info.status, 'stale');
- assert.strictEqual(info.roleColor, '#6b7280');
-});
-
-test('prefers last_heard over last_seen', () => {
- // last_seen is stale, but last_heard is recent
- const info = mockGetStatusInfo({
- role: 'companion',
- last_seen: new Date(now - 48*h).toISOString(),
- last_heard: new Date(now - 1*h).toISOString()
- });
- assert.strictEqual(info.status, 'active');
-});
-
-// === getStatusTooltip tests ===
-console.log('\n=== getStatusTooltip ===');
-
-// Load from nodes.js by extracting the function
-// Since nodes.js is complex, I'll re-implement the tooltip function for testing
-function getStatusTooltip(role, status) {
- const isInfra = role === 'repeater' || role === 'room';
- const threshold = isInfra ? '72h' : '24h';
- if (status === 'active') {
- return 'Active β heard within the last ' + threshold + '.' + (isInfra ? ' Repeaters typically advertise every 12-24h.' : '');
- }
- if (role === 'companion') {
- return 'Stale β not heard for over ' + threshold + '. Companions only advertise when the user initiates β this may be normal.';
- }
- if (role === 'sensor') {
- return 'Stale β not heard for over ' + threshold + '. This sensor may be offline.';
- }
- return 'Stale β not heard for over ' + threshold + '. This ' + role + ' may be offline or out of range.';
-}
-
-test('active repeater mentions "72h" and "advertise every 12-24h"', () => {
- const tip = getStatusTooltip('repeater', 'active');
- assert(tip.includes('72h'), 'should mention 72h');
- assert(tip.includes('advertise every 12-24h'), 'should mention advertise frequency');
-});
-
-test('active companion mentions "24h"', () => {
- const tip = getStatusTooltip('companion', 'active');
- assert(tip.includes('24h'), 'should mention 24h');
-});
-
-test('stale companion mentions "24h" and "user initiates"', () => {
- const tip = getStatusTooltip('companion', 'stale');
- assert(tip.includes('24h'), 'should mention 24h');
- assert(tip.includes('user initiates'), 'should mention user initiates');
-});
-
-test('stale repeater mentions "offline or out of range"', () => {
- const tip = getStatusTooltip('repeater', 'stale');
- assert(tip.includes('offline or out of range'), 'should mention offline or out of range');
-});
-
-test('stale sensor mentions "sensor may be offline"', () => {
- const tip = getStatusTooltip('sensor', 'stale');
- assert(tip.includes('sensor may be offline'));
-});
-
-test('stale room uses 72h threshold', () => {
- const tip = getStatusTooltip('room', 'stale');
- assert(tip.includes('72h'));
-});
// === Bug check: renderRows uses last_seen instead of last_heard || last_seen ===
console.log('\n=== BUG CHECK ===');
diff --git a/test-anim-perf.js b/test-anim-perf.js
deleted file mode 100644
index edc3e6d4..00000000
--- a/test-anim-perf.js
+++ /dev/null
@@ -1,123 +0,0 @@
-/**
- * test-anim-perf.js β Performance benchmark for animation timer management
- *
- * Demonstrates that the rAF + concurrency-cap approach keeps active animation
- * count bounded, whereas the old setInterval approach accumulated without limit.
- *
- * Run: node test-anim-perf.js
- */
-
-'use strict';
-
-let passed = 0, failed = 0;
-function assert(cond, msg) {
- if (cond) { console.log(` β
${msg}`); passed++; }
- else { console.log(` β ${msg}`); failed++; }
-}
-
-// ---------------------------------------------------------------------------
-// Simulate OLD behaviour: setInterval-based, no concurrency cap
-// ---------------------------------------------------------------------------
-function simulateOldModel(packetsPerSec, hopsPerPacket, durationSec) {
- // Each hop spawns 3 intervals (pulse 26ms, line 33ms, fade 52ms).
- // Pulse lasts ~2s, line ~0.66s, fade ~0.8s+0.4s β 1.2s
- // At any moment, timers from the last ~2s of packets are still alive.
- const intervalLifetimes = [2.0, 0.66, 1.2]; // seconds each interval lives
- let maxConcurrent = 0;
- // Walk through time in 0.1s steps
- const dt = 0.1;
- const spawns = []; // {time, lifetime}
- for (let t = 0; t < durationSec; t += dt) {
- // Spawn timers for packets arriving in this window
- const pktsInWindow = packetsPerSec * dt;
- for (let p = 0; p < pktsInWindow; p++) {
- for (let h = 0; h < hopsPerPacket; h++) {
- for (const lt of intervalLifetimes) {
- spawns.push({ time: t, lifetime: lt });
- }
- }
- }
- // Count alive timers
- const alive = spawns.filter(s => t < s.time + s.lifetime).length;
- if (alive > maxConcurrent) maxConcurrent = alive;
- }
- return maxConcurrent;
-}
-
-// ---------------------------------------------------------------------------
-// Simulate NEW behaviour: rAF + MAX_CONCURRENT_ANIMS cap
-// ---------------------------------------------------------------------------
-function simulateNewModel(packetsPerSec, hopsPerPacket, durationSec) {
- const MAX_CONCURRENT_ANIMS = 20;
- let activeAnims = 0;
- let maxConcurrent = 0;
- const anims = []; // {endTime}
- const dt = 0.1;
- for (let t = 0; t < durationSec; t += dt) {
- // Expire finished animations
- while (anims.length && anims[0].endTime <= t) {
- anims.shift();
- activeAnims--;
- }
- // Try to start new animations
- const pktsInWindow = packetsPerSec * dt;
- for (let p = 0; p < pktsInWindow; p++) {
- if (activeAnims >= MAX_CONCURRENT_ANIMS) break; // cap reached β drop
- activeAnims++;
- // rAF animation lifetime: longest is pulse ~2s
- anims.push({ endTime: t + 2.0 });
- }
- // Sort by endTime so expiry works
- anims.sort((a, b) => a.endTime - b.endTime);
- if (activeAnims > maxConcurrent) maxConcurrent = activeAnims;
- }
- return maxConcurrent;
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-console.log('\n=== Animation timer accumulation: old vs new ===');
-
-// Scenario: 5 pkts/sec, 3 hops each, 30 seconds
-const oldPeak30s = simulateOldModel(5, 3, 30);
-const newPeak30s = simulateNewModel(5, 3, 30);
-console.log(` Old model (30s @ 5pkt/sΓ3hops): peak ${oldPeak30s} concurrent timers`);
-console.log(` New model (30s @ 5pkt/sΓ3hops): peak ${newPeak30s} concurrent animations`);
-assert(oldPeak30s > 100, `old model accumulates >100 timers (got ${oldPeak30s})`);
-assert(newPeak30s <= 20, `new model stays β€20 (got ${newPeak30s})`);
-
-// Scenario: 5 minutes sustained
-const oldPeak5m = simulateOldModel(5, 3, 300);
-const newPeak5m = simulateNewModel(5, 3, 300);
-console.log(` Old model (5min @ 5pkt/sΓ3hops): peak ${oldPeak5m} concurrent timers`);
-console.log(` New model (5min @ 5pkt/sΓ3hops): peak ${newPeak5m} concurrent animations`);
-assert(oldPeak5m > 100, `old model at 5min still unbounded (got ${oldPeak5m})`);
-assert(newPeak5m <= 20, `new model at 5min still β€20 (got ${newPeak5m})`);
-
-// Scenario: burst β 20 pkts/sec for 10s
-const oldBurst = simulateOldModel(20, 3, 10);
-const newBurst = simulateNewModel(20, 3, 10);
-console.log(` Old model (burst 20pkt/sΓ3hops, 10s): peak ${oldBurst} concurrent timers`);
-console.log(` New model (burst 20pkt/sΓ3hops, 10s): peak ${newBurst} concurrent animations`);
-assert(oldBurst > 200, `old model under burst >200 timers (got ${oldBurst})`);
-assert(newBurst <= 20, `new model under burst stays β€20 (got ${newBurst})`);
-
-console.log('\n=== drawAnimatedLine frame-drop catch-up ===');
-
-// Read the source and verify catch-up logic exists
-const fs = require('fs');
-const src = fs.readFileSync(__dirname + '/public/live.js', 'utf8');
-
-// Extract the animateLine function body
-const lineMatch = src.match(/function animateLine\(now\)\s*\{[\s\S]*?requestAnimationFrame\(animateLine\)/);
-assert(lineMatch && /Math\.min\(Math\.floor\(elapsed\s*\/\s*33\)/.test(lineMatch[0]),
- 'drawAnimatedLine catches up on frame drops (multi-tick per frame)');
-
-const fadeMatch = src.match(/function animateFade\(now\)\s*\{[\s\S]*?requestAnimationFrame\(animateFade\)/);
-assert(fadeMatch && /Math\.min\(Math\.floor\(fadeElapsed\s*\/\s*52\)/.test(fadeMatch[0]),
- 'animateFade catches up on frame drops (multi-tick per frame)');
-
-console.log(`\n${passed} passed, ${failed} failed\n`);
-process.exit(failed ? 1 : 0);
diff --git a/test-channel-add-ux.js b/test-channel-add-ux.js
deleted file mode 100644
index 1de59009..00000000
--- a/test-channel-add-ux.js
+++ /dev/null
@@ -1,64 +0,0 @@
-/**
- * Tests for #759 β Add channel UX: button, hint, status feedback.
- * Validates the HTML structure rendered by channels.js init.
- */
-'use strict';
-
-const fs = require('fs');
-
-let passed = 0;
-let failed = 0;
-
-function assert(cond, msg) {
- if (cond) { passed++; console.log(' β ' + msg); }
- else { failed++; console.error(' β ' + msg); }
-}
-
-function assertIncludes(html, substr, msg) {
- assert(html.includes(substr), msg);
-}
-
-// Read the channels.js source to extract the HTML template
-const src = fs.readFileSync(__dirname + '/public/channels.js', 'utf8');
-
-// Extract the sidebar HTML from the template literal
-const htmlMatch = src.match(/app\.innerHTML\s*=\s*`([\s\S]*?)`;/);
-const html = htmlMatch ? htmlMatch[1] : '';
-
-console.log('Test: Add channel UX (#759)');
-
-// 1. Button renders in the form
-assertIncludes(html, 'class="ch-add-btn"', 'Add button has ch-add-btn class');
-assertIncludes(html, 'type="submit"', 'Button is type=submit');
-assertIncludes(html, '>+', 'Button shows + text');
-
-// 2. Form has proper structure
-assertIncludes(html, 'class="ch-add-form"', 'Form has ch-add-form class');
-assertIncludes(html, 'class="ch-add-row"', 'Row wrapper present');
-assert(!html.includes('class="ch-add-label"'), 'Label removed (redundant with hint)');
-
-// 3. Hint text present
-assertIncludes(html, 'class="ch-add-hint"', 'Hint div present');
-assertIncludes(html, 'e.g. #LongFast or 32-char hex key', 'Hint text correct');
-
-// 4. Status div present
-assertIncludes(html, 'id="chAddStatus"', 'Status div has correct id');
-assertIncludes(html, 'class="ch-add-status"', 'Status div has correct class');
-assertIncludes(html, 'style="display:none"', 'Status div hidden by default');
-
-// 5. showAddStatus function exists in source
-assert(src.includes('function showAddStatus('), 'showAddStatus function defined');
-assert(src.includes("'success'"), 'Success status type referenced');
-assert(src.includes("'error'"), 'Error status type referenced');
-
-// 6. CSS classes exist
-const css = fs.readFileSync(__dirname + '/public/style.css', 'utf8');
-assert(css.includes('.ch-add-form'), 'CSS: .ch-add-form defined');
-assert(css.includes('.ch-add-btn'), 'CSS: .ch-add-btn defined');
-assert(css.includes('.ch-add-hint'), 'CSS: .ch-add-hint defined');
-assert(css.includes('.ch-add-status'), 'CSS: .ch-add-status defined');
-assert(css.includes('.ch-add-row'), 'CSS: .ch-add-row defined');
-// .ch-add-label CSS kept for backward compat but label removed from HTML
-
-console.log('\n' + passed + ' passed, ' + failed + ' failed');
-process.exit(failed > 0 ? 1 : 0);
diff --git a/test-e2e-playwright.js b/test-e2e-playwright.js
index c1963964..af75e432 100644
--- a/test-e2e-playwright.js
+++ b/test-e2e-playwright.js
@@ -224,10 +224,7 @@ async function run() {
// Test 5: Node detail loads (reuses nodes page from test 2)
await test('Node detail loads', async () => {
await page.waitForSelector('table tbody tr');
- // Click first row
- const firstRow = await page.$('table tbody tr');
- assert(firstRow, 'No node rows found');
- await firstRow.click();
+ await page.click('table tbody tr');
// Wait for detail pane to appear
await page.waitForSelector('.node-detail');
const html = await page.content();
@@ -240,17 +237,14 @@ async function run() {
await test('Node side panel Details link navigates', async () => {
await page.goto(`${BASE}/#/nodes`, { waitUntil: 'domcontentloaded' });
await page.waitForSelector('table tbody tr');
- // Click first row to open side panel
- const firstRow = await page.$('table tbody tr');
- assert(firstRow, 'No node rows found');
- await firstRow.click();
+ await page.click('table tbody tr');
await page.waitForSelector('.node-detail');
// Find the Details link in the side panel
- const detailsLink = await page.$('#nodesRight a.btn-primary[href^="#/nodes/"]');
- assert(detailsLink, 'Details link not found in side panel');
- const href = await detailsLink.getAttribute('href');
+ await page.waitForSelector('#nodesRight a.btn-primary[href^="#/nodes/"]');
+ const href = await page.$eval('#nodesRight a.btn-primary[href^="#/nodes/"]', el => el.getAttribute('href'));
+ assert(href, 'Details link not found in side panel');
// Click the Details link β this should navigate to the full detail page
- await detailsLink.click();
+ await page.click('#nodesRight a.btn-primary[href^="#/nodes/"]');
// Wait for navigation β the full detail page has sections like neighbors/packets
await page.waitForFunction((expectedHash) => {
return location.hash === expectedHash;
@@ -663,6 +657,8 @@ async function run() {
await page.waitForSelector('#ngCanvas', { timeout: 8000 });
const hasCanvas = await page.$('#ngCanvas');
assert(hasCanvas, 'Neighbor Graph tab should have a canvas element');
+ // Stats are populated after the async API call β wait for at least one card before counting
+ await page.waitForSelector('#ngStats .stat-card', { timeout: 8000 });
const hasStats = await page.$$eval('#ngStats .stat-card', els => els.length);
assert(hasStats >= 3, `Neighbor Graph stats should have >=3 cards, got ${hasStats}`);
// Verify filters exist
@@ -1358,6 +1354,38 @@ async function run() {
await page.evaluate(() => localStorage.removeItem('cs-theme-overrides'));
});
+ await test('Customizer v2: typing in text field does not collapse focus (re-render guard)', async () => {
+ await page.goto(BASE, { waitUntil: 'domcontentloaded' });
+ await page.waitForSelector('nav, .navbar, .nav, [class*="nav"]');
+ await page.waitForFunction(() => window._customizerV2 && window._customizerV2.initDone, { timeout: 5000 });
+ const toggleSel = '#customizeToggle, button[title*="ustom" i], [class*="customize"]';
+ const btn = await page.$(toggleSel);
+ if (!btn) { console.log(' βοΈ Customizer toggle not found'); return; }
+ await btn.click();
+ await page.waitForSelector('.cust-overlay', { timeout: 5000 });
+ const result = await page.evaluate(() => {
+ const input = document.querySelector('.cust-overlay input[type="text"][data-cv2-field]');
+ if (!input) return { skipped: true };
+ input.focus();
+ input.value = 'test';
+ input.dispatchEvent(new Event('input', { bubbles: true }));
+ const inputRef = input;
+ return new Promise(resolve => {
+ setTimeout(() => {
+ const panel = document.querySelector('.cust-overlay');
+ resolve({
+ inputConnected: inputRef.isConnected,
+ focusInPanel: panel ? panel.contains(document.activeElement) : false,
+ });
+ }, 500);
+ });
+ });
+ if (result.skipped) { console.log(' βοΈ No text input with data-cv2-field found in panel'); return; }
+ assert(result.inputConnected, 'Input element should remain connected to DOM after debounce fires');
+ assert(result.focusInPanel, 'Focus should remain inside panel after debounce β re-render must not run while typing');
+ await page.evaluate(() => localStorage.removeItem('cs-theme-overrides'));
+ });
+
await test('Show Neighbors populates neighborPubkeys from affinity API', async () => {
const testPubkey = 'aabbccdd11223344556677889900aabbccddeeff00112233445566778899001122';
diff --git a/test-hop-resolver-affinity.js b/test-hop-resolver-affinity.js
index e09e20a6..a9ce2dda 100644
--- a/test-hop-resolver-affinity.js
+++ b/test-hop-resolver-affinity.js
@@ -22,9 +22,9 @@ function assert(condition, msg) {
// ββ Test nodes ββ
// Two nodes share the same 1-byte prefix "ab"
-const nodeA = { public_key: 'ab1111', name: 'NodeA', lat: 37.0, lon: -122.0 };
-const nodeB = { public_key: 'ab2222', name: 'NodeB', lat: 38.0, lon: -123.0 };
-const nodeC = { public_key: 'cd3333', name: 'NodeC', lat: 37.5, lon: -122.5 };
+const nodeA = { public_key: 'ab1111', name: 'NodeA', role: 'repeater', lat: 37.0, lon: -122.0 };
+const nodeB = { public_key: 'ab2222', name: 'NodeB', role: 'repeater', lat: 38.0, lon: -123.0 };
+const nodeC = { public_key: 'cd3333', name: 'NodeC', role: 'repeater', lat: 37.5, lon: -122.5 };
console.log('\n=== HopResolver Affinity Tests ===\n');
@@ -88,7 +88,7 @@ assert(result5['ab'].name === 'NodeB', 'Should pick NodeB (highest affinity 0.9)
// Test 6: Unambiguous hops are not affected by affinity
console.log('\nTest 6: Unambiguous hops unaffected by affinity');
-const nodeD = { public_key: 'ee4444', name: 'NodeD', lat: 36.0, lon: -121.0 };
+const nodeD = { public_key: 'ee4444', name: 'NodeD', role: 'repeater', lat: 36.0, lon: -121.0 };
HopResolver.init([nodeA, nodeB, nodeC, nodeD]);
HopResolver.setAffinity({ edges: [] });
const result6 = HopResolver.resolve(['ee44'], null, null, null, null, null);
@@ -97,9 +97,9 @@ assert(!result6['ee44'].ambiguous, 'Should not be marked ambiguous');
// Test 7: lat=0 / lon=0 candidates are NOT excluded (equator/prime-meridian bug fix)
console.log('\nTest 7: lat=0 / lon=0 candidates are included in geo scoring');
-const nodeEquator = { public_key: 'ab5555', name: 'EquatorNode', lat: 0, lon: 10 };
-const nodeFar = { public_key: 'ab6666', name: 'FarNode', lat: 60, lon: 60 };
-const anchorNearEq = { public_key: 'cd7777', name: 'AnchorEq', lat: 1, lon: 11 };
+const nodeEquator = { public_key: 'ab5555', name: 'EquatorNode', role: 'repeater', lat: 0, lon: 10 };
+const nodeFar = { public_key: 'ab6666', name: 'FarNode', role: 'repeater', lat: 60, lon: 60 };
+const anchorNearEq = { public_key: 'cd7777', name: 'AnchorEq', role: 'repeater', lat: 1, lon: 11 };
HopResolver.init([nodeEquator, nodeFar, anchorNearEq]);
HopResolver.setAffinity({});
// Anchor near equator β EquatorNode (0,10) should be geo-closest
@@ -109,13 +109,44 @@ assert(result7['ab'].name === 'EquatorNode',
// Test 8: lon=0 candidate is also included
console.log('\nTest 8: lon=0 candidate is included in geo scoring');
-const nodePrime = { public_key: 'ab8888', name: 'PrimeMeridian', lat: 10, lon: 0 };
-const anchorNearPM = { public_key: 'cd9999', name: 'AnchorPM', lat: 11, lon: 1 };
+const nodePrime = { public_key: 'ab8888', name: 'PrimeMeridian', role: 'repeater', lat: 10, lon: 0 };
+const anchorNearPM = { public_key: 'cd9999', name: 'AnchorPM', role: 'repeater', lat: 11, lon: 1 };
HopResolver.init([nodePrime, nodeFar, anchorNearPM]);
HopResolver.setAffinity({});
const result8 = HopResolver.resolve(['cd99', 'ab'], 11.0, 1.0, null, null, null);
assert(result8['ab'].name === 'PrimeMeridian',
'lon=0 candidate should be included and win by geo β got: ' + result8['ab'].name);
+// ββ Role filter tests (#935) ββ
+console.log('\nTest: Role filter β companions excluded from prefixIdx');
+const companion = { public_key: 'ab9999', name: 'Companion1', role: 'companion', lat: 37.0, lon: -122.0 };
+const sensor = { public_key: 'ab7777', name: 'Sensor1', role: 'sensor', lat: 37.0, lon: -122.0 };
+const repeater = { public_key: 'ab1234', name: 'Repeater1', role: 'repeater', lat: 37.0, lon: -122.0 };
+const roomSrv = { public_key: 'ff1234', name: 'RoomSrv1', role: 'room_server', lat: 37.0, lon: -122.0 };
+
+HopResolver.init([companion, sensor, repeater, roomSrv]);
+HopResolver.setAffinity({});
+
+// Prefix 'ab' should only resolve to repeater (companion/sensor excluded)
+const r1 = HopResolver.resolve(['ab12'], 0, 0, null, null, null);
+assert(r1['ab12'] && r1['ab12'].name === 'Repeater1',
+ 'prefix ab12 resolves to Repeater1 not companion β got: ' + (r1['ab12'] && r1['ab12'].name));
+
+// Prefix 'ff' should resolve to room_server
+const r2 = HopResolver.resolve(['ff12'], 0, 0, null, null, null);
+assert(r2['ff12'] && r2['ff12'].name === 'RoomSrv1',
+ 'prefix ff12 resolves to RoomSrv1 β got: ' + (r2['ff12'] && r2['ff12'].name));
+
+// Prefix that only matches companion should return nothing
+const r3 = HopResolver.resolve(['ab99'], 0, 0, null, null, null);
+assert(!r3['ab99'] || !r3['ab99'].name,
+ 'prefix ab99 (companion only) resolves to nothing β got: ' + (r3['ab99'] && r3['ab99'].name));
+
+// pubkeyIdx should still have companion (full pubkey lookup)
+console.log('\nTest: pubkeyIdx still includes all roles');
+const fromServer = HopResolver.resolveFromServer(['ab99'], [companion.public_key]);
+assert(fromServer['ab99'] && fromServer['ab99'].name === 'Companion1',
+ 'resolveFromServer finds companion by full pubkey β got: ' + (fromServer['ab99'] && fromServer['ab99'].name));
+
console.log('\n' + (passed + failed) + ' tests, ' + passed + ' passed, ' + failed + ' failed\n');
process.exit(failed > 0 ? 1 : 0);
diff --git a/test-packets.js b/test-packets.js
index 66b6e36c..bce63307 100644
--- a/test-packets.js
+++ b/test-packets.js
@@ -844,6 +844,120 @@ console.log('\n=== packets.js: _invalidateRowCounts / _refreshRowCountsIfDirty (
});
}
+console.log('\n=== packets.js: buildPacketsParams ===');
+{
+ const ctx = loadPacketsSandbox();
+ const api = ctx._packetsTestAPI;
+ assert(typeof api.buildPacketsParams === 'function', 'buildPacketsParams must be exported');
+
+ test('hash filter suppresses region β direct hash links work regardless of saved region', () => {
+ // This is the bug from URL https://analyzer.../#/packets?hash=178525e9f693aa7e
+ // when the user's saved RegionFilter excludes the packet's observer region.
+ // The hash is an exact identifier; ALL other filters must be ignored.
+ const p = api.buildPacketsParams({
+ filters: { hash: 'abc123' },
+ regionParam: 'SJC,SFO,OAK,MRY',
+ windowMin: 60,
+ groupByHash: false,
+ limit: 200,
+ });
+ assert.strictEqual(p.get('hash'), 'abc123');
+ assert.strictEqual(p.get('region'), null, 'region must NOT be set when hash is present');
+ assert.strictEqual(p.get('since'), null, 'since must NOT be set when hash is present');
+ });
+
+ test('hash filter suppresses ALL other filters β observer, node, channel too', () => {
+ const p = api.buildPacketsParams({
+ filters: { hash: 'h', node: 'n', observer: 'o', channel: 'c' },
+ regionParam: 'SJC',
+ windowMin: 60,
+ groupByHash: false,
+ limit: 200,
+ });
+ assert.strictEqual(p.get('hash'), 'h');
+ assert.strictEqual(p.get('node'), null);
+ assert.strictEqual(p.get('observer'), null);
+ assert.strictEqual(p.get('channel'), null);
+ assert.strictEqual(p.get('region'), null);
+ assert.strictEqual(p.get('since'), null);
+ });
+
+ test('hash filter suppresses region with default windowMin=0', () => {
+ const p = api.buildPacketsParams({
+ filters: { hash: 'deadbeef' },
+ regionParam: 'COA',
+ windowMin: 0,
+ groupByHash: false,
+ limit: 50,
+ });
+ assert.strictEqual(p.get('hash'), 'deadbeef');
+ assert.strictEqual(p.get('region'), null);
+ });
+
+ test('region applied normally when hash filter is absent', () => {
+ const p = api.buildPacketsParams({
+ filters: {},
+ regionParam: 'SJC,SFO',
+ windowMin: 60,
+ groupByHash: false,
+ limit: 200,
+ });
+ assert.strictEqual(p.get('region'), 'SJC,SFO', 'region must apply when no hash');
+ assert.strictEqual(p.get('hash'), null);
+ assert(p.get('since'), 'since must apply when no hash and windowMin>0');
+ });
+
+ test('observer/node/channel pass through normally when no hash', () => {
+ const p = api.buildPacketsParams({
+ filters: { observer: 'obs1', node: 'node1', channel: '#test' },
+ regionParam: '',
+ windowMin: 0,
+ groupByHash: false,
+ limit: 50,
+ });
+ assert.strictEqual(p.get('observer'), 'obs1');
+ assert.strictEqual(p.get('node'), 'node1');
+ assert.strictEqual(p.get('channel'), '#test');
+ });
+
+ test('region absent when regionParam empty β no spurious empty region= param', () => {
+ const p = api.buildPacketsParams({
+ filters: {},
+ regionParam: '',
+ windowMin: 0,
+ groupByHash: false,
+ limit: 50,
+ });
+ assert.strictEqual(p.get('region'), null);
+ });
+
+ test('groupByHash=true with hash sets groupByHash and omits expand', () => {
+ const p = api.buildPacketsParams({
+ filters: { hash: 'h' }, regionParam: '', windowMin: 0, groupByHash: true, limit: 50,
+ });
+ assert.strictEqual(p.get('groupByHash'), 'true');
+ assert.strictEqual(p.get('expand'), null);
+ assert.strictEqual(p.get('hash'), 'h');
+ });
+
+ test('groupByHash=false with hash sets expand=observations', () => {
+ const p = api.buildPacketsParams({
+ filters: { hash: 'h' }, regionParam: '', windowMin: 0, groupByHash: false, limit: 50,
+ });
+ assert.strictEqual(p.get('expand'), 'observations');
+ assert.strictEqual(p.get('groupByHash'), null);
+ assert.strictEqual(p.get('hash'), 'h');
+ });
+
+ test('groupByHash=false without hash sets expand=observations', () => {
+ const p = api.buildPacketsParams({
+ filters: {}, regionParam: '', windowMin: 0, groupByHash: false, limit: 50,
+ });
+ assert.strictEqual(p.get('expand'), 'observations');
+ assert.strictEqual(p.get('groupByHash'), null);
+ });
+}
+
// ===== SUMMARY =====
console.log(`\n${'='.repeat(40)}`);
console.log(`packets.js tests: ${passed} passed, ${failed} failed`);
diff --git a/test-path-inspector-e2e.js b/test-path-inspector-e2e.js
new file mode 100644
index 00000000..ddf16c45
--- /dev/null
+++ b/test-path-inspector-e2e.js
@@ -0,0 +1,87 @@
+// E2E tests for Path Inspector (spec Β§5 β Playwright).
+// Run: npx playwright test test-path-inspector-e2e.js
+// Requires: running server on BASE_URL (default http://localhost:3000).
+'use strict';
+
+const { test, expect } = require('@playwright/test');
+const BASE_URL = process.env.BASE_URL || 'http://localhost:3000';
+
+test.describe('Path Inspector β Map Side Pane (spec Β§2.7)', () => {
+ test('side pane present and collapsed by default', async ({ page }) => {
+ await page.goto(`${BASE_URL}/#/map`);
+ const pane = page.locator('#mapSidePane');
+ await expect(pane).toBeVisible();
+ await expect(pane).not.toHaveClass(/expanded/);
+ });
+
+ test('click toggle expands the pane', async ({ page }) => {
+ await page.goto(`${BASE_URL}/#/map`);
+ await page.click('#mapPaneToggle');
+ const pane = page.locator('#mapSidePane');
+ await expect(pane).toHaveClass(/expanded/);
+ });
+
+ test('submit valid prefixes renders candidates within 1s', async ({ page }) => {
+ await page.goto(`${BASE_URL}/#/map`);
+ await page.click('#mapPaneToggle');
+ await page.fill('#mapPiInput', '2c,a1,f4');
+ await page.click('#mapPiSubmit');
+ // Wait for results or error (both indicate API round-trip complete).
+ await expect(page.locator('#mapPiResults table, #mapPiResults .no-results, #mapPiError')).toBeVisible({ timeout: 1000 });
+ });
+
+ test('Show on Map button draws polyline on map', async ({ page }) => {
+ await page.goto(`${BASE_URL}/#/map`);
+ await page.click('#mapPaneToggle');
+ await page.fill('#mapPiInput', '2c,a1');
+ await page.click('#mapPiSubmit');
+ // Wait for results.
+ const btn = page.locator('#mapPiResults button[data-idx="0"]');
+ await btn.waitFor({ timeout: 2000 });
+ await btn.click();
+ // Check that route layer has SVG polyline paths drawn.
+ const svg = page.locator('#leaflet-map .leaflet-overlay-pane svg path');
+ await expect(svg.first()).toBeVisible({ timeout: 2000 });
+ });
+
+ test('switching candidate clears prior polyline', async ({ page }) => {
+ await page.goto(`${BASE_URL}/#/map`);
+ await page.click('#mapPaneToggle');
+ await page.fill('#mapPiInput', '2c,a1');
+ await page.click('#mapPiSubmit');
+ const btn0 = page.locator('#mapPiResults button[data-idx="0"]');
+ await btn0.waitFor({ timeout: 2000 });
+ await btn0.click();
+ // Click second candidate if available.
+ const btn1 = page.locator('#mapPiResults button[data-idx="1"]');
+ if (await btn1.isVisible()) {
+ await btn1.click();
+ // Prior route should be cleared β only one polyline group visible.
+ }
+ });
+});
+
+test.describe('Path Inspector β Standalone Page', () => {
+ test('deep link auto-fills and runs', async ({ page }) => {
+ await page.goto(`${BASE_URL}/#/tools/path-inspector?prefixes=2c,a1,f4`);
+ const input = page.locator('#path-inspector-input');
+ await expect(input).toHaveValue('2c,a1,f4');
+ // Should auto-submit and show results or error.
+ await expect(page.locator('#path-inspector-results table, #path-inspector-results .no-results, #path-inspector-error')).toBeVisible({ timeout: 2000 });
+ });
+
+ test('old #/traces/
redirects to #/tools/trace/', async ({ page }) => {
+ await page.goto(`${BASE_URL}/#/traces/abc123`);
+ await page.waitForTimeout(500);
+ expect(page.url()).toContain('#/tools/trace/abc123');
+ });
+});
+
+test.describe('Path Inspector β Tools Landing (spec Β§2.8)', () => {
+ test('Tools nav shows landing with both entries', async ({ page }) => {
+ await page.goto(`${BASE_URL}/#/tools`);
+ await expect(page.locator('.tools-landing')).toBeVisible();
+ await expect(page.locator('a[href="#/tools/path-inspector"]')).toBeVisible();
+ await expect(page.locator('a[href*="#/tools/trace"]')).toBeVisible();
+ });
+});
diff --git a/test-path-inspector.js b/test-path-inspector.js
new file mode 100644
index 00000000..3d818b85
--- /dev/null
+++ b/test-path-inspector.js
@@ -0,0 +1,106 @@
+// test-path-inspector.js β vm.createContext sandbox tests for path-inspector.js
+'use strict';
+const vm = require('vm');
+const fs = require('fs');
+const assert = require('assert');
+
+const src = fs.readFileSync(__dirname + '/public/path-inspector.js', 'utf8');
+
+function createSandbox() {
+ const sandbox = {
+ window: {},
+ document: {
+ getElementById: () => ({ textContent: '', innerHTML: '', addEventListener: () => {}, querySelectorAll: () => [] }),
+ querySelectorAll: () => []
+ },
+ location: { hash: '#/tools/path-inspector' },
+ history: { replaceState: () => {} },
+ fetch: () => Promise.resolve({ ok: true, json: () => Promise.resolve({ candidates: [] }) }),
+ URLSearchParams: URLSearchParams,
+ registerPage: function () {},
+ escapeHtml: s => s,
+ console: console
+ };
+ sandbox.self = sandbox;
+ sandbox.globalThis = sandbox;
+ const ctx = vm.createContext(sandbox);
+ vm.runInContext(src, ctx);
+ return sandbox;
+}
+
+// Test: parsePrefixes accepts comma-separated.
+(function testParseComma() {
+ const sb = createSandbox();
+ const result = sb.window.PathInspector.parsePrefixes('2C,A1,F4');
+ assert.strictEqual(JSON.stringify(result), JSON.stringify(['2c', 'a1', 'f4']));
+ console.log('β parsePrefixes comma-separated');
+})();
+
+// Test: parsePrefixes accepts space-separated.
+(function testParseSpace() {
+ const sb = createSandbox();
+ const result = sb.window.PathInspector.parsePrefixes('2C A1 F4');
+ assert.strictEqual(JSON.stringify(result), JSON.stringify(['2c', 'a1', 'f4']));
+ console.log('β parsePrefixes space-separated');
+})();
+
+// Test: parsePrefixes accepts mixed.
+(function testParseMixed() {
+ const sb = createSandbox();
+ const result = sb.window.PathInspector.parsePrefixes(' 2C, A1 F4 ');
+ assert.strictEqual(JSON.stringify(result), JSON.stringify(['2c', 'a1', 'f4']));
+ console.log('β parsePrefixes mixed separators');
+})();
+
+// Test: validatePrefixes rejects empty.
+(function testValidateEmpty() {
+ const sb = createSandbox();
+ const err = sb.window.PathInspector.validatePrefixes([]);
+ assert.ok(err !== null, 'should reject empty');
+ console.log('β validatePrefixes rejects empty');
+})();
+
+// Test: validatePrefixes rejects odd-length.
+(function testValidateOdd() {
+ const sb = createSandbox();
+ const err = sb.window.PathInspector.validatePrefixes(['abc']);
+ assert.ok(err !== null && err.includes('Odd'), 'should reject odd-length');
+ console.log('β validatePrefixes rejects odd-length');
+})();
+
+// Test: validatePrefixes rejects >3 bytes.
+(function testValidateTooLong() {
+ const sb = createSandbox();
+ const err = sb.window.PathInspector.validatePrefixes(['aabbccdd']);
+ assert.ok(err !== null && err.includes('too long'), 'should reject >3 bytes');
+ console.log('β validatePrefixes rejects >3 bytes');
+})();
+
+// Test: validatePrefixes rejects mixed lengths.
+(function testValidateMixed() {
+ const sb = createSandbox();
+ const err = sb.window.PathInspector.validatePrefixes(['aa', 'bbcc']);
+ assert.ok(err !== null && err.includes('Mixed'), 'should reject mixed');
+ console.log('β validatePrefixes rejects mixed lengths');
+})();
+
+// Test: validatePrefixes accepts valid input.
+(function testValidateValid() {
+ const sb = createSandbox();
+ const err = sb.window.PathInspector.validatePrefixes(['2c', 'a1', 'f4']);
+ assert.strictEqual(err, null);
+ console.log('β validatePrefixes accepts valid');
+})();
+
+// Test: validatePrefixes rejects invalid hex.
+(function testValidateInvalidHex() {
+ const sb = createSandbox();
+ const err = sb.window.PathInspector.validatePrefixes(['zz']);
+ assert.ok(err !== null && err.includes('Invalid hex'), 'should reject invalid hex');
+ console.log('β validatePrefixes rejects invalid hex');
+})();
+
+// Anti-tautology: if validation were removed (always return null), the odd-length test would fail.
+// Mental revert: validatePrefixes = () => null; β testValidateOdd would fail because err would be null.
+
+console.log('\nAll path-inspector tests passed!');
diff --git a/tools/geofilter-builder.html b/tools/geofilter-builder.html
index addb7e69..93beab8e 100644
--- a/tools/geofilter-builder.html
+++ b/tools/geofilter-builder.html
@@ -72,7 +72,8 @@ let polygon = null;
let closingLine = null;
function latLonPair(latlng) {
- return [parseFloat(latlng.lat.toFixed(6)), parseFloat(latlng.lng.toFixed(6))];
+ const w = latlng.wrap();
+ return [parseFloat(w.lat.toFixed(6)), parseFloat(w.lng.toFixed(6))];
}
function render() {