feat: implement packet store eviction/aging to prevent OOM (#273)

## Summary

The in-memory `PacketStore` had **no eviction or aging** — it grew
unbounded until OOM killed the process. At ~3K packets/hour and ~5KB per
packet (not the 450 bytes previously estimated), an 8GB VM would OOM in
a few days.

## Changes

### Time-based eviction
- Configurable via `config.json`: `"packetStore": { "retentionHours": 24
}`
- Packets older than the retention window are evicted from the head of
the sorted slice

### Memory-based cap
- Configurable via `"packetStore": { "maxMemoryMB": 1024 }`
- Hard ceiling — evicts oldest packets when estimated memory exceeds the
cap

### Index cleanup
When a `StoreTx` is evicted, ALL associated data is removed from:
- `byHash`, `byTxID`, `byObsID`, `byObserver`, `byNode`, `byPayloadType`
- `nodeHashes`, `distHops`, `distPaths`, `spIndex`

### Periodic execution
- Background ticker runs eviction every 60 seconds
- Analytics caches and hash size cache are invalidated after eviction

### Stats fixes
- `estimatedMB` now uses ~5KB/packet + ~500B/observation (was 430B +
200B)
- `evicted` counter reflects actual evictions (was hardcoded to 0)
- Removed fake `maxPackets: 2386092` and `maxMB: 1024` from stats

### Config example
```json
{
  "packetStore": {
    "retentionHours": 24,
    "maxMemoryMB": 1024
  }
}
```

Both values default to 0 (unlimited) for backward compatibility.

## Tests
- 7 new tests in `eviction_test.go` covering time-based, memory-based,
index cleanup, thread safety, config parsing, and no-op when disabled
- All existing tests pass unchanged

Co-authored-by: Kpa-clawbot <kpabap+clawdbot@gmail.com>

.badges/backend-coverage.json

@@ -1 +0,0 @@
-{"schemaVersion":1,"label":"backend coverage","message":"87.79%","color":"brightgreen"}

.badges/backend-tests.json

@@ -1 +0,0 @@
-{"schemaVersion":1,"label":"backend tests","message":"998 passed","color":"brightgreen"}

.badges/coverage.json

@@ -1 +0,0 @@
-{"schemaVersion":1,"label":"coverage","message":"76%","color":"yellow"}

.badges/e2e-tests.json

@@ -0,0 +1 @@
+{"schemaVersion":1,"label":"e2e tests","message":"45 passed","color":"brightgreen"}

.badges/frontend-coverage.json

@@ -1 +1 @@
-{"schemaVersion":1,"label":"frontend coverage","message":"31.35%","color":"red"}
+{"schemaVersion":1,"label":"frontend coverage","message":"39.68%","color":"red"}

.badges/go-ingestor-coverage.json

@@ -0,0 +1 @@
+{"schemaVersion":1,"label":"go ingestor coverage","message":"70.2%","color":"yellow"}

.badges/go-server-coverage.json

@@ -0,0 +1 @@
+{"schemaVersion":1,"label":"go server coverage","message":"85.4%","color":"green"}

.badges/tests.json

@@ -1 +0,0 @@
-{"schemaVersion":1,"label":"tests","message":"844/844 passed","color":"brightgreen"}

.gitattributes

@@ -0,0 +1,5 @@
+# Squad: union merge for append-only team state files
+.squad/decisions.md merge=union
+.squad/agents/*/history.md merge=union
+.squad/log/** merge=union
+.squad/orchestration-log/** merge=union

.github/workflows/deploy.yml

@@ -1,50 +1,43 @@
-name: Deploy
+name: CI/CD Pipeline
 
 on:
   push:
     branches: [master]
-    paths-ignore:
-      - '**.md'
-      - 'LICENSE'
-      - '.gitignore'
-      - 'docs/**'
   pull_request:
     branches: [master]
-    paths-ignore:
-      - '**.md'
-      - 'LICENSE'
-      - '.gitignore'
-      - 'docs/**'
 
 concurrency:
-  group: deploy
+  group: ci-${{ github.event.pull_request.number || github.ref }}
   cancel-in-progress: true
 
 env:
   FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
+  STAGING_COMPOSE_FILE: docker-compose.staging.yml
+  STAGING_SERVICE: staging-go
+  STAGING_CONTAINER: corescope-staging-go
 
-# Pipeline:
-#   node-test (frontend tests) ──┐
-#   go-test                      ├──→ build → deploy → publish
-#                                └─ (both wait)
-#
-# Proto validation flow:
-#   1. go-test job: verify .proto files compile (syntax check)
-#   2. deploy job: capture fresh fixtures from prod, validate protos match actual API responses
+# Pipeline (sequential, fail-fast):
+#   go-test → e2e-test → build → deploy → publish
+#   PRs stop after build. Master continues to deploy + publish.
 
 jobs:
   # ───────────────────────────────────────────────────────────────
-  # 1. Go Build & Test — compiles + tests Go modules, coverage badges
+  # 1. Go Build & Test
   # ───────────────────────────────────────────────────────────────
   go-test:
     name: "✅ Go Build & Test"
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Clean Go module cache
+        run: rm -rf ~/go/pkg/mod 2>/dev/null || true
 
       - name: Set up Go 1.22
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
         with:
           go-version: '1.22'
           cache-dependency-path: |
@@ -69,14 +62,11 @@ jobs:
           echo "--- Go Ingestor Coverage ---"
           go tool cover -func=ingestor-coverage.out | tail -1
 
-      - name: Verify proto syntax (all .proto files compile)
+      - name: Verify proto syntax
         run: |
           set -e
-          echo "Installing protoc..."
           sudo apt-get update -qq
           sudo apt-get install -y protobuf-compiler
-          
-          echo "Checking proto syntax..."
           for proto in proto/*.proto; do
             echo "  ✓ $(basename "$proto")"
             protoc --proto_path=proto --descriptor_set_out=/dev/null "$proto"
@@ -84,37 +74,27 @@ jobs:
           echo "✅ All .proto files are syntactically valid"
 
       - name: Generate Go coverage badges
-        if: always()
+        if: success()
         run: |
           mkdir -p .badges
 
-          # Parse server coverage
           SERVER_COV="0"
           if [ -f cmd/server/server-coverage.out ]; then
             SERVER_COV=$(cd cmd/server && go tool cover -func=server-coverage.out | tail -1 | grep -oP '[\d.]+(?=%)')
           fi
           SERVER_COLOR="red"
-          if [ "$(echo "$SERVER_COV >= 80" | bc -l 2>/dev/null)" = "1" ]; then
-            SERVER_COLOR="green"
-          elif [ "$(echo "$SERVER_COV >= 60" | bc -l 2>/dev/null)" = "1" ]; then
-            SERVER_COLOR="yellow"
-          fi
+          if [ "$(echo "$SERVER_COV >= 80" | bc -l 2>/dev/null)" = "1" ]; then SERVER_COLOR="green"
+          elif [ "$(echo "$SERVER_COV >= 60" | bc -l 2>/dev/null)" = "1" ]; then SERVER_COLOR="yellow"; fi
           echo "{\"schemaVersion\":1,\"label\":\"go server coverage\",\"message\":\"${SERVER_COV}%\",\"color\":\"${SERVER_COLOR}\"}" > .badges/go-server-coverage.json
-          echo "Go server coverage: ${SERVER_COV}% (${SERVER_COLOR})"
 
-          # Parse ingestor coverage
           INGESTOR_COV="0"
           if [ -f cmd/ingestor/ingestor-coverage.out ]; then
             INGESTOR_COV=$(cd cmd/ingestor && go tool cover -func=ingestor-coverage.out | tail -1 | grep -oP '[\d.]+(?=%)')
           fi
           INGESTOR_COLOR="red"
-          if [ "$(echo "$INGESTOR_COV >= 80" | bc -l 2>/dev/null)" = "1" ]; then
-            INGESTOR_COLOR="green"
-          elif [ "$(echo "$INGESTOR_COV >= 60" | bc -l 2>/dev/null)" = "1" ]; then
-            INGESTOR_COLOR="yellow"
-          fi
+          if [ "$(echo "$INGESTOR_COV >= 80" | bc -l 2>/dev/null)" = "1" ]; then INGESTOR_COLOR="green"
+          elif [ "$(echo "$INGESTOR_COV >= 60" | bc -l 2>/dev/null)" = "1" ]; then INGESTOR_COLOR="yellow"; fi
           echo "{\"schemaVersion\":1,\"label\":\"go ingestor coverage\",\"message\":\"${INGESTOR_COV}%\",\"color\":\"${INGESTOR_COLOR}\"}" > .badges/go-ingestor-coverage.json
-          echo "Go ingestor coverage: ${INGESTOR_COV}% (${INGESTOR_COLOR})"
 
           echo "## Go Coverage" >> $GITHUB_STEP_SUMMARY
           echo "| Module | Coverage |" >> $GITHUB_STEP_SUMMARY
@@ -123,89 +103,68 @@ jobs:
           echo "| Ingestor | ${INGESTOR_COV}% |" >> $GITHUB_STEP_SUMMARY
 
       - name: Upload Go coverage badges
-        if: always()
-        uses: actions/upload-artifact@v4
+        if: success()
+        uses: actions/upload-artifact@v6
         with:
           name: go-badges
           path: .badges/go-*.json
           retention-days: 1
           if-no-files-found: ignore
+          include-hidden-files: true
 
   # ───────────────────────────────────────────────────────────────
-  # 2. Node.js Tests — backend unit tests + Playwright E2E, coverage
+  # 2. Playwright E2E Tests (against Go server with fixture DB)
   # ───────────────────────────────────────────────────────────────
-  node-test:
-    name: "🧪 Node.js Tests"
-    runs-on: self-hosted
+  e2e-test:
+    name: "🎭 Playwright E2E Tests"
+    needs: [go-test]
+    runs-on: [self-hosted, Linux]
+    defaults:
+      run:
+        shell: bash
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
-          fetch-depth: 2
+          fetch-depth: 0
 
       - name: Set up Node.js 22
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v5
         with:
           node-version: '22'
 
+      - name: Clean Go module cache
+        run: rm -rf ~/go/pkg/mod 2>/dev/null || true
+
+      - name: Set up Go 1.22
+        uses: actions/setup-go@v6
+        with:
+          go-version: '1.22'
+          cache-dependency-path: cmd/server/go.sum
+
+      - name: Build Go server
+        run: |
+          cd cmd/server
+          go build -o ../../corescope-server .
+          echo "Go server built successfully"
+
       - name: Install npm dependencies
         run: npm ci --production=false
 
-      - name: Detect changed files
-        id: changes
-        run: |
-          BACKEND=$(git diff --name-only HEAD~1 | grep -cE '^(server|db|decoder|packet-store|server-helpers|iata-coords)\.js$' || true)
-          FRONTEND=$(git diff --name-only HEAD~1 | grep -cE '^public/' || true)
-          TESTS=$(git diff --name-only HEAD~1 | grep -cE '^test-|^tools/' || true)
-          CI=$(git diff --name-only HEAD~1 | grep -cE '\.github/|package\.json|test-all\.sh|scripts/' || true)
-          # If CI/test infra changed, run everything
-          if [ "$CI" -gt 0 ]; then BACKEND=1; FRONTEND=1; fi
-          # If test files changed, run everything
-          if [ "$TESTS" -gt 0 ]; then BACKEND=1; FRONTEND=1; fi
-          echo "backend=$([[ $BACKEND -gt 0 ]] && echo true || echo false)" >> $GITHUB_OUTPUT
-          echo "frontend=$([[ $FRONTEND -gt 0 ]] && echo true || echo false)" >> $GITHUB_OUTPUT
-          echo "Changes: backend=$BACKEND frontend=$FRONTEND tests=$TESTS ci=$CI"
-
-      - name: Run backend tests with coverage
-        if: steps.changes.outputs.backend == 'true'
-        run: |
-          npx c8 --reporter=text-summary --reporter=text sh test-all.sh 2>&1 | tee test-output.txt
-          
-          TOTAL_PASS=$(grep -oP '\d+(?= passed)' test-output.txt | awk '{s+=$1} END {print s}')
-          TOTAL_FAIL=$(grep -oP '\d+(?= failed)' test-output.txt | awk '{s+=$1} END {print s}')
-          BE_COVERAGE=$(grep 'Statements' test-output.txt | tail -1 | grep -oP '[\d.]+(?=%)')
-          
-          mkdir -p .badges
-          BE_COLOR="red"
-          [ "$(echo "$BE_COVERAGE > 60" | bc -l 2>/dev/null)" = "1" ] && BE_COLOR="yellow"
-          [ "$(echo "$BE_COVERAGE > 80" | bc -l 2>/dev/null)" = "1" ] && BE_COLOR="brightgreen"
-          echo "{\"schemaVersion\":1,\"label\":\"backend tests\",\"message\":\"${TOTAL_PASS} passed\",\"color\":\"brightgreen\"}" > .badges/backend-tests.json
-          echo "{\"schemaVersion\":1,\"label\":\"backend coverage\",\"message\":\"${BE_COVERAGE}%\",\"color\":\"${BE_COLOR}\"}" > .badges/backend-coverage.json
-          
-          echo "## Backend: ${TOTAL_PASS} tests, ${BE_COVERAGE}% coverage" >> $GITHUB_STEP_SUMMARY
-
-      - name: Run backend tests (quick, no coverage)
-        if: steps.changes.outputs.backend == 'false'
-        run: npm run test:unit
-
       - name: Install Playwright browser
-        if: steps.changes.outputs.frontend == 'true'
-        run: npx playwright install chromium --with-deps 2>/dev/null || true
+        run: |
+          npx playwright install chromium 2>/dev/null || true
+          npx playwright install-deps chromium 2>/dev/null || true
 
       - name: Instrument frontend JS for coverage
-        if: steps.changes.outputs.frontend == 'true'
         run: sh scripts/instrument-frontend.sh
 
-      - name: Start instrumented test server on port 13581
-        if: steps.changes.outputs.frontend == 'true'
+      - name: Start Go server with fixture DB
         run: |
-          # Kill any stale server on 13581
           fuser -k 13581/tcp 2>/dev/null || true
-          sleep 2
-          COVERAGE=1 PORT=13581 node server.js &
+          sleep 1
+          ./corescope-server -port 13581 -db test-fixtures/e2e-fixture.db -public public-instrumented &
           echo $! > .server.pid
-          echo "Server PID: $(cat .server.pid)"
-          # Health-check poll loop (up to 30s)
           for i in $(seq 1 30); do
             if curl -sf http://localhost:13581/api/stats > /dev/null 2>&1; then
               echo "Server ready after ${i}s"
@@ -213,26 +172,27 @@ jobs:
             fi
             if [ "$i" -eq 30 ]; then
               echo "Server failed to start within 30s"
-              echo "Last few lines from server logs:"
-              ps aux | grep "PORT=13581" || echo "No server process found"
               exit 1
             fi
             sleep 1
           done
 
-      - name: Run Playwright E2E tests
-        if: steps.changes.outputs.frontend == 'true'
-        run: BASE_URL=http://localhost:13581 node test-e2e-playwright.js 2>&1 | tee e2e-output.txt
-
-      - name: Collect frontend coverage report
-        if: always() && steps.changes.outputs.frontend == 'true'
+      - name: Run Playwright E2E tests (fail-fast)
         run: |
-          BASE_URL=http://localhost:13581 node scripts/collect-frontend-coverage.js 2>&1 | tee fe-coverage-output.txt
-          
-          E2E_PASS=$(grep -oP '[0-9]+(?=/)' e2e-output.txt | tail -1)
-          
+          BASE_URL=http://localhost:13581 node test-e2e-playwright.js 2>&1 | tee e2e-output.txt
+
+      - name: Collect frontend coverage (parallel)
+        if: success() && github.event_name == 'push'
+        run: |
+          BASE_URL=http://localhost:13581 node scripts/collect-frontend-coverage.js 2>&1 | tee fe-coverage-output.txt || true
+
+      - name: Generate frontend coverage badges
+        if: success()
+        run: |
+          E2E_PASS=$(grep -oP '[0-9]+(?=/)' e2e-output.txt | tail -1 || echo "0")
+
           mkdir -p .badges
-          if [ -f .nyc_output/frontend-coverage.json ]; then
+          if [ -f .nyc_output/frontend-coverage.json ] || [ -f .nyc_output/e2e-coverage.json ]; then
             npx nyc report --reporter=text-summary --reporter=text 2>&1 | tee fe-report.txt
             FE_COVERAGE=$(grep 'Statements' fe-report.txt | head -1 | grep -oP '[\d.]+(?=%)' || echo "0")
             FE_COVERAGE=${FE_COVERAGE:-0}
@@ -242,50 +202,39 @@ jobs:
             echo "{\"schemaVersion\":1,\"label\":\"frontend coverage\",\"message\":\"${FE_COVERAGE}%\",\"color\":\"${FE_COLOR}\"}" > .badges/frontend-coverage.json
             echo "## Frontend: ${FE_COVERAGE}% coverage" >> $GITHUB_STEP_SUMMARY
           fi
-          echo "{\"schemaVersion\":1,\"label\":\"frontend tests\",\"message\":\"${E2E_PASS:-0} E2E passed\",\"color\":\"brightgreen\"}" > .badges/frontend-tests.json
+          echo "{\"schemaVersion\":1,\"label\":\"e2e tests\",\"message\":\"${E2E_PASS:-0} passed\",\"color\":\"brightgreen\"}" > .badges/e2e-tests.json
 
       - name: Stop test server
-        if: always() && steps.changes.outputs.frontend == 'true'
+        if: always()
         run: |
           if [ -f .server.pid ]; then
             kill $(cat .server.pid) 2>/dev/null || true
             rm -f .server.pid
-            echo "Server stopped"
           fi
 
-      - name: Run frontend E2E (quick, no coverage)
-        if: steps.changes.outputs.frontend == 'false'
-        run: |
-          fuser -k 13581/tcp 2>/dev/null || true
-          PORT=13581 node server.js &
-          SERVER_PID=$!
-          sleep 5
-          BASE_URL=http://localhost:13581 node test-e2e-playwright.js || true
-          kill $SERVER_PID 2>/dev/null || true
-
-      - name: Upload Node.js test badges
-        if: always()
-        uses: actions/upload-artifact@v4
+      - name: Upload E2E badges
+        if: success()
+        uses: actions/upload-artifact@v6
         with:
-          name: node-badges
+          name: e2e-badges
           path: .badges/
           retention-days: 1
           if-no-files-found: ignore
+          include-hidden-files: true
 
   # ───────────────────────────────────────────────────────────────
   # 3. Build Docker Image
   # ───────────────────────────────────────────────────────────────
   build:
     name: "🏗️ Build Docker Image"
-    if: github.event_name == 'push'
-    needs: [go-test]
-    runs-on: self-hosted
+    needs: [e2e-test]
+    runs-on: [self-hosted, Linux]
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Set up Node.js 22
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v5
         with:
           node-version: '22'
 
@@ -294,28 +243,49 @@ jobs:
           echo "${GITHUB_SHA::7}" > .git-commit
           APP_VERSION=$(node -p "require('./package.json').version") \
           GIT_COMMIT="${GITHUB_SHA::7}" \
-          docker compose --profile staging-go build staging-go
-          echo "Built Go staging image"
+          APP_VERSION=$(grep -oP 'APP_VERSION:-\K[^}]+' docker-compose.yml | head -1 || echo "3.0.0")
+          GIT_COMMIT=$(git rev-parse --short HEAD)
+          BUILD_TIME=$(date -u '+%Y-%m-%dT%H:%M:%SZ')
+          export APP_VERSION GIT_COMMIT BUILD_TIME
+          docker compose -f "$STAGING_COMPOSE_FILE" -p corescope-staging build "$STAGING_SERVICE"
+          echo "Built Go staging image ✅"
 
   # ───────────────────────────────────────────────────────────────
-  # 4. Deploy Staging — start on port 82, healthcheck, smoke test
+  # 4. Deploy Staging (master only)
   # ───────────────────────────────────────────────────────────────
   deploy:
     name: "🚀 Deploy Staging"
     if: github.event_name == 'push'
     needs: [build]
-    runs-on: self-hosted
+    runs-on: [self-hosted, Linux]
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
-      - name: Start staging on port 82
+      - name: Deploy staging
         run: |
-          # Force remove stale containers
-          docker rm -f corescope-staging-go 2>/dev/null || true
-          # Clean up stale ports
-          fuser -k 82/tcp 2>/dev/null || true
-          docker compose --profile staging-go up -d staging-go
+          # Use docker compose down (not just stop/rm) to properly clean up
+          # the old container, network, and release memory before starting new one
+          docker compose -f "$STAGING_COMPOSE_FILE" -p corescope-staging down --timeout 30 2>/dev/null || true
+
+          # Wait for container to be fully gone and OS to reclaim memory (3GB limit)
+          for i in $(seq 1 15); do
+            if ! docker ps -a --format '{{.Names}}' | grep -q 'corescope-staging-go'; then
+              break
+            fi
+            sleep 1
+          done
+          sleep 5  # extra pause for OS memory reclaim
+
+          # Ensure staging config exists (docker creates a directory if bind mount source missing)
+          STAGING_DATA="${STAGING_DATA_DIR:-$HOME/meshcore-staging-data}"
+          if [ ! -f "$STAGING_DATA/config.json" ]; then
+            echo "Staging config missing — copying from repo config.example.json"
+            mkdir -p "$STAGING_DATA"
+            cp config.example.json "$STAGING_DATA/config.json"
+          fi
+
+          docker compose -f "$STAGING_COMPOSE_FILE" -p corescope-staging up -d staging-go
 
       - name: Healthcheck staging container
         run: |
@@ -343,51 +313,64 @@ jobs:
           fi
 
   # ───────────────────────────────────────────────────────────────
-  # 5. Publish Badges & Summary
+  # 5. Publish Badges & Summary (master only)
   # ───────────────────────────────────────────────────────────────
   publish:
     name: "📝 Publish Badges & Summary"
     if: github.event_name == 'push'
     needs: [deploy]
-    runs-on: self-hosted
+    runs-on: [self-hosted, Linux]
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Download Go coverage badges
         continue-on-error: true
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v6
         with:
           name: go-badges
           path: .badges/
 
-      - name: Download Node.js test badges
+      - name: Download E2E badges
         continue-on-error: true
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v6
         with:
-          name: node-badges
+          name: e2e-badges
           path: .badges/
 
       - name: Publish coverage badges to repo
         continue-on-error: true
+        env:
+          GH_TOKEN: ${{ secrets.BADGE_PUSH_TOKEN }}
         run: |
-          git config user.name "github-actions"
-          git config user.email "actions@github.com"
-          git remote set-url origin https://x-access-token:${{ github.token }}@github.com/${{ github.repository }}.git
-          git add .badges/ -f
-          git diff --cached --quiet || (git commit -m "ci: update test badges [skip ci]" && git push) || echo "Badge push failed"
+          # GITHUB_TOKEN cannot push to protected branches (required status checks).
+          # Use admin PAT (BADGE_PUSH_TOKEN) via GitHub Contents API instead.
+          for badge in .badges/*.json; do
+            FILENAME=$(basename "$badge")
+            FILEPATH=".badges/$FILENAME"
+            CONTENT=$(base64 -w0 "$badge")
+            CURRENT_SHA=$(gh api "repos/${{ github.repository }}/contents/$FILEPATH" --jq '.sha' 2>/dev/null || echo "")
+            if [ -n "$CURRENT_SHA" ]; then
+              gh api "repos/${{ github.repository }}/contents/$FILEPATH" \
+                -X PUT \
+                -f message="ci: update $FILENAME [skip ci]" \
+                -f content="$CONTENT" \
+                -f sha="$CURRENT_SHA" \
+                -f branch="master" \
+                --silent 2>&1 || echo "Failed to update $FILENAME"
+            else
+              gh api "repos/${{ github.repository }}/contents/$FILEPATH" \
+                -X PUT \
+                -f message="ci: update $FILENAME [skip ci]" \
+                -f content="$CONTENT" \
+                -f branch="master" \
+                --silent 2>&1 || echo "Failed to create $FILENAME"
+            fi
+          done
+          echo "Badge publish complete"
 
       - name: Post deployment summary
         run: |
           echo "## Staging Deployed ✓" >> $GITHUB_STEP_SUMMARY
           echo "" >> $GITHUB_STEP_SUMMARY
           echo "**Commit:** \`$(git rev-parse --short HEAD)\` — $(git log -1 --format=%s)" >> $GITHUB_STEP_SUMMARY
-          echo "" >> $GITHUB_STEP_SUMMARY
-          echo "**Staging:** http://<VM_HOST>:82" >> $GITHUB_STEP_SUMMARY
-          echo "" >> $GITHUB_STEP_SUMMARY
-          echo "To promote to production:" >> $GITHUB_STEP_SUMMARY
-          echo "\`\`\`bash" >> $GITHUB_STEP_SUMMARY
-          echo "ssh deploy@\$VM_HOST" >> $GITHUB_STEP_SUMMARY
-          echo "cd /opt/corescope-deploy" >> $GITHUB_STEP_SUMMARY
-          echo "./manage.sh promote" >> $GITHUB_STEP_SUMMARY
-          echo "\`\`\`" >> $GITHUB_STEP_SUMMARY

.github/workflows/squad-heartbeat.yml

@@ -0,0 +1,171 @@
+name: Squad Heartbeat (Ralph)
+# ⚠️ SYNC: This workflow is maintained in 4 locations. Changes must be applied to all:
+#   - templates/workflows/squad-heartbeat.yml (source template)
+#   - packages/squad-cli/templates/workflows/squad-heartbeat.yml (CLI package)
+#   - .squad/templates/workflows/squad-heartbeat.yml (installed template)
+#   - .github/workflows/squad-heartbeat.yml (active workflow)
+# Run 'squad upgrade' to sync installed copies from source templates.
+
+on:
+  schedule:
+    # Every 30 minutes — adjust via cron expression as needed
+    - cron: '*/30 * * * *'
+
+  # React to completed work or new squad work
+  issues:
+    types: [closed, labeled]
+  pull_request:
+    types: [closed]
+
+  # Manual trigger
+  workflow_dispatch:
+
+permissions:
+  issues: write
+  contents: read
+  pull-requests: read
+
+jobs:
+  heartbeat:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check triage script
+        id: check-script
+        run: |
+          if [ -f ".squad/templates/ralph-triage.js" ]; then
+            echo "has_script=true" >> $GITHUB_OUTPUT
+          else
+            echo "has_script=false" >> $GITHUB_OUTPUT
+            echo "⚠️ ralph-triage.js not found — run 'squad upgrade' to install"
+          fi
+
+      - name: Ralph — Smart triage
+        if: steps.check-script.outputs.has_script == 'true'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          node .squad/templates/ralph-triage.js \
+            --squad-dir .squad \
+            --output triage-results.json
+
+      - name: Ralph — Apply triage decisions
+        if: steps.check-script.outputs.has_script == 'true' && hashFiles('triage-results.json') != ''
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+            const path = 'triage-results.json';
+            if (!fs.existsSync(path)) {
+              core.info('No triage results — board is clear');
+              return;
+            }
+            
+            const results = JSON.parse(fs.readFileSync(path, 'utf8'));
+            if (results.length === 0) {
+              core.info('📋 Board is clear — Ralph found no untriaged issues');
+              return;
+            }
+            
+            for (const decision of results) {
+              try {
+                await github.rest.issues.addLabels({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: decision.issueNumber,
+                  labels: [decision.label]
+                });
+                
+                await github.rest.issues.createComment({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: decision.issueNumber,
+                  body: [
+                    '### 🔄 Ralph — Auto-Triage',
+                    '',
+                    `**Assigned to:** ${decision.assignTo}`,
+                    `**Reason:** ${decision.reason}`,
+                    `**Source:** ${decision.source}`,
+                    '',
+                    '> Ralph auto-triaged this issue using routing rules.',
+                    '> To reassign, swap the `squad:*` label.'
+                  ].join('\n')
+                });
+                
+                core.info(`Triaged #${decision.issueNumber} → ${decision.assignTo} (${decision.source})`);
+              } catch (e) {
+                core.warning(`Failed to triage #${decision.issueNumber}: ${e.message}`);
+              }
+            }
+            
+            core.info(`🔄 Ralph triaged ${results.length} issue(s)`);
+
+      # Copilot auto-assign step (uses PAT if available)
+      - name: Ralph — Assign @copilot issues
+        if: success()
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.COPILOT_ASSIGN_TOKEN || secrets.GITHUB_TOKEN }}
+          script: |
+            const fs = require('fs');
+
+            let teamFile = '.squad/team.md';
+            if (!fs.existsSync(teamFile)) {
+              teamFile = '.ai-team/team.md';
+            }
+            if (!fs.existsSync(teamFile)) return;
+
+            const content = fs.readFileSync(teamFile, 'utf8');
+
+            // Check if @copilot is on the team with auto-assign
+            const hasCopilot = content.includes('🤖 Coding Agent') || content.includes('@copilot');
+            const autoAssign = content.includes('<!-- copilot-auto-assign: true -->');
+            if (!hasCopilot || !autoAssign) return;
+
+            // Find issues labeled squad:copilot with no assignee
+            try {
+              const { data: copilotIssues } = await github.rest.issues.listForRepo({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                labels: 'squad:copilot',
+                state: 'open',
+                per_page: 5
+              });
+
+              const unassigned = copilotIssues.filter(i =>
+                !i.assignees || i.assignees.length === 0
+              );
+
+              if (unassigned.length === 0) {
+                core.info('No unassigned squad:copilot issues');
+                return;
+              }
+
+              // Get repo default branch
+              const { data: repoData } = await github.rest.repos.get({
+                owner: context.repo.owner,
+                repo: context.repo.repo
+              });
+
+              for (const issue of unassigned) {
+                try {
+                  await github.request('POST /repos/{owner}/{repo}/issues/{issue_number}/assignees', {
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    issue_number: issue.number,
+                    assignees: ['copilot-swe-agent[bot]'],
+                    agent_assignment: {
+                      target_repo: `${context.repo.owner}/${context.repo.repo}`,
+                      base_branch: repoData.default_branch,
+                      custom_instructions: `Read .squad/team.md (or .ai-team/team.md) for team context and .squad/routing.md (or .ai-team/routing.md) for routing rules.`
+                    }
+                  });
+                  core.info(`Assigned copilot-swe-agent[bot] to #${issue.number}`);
+                } catch (e) {
+                  core.warning(`Failed to assign @copilot to #${issue.number}: ${e.message}`);
+                }
+              }
+            } catch (e) {
+              core.info(`No squad:copilot label found or error: ${e.message}`);
+            }

.github/workflows/squad-issue-assign.yml

@@ -0,0 +1,161 @@
+name: Squad Issue Assign
+
+on:
+  issues:
+    types: [labeled]
+
+permissions:
+  issues: write
+  contents: read
+
+jobs:
+  assign-work:
+    # Only trigger on squad:{member} labels (not the base "squad" label)
+    if: startsWith(github.event.label.name, 'squad:')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Identify assigned member and trigger work
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+            const issue = context.payload.issue;
+            const label = context.payload.label.name;
+
+            // Extract member name from label (e.g., "squad:ripley" → "ripley")
+            const memberName = label.replace('squad:', '').toLowerCase();
+
+            // Read team roster — check .squad/ first, fall back to .ai-team/
+            let teamFile = '.squad/team.md';
+            if (!fs.existsSync(teamFile)) {
+              teamFile = '.ai-team/team.md';
+            }
+            if (!fs.existsSync(teamFile)) {
+              core.warning('No .squad/team.md or .ai-team/team.md found — cannot assign work');
+              return;
+            }
+
+            const content = fs.readFileSync(teamFile, 'utf8');
+            const lines = content.split('\n');
+
+            // Check if this is a coding agent assignment
+            const isCopilotAssignment = memberName === 'copilot';
+
+            let assignedMember = null;
+            if (isCopilotAssignment) {
+              assignedMember = { name: '@copilot', role: 'Coding Agent' };
+            } else {
+              let inMembersTable = false;
+              for (const line of lines) {
+                if (line.match(/^##\s+(Members|Team Roster)/i)) {
+                  inMembersTable = true;
+                  continue;
+                }
+                if (inMembersTable && line.startsWith('## ')) {
+                  break;
+                }
+                if (inMembersTable && line.startsWith('|') && !line.includes('---') && !line.includes('Name')) {
+                  const cells = line.split('|').map(c => c.trim()).filter(Boolean);
+                  if (cells.length >= 2 && cells[0].toLowerCase() === memberName) {
+                    assignedMember = { name: cells[0], role: cells[1] };
+                    break;
+                  }
+                }
+              }
+            }
+
+            if (!assignedMember) {
+              core.warning(`No member found matching label "${label}"`);
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issue.number,
+                body: `⚠️ No squad member found matching label \`${label}\`. Check \`.squad/team.md\` (or \`.ai-team/team.md\`) for valid member names.`
+              });
+              return;
+            }
+
+            // Post assignment acknowledgment
+            let comment;
+            if (isCopilotAssignment) {
+              comment = [
+                `### 🤖 Routed to @copilot (Coding Agent)`,
+                '',
+                `**Issue:** #${issue.number} — ${issue.title}`,
+                '',
+                `@copilot has been assigned and will pick this up automatically.`,
+                '',
+                `> The coding agent will create a \`copilot/*\` branch and open a draft PR.`,
+                `> Review the PR as you would any team member's work.`,
+              ].join('\n');
+            } else {
+              comment = [
+                `### 📋 Assigned to ${assignedMember.name} (${assignedMember.role})`,
+                '',
+                `**Issue:** #${issue.number} — ${issue.title}`,
+                '',
+                `${assignedMember.name} will pick this up in the next Copilot session.`,
+                '',
+                `> **For Copilot coding agent:** If enabled, this issue will be worked automatically.`,
+                `> Otherwise, start a Copilot session and say:`,
+                `> \`${assignedMember.name}, work on issue #${issue.number}\``,
+              ].join('\n');
+            }
+
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: issue.number,
+              body: comment
+            });
+
+            core.info(`Issue #${issue.number} assigned to ${assignedMember.name} (${assignedMember.role})`);
+
+      # Separate step: assign @copilot using PAT (required for coding agent)
+      - name: Assign @copilot coding agent
+        if: github.event.label.name == 'squad:copilot'
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.COPILOT_ASSIGN_TOKEN }}
+          script: |
+            const owner = context.repo.owner;
+            const repo = context.repo.repo;
+            const issue_number = context.payload.issue.number;
+
+            // Get the default branch name (main, master, etc.)
+            const { data: repoData } = await github.rest.repos.get({ owner, repo });
+            const baseBranch = repoData.default_branch;
+
+            try {
+              await github.request('POST /repos/{owner}/{repo}/issues/{issue_number}/assignees', {
+                owner,
+                repo,
+                issue_number,
+                assignees: ['copilot-swe-agent[bot]'],
+                agent_assignment: {
+                  target_repo: `${owner}/${repo}`,
+                  base_branch: baseBranch,
+                  custom_instructions: '',
+                  custom_agent: '',
+                  model: ''
+                },
+                headers: {
+                  'X-GitHub-Api-Version': '2022-11-28'
+                }
+              });
+              core.info(`Assigned copilot-swe-agent to issue #${issue_number} (base: ${baseBranch})`);
+            } catch (err) {
+              core.warning(`Assignment with agent_assignment failed: ${err.message}`);
+              // Fallback: try without agent_assignment
+              try {
+                await github.rest.issues.addAssignees({
+                  owner, repo, issue_number,
+                  assignees: ['copilot-swe-agent']
+                });
+                core.info(`Fallback assigned copilot-swe-agent to issue #${issue_number}`);
+              } catch (err2) {
+                core.warning(`Fallback also failed: ${err2.message}`);
+              }
+            }

.github/workflows/squad-triage.yml

@@ -0,0 +1,260 @@
+name: Squad Triage
+
+on:
+  issues:
+    types: [labeled]
+
+permissions:
+  issues: write
+  contents: read
+
+jobs:
+  triage:
+    if: github.event.label.name == 'squad'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Triage issue via Lead agent
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+            const issue = context.payload.issue;
+
+            // Read team roster — check .squad/ first, fall back to .ai-team/
+            let teamFile = '.squad/team.md';
+            if (!fs.existsSync(teamFile)) {
+              teamFile = '.ai-team/team.md';
+            }
+            if (!fs.existsSync(teamFile)) {
+              core.warning('No .squad/team.md or .ai-team/team.md found — cannot triage');
+              return;
+            }
+
+            const content = fs.readFileSync(teamFile, 'utf8');
+            const lines = content.split('\n');
+
+            // Check if @copilot is on the team
+            const hasCopilot = content.includes('🤖 Coding Agent');
+            const copilotAutoAssign = content.includes('<!-- copilot-auto-assign: true -->');
+
+            // Parse @copilot capability profile
+            let goodFitKeywords = [];
+            let needsReviewKeywords = [];
+            let notSuitableKeywords = [];
+
+            if (hasCopilot) {
+              // Extract capability tiers from team.md
+              const goodFitMatch = content.match(/🟢\s*Good fit[^:]*:\s*(.+)/i);
+              const needsReviewMatch = content.match(/🟡\s*Needs review[^:]*:\s*(.+)/i);
+              const notSuitableMatch = content.match(/🔴\s*Not suitable[^:]*:\s*(.+)/i);
+
+              if (goodFitMatch) {
+                goodFitKeywords = goodFitMatch[1].toLowerCase().split(',').map(s => s.trim());
+              } else {
+                goodFitKeywords = ['bug fix', 'test coverage', 'lint', 'format', 'dependency update', 'small feature', 'scaffolding', 'doc fix', 'documentation'];
+              }
+              if (needsReviewMatch) {
+                needsReviewKeywords = needsReviewMatch[1].toLowerCase().split(',').map(s => s.trim());
+              } else {
+                needsReviewKeywords = ['medium feature', 'refactoring', 'api endpoint', 'migration'];
+              }
+              if (notSuitableMatch) {
+                notSuitableKeywords = notSuitableMatch[1].toLowerCase().split(',').map(s => s.trim());
+              } else {
+                notSuitableKeywords = ['architecture', 'system design', 'security', 'auth', 'encryption', 'performance'];
+              }
+            }
+
+            const members = [];
+            let inMembersTable = false;
+            for (const line of lines) {
+              if (line.match(/^##\s+(Members|Team Roster)/i)) {
+                inMembersTable = true;
+                continue;
+              }
+              if (inMembersTable && line.startsWith('## ')) {
+                break;
+              }
+              if (inMembersTable && line.startsWith('|') && !line.includes('---') && !line.includes('Name')) {
+                const cells = line.split('|').map(c => c.trim()).filter(Boolean);
+                if (cells.length >= 2 && cells[0] !== 'Scribe') {
+                  members.push({
+                    name: cells[0],
+                    role: cells[1]
+                  });
+                }
+              }
+            }
+
+            // Read routing rules — check .squad/ first, fall back to .ai-team/
+            let routingFile = '.squad/routing.md';
+            if (!fs.existsSync(routingFile)) {
+              routingFile = '.ai-team/routing.md';
+            }
+            let routingContent = '';
+            if (fs.existsSync(routingFile)) {
+              routingContent = fs.readFileSync(routingFile, 'utf8');
+            }
+
+            // Find the Lead
+            const lead = members.find(m =>
+              m.role.toLowerCase().includes('lead') ||
+              m.role.toLowerCase().includes('architect') ||
+              m.role.toLowerCase().includes('coordinator')
+            );
+
+            if (!lead) {
+              core.warning('No Lead role found in team roster — cannot triage');
+              return;
+            }
+
+            // Build triage context
+            const memberList = members.map(m =>
+              `- **${m.name}** (${m.role}) → label: \`squad:${m.name.toLowerCase()}\``
+            ).join('\n');
+
+            // Determine best assignee based on issue content and routing
+            const issueText = `${issue.title}\n${issue.body || ''}`.toLowerCase();
+
+            let assignedMember = null;
+            let triageReason = '';
+            let copilotTier = null;
+
+            // First, evaluate @copilot fit if enabled
+            if (hasCopilot) {
+              const isNotSuitable = notSuitableKeywords.some(kw => issueText.includes(kw));
+              const isGoodFit = !isNotSuitable && goodFitKeywords.some(kw => issueText.includes(kw));
+              const isNeedsReview = !isNotSuitable && !isGoodFit && needsReviewKeywords.some(kw => issueText.includes(kw));
+
+              if (isGoodFit) {
+                copilotTier = 'good-fit';
+                assignedMember = { name: '@copilot', role: 'Coding Agent' };
+                triageReason = '🟢 Good fit for @copilot — matches capability profile';
+              } else if (isNeedsReview) {
+                copilotTier = 'needs-review';
+                assignedMember = { name: '@copilot', role: 'Coding Agent' };
+                triageReason = '🟡 Routing to @copilot (needs review) — a squad member should review the PR';
+              } else if (isNotSuitable) {
+                copilotTier = 'not-suitable';
+                // Fall through to normal routing
+              }
+            }
+
+            // If not routed to @copilot, use keyword-based routing
+            if (!assignedMember) {
+              for (const member of members) {
+                const role = member.role.toLowerCase();
+                if ((role.includes('frontend') || role.includes('ui')) &&
+                    (issueText.includes('ui') || issueText.includes('frontend') ||
+                     issueText.includes('css') || issueText.includes('component') ||
+                     issueText.includes('button') || issueText.includes('page') ||
+                     issueText.includes('layout') || issueText.includes('design'))) {
+                  assignedMember = member;
+                  triageReason = 'Issue relates to frontend/UI work';
+                  break;
+                }
+                if ((role.includes('backend') || role.includes('api') || role.includes('server')) &&
+                    (issueText.includes('api') || issueText.includes('backend') ||
+                     issueText.includes('database') || issueText.includes('endpoint') ||
+                     issueText.includes('server') || issueText.includes('auth'))) {
+                  assignedMember = member;
+                  triageReason = 'Issue relates to backend/API work';
+                  break;
+                }
+                if ((role.includes('test') || role.includes('qa') || role.includes('quality')) &&
+                    (issueText.includes('test') || issueText.includes('bug') ||
+                     issueText.includes('fix') || issueText.includes('regression') ||
+                     issueText.includes('coverage'))) {
+                  assignedMember = member;
+                  triageReason = 'Issue relates to testing/quality work';
+                  break;
+                }
+                if ((role.includes('devops') || role.includes('infra') || role.includes('ops')) &&
+                    (issueText.includes('deploy') || issueText.includes('ci') ||
+                     issueText.includes('pipeline') || issueText.includes('docker') ||
+                     issueText.includes('infrastructure'))) {
+                  assignedMember = member;
+                  triageReason = 'Issue relates to DevOps/infrastructure work';
+                  break;
+                }
+              }
+            }
+
+            // Default to Lead if no routing match
+            if (!assignedMember) {
+              assignedMember = lead;
+              triageReason = 'No specific domain match — assigned to Lead for further analysis';
+            }
+
+            const isCopilot = assignedMember.name === '@copilot';
+            const assignLabel = isCopilot ? 'squad:copilot' : `squad:${assignedMember.name.toLowerCase()}`;
+
+            // Add the member-specific label
+            await github.rest.issues.addLabels({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: issue.number,
+              labels: [assignLabel]
+            });
+
+            // Apply default triage verdict
+            await github.rest.issues.addLabels({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: issue.number,
+              labels: ['go:needs-research']
+            });
+
+            // Auto-assign @copilot if enabled
+            if (isCopilot && copilotAutoAssign) {
+              try {
+                await github.rest.issues.addAssignees({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: issue.number,
+                  assignees: ['copilot']
+                });
+              } catch (err) {
+                core.warning(`Could not auto-assign @copilot: ${err.message}`);
+              }
+            }
+
+            // Build copilot evaluation note
+            let copilotNote = '';
+            if (hasCopilot && !isCopilot) {
+              if (copilotTier === 'not-suitable') {
+                copilotNote = `\n\n**@copilot evaluation:** 🔴 Not suitable — issue involves work outside the coding agent's capability profile.`;
+              } else {
+                copilotNote = `\n\n**@copilot evaluation:** No strong capability match — routed to squad member.`;
+              }
+            }
+
+            // Post triage comment
+            const comment = [
+              `### 🏗️ Squad Triage — ${lead.name} (${lead.role})`,
+              '',
+              `**Issue:** #${issue.number} — ${issue.title}`,
+              `**Assigned to:** ${assignedMember.name} (${assignedMember.role})`,
+              `**Reason:** ${triageReason}`,
+              copilotTier === 'needs-review' ? `\n⚠️ **PR review recommended** — a squad member should review @copilot's work on this one.` : '',
+              copilotNote,
+              '',
+              `---`,
+              '',
+              `**Team roster:**`,
+              memberList,
+              hasCopilot ? `- **@copilot** (Coding Agent) → label: \`squad:copilot\`` : '',
+              '',
+              `> To reassign, remove the current \`squad:*\` label and add the correct one.`,
+            ].filter(Boolean).join('\n');
+
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: issue.number,
+              body: comment
+            });
+
+            core.info(`Triaged issue #${issue.number} → ${assignedMember.name} (${assignLabel})`);

.github/workflows/sync-squad-labels.yml

@@ -0,0 +1,169 @@
+name: Sync Squad Labels
+
+on:
+  push:
+    paths:
+      - '.squad/team.md'
+      - '.ai-team/team.md'
+  workflow_dispatch:
+
+permissions:
+  issues: write
+  contents: read
+
+jobs:
+  sync-labels:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Parse roster and sync labels
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+            let teamFile = '.squad/team.md';
+            if (!fs.existsSync(teamFile)) {
+              teamFile = '.ai-team/team.md';
+            }
+
+            if (!fs.existsSync(teamFile)) {
+              core.info('No .squad/team.md or .ai-team/team.md found — skipping label sync');
+              return;
+            }
+
+            const content = fs.readFileSync(teamFile, 'utf8');
+            const lines = content.split('\n');
+
+            // Parse the Members table for agent names
+            const members = [];
+            let inMembersTable = false;
+            for (const line of lines) {
+              if (line.match(/^##\s+(Members|Team Roster)/i)) {
+                inMembersTable = true;
+                continue;
+              }
+              if (inMembersTable && line.startsWith('## ')) {
+                break;
+              }
+              if (inMembersTable && line.startsWith('|') && !line.includes('---') && !line.includes('Name')) {
+                const cells = line.split('|').map(c => c.trim()).filter(Boolean);
+                if (cells.length >= 2 && cells[0] !== 'Scribe') {
+                  members.push({
+                    name: cells[0],
+                    role: cells[1]
+                  });
+                }
+              }
+            }
+
+            core.info(`Found ${members.length} squad members: ${members.map(m => m.name).join(', ')}`);
+
+            // Check if @copilot is on the team
+            const hasCopilot = content.includes('🤖 Coding Agent');
+
+            // Define label color palette for squad labels
+            const SQUAD_COLOR = '9B8FCC';
+            const MEMBER_COLOR = '9B8FCC';
+            const COPILOT_COLOR = '10b981';
+
+            // Define go: and release: labels (static)
+            const GO_LABELS = [
+              { name: 'go:yes', color: '0E8A16', description: 'Ready to implement' },
+              { name: 'go:no', color: 'B60205', description: 'Not pursuing' },
+              { name: 'go:needs-research', color: 'FBCA04', description: 'Needs investigation' }
+            ];
+
+            const RELEASE_LABELS = [
+              { name: 'release:v0.4.0', color: '6B8EB5', description: 'Targeted for v0.4.0' },
+              { name: 'release:v0.5.0', color: '6B8EB5', description: 'Targeted for v0.5.0' },
+              { name: 'release:v0.6.0', color: '8B7DB5', description: 'Targeted for v0.6.0' },
+              { name: 'release:v1.0.0', color: '8B7DB5', description: 'Targeted for v1.0.0' },
+              { name: 'release:backlog', color: 'D4E5F7', description: 'Not yet targeted' }
+            ];
+
+            const TYPE_LABELS = [
+              { name: 'type:feature', color: 'DDD1F2', description: 'New capability' },
+              { name: 'type:bug', color: 'FF0422', description: 'Something broken' },
+              { name: 'type:spike', color: 'F2DDD4', description: 'Research/investigation — produces a plan, not code' },
+              { name: 'type:docs', color: 'D4E5F7', description: 'Documentation work' },
+              { name: 'type:chore', color: 'D4E5F7', description: 'Maintenance, refactoring, cleanup' },
+              { name: 'type:epic', color: 'CC4455', description: 'Parent issue that decomposes into sub-issues' }
+            ];
+
+            // High-signal labels — these MUST visually dominate all others
+            const SIGNAL_LABELS = [
+              { name: 'bug', color: 'FF0422', description: 'Something isn\'t working' },
+              { name: 'feedback', color: '00E5FF', description: 'User feedback — high signal, needs attention' }
+            ];
+
+            const PRIORITY_LABELS = [
+              { name: 'priority:p0', color: 'B60205', description: 'Blocking release' },
+              { name: 'priority:p1', color: 'D93F0B', description: 'This sprint' },
+              { name: 'priority:p2', color: 'FBCA04', description: 'Next sprint' }
+            ];
+
+            // Ensure the base "squad" triage label exists
+            const labels = [
+              { name: 'squad', color: SQUAD_COLOR, description: 'Squad triage inbox — Lead will assign to a member' }
+            ];
+
+            for (const member of members) {
+              labels.push({
+                name: `squad:${member.name.toLowerCase()}`,
+                color: MEMBER_COLOR,
+                description: `Assigned to ${member.name} (${member.role})`
+              });
+            }
+
+            // Add @copilot label if coding agent is on the team
+            if (hasCopilot) {
+              labels.push({
+                name: 'squad:copilot',
+                color: COPILOT_COLOR,
+                description: 'Assigned to @copilot (Coding Agent) for autonomous work'
+              });
+            }
+
+            // Add go:, release:, type:, priority:, and high-signal labels
+            labels.push(...GO_LABELS);
+            labels.push(...RELEASE_LABELS);
+            labels.push(...TYPE_LABELS);
+            labels.push(...PRIORITY_LABELS);
+            labels.push(...SIGNAL_LABELS);
+
+            // Sync labels (create or update)
+            for (const label of labels) {
+              try {
+                await github.rest.issues.getLabel({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  name: label.name
+                });
+                // Label exists — update it
+                await github.rest.issues.updateLabel({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  name: label.name,
+                  color: label.color,
+                  description: label.description
+                });
+                core.info(`Updated label: ${label.name}`);
+              } catch (err) {
+                if (err.status === 404) {
+                  // Label doesn't exist — create it
+                  await github.rest.issues.createLabel({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    name: label.name,
+                    color: label.color,
+                    description: label.description
+                  });
+                  core.info(`Created label: ${label.name}`);
+                } else {
+                  throw err;
+                }
+              }
+            }
+
+            core.info(`Label sync complete: ${labels.length} labels synced`);

.gitignore

@@ -28,3 +28,5 @@ reps.txt
 cmd/server/server.exe
 cmd/ingestor/ingestor.exe
 # CI trigger
+!test-fixtures/e2e-fixture.db
+corescope-server

.nycrc.json

@@ -0,0 +1,10 @@
+{
+  "include": [
+    "public/*.js"
+  ],
+  "exclude": [
+    "public/vendor/**",
+    "public/leaflet-*.js",
+    "public/qrcode*.js"
+  ]
+}

AGENTS.md

@@ -4,14 +4,20 @@ Guide for AI agents working on this codebase. Read this before writing any code.
 
 ## Architecture
 
-Single Node.js server + static frontend. No build step. No framework. No bundler.
+Go backend + static frontend. No build step. No framework. No bundler.
+
+**⚠️ The Node.js server (server.js) is DEPRECATED and has been removed. All backend code is in Go.**
+**⚠️ DO NOT create or modify any Node.js server files. All backend changes go in `cmd/server/` or `cmd/ingestor/`.**
 
 ```
-server.js          — Express API + MQTT ingestion + WebSocket broadcast
-decoder.js         — MeshCore packet parser (header, path, payload, adverts)
-packet-store.js    — In-memory packet store + query engine (backed by SQLite)
-db.js              — SQLite schema + prepared statements
-public/            — Frontend (vanilla JS, one file per page)
+cmd/server/        — Go API server (REST + WebSocket broadcast + static file serving)
+  main.go          — Entry point, flags, SPA handler
+  routes.go        — All /api/* endpoints
+  store.go         — In-memory packet store + analytics + SQLite queries
+  config.go        — Configuration loading
+  decoder.go       — MeshCore packet decoder
+cmd/ingestor/      — Go MQTT ingestor (separate binary, writes to shared SQLite DB)
+public/            — Frontend (vanilla JS, one file per page) — ACTIVE, NOT DEPRECATED
   app.js           — SPA router, shared globals, theme loading
   roles.js         — ROLE_COLORS, TYPE_COLORS, health thresholds, shared helpers
   nodes.js         — Nodes list + side pane + full detail page
@@ -28,17 +34,25 @@ public/            — Frontend (vanilla JS, one file per page)
   live.css         — Live page styles
   home.css         — Home page styles
   index.html       — SPA shell, script/style tags with cache busters
+test-fixtures/     — Real data SQLite fixture from staging (used for E2E tests)
+scripts/           — Tooling (coverage collector, fixture capture, frontend instrumentation)
 ```
 
 ### Data Flow
-1. MQTT brokers → server.js ingests packets → decoder.js parses → packet-store.js stores in memory + SQLite
-2. WebSocket broadcasts new packets to connected browsers
-3. Frontend fetches via REST API, filters/sorts client-side
+1. MQTT brokers → Go ingestor (`cmd/ingestor/`) ingests packets → decodes → writes to SQLite
+2. Go server (`cmd/server/`) polls SQLite for new packets, broadcasts via WebSocket
+3. Frontend fetches via REST API (`/api/*`), filters/sorts client-side
+
+### What's Deprecated (DO NOT TOUCH)
+The following were part of the old Node.js backend and have been removed:
+- `server.js`, `db.js`, `decoder.js`, `server-helpers.js`, `packet-store.js`, `iata-coords.js`
+- All `test-server-*.js`, `test-decoder*.js`, `test-db*.js`, `test-regional*.js` files
+- If you see references to these in comments or docs, they're stale — ignore them
 
 ## Rules — Read These First
 
 ### 1. No commit without tests
-Every change that touches logic MUST have unit tests. Run `node test-packet-filter.js && node test-aging.js` before pushing. If you add new logic, add tests to the appropriate test file or create a new one. No exceptions.
+Every change that touches logic MUST have tests. For Go backend: `cd cmd/server && go test ./...` and `cd cmd/ingestor && go test ./...`. For frontend: `node test-packet-filter.js && node test-aging.js && node test-frontend-helpers.js`. If you add new logic, add tests. No exceptions.
 
 ### 2. No commit without browser validation
 After pushing, verify the change works in an actual browser. Use `browser profile=openclaw` against the running instance. Take a screenshot if the change is visual. If you can't validate it, say so — don't claim it works.

README.md

@@ -1,14 +1,14 @@
 # CoreScope
 
-[![Go Server Coverage](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/Kpa-clawbot/corescope/master/.badges/go-server-coverage.json)](https://github.com/Kpa-clawbot/corescope/actions/workflows/deploy.yml)
-[![Go Ingestor Coverage](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/Kpa-clawbot/corescope/master/.badges/go-ingestor-coverage.json)](https://github.com/Kpa-clawbot/corescope/actions/workflows/deploy.yml)
-[![Frontend Tests](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/Kpa-clawbot/corescope/master/.badges/frontend-tests.json)](https://github.com/Kpa-clawbot/corescope/actions/workflows/deploy.yml)
-[![Frontend Coverage](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/Kpa-clawbot/corescope/master/.badges/frontend-coverage.json)](https://github.com/Kpa-clawbot/corescope/actions/workflows/deploy.yml)
-[![Deploy](https://github.com/Kpa-clawbot/corescope/actions/workflows/deploy.yml/badge.svg)](https://github.com/Kpa-clawbot/corescope/actions/workflows/deploy.yml)
+[![Go Server Coverage](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/Kpa-clawbot/CoreScope/master/.badges/go-server-coverage.json)](https://github.com/Kpa-clawbot/CoreScope/actions/workflows/deploy.yml)
+[![Go Ingestor Coverage](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/Kpa-clawbot/CoreScope/master/.badges/go-ingestor-coverage.json)](https://github.com/Kpa-clawbot/CoreScope/actions/workflows/deploy.yml)
+[![E2E Tests](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/Kpa-clawbot/CoreScope/master/.badges/e2e-tests.json)](https://github.com/Kpa-clawbot/CoreScope/actions/workflows/deploy.yml)
+[![Frontend Coverage](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/Kpa-clawbot/CoreScope/master/.badges/frontend-coverage.json)](https://github.com/Kpa-clawbot/CoreScope/actions/workflows/deploy.yml)
+[![Deploy](https://github.com/Kpa-clawbot/CoreScope/actions/workflows/deploy.yml/badge.svg)](https://github.com/Kpa-clawbot/CoreScope/actions/workflows/deploy.yml)
 
 > High-performance mesh network analyzer powered by Go. Sub-millisecond packet queries, ~300 MB memory for 56K+ packets, real-time WebSocket broadcast, full channel decryption.
 
-Self-hosted, open-source MeshCore packet analyzer — a community alternative to the closed-source `analyzer.letsmesh.net`. Collects MeshCore packets via MQTT, decodes them in real time, and presents a full web UI with live packet feed, interactive maps, channel chat, packet tracing, and per-node analytics.
+Self-hosted, open-source MeshCore packet analyzer. Collects MeshCore packets via MQTT, decodes them in real time, and presents a full web UI with live packet feed, interactive maps, channel chat, packet tracing, and per-node analytics.
 
 ## ⚡ Performance
 
@@ -79,7 +79,7 @@ Full experience on your phone — proper touch controls, iOS safe area support,
 No Go installation needed — everything builds inside the container.
 
 ```bash
-git clone https://github.com/Kpa-clawbot/corescope.git
+git clone https://github.com/Kpa-clawbot/CoreScope.git
 cd corescope
 ./manage.sh setup
 ```

benchmark-ab.sh

@@ -1,131 +0,0 @@
-#!/bin/bash
-# A/B benchmark: old (pre-perf) vs new (current)
-# Usage: ./benchmark-ab.sh
-set -e
-
-PORT_OLD=13003
-PORT_NEW=13004
-RUNS=3
-DB_PATH="$(pwd)/data/meshcore.db"
-
-OLD_COMMIT="23caae4"
-NEW_COMMIT="$(git rev-parse HEAD)"
-
-echo "═══════════════════════════════════════════════════════"
-echo "  A/B Benchmark: Pre-optimization vs Current"
-echo "═══════════════════════════════════════════════════════"
-echo "OLD: $OLD_COMMIT (v2.0.1 — before any perf work)"
-echo "NEW: $NEW_COMMIT (current)"
-echo "Runs per endpoint: $RUNS"
-echo ""
-
-# Get a real node pubkey for testing
-ORIG_DIR="$(pwd)"
-PUBKEY=$(sqlite3 "$DB_PATH" "SELECT public_key FROM nodes ORDER BY last_seen DESC LIMIT 1")
-echo "Test node: ${PUBKEY:0:16}..."
-echo ""
-
-# Setup old version in temp dir
-OLD_DIR=$(mktemp -d)
-echo "Cloning old version to $OLD_DIR..."
-git worktree add "$OLD_DIR" "$OLD_COMMIT" --quiet 2>/dev/null || {
-  git worktree add "$OLD_DIR" "$OLD_COMMIT" --detach --quiet
-}
-# Copy config + db symlink
-# Copy config + db + share node_modules
-cp config.json "$OLD_DIR/"
-mkdir -p "$OLD_DIR/data"
-cp "$ORIG_DIR/data/meshcore.db" "$OLD_DIR/data/meshcore.db"
-ln -sf "$ORIG_DIR/node_modules" "$OLD_DIR/node_modules"
-
-ENDPOINTS=(
-  "Stats|/api/stats"
-  "Packets(50)|/api/packets?limit=50"
-  "PacketsGrouped|/api/packets?limit=50&groupByHash=true"
-  "NodesList|/api/nodes?limit=50"
-  "NodeDetail|/api/nodes/$PUBKEY"
-  "NodeHealth|/api/nodes/$PUBKEY/health"
-  "NodeAnalytics|/api/nodes/$PUBKEY/analytics?days=7"
-  "BulkHealth|/api/nodes/bulk-health?limit=50"
-  "NetworkStatus|/api/nodes/network-status"
-  "Channels|/api/channels"
-  "Observers|/api/observers"
-  "RF|/api/analytics/rf"
-  "Topology|/api/analytics/topology"
-  "ChannelAnalytics|/api/analytics/channels"
-  "HashSizes|/api/analytics/hash-sizes"
-)
-
-bench_endpoint() {
-  local port=$1 path=$2 runs=$3 nocache=$4
-  local total=0
-  for i in $(seq 1 $runs); do
-    local url="http://127.0.0.1:$port$path"
-    if [ "$nocache" = "1" ]; then
-      if echo "$path" | grep -q '?'; then
-        url="${url}&nocache=1"
-      else
-        url="${url}?nocache=1"
-      fi
-    fi
-    local ms=$(curl -s -o /dev/null -w "%{time_total}" "$url" 2>/dev/null)
-    local ms_int=$(echo "$ms * 1000" | bc | cut -d. -f1)
-    total=$((total + ms_int))
-  done
-  echo $((total / runs))
-}
-
-# Launch old server
-echo "Starting OLD server (port $PORT_OLD)..."
-cd "$OLD_DIR"
-PORT=$PORT_OLD node server.js &>/dev/null &
-OLD_PID=$!
-cd - >/dev/null
-
-# Launch new server
-echo "Starting NEW server (port $PORT_NEW)..."
-PORT=$PORT_NEW node server.js &>/dev/null &
-NEW_PID=$!
-
-# Wait for both
-sleep 12  # old server has no memory store; new needs prewarm
-
-# Verify
-curl -s "http://127.0.0.1:$PORT_OLD/api/stats" >/dev/null 2>&1 || { echo "OLD server failed to start"; kill $OLD_PID $NEW_PID 2>/dev/null; exit 1; }
-curl -s "http://127.0.0.1:$PORT_NEW/api/stats" >/dev/null 2>&1 || { echo "NEW server failed to start"; kill $OLD_PID $NEW_PID 2>/dev/null; exit 1; }
-
-echo ""
-echo "Warming up caches on new server..."
-for ep in "${ENDPOINTS[@]}"; do
-  path="${ep#*|}"
-  curl -s -o /dev/null "http://127.0.0.1:$PORT_NEW$path" 2>/dev/null
-done
-sleep 2
-
-printf "\n%-22s %9s %9s %9s %9s\n" "Endpoint" "Old(ms)" "New-cold" "New-cache" "Speedup"
-printf "%-22s %9s %9s %9s %9s\n" "──────────────────────" "─────────" "─────────" "─────────" "─────────"
-
-for ep in "${ENDPOINTS[@]}"; do
-  name="${ep%%|*}"
-  path="${ep#*|}"
-  
-  old_ms=$(bench_endpoint $PORT_OLD "$path" $RUNS 0)
-  new_cold=$(bench_endpoint $PORT_NEW "$path" $RUNS 1)
-  new_cached=$(bench_endpoint $PORT_NEW "$path" $RUNS 0)
-  
-  if [ "$old_ms" -gt 0 ] && [ "$new_cached" -gt 0 ]; then
-    speedup="${old_ms}/${new_cached}"
-    speedup_x=$(echo "scale=0; $old_ms / $new_cached" | bc 2>/dev/null || echo "?")
-    printf "%-22s %7dms %7dms %7dms %7d×\n" "$name" "$old_ms" "$new_cold" "$new_cached" "$speedup_x"
-  else
-    printf "%-22s %7dms %7dms %7dms %9s\n" "$name" "$old_ms" "$new_cold" "$new_cached" "∞"
-  fi
-done
-
-echo ""
-echo "═══════════════════════════════════════════════════════"
-
-# Cleanup
-kill $OLD_PID $NEW_PID 2>/dev/null
-git worktree remove "$OLD_DIR" --force 2>/dev/null
-echo "Done."

benchmark.js

@@ -1,246 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Benchmark suite for meshcore-analyzer.
- * Launches two server instances — one with in-memory store, one with pure SQLite —
- * and compares performance side by side.
- *
- * Usage: node benchmark.js [--runs 5] [--json]
- */
-
-const http = require('http');
-const { spawn } = require('child_process');
-const path = require('path');
-
-const args = process.argv.slice(2);
-const RUNS = Number(args.find((a, i) => args[i - 1] === '--runs') || 5);
-const JSON_OUT = args.includes('--json');
-
-const PORT_MEM = 13001;  // In-memory store
-const PORT_SQL = 13002;  // SQLite-only
-
-const ENDPOINTS = [
-  { name: 'Stats', path: '/api/stats' },
-  { name: 'Packets (50)', path: '/api/packets?limit=50' },
-  { name: 'Packets (100)', path: '/api/packets?limit=100' },
-  { name: 'Packets grouped', path: '/api/packets?limit=100&groupByHash=true' },
-  { name: 'Packets filtered', path: '/api/packets?limit=50&type=5' },
-  { name: 'Packets timestamps', path: '/api/packets/timestamps?since=2020-01-01' },
-  { name: 'Nodes list', path: '/api/nodes?limit=50' },
-  { name: 'Node detail', path: '/api/nodes/__FIRST_NODE__' },
-  { name: 'Node health', path: '/api/nodes/__FIRST_NODE__/health' },
-  { name: 'Bulk health', path: '/api/nodes/bulk-health?limit=50' },
-  { name: 'Network status', path: '/api/nodes/network-status' },
-  { name: 'Observers', path: '/api/observers' },
-  { name: 'Channels', path: '/api/channels' },
-  { name: 'RF Analytics', path: '/api/analytics/rf' },
-  { name: 'Topology', path: '/api/analytics/topology' },
-  { name: 'Channel Analytics', path: '/api/analytics/channels' },
-  { name: 'Hash Sizes', path: '/api/analytics/hash-sizes' },
-  { name: 'Subpaths 2-hop', path: '/api/analytics/subpaths?minLen=2&maxLen=2&limit=50' },
-  { name: 'Subpaths 3-hop', path: '/api/analytics/subpaths?minLen=3&maxLen=3&limit=30' },
-  { name: 'Subpaths 4-hop', path: '/api/analytics/subpaths?minLen=4&maxLen=4&limit=20' },
-  { name: 'Subpaths 5-8 hop', path: '/api/analytics/subpaths?minLen=5&maxLen=8&limit=15' },
-];
-
-function fetch(url) {
-  return new Promise((resolve, reject) => {
-    const t0 = process.hrtime.bigint();
-    const req = http.get(url, (res) => {
-      let body = '';
-      res.on('data', c => body += c);
-      res.on('end', () => {
-        const ms = Number(process.hrtime.bigint() - t0) / 1e6;
-        resolve({ ms, bytes: Buffer.byteLength(body), status: res.statusCode, body });
-      });
-    });
-    req.on('error', reject);
-    req.setTimeout(60000, () => { req.destroy(); reject(new Error('timeout')); });
-  });
-}
-
-function median(arr) { const s = [...arr].sort((a,b)=>a-b); return s[Math.floor(s.length/2)]; }
-function p95(arr) { const s = [...arr].sort((a,b)=>a-b); return s[Math.floor(s.length*0.95)]; }
-function avg(arr) { return arr.reduce((a,b)=>a+b,0)/arr.length; }
-function fmt(ms) { return ms >= 1000 ? (ms/1000).toFixed(1)+'s' : ms.toFixed(1)+'ms'; }
-function fmtSize(b) { return b >= 1048576 ? (b/1048576).toFixed(1)+'MB' : b >= 1024 ? (b/1024).toFixed(0)+'KB' : b+'B'; }
-
-function launchServer(port, env = {}) {
-  return new Promise((resolve, reject) => {
-    const child = spawn('node', ['server.js'], {
-      cwd: __dirname,
-      env: { ...process.env, PORT: String(port), ...env },
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    let started = false;
-    const timeout = setTimeout(() => { if (!started) { child.kill(); reject(new Error('Server start timeout')); } }, 30000);
-
-    child.stdout.on('data', (d) => {
-      if (!started && (d.toString().includes('listening') || d.toString().includes('running'))) {
-        started = true; clearTimeout(timeout); resolve(child);
-      }
-    });
-    child.stderr.on('data', (d) => {
-      if (!started && (d.toString().includes('listening') || d.toString().includes('running'))) {
-        started = true; clearTimeout(timeout); resolve(child);
-      }
-    });
-    child.on('exit', (code) => { if (!started) { clearTimeout(timeout); reject(new Error(`Server exited with ${code}`)); } });
-
-    // Fallback: wait longer (SQLite-only mode pre-warms subpaths ~6s)
-    setTimeout(() => {
-      if (!started) {
-        started = true; clearTimeout(timeout);
-        resolve(child);
-      }
-    }, 15000);
-  });
-}
-
-async function waitForServer(port, maxMs = 20000) {
-  const t0 = Date.now();
-  while (Date.now() - t0 < maxMs) {
-    try {
-      const r = await fetch(`http://127.0.0.1:${port}/api/stats`);
-      if (r.status === 200) return true;
-    } catch {}
-    await new Promise(r => setTimeout(r, 500));
-  }
-  throw new Error(`Server on port ${port} didn't start`);
-}
-
-async function benchmarkEndpoints(port, endpoints, nocache = false) {
-  const results = [];
-  for (const ep of endpoints) {
-    const suffix = nocache ? (ep.path.includes('?') ? '&nocache=1' : '?nocache=1') : '';
-    const url = `http://127.0.0.1:${port}${ep.path}${suffix}`;
-
-    // Warm-up
-    try { await fetch(url); } catch {}
-
-    const times = [];
-    let bytes = 0;
-    let failed = false;
-
-    for (let i = 0; i < RUNS; i++) {
-      try {
-        const r = await fetch(url);
-        if (r.status !== 200) { failed = true; break; }
-        times.push(r.ms);
-        bytes = r.bytes;
-      } catch { failed = true; break; }
-    }
-
-    if (failed || !times.length) {
-      results.push({ name: ep.name, failed: true });
-    } else {
-      results.push({
-        name: ep.name,
-        avg: Math.round(avg(times) * 10) / 10,
-        p50: Math.round(median(times) * 10) / 10,
-        p95: Math.round(p95(times) * 10) / 10,
-        bytes
-      });
-    }
-  }
-  return results;
-}
-
-async function run() {
-  console.log(`\nCoreScope Benchmark — ${RUNS} runs per endpoint`);
-  console.log('Launching servers...\n');
-
-  // Launch both servers
-  let memServer, sqlServer;
-  try {
-    console.log('  Starting in-memory server (port ' + PORT_MEM + ')...');
-    memServer = await launchServer(PORT_MEM, {});
-    await waitForServer(PORT_MEM);
-    console.log('  ✅ In-memory server ready');
-
-    console.log('  Starting SQLite-only server (port ' + PORT_SQL + ')...');
-    sqlServer = await launchServer(PORT_SQL, { NO_MEMORY_STORE: '1' });
-    await waitForServer(PORT_SQL);
-    console.log('  ✅ SQLite-only server ready\n');
-  } catch (e) {
-    console.error('Failed to start servers:', e.message);
-    if (memServer) memServer.kill();
-    if (sqlServer) sqlServer.kill();
-    process.exit(1);
-  }
-
-  // Get first node pubkey
-  let firstNode = '';
-  try {
-    const r = await fetch(`http://127.0.0.1:${PORT_MEM}/api/nodes?limit=1`);
-    const data = JSON.parse(r.body);
-    firstNode = data.nodes?.[0]?.public_key || '';
-  } catch {}
-
-  const endpoints = ENDPOINTS.map(e => ({
-    ...e,
-    path: e.path.replace('__FIRST_NODE__', firstNode),
-  }));
-
-  // Get packet count
-  try {
-    const r = await fetch(`http://127.0.0.1:${PORT_MEM}/api/stats`);
-    const stats = JSON.parse(r.body);
-    console.log(`Dataset: ${(stats.totalPackets || '?').toLocaleString()} packets\n`);
-  } catch {}
-
-  // Run benchmarks
-  console.log('Benchmarking in-memory store (nocache for true compute cost)...');
-  const memResults = await benchmarkEndpoints(PORT_MEM, endpoints, true);
-
-  console.log('Benchmarking SQLite-only (nocache)...');
-  const sqlResults = await benchmarkEndpoints(PORT_SQL, endpoints, true);
-
-  // Also test cached in-memory for the full picture
-  console.log('Benchmarking in-memory store (cached)...');
-  const memCachedResults = await benchmarkEndpoints(PORT_MEM, endpoints, false);
-
-  // Kill servers
-  memServer.kill();
-  sqlServer.kill();
-
-  if (JSON_OUT) {
-    console.log(JSON.stringify({ memoryNocache: memResults, sqliteNocache: sqlResults, memoryCached: memCachedResults }, null, 2));
-    return;
-  }
-
-  // Print results
-  const W = 94;
-  console.log(`\n${'═'.repeat(W)}`);
-  console.log('  🏁 BENCHMARK RESULTS: SQLite vs In-Memory Store');
-  console.log(`${'═'.repeat(W)}`);
-  console.log(`${'Endpoint'.padEnd(24)} ${'SQLite'.padStart(9)} ${'Memory'.padStart(9)} ${'Cached'.padStart(9)} ${'Speedup'.padStart(9)} ${'Size (SQL)'.padStart(10)} ${'Size (Mem)'.padStart(10)}`);
-  console.log(`${'─'.repeat(24)} ${'─'.repeat(9)} ${'─'.repeat(9)} ${'─'.repeat(9)} ${'─'.repeat(9)} ${'─'.repeat(10)} ${'─'.repeat(10)}`);
-
-  for (let i = 0; i < endpoints.length; i++) {
-    const sql = sqlResults[i];
-    const mem = memResults[i];
-    const cached = memCachedResults[i];
-    if (!sql || sql.failed || !mem || mem.failed) {
-      console.log(`${endpoints[i].name.padEnd(24)} ${'FAILED'.padStart(9)}`);
-      continue;
-    }
-
-    const speedup = sql.avg > 0 && mem.avg > 0 ? Math.round(sql.avg / mem.avg) + '×' : '—';
-    const cachedStr = cached && !cached.failed ? fmt(cached.avg) : '—';
-
-    console.log(
-      `${sql.name.padEnd(24)} ${fmt(sql.avg).padStart(9)} ${fmt(mem.avg).padStart(9)} ${cachedStr.padStart(9)} ${speedup.padStart(9)} ${fmtSize(sql.bytes).padStart(10)} ${fmtSize(mem.bytes).padStart(10)}`
-    );
-  }
-
-  // Summary
-  const sqlTotal = sqlResults.filter(r => !r.failed).reduce((s, r) => s + r.avg, 0);
-  const memTotal = memResults.filter(r => !r.failed).reduce((s, r) => s + r.avg, 0);
-  console.log(`${'─'.repeat(24)} ${'─'.repeat(9)} ${'─'.repeat(9)} ${'─'.repeat(9)} ${'─'.repeat(9)}`);
-  console.log(`${'TOTAL'.padEnd(24)} ${fmt(sqlTotal).padStart(9)} ${fmt(memTotal).padStart(9)} ${''.padStart(9)} ${(Math.round(sqlTotal/memTotal)+'×').padStart(9)}`);
-  console.log(`\n${'═'.repeat(W)}\n`);
-}
-
-run().catch(e => { console.error(e); process.exit(1); });

cmd/ingestor/decoder.go

@@ -72,8 +72,8 @@ type Header struct {
 
 // TransportCodes are present on TRANSPORT_FLOOD and TRANSPORT_DIRECT routes.
 type TransportCodes struct {
-	NextHop string `json:"nextHop"`
-	LastHop string `json:"lastHop"`
+	Code1 string `json:"code1"`
+	Code2 string `json:"code2"`
 }
 
 // Path holds decoded path/hop information.
@@ -92,6 +92,8 @@ type AdvertFlags struct {
 	Room        bool `json:"room"`
 	Sensor      bool `json:"sensor"`
 	HasLocation bool `json:"hasLocation"`
+	HasFeat1    bool `json:"hasFeat1"`
+	HasFeat2    bool `json:"hasFeat2"`
 	HasName     bool `json:"hasName"`
 }
 
@@ -111,6 +113,8 @@ type Payload struct {
 	Lat           *float64     `json:"lat,omitempty"`
 	Lon           *float64     `json:"lon,omitempty"`
 	Name          string       `json:"name,omitempty"`
+	Feat1         *int         `json:"feat1,omitempty"`
+	Feat2         *int         `json:"feat2,omitempty"`
 	BatteryMv     *int         `json:"battery_mv,omitempty"`
 	TemperatureC  *float64     `json:"temperature_c,omitempty"`
 	ChannelHash   int          `json:"channelHash,omitempty"`
@@ -123,6 +127,8 @@ type Payload struct {
 	EphemeralPubKey string     `json:"ephemeralPubKey,omitempty"`
 	PathData      string       `json:"pathData,omitempty"`
 	Tag           uint32       `json:"tag,omitempty"`
+	AuthCode      uint32       `json:"authCode,omitempty"`
+	TraceFlags    *int         `json:"traceFlags,omitempty"`
 	RawHex        string       `json:"raw,omitempty"`
 	Error         string       `json:"error,omitempty"`
 }
@@ -199,14 +205,13 @@ func decodeEncryptedPayload(typeName string, buf []byte) Payload {
 }
 
 func decodeAck(buf []byte) Payload {
-	if len(buf) < 6 {
+	if len(buf) < 4 {
 		return Payload{Type: "ACK", Error: "too short", RawHex: hex.EncodeToString(buf)}
 	}
+	checksum := binary.LittleEndian.Uint32(buf[0:4])
 	return Payload{
 		Type:      "ACK",
-		DestHash:  hex.EncodeToString(buf[0:1]),
-		SrcHash:   hex.EncodeToString(buf[1:2]),
-		ExtraHash: hex.EncodeToString(buf[2:6]),
+		ExtraHash: fmt.Sprintf("%08x", checksum),
 	}
 }
 
@@ -231,6 +236,8 @@ func decodeAdvert(buf []byte) Payload {
 	if len(appdata) > 0 {
 		flags := appdata[0]
 		advType := int(flags & 0x0F)
+		hasFeat1 := flags&0x20 != 0
+		hasFeat2 := flags&0x40 != 0
 		p.Flags = &AdvertFlags{
 			Raw:         int(flags),
 			Type:        advType,
@@ -239,6 +246,8 @@ func decodeAdvert(buf []byte) Payload {
 			Room:        advType == 3,
 			Sensor:      advType == 4,
 			HasLocation: flags&0x10 != 0,
+			HasFeat1:    hasFeat1,
+			HasFeat2:    hasFeat2,
 			HasName:     flags&0x80 != 0,
 		}
 
@@ -252,6 +261,16 @@ func decodeAdvert(buf []byte) Payload {
 			p.Lon = &lon
 			off += 8
 		}
+		if hasFeat1 && len(appdata) >= off+2 {
+			feat1 := int(binary.LittleEndian.Uint16(appdata[off : off+2]))
+			p.Feat1 = &feat1
+			off += 2
+		}
+		if hasFeat2 && len(appdata) >= off+2 {
+			feat2 := int(binary.LittleEndian.Uint16(appdata[off : off+2]))
+			p.Feat2 = &feat2
+			off += 2
+		}
 		if p.Flags.HasName {
 			// Find null terminator to separate name from trailing telemetry bytes
 			nameEnd := len(appdata)
@@ -469,15 +488,22 @@ func decodePathPayload(buf []byte) Payload {
 }
 
 func decodeTrace(buf []byte) Payload {
-	if len(buf) < 12 {
+	if len(buf) < 9 {
 		return Payload{Type: "TRACE", Error: "too short", RawHex: hex.EncodeToString(buf)}
 	}
-	return Payload{
-		Type:     "TRACE",
-		DestHash: hex.EncodeToString(buf[5:11]),
-		SrcHash:  hex.EncodeToString(buf[11:12]),
-		Tag:      binary.LittleEndian.Uint32(buf[1:5]),
+	tag := binary.LittleEndian.Uint32(buf[0:4])
+	authCode := binary.LittleEndian.Uint32(buf[4:8])
+	flags := int(buf[8])
+	p := Payload{
+		Type:       "TRACE",
+		Tag:        tag,
+		AuthCode:   authCode,
+		TraceFlags: &flags,
 	}
+	if len(buf) > 9 {
+		p.PathData = hex.EncodeToString(buf[9:])
+	}
+	return p
 }
 
 func decodePayload(payloadType int, buf []byte, channelKeys map[string]string) Payload {
@@ -520,8 +546,7 @@ func DecodePacket(hexString string, channelKeys map[string]string) (*DecodedPack
 	}
 
 	header := decodeHeader(buf[0])
-	pathByte := buf[1]
-	offset := 2
+	offset := 1
 
 	var tc *TransportCodes
 	if isTransportRoute(header.RouteType) {
@@ -529,12 +554,18 @@ func DecodePacket(hexString string, channelKeys map[string]string) (*DecodedPack
 			return nil, fmt.Errorf("packet too short for transport codes")
 		}
 		tc = &TransportCodes{
-			NextHop: strings.ToUpper(hex.EncodeToString(buf[offset : offset+2])),
-			LastHop: strings.ToUpper(hex.EncodeToString(buf[offset+2 : offset+4])),
+			Code1: strings.ToUpper(hex.EncodeToString(buf[offset : offset+2])),
+			Code2: strings.ToUpper(hex.EncodeToString(buf[offset+2 : offset+4])),
 		}
 		offset += 4
 	}
 
+	if offset >= len(buf) {
+		return nil, fmt.Errorf("packet too short (no path byte)")
+	}
+	pathByte := buf[offset]
+	offset++
+
 	path, bytesConsumed := decodePath(pathByte, buf, offset)
 	offset += bytesConsumed
 
@@ -562,16 +593,24 @@ func ComputeContentHash(rawHex string) string {
 		return rawHex
 	}
 
-	pathByte := buf[1]
+	headerByte := buf[0]
+	offset := 1
+	if isTransportRoute(int(headerByte & 0x03)) {
+		offset += 4
+	}
+	if offset >= len(buf) {
+		if len(rawHex) >= 16 {
+			return rawHex[:16]
+		}
+		return rawHex
+	}
+	pathByte := buf[offset]
+	offset++
 	hashSize := int((pathByte>>6)&0x3) + 1
 	hashCount := int(pathByte & 0x3F)
 	pathBytes := hashSize * hashCount
 
-	headerByte := buf[0]
-	payloadStart := 2 + pathBytes
-	if isTransportRoute(int(headerByte & 0x03)) {
-		payloadStart += 4
-	}
+	payloadStart := offset + pathBytes
 	if payloadStart > len(buf) {
 		if len(rawHex) >= 16 {
 			return rawHex[:16]

cmd/ingestor/decoder_test.go

@@ -129,7 +129,8 @@ func TestDecodePath3ByteHashes(t *testing.T) {
 
 func TestTransportCodes(t *testing.T) {
 	// Route type 0 (TRANSPORT_FLOOD) should have transport codes
-	hex := "1400" + "AABB" + "CCDD" + "1A" + strings.Repeat("00", 10)
+	// Firmware order: header + transport_codes(4) + path_len + path + payload
+	hex := "14" + "AABB" + "CCDD" + "00" + strings.Repeat("00", 10)
 	pkt, err := DecodePacket(hex, nil)
 	if err != nil {
 		t.Fatal(err)
@@ -140,11 +141,11 @@ func TestTransportCodes(t *testing.T) {
 	if pkt.TransportCodes == nil {
 		t.Fatal("transportCodes should not be nil for TRANSPORT_FLOOD")
 	}
-	if pkt.TransportCodes.NextHop != "AABB" {
-		t.Errorf("nextHop=%s, want AABB", pkt.TransportCodes.NextHop)
+	if pkt.TransportCodes.Code1 != "AABB" {
+		t.Errorf("code1=%s, want AABB", pkt.TransportCodes.Code1)
 	}
-	if pkt.TransportCodes.LastHop != "CCDD" {
-		t.Errorf("lastHop=%s, want CCDD", pkt.TransportCodes.LastHop)
+	if pkt.TransportCodes.Code2 != "CCDD" {
+		t.Errorf("code2=%s, want CCDD", pkt.TransportCodes.Code2)
 	}
 
 	// Route type 1 (FLOOD) should NOT have transport codes
@@ -537,10 +538,11 @@ func TestDecodeTraceShort(t *testing.T) {
 
 func TestDecodeTraceValid(t *testing.T) {
 	buf := make([]byte, 16)
-	buf[0] = 0x00
-	buf[1] = 0x01 // tag LE uint32 = 1
-	buf[5] = 0xAA // destHash start
-	buf[11] = 0xBB
+	// tag(4) + authCode(4) + flags(1) + pathData
+	binary.LittleEndian.PutUint32(buf[0:4], 1)          // tag = 1
+	binary.LittleEndian.PutUint32(buf[4:8], 0xDEADBEEF) // authCode
+	buf[8] = 0x02                                         // flags
+	buf[9] = 0xAA                                         // path data
 	p := decodeTrace(buf)
 	if p.Error != "" {
 		t.Errorf("unexpected error: %s", p.Error)
@@ -548,9 +550,18 @@ func TestDecodeTraceValid(t *testing.T) {
 	if p.Tag != 1 {
 		t.Errorf("tag=%d, want 1", p.Tag)
 	}
+	if p.AuthCode != 0xDEADBEEF {
+		t.Errorf("authCode=%d, want 0xDEADBEEF", p.AuthCode)
+	}
+	if p.TraceFlags == nil || *p.TraceFlags != 2 {
+		t.Errorf("traceFlags=%v, want 2", p.TraceFlags)
+	}
 	if p.Type != "TRACE" {
 		t.Errorf("type=%s, want TRACE", p.Type)
 	}
+	if p.PathData == "" {
+		t.Error("pathData should not be empty")
+	}
 }
 
 func TestDecodeAdvertShort(t *testing.T) {
@@ -833,10 +844,9 @@ func TestComputeContentHashShortHex(t *testing.T) {
 }
 
 func TestComputeContentHashTransportRoute(t *testing.T) {
-	// Route type 0 (TRANSPORT_FLOOD) with no path hops + 4 transport code bytes
-	// header=0x14 (TRANSPORT_FLOOD, ADVERT), path=0x00 (0 hops)
-	// transport codes = 4 bytes, then payload
-	hex := "1400" + "AABBCCDD" + strings.Repeat("EE", 10)
+	// Route type 0 (TRANSPORT_FLOOD) with transport codes then path=0x00 (0 hops)
+	// header=0x14 (TRANSPORT_FLOOD, ADVERT), transport(4), path=0x00
+	hex := "14" + "AABBCCDD" + "00" + strings.Repeat("EE", 10)
 	hash := ComputeContentHash(hex)
 	if len(hash) != 16 {
 		t.Errorf("hash length=%d, want 16", len(hash))
@@ -870,12 +880,10 @@ func TestComputeContentHashPayloadBeyondBufferLongHex(t *testing.T) {
 
 func TestComputeContentHashTransportBeyondBuffer(t *testing.T) {
 	// Transport route (0x00 = TRANSPORT_FLOOD) with path claiming some bytes
-	// total buffer too short for transport codes + path
-	// header=0x00, pathByte=0x02 (2 hops, 1-byte hash), then only 2 more bytes
-	// payloadStart = 2 + 2 + 4(transport) = 8, but buffer only 6 bytes
-	hex := "0002" + "AABB" + strings.Repeat("CC", 6) // 20 chars = 10 bytes
+	// header=0x00, transport(4), pathByte=0x02 (2 hops, 1-byte hash)
+	// offset=1+4+1+2=8, buffer needs to be >= 8
+	hex := "00" + "AABB" + "CCDD" + "02" + strings.Repeat("CC", 6) // 20 chars = 10 bytes  
 	hash := ComputeContentHash(hex)
-	// payloadStart = 2 + 2 + 4 = 8, buffer is 10 bytes → should work
 	if len(hash) != 16 {
 		t.Errorf("hash length=%d, want 16", len(hash))
 	}
@@ -913,8 +921,8 @@ func TestDecodePacketWithNewlines(t *testing.T) {
 }
 
 func TestDecodePacketTransportRouteTooShort(t *testing.T) {
-	// TRANSPORT_FLOOD (route=0) but only 3 bytes total → too short for transport codes
-	_, err := DecodePacket("140011", nil)
+	// TRANSPORT_FLOOD (route=0) but only 2 bytes total → too short for transport codes
+	_, err := DecodePacket("1400", nil)
 	if err == nil {
 		t.Error("expected error for transport route with too-short buffer")
 	}
@@ -931,16 +939,19 @@ func TestDecodeAckShort(t *testing.T) {
 }
 
 func TestDecodeAckValid(t *testing.T) {
-	buf := []byte{0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF}
+	buf := []byte{0xAA, 0xBB, 0xCC, 0xDD}
 	p := decodeAck(buf)
 	if p.Error != "" {
 		t.Errorf("unexpected error: %s", p.Error)
 	}
-	if p.DestHash != "aa" {
-		t.Errorf("destHash=%s, want aa", p.DestHash)
+	if p.ExtraHash != "ddccbbaa" {
+		t.Errorf("extraHash=%s, want ddccbbaa", p.ExtraHash)
 	}
-	if p.ExtraHash != "ccddeeff" {
-		t.Errorf("extraHash=%s, want ccddeeff", p.ExtraHash)
+	if p.DestHash != "" {
+		t.Errorf("destHash should be empty, got %s", p.DestHash)
+	}
+	if p.SrcHash != "" {
+		t.Errorf("srcHash should be empty, got %s", p.SrcHash)
 	}
 }
 

cmd/server/config.go

@@ -45,6 +45,14 @@ type Config struct {
 	CacheTTL map[string]interface{} `json:"cacheTTL"`
 
 	Retention *RetentionConfig `json:"retention,omitempty"`
+
+	PacketStore *PacketStoreConfig `json:"packetStore,omitempty"`
+}
+
+// PacketStoreConfig controls in-memory packet store limits.
+type PacketStoreConfig struct {
+	RetentionHours float64 `json:"retentionHours"` // max age of packets in hours (0 = unlimited)
+	MaxMemoryMB    int     `json:"maxMemoryMB"`     // hard memory ceiling in MB (0 = unlimited)
 }
 
 type RetentionConfig struct {
@@ -60,10 +68,10 @@ func (c *Config) NodeDaysOrDefault() int {
 }
 
 type HealthThresholds struct {
-	InfraDegradedMs int `json:"infraDegradedMs"`
-	InfraSilentMs   int `json:"infraSilentMs"`
-	NodeDegradedMs  int `json:"nodeDegradedMs"`
-	NodeSilentMs    int `json:"nodeSilentMs"`
+	InfraDegradedHours float64 `json:"infraDegradedHours"`
+	InfraSilentHours   float64 `json:"infraSilentHours"`
+	NodeDegradedHours  float64 `json:"nodeDegradedHours"`
+	NodeSilentHours    float64 `json:"nodeSilentHours"`
 }
 
 // ThemeFile mirrors theme.json overlay.
@@ -126,34 +134,46 @@ func LoadTheme(baseDirs ...string) *ThemeFile {
 
 func (c *Config) GetHealthThresholds() HealthThresholds {
 	h := HealthThresholds{
-		InfraDegradedMs: 86400000,
-		InfraSilentMs:   259200000,
-		NodeDegradedMs:  3600000,
-		NodeSilentMs:    86400000,
+		InfraDegradedHours: 24,
+		InfraSilentHours:   72,
+		NodeDegradedHours:  1,
+		NodeSilentHours:    24,
 	}
 	if c.HealthThresholds != nil {
-		if c.HealthThresholds.InfraDegradedMs > 0 {
-			h.InfraDegradedMs = c.HealthThresholds.InfraDegradedMs
+		if c.HealthThresholds.InfraDegradedHours > 0 {
+			h.InfraDegradedHours = c.HealthThresholds.InfraDegradedHours
 		}
-		if c.HealthThresholds.InfraSilentMs > 0 {
-			h.InfraSilentMs = c.HealthThresholds.InfraSilentMs
+		if c.HealthThresholds.InfraSilentHours > 0 {
+			h.InfraSilentHours = c.HealthThresholds.InfraSilentHours
 		}
-		if c.HealthThresholds.NodeDegradedMs > 0 {
-			h.NodeDegradedMs = c.HealthThresholds.NodeDegradedMs
+		if c.HealthThresholds.NodeDegradedHours > 0 {
+			h.NodeDegradedHours = c.HealthThresholds.NodeDegradedHours
 		}
-		if c.HealthThresholds.NodeSilentMs > 0 {
-			h.NodeSilentMs = c.HealthThresholds.NodeSilentMs
+		if c.HealthThresholds.NodeSilentHours > 0 {
+			h.NodeSilentHours = c.HealthThresholds.NodeSilentHours
 		}
 	}
 	return h
 }
 
-// GetHealthMs returns degraded/silent thresholds for a given role.
+// GetHealthMs returns degraded/silent thresholds in ms for a given role.
 func (h HealthThresholds) GetHealthMs(role string) (degradedMs, silentMs int) {
+	const hourMs = 3600000
 	if role == "repeater" || role == "room" {
-		return h.InfraDegradedMs, h.InfraSilentMs
+		return int(h.InfraDegradedHours * hourMs), int(h.InfraSilentHours * hourMs)
+	}
+	return int(h.NodeDegradedHours * hourMs), int(h.NodeSilentHours * hourMs)
+}
+
+// ToClientMs returns the thresholds as ms for the frontend.
+func (h HealthThresholds) ToClientMs() map[string]int {
+	const hourMs = 3600000
+	return map[string]int{
+		"infraDegradedMs": int(h.InfraDegradedHours * hourMs),
+		"infraSilentMs":   int(h.InfraSilentHours * hourMs),
+		"nodeDegradedMs":  int(h.NodeDegradedHours * hourMs),
+		"nodeSilentMs":    int(h.NodeSilentHours * hourMs),
 	}
-	return h.NodeDegradedMs, h.NodeSilentMs
 }
 
 func (c *Config) ResolveDBPath(baseDir string) string {

cmd/server/config_test.go

@@ -23,10 +23,10 @@ func TestLoadConfigValidJSON(t *testing.T) {
 			"SJC": "San Jose",
 		},
 		"healthThresholds": map[string]interface{}{
-			"infraDegradedMs": 100000,
-			"infraSilentMs":   200000,
-			"nodeDegradedMs":  50000,
-			"nodeSilentMs":    100000,
+			"infraDegradedHours": 2,
+			"infraSilentHours":   4,
+			"nodeDegradedHours":  0.5,
+			"nodeSilentHours":    2,
 		},
 		"liveMap": map[string]interface{}{
 			"propagationBufferMs": 3000,
@@ -178,68 +178,68 @@ func TestGetHealthThresholdsDefaults(t *testing.T) {
 	cfg := &Config{}
 	ht := cfg.GetHealthThresholds()
 
-	if ht.InfraDegradedMs != 86400000 {
-		t.Errorf("expected 86400000, got %d", ht.InfraDegradedMs)
+	if ht.InfraDegradedHours != 24 {
+		t.Errorf("expected 24, got %v", ht.InfraDegradedHours)
 	}
-	if ht.InfraSilentMs != 259200000 {
-		t.Errorf("expected 259200000, got %d", ht.InfraSilentMs)
+	if ht.InfraSilentHours != 72 {
+		t.Errorf("expected 72, got %v", ht.InfraSilentHours)
 	}
-	if ht.NodeDegradedMs != 3600000 {
-		t.Errorf("expected 3600000, got %d", ht.NodeDegradedMs)
+	if ht.NodeDegradedHours != 1 {
+		t.Errorf("expected 1, got %v", ht.NodeDegradedHours)
 	}
-	if ht.NodeSilentMs != 86400000 {
-		t.Errorf("expected 86400000, got %d", ht.NodeSilentMs)
+	if ht.NodeSilentHours != 24 {
+		t.Errorf("expected 24, got %v", ht.NodeSilentHours)
 	}
 }
 
 func TestGetHealthThresholdsCustom(t *testing.T) {
 	cfg := &Config{
 		HealthThresholds: &HealthThresholds{
-			InfraDegradedMs: 100000,
-			InfraSilentMs:   200000,
-			NodeDegradedMs:  50000,
-			NodeSilentMs:    100000,
+			InfraDegradedHours: 2,
+			InfraSilentHours:   4,
+			NodeDegradedHours:  0.5,
+			NodeSilentHours:    2,
 		},
 	}
 	ht := cfg.GetHealthThresholds()
 
-	if ht.InfraDegradedMs != 100000 {
-		t.Errorf("expected 100000, got %d", ht.InfraDegradedMs)
+	if ht.InfraDegradedHours != 2 {
+		t.Errorf("expected 2, got %v", ht.InfraDegradedHours)
 	}
-	if ht.InfraSilentMs != 200000 {
-		t.Errorf("expected 200000, got %d", ht.InfraSilentMs)
+	if ht.InfraSilentHours != 4 {
+		t.Errorf("expected 4, got %v", ht.InfraSilentHours)
 	}
-	if ht.NodeDegradedMs != 50000 {
-		t.Errorf("expected 50000, got %d", ht.NodeDegradedMs)
+	if ht.NodeDegradedHours != 0.5 {
+		t.Errorf("expected 0.5, got %v", ht.NodeDegradedHours)
 	}
-	if ht.NodeSilentMs != 100000 {
-		t.Errorf("expected 100000, got %d", ht.NodeSilentMs)
+	if ht.NodeSilentHours != 2 {
+		t.Errorf("expected 2, got %v", ht.NodeSilentHours)
 	}
 }
 
 func TestGetHealthThresholdsPartialCustom(t *testing.T) {
 	cfg := &Config{
 		HealthThresholds: &HealthThresholds{
-			InfraDegradedMs: 100000,
+			InfraDegradedHours: 2,
 			// Others left as zero → should use defaults
 		},
 	}
 	ht := cfg.GetHealthThresholds()
 
-	if ht.InfraDegradedMs != 100000 {
-		t.Errorf("expected 100000, got %d", ht.InfraDegradedMs)
+	if ht.InfraDegradedHours != 2 {
+		t.Errorf("expected 2, got %v", ht.InfraDegradedHours)
 	}
-	if ht.InfraSilentMs != 259200000 {
-		t.Errorf("expected default 259200000, got %d", ht.InfraSilentMs)
+	if ht.InfraSilentHours != 72 {
+		t.Errorf("expected default 72, got %v", ht.InfraSilentHours)
 	}
 }
 
 func TestGetHealthMs(t *testing.T) {
 	ht := HealthThresholds{
-		InfraDegradedMs: 86400000,
-		InfraSilentMs:   259200000,
-		NodeDegradedMs:  3600000,
-		NodeSilentMs:    86400000,
+		InfraDegradedHours: 24,
+		InfraSilentHours:   72,
+		NodeDegradedHours:  1,
+		NodeSilentHours:    24,
 	}
 
 	tests := []struct {

cmd/server/db_test.go

@@ -17,6 +17,8 @@ func setupTestDB(t *testing.T) *DB {
 	if err != nil {
 		t.Fatal(err)
 	}
+	// Force single connection so all goroutines share the same in-memory DB
+	conn.SetMaxOpenConns(1)
 
 	// Create schema matching MeshCore Analyzer v3
 	schema := `
@@ -511,10 +513,10 @@ func TestGetNetworkStatus(t *testing.T) {
 	seedTestData(t, db)
 
 	ht := HealthThresholds{
-		InfraDegradedMs: 86400000,
-		InfraSilentMs:   259200000,
-		NodeDegradedMs:  3600000,
-		NodeSilentMs:    86400000,
+		InfraDegradedHours: 24,
+		InfraSilentHours:   72,
+		NodeDegradedHours:  1,
+		NodeSilentHours:    24,
 	}
 	result, err := db.GetNetworkStatus(ht)
 	if err != nil {
@@ -1048,10 +1050,10 @@ func TestGetNetworkStatusDateFormats(t *testing.T) {
 		VALUES ('node4444', 'NodeBad', 'sensor', 'not-a-date')`)
 
 	ht := HealthThresholds{
-		InfraDegradedMs: 86400000,
-		InfraSilentMs:   259200000,
-		NodeDegradedMs:  3600000,
-		NodeSilentMs:    86400000,
+		InfraDegradedHours: 24,
+		InfraSilentHours:   72,
+		NodeDegradedHours:  1,
+		NodeSilentHours:    24,
 	}
 	result, err := db.GetNetworkStatus(ht)
 	if err != nil {

cmd/server/decoder.go

@@ -54,8 +54,8 @@ type Header struct {
 
 // TransportCodes are present on TRANSPORT_FLOOD and TRANSPORT_DIRECT routes.
 type TransportCodes struct {
-	NextHop string `json:"nextHop"`
-	LastHop string `json:"lastHop"`
+	Code1 string `json:"code1"`
+	Code2 string `json:"code2"`
 }
 
 // Path holds decoded path/hop information.
@@ -74,6 +74,8 @@ type AdvertFlags struct {
 	Room        bool `json:"room"`
 	Sensor      bool `json:"sensor"`
 	HasLocation bool `json:"hasLocation"`
+	HasFeat1    bool `json:"hasFeat1"`
+	HasFeat2    bool `json:"hasFeat2"`
 	HasName     bool `json:"hasName"`
 }
 
@@ -97,6 +99,8 @@ type Payload struct {
 	EphemeralPubKey string       `json:"ephemeralPubKey,omitempty"`
 	PathData        string       `json:"pathData,omitempty"`
 	Tag             uint32       `json:"tag,omitempty"`
+	AuthCode        uint32       `json:"authCode,omitempty"`
+	TraceFlags      *int         `json:"traceFlags,omitempty"`
 	RawHex          string       `json:"raw,omitempty"`
 	Error           string       `json:"error,omitempty"`
 }
@@ -173,14 +177,13 @@ func decodeEncryptedPayload(typeName string, buf []byte) Payload {
 }
 
 func decodeAck(buf []byte) Payload {
-	if len(buf) < 6 {
+	if len(buf) < 4 {
 		return Payload{Type: "ACK", Error: "too short", RawHex: hex.EncodeToString(buf)}
 	}
+	checksum := binary.LittleEndian.Uint32(buf[0:4])
 	return Payload{
 		Type:      "ACK",
-		DestHash:  hex.EncodeToString(buf[0:1]),
-		SrcHash:   hex.EncodeToString(buf[1:2]),
-		ExtraHash: hex.EncodeToString(buf[2:6]),
+		ExtraHash: fmt.Sprintf("%08x", checksum),
 	}
 }
 
@@ -205,6 +208,8 @@ func decodeAdvert(buf []byte) Payload {
 	if len(appdata) > 0 {
 		flags := appdata[0]
 		advType := int(flags & 0x0F)
+		hasFeat1 := flags&0x20 != 0
+		hasFeat2 := flags&0x40 != 0
 		p.Flags = &AdvertFlags{
 			Raw:         int(flags),
 			Type:        advType,
@@ -213,6 +218,8 @@ func decodeAdvert(buf []byte) Payload {
 			Room:        advType == 3,
 			Sensor:      advType == 4,
 			HasLocation: flags&0x10 != 0,
+			HasFeat1:    hasFeat1,
+			HasFeat2:    hasFeat2,
 			HasName:     flags&0x80 != 0,
 		}
 
@@ -226,6 +233,12 @@ func decodeAdvert(buf []byte) Payload {
 			p.Lon = &lon
 			off += 8
 		}
+		if hasFeat1 && len(appdata) >= off+2 {
+			off += 2  // skip feat1 bytes (reserved for future use)
+		}
+		if hasFeat2 && len(appdata) >= off+2 {
+			off += 2  // skip feat2 bytes (reserved for future use)
+		}
 		if p.Flags.HasName {
 			name := string(appdata[off:])
 			name = strings.TrimRight(name, "\x00")
@@ -276,15 +289,22 @@ func decodePathPayload(buf []byte) Payload {
 }
 
 func decodeTrace(buf []byte) Payload {
-	if len(buf) < 12 {
+	if len(buf) < 9 {
 		return Payload{Type: "TRACE", Error: "too short", RawHex: hex.EncodeToString(buf)}
 	}
-	return Payload{
-		Type:     "TRACE",
-		DestHash: hex.EncodeToString(buf[5:11]),
-		SrcHash:  hex.EncodeToString(buf[11:12]),
-		Tag:      binary.LittleEndian.Uint32(buf[1:5]),
+	tag := binary.LittleEndian.Uint32(buf[0:4])
+	authCode := binary.LittleEndian.Uint32(buf[4:8])
+	flags := int(buf[8])
+	p := Payload{
+		Type:       "TRACE",
+		Tag:        tag,
+		AuthCode:   authCode,
+		TraceFlags: &flags,
 	}
+	if len(buf) > 9 {
+		p.PathData = hex.EncodeToString(buf[9:])
+	}
+	return p
 }
 
 func decodePayload(payloadType int, buf []byte) Payload {
@@ -327,8 +347,7 @@ func DecodePacket(hexString string) (*DecodedPacket, error) {
 	}
 
 	header := decodeHeader(buf[0])
-	pathByte := buf[1]
-	offset := 2
+	offset := 1
 
 	var tc *TransportCodes
 	if isTransportRoute(header.RouteType) {
@@ -336,12 +355,18 @@ func DecodePacket(hexString string) (*DecodedPacket, error) {
 			return nil, fmt.Errorf("packet too short for transport codes")
 		}
 		tc = &TransportCodes{
-			NextHop: strings.ToUpper(hex.EncodeToString(buf[offset : offset+2])),
-			LastHop: strings.ToUpper(hex.EncodeToString(buf[offset+2 : offset+4])),
+			Code1: strings.ToUpper(hex.EncodeToString(buf[offset : offset+2])),
+			Code2: strings.ToUpper(hex.EncodeToString(buf[offset+2 : offset+4])),
 		}
 		offset += 4
 	}
 
+	if offset >= len(buf) {
+		return nil, fmt.Errorf("packet too short (no path byte)")
+	}
+	pathByte := buf[offset]
+	offset++
+
 	path, bytesConsumed := decodePath(pathByte, buf, offset)
 	offset += bytesConsumed
 
@@ -367,16 +392,24 @@ func ComputeContentHash(rawHex string) string {
 		return rawHex
 	}
 
-	pathByte := buf[1]
+	headerByte := buf[0]
+	offset := 1
+	if isTransportRoute(int(headerByte & 0x03)) {
+		offset += 4
+	}
+	if offset >= len(buf) {
+		if len(rawHex) >= 16 {
+			return rawHex[:16]
+		}
+		return rawHex
+	}
+	pathByte := buf[offset]
+	offset++
 	hashSize := int((pathByte>>6)&0x3) + 1
 	hashCount := int(pathByte & 0x3F)
 	pathBytes := hashSize * hashCount
 
-	headerByte := buf[0]
-	payloadStart := 2 + pathBytes
-	if isTransportRoute(int(headerByte & 0x03)) {
-		payloadStart += 4
-	}
+	payloadStart := offset + pathBytes
 	if payloadStart > len(buf) {
 		if len(rawHex) >= 16 {
 			return rawHex[:16]

cmd/server/eviction_test.go

@@ -0,0 +1,252 @@
+package main
+
+import (
+	"fmt"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+// makeTestStore creates a PacketStore with fake packets for eviction testing.
+// It does NOT use a DB — indexes are populated manually.
+func makeTestStore(count int, startTime time.Time, intervalMin int) *PacketStore {
+	store := &PacketStore{
+		packets:       make([]*StoreTx, 0, count),
+		byHash:        make(map[string]*StoreTx, count),
+		byTxID:        make(map[int]*StoreTx, count),
+		byObsID:       make(map[int]*StoreObs, count*2),
+		byObserver:    make(map[string][]*StoreObs),
+		byNode:        make(map[string][]*StoreTx),
+		nodeHashes:    make(map[string]map[string]bool),
+		byPayloadType: make(map[int][]*StoreTx),
+		spIndex:       make(map[string]int),
+		distHops:      make([]distHopRecord, 0),
+		distPaths:     make([]distPathRecord, 0),
+		rfCache:       make(map[string]*cachedResult),
+		topoCache:     make(map[string]*cachedResult),
+		hashCache:     make(map[string]*cachedResult),
+		chanCache:     make(map[string]*cachedResult),
+		distCache:     make(map[string]*cachedResult),
+		subpathCache:  make(map[string]*cachedResult),
+		rfCacheTTL:    15 * time.Second,
+	}
+
+	obsID := 1000
+	for i := 0; i < count; i++ {
+		ts := startTime.Add(time.Duration(i*intervalMin) * time.Minute)
+		hash := fmt.Sprintf("hash%04d", i)
+		txID := i + 1
+		pt := 4 // ADVERT
+		decodedJSON := fmt.Sprintf(`{"pubKey":"pk%04d"}`, i)
+
+		tx := &StoreTx{
+			ID:          txID,
+			Hash:        hash,
+			FirstSeen:   ts.UTC().Format(time.RFC3339),
+			PayloadType: &pt,
+			DecodedJSON: decodedJSON,
+			PathJSON:    `["aa","bb","cc"]`,
+		}
+
+		// Add 2 observations per tx
+		for j := 0; j < 2; j++ {
+			obsID++
+			obsIDStr := fmt.Sprintf("obs%d", j)
+			obs := &StoreObs{
+				ID:             obsID,
+				TransmissionID: txID,
+				ObserverID:     obsIDStr,
+				ObserverName:   fmt.Sprintf("Observer%d", j),
+				Timestamp:      ts.UTC().Format(time.RFC3339),
+			}
+			tx.Observations = append(tx.Observations, obs)
+			tx.ObservationCount++
+			store.byObsID[obsID] = obs
+			store.byObserver[obsIDStr] = append(store.byObserver[obsIDStr], obs)
+			store.totalObs++
+		}
+
+		store.packets = append(store.packets, tx)
+		store.byHash[hash] = tx
+		store.byTxID[txID] = tx
+		store.byPayloadType[pt] = append(store.byPayloadType[pt], tx)
+
+		// Index by node
+		pk := fmt.Sprintf("pk%04d", i)
+		if store.nodeHashes[pk] == nil {
+			store.nodeHashes[pk] = make(map[string]bool)
+		}
+		store.nodeHashes[pk][hash] = true
+		store.byNode[pk] = append(store.byNode[pk], tx)
+
+		// Add to distance index
+		store.distHops = append(store.distHops, distHopRecord{tx: tx, Hash: hash})
+		store.distPaths = append(store.distPaths, distPathRecord{tx: tx, Hash: hash})
+
+		// Subpath index
+		addTxToSubpathIndex(store.spIndex, tx)
+	}
+
+	return store
+}
+
+func TestEvictStale_TimeBasedEviction(t *testing.T) {
+	now := time.Now().UTC()
+	// 100 packets: first 50 are 48h old, last 50 are 1h old
+	store := makeTestStore(100, now.Add(-48*time.Hour), 0)
+	// Override: set first 50 to 48h ago, last 50 to 1h ago
+	for i := 0; i < 50; i++ {
+		store.packets[i].FirstSeen = now.Add(-48 * time.Hour).Format(time.RFC3339)
+	}
+	for i := 50; i < 100; i++ {
+		store.packets[i].FirstSeen = now.Add(-1 * time.Hour).Format(time.RFC3339)
+	}
+
+	store.retentionHours = 24
+
+	evicted := store.EvictStale()
+	if evicted != 50 {
+		t.Fatalf("expected 50 evicted, got %d", evicted)
+	}
+	if len(store.packets) != 50 {
+		t.Fatalf("expected 50 remaining, got %d", len(store.packets))
+	}
+	if len(store.byHash) != 50 {
+		t.Fatalf("expected 50 in byHash, got %d", len(store.byHash))
+	}
+	if len(store.byTxID) != 50 {
+		t.Fatalf("expected 50 in byTxID, got %d", len(store.byTxID))
+	}
+	// 50 remaining * 2 obs each = 100 obs
+	if store.totalObs != 100 {
+		t.Fatalf("expected 100 obs remaining, got %d", store.totalObs)
+	}
+	if len(store.byObsID) != 100 {
+		t.Fatalf("expected 100 in byObsID, got %d", len(store.byObsID))
+	}
+	if atomic.LoadInt64(&store.evicted) != 50 {
+		t.Fatalf("expected evicted counter=50, got %d", atomic.LoadInt64(&store.evicted))
+	}
+
+	// Verify evicted hashes are gone
+	if _, ok := store.byHash["hash0000"]; ok {
+		t.Fatal("hash0000 should have been evicted")
+	}
+	// Verify remaining hashes exist
+	if _, ok := store.byHash["hash0050"]; !ok {
+		t.Fatal("hash0050 should still exist")
+	}
+
+	// Verify distance indexes cleaned
+	if len(store.distHops) != 50 {
+		t.Fatalf("expected 50 distHops, got %d", len(store.distHops))
+	}
+	if len(store.distPaths) != 50 {
+		t.Fatalf("expected 50 distPaths, got %d", len(store.distPaths))
+	}
+}
+
+func TestEvictStale_NoEvictionWhenDisabled(t *testing.T) {
+	now := time.Now().UTC()
+	store := makeTestStore(10, now.Add(-48*time.Hour), 60)
+	// No retention set (defaults to 0)
+
+	evicted := store.EvictStale()
+	if evicted != 0 {
+		t.Fatalf("expected 0 evicted, got %d", evicted)
+	}
+	if len(store.packets) != 10 {
+		t.Fatalf("expected 10 remaining, got %d", len(store.packets))
+	}
+}
+
+func TestEvictStale_MemoryBasedEviction(t *testing.T) {
+	now := time.Now().UTC()
+	// Create enough packets to exceed a small memory limit
+	// 1000 packets * 5KB + 2000 obs * 500B ≈ 6MB
+	store := makeTestStore(1000, now.Add(-1*time.Hour), 0)
+	// All packets are recent (1h old) so time-based won't trigger
+	store.retentionHours = 24
+	store.maxMemoryMB = 3 // ~3MB limit, should evict roughly half
+
+	evicted := store.EvictStale()
+	if evicted == 0 {
+		t.Fatal("expected some evictions for memory cap")
+	}
+	// After eviction, estimated memory should be <= 3MB
+	estMB := store.estimatedMemoryMB()
+	if estMB > 3.5 { // small tolerance
+		t.Fatalf("expected <=3.5MB after eviction, got %.1fMB", estMB)
+	}
+}
+
+func TestEvictStale_CleansNodeIndexes(t *testing.T) {
+	now := time.Now().UTC()
+	store := makeTestStore(10, now.Add(-48*time.Hour), 0)
+	store.retentionHours = 24
+
+	// Verify node indexes exist before eviction
+	if len(store.byNode) != 10 {
+		t.Fatalf("expected 10 nodes indexed, got %d", len(store.byNode))
+	}
+	if len(store.nodeHashes) != 10 {
+		t.Fatalf("expected 10 nodeHashes, got %d", len(store.nodeHashes))
+	}
+
+	evicted := store.EvictStale()
+	if evicted != 10 {
+		t.Fatalf("expected 10 evicted, got %d", evicted)
+	}
+
+	// All should be cleaned
+	if len(store.byNode) != 0 {
+		t.Fatalf("expected 0 nodes, got %d", len(store.byNode))
+	}
+	if len(store.nodeHashes) != 0 {
+		t.Fatalf("expected 0 nodeHashes, got %d", len(store.nodeHashes))
+	}
+	if len(store.byPayloadType) != 0 {
+		t.Fatalf("expected 0 payload types, got %d", len(store.byPayloadType))
+	}
+	if len(store.byObserver) != 0 {
+		t.Fatalf("expected 0 observers, got %d", len(store.byObserver))
+	}
+}
+
+func TestEvictStale_RunEvictionThreadSafe(t *testing.T) {
+	now := time.Now().UTC()
+	store := makeTestStore(20, now.Add(-48*time.Hour), 0)
+	store.retentionHours = 24
+
+	evicted := store.RunEviction()
+	if evicted != 20 {
+		t.Fatalf("expected 20 evicted, got %d", evicted)
+	}
+}
+
+func TestStartEvictionTicker_NoopWhenDisabled(t *testing.T) {
+	store := &PacketStore{}
+	stop := store.StartEvictionTicker()
+	stop() // should not panic
+}
+
+func TestNewPacketStoreWithConfig(t *testing.T) {
+	cfg := &PacketStoreConfig{
+		RetentionHours: 48,
+		MaxMemoryMB:    512,
+	}
+	store := NewPacketStore(nil, cfg)
+	if store.retentionHours != 48 {
+		t.Fatalf("expected retentionHours=48, got %f", store.retentionHours)
+	}
+	if store.maxMemoryMB != 512 {
+		t.Fatalf("expected maxMemoryMB=512, got %d", store.maxMemoryMB)
+	}
+}
+
+func TestNewPacketStoreNilConfig(t *testing.T) {
+	store := NewPacketStore(nil, nil)
+	if store.retentionHours != 0 {
+		t.Fatalf("expected retentionHours=0, got %f", store.retentionHours)
+	}
+}

cmd/server/main.go

@@ -128,7 +128,7 @@ func main() {
 	}
 
 	// In-memory packet store
-	store := NewPacketStore(database)
+	store := NewPacketStore(database, cfg.PacketStore)
 	if err := store.Load(); err != nil {
 		log.Fatalf("[store] failed to load: %v", err)
 	}
@@ -164,6 +164,10 @@ func main() {
 	poller.store = store
 	go poller.Start()
 
+	// Start periodic eviction
+	stopEviction := store.StartEvictionTicker()
+	defer stopEviction()
+
 	// Graceful shutdown
 	httpServer := &http.Server{
 		Addr:         fmt.Sprintf(":%d", cfg.Port),

cmd/server/parity_test.go

@@ -1,403 +1,506 @@
-package main
-
-// parity_test.go — Golden fixture shape tests.
-// Validates that Go API responses match the shape of Node.js API responses.
-// Shapes were captured from the production Node.js server and stored in
-// testdata/golden/shapes.json.
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-)
-
-// shapeSpec describes the expected JSON structure from the Node.js server.
-type shapeSpec struct {
-	Type        string               `json:"type"`
-	Keys        map[string]shapeSpec `json:"keys,omitempty"`
-	ElementShape *shapeSpec           `json:"elementShape,omitempty"`
-	DynamicKeys  bool                 `json:"dynamicKeys,omitempty"`
-	ValueShape   *shapeSpec           `json:"valueShape,omitempty"`
-	RequiredKeys map[string]shapeSpec `json:"requiredKeys,omitempty"`
-}
-
-// loadShapes reads testdata/golden/shapes.json relative to this source file.
-func loadShapes(t *testing.T) map[string]shapeSpec {
-	t.Helper()
-	_, thisFile, _, _ := runtime.Caller(0)
-	dir := filepath.Dir(thisFile)
-	data, err := os.ReadFile(filepath.Join(dir, "testdata", "golden", "shapes.json"))
-	if err != nil {
-		t.Fatalf("cannot load shapes.json: %v", err)
-	}
-	var shapes map[string]shapeSpec
-	if err := json.Unmarshal(data, &shapes); err != nil {
-		t.Fatalf("cannot parse shapes.json: %v", err)
-	}
-	return shapes
-}
-
-// validateShape recursively checks that `actual` matches the expected `spec`.
-// `path` tracks the JSON path for error messages.
-// Returns a list of mismatch descriptions.
-func validateShape(actual interface{}, spec shapeSpec, path string) []string {
-	var errs []string
-
-	switch spec.Type {
-	case "null", "nullable":
-		// nullable means: value can be null OR matching type. Accept anything.
-		return nil
-	case "nullable_number":
-		// Can be null or number
-		if actual != nil {
-			if _, ok := actual.(float64); !ok {
-				errs = append(errs, fmt.Sprintf("%s: expected number or null, got %T", path, actual))
-			}
-		}
-		return errs
-	case "string":
-		if actual == nil {
-			errs = append(errs, fmt.Sprintf("%s: expected string, got null", path))
-		} else if _, ok := actual.(string); !ok {
-			errs = append(errs, fmt.Sprintf("%s: expected string, got %T", path, actual))
-		}
-	case "number":
-		if actual == nil {
-			errs = append(errs, fmt.Sprintf("%s: expected number, got null", path))
-		} else if _, ok := actual.(float64); !ok {
-			errs = append(errs, fmt.Sprintf("%s: expected number, got %T (%v)", path, actual, actual))
-		}
-	case "boolean":
-		if actual == nil {
-			errs = append(errs, fmt.Sprintf("%s: expected boolean, got null", path))
-		} else if _, ok := actual.(bool); !ok {
-			errs = append(errs, fmt.Sprintf("%s: expected boolean, got %T", path, actual))
-		}
-	case "array":
-		if actual == nil {
-			errs = append(errs, fmt.Sprintf("%s: expected array, got null (arrays must be [] not null)", path))
-			return errs
-		}
-		arr, ok := actual.([]interface{})
-		if !ok {
-			errs = append(errs, fmt.Sprintf("%s: expected array, got %T", path, actual))
-			return errs
-		}
-		if spec.ElementShape != nil && len(arr) > 0 {
-			errs = append(errs, validateShape(arr[0], *spec.ElementShape, path+"[0]")...)
-		}
-	case "object":
-		if actual == nil {
-			errs = append(errs, fmt.Sprintf("%s: expected object, got null", path))
-			return errs
-		}
-		obj, ok := actual.(map[string]interface{})
-		if !ok {
-			errs = append(errs, fmt.Sprintf("%s: expected object, got %T", path, actual))
-			return errs
-		}
-
-		if spec.DynamicKeys {
-			// Object with dynamic keys — validate value shapes
-			if spec.ValueShape != nil && len(obj) > 0 {
-				for k, v := range obj {
-					errs = append(errs, validateShape(v, *spec.ValueShape, path+"."+k)...)
-					break // check just one sample
-				}
-			}
-			if spec.RequiredKeys != nil {
-				for rk, rs := range spec.RequiredKeys {
-					v, exists := obj[rk]
-					if !exists {
-						errs = append(errs, fmt.Sprintf("%s: missing required key %q in dynamic-key object", path, rk))
-					} else {
-						errs = append(errs, validateShape(v, rs, path+"."+rk)...)
-					}
-				}
-			}
-		} else if spec.Keys != nil {
-			// Object with known keys — check each expected key exists and has correct type
-			for key, keySpec := range spec.Keys {
-				val, exists := obj[key]
-				if !exists {
-					errs = append(errs, fmt.Sprintf("%s: missing field %q (expected %s)", path, key, keySpec.Type))
-				} else {
-					errs = append(errs, validateShape(val, keySpec, path+"."+key)...)
-				}
-			}
-		}
-	}
-
-	return errs
-}
-
-// parityEndpoint defines one endpoint to test for parity.
-type parityEndpoint struct {
-	name     string // key in shapes.json
-	path     string // HTTP path to request
-}
-
-func TestParityShapes(t *testing.T) {
-	shapes := loadShapes(t)
-	_, router := setupTestServer(t)
-
-	endpoints := []parityEndpoint{
-		{"stats", "/api/stats"},
-		{"nodes", "/api/nodes?limit=5"},
-		{"packets", "/api/packets?limit=5"},
-		{"packets_grouped", "/api/packets?limit=5&groupByHash=true"},
-		{"observers", "/api/observers"},
-		{"channels", "/api/channels"},
-		{"channel_messages", "/api/channels/0000000000000000/messages?limit=5"},
-		{"analytics_rf", "/api/analytics/rf?days=7"},
-		{"analytics_topology", "/api/analytics/topology?days=7"},
-		{"analytics_hash_sizes", "/api/analytics/hash-sizes?days=7"},
-		{"analytics_distance", "/api/analytics/distance?days=7"},
-		{"analytics_subpaths", "/api/analytics/subpaths?days=7"},
-		{"bulk_health", "/api/nodes/bulk-health"},
-		{"health", "/api/health"},
-		{"perf", "/api/perf"},
-	}
-
-	for _, ep := range endpoints {
-		t.Run("Parity_"+ep.name, func(t *testing.T) {
-			spec, ok := shapes[ep.name]
-			if !ok {
-				t.Fatalf("no shape spec found for %q in shapes.json", ep.name)
-			}
-
-			req := httptest.NewRequest("GET", ep.path, nil)
-			w := httptest.NewRecorder()
-			router.ServeHTTP(w, req)
-
-			if w.Code != 200 {
-				t.Fatalf("GET %s returned %d, expected 200. Body: %s",
-					ep.path, w.Code, w.Body.String())
-			}
-
-			var body interface{}
-			if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil {
-				t.Fatalf("GET %s returned invalid JSON: %v\nBody: %s",
-					ep.path, err, w.Body.String())
-			}
-
-			mismatches := validateShape(body, spec, ep.path)
-			if len(mismatches) > 0 {
-				t.Errorf("Go %s has %d shape mismatches vs Node.js golden:\n  %s",
-					ep.path, len(mismatches), strings.Join(mismatches, "\n  "))
-			}
-		})
-	}
-}
-
-// TestParityNodeDetail tests node detail endpoint shape.
-// Uses a known test node public key from seeded data.
-func TestParityNodeDetail(t *testing.T) {
-	shapes := loadShapes(t)
-	_, router := setupTestServer(t)
-
-	spec, ok := shapes["node_detail"]
-	if !ok {
-		t.Fatal("no shape spec for node_detail in shapes.json")
-	}
-
-	req := httptest.NewRequest("GET", "/api/nodes/aabbccdd11223344", nil)
-	w := httptest.NewRecorder()
-	router.ServeHTTP(w, req)
-
-	if w.Code != 200 {
-		t.Fatalf("node detail returned %d: %s", w.Code, w.Body.String())
-	}
-
-	var body interface{}
-	json.Unmarshal(w.Body.Bytes(), &body)
-
-	mismatches := validateShape(body, spec, "/api/nodes/{pubkey}")
-	if len(mismatches) > 0 {
-		t.Errorf("Go node detail has %d shape mismatches vs Node.js golden:\n  %s",
-			len(mismatches), strings.Join(mismatches, "\n  "))
-	}
-}
-
-// TestParityArraysNotNull verifies that array-typed fields in Go responses are
-// [] (empty array) rather than null. This is a common Go/JSON pitfall where
-// nil slices marshal as null instead of [].
-// Uses shapes.json to know which fields SHOULD be arrays.
-func TestParityArraysNotNull(t *testing.T) {
-	shapes := loadShapes(t)
-	_, router := setupTestServer(t)
-
-	endpoints := []struct {
-		name string
-		path string
-	}{
-		{"stats", "/api/stats"},
-		{"nodes", "/api/nodes?limit=5"},
-		{"packets", "/api/packets?limit=5"},
-		{"packets_grouped", "/api/packets?limit=5&groupByHash=true"},
-		{"observers", "/api/observers"},
-		{"channels", "/api/channels"},
-		{"bulk_health", "/api/nodes/bulk-health"},
-		{"analytics_rf", "/api/analytics/rf?days=7"},
-		{"analytics_topology", "/api/analytics/topology?days=7"},
-		{"analytics_hash_sizes", "/api/analytics/hash-sizes?days=7"},
-		{"analytics_distance", "/api/analytics/distance?days=7"},
-		{"analytics_subpaths", "/api/analytics/subpaths?days=7"},
-	}
-
-	for _, ep := range endpoints {
-		t.Run("NullArrayCheck_"+ep.name, func(t *testing.T) {
-			spec, ok := shapes[ep.name]
-			if !ok {
-				t.Skipf("no shape spec for %s", ep.name)
-			}
-
-			req := httptest.NewRequest("GET", ep.path, nil)
-			w := httptest.NewRecorder()
-			router.ServeHTTP(w, req)
-
-			if w.Code != 200 {
-				t.Skipf("GET %s returned %d, skipping null-array check", ep.path, w.Code)
-			}
-
-			var body interface{}
-			json.Unmarshal(w.Body.Bytes(), &body)
-
-			nullArrays := findNullArrays(body, spec, ep.path)
-			if len(nullArrays) > 0 {
-				t.Errorf("Go %s has null where [] expected:\n  %s\n"+
-					"Go nil slices marshal as null — initialize with make() or literal",
-					ep.path, strings.Join(nullArrays, "\n  "))
-			}
-		})
-	}
-}
-
-// findNullArrays walks JSON data alongside a shape spec and returns paths
-// where the spec says the field should be an array but Go returned null.
-func findNullArrays(actual interface{}, spec shapeSpec, path string) []string {
-	var nulls []string
-
-	switch spec.Type {
-	case "array":
-		if actual == nil {
-			nulls = append(nulls, fmt.Sprintf("%s: null (should be [])", path))
-		} else if arr, ok := actual.([]interface{}); ok && spec.ElementShape != nil {
-			for i, elem := range arr {
-				nulls = append(nulls, findNullArrays(elem, *spec.ElementShape, fmt.Sprintf("%s[%d]", path, i))...)
-			}
-		}
-	case "object":
-		obj, ok := actual.(map[string]interface{})
-		if !ok || obj == nil {
-			return nulls
-		}
-		if spec.Keys != nil {
-			for key, keySpec := range spec.Keys {
-				if val, exists := obj[key]; exists {
-					nulls = append(nulls, findNullArrays(val, keySpec, path+"."+key)...)
-				} else if keySpec.Type == "array" {
-					// Key missing entirely — also a null-array problem
-					nulls = append(nulls, fmt.Sprintf("%s.%s: missing (should be [])", path, key))
-				}
-			}
-		}
-		if spec.DynamicKeys && spec.ValueShape != nil {
-			for k, v := range obj {
-				nulls = append(nulls, findNullArrays(v, *spec.ValueShape, path+"."+k)...)
-				break // sample one
-			}
-		}
-	}
-
-	return nulls
-}
-
-// TestParityHealthEngine verifies Go health endpoint declares engine=go
-// while Node declares engine=node (or omits it). The Go server must always
-// identify itself.
-func TestParityHealthEngine(t *testing.T) {
-	_, router := setupTestServer(t)
-
-	req := httptest.NewRequest("GET", "/api/health", nil)
-	w := httptest.NewRecorder()
-	router.ServeHTTP(w, req)
-
-	var body map[string]interface{}
-	json.Unmarshal(w.Body.Bytes(), &body)
-
-	engine, ok := body["engine"]
-	if !ok {
-		t.Error("health response missing 'engine' field (Go server must include engine=go)")
-	} else if engine != "go" {
-		t.Errorf("health engine=%v, expected 'go'", engine)
-	}
-}
-
-// TestValidateShapeFunction directly tests the shape validator itself.
-func TestValidateShapeFunction(t *testing.T) {
-	t.Run("string match", func(t *testing.T) {
-		errs := validateShape("hello", shapeSpec{Type: "string"}, "$.x")
-		if len(errs) != 0 {
-			t.Errorf("unexpected errors: %v", errs)
-		}
-	})
-
-	t.Run("string mismatch", func(t *testing.T) {
-		errs := validateShape(42.0, shapeSpec{Type: "string"}, "$.x")
-		if len(errs) != 1 {
-			t.Errorf("expected 1 error, got %d: %v", len(errs), errs)
-		}
-	})
-
-	t.Run("null array rejected", func(t *testing.T) {
-		errs := validateShape(nil, shapeSpec{Type: "array"}, "$.arr")
-		if len(errs) != 1 || !strings.Contains(errs[0], "null") {
-			t.Errorf("expected null-array error, got: %v", errs)
-		}
-	})
-
-	t.Run("empty array OK", func(t *testing.T) {
-		errs := validateShape([]interface{}{}, shapeSpec{Type: "array"}, "$.arr")
-		if len(errs) != 0 {
-			t.Errorf("unexpected errors for empty array: %v", errs)
-		}
-	})
-
-	t.Run("missing object key", func(t *testing.T) {
-		spec := shapeSpec{Type: "object", Keys: map[string]shapeSpec{
-			"name": {Type: "string"},
-			"age":  {Type: "number"},
-		}}
-		obj := map[string]interface{}{"name": "test"}
-		errs := validateShape(obj, spec, "$.user")
-		if len(errs) != 1 || !strings.Contains(errs[0], "age") {
-			t.Errorf("expected missing age error, got: %v", errs)
-		}
-	})
-
-	t.Run("nullable allows null", func(t *testing.T) {
-		errs := validateShape(nil, shapeSpec{Type: "nullable"}, "$.x")
-		if len(errs) != 0 {
-			t.Errorf("nullable should accept null: %v", errs)
-		}
-	})
-
-	t.Run("dynamic keys validates value shape", func(t *testing.T) {
-		spec := shapeSpec{
-			Type:        "object",
-			DynamicKeys: true,
-			ValueShape:  &shapeSpec{Type: "number"},
-		}
-		obj := map[string]interface{}{"a": 1.0, "b": 2.0}
-		errs := validateShape(obj, spec, "$.dyn")
-		if len(errs) != 0 {
-			t.Errorf("unexpected errors: %v", errs)
-		}
-	})
-}
+package main
+
+// parity_test.go — Golden fixture shape tests.
+// Validates that Go API responses match the shape of Node.js API responses.
+// Shapes were captured from the production Node.js server and stored in
+// testdata/golden/shapes.json.
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+)
+
+// shapeSpec describes the expected JSON structure from the Node.js server.
+type shapeSpec struct {
+	Type         string               `json:"type"`
+	Keys         map[string]shapeSpec `json:"keys,omitempty"`
+	ElementShape *shapeSpec           `json:"elementShape,omitempty"`
+	DynamicKeys  bool                 `json:"dynamicKeys,omitempty"`
+	ValueShape   *shapeSpec           `json:"valueShape,omitempty"`
+	RequiredKeys map[string]shapeSpec `json:"requiredKeys,omitempty"`
+}
+
+// loadShapes reads testdata/golden/shapes.json relative to this source file.
+func loadShapes(t *testing.T) map[string]shapeSpec {
+	t.Helper()
+	_, thisFile, _, _ := runtime.Caller(0)
+	dir := filepath.Dir(thisFile)
+	data, err := os.ReadFile(filepath.Join(dir, "testdata", "golden", "shapes.json"))
+	if err != nil {
+		t.Fatalf("cannot load shapes.json: %v", err)
+	}
+	var shapes map[string]shapeSpec
+	if err := json.Unmarshal(data, &shapes); err != nil {
+		t.Fatalf("cannot parse shapes.json: %v", err)
+	}
+	return shapes
+}
+
+// validateShape recursively checks that `actual` matches the expected `spec`.
+// `path` tracks the JSON path for error messages.
+// Returns a list of mismatch descriptions.
+func validateShape(actual interface{}, spec shapeSpec, path string) []string {
+	var errs []string
+
+	switch spec.Type {
+	case "null", "nullable":
+		// nullable means: value can be null OR matching type. Accept anything.
+		return nil
+	case "nullable_number":
+		// Can be null or number
+		if actual != nil {
+			if _, ok := actual.(float64); !ok {
+				errs = append(errs, fmt.Sprintf("%s: expected number or null, got %T", path, actual))
+			}
+		}
+		return errs
+	case "string":
+		if actual == nil {
+			errs = append(errs, fmt.Sprintf("%s: expected string, got null", path))
+		} else if _, ok := actual.(string); !ok {
+			errs = append(errs, fmt.Sprintf("%s: expected string, got %T", path, actual))
+		}
+	case "number":
+		if actual == nil {
+			errs = append(errs, fmt.Sprintf("%s: expected number, got null", path))
+		} else if _, ok := actual.(float64); !ok {
+			errs = append(errs, fmt.Sprintf("%s: expected number, got %T (%v)", path, actual, actual))
+		}
+	case "boolean":
+		if actual == nil {
+			errs = append(errs, fmt.Sprintf("%s: expected boolean, got null", path))
+		} else if _, ok := actual.(bool); !ok {
+			errs = append(errs, fmt.Sprintf("%s: expected boolean, got %T", path, actual))
+		}
+	case "array":
+		if actual == nil {
+			errs = append(errs, fmt.Sprintf("%s: expected array, got null (arrays must be [] not null)", path))
+			return errs
+		}
+		arr, ok := actual.([]interface{})
+		if !ok {
+			errs = append(errs, fmt.Sprintf("%s: expected array, got %T", path, actual))
+			return errs
+		}
+		if spec.ElementShape != nil && len(arr) > 0 {
+			errs = append(errs, validateShape(arr[0], *spec.ElementShape, path+"[0]")...)
+		}
+	case "object":
+		if actual == nil {
+			errs = append(errs, fmt.Sprintf("%s: expected object, got null", path))
+			return errs
+		}
+		obj, ok := actual.(map[string]interface{})
+		if !ok {
+			errs = append(errs, fmt.Sprintf("%s: expected object, got %T", path, actual))
+			return errs
+		}
+
+		if spec.DynamicKeys {
+			// Object with dynamic keys — validate value shapes
+			if spec.ValueShape != nil && len(obj) > 0 {
+				for k, v := range obj {
+					errs = append(errs, validateShape(v, *spec.ValueShape, path+"."+k)...)
+					break // check just one sample
+				}
+			}
+			if spec.RequiredKeys != nil {
+				for rk, rs := range spec.RequiredKeys {
+					v, exists := obj[rk]
+					if !exists {
+						errs = append(errs, fmt.Sprintf("%s: missing required key %q in dynamic-key object", path, rk))
+					} else {
+						errs = append(errs, validateShape(v, rs, path+"."+rk)...)
+					}
+				}
+			}
+		} else if spec.Keys != nil {
+			// Object with known keys — check each expected key exists and has correct type
+			for key, keySpec := range spec.Keys {
+				val, exists := obj[key]
+				if !exists {
+					errs = append(errs, fmt.Sprintf("%s: missing field %q (expected %s)", path, key, keySpec.Type))
+				} else {
+					errs = append(errs, validateShape(val, keySpec, path+"."+key)...)
+				}
+			}
+		}
+	}
+
+	return errs
+}
+
+// parityEndpoint defines one endpoint to test for parity.
+type parityEndpoint struct {
+	name string // key in shapes.json
+	path string // HTTP path to request
+}
+
+func TestParityShapes(t *testing.T) {
+	shapes := loadShapes(t)
+	_, router := setupTestServer(t)
+
+	endpoints := []parityEndpoint{
+		{"stats", "/api/stats"},
+		{"nodes", "/api/nodes?limit=5"},
+		{"packets", "/api/packets?limit=5"},
+		{"packets_grouped", "/api/packets?limit=5&groupByHash=true"},
+		{"observers", "/api/observers"},
+		{"channels", "/api/channels"},
+		{"channel_messages", "/api/channels/0000000000000000/messages?limit=5"},
+		{"analytics_rf", "/api/analytics/rf?days=7"},
+		{"analytics_topology", "/api/analytics/topology?days=7"},
+		{"analytics_hash_sizes", "/api/analytics/hash-sizes?days=7"},
+		{"analytics_distance", "/api/analytics/distance?days=7"},
+		{"analytics_subpaths", "/api/analytics/subpaths?days=7"},
+		{"bulk_health", "/api/nodes/bulk-health"},
+		{"health", "/api/health"},
+		{"perf", "/api/perf"},
+	}
+
+	for _, ep := range endpoints {
+		t.Run("Parity_"+ep.name, func(t *testing.T) {
+			spec, ok := shapes[ep.name]
+			if !ok {
+				t.Fatalf("no shape spec found for %q in shapes.json", ep.name)
+			}
+
+			req := httptest.NewRequest("GET", ep.path, nil)
+			w := httptest.NewRecorder()
+			router.ServeHTTP(w, req)
+
+			if w.Code != 200 {
+				t.Fatalf("GET %s returned %d, expected 200. Body: %s",
+					ep.path, w.Code, w.Body.String())
+			}
+
+			var body interface{}
+			if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil {
+				t.Fatalf("GET %s returned invalid JSON: %v\nBody: %s",
+					ep.path, err, w.Body.String())
+			}
+
+			mismatches := validateShape(body, spec, ep.path)
+			if len(mismatches) > 0 {
+				t.Errorf("Go %s has %d shape mismatches vs Node.js golden:\n  %s",
+					ep.path, len(mismatches), strings.Join(mismatches, "\n  "))
+			}
+		})
+	}
+}
+
+// TestParityNodeDetail tests node detail endpoint shape.
+// Uses a known test node public key from seeded data.
+func TestParityNodeDetail(t *testing.T) {
+	shapes := loadShapes(t)
+	_, router := setupTestServer(t)
+
+	spec, ok := shapes["node_detail"]
+	if !ok {
+		t.Fatal("no shape spec for node_detail in shapes.json")
+	}
+
+	req := httptest.NewRequest("GET", "/api/nodes/aabbccdd11223344", nil)
+	w := httptest.NewRecorder()
+	router.ServeHTTP(w, req)
+
+	if w.Code != 200 {
+		t.Fatalf("node detail returned %d: %s", w.Code, w.Body.String())
+	}
+
+	var body interface{}
+	json.Unmarshal(w.Body.Bytes(), &body)
+
+	mismatches := validateShape(body, spec, "/api/nodes/{pubkey}")
+	if len(mismatches) > 0 {
+		t.Errorf("Go node detail has %d shape mismatches vs Node.js golden:\n  %s",
+			len(mismatches), strings.Join(mismatches, "\n  "))
+	}
+}
+
+// TestParityArraysNotNull verifies that array-typed fields in Go responses are
+// [] (empty array) rather than null. This is a common Go/JSON pitfall where
+// nil slices marshal as null instead of [].
+// Uses shapes.json to know which fields SHOULD be arrays.
+func TestParityArraysNotNull(t *testing.T) {
+	shapes := loadShapes(t)
+	_, router := setupTestServer(t)
+
+	endpoints := []struct {
+		name string
+		path string
+	}{
+		{"stats", "/api/stats"},
+		{"nodes", "/api/nodes?limit=5"},
+		{"packets", "/api/packets?limit=5"},
+		{"packets_grouped", "/api/packets?limit=5&groupByHash=true"},
+		{"observers", "/api/observers"},
+		{"channels", "/api/channels"},
+		{"bulk_health", "/api/nodes/bulk-health"},
+		{"analytics_rf", "/api/analytics/rf?days=7"},
+		{"analytics_topology", "/api/analytics/topology?days=7"},
+		{"analytics_hash_sizes", "/api/analytics/hash-sizes?days=7"},
+		{"analytics_distance", "/api/analytics/distance?days=7"},
+		{"analytics_subpaths", "/api/analytics/subpaths?days=7"},
+	}
+
+	for _, ep := range endpoints {
+		t.Run("NullArrayCheck_"+ep.name, func(t *testing.T) {
+			spec, ok := shapes[ep.name]
+			if !ok {
+				t.Skipf("no shape spec for %s", ep.name)
+			}
+
+			req := httptest.NewRequest("GET", ep.path, nil)
+			w := httptest.NewRecorder()
+			router.ServeHTTP(w, req)
+
+			if w.Code != 200 {
+				t.Skipf("GET %s returned %d, skipping null-array check", ep.path, w.Code)
+			}
+
+			var body interface{}
+			json.Unmarshal(w.Body.Bytes(), &body)
+
+			nullArrays := findNullArrays(body, spec, ep.path)
+			if len(nullArrays) > 0 {
+				t.Errorf("Go %s has null where [] expected:\n  %s\n"+
+					"Go nil slices marshal as null — initialize with make() or literal",
+					ep.path, strings.Join(nullArrays, "\n  "))
+			}
+		})
+	}
+}
+
+// findNullArrays walks JSON data alongside a shape spec and returns paths
+// where the spec says the field should be an array but Go returned null.
+func findNullArrays(actual interface{}, spec shapeSpec, path string) []string {
+	var nulls []string
+
+	switch spec.Type {
+	case "array":
+		if actual == nil {
+			nulls = append(nulls, fmt.Sprintf("%s: null (should be [])", path))
+		} else if arr, ok := actual.([]interface{}); ok && spec.ElementShape != nil {
+			for i, elem := range arr {
+				nulls = append(nulls, findNullArrays(elem, *spec.ElementShape, fmt.Sprintf("%s[%d]", path, i))...)
+			}
+		}
+	case "object":
+		obj, ok := actual.(map[string]interface{})
+		if !ok || obj == nil {
+			return nulls
+		}
+		if spec.Keys != nil {
+			for key, keySpec := range spec.Keys {
+				if val, exists := obj[key]; exists {
+					nulls = append(nulls, findNullArrays(val, keySpec, path+"."+key)...)
+				} else if keySpec.Type == "array" {
+					// Key missing entirely — also a null-array problem
+					nulls = append(nulls, fmt.Sprintf("%s.%s: missing (should be [])", path, key))
+				}
+			}
+		}
+		if spec.DynamicKeys && spec.ValueShape != nil {
+			for k, v := range obj {
+				nulls = append(nulls, findNullArrays(v, *spec.ValueShape, path+"."+k)...)
+				break // sample one
+			}
+		}
+	}
+
+	return nulls
+}
+
+// TestParityHealthEngine verifies Go health endpoint declares engine=go
+// while Node declares engine=node (or omits it). The Go server must always
+// identify itself.
+func TestParityHealthEngine(t *testing.T) {
+	_, router := setupTestServer(t)
+
+	req := httptest.NewRequest("GET", "/api/health", nil)
+	w := httptest.NewRecorder()
+	router.ServeHTTP(w, req)
+
+	var body map[string]interface{}
+	json.Unmarshal(w.Body.Bytes(), &body)
+
+	engine, ok := body["engine"]
+	if !ok {
+		t.Error("health response missing 'engine' field (Go server must include engine=go)")
+	} else if engine != "go" {
+		t.Errorf("health engine=%v, expected 'go'", engine)
+	}
+}
+
+// TestValidateShapeFunction directly tests the shape validator itself.
+func TestValidateShapeFunction(t *testing.T) {
+	t.Run("string match", func(t *testing.T) {
+		errs := validateShape("hello", shapeSpec{Type: "string"}, "$.x")
+		if len(errs) != 0 {
+			t.Errorf("unexpected errors: %v", errs)
+		}
+	})
+
+	t.Run("string mismatch", func(t *testing.T) {
+		errs := validateShape(42.0, shapeSpec{Type: "string"}, "$.x")
+		if len(errs) != 1 {
+			t.Errorf("expected 1 error, got %d: %v", len(errs), errs)
+		}
+	})
+
+	t.Run("null array rejected", func(t *testing.T) {
+		errs := validateShape(nil, shapeSpec{Type: "array"}, "$.arr")
+		if len(errs) != 1 || !strings.Contains(errs[0], "null") {
+			t.Errorf("expected null-array error, got: %v", errs)
+		}
+	})
+
+	t.Run("empty array OK", func(t *testing.T) {
+		errs := validateShape([]interface{}{}, shapeSpec{Type: "array"}, "$.arr")
+		if len(errs) != 0 {
+			t.Errorf("unexpected errors for empty array: %v", errs)
+		}
+	})
+
+	t.Run("missing object key", func(t *testing.T) {
+		spec := shapeSpec{Type: "object", Keys: map[string]shapeSpec{
+			"name": {Type: "string"},
+			"age":  {Type: "number"},
+		}}
+		obj := map[string]interface{}{"name": "test"}
+		errs := validateShape(obj, spec, "$.user")
+		if len(errs) != 1 || !strings.Contains(errs[0], "age") {
+			t.Errorf("expected missing age error, got: %v", errs)
+		}
+	})
+
+	t.Run("nullable allows null", func(t *testing.T) {
+		errs := validateShape(nil, shapeSpec{Type: "nullable"}, "$.x")
+		if len(errs) != 0 {
+			t.Errorf("nullable should accept null: %v", errs)
+		}
+	})
+
+	t.Run("dynamic keys validates value shape", func(t *testing.T) {
+		spec := shapeSpec{
+			Type:        "object",
+			DynamicKeys: true,
+			ValueShape:  &shapeSpec{Type: "number"},
+		}
+		obj := map[string]interface{}{"a": 1.0, "b": 2.0}
+		errs := validateShape(obj, spec, "$.dyn")
+		if len(errs) != 0 {
+			t.Errorf("unexpected errors: %v", errs)
+		}
+	})
+}
+
+func TestParityWSMultiObserverGolden(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+	seedTestData(t, db)
+	hub := NewHub()
+	store := NewPacketStore(db, nil)
+	if err := store.Load(); err != nil {
+		t.Fatalf("store load failed: %v", err)
+	}
+
+	poller := NewPoller(db, hub, 50*time.Millisecond)
+	poller.store = store
+
+	client := &Client{send: make(chan []byte, 256)}
+	hub.Register(client)
+	defer hub.Unregister(client)
+
+	go poller.Start()
+	defer poller.Stop()
+
+	// Wait for poller to initialize its lastID/lastObsID cursors before
+	// inserting new data; otherwise the poller may snapshot a lastID that
+	// already includes the test data and never broadcast it.
+	time.Sleep(100 * time.Millisecond)
+
+	now := time.Now().UTC().Format(time.RFC3339)
+	if _, err := db.conn.Exec(`INSERT INTO transmissions (raw_hex, hash, first_seen, route_type, payload_type, decoded_json)
+		VALUES ('BEEF', 'goldenstarburst237', ?, 1, 4, '{"pubKey":"aabbccdd11223344","type":"ADVERT"}')`, now); err != nil {
+		t.Fatalf("insert tx failed: %v", err)
+	}
+	var txID int
+	if err := db.conn.QueryRow(`SELECT id FROM transmissions WHERE hash='goldenstarburst237'`).Scan(&txID); err != nil {
+		t.Fatalf("query tx id failed: %v", err)
+	}
+	ts := time.Now().Unix()
+	if _, err := db.conn.Exec(`INSERT INTO observations (transmission_id, observer_idx, snr, rssi, path_json, timestamp)
+		VALUES (?, 1, 11.0, -88, '["p1"]', ?),
+		       (?, 2, 9.0, -92, '["p1","p2"]', ?),
+		       (?, 1, 7.0, -96, '["p1","p2","p3"]', ?)`,
+		txID, ts, txID, ts+1, txID, ts+2); err != nil {
+		t.Fatalf("insert obs failed: %v", err)
+	}
+
+	type golden struct {
+		Hash        string
+		Count       int
+		Paths       []string
+		ObserverIDs []string
+	}
+	expected := golden{
+		Hash:        "goldenstarburst237",
+		Count:       3,
+		Paths:       []string{`["p1"]`, `["p1","p2"]`, `["p1","p2","p3"]`},
+		ObserverIDs: []string{"obs1", "obs2"},
+	}
+
+	gotPaths := make([]string, 0, expected.Count)
+	gotObservers := make(map[string]bool)
+	deadline := time.After(2 * time.Second)
+	for len(gotPaths) < expected.Count {
+		select {
+		case raw := <-client.send:
+			var msg map[string]interface{}
+			if err := json.Unmarshal(raw, &msg); err != nil {
+				t.Fatalf("unmarshal ws message failed: %v", err)
+			}
+			if msg["type"] != "packet" {
+				continue
+			}
+			data, _ := msg["data"].(map[string]interface{})
+			if data == nil || data["hash"] != expected.Hash {
+				continue
+			}
+			if path, ok := data["path_json"].(string); ok {
+				gotPaths = append(gotPaths, path)
+			}
+			if oid, ok := data["observer_id"].(string); ok && oid != "" {
+				gotObservers[oid] = true
+			}
+		case <-deadline:
+			t.Fatalf("timed out waiting for %d ws messages, got %d", expected.Count, len(gotPaths))
+		}
+	}
+
+	sort.Strings(gotPaths)
+	sort.Strings(expected.Paths)
+	if len(gotPaths) != len(expected.Paths) {
+		t.Fatalf("path count mismatch: got %d want %d", len(gotPaths), len(expected.Paths))
+	}
+	for i := range expected.Paths {
+		if gotPaths[i] != expected.Paths[i] {
+			t.Fatalf("path mismatch at %d: got %q want %q", i, gotPaths[i], expected.Paths[i])
+		}
+	}
+	for _, oid := range expected.ObserverIDs {
+		if !gotObservers[oid] {
+			t.Fatalf("missing expected observer %q in ws messages", oid)
+		}
+	}
+}

cmd/server/routes.go

@@ -33,6 +33,11 @@ type Server struct {
 	memStatsMu   sync.Mutex
 	memStatsCache runtime.MemStats
 	memStatsCachedAt time.Time
+
+	// Cached /api/stats response — recomputed at most once every 10s
+	statsMu      sync.Mutex
+	statsCache   *StatsResponse
+	statsCachedAt time.Time
 }
 
 // PerfStats tracks request performance.
@@ -208,7 +213,7 @@ func (s *Server) handleConfigCache(w http.ResponseWriter, r *http.Request) {
 func (s *Server) handleConfigClient(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, ClientConfigResponse{
 		Roles:               s.cfg.Roles,
-		HealthThresholds:    s.cfg.HealthThresholds,
+		HealthThresholds:    s.cfg.GetHealthThresholds().ToClientMs(),
 		Tiles:               s.cfg.Tiles,
 		SnrThresholds:       s.cfg.SnrThresholds,
 		DistThresholds:      s.cfg.DistThresholds,
@@ -380,6 +385,17 @@ func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
 }
 
 func (s *Server) handleStats(w http.ResponseWriter, r *http.Request) {
+	const statsTTL = 10 * time.Second
+
+	s.statsMu.Lock()
+	if s.statsCache != nil && time.Since(s.statsCachedAt) < statsTTL {
+		cached := s.statsCache
+		s.statsMu.Unlock()
+		writeJSON(w, cached)
+		return
+	}
+	s.statsMu.Unlock()
+
 	var stats *Stats
 	var err error
 	if s.store != nil {
@@ -392,7 +408,7 @@ func (s *Server) handleStats(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	counts := s.db.GetRoleCounts()
-	writeJSON(w, StatsResponse{
+	resp := &StatsResponse{
 		TotalPackets:       stats.TotalPackets,
 		TotalTransmissions: &stats.TotalTransmissions,
 		TotalObservations:  stats.TotalObservations,
@@ -411,7 +427,14 @@ func (s *Server) handleStats(w http.ResponseWriter, r *http.Request) {
 			Companions: counts["companions"],
 			Sensors:    counts["sensors"],
 		},
-	})
+	}
+
+	s.statsMu.Lock()
+	s.statsCache = resp
+	s.statsCachedAt = time.Now()
+	s.statsMu.Unlock()
+
+	writeJSON(w, resp)
 }
 
 func (s *Server) handlePerf(w http.ResponseWriter, r *http.Request) {
@@ -1132,12 +1155,13 @@ func (s *Server) handleAnalyticsHashSizes(w http.ResponseWriter, r *http.Request
 		writeJSON(w, s.store.GetAnalyticsHashSizes(region))
 		return
 	}
-	writeJSON(w, HashSizeAnalyticsResponse{
-		Total:          0,
-		Distribution:   map[string]int{"1": 0, "2": 0, "3": 0},
-		Hourly:         []HashSizeHourly{},
-		TopHops:        []HashSizeHop{},
-		MultiByteNodes: []MultiByteNode{},
+	writeJSON(w, map[string]interface{}{
+		"total":                    0,
+		"distribution":            map[string]int{"1": 0, "2": 0, "3": 0},
+		"distributionByRepeaters": map[string]int{"1": 0, "2": 0, "3": 0},
+		"hourly":                  []HashSizeHourly{},
+		"topHops":                 []HashSizeHop{},
+		"multiByteNodes":          []MultiByteNode{},
 	})
 }
 

cmd/server/routes_test.go

@@ -17,7 +17,7 @@ func setupTestServer(t *testing.T) (*Server, *mux.Router) {
 	cfg := &Config{Port: 3000}
 	hub := NewHub()
 	srv := NewServer(db, cfg, hub)
-	store := NewPacketStore(db)
+	store := NewPacketStore(db, nil)
 	if err := store.Load(); err != nil {
 		t.Fatalf("store.Load failed: %v", err)
 	}
@@ -1259,7 +1259,7 @@ func TestNodeAnalyticsNoNameNode(t *testing.T) {
 	cfg := &Config{Port: 3000}
 	hub := NewHub()
 	srv := NewServer(db, cfg, hub)
-	store := NewPacketStore(db)
+	store := NewPacketStore(db, nil)
 	if err := store.Load(); err != nil {
 		t.Fatalf("store.Load failed: %v", err)
 	}
@@ -1295,7 +1295,7 @@ func TestNodeHealthForNoNameNode(t *testing.T) {
 	cfg := &Config{Port: 3000}
 	hub := NewHub()
 	srv := NewServer(db, cfg, hub)
-	store := NewPacketStore(db)
+	store := NewPacketStore(db, nil)
 	if err := store.Load(); err != nil {
 		t.Fatalf("store.Load failed: %v", err)
 	}
@@ -1890,7 +1890,7 @@ t.Error("hash_sizes_seen should not be set for single size")
 func TestGetNodeHashSizeInfoFlipFlop(t *testing.T) {
 db := setupTestDB(t)
 seedTestData(t, db)
-store := NewPacketStore(db)
+store := NewPacketStore(db, nil)
 if err := store.Load(); err != nil {
 	t.Fatalf("store.Load failed: %v", err)
 }

cmd/server/store.go

@@ -98,6 +98,16 @@ type PacketStore struct {
 	// computed during Load() and incrementally updated on ingest.
 	distHops  []distHopRecord
 	distPaths []distPathRecord
+
+	// Cached GetNodeHashSizeInfo result — recomputed at most once every 15s
+	hashSizeInfoMu    sync.Mutex
+	hashSizeInfoCache map[string]*hashSizeNodeInfo
+	hashSizeInfoAt    time.Time
+
+	// Eviction config and stats
+	retentionHours float64 // 0 = unlimited
+	maxMemoryMB    int     // 0 = unlimited
+	evicted        int64   // total packets evicted
 }
 
 // Precomputed distance records for fast analytics aggregation.
@@ -138,8 +148,8 @@ type cachedResult struct {
 }
 
 // NewPacketStore creates a new empty packet store backed by db.
-func NewPacketStore(db *DB) *PacketStore {
-	return &PacketStore{
+func NewPacketStore(db *DB, cfg *PacketStoreConfig) *PacketStore {
+	ps := &PacketStore{
 		db:            db,
 		packets:       make([]*StoreTx, 0, 65536),
 		byHash:        make(map[string]*StoreTx, 65536),
@@ -158,6 +168,11 @@ func NewPacketStore(db *DB) *PacketStore {
 		rfCacheTTL:    15 * time.Second,
 		spIndex:       make(map[string]int, 4096),
 	}
+	if cfg != nil {
+		ps.retentionHours = cfg.RetentionHours
+		ps.maxMemoryMB = cfg.MaxMemoryMB
+	}
+	return ps
 }
 
 // Load reads all transmissions + observations from SQLite into memory.
@@ -288,7 +303,7 @@ func (s *PacketStore) Load() error {
 
 	s.loaded = true
 	elapsed := time.Since(t0)
-	estMB := (len(s.packets)*450 + s.totalObs*100) / (1024 * 1024)
+	estMB := (len(s.packets)*5120 + s.totalObs*500) / (1024 * 1024)
 	log.Printf("[store] Loaded %d transmissions (%d observations) in %v (~%dMB est)",
 		len(s.packets), s.totalObs, elapsed, estMB)
 	return nil
@@ -537,20 +552,22 @@ func (s *PacketStore) GetPerfStoreStats() map[string]interface{} {
 	}
 	s.mu.RUnlock()
 
-	// Rough estimate: ~430 bytes per packet + ~200 per observation
-	estimatedMB := math.Round(float64(totalLoaded*430+totalObs*200)/1048576*10) / 10
+	// Realistic estimate: ~5KB per packet + ~500 bytes per observation
+	estimatedMB := math.Round(float64(totalLoaded*5120+totalObs*500)/1048576*10) / 10
+
+	evicted := atomic.LoadInt64(&s.evicted)
 
 	return map[string]interface{}{
 		"totalLoaded":       totalLoaded,
 		"totalObservations": totalObs,
-		"evicted":           0,
+		"evicted":           evicted,
 		"inserts":           atomic.LoadInt64(&s.insertCount),
 		"queries":           atomic.LoadInt64(&s.queryCount),
 		"inMemory":          totalLoaded,
 		"sqliteOnly":        false,
-		"maxPackets":        2386092,
+		"retentionHours":    s.retentionHours,
+		"maxMemoryMB":       s.maxMemoryMB,
 		"estimatedMB":       estimatedMB,
-		"maxMB":             1024,
 		"indexes": map[string]interface{}{
 			"byHash":           hashIdx,
 			"byTxID":           txIdx,
@@ -643,12 +660,12 @@ func (s *PacketStore) GetPerfStoreStatsTyped() PerfPacketStoreStats {
 	}
 	s.mu.RUnlock()
 
-	estimatedMB := math.Round(float64(totalLoaded*430+totalObs*200)/1048576*10) / 10
+	estimatedMB := math.Round(float64(totalLoaded*5120+totalObs*500)/1048576*10) / 10
 
 	return PerfPacketStoreStats{
 		TotalLoaded:       totalLoaded,
 		TotalObservations: totalObs,
-		Evicted:           0,
+		Evicted:           int(atomic.LoadInt64(&s.evicted)),
 		Inserts:           atomic.LoadInt64(&s.insertCount),
 		Queries:           atomic.LoadInt64(&s.queryCount),
 		InMemory:          totalLoaded,
@@ -1034,7 +1051,7 @@ func (s *PacketStore) IngestNewFromDB(sinceID, limit int) ([]map[string]interfac
 		}
 	}
 
-	// Build broadcast maps (same shape as Node.js WS broadcast)
+	// Build broadcast maps (same shape as Node.js WS broadcast), one per observation.
 	result := make([]map[string]interface{}, 0, len(broadcastOrder))
 	for _, txID := range broadcastOrder {
 		tx := broadcastTxs[txID]
@@ -1050,32 +1067,34 @@ func (s *PacketStore) IngestNewFromDB(sinceID, limit int) ([]map[string]interfac
 				decoded["payload"] = payload
 			}
 		}
-		// Build the nested packet object (packets.js checks m.data.packet)
-		pkt := map[string]interface{}{
-			"id":                tx.ID,
-			"raw_hex":           strOrNil(tx.RawHex),
-			"hash":              strOrNil(tx.Hash),
-			"first_seen":        strOrNil(tx.FirstSeen),
-			"timestamp":         strOrNil(tx.FirstSeen),
-			"route_type":        intPtrOrNil(tx.RouteType),
-			"payload_type":      intPtrOrNil(tx.PayloadType),
-			"decoded_json":      strOrNil(tx.DecodedJSON),
-			"observer_id":       strOrNil(tx.ObserverID),
-			"observer_name":     strOrNil(tx.ObserverName),
-			"snr":               floatPtrOrNil(tx.SNR),
-			"rssi":              floatPtrOrNil(tx.RSSI),
-			"path_json":         strOrNil(tx.PathJSON),
-			"direction":         strOrNil(tx.Direction),
-			"observation_count": tx.ObservationCount,
+		for _, obs := range tx.Observations {
+			// Build the nested packet object (packets.js checks m.data.packet)
+			pkt := map[string]interface{}{
+				"id":                tx.ID,
+				"raw_hex":           strOrNil(tx.RawHex),
+				"hash":              strOrNil(tx.Hash),
+				"first_seen":        strOrNil(tx.FirstSeen),
+				"timestamp":         strOrNil(tx.FirstSeen),
+				"route_type":        intPtrOrNil(tx.RouteType),
+				"payload_type":      intPtrOrNil(tx.PayloadType),
+				"decoded_json":      strOrNil(tx.DecodedJSON),
+				"observer_id":       strOrNil(obs.ObserverID),
+				"observer_name":     strOrNil(obs.ObserverName),
+				"snr":               floatPtrOrNil(obs.SNR),
+				"rssi":              floatPtrOrNil(obs.RSSI),
+				"path_json":         strOrNil(obs.PathJSON),
+				"direction":         strOrNil(obs.Direction),
+				"observation_count": tx.ObservationCount,
+			}
+			// Broadcast map: top-level fields for live.js + nested packet for packets.js
+			broadcastMap := make(map[string]interface{}, len(pkt)+2)
+			for k, v := range pkt {
+				broadcastMap[k] = v
+			}
+			broadcastMap["decoded"] = decoded
+			broadcastMap["packet"] = pkt
+			result = append(result, broadcastMap)
 		}
-		// Broadcast map: top-level fields for live.js + nested packet for packets.js
-		broadcastMap := make(map[string]interface{}, len(pkt)+2)
-		for k, v := range pkt {
-			broadcastMap[k] = v
-		}
-		broadcastMap["decoded"] = decoded
-		broadcastMap["packet"] = pkt
-		result = append(result, broadcastMap)
 	}
 
 	// Invalidate analytics caches since new data was ingested
@@ -1096,7 +1115,7 @@ func (s *PacketStore) IngestNewFromDB(sinceID, limit int) ([]map[string]interfac
 // IngestNewObservations loads new observations for transmissions already in the
 // store. This catches observations that arrive after IngestNewFromDB has already
 // advanced past the transmission's ID (fixes #174).
-func (s *PacketStore) IngestNewObservations(sinceObsID, limit int) int {
+func (s *PacketStore) IngestNewObservations(sinceObsID, limit int) []map[string]interface{} {
 	if limit <= 0 {
 		limit = 500
 	}
@@ -1122,7 +1141,7 @@ func (s *PacketStore) IngestNewObservations(sinceObsID, limit int) int {
 	rows, err := s.db.conn.Query(querySQL, sinceObsID, limit)
 	if err != nil {
 		log.Printf("[store] ingest observations query error: %v", err)
-		return sinceObsID
+		return nil
 	}
 	defer rows.Close()
 
@@ -1165,20 +1184,16 @@ func (s *PacketStore) IngestNewObservations(sinceObsID, limit int) int {
 	}
 
 	if len(obsRows) == 0 {
-		return sinceObsID
+		return nil
 	}
 
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
-	newMaxObsID := sinceObsID
 	updatedTxs := make(map[int]*StoreTx)
+	broadcastMaps := make([]map[string]interface{}, 0, len(obsRows))
 
 	for _, r := range obsRows {
-		if r.obsID > newMaxObsID {
-			newMaxObsID = r.obsID
-		}
-
 		// Already ingested (e.g. by IngestNewFromDB in same cycle)
 		if _, exists := s.byObsID[r.obsID]; exists {
 			continue
@@ -1221,6 +1236,43 @@ func (s *PacketStore) IngestNewObservations(sinceObsID, limit int) int {
 		}
 		s.totalObs++
 		updatedTxs[r.txID] = tx
+
+		decoded := map[string]interface{}{
+			"header": map[string]interface{}{
+				"payloadTypeName": resolvePayloadTypeName(tx.PayloadType),
+			},
+		}
+		if tx.DecodedJSON != "" {
+			var payload map[string]interface{}
+			if json.Unmarshal([]byte(tx.DecodedJSON), &payload) == nil {
+				decoded["payload"] = payload
+			}
+		}
+
+		pkt := map[string]interface{}{
+			"id":                tx.ID,
+			"raw_hex":           strOrNil(tx.RawHex),
+			"hash":              strOrNil(tx.Hash),
+			"first_seen":        strOrNil(tx.FirstSeen),
+			"timestamp":         strOrNil(tx.FirstSeen),
+			"route_type":        intPtrOrNil(tx.RouteType),
+			"payload_type":      intPtrOrNil(tx.PayloadType),
+			"decoded_json":      strOrNil(tx.DecodedJSON),
+			"observer_id":       strOrNil(obs.ObserverID),
+			"observer_name":     strOrNil(obs.ObserverName),
+			"snr":               floatPtrOrNil(obs.SNR),
+			"rssi":              floatPtrOrNil(obs.RSSI),
+			"path_json":         strOrNil(obs.PathJSON),
+			"direction":         strOrNil(obs.Direction),
+			"observation_count": tx.ObservationCount,
+		}
+		broadcastMap := make(map[string]interface{}, len(pkt)+2)
+		for k, v := range pkt {
+			broadcastMap[k] = v
+		}
+		broadcastMap["decoded"] = decoded
+		broadcastMap["packet"] = pkt
+		broadcastMaps = append(broadcastMaps, broadcastMap)
 	}
 
 	// Re-pick best observation for updated transmissions and update subpath index
@@ -1275,7 +1327,7 @@ func (s *PacketStore) IngestNewObservations(sinceObsID, limit int) int {
 		// analytics caches cleared; no per-cycle log to avoid stdout overhead
 	}
 
-	return newMaxObsID
+	return broadcastMaps
 }
 
 // MaxTransmissionID returns the highest transmission ID in the store.
@@ -1659,6 +1711,218 @@ func (s *PacketStore) buildDistanceIndex() {
 		len(s.distHops), len(s.distPaths))
 }
 
+// estimatedMemoryMB returns estimated memory usage of the packet store.
+func (s *PacketStore) estimatedMemoryMB() float64 {
+	return float64(len(s.packets)*5120+s.totalObs*500) / 1048576.0
+}
+
+// EvictStale removes packets older than the retention window and/or exceeding
+// the memory cap. Must be called with s.mu held (Lock). Returns the number of
+// packets evicted.
+func (s *PacketStore) EvictStale() int {
+	if s.retentionHours <= 0 && s.maxMemoryMB <= 0 {
+		return 0
+	}
+
+	cutoffIdx := 0
+
+	// Time-based eviction: find how many packets from the head are too old
+	if s.retentionHours > 0 {
+		cutoff := time.Now().UTC().Add(-time.Duration(s.retentionHours*3600) * time.Second).Format(time.RFC3339)
+		for cutoffIdx < len(s.packets) && s.packets[cutoffIdx].FirstSeen < cutoff {
+			cutoffIdx++
+		}
+	}
+
+	// Memory-based eviction: if still over budget, trim more from head
+	if s.maxMemoryMB > 0 {
+		for cutoffIdx < len(s.packets) && s.estimatedMemoryMB() > float64(s.maxMemoryMB) {
+			// Estimate how many more to evict: rough binary approach
+			overMB := s.estimatedMemoryMB() - float64(s.maxMemoryMB)
+			// ~5KB per packet, so overMB * 1024*1024 / 5120 packets
+			extra := int(overMB * 1048576.0 / 5120.0)
+			if extra < 100 {
+				extra = 100
+			}
+			cutoffIdx += extra
+			if cutoffIdx > len(s.packets) {
+				cutoffIdx = len(s.packets)
+			}
+			// Recalculate estimated memory with fewer packets
+			// (we haven't actually removed yet, so simulate)
+			remainingPkts := len(s.packets) - cutoffIdx
+			remainingObs := s.totalObs
+			for _, tx := range s.packets[:cutoffIdx] {
+				remainingObs -= len(tx.Observations)
+			}
+			estMB := float64(remainingPkts*5120+remainingObs*500) / 1048576.0
+			if estMB <= float64(s.maxMemoryMB) {
+				break
+			}
+		}
+	}
+
+	if cutoffIdx == 0 {
+		return 0
+	}
+	if cutoffIdx > len(s.packets) {
+		cutoffIdx = len(s.packets)
+	}
+
+	evicting := s.packets[:cutoffIdx]
+	evictedObs := 0
+
+	// Remove from all indexes
+	for _, tx := range evicting {
+		delete(s.byHash, tx.Hash)
+		delete(s.byTxID, tx.ID)
+
+		// Remove observations from indexes
+		for _, obs := range tx.Observations {
+			delete(s.byObsID, obs.ID)
+			// Remove from byObserver
+			if obs.ObserverID != "" {
+				obsList := s.byObserver[obs.ObserverID]
+				for i, o := range obsList {
+					if o.ID == obs.ID {
+						s.byObserver[obs.ObserverID] = append(obsList[:i], obsList[i+1:]...)
+						break
+					}
+				}
+				if len(s.byObserver[obs.ObserverID]) == 0 {
+					delete(s.byObserver, obs.ObserverID)
+				}
+			}
+			evictedObs++
+		}
+
+		// Remove from byPayloadType
+		if tx.PayloadType != nil {
+			pt := *tx.PayloadType
+			ptList := s.byPayloadType[pt]
+			for i, t := range ptList {
+				if t.ID == tx.ID {
+					s.byPayloadType[pt] = append(ptList[:i], ptList[i+1:]...)
+					break
+				}
+			}
+			if len(s.byPayloadType[pt]) == 0 {
+				delete(s.byPayloadType, pt)
+			}
+		}
+
+		// Remove from byNode and nodeHashes
+		if tx.DecodedJSON != "" {
+			var decoded map[string]interface{}
+			if json.Unmarshal([]byte(tx.DecodedJSON), &decoded) == nil {
+				for _, field := range []string{"pubKey", "destPubKey", "srcPubKey"} {
+					if v, ok := decoded[field].(string); ok && v != "" {
+						if hashes, ok := s.nodeHashes[v]; ok {
+							delete(hashes, tx.Hash)
+							if len(hashes) == 0 {
+								delete(s.nodeHashes, v)
+							}
+						}
+						// Remove tx from byNode
+						nodeList := s.byNode[v]
+						for i, t := range nodeList {
+							if t.ID == tx.ID {
+								s.byNode[v] = append(nodeList[:i], nodeList[i+1:]...)
+								break
+							}
+						}
+						if len(s.byNode[v]) == 0 {
+							delete(s.byNode, v)
+						}
+					}
+				}
+			}
+		}
+
+		// Remove from subpath index
+		removeTxFromSubpathIndex(s.spIndex, tx)
+	}
+
+	// Remove from distance indexes — filter out records referencing evicted txs
+	evictedTxSet := make(map[*StoreTx]bool, cutoffIdx)
+	for _, tx := range evicting {
+		evictedTxSet[tx] = true
+	}
+	newDistHops := s.distHops[:0]
+	for i := range s.distHops {
+		if !evictedTxSet[s.distHops[i].tx] {
+			newDistHops = append(newDistHops, s.distHops[i])
+		}
+	}
+	s.distHops = newDistHops
+
+	newDistPaths := s.distPaths[:0]
+	for i := range s.distPaths {
+		if !evictedTxSet[s.distPaths[i].tx] {
+			newDistPaths = append(newDistPaths, s.distPaths[i])
+		}
+	}
+	s.distPaths = newDistPaths
+
+	// Trim packets slice
+	n := copy(s.packets, s.packets[cutoffIdx:])
+	s.packets = s.packets[:n]
+	s.totalObs -= evictedObs
+
+	evictCount := cutoffIdx
+	atomic.AddInt64(&s.evicted, int64(evictCount))
+	freedMB := float64(evictCount*5120+evictedObs*500) / 1048576.0
+	log.Printf("[store] Evicted %d packets older than %.0fh (freed ~%.1fMB estimated)",
+		evictCount, s.retentionHours, freedMB)
+
+	// Invalidate analytics caches
+	s.cacheMu.Lock()
+	s.rfCache = make(map[string]*cachedResult)
+	s.topoCache = make(map[string]*cachedResult)
+	s.hashCache = make(map[string]*cachedResult)
+	s.chanCache = make(map[string]*cachedResult)
+	s.distCache = make(map[string]*cachedResult)
+	s.subpathCache = make(map[string]*cachedResult)
+	s.cacheMu.Unlock()
+
+	// Invalidate hash size cache
+	s.hashSizeInfoMu.Lock()
+	s.hashSizeInfoCache = nil
+	s.hashSizeInfoMu.Unlock()
+
+	return evictCount
+}
+
+// RunEviction acquires the write lock and runs eviction. Safe to call from
+// a goroutine. Returns evicted count.
+func (s *PacketStore) RunEviction() int {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.EvictStale()
+}
+
+// StartEvictionTicker starts a background goroutine that runs eviction every
+// minute. Returns a stop function.
+func (s *PacketStore) StartEvictionTicker() func() {
+	if s.retentionHours <= 0 && s.maxMemoryMB <= 0 {
+		return func() {} // no-op
+	}
+	ticker := time.NewTicker(1 * time.Minute)
+	done := make(chan struct{})
+	go func() {
+		for {
+			select {
+			case <-ticker.C:
+				s.RunEviction()
+			case <-done:
+				ticker.Stop()
+				return
+			}
+		}
+	}()
+	return func() { close(done) }
+}
+
 // computeDistancesForTx computes distance records for a single transmission.
 func computeDistancesForTx(tx *StoreTx, nodeByPk map[string]*nodeInfo, repeaterSet map[string]bool, resolveHop func(string) *nodeInfo) ([]distHopRecord, *distPathRecord) {
 	pathHops := txGetParsedPath(tx)
@@ -2269,6 +2533,7 @@ func (s *PacketStore) computeAnalyticsRF(region string) map[string]interface{} {
 	seenTypeHashes := make(map[string]bool, len(s.packets))
 	typeBuckets := map[int]int{}
 	hourBuckets := map[string]int{}
+	seenHourHash := make(map[string]bool, len(s.packets)) // dedup packets-per-hour by hash+hour
 	snrByType := map[string]*struct{ vals []float64 }{}
 	sigTime := map[string]*struct {
 		snrs  []float64
@@ -2341,10 +2606,16 @@ func (s *PacketStore) computeAnalyticsRF(region string) map[string]interface{} {
 					rssiVals = append(rssiVals, *obs.RSSI)
 				}
 
-				// Packets per hour
+				// Packets per hour (unique by hash per hour)
 				if len(ts) >= 13 {
 					hr := ts[:13]
-					hourBuckets[hr]++
+					hk := hash + "|" + hr
+					if hash == "" || !seenHourHash[hk] {
+						if hash != "" {
+							seenHourHash[hk] = true
+						}
+						hourBuckets[hr]++
+					}
 				}
 
 				// Packet sizes (unique by hash)
@@ -2432,7 +2703,14 @@ func (s *PacketStore) computeAnalyticsRF(region string) map[string]interface{} {
 					}
 
 					if len(ts) >= 13 {
-						hourBuckets[ts[:13]]++
+						hr := ts[:13]
+						hk := hash + "|" + hr
+						if hash == "" || !seenHourHash[hk] {
+							if hash != "" {
+								seenHourHash[hk] = true
+							}
+							hourBuckets[hr]++
+						}
 					}
 				}
 			} else {
@@ -3705,12 +3983,21 @@ func (s *PacketStore) computeAnalyticsHashSizes(region string) map[string]interf
 		return multiByteNodes[i]["packets"].(int) > multiByteNodes[j]["packets"].(int)
 	})
 
+	// Distribution by repeaters: count unique nodes per hash size
+	distributionByRepeaters := map[string]int{"1": 0, "2": 0, "3": 0}
+	for _, data := range byNode {
+		hs := data["hashSize"].(int)
+		key := strconv.Itoa(hs)
+		distributionByRepeaters[key]++
+	}
+
 	return map[string]interface{}{
-		"total":          total,
-		"distribution":   distribution,
-		"hourly":         hourly,
-		"topHops":        topHops,
-		"multiByteNodes": multiByteNodes,
+		"total":                    total,
+		"distribution":            distribution,
+		"distributionByRepeaters": distributionByRepeaters,
+		"hourly":                  hourly,
+		"topHops":                 topHops,
+		"multiByteNodes":          multiByteNodes,
 	}
 }
 
@@ -3722,8 +4009,26 @@ type hashSizeNodeInfo struct {
 	Inconsistent bool
 }
 
-// GetNodeHashSizeInfo scans advert packets to compute per-node hash size data.
+// GetNodeHashSizeInfo returns cached per-node hash size data, recomputing at most every 15s.
 func (s *PacketStore) GetNodeHashSizeInfo() map[string]*hashSizeNodeInfo {
+	const ttl = 15 * time.Second
+	s.hashSizeInfoMu.Lock()
+	if s.hashSizeInfoCache != nil && time.Since(s.hashSizeInfoAt) < ttl {
+		cached := s.hashSizeInfoCache
+		s.hashSizeInfoMu.Unlock()
+		return cached
+	}
+	s.hashSizeInfoMu.Unlock()
+	result := s.computeNodeHashSizeInfo()
+	s.hashSizeInfoMu.Lock()
+	s.hashSizeInfoCache = result
+	s.hashSizeInfoAt = time.Now()
+	s.hashSizeInfoMu.Unlock()
+	return result
+}
+
+// computeNodeHashSizeInfo scans advert packets to compute per-node hash size data.
+func (s *PacketStore) computeNodeHashSizeInfo() map[string]*hashSizeNodeInfo {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 

cmd/server/websocket.go

@@ -1,229 +1,245 @@
-package main
-
-import (
-	"encoding/json"
-	"log"
-	"net/http"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/gorilla/websocket"
-)
-
-var upgrader = websocket.Upgrader{
-	ReadBufferSize:  1024,
-	WriteBufferSize: 4096,
-	CheckOrigin:     func(r *http.Request) bool { return true },
-}
-
-// Hub manages WebSocket clients and broadcasts.
-type Hub struct {
-	mu      sync.RWMutex
-	clients map[*Client]bool
-}
-
-// Client is a single WebSocket connection.
-type Client struct {
-	conn *websocket.Conn
-	send chan []byte
-}
-
-func NewHub() *Hub {
-	return &Hub{
-		clients: make(map[*Client]bool),
-	}
-}
-
-func (h *Hub) ClientCount() int {
-	h.mu.RLock()
-	defer h.mu.RUnlock()
-	return len(h.clients)
-}
-
-func (h *Hub) Register(c *Client) {
-	h.mu.Lock()
-	h.clients[c] = true
-	h.mu.Unlock()
-	log.Printf("[ws] client connected (%d total)", h.ClientCount())
-}
-
-func (h *Hub) Unregister(c *Client) {
-	h.mu.Lock()
-	if _, ok := h.clients[c]; ok {
-		delete(h.clients, c)
-		close(c.send)
-	}
-	h.mu.Unlock()
-	log.Printf("[ws] client disconnected (%d total)", h.ClientCount())
-}
-
-// Broadcast sends a message to all connected clients.
-func (h *Hub) Broadcast(msg interface{}) {
-	data, err := json.Marshal(msg)
-	if err != nil {
-		log.Printf("[ws] marshal error: %v", err)
-		return
-	}
-	h.mu.RLock()
-	defer h.mu.RUnlock()
-	for c := range h.clients {
-		select {
-		case c.send <- data:
-		default:
-			// Client buffer full — drop
-		}
-	}
-}
-
-// ServeWS handles the WebSocket upgrade and runs the client.
-func (h *Hub) ServeWS(w http.ResponseWriter, r *http.Request) {
-	conn, err := upgrader.Upgrade(w, r, nil)
-	if err != nil {
-		log.Printf("[ws] upgrade error: %v", err)
-		return
-	}
-
-	client := &Client{
-		conn: conn,
-		send: make(chan []byte, 256),
-	}
-	h.Register(client)
-
-	go client.writePump()
-	go client.readPump(h)
-}
-
-// wsOrStatic upgrades WebSocket requests at any path, serves static files otherwise.
-func wsOrStatic(hub *Hub, static http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if strings.EqualFold(r.Header.Get("Upgrade"), "websocket") {
-			hub.ServeWS(w, r)
-			return
-		}
-		static.ServeHTTP(w, r)
-	})
-}
-
-func (c *Client) readPump(hub *Hub) {
-	defer func() {
-		hub.Unregister(c)
-		c.conn.Close()
-	}()
-	c.conn.SetReadLimit(512)
-	c.conn.SetReadDeadline(time.Now().Add(60 * time.Second))
-	c.conn.SetPongHandler(func(string) error {
-		c.conn.SetReadDeadline(time.Now().Add(60 * time.Second))
-		return nil
-	})
-	for {
-		_, _, err := c.conn.ReadMessage()
-		if err != nil {
-			break
-		}
-	}
-}
-
-func (c *Client) writePump() {
-	ticker := time.NewTicker(30 * time.Second)
-	defer func() {
-		ticker.Stop()
-		c.conn.Close()
-	}()
-	for {
-		select {
-		case message, ok := <-c.send:
-			c.conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
-			if !ok {
-				c.conn.WriteMessage(websocket.CloseMessage, []byte{})
-				return
-			}
-			if err := c.conn.WriteMessage(websocket.TextMessage, message); err != nil {
-				return
-			}
-		case <-ticker.C:
-			c.conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
-			if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
-				return
-			}
-		}
-	}
-}
-
-// Poller watches for new transmissions in SQLite and broadcasts them.
-type Poller struct {
-	db       *DB
-	hub      *Hub
-	store    *PacketStore // optional: if set, new transmissions are ingested into memory
-	interval time.Duration
-	stop     chan struct{}
-}
-
-func NewPoller(db *DB, hub *Hub, interval time.Duration) *Poller {
-	return &Poller{db: db, hub: hub, interval: interval, stop: make(chan struct{})}
-}
-
-func (p *Poller) Start() {
-	lastID := p.db.GetMaxTransmissionID()
-	lastObsID := p.db.GetMaxObservationID()
-	log.Printf("[poller] starting from transmission ID %d, obs ID %d, interval %v", lastID, lastObsID, p.interval)
-
-	ticker := time.NewTicker(p.interval)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-ticker.C:
-			if p.store != nil {
-				// Ingest new transmissions into in-memory store and broadcast
-				newTxs, newMax := p.store.IngestNewFromDB(lastID, 100)
-				if newMax > lastID {
-					lastID = newMax
-				}
-				// Ingest new observations for existing transmissions (fixes #174)
-				newObsMax := p.store.IngestNewObservations(lastObsID, 500)
-				if newObsMax > lastObsID {
-					lastObsID = newObsMax
-				}
-				if len(newTxs) > 0 {
-					log.Printf("[broadcast] sending %d packets to %d clients (lastID now %d)", len(newTxs), p.hub.ClientCount(), lastID)
-				}
-				for _, tx := range newTxs {
-					p.hub.Broadcast(WSMessage{
-						Type: "packet",
-						Data: tx,
-					})
-				}
-			} else {
-				// Fallback: direct DB query (used when store is nil, e.g. tests)
-				newTxs, err := p.db.GetNewTransmissionsSince(lastID, 100)
-				if err != nil {
-					log.Printf("[poller] error: %v", err)
-					continue
-				}
-				for _, tx := range newTxs {
-					id, _ := tx["id"].(int)
-					if id > lastID {
-						lastID = id
-					}
-					// Copy packet fields for the nested packet (avoids circular ref)
-					pkt := make(map[string]interface{}, len(tx))
-					for k, v := range tx {
-						pkt[k] = v
-					}
-					tx["packet"] = pkt
-					p.hub.Broadcast(WSMessage{
-						Type: "packet",
-						Data: tx,
-					})
-				}
-			}
-		case <-p.stop:
-			return
-		}
-	}
-}
-
-func (p *Poller) Stop() {
-	close(p.stop)
-}
+package main
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+var upgrader = websocket.Upgrader{
+	ReadBufferSize:  1024,
+	WriteBufferSize: 4096,
+	CheckOrigin:     func(r *http.Request) bool { return true },
+}
+
+// Hub manages WebSocket clients and broadcasts.
+type Hub struct {
+	mu      sync.RWMutex
+	clients map[*Client]bool
+}
+
+// Client is a single WebSocket connection.
+type Client struct {
+	conn *websocket.Conn
+	send chan []byte
+}
+
+func NewHub() *Hub {
+	return &Hub{
+		clients: make(map[*Client]bool),
+	}
+}
+
+func (h *Hub) ClientCount() int {
+	h.mu.RLock()
+	defer h.mu.RUnlock()
+	return len(h.clients)
+}
+
+func (h *Hub) Register(c *Client) {
+	h.mu.Lock()
+	h.clients[c] = true
+	h.mu.Unlock()
+	log.Printf("[ws] client connected (%d total)", h.ClientCount())
+}
+
+func (h *Hub) Unregister(c *Client) {
+	h.mu.Lock()
+	if _, ok := h.clients[c]; ok {
+		delete(h.clients, c)
+		close(c.send)
+	}
+	h.mu.Unlock()
+	log.Printf("[ws] client disconnected (%d total)", h.ClientCount())
+}
+
+// Broadcast sends a message to all connected clients.
+func (h *Hub) Broadcast(msg interface{}) {
+	data, err := json.Marshal(msg)
+	if err != nil {
+		log.Printf("[ws] marshal error: %v", err)
+		return
+	}
+	h.mu.RLock()
+	defer h.mu.RUnlock()
+	for c := range h.clients {
+		select {
+		case c.send <- data:
+		default:
+			// Client buffer full — drop
+		}
+	}
+}
+
+// ServeWS handles the WebSocket upgrade and runs the client.
+func (h *Hub) ServeWS(w http.ResponseWriter, r *http.Request) {
+	conn, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		log.Printf("[ws] upgrade error: %v", err)
+		return
+	}
+
+	client := &Client{
+		conn: conn,
+		send: make(chan []byte, 256),
+	}
+	h.Register(client)
+
+	go client.writePump()
+	go client.readPump(h)
+}
+
+// wsOrStatic upgrades WebSocket requests at any path, serves static files otherwise.
+func wsOrStatic(hub *Hub, static http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if strings.EqualFold(r.Header.Get("Upgrade"), "websocket") {
+			hub.ServeWS(w, r)
+			return
+		}
+		static.ServeHTTP(w, r)
+	})
+}
+
+func (c *Client) readPump(hub *Hub) {
+	defer func() {
+		hub.Unregister(c)
+		c.conn.Close()
+	}()
+	c.conn.SetReadLimit(512)
+	c.conn.SetReadDeadline(time.Now().Add(60 * time.Second))
+	c.conn.SetPongHandler(func(string) error {
+		c.conn.SetReadDeadline(time.Now().Add(60 * time.Second))
+		return nil
+	})
+	for {
+		_, _, err := c.conn.ReadMessage()
+		if err != nil {
+			break
+		}
+	}
+}
+
+func (c *Client) writePump() {
+	ticker := time.NewTicker(30 * time.Second)
+	defer func() {
+		ticker.Stop()
+		c.conn.Close()
+	}()
+	for {
+		select {
+		case message, ok := <-c.send:
+			c.conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
+			if !ok {
+				c.conn.WriteMessage(websocket.CloseMessage, []byte{})
+				return
+			}
+			if err := c.conn.WriteMessage(websocket.TextMessage, message); err != nil {
+				return
+			}
+		case <-ticker.C:
+			c.conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
+			if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
+				return
+			}
+		}
+	}
+}
+
+// Poller watches for new transmissions in SQLite and broadcasts them.
+type Poller struct {
+	db       *DB
+	hub      *Hub
+	store    *PacketStore // optional: if set, new transmissions are ingested into memory
+	interval time.Duration
+	stop     chan struct{}
+}
+
+func NewPoller(db *DB, hub *Hub, interval time.Duration) *Poller {
+	return &Poller{db: db, hub: hub, interval: interval, stop: make(chan struct{})}
+}
+
+func (p *Poller) Start() {
+	lastID := p.db.GetMaxTransmissionID()
+	lastObsID := p.db.GetMaxObservationID()
+	log.Printf("[poller] starting from transmission ID %d, obs ID %d, interval %v", lastID, lastObsID, p.interval)
+
+	ticker := time.NewTicker(p.interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			if p.store != nil {
+				// Ingest new transmissions into in-memory store and broadcast
+				newTxs, newMax := p.store.IngestNewFromDB(lastID, 100)
+				if newMax > lastID {
+					lastID = newMax
+				}
+				// Ingest new observations for existing transmissions (fixes #174)
+				nextObsID := lastObsID
+				if err := p.db.conn.QueryRow(`
+					SELECT COALESCE(MAX(id), ?) FROM (
+						SELECT id FROM observations
+						WHERE id > ?
+						ORDER BY id ASC
+						LIMIT 500
+					)`, lastObsID, lastObsID).Scan(&nextObsID); err != nil {
+					nextObsID = lastObsID
+				}
+				newObs := p.store.IngestNewObservations(lastObsID, 500)
+				if nextObsID > lastObsID {
+					lastObsID = nextObsID
+				}
+				if len(newTxs) > 0 {
+					log.Printf("[broadcast] sending %d packets to %d clients (lastID now %d)", len(newTxs), p.hub.ClientCount(), lastID)
+				}
+				for _, tx := range newTxs {
+					p.hub.Broadcast(WSMessage{
+						Type: "packet",
+						Data: tx,
+					})
+				}
+				for _, obs := range newObs {
+					p.hub.Broadcast(WSMessage{
+						Type: "packet",
+						Data: obs,
+					})
+				}
+			} else {
+				// Fallback: direct DB query (used when store is nil, e.g. tests)
+				newTxs, err := p.db.GetNewTransmissionsSince(lastID, 100)
+				if err != nil {
+					log.Printf("[poller] error: %v", err)
+					continue
+				}
+				for _, tx := range newTxs {
+					id, _ := tx["id"].(int)
+					if id > lastID {
+						lastID = id
+					}
+					// Copy packet fields for the nested packet (avoids circular ref)
+					pkt := make(map[string]interface{}, len(tx))
+					for k, v := range tx {
+						pkt[k] = v
+					}
+					tx["packet"] = pkt
+					p.hub.Broadcast(WSMessage{
+						Type: "packet",
+						Data: tx,
+					})
+				}
+			}
+		case <-p.stop:
+			return
+		}
+	}
+}
+
+func (p *Poller) Stop() {
+	close(p.stop)
+}

cmd/server/websocket_test.go

@@ -1,275 +1,415 @@
-package main
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"github.com/gorilla/websocket"
-)
-
-func TestHubBroadcast(t *testing.T) {
-	hub := NewHub()
-
-	if hub.ClientCount() != 0 {
-		t.Errorf("expected 0 clients, got %d", hub.ClientCount())
-	}
-
-	// Create a test server with WebSocket endpoint
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		hub.ServeWS(w, r)
-	}))
-	defer srv.Close()
-
-	// Connect a WebSocket client
-	wsURL := "ws" + srv.URL[4:] // replace http with ws
-	conn, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
-	if err != nil {
-		t.Fatalf("dial error: %v", err)
-	}
-	defer conn.Close()
-
-	// Wait for registration
-	time.Sleep(50 * time.Millisecond)
-
-	if hub.ClientCount() != 1 {
-		t.Errorf("expected 1 client, got %d", hub.ClientCount())
-	}
-
-	// Broadcast a message
-	hub.Broadcast(map[string]interface{}{
-		"type": "packet",
-		"data": map[string]interface{}{"id": 1, "hash": "test123"},
-	})
-
-	// Read the message
-	conn.SetReadDeadline(time.Now().Add(2 * time.Second))
-	_, msg, err := conn.ReadMessage()
-	if err != nil {
-		t.Fatalf("read error: %v", err)
-	}
-	if len(msg) == 0 {
-		t.Error("expected non-empty message")
-	}
-
-	// Disconnect
-	conn.Close()
-	time.Sleep(100 * time.Millisecond)
-}
-
-func TestPollerCreation(t *testing.T) {
-	db := setupTestDB(t)
-	defer db.Close()
-	seedTestData(t, db)
-	hub := NewHub()
-
-	poller := NewPoller(db, hub, 100*time.Millisecond)
-	if poller == nil {
-		t.Fatal("expected poller")
-	}
-
-	// Start and stop
-	go poller.Start()
-	time.Sleep(200 * time.Millisecond)
-	poller.Stop()
-}
-
-func TestHubMultipleClients(t *testing.T) {
-	hub := NewHub()
-
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		hub.ServeWS(w, r)
-	}))
-	defer srv.Close()
-
-	wsURL := "ws" + srv.URL[4:]
-
-	// Connect two clients
-	conn1, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
-	if err != nil {
-		t.Fatalf("dial error: %v", err)
-	}
-	defer conn1.Close()
-
-	conn2, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
-	if err != nil {
-		t.Fatalf("dial error: %v", err)
-	}
-	defer conn2.Close()
-
-	time.Sleep(100 * time.Millisecond)
-
-	if hub.ClientCount() != 2 {
-		t.Errorf("expected 2 clients, got %d", hub.ClientCount())
-	}
-
-	// Broadcast and both should receive
-	hub.Broadcast(map[string]interface{}{"type": "test", "data": "hello"})
-
-	conn1.SetReadDeadline(time.Now().Add(2 * time.Second))
-	_, msg1, err := conn1.ReadMessage()
-	if err != nil {
-		t.Fatalf("conn1 read error: %v", err)
-	}
-	if len(msg1) == 0 {
-		t.Error("expected non-empty message on conn1")
-	}
-
-	conn2.SetReadDeadline(time.Now().Add(2 * time.Second))
-	_, msg2, err := conn2.ReadMessage()
-	if err != nil {
-		t.Fatalf("conn2 read error: %v", err)
-	}
-	if len(msg2) == 0 {
-		t.Error("expected non-empty message on conn2")
-	}
-
-	// Disconnect one
-	conn1.Close()
-	time.Sleep(100 * time.Millisecond)
-
-	// Remaining client should still work
-	hub.Broadcast(map[string]interface{}{"type": "test2"})
-
-	conn2.SetReadDeadline(time.Now().Add(2 * time.Second))
-	_, msg3, err := conn2.ReadMessage()
-	if err != nil {
-		t.Fatalf("conn2 read error after disconnect: %v", err)
-	}
-	if len(msg3) == 0 {
-		t.Error("expected non-empty message")
-	}
-}
-
-func TestBroadcastFullBuffer(t *testing.T) {
-	hub := NewHub()
-
-	// Create a client with tiny buffer (1)
-	client := &Client{
-		send: make(chan []byte, 1),
-	}
-	hub.mu.Lock()
-	hub.clients[client] = true
-	hub.mu.Unlock()
-
-	// Fill the buffer
-	client.send <- []byte("first")
-
-	// This broadcast should drop the message (buffer full)
-	hub.Broadcast(map[string]interface{}{"type": "dropped"})
-
-	// Channel should still only have the first message
-	select {
-	case msg := <-client.send:
-		if string(msg) != "first" {
-			t.Errorf("expected 'first', got %s", string(msg))
-		}
-	default:
-		t.Error("expected message in channel")
-	}
-
-	// Clean up
-	hub.mu.Lock()
-	delete(hub.clients, client)
-	hub.mu.Unlock()
-}
-
-func TestBroadcastMarshalError(t *testing.T) {
-	hub := NewHub()
-
-	// Marshal error: functions can't be marshaled to JSON
-	hub.Broadcast(map[string]interface{}{"bad": func() {}})
-	// Should not panic — just log and return
-}
-
-func TestPollerBroadcastsNewData(t *testing.T) {
-	db := setupTestDB(t)
-	defer db.Close()
-	seedTestData(t, db)
-	hub := NewHub()
-
-	// Create a client to receive broadcasts
-	client := &Client{
-		send: make(chan []byte, 256),
-	}
-	hub.mu.Lock()
-	hub.clients[client] = true
-	hub.mu.Unlock()
-
-	poller := NewPoller(db, hub, 50*time.Millisecond)
-	go poller.Start()
-
-	// Insert new data to trigger broadcast
-	db.conn.Exec(`INSERT INTO transmissions (raw_hex, hash, first_seen, route_type, payload_type)
-		VALUES ('EEFF', 'newhash123456789', '2026-01-16T10:00:00Z', 1, 4)`)
-
-	time.Sleep(200 * time.Millisecond)
-	poller.Stop()
-
-	// Check if client received broadcast with packet field (fixes #162)
-	select {
-	case msg := <-client.send:
-		if len(msg) == 0 {
-			t.Error("expected non-empty broadcast message")
-		}
-		var parsed map[string]interface{}
-		if err := json.Unmarshal(msg, &parsed); err != nil {
-			t.Fatalf("failed to parse broadcast: %v", err)
-		}
-		if parsed["type"] != "packet" {
-			t.Errorf("expected type=packet, got %v", parsed["type"])
-		}
-		data, ok := parsed["data"].(map[string]interface{})
-		if !ok {
-			t.Fatal("expected data to be an object")
-		}
-		// packets.js filters on m.data.packet — must exist
-		pkt, ok := data["packet"]
-		if !ok || pkt == nil {
-			t.Error("expected data.packet to exist (required by packets.js WS handler)")
-		}
-		pktMap, ok := pkt.(map[string]interface{})
-		if !ok {
-			t.Fatal("expected data.packet to be an object")
-		}
-		// Verify key fields exist in nested packet (timestamp required by packets.js)
-		for _, field := range []string{"id", "hash", "payload_type", "timestamp"} {
-			if _, exists := pktMap[field]; !exists {
-				t.Errorf("expected data.packet.%s to exist", field)
-			}
-		}
-	default:
-		// Might not have received due to timing
-	}
-
-	// Clean up
-	hub.mu.Lock()
-	delete(hub.clients, client)
-	hub.mu.Unlock()
-}
-
-func TestHubRegisterUnregister(t *testing.T) {
-	hub := NewHub()
-
-	client := &Client{
-		send: make(chan []byte, 256),
-	}
-
-	hub.Register(client)
-	if hub.ClientCount() != 1 {
-		t.Errorf("expected 1 client after register, got %d", hub.ClientCount())
-	}
-
-	hub.Unregister(client)
-	if hub.ClientCount() != 0 {
-		t.Errorf("expected 0 clients after unregister, got %d", hub.ClientCount())
-	}
-
-	// Unregister again should be safe
-	hub.Unregister(client)
-	if hub.ClientCount() != 0 {
-		t.Errorf("expected 0 clients, got %d", hub.ClientCount())
-	}
-}
+package main
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"sort"
+	"testing"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+func TestHubBroadcast(t *testing.T) {
+	hub := NewHub()
+
+	if hub.ClientCount() != 0 {
+		t.Errorf("expected 0 clients, got %d", hub.ClientCount())
+	}
+
+	// Create a test server with WebSocket endpoint
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		hub.ServeWS(w, r)
+	}))
+	defer srv.Close()
+
+	// Connect a WebSocket client
+	wsURL := "ws" + srv.URL[4:] // replace http with ws
+	conn, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
+	if err != nil {
+		t.Fatalf("dial error: %v", err)
+	}
+	defer conn.Close()
+
+	// Wait for registration
+	time.Sleep(50 * time.Millisecond)
+
+	if hub.ClientCount() != 1 {
+		t.Errorf("expected 1 client, got %d", hub.ClientCount())
+	}
+
+	// Broadcast a message
+	hub.Broadcast(map[string]interface{}{
+		"type": "packet",
+		"data": map[string]interface{}{"id": 1, "hash": "test123"},
+	})
+
+	// Read the message
+	conn.SetReadDeadline(time.Now().Add(2 * time.Second))
+	_, msg, err := conn.ReadMessage()
+	if err != nil {
+		t.Fatalf("read error: %v", err)
+	}
+	if len(msg) == 0 {
+		t.Error("expected non-empty message")
+	}
+
+	// Disconnect
+	conn.Close()
+	time.Sleep(100 * time.Millisecond)
+}
+
+func TestPollerCreation(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+	seedTestData(t, db)
+	hub := NewHub()
+
+	poller := NewPoller(db, hub, 100*time.Millisecond)
+	if poller == nil {
+		t.Fatal("expected poller")
+	}
+
+	// Start and stop
+	go poller.Start()
+	time.Sleep(200 * time.Millisecond)
+	poller.Stop()
+}
+
+func TestHubMultipleClients(t *testing.T) {
+	hub := NewHub()
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		hub.ServeWS(w, r)
+	}))
+	defer srv.Close()
+
+	wsURL := "ws" + srv.URL[4:]
+
+	// Connect two clients
+	conn1, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
+	if err != nil {
+		t.Fatalf("dial error: %v", err)
+	}
+	defer conn1.Close()
+
+	conn2, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
+	if err != nil {
+		t.Fatalf("dial error: %v", err)
+	}
+	defer conn2.Close()
+
+	time.Sleep(100 * time.Millisecond)
+
+	if hub.ClientCount() != 2 {
+		t.Errorf("expected 2 clients, got %d", hub.ClientCount())
+	}
+
+	// Broadcast and both should receive
+	hub.Broadcast(map[string]interface{}{"type": "test", "data": "hello"})
+
+	conn1.SetReadDeadline(time.Now().Add(2 * time.Second))
+	_, msg1, err := conn1.ReadMessage()
+	if err != nil {
+		t.Fatalf("conn1 read error: %v", err)
+	}
+	if len(msg1) == 0 {
+		t.Error("expected non-empty message on conn1")
+	}
+
+	conn2.SetReadDeadline(time.Now().Add(2 * time.Second))
+	_, msg2, err := conn2.ReadMessage()
+	if err != nil {
+		t.Fatalf("conn2 read error: %v", err)
+	}
+	if len(msg2) == 0 {
+		t.Error("expected non-empty message on conn2")
+	}
+
+	// Disconnect one
+	conn1.Close()
+	time.Sleep(100 * time.Millisecond)
+
+	// Remaining client should still work
+	hub.Broadcast(map[string]interface{}{"type": "test2"})
+
+	conn2.SetReadDeadline(time.Now().Add(2 * time.Second))
+	_, msg3, err := conn2.ReadMessage()
+	if err != nil {
+		t.Fatalf("conn2 read error after disconnect: %v", err)
+	}
+	if len(msg3) == 0 {
+		t.Error("expected non-empty message")
+	}
+}
+
+func TestBroadcastFullBuffer(t *testing.T) {
+	hub := NewHub()
+
+	// Create a client with tiny buffer (1)
+	client := &Client{
+		send: make(chan []byte, 1),
+	}
+	hub.mu.Lock()
+	hub.clients[client] = true
+	hub.mu.Unlock()
+
+	// Fill the buffer
+	client.send <- []byte("first")
+
+	// This broadcast should drop the message (buffer full)
+	hub.Broadcast(map[string]interface{}{"type": "dropped"})
+
+	// Channel should still only have the first message
+	select {
+	case msg := <-client.send:
+		if string(msg) != "first" {
+			t.Errorf("expected 'first', got %s", string(msg))
+		}
+	default:
+		t.Error("expected message in channel")
+	}
+
+	// Clean up
+	hub.mu.Lock()
+	delete(hub.clients, client)
+	hub.mu.Unlock()
+}
+
+func TestBroadcastMarshalError(t *testing.T) {
+	hub := NewHub()
+
+	// Marshal error: functions can't be marshaled to JSON
+	hub.Broadcast(map[string]interface{}{"bad": func() {}})
+	// Should not panic — just log and return
+}
+
+func TestPollerBroadcastsNewData(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+	seedTestData(t, db)
+	hub := NewHub()
+
+	// Create a client to receive broadcasts
+	client := &Client{
+		send: make(chan []byte, 256),
+	}
+	hub.mu.Lock()
+	hub.clients[client] = true
+	hub.mu.Unlock()
+
+	poller := NewPoller(db, hub, 50*time.Millisecond)
+	go poller.Start()
+
+	// Insert new data to trigger broadcast
+	db.conn.Exec(`INSERT INTO transmissions (raw_hex, hash, first_seen, route_type, payload_type)
+		VALUES ('EEFF', 'newhash123456789', '2026-01-16T10:00:00Z', 1, 4)`)
+
+	time.Sleep(200 * time.Millisecond)
+	poller.Stop()
+
+	// Check if client received broadcast with packet field (fixes #162)
+	select {
+	case msg := <-client.send:
+		if len(msg) == 0 {
+			t.Error("expected non-empty broadcast message")
+		}
+		var parsed map[string]interface{}
+		if err := json.Unmarshal(msg, &parsed); err != nil {
+			t.Fatalf("failed to parse broadcast: %v", err)
+		}
+		if parsed["type"] != "packet" {
+			t.Errorf("expected type=packet, got %v", parsed["type"])
+		}
+		data, ok := parsed["data"].(map[string]interface{})
+		if !ok {
+			t.Fatal("expected data to be an object")
+		}
+		// packets.js filters on m.data.packet — must exist
+		pkt, ok := data["packet"]
+		if !ok || pkt == nil {
+			t.Error("expected data.packet to exist (required by packets.js WS handler)")
+		}
+		pktMap, ok := pkt.(map[string]interface{})
+		if !ok {
+			t.Fatal("expected data.packet to be an object")
+		}
+		// Verify key fields exist in nested packet (timestamp required by packets.js)
+		for _, field := range []string{"id", "hash", "payload_type", "timestamp"} {
+			if _, exists := pktMap[field]; !exists {
+				t.Errorf("expected data.packet.%s to exist", field)
+			}
+		}
+	default:
+		// Might not have received due to timing
+	}
+
+	// Clean up
+	hub.mu.Lock()
+	delete(hub.clients, client)
+	hub.mu.Unlock()
+}
+
+func TestPollerBroadcastsMultipleObservations(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+	seedTestData(t, db)
+	hub := NewHub()
+
+	client := &Client{
+		send: make(chan []byte, 256),
+	}
+	hub.mu.Lock()
+	hub.clients[client] = true
+	hub.mu.Unlock()
+	defer func() {
+		hub.mu.Lock()
+		delete(hub.clients, client)
+		hub.mu.Unlock()
+	}()
+
+	poller := NewPoller(db, hub, 50*time.Millisecond)
+	store := NewPacketStore(db, nil)
+	if err := store.Load(); err != nil {
+		t.Fatalf("store load failed: %v", err)
+	}
+	poller.store = store
+	go poller.Start()
+	defer poller.Stop()
+
+	// Wait for poller to initialize its lastID/lastObsID cursors before
+	// inserting new data; otherwise the poller may snapshot a lastID that
+	// already includes the test data and never broadcast it.
+	time.Sleep(100 * time.Millisecond)
+
+	now := time.Now().UTC().Format(time.RFC3339)
+	if _, err := db.conn.Exec(`INSERT INTO transmissions (raw_hex, hash, first_seen, route_type, payload_type, decoded_json)
+		VALUES ('FACE', 'starbursthash237a', ?, 1, 4, '{"pubKey":"aabbccdd11223344","type":"ADVERT"}')`, now); err != nil {
+		t.Fatalf("insert tx failed: %v", err)
+	}
+	var txID int
+	if err := db.conn.QueryRow(`SELECT id FROM transmissions WHERE hash='starbursthash237a'`).Scan(&txID); err != nil {
+		t.Fatalf("query tx id failed: %v", err)
+	}
+	ts := time.Now().Unix()
+	if _, err := db.conn.Exec(`INSERT INTO observations (transmission_id, observer_idx, snr, rssi, path_json, timestamp)
+		VALUES (?, 1, 14.0, -82, '["aa"]', ?),
+		       (?, 2, 10.5, -90, '["aa","bb"]', ?),
+		       (?, 1, 7.0, -96, '["aa","bb","cc"]', ?)`,
+		txID, ts, txID, ts+1, txID, ts+2); err != nil {
+		t.Fatalf("insert observations failed: %v", err)
+	}
+
+	deadline := time.After(2 * time.Second)
+	var dataMsgs []map[string]interface{}
+	for len(dataMsgs) < 3 {
+		select {
+		case raw := <-client.send:
+			var parsed map[string]interface{}
+			if err := json.Unmarshal(raw, &parsed); err != nil {
+				t.Fatalf("unmarshal ws msg failed: %v", err)
+			}
+			if parsed["type"] != "packet" {
+				continue
+			}
+			data, ok := parsed["data"].(map[string]interface{})
+			if !ok {
+				continue
+			}
+			if data["hash"] == "starbursthash237a" {
+				dataMsgs = append(dataMsgs, data)
+			}
+		case <-deadline:
+			t.Fatalf("timed out waiting for 3 observation broadcasts, got %d", len(dataMsgs))
+		}
+	}
+
+	if len(dataMsgs) != 3 {
+		t.Fatalf("expected 3 messages, got %d", len(dataMsgs))
+	}
+
+	paths := make([]string, 0, 3)
+	observers := make(map[string]bool)
+	for _, m := range dataMsgs {
+		hash, _ := m["hash"].(string)
+		if hash != "starbursthash237a" {
+			t.Fatalf("unexpected hash %q", hash)
+		}
+		p, _ := m["path_json"].(string)
+		paths = append(paths, p)
+		if oid, ok := m["observer_id"].(string); ok && oid != "" {
+			observers[oid] = true
+		}
+	}
+	sort.Strings(paths)
+	wantPaths := []string{`["aa","bb","cc"]`, `["aa","bb"]`, `["aa"]`}
+	sort.Strings(wantPaths)
+	for i := range wantPaths {
+		if paths[i] != wantPaths[i] {
+			t.Fatalf("path mismatch at %d: got %q want %q", i, paths[i], wantPaths[i])
+		}
+	}
+	if len(observers) < 2 {
+		t.Fatalf("expected observations from >=2 observers, got %d", len(observers))
+	}
+}
+
+func TestIngestNewObservationsBroadcast(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+	seedTestData(t, db)
+	store := NewPacketStore(db, nil)
+	if err := store.Load(); err != nil {
+		t.Fatalf("store load failed: %v", err)
+	}
+
+	maxObs := db.GetMaxObservationID()
+	now := time.Now().Unix()
+	if _, err := db.conn.Exec(`INSERT INTO observations (transmission_id, observer_idx, snr, rssi, path_json, timestamp)
+		VALUES (1, 2, 6.0, -100, '["aa","zz"]', ?),
+		       (1, 1, 5.0, -101, '["aa","yy"]', ?)`, now, now+1); err != nil {
+		t.Fatalf("insert new observations failed: %v", err)
+	}
+
+	maps := store.IngestNewObservations(maxObs, 500)
+	if len(maps) != 2 {
+		t.Fatalf("expected 2 broadcast maps, got %d", len(maps))
+	}
+	for _, m := range maps {
+		if m["hash"] != "abc123def4567890" {
+			t.Fatalf("unexpected hash in map: %v", m["hash"])
+		}
+		path, ok := m["path_json"].(string)
+		if !ok || path == "" {
+			t.Fatalf("missing path_json in map: %#v", m)
+		}
+		if _, ok := m["observer_id"]; !ok {
+			t.Fatalf("missing observer_id in map: %#v", m)
+		}
+	}
+}
+
+func TestHubRegisterUnregister(t *testing.T) {
+	hub := NewHub()
+
+	client := &Client{
+		send: make(chan []byte, 256),
+	}
+
+	hub.Register(client)
+	if hub.ClientCount() != 1 {
+		t.Errorf("expected 1 client after register, got %d", hub.ClientCount())
+	}
+
+	hub.Unregister(client)
+	if hub.ClientCount() != 0 {
+		t.Errorf("expected 0 clients after unregister, got %d", hub.ClientCount())
+	}
+
+	// Unregister again should be safe
+	hub.Unregister(client)
+	if hub.ClientCount() != 0 {
+		t.Errorf("expected 0 clients, got %d", hub.ClientCount())
+	}
+}

config.example.json

@@ -98,6 +98,13 @@
     "#bookclub",
     "#shtf"
   ],
+  "healthThresholds": {
+    "infraDegradedHours": 24,
+    "infraSilentHours": 72,
+    "nodeDegradedHours": 1,
+    "nodeSilentHours": 24,
+    "_comment": "How long (hours) before nodes show as degraded/silent. 'infra' = repeaters & rooms, 'node' = companions & others."
+  },
   "defaultRegion": "SJC",
   "mapDefaults": {
     "center": [

db.js

@@ -1,935 +0,0 @@
-const Database = require('better-sqlite3');
-const path = require('path');
-const fs = require('fs');
-
-// Ensure data directory exists
-const dbPath = process.env.DB_PATH || path.join(__dirname, 'data', 'meshcore.db');
-const dataDir = path.dirname(dbPath);
-if (!fs.existsSync(dataDir)) fs.mkdirSync(dataDir, { recursive: true });
-
-const db = new Database(dbPath);
-db.pragma('journal_mode = WAL');
-db.pragma('foreign_keys = ON');
-db.pragma('wal_autocheckpoint = 0'); // Disable auto-checkpoint — manual checkpoint on timer to avoid random event loop spikes
-
-// --- Migration: drop legacy tables (replaced by transmissions + observations in v2.3.0) ---
-// Drop paths first (has FK to packets)
-const legacyTables = ['paths', 'packets'];
-for (const t of legacyTables) {
-  const exists = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`).get(t);
-  if (exists) {
-    console.log(`[migration] Dropping legacy table: ${t}`);
-    db.exec(`DROP TABLE IF EXISTS ${t}`);
-  }
-}
-
-// --- Schema ---
-db.exec(`
-  CREATE TABLE IF NOT EXISTS nodes (
-    public_key TEXT PRIMARY KEY,
-    name TEXT,
-    role TEXT,
-    lat REAL,
-    lon REAL,
-    last_seen TEXT,
-    first_seen TEXT,
-    advert_count INTEGER DEFAULT 0,
-    battery_mv INTEGER,
-    temperature_c REAL
-  );
-
-  CREATE TABLE IF NOT EXISTS observers (
-    id TEXT PRIMARY KEY,
-    name TEXT,
-    iata TEXT,
-    last_seen TEXT,
-    first_seen TEXT,
-    packet_count INTEGER DEFAULT 0,
-    model TEXT,
-    firmware TEXT,
-    client_version TEXT,
-    radio TEXT,
-    battery_mv INTEGER,
-    uptime_secs INTEGER,
-    noise_floor INTEGER
-  );
-
-  CREATE TABLE IF NOT EXISTS inactive_nodes (
-    public_key TEXT PRIMARY KEY,
-    name TEXT,
-    role TEXT,
-    lat REAL,
-    lon REAL,
-    last_seen TEXT,
-    first_seen TEXT,
-    advert_count INTEGER DEFAULT 0,
-    battery_mv INTEGER,
-    temperature_c REAL
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_nodes_last_seen ON nodes(last_seen);
-  CREATE INDEX IF NOT EXISTS idx_observers_last_seen ON observers(last_seen);
-  CREATE INDEX IF NOT EXISTS idx_inactive_nodes_last_seen ON inactive_nodes(last_seen);
-
-  CREATE TABLE IF NOT EXISTS transmissions (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    raw_hex TEXT NOT NULL,
-    hash TEXT NOT NULL UNIQUE,
-    first_seen TEXT NOT NULL,
-    route_type INTEGER,
-    payload_type INTEGER,
-    payload_version INTEGER,
-    decoded_json TEXT,
-    created_at TEXT DEFAULT (datetime('now'))
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_transmissions_hash ON transmissions(hash);
-  CREATE INDEX IF NOT EXISTS idx_transmissions_first_seen ON transmissions(first_seen);
-  CREATE INDEX IF NOT EXISTS idx_transmissions_payload_type ON transmissions(payload_type);
-`);
-
-// --- Determine schema version ---
-let schemaVersion = db.pragma('user_version', { simple: true }) || 0;
-
-// Migrate from old schema_version table to pragma user_version
-if (schemaVersion === 0) {
-  try {
-    const row = db.prepare('SELECT version FROM schema_version ORDER BY version DESC LIMIT 1').get();
-    if (row && row.version >= 3) {
-      db.pragma(`user_version = ${row.version}`);
-      schemaVersion = row.version;
-      db.exec('DROP TABLE IF EXISTS schema_version');
-    }
-  } catch {}
-}
-
-// Detect v3 schema by column presence (handles crash between migration and version write)
-if (schemaVersion === 0) {
-  try {
-    const cols = db.pragma('table_info(observations)').map(c => c.name);
-    if (cols.includes('observer_idx') && !cols.includes('observer_id')) {
-      db.pragma('user_version = 3');
-      schemaVersion = 3;
-      console.log('[migration-v3] Detected already-migrated schema, set user_version = 3');
-    }
-  } catch {}
-}
-
-// --- v3 migration: lean observations table ---
-function needsV3Migration() {
-  if (schemaVersion >= 3) return false;
-  // Check if observations table exists with old observer_id TEXT column
-  const obsExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='observations'").get();
-  if (!obsExists) return false;
-  const cols = db.pragma('table_info(observations)').map(c => c.name);
-  return cols.includes('observer_id');
-}
-
-function runV3Migration() {
-  const startTime = Date.now();
-  console.log('[migration-v3] Starting observations table optimization...');
-
-  // a. Backup DB
-  const backupPath = dbPath + `.pre-v3-backup-${Date.now()}`;
-  try {
-    console.log(`[migration-v3] Backing up DB to ${backupPath}...`);
-    fs.copyFileSync(dbPath, backupPath);
-    console.log(`[migration-v3] Backup complete (${Date.now() - startTime}ms)`);
-  } catch (e) {
-    console.error(`[migration-v3] Backup failed, aborting migration: ${e.message}`);
-    return false;
-  }
-
-  try {
-    // b. Create lean table
-    let stepStart = Date.now();
-    db.exec(`
-      CREATE TABLE observations_v3 (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        transmission_id INTEGER NOT NULL REFERENCES transmissions(id),
-        observer_idx INTEGER,
-        direction TEXT,
-        snr REAL,
-        rssi REAL,
-        score INTEGER,
-        path_json TEXT,
-        timestamp INTEGER NOT NULL
-      )
-    `);
-    console.log(`[migration-v3] Created observations_v3 table (${Date.now() - stepStart}ms)`);
-
-    // c. Migrate data
-    stepStart = Date.now();
-    const result = db.prepare(`
-      INSERT INTO observations_v3 (id, transmission_id, observer_idx, direction, snr, rssi, score, path_json, timestamp)
-      SELECT o.id, o.transmission_id, obs.rowid, o.direction, o.snr, o.rssi, o.score, o.path_json,
-        CAST(strftime('%s', o.timestamp) AS INTEGER)
-      FROM observations o
-      LEFT JOIN observers obs ON obs.id = o.observer_id
-    `).run();
-    console.log(`[migration-v3] Migrated ${result.changes} rows (${Date.now() - stepStart}ms)`);
-
-    // d. Drop view, old table, rename
-    stepStart = Date.now();
-    db.exec('DROP VIEW IF EXISTS packets_v');
-    db.exec('DROP TABLE observations');
-    db.exec('ALTER TABLE observations_v3 RENAME TO observations');
-    console.log(`[migration-v3] Replaced observations table (${Date.now() - stepStart}ms)`);
-
-    // f. Create indexes
-    stepStart = Date.now();
-    db.exec(`
-      CREATE INDEX idx_observations_transmission_id ON observations(transmission_id);
-      CREATE INDEX idx_observations_observer_idx ON observations(observer_idx);
-      CREATE INDEX idx_observations_timestamp ON observations(timestamp);
-      CREATE UNIQUE INDEX idx_observations_dedup ON observations(transmission_id, observer_idx, COALESCE(path_json, ''));
-    `);
-    console.log(`[migration-v3] Created indexes (${Date.now() - stepStart}ms)`);
-
-    // g. Set schema version
-    
-    db.pragma('user_version = 3');
-    schemaVersion = 3;
-
-    // h. Rebuild view (done below in common code)
-
-    // i. VACUUM + checkpoint
-    stepStart = Date.now();
-    db.exec('VACUUM');
-    db.pragma('wal_checkpoint(TRUNCATE)');
-    console.log(`[migration-v3] VACUUM + checkpoint complete (${Date.now() - stepStart}ms)`);
-
-    console.log(`[migration-v3] Migration complete! Total time: ${Date.now() - startTime}ms`);
-    return true;
-  } catch (e) {
-    console.error(`[migration-v3] Migration failed: ${e.message}`);
-    console.error('[migration-v3] Restore from backup if needed: ' + dbPath + '.pre-v3-backup');
-    // Try to clean up v3 table if it exists
-    try { db.exec('DROP TABLE IF EXISTS observations_v3'); } catch {}
-    return false;
-  }
-}
-
-const isV3 = schemaVersion >= 3;
-
-if (!isV3 && needsV3Migration()) {
-  runV3Migration();
-}
-
-// If user_version < 3 and no migration happened (fresh DB or migration skipped), create old-style table
-if (schemaVersion < 3) {
-  const obsExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='observations'").get();
-  if (!obsExists) {
-    // Fresh DB — create v3 schema directly
-    db.exec(`
-      CREATE TABLE observations (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        transmission_id INTEGER NOT NULL REFERENCES transmissions(id),
-        observer_idx INTEGER,
-        direction TEXT,
-        snr REAL,
-        rssi REAL,
-        score INTEGER,
-        path_json TEXT,
-        timestamp INTEGER NOT NULL
-      );
-      CREATE INDEX idx_observations_transmission_id ON observations(transmission_id);
-      CREATE INDEX idx_observations_observer_idx ON observations(observer_idx);
-      CREATE INDEX idx_observations_timestamp ON observations(timestamp);
-      CREATE UNIQUE INDEX idx_observations_dedup ON observations(transmission_id, observer_idx, COALESCE(path_json, ''));
-    `);
-    
-    db.pragma('user_version = 3');
-    schemaVersion = 3;
-  } else {
-    // Old-style observations table exists but migration wasn't run (or failed)
-    // Ensure indexes exist for old schema
-    db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_observations_hash ON observations(hash);
-      CREATE INDEX IF NOT EXISTS idx_observations_transmission_id ON observations(transmission_id);
-      CREATE INDEX IF NOT EXISTS idx_observations_observer_id ON observations(observer_id);
-      CREATE INDEX IF NOT EXISTS idx_observations_timestamp ON observations(timestamp);
-    `);
-    // Dedup cleanup for old schema
-    try {
-      db.exec(`DROP INDEX IF EXISTS idx_observations_dedup`);
-      db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_observations_dedup ON observations(hash, observer_id, COALESCE(path_json, ''))`);
-      db.exec(`DELETE FROM observations WHERE id NOT IN (SELECT MIN(id) FROM observations GROUP BY hash, observer_id, COALESCE(path_json, ''))`);
-    } catch {}
-  }
-}
-
-// --- Create/rebuild packets_v view ---
-db.exec('DROP VIEW IF EXISTS packets_v');
-if (schemaVersion >= 3) {
-  db.exec(`
-    CREATE VIEW packets_v AS
-      SELECT o.id, t.raw_hex,
-             datetime(o.timestamp, 'unixepoch') AS timestamp,
-             obs.id AS observer_id, obs.name AS observer_name,
-             o.direction, o.snr, o.rssi, o.score, t.hash, t.route_type,
-             t.payload_type, t.payload_version, o.path_json, t.decoded_json,
-             t.created_at
-      FROM observations o
-      JOIN transmissions t ON t.id = o.transmission_id
-      LEFT JOIN observers obs ON obs.rowid = o.observer_idx
-  `);
-} else {
-  db.exec(`
-    CREATE VIEW packets_v AS
-      SELECT o.id, t.raw_hex, o.timestamp, o.observer_id, o.observer_name,
-             o.direction, o.snr, o.rssi, o.score, t.hash, t.route_type,
-             t.payload_type, t.payload_version, o.path_json, t.decoded_json,
-             t.created_at
-      FROM observations o
-      JOIN transmissions t ON t.id = o.transmission_id
-  `);
-}
-
-// --- Migrations for existing DBs ---
-const observerCols = db.pragma('table_info(observers)').map(c => c.name);
-for (const col of ['model', 'firmware', 'client_version', 'radio', 'battery_mv', 'uptime_secs', 'noise_floor']) {
-  if (!observerCols.includes(col)) {
-    const type = ['battery_mv', 'uptime_secs', 'noise_floor'].includes(col) ? 'INTEGER' : 'TEXT';
-    db.exec(`ALTER TABLE observers ADD COLUMN ${col} ${type}`);
-    console.log(`[migration] Added observers.${col}`);
-  }
-}
-
-// --- Cleanup corrupted nodes on startup ---
-// Remove nodes with obviously invalid data (short pubkeys, control chars in names, etc.)
-{
-  const cleaned = db.prepare(`
-    DELETE FROM nodes WHERE
-      length(public_key) < 16
-      OR public_key GLOB '*[^0-9a-fA-F]*'
-      OR (lat IS NOT NULL AND (lat < -90 OR lat > 90))
-      OR (lon IS NOT NULL AND (lon < -180 OR lon > 180))
-  `).run();
-  if (cleaned.changes > 0) console.log(`[cleanup] Removed ${cleaned.changes} corrupted node(s) from DB`);
-}
-
-// --- One-time migration: recalculate advert_count to count unique transmissions only ---
-{
-  db.exec(`CREATE TABLE IF NOT EXISTS _migrations (name TEXT PRIMARY KEY)`);
-  const done = db.prepare(`SELECT 1 FROM _migrations WHERE name = 'advert_count_unique_v1'`).get();
-  if (!done) {
-    const start = Date.now();
-    console.log('[migration] Recalculating advert_count (unique transmissions only)...');
-    db.prepare(`
-      UPDATE nodes SET advert_count = (
-        SELECT COUNT(*) FROM transmissions t
-        WHERE t.payload_type = 4
-          AND t.decoded_json LIKE '%' || nodes.public_key || '%'
-      )
-    `).run();
-    db.prepare(`INSERT INTO _migrations (name) VALUES ('advert_count_unique_v1')`).run();
-    console.log(`[migration] advert_count recalculated in ${Date.now() - start}ms`);
-  }
-}
-
-// --- One-time migration: add telemetry columns to nodes and inactive_nodes ---
-{
-  const done = db.prepare(`SELECT 1 FROM _migrations WHERE name = 'node_telemetry_v1'`).get();
-  if (!done) {
-    console.log('[migration] Adding telemetry columns to nodes/inactive_nodes...');
-    const nodeCols = db.pragma('table_info(nodes)').map(c => c.name);
-    if (!nodeCols.includes('battery_mv')) db.exec(`ALTER TABLE nodes ADD COLUMN battery_mv INTEGER`);
-    if (!nodeCols.includes('temperature_c')) db.exec(`ALTER TABLE nodes ADD COLUMN temperature_c REAL`);
-    const inactiveCols = db.pragma('table_info(inactive_nodes)').map(c => c.name);
-    if (!inactiveCols.includes('battery_mv')) db.exec(`ALTER TABLE inactive_nodes ADD COLUMN battery_mv INTEGER`);
-    if (!inactiveCols.includes('temperature_c')) db.exec(`ALTER TABLE inactive_nodes ADD COLUMN temperature_c REAL`);
-    db.prepare(`INSERT INTO _migrations (name) VALUES ('node_telemetry_v1')`).run();
-    console.log('[migration] node telemetry columns added');
-  }
-}
-
-// --- Prepared statements ---
-const stmts = {
-  upsertNode: db.prepare(`
-    INSERT INTO nodes (public_key, name, role, lat, lon, last_seen, first_seen)
-    VALUES (@public_key, @name, @role, @lat, @lon, @last_seen, @first_seen)
-    ON CONFLICT(public_key) DO UPDATE SET
-      name = COALESCE(@name, name),
-      role = COALESCE(@role, role),
-      lat = COALESCE(@lat, lat),
-      lon = COALESCE(@lon, lon),
-      last_seen = @last_seen
-  `),
-  incrementAdvertCount: db.prepare(`
-    UPDATE nodes SET advert_count = advert_count + 1 WHERE public_key = @public_key
-  `),
-  updateNodeTelemetry: db.prepare(`
-    UPDATE nodes SET
-      battery_mv = COALESCE(@battery_mv, battery_mv),
-      temperature_c = COALESCE(@temperature_c, temperature_c)
-    WHERE public_key = @public_key
-  `),
-  upsertObserver: db.prepare(`
-    INSERT INTO observers (id, name, iata, last_seen, first_seen, packet_count, model, firmware, client_version, radio, battery_mv, uptime_secs, noise_floor)
-    VALUES (@id, @name, @iata, @last_seen, @first_seen, 1, @model, @firmware, @client_version, @radio, @battery_mv, @uptime_secs, @noise_floor)
-    ON CONFLICT(id) DO UPDATE SET
-      name = COALESCE(@name, name),
-      iata = COALESCE(@iata, iata),
-      last_seen = @last_seen,
-      packet_count = packet_count + 1,
-      model = COALESCE(@model, model),
-      firmware = COALESCE(@firmware, firmware),
-      client_version = COALESCE(@client_version, client_version),
-      radio = COALESCE(@radio, radio),
-      battery_mv = COALESCE(@battery_mv, battery_mv),
-      uptime_secs = COALESCE(@uptime_secs, uptime_secs),
-      noise_floor = COALESCE(@noise_floor, noise_floor)
-  `),
-  updateObserverStatus: db.prepare(`
-    INSERT INTO observers (id, name, iata, last_seen, first_seen, packet_count, model, firmware, client_version, radio, battery_mv, uptime_secs, noise_floor)
-    VALUES (@id, @name, @iata, @last_seen, @first_seen, 0, @model, @firmware, @client_version, @radio, @battery_mv, @uptime_secs, @noise_floor)
-    ON CONFLICT(id) DO UPDATE SET
-      name = COALESCE(@name, name),
-      iata = COALESCE(@iata, iata),
-      last_seen = @last_seen,
-      model = COALESCE(@model, model),
-      firmware = COALESCE(@firmware, firmware),
-      client_version = COALESCE(@client_version, client_version),
-      radio = COALESCE(@radio, radio),
-      battery_mv = COALESCE(@battery_mv, battery_mv),
-      uptime_secs = COALESCE(@uptime_secs, uptime_secs),
-      noise_floor = COALESCE(@noise_floor, noise_floor)
-  `),
-  getPacket: db.prepare(`SELECT * FROM packets_v WHERE id = ?`),
-  getNode: db.prepare(`SELECT * FROM nodes WHERE public_key = ?`),
-  getRecentPacketsForNode: db.prepare(`
-    SELECT * FROM packets_v WHERE decoded_json LIKE ? OR decoded_json LIKE ? OR decoded_json LIKE ? OR decoded_json LIKE ?
-    ORDER BY timestamp DESC LIMIT 20
-  `),
-  getObservers: db.prepare(`SELECT * FROM observers ORDER BY last_seen DESC`),
-  countPackets: db.prepare(`SELECT COUNT(*) as count FROM observations`),
-  countNodes: db.prepare(`SELECT COUNT(*) as count FROM nodes`),
-  countActiveNodes: db.prepare(`SELECT COUNT(*) as count FROM nodes WHERE last_seen > ?`),
-  countActiveNodesByRole: db.prepare(`SELECT COUNT(*) as count FROM nodes WHERE role = ? AND last_seen > ?`),
-  countObservers: db.prepare(`SELECT COUNT(*) as count FROM observers`),
-  countRecentPackets: schemaVersion >= 3
-    ? db.prepare(`SELECT COUNT(*) as count FROM observations WHERE timestamp > CAST(strftime('%s', ?) AS INTEGER)`)
-    : db.prepare(`SELECT COUNT(*) as count FROM observations WHERE timestamp > ?`),
-  getTransmissionByHash: db.prepare(`SELECT id, first_seen FROM transmissions WHERE hash = ?`),
-  insertTransmission: db.prepare(`
-    INSERT INTO transmissions (raw_hex, hash, first_seen, route_type, payload_type, payload_version, decoded_json)
-    VALUES (@raw_hex, @hash, @first_seen, @route_type, @payload_type, @payload_version, @decoded_json)
-  `),
-  updateTransmissionFirstSeen: db.prepare(`UPDATE transmissions SET first_seen = @first_seen WHERE id = @id`),
-  insertObservation: schemaVersion >= 3
-    ? db.prepare(`
-        INSERT OR IGNORE INTO observations (transmission_id, observer_idx, direction, snr, rssi, score, path_json, timestamp)
-        VALUES (@transmission_id, @observer_idx, @direction, @snr, @rssi, @score, @path_json, @timestamp)
-      `)
-    : db.prepare(`
-        INSERT OR IGNORE INTO observations (transmission_id, hash, observer_id, observer_name, direction, snr, rssi, score, path_json, timestamp)
-        VALUES (@transmission_id, @hash, @observer_id, @observer_name, @direction, @snr, @rssi, @score, @path_json, @timestamp)
-      `),
-  getObserverRowid: db.prepare(`SELECT rowid FROM observers WHERE id = ?`),
-};
-
-// --- In-memory observer map (observer_id text → rowid integer) ---
-const observerIdToRowid = new Map();
-if (schemaVersion >= 3) {
-  const rows = db.prepare('SELECT id, rowid FROM observers').all();
-  for (const r of rows) observerIdToRowid.set(r.id, r.rowid);
-}
-
-// --- In-memory dedup set for v3 ---
-const dedupSet = new Map(); // key → timestamp (for cleanup)
-const DEDUP_TTL_MS = 5 * 60 * 1000; // 5 minutes
-
-function cleanupDedupSet() {
-  const cutoff = Date.now() - DEDUP_TTL_MS;
-  for (const [key, ts] of dedupSet) {
-    if (ts < cutoff) dedupSet.delete(key);
-  }
-}
-
-// Periodic cleanup every 60s
-setInterval(cleanupDedupSet, 60000).unref();
-
-function resolveObserverIdx(observerId) {
-  if (!observerId) return null;
-  let rowid = observerIdToRowid.get(observerId);
-  if (rowid !== undefined) return rowid;
-  // Try DB lookup (observer may have been inserted elsewhere)
-  const row = stmts.getObserverRowid.get(observerId);
-  if (row) {
-    observerIdToRowid.set(observerId, row.rowid);
-    return row.rowid;
-  }
-  return null;
-}
-
-// --- Helper functions ---
-
-function insertTransmission(data) {
-  const hash = data.hash;
-  if (!hash) return null;
-
-  const timestamp = data.timestamp || new Date().toISOString();
-  let transmissionId;
-
-  let isNew = false;
-  const existing = stmts.getTransmissionByHash.get(hash);
-  if (existing) {
-    transmissionId = existing.id;
-    if (timestamp < existing.first_seen) {
-      stmts.updateTransmissionFirstSeen.run({ id: transmissionId, first_seen: timestamp });
-    }
-  } else {
-    isNew = true;
-    const result = stmts.insertTransmission.run({
-      raw_hex: data.raw_hex || '',
-      hash,
-      first_seen: timestamp,
-      route_type: data.route_type ?? null,
-      payload_type: data.payload_type ?? null,
-      payload_version: data.payload_version ?? null,
-      decoded_json: data.decoded_json || null,
-    });
-    transmissionId = result.lastInsertRowid;
-  }
-
-  let obsResult;
-  if (schemaVersion >= 3) {
-    const observerIdx = resolveObserverIdx(data.observer_id);
-    const epochTs = typeof timestamp === 'number' ? timestamp : Math.floor(new Date(timestamp).getTime() / 1000);
-
-    // In-memory dedup check
-    const dedupKey = `${transmissionId}|${observerIdx}|${data.path_json || ''}`;
-    if (dedupSet.has(dedupKey)) {
-      return { transmissionId, observationId: 0, isNew };
-    }
-
-    obsResult = stmts.insertObservation.run({
-      transmission_id: transmissionId,
-      observer_idx: observerIdx,
-      direction: data.direction || null,
-      snr: data.snr ?? null,
-      rssi: data.rssi ?? null,
-      score: data.score ?? null,
-      path_json: data.path_json || null,
-      timestamp: epochTs,
-    });
-    dedupSet.set(dedupKey, Date.now());
-  } else {
-    obsResult = stmts.insertObservation.run({
-      transmission_id: transmissionId,
-      hash,
-      observer_id: data.observer_id || null,
-      observer_name: data.observer_name || null,
-      direction: data.direction || null,
-      snr: data.snr ?? null,
-      rssi: data.rssi ?? null,
-      score: data.score ?? null,
-      path_json: data.path_json || null,
-      timestamp,
-    });
-  }
-
-  return { transmissionId, observationId: obsResult.lastInsertRowid, isNew };
-}
-
-function incrementAdvertCount(publicKey) {
-  stmts.incrementAdvertCount.run({ public_key: publicKey });
-}
-
-function updateNodeTelemetry(data) {
-  stmts.updateNodeTelemetry.run({
-    public_key: data.public_key,
-    battery_mv: data.battery_mv ?? null,
-    temperature_c: data.temperature_c ?? null,
-  });
-}
-
-function upsertNode(data) {
-  const now = new Date().toISOString();
-  stmts.upsertNode.run({
-    public_key: data.public_key,
-    name: data.name || null,
-    role: data.role || null,
-    lat: data.lat ?? null,
-    lon: data.lon ?? null,
-    last_seen: data.last_seen || now,
-    first_seen: data.first_seen || now,
-  });
-}
-
-function upsertObserver(data) {
-  const now = new Date().toISOString();
-  stmts.upsertObserver.run({
-    id: data.id,
-    name: data.name || null,
-    iata: data.iata || null,
-    last_seen: data.last_seen || now,
-    first_seen: data.first_seen || now,
-    model: data.model || null,
-    firmware: data.firmware || null,
-    client_version: data.client_version || null,
-    radio: data.radio || null,
-    battery_mv: data.battery_mv || null,
-    uptime_secs: data.uptime_secs || null,
-    noise_floor: data.noise_floor || null,
-  });
-  // Update in-memory map for v3
-  if (schemaVersion >= 3 && !observerIdToRowid.has(data.id)) {
-    const row = stmts.getObserverRowid.get(data.id);
-    if (row) observerIdToRowid.set(data.id, row.rowid);
-  }
-}
-
-function updateObserverStatus(data) {
-  const now = new Date().toISOString();
-  stmts.updateObserverStatus.run({
-    id: data.id,
-    name: data.name || null,
-    iata: data.iata || null,
-    last_seen: data.last_seen || now,
-    first_seen: data.first_seen || now,
-    model: data.model || null,
-    firmware: data.firmware || null,
-    client_version: data.client_version || null,
-    radio: data.radio || null,
-    battery_mv: data.battery_mv || null,
-    uptime_secs: data.uptime_secs || null,
-    noise_floor: data.noise_floor || null,
-  });
-}
-
-function getPackets({ limit = 50, offset = 0, type, route, hash, since } = {}) {
-  let where = [];
-  let params = {};
-  if (type !== undefined) { where.push('payload_type = @type'); params.type = type; }
-  if (route !== undefined) { where.push('route_type = @route'); params.route = route; }
-  if (hash) { where.push('hash = @hash'); params.hash = hash; }
-  if (since) { where.push('timestamp > @since'); params.since = since; }
-  const clause = where.length ? 'WHERE ' + where.join(' AND ') : '';
-  const rows = db.prepare(`SELECT * FROM packets_v ${clause} ORDER BY timestamp DESC LIMIT @limit OFFSET @offset`).all({ ...params, limit, offset });
-  const total = db.prepare(`SELECT COUNT(*) as count FROM packets_v ${clause}`).get(params).count;
-  return { rows, total };
-}
-
-function getTransmission(id) {
-  try {
-    return db.prepare('SELECT * FROM transmissions WHERE id = ?').get(id) || null;
-  } catch { return null; }
-}
-
-function getPacket(id) {
-  const packet = stmts.getPacket.get(id);
-  if (!packet) return null;
-  return packet;
-}
-
-function getNodes({ limit = 50, offset = 0, sortBy = 'last_seen' } = {}) {
-  const allowed = ['last_seen', 'name', 'advert_count', 'first_seen'];
-  const col = allowed.includes(sortBy) ? sortBy : 'last_seen';
-  const dir = col === 'name' ? 'ASC' : 'DESC';
-  const rows = db.prepare(`SELECT * FROM nodes ORDER BY ${col} ${dir} LIMIT ? OFFSET ?`).all(limit, offset);
-  const total = stmts.countNodes.get().count;
-  return { rows, total };
-}
-
-function getNode(pubkey) {
-  const node = stmts.getNode.get(pubkey);
-  if (!node) return null;
-  // Match by: pubkey anywhere, name in sender/text fields, name as text prefix ("Name: msg")
-  const namePattern = node.name ? `%${node.name}%` : `%${pubkey}%`;
-  const textPrefix = node.name ? `%"text":"${node.name}:%` : `%${pubkey}%`;
-  node.recentPackets = stmts.getRecentPacketsForNode.all(
-    `%${pubkey}%`,
-    namePattern,
-    textPrefix,
-    `%"sender":"${node.name || pubkey}"%`
-  );
-  return node;
-}
-
-function getObservers() {
-  return stmts.getObservers.all();
-}
-
-function getStats() {
-  const oneHourAgo = new Date(Date.now() - 3600000).toISOString();
-  const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 3600000).toISOString();
-  // Try to get transmission count from normalized schema
-  let totalTransmissions = null;
-  try {
-    totalTransmissions = db.prepare('SELECT COUNT(*) as count FROM transmissions').get().count;
-  } catch {}
-  return {
-    totalPackets: totalTransmissions || stmts.countPackets.get().count,
-    totalTransmissions,
-    totalObservations: stmts.countPackets.get().count,
-    totalNodes: stmts.countActiveNodes.get(sevenDaysAgo).count,
-    totalNodesAllTime: stmts.countNodes.get().count,
-    totalObservers: stmts.countObservers.get().count,
-    packetsLastHour: stmts.countRecentPackets.get(oneHourAgo).count,
-    packetsLast24h: stmts.countRecentPackets.get(new Date(Date.now() - 24 * 3600000).toISOString()).count,
-  };
-}
-
-// --- Run directly ---
-if (require.main === module) {
-  console.log('Stats:', getStats());
-}
-
-// Remove phantom nodes created by autoLearnHopNodes before this fix.
-// Real MeshCore pubkeys are 32 bytes (64 hex chars). Phantom nodes have only
-// the hop prefix as their public_key (typically 4-8 hex chars).
-// Threshold: public_key <= 16 hex chars (8 bytes) is too short to be real.
-function removePhantomNodes() {
-  const result = db.prepare(`DELETE FROM nodes WHERE LENGTH(public_key) <= 16`).run();
-  if (result.changes > 0) {
-    console.log(`[cleanup] Removed ${result.changes} phantom node(s) with short public_key prefixes`);
-  }
-  return result.changes;
-}
-
-function searchNodes(query, limit = 10) {
-  return db.prepare(`
-    SELECT * FROM nodes
-    WHERE name LIKE @q OR public_key LIKE @prefix
-    ORDER BY last_seen DESC
-    LIMIT @limit
-  `).all({ q: `%${query}%`, prefix: `${query}%`, limit });
-}
-
-function getNodeHealth(pubkey) {
-  const node = stmts.getNode.get(pubkey);
-  if (!node) return null;
-
-  const todayStart = new Date();
-  todayStart.setUTCHours(0, 0, 0, 0);
-  const todayISO = todayStart.toISOString();
-
-  const keyPattern = `%${pubkey}%`;
-  // Also match by node name in decoded_json (channel messages have sender name, not pubkey)
-  const namePattern = node.name ? `%${node.name.replace(/[%_]/g, '')}%` : null;
-  const whereClause = namePattern
-    ? `(decoded_json LIKE @keyPattern OR decoded_json LIKE @namePattern)`
-    : `decoded_json LIKE @keyPattern`;
-  const params = namePattern ? { keyPattern, namePattern } : { keyPattern };
-
-  // Observers that heard this node
-  const observers = db.prepare(`
-    SELECT observer_id, observer_name,
-      AVG(snr) as avgSnr, AVG(rssi) as avgRssi, COUNT(*) as packetCount
-    FROM packets_v
-    WHERE ${whereClause} AND observer_id IS NOT NULL
-    GROUP BY observer_id
-    ORDER BY packetCount DESC
-  `).all(params);
-
-  // Stats
-  const packetsToday = db.prepare(`
-    SELECT COUNT(*) as count FROM packets_v WHERE ${whereClause} AND timestamp > @since
-  `).get({ ...params, since: todayISO }).count;
-
-  const avgStats = db.prepare(`
-    SELECT AVG(snr) as avgSnr FROM packets_v WHERE ${whereClause}
-  `).get(params);
-
-  const lastHeard = db.prepare(`
-    SELECT MAX(timestamp) as lastHeard FROM packets_v WHERE ${whereClause}
-  `).get(params).lastHeard;
-
-  // Avg hops from path_json
-  const pathRows = db.prepare(`
-    SELECT path_json FROM packets_v WHERE ${whereClause} AND path_json IS NOT NULL
-  `).all(params);
-
-  let totalHops = 0, hopCount = 0;
-  for (const row of pathRows) {
-    try {
-      const hops = JSON.parse(row.path_json);
-      if (Array.isArray(hops)) { totalHops += hops.length; hopCount++; }
-    } catch {}
-  }
-  const avgHops = hopCount > 0 ? Math.round(totalHops / hopCount) : 0;
-
-  const totalPackets = db.prepare(`
-    SELECT COUNT(*) as count FROM packets_v WHERE ${whereClause}
-  `).get(params).count;
-
-  // Recent 10 packets
-  const recentPackets = db.prepare(`
-    SELECT * FROM packets_v WHERE ${whereClause} ORDER BY timestamp DESC LIMIT 10
-  `).all(params);
-
-  return {
-    node,
-    observers,
-    stats: { totalPackets, packetsToday, avgSnr: avgStats.avgSnr, avgHops, lastHeard },
-    recentPackets,
-  };
-}
-
-function getNodeAnalytics(pubkey, days) {
-  const node = stmts.getNode.get(pubkey);
-  if (!node) return null;
-
-  const now = new Date();
-  const from = new Date(now.getTime() - days * 86400000);
-  const fromISO = from.toISOString();
-  const toISO = now.toISOString();
-
-  const keyPattern = `%${pubkey}%`;
-  const namePattern = node.name ? `%${node.name.replace(/[%_]/g, '')}%` : null;
-  const whereClause = namePattern
-    ? `(decoded_json LIKE @keyPattern OR decoded_json LIKE @namePattern)`
-    : `decoded_json LIKE @keyPattern`;
-  const timeWhere = `${whereClause} AND timestamp > @fromISO`;
-  const params = namePattern ? { keyPattern, namePattern, fromISO } : { keyPattern, fromISO };
-
-  // Activity timeline
-  const activityTimeline = db.prepare(`
-    SELECT strftime('%Y-%m-%dT%H:00:00Z', timestamp) as bucket, COUNT(*) as count
-    FROM packets_v WHERE ${timeWhere} GROUP BY bucket ORDER BY bucket
-  `).all(params);
-
-  // SNR trend
-  const snrTrend = db.prepare(`
-    SELECT timestamp, snr, rssi, observer_id, observer_name
-    FROM packets_v WHERE ${timeWhere} AND snr IS NOT NULL ORDER BY timestamp
-  `).all(params);
-
-  // Packet type breakdown
-  const packetTypeBreakdown = db.prepare(`
-    SELECT payload_type, COUNT(*) as count FROM packets_v WHERE ${timeWhere} GROUP BY payload_type
-  `).all(params);
-
-  // Observer coverage
-  const observerCoverage = db.prepare(`
-    SELECT observer_id, observer_name, COUNT(*) as packetCount,
-      AVG(snr) as avgSnr, AVG(rssi) as avgRssi, MIN(timestamp) as firstSeen, MAX(timestamp) as lastSeen
-    FROM packets_v WHERE ${timeWhere} AND observer_id IS NOT NULL
-    GROUP BY observer_id ORDER BY packetCount DESC
-  `).all(params);
-
-  // Hop distribution
-  const pathRows = db.prepare(`
-    SELECT path_json FROM packets_v WHERE ${timeWhere} AND path_json IS NOT NULL
-  `).all(params);
-
-  const hopCounts = {};
-  let totalWithPath = 0, relayedCount = 0;
-  for (const row of pathRows) {
-    try {
-      const hops = JSON.parse(row.path_json);
-      if (Array.isArray(hops)) {
-        const h = hops.length;
-        const key = h >= 4 ? '4+' : String(h);
-        hopCounts[key] = (hopCounts[key] || 0) + 1;
-        totalWithPath++;
-        if (h > 1) relayedCount++;
-      }
-    } catch {}
-  }
-  const hopDistribution = Object.entries(hopCounts).map(([hops, count]) => ({ hops, count }))
-    .sort((a, b) => a.hops.localeCompare(b.hops, undefined, { numeric: true }));
-
-  // Peer interactions from decoded_json
-  const decodedRows = db.prepare(`
-    SELECT decoded_json, timestamp FROM packets_v WHERE ${timeWhere} AND decoded_json IS NOT NULL
-  `).all(params);
-
-  const peerMap = {};
-  for (const row of decodedRows) {
-    try {
-      const d = JSON.parse(row.decoded_json);
-      // Look for sender/recipient pubkeys that aren't this node
-      const candidates = [];
-      if (d.sender_key && d.sender_key !== pubkey) candidates.push({ key: d.sender_key, name: d.sender_name || d.sender_short_name });
-      if (d.recipient_key && d.recipient_key !== pubkey) candidates.push({ key: d.recipient_key, name: d.recipient_name || d.recipient_short_name });
-      if (d.pubkey && d.pubkey !== pubkey) candidates.push({ key: d.pubkey, name: d.name });
-      for (const c of candidates) {
-        if (!c.key) continue;
-        if (!peerMap[c.key]) peerMap[c.key] = { peer_key: c.key, peer_name: c.name || c.key.slice(0, 12), messageCount: 0, lastContact: row.timestamp };
-        peerMap[c.key].messageCount++;
-        if (row.timestamp > peerMap[c.key].lastContact) peerMap[c.key].lastContact = row.timestamp;
-      }
-    } catch {}
-  }
-  const peerInteractions = Object.values(peerMap).sort((a, b) => b.messageCount - a.messageCount).slice(0, 20);
-
-  // Uptime heatmap
-  const uptimeHeatmap = db.prepare(`
-    SELECT CAST(strftime('%w', timestamp) AS INTEGER) as dayOfWeek,
-      CAST(strftime('%H', timestamp) AS INTEGER) as hour, COUNT(*) as count
-    FROM packets_v WHERE ${timeWhere} GROUP BY dayOfWeek, hour
-  `).all(params);
-
-  // Computed stats
-  const totalPackets = db.prepare(`SELECT COUNT(*) as count FROM packets_v WHERE ${timeWhere}`).get(params).count;
-  const uniqueObservers = observerCoverage.length;
-  const uniquePeers = peerInteractions.length;
-  const avgPacketsPerDay = days > 0 ? Math.round(totalPackets / days * 10) / 10 : totalPackets;
-
-  // Availability: distinct hours with packets / total hours
-  const distinctHours = activityTimeline.length;
-  const totalHours = days * 24;
-  const availabilityPct = totalHours > 0 ? Math.round(distinctHours / totalHours * 1000) / 10 : 0;
-
-  // Longest silence
-  const timestamps = db.prepare(`
-    SELECT timestamp FROM packets_v WHERE ${timeWhere} ORDER BY timestamp
-  `).all(params).map(r => new Date(r.timestamp).getTime());
-
-  let longestSilenceMs = 0, longestSilenceStart = null;
-  for (let i = 1; i < timestamps.length; i++) {
-    const gap = timestamps[i] - timestamps[i - 1];
-    if (gap > longestSilenceMs) { longestSilenceMs = gap; longestSilenceStart = new Date(timestamps[i - 1]).toISOString(); }
-  }
-
-  // Signal grade
-  const snrValues = snrTrend.map(r => r.snr);
-  const snrMean = snrValues.length > 0 ? snrValues.reduce((a, b) => a + b, 0) / snrValues.length : 0;
-  const snrStdDev = snrValues.length > 1 ? Math.sqrt(snrValues.reduce((s, v) => s + (v - snrMean) ** 2, 0) / snrValues.length) : 0;
-  let signalGrade = 'D';
-  if (snrMean > 15 && snrStdDev < 2) signalGrade = 'A';
-  else if (snrMean > 15) signalGrade = 'A-';
-  else if (snrMean > 12 && snrStdDev < 3) signalGrade = 'B+';
-  else if (snrMean > 8) signalGrade = 'B';
-  else if (snrMean > 3) signalGrade = 'C';
-
-  const relayPct = totalWithPath > 0 ? Math.round(relayedCount / totalWithPath * 1000) / 10 : 0;
-
-  return {
-    node,
-    timeRange: { from: fromISO, to: toISO, days },
-    activityTimeline,
-    snrTrend,
-    packetTypeBreakdown,
-    observerCoverage,
-    hopDistribution,
-    peerInteractions,
-    uptimeHeatmap,
-    computedStats: {
-      availabilityPct, longestSilenceMs, longestSilenceStart, signalGrade,
-      snrMean: Math.round(snrMean * 10) / 10, snrStdDev: Math.round(snrStdDev * 10) / 10,
-      relayPct, totalPackets, uniqueObservers, uniquePeers, avgPacketsPerDay
-    }
-  };
-}
-
-// Move stale nodes to inactive_nodes table based on retention.nodeDays config.
-function moveStaleNodes(nodeDays) {
-  if (!nodeDays || nodeDays <= 0) return 0;
-  const cutoff = new Date(Date.now() - nodeDays * 24 * 3600000).toISOString();
-  const move = db.transaction(() => {
-    db.prepare(`INSERT OR REPLACE INTO inactive_nodes SELECT * FROM nodes WHERE last_seen < ?`).run(cutoff);
-    const result = db.prepare(`DELETE FROM nodes WHERE last_seen < ?`).run(cutoff);
-    return result.changes;
-  });
-  const moved = move();
-  if (moved > 0) {
-    console.log(`[retention] Moved ${moved} node(s) to inactive_nodes (not seen in ${nodeDays} days)`);
-  }
-  return moved;
-}
-
-module.exports = { db, schemaVersion, observerIdToRowid, resolveObserverIdx, insertTransmission, upsertNode, incrementAdvertCount, updateNodeTelemetry, upsertObserver, updateObserverStatus, getPackets, getPacket, getTransmission, getNodes, getNode, getObservers, getStats, searchNodes, getNodeHealth, getNodeAnalytics, removePhantomNodes, moveStaleNodes };

decoder.js

@@ -1,429 +0,0 @@
-/**
- * MeshCore Packet Decoder
- * Custom implementation — does NOT use meshcore-decoder library (known path_length bug).
- *
- * Packet layout:
- *   [header(1)] [pathLength(1)] [transportCodes?] [path hops] [payload...]
- *
- * Header byte (LSB first):
- *   bits 1-0: routeType (0=TRANSPORT_FLOOD, 1=FLOOD, 2=DIRECT, 3=TRANSPORT_DIRECT)
- *   bits 5-2: payloadType
- *   bits 7-6: payloadVersion
- *
- * Path length byte:
- *   bits 5-0: hash_count (number of hops, 0-63)
- *   bits 7-6: (value >> 6) + 1 = hash_size (1-4 bytes per hop hash)
- */
-
-'use strict';
-
-// --- Constants ---
-
-const ROUTE_TYPES = {
-  0: 'TRANSPORT_FLOOD',
-  1: 'FLOOD',
-  2: 'DIRECT',
-  3: 'TRANSPORT_DIRECT',
-};
-
-const PAYLOAD_TYPES = {
-  0x00: 'REQ',
-  0x01: 'RESPONSE',
-  0x02: 'TXT_MSG',
-  0x03: 'ACK',
-  0x04: 'ADVERT',
-  0x05: 'GRP_TXT',
-  0x06: 'GRP_DATA',
-  0x07: 'ANON_REQ',
-  0x08: 'PATH',
-  0x09: 'TRACE',
-  0x0A: 'MULTIPART',
-  0x0B: 'CONTROL',
-  0x0F: 'RAW_CUSTOM',
-};
-
-// Route types that carry transport codes (nextHop + lastHop, 2 bytes each)
-const TRANSPORT_ROUTES = new Set([0, 3]); // TRANSPORT_FLOOD, TRANSPORT_DIRECT
-
-// --- Header parsing ---
-
-function decodeHeader(byte) {
-  return {
-    routeType: byte & 0x03,
-    routeTypeName: ROUTE_TYPES[byte & 0x03] || 'UNKNOWN',
-    payloadType: (byte >> 2) & 0x0F,
-    payloadTypeName: PAYLOAD_TYPES[(byte >> 2) & 0x0F] || 'UNKNOWN',
-    payloadVersion: (byte >> 6) & 0x03,
-  };
-}
-
-// --- Path parsing ---
-
-function decodePath(pathByte, buf, offset) {
-  const hashSize = (pathByte >> 6) + 1;   // 1-4 bytes per hash
-  const hashCount = pathByte & 0x3F;       // 0-63 hops
-  const available = buf.length - offset;
-  // Cap to what the buffer actually holds — corrupt packets may claim more hops than exist
-  const safeCount = Math.min(hashCount, Math.floor(available / hashSize));
-  const totalBytes = safeCount * hashSize;
-  const hops = [];
-
-  for (let i = 0; i < safeCount; i++) {
-    hops.push(buf.subarray(offset + i * hashSize, offset + i * hashSize + hashSize).toString('hex').toUpperCase());
-  }
-
-  return {
-    hashSize,
-    hashCount: safeCount,
-    hops,
-    bytesConsumed: totalBytes,
-    truncated: safeCount < hashCount,
-  };
-}
-
-// --- Payload decoders ---
-
-/** REQ / RESPONSE / TXT_MSG: dest(1) + src(1) + MAC(2) + encrypted (PAYLOAD_VER_1, per Mesh.cpp) */
-function decodeEncryptedPayload(buf) {
-  if (buf.length < 4) return { error: 'too short', raw: buf.toString('hex') };
-  return {
-    destHash: buf.subarray(0, 1).toString('hex'),
-    srcHash: buf.subarray(1, 2).toString('hex'),
-    mac: buf.subarray(2, 4).toString('hex'),
-    encryptedData: buf.subarray(4).toString('hex'),
-  };
-}
-
-/** ACK: dest(1) + src(1) + ack_hash(4) (per Mesh.cpp) */
-function decodeAck(buf) {
-  if (buf.length < 6) return { error: 'too short', raw: buf.toString('hex') };
-  return {
-    destHash: buf.subarray(0, 1).toString('hex'),
-    srcHash: buf.subarray(1, 2).toString('hex'),
-    extraHash: buf.subarray(2, 6).toString('hex'),
-  };
-}
-
-/** ADVERT: pubkey(32) + timestamp(4 LE) + signature(64) + appdata */
-function decodeAdvert(buf) {
-  if (buf.length < 100) return { error: 'too short for advert', raw: buf.toString('hex') };
-  const pubKey = buf.subarray(0, 32).toString('hex');
-  const timestamp = buf.readUInt32LE(32);
-  const signature = buf.subarray(36, 100).toString('hex');
-  const appdata = buf.subarray(100);
-
-  const result = { pubKey, timestamp, timestampISO: new Date(timestamp * 1000).toISOString(), signature };
-
-  if (appdata.length > 0) {
-    const flags = appdata[0];
-    const advType = flags & 0x0F; // lower nibble is enum type, not individual bits
-    result.flags = {
-      raw: flags,
-      type: advType,
-      chat: advType === 1,
-      repeater: advType === 2,
-      room: advType === 3,
-      sensor: advType === 4,
-      hasLocation: !!(flags & 0x10),
-      hasName: !!(flags & 0x80),
-    };
-
-    let off = 1;
-    if (result.flags.hasLocation && appdata.length >= off + 8) {
-      result.lat = appdata.readInt32LE(off) / 1e6;
-      result.lon = appdata.readInt32LE(off + 4) / 1e6;
-      off += 8;
-    }
-    if (result.flags.hasName) {
-      // Find null terminator to separate name from trailing telemetry bytes
-      let nameEnd = appdata.length;
-      for (let i = off; i < appdata.length; i++) {
-        if (appdata[i] === 0x00) { nameEnd = i; break; }
-      }
-      let name = appdata.subarray(off, nameEnd).toString('utf8');
-      name = name.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '');
-      result.name = name;
-      off = nameEnd;
-      // Skip null terminator(s)
-      while (off < appdata.length && appdata[off] === 0x00) off++;
-    }
-
-    // Telemetry bytes after name: battery_mv(2 LE) + temperature_c(2 LE, signed, /100)
-    // Only sensor nodes (advType=4) carry telemetry bytes.
-    if (result.flags.sensor && off + 4 <= appdata.length) {
-      const batteryMv = appdata.readUInt16LE(off);
-      const tempRaw = appdata.readInt16LE(off + 2);
-      const tempC = tempRaw / 100.0;
-      if (batteryMv > 0 && batteryMv <= 10000) {
-        result.battery_mv = batteryMv;
-      }
-      // Raw int16 / 100 → °C; accept -50°C to 100°C (raw: -5000 to 10000)
-      if (tempRaw >= -5000 && tempRaw <= 10000) {
-        result.temperature_c = tempC;
-      }
-    }
-  }
-
-  return result;
-}
-
-/**
- * Check if text contains non-printable characters (binary garbage).
- * Returns true if more than 2 non-printable chars found (excluding \n, \t).
- */
-function hasNonPrintableChars(text) {
-  if (!text) return false;
-  let count = 0;
-  for (let i = 0; i < text.length; i++) {
-    const code = text.charCodeAt(i);
-    if (code < 0x20 && code !== 0x0A && code !== 0x09) count++;
-    else if (code === 0xFFFD) count++;  // Unicode replacement char (invalid UTF-8)
-    if (count > 2) return true;
-  }
-  return false;
-}
-
-/** GRP_TXT: channel_hash(1) + MAC(2) + encrypted */
-function decodeGrpTxt(buf, channelKeys) {
-  if (buf.length < 3) return { error: 'too short', raw: buf.toString('hex') };
-  const channelHash = buf[0];
-  const channelHashHex = channelHash.toString(16).padStart(2, '0').toUpperCase();
-  const mac = buf.subarray(1, 3).toString('hex');
-  const encryptedData = buf.subarray(3).toString('hex');
-
-  const hasKeys = channelKeys && Object.keys(channelKeys).length > 0;
-
-  // Try decryption with known channel keys
-  if (hasKeys && encryptedData.length >= 10) {
-    try {
-      const { ChannelCrypto } = require('@michaelhart/meshcore-decoder/dist/crypto/channel-crypto');
-      for (const [name, key] of Object.entries(channelKeys)) {
-        const result = ChannelCrypto.decryptGroupTextMessage(encryptedData, mac, key);
-        if (result.success && result.data) {
-          const text = result.data.sender && result.data.message
-            ? `${result.data.sender}: ${result.data.message}`
-            : result.data.message || '';
-          // Validate decrypted text is printable UTF-8 (not binary garbage)
-          if (hasNonPrintableChars(text)) {
-            return {
-              type: 'GRP_TXT', channelHash, channelHashHex, channel: name,
-              decryptionStatus: 'decryption_failed', text: null, mac, encryptedData,
-            };
-          }
-          return {
-            type: 'CHAN',
-            channel: name,
-            channelHash,
-            channelHashHex,
-            decryptionStatus: 'decrypted',
-            sender: result.data.sender || null,
-            text,
-            sender_timestamp: result.data.timestamp,
-            flags: result.data.flags,
-          };
-        }
-      }
-    } catch (e) { /* decryption failed, fall through */ }
-
-    return { type: 'GRP_TXT', channelHash, channelHashHex, decryptionStatus: 'decryption_failed', mac, encryptedData };
-  }
-
-  return { type: 'GRP_TXT', channelHash, channelHashHex, decryptionStatus: 'no_key', mac, encryptedData };
-}
-
-/** ANON_REQ: dest(6) + ephemeral_pubkey(32) + MAC(4) + encrypted */
-function decodeAnonReq(buf) {
-  if (buf.length < 35) return { error: 'too short', raw: buf.toString('hex') };
-  return {
-    destHash: buf.subarray(0, 1).toString('hex'),
-    ephemeralPubKey: buf.subarray(1, 33).toString('hex'),
-    mac: buf.subarray(33, 35).toString('hex'),
-    encryptedData: buf.subarray(35).toString('hex'),
-  };
-}
-
-/** PATH: dest(6) + src(6) + MAC(4) + path_data */
-function decodePath_payload(buf) {
-  if (buf.length < 4) return { error: 'too short', raw: buf.toString('hex') };
-  return {
-    destHash: buf.subarray(0, 1).toString('hex'),
-    srcHash: buf.subarray(1, 2).toString('hex'),
-    mac: buf.subarray(2, 4).toString('hex'),
-    pathData: buf.subarray(4).toString('hex'),
-  };
-}
-
-/** TRACE: flags(1) + tag(4) + dest(6) + src(1) */
-function decodeTrace(buf) {
-  if (buf.length < 12) return { error: 'too short', raw: buf.toString('hex') };
-  return {
-    flags: buf[0],
-    tag: buf.readUInt32LE(1),
-    destHash: buf.subarray(5, 11).toString('hex'),
-    srcHash: buf.subarray(11, 12).toString('hex'),
-  };
-}
-
-// Dispatcher
-function decodePayload(type, buf, channelKeys) {
-  switch (type) {
-    case 0x00: return { type: 'REQ', ...decodeEncryptedPayload(buf) };
-    case 0x01: return { type: 'RESPONSE', ...decodeEncryptedPayload(buf) };
-    case 0x02: return { type: 'TXT_MSG', ...decodeEncryptedPayload(buf) };
-    case 0x03: return { type: 'ACK', ...decodeAck(buf) };
-    case 0x04: return { type: 'ADVERT', ...decodeAdvert(buf) };
-    case 0x05: return { type: 'GRP_TXT', ...decodeGrpTxt(buf, channelKeys) };
-    case 0x07: return { type: 'ANON_REQ', ...decodeAnonReq(buf) };
-    case 0x08: return { type: 'PATH', ...decodePath_payload(buf) };
-    case 0x09: return { type: 'TRACE', ...decodeTrace(buf) };
-    default:   return { type: 'UNKNOWN', raw: buf.toString('hex') };
-  }
-}
-
-// --- Main decoder ---
-
-function decodePacket(hexString, channelKeys) {
-  const hex = hexString.replace(/\s+/g, '');
-  const buf = Buffer.from(hex, 'hex');
-
-  if (buf.length < 2) throw new Error('Packet too short (need at least header + pathLength)');
-
-  const header = decodeHeader(buf[0]);
-  const pathByte = buf[1];
-  let offset = 2;
-
-  // Transport codes for TRANSPORT_FLOOD / TRANSPORT_DIRECT
-  let transportCodes = null;
-  if (TRANSPORT_ROUTES.has(header.routeType)) {
-    if (buf.length < offset + 4) throw new Error('Packet too short for transport codes');
-    transportCodes = {
-      nextHop: buf.subarray(offset, offset + 2).toString('hex').toUpperCase(),
-      lastHop: buf.subarray(offset + 2, offset + 4).toString('hex').toUpperCase(),
-    };
-    offset += 4;
-  }
-
-  // Path
-  const path = decodePath(pathByte, buf, offset);
-  offset += path.bytesConsumed;
-
-  // Payload (rest of buffer)
-  const payloadBuf = buf.subarray(offset);
-  const payload = decodePayload(header.payloadType, payloadBuf, channelKeys);
-
-  return {
-    header: {
-      routeType: header.routeType,
-      routeTypeName: header.routeTypeName,
-      payloadType: header.payloadType,
-      payloadTypeName: header.payloadTypeName,
-      payloadVersion: header.payloadVersion,
-    },
-    transportCodes,
-    path: {
-      hashSize: path.hashSize,
-      hashCount: path.hashCount,
-      hops: path.hops,
-      truncated: path.truncated,
-    },
-    payload,
-    raw: hex.toUpperCase(),
-  };
-}
-
-// --- ADVERT validation ---
-
-const VALID_ROLES = new Set(['repeater', 'companion', 'room', 'sensor']);
-
-/**
- * Validate decoded ADVERT data before upserting into the DB.
- * Returns { valid: true } or { valid: false, reason: string }.
- */
-function validateAdvert(advert) {
-  if (!advert || advert.error) return { valid: false, reason: advert?.error || 'null advert' };
-
-  // pubkey must be at least 16 hex chars (8 bytes) and not all zeros
-  const pk = advert.pubKey || '';
-  if (pk.length < 16) return { valid: false, reason: `pubkey too short (${pk.length} hex chars)` };
-  if (/^0+$/.test(pk)) return { valid: false, reason: 'pubkey is all zeros' };
-
-  // lat/lon must be in valid ranges if present
-  if (advert.lat != null) {
-    if (!Number.isFinite(advert.lat) || advert.lat < -90 || advert.lat > 90) {
-      return { valid: false, reason: `invalid lat: ${advert.lat}` };
-    }
-  }
-  if (advert.lon != null) {
-    if (!Number.isFinite(advert.lon) || advert.lon < -180 || advert.lon > 180) {
-      return { valid: false, reason: `invalid lon: ${advert.lon}` };
-    }
-  }
-
-  // name must not contain control chars (except space) or be garbage
-  if (advert.name != null) {
-    // eslint-disable-next-line no-control-regex
-    if (/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(advert.name)) {
-      return { valid: false, reason: 'name contains control characters' };
-    }
-    // Reject names that are mostly non-printable or suspiciously long
-    if (advert.name.length > 64) {
-      return { valid: false, reason: `name too long (${advert.name.length} chars)` };
-    }
-  }
-
-  // role derivation check — flags byte should produce a known role
-  if (advert.flags) {
-    const role = advert.flags.repeater ? 'repeater' : advert.flags.room ? 'room' : advert.flags.sensor ? 'sensor' : 'companion';
-    if (!VALID_ROLES.has(role)) return { valid: false, reason: `unknown role: ${role}` };
-  }
-
-  // timestamp: decoded but not currently used for node storage — skip validation
-
-  return { valid: true };
-}
-
-module.exports = { decodePacket, validateAdvert, hasNonPrintableChars, ROUTE_TYPES, PAYLOAD_TYPES, VALID_ROLES };
-
-// --- Tests ---
-if (require.main === module) {
-  console.log('=== Test 1: ADVERT, FLOOD, 5 hops (2-byte hashes), "Test Repeater" ===');
-  const pkt1 = decodePacket(
-    '11451000D818206D3AAC152C8A91F89957E6D30CA51F36E28790228971C473B755F244F718754CF5EE4A2FD58D944466E42CDED140C66D0CC590183E32BAF40F112BE8F3F2BDF6012B4B2793C52F1D36F69EE054D9A05593286F78453E56C0EC4A3EB95DDA2A7543FCCC00B939CACC009278603902FC12BCF84B706120526F6F6620536F6C6172'
-  );
-  console.log(JSON.stringify(pkt1, null, 2));
-  console.log();
-
-  // Assertions
-  const assert = (cond, msg) => { if (!cond) throw new Error('ASSERT FAILED: ' + msg); };
-  assert(pkt1.header.routeTypeName === 'FLOOD', 'route should be FLOOD');
-  assert(pkt1.header.payloadTypeName === 'ADVERT', 'payload should be ADVERT');
-  assert(pkt1.path.hashSize === 2, 'hashSize should be 2');
-  assert(pkt1.path.hashCount === 5, 'hashCount should be 5');
-  assert(pkt1.path.hops[0] === '1000', 'first hop should be 1000');
-  assert(pkt1.path.hops[1] === 'D818', 'second hop should be D818');
-  assert(pkt1.transportCodes === null, 'FLOOD has no transport codes');
-  assert(pkt1.payload.name === 'Test Repeater', 'name should be "Test Repeater"');
-  console.log('✅ Test 1 passed\n');
-
-  console.log('=== Test 2: ADVERT, FLOOD, 0 hops (zero-path) ===');
-  // Build a minimal advert: header=0x11 (FLOOD+ADVERT), pathLen=0x00 (1-byte hashes, 0 hops)
-  // Then a minimal advert payload: 32-byte pubkey + 4-byte ts + 64-byte sig + flags(1)
-  const fakePubKey = '00'.repeat(32);
-  const fakeTs = '78563412'; // LE = 0x12345678
-  const fakeSig = 'AA'.repeat(64);
-  const flags = '00'; // no location, no name
-  const pkt2hex = '1100' + fakePubKey + fakeTs + fakeSig + flags;
-  const pkt2 = decodePacket(pkt2hex);
-  console.log(JSON.stringify(pkt2, null, 2));
-  console.log();
-
-  assert(pkt2.header.routeTypeName === 'FLOOD', 'route should be FLOOD');
-  assert(pkt2.header.payloadTypeName === 'ADVERT', 'payload should be ADVERT');
-  assert(pkt2.path.hashSize === 1, 'hashSize should be 1');
-  assert(pkt2.path.hashCount === 0, 'hashCount should be 0');
-  assert(pkt2.path.hops.length === 0, 'no hops');
-  assert(pkt2.payload.timestamp === 0x12345678, 'timestamp');
-  console.log('✅ Test 2 passed\n');
-
-  console.log('All tests passed ✅');
-}

docker-compose.staging.yml

@@ -0,0 +1,43 @@
+# Staging-only compose file. Production is managed by docker-compose.yml.
+# Override defaults via .env or environment variables.
+
+services:
+  staging-go:
+    build:
+      context: .
+      dockerfile: Dockerfile
+      args:
+        APP_VERSION: ${APP_VERSION:-unknown}
+        GIT_COMMIT: ${GIT_COMMIT:-unknown}
+        BUILD_TIME: ${BUILD_TIME:-unknown}
+    image: corescope-go:latest
+    container_name: corescope-staging-go
+    restart: unless-stopped
+    deploy:
+      resources:
+        limits:
+          memory: 3g
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    ports:
+      - "${STAGING_GO_HTTP_PORT:-82}:80"
+      - "${STAGING_GO_MQTT_PORT:-1885}:1883"
+      - "6060:6060"   # pprof server
+      - "6061:6061"   # pprof ingestor
+    volumes:
+      - ${STAGING_DATA_DIR:-~/meshcore-staging-data}/config.json:/app/config.json:ro
+      - ${STAGING_DATA_DIR:-~/meshcore-staging-data}:/app/data
+      - caddy-data-staging-go:/data/caddy
+    environment:
+      - NODE_ENV=staging
+      - ENABLE_PPROF=true
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "http://localhost:3000/api/stats"]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+      start_period: 60s
+
+volumes:
+  # Named volume for Caddy TLS certificates (not user data — managed by Caddy internally)
+  caddy-data-staging-go:

docker-compose.yml

@@ -1,86 +1,38 @@
-# All container config lives here. manage.sh is just a wrapper around docker compose.
-# Override defaults via .env or environment variables.
-# CRITICAL: All data mounts use bind mounts (~/path), NOT named volumes.
-# This ensures the DB and theme are visible on the host filesystem for backup.
-
-services:
-  prod:
-    build: .
-    image: corescope:latest
-    container_name: corescope-prod
-    restart: unless-stopped
-    ports:
-      - "${PROD_HTTP_PORT:-80}:${PROD_HTTP_PORT:-80}"
-      - "${PROD_HTTPS_PORT:-443}:${PROD_HTTPS_PORT:-443}"
-      - "${PROD_MQTT_PORT:-1883}:1883"
-    volumes:
-      - ./config.json:/app/config.json:ro
-      - ./caddy-config/Caddyfile:/etc/caddy/Caddyfile:ro
-      - ${PROD_DATA_DIR:-~/meshcore-data}:/app/data
-      - caddy-data:/data/caddy
-    environment:
-      - NODE_ENV=production
-    healthcheck:
-      test: ["CMD", "wget", "-qO-", "http://localhost:3000/api/stats"]
-      interval: 30s
-      timeout: 5s
-      retries: 3
-
-  staging:
-    build: .
-    image: corescope:latest
-    container_name: corescope-staging
-    restart: unless-stopped
-    ports:
-      - "${STAGING_HTTP_PORT:-81}:${STAGING_HTTP_PORT:-81}"
-      - "${STAGING_MQTT_PORT:-1884}:1883"
-    volumes:
-      - ${STAGING_DATA_DIR:-~/meshcore-staging-data}/config.json:/app/config.json:ro
-      - ${STAGING_DATA_DIR:-~/meshcore-staging-data}/Caddyfile:/etc/caddy/Caddyfile:ro
-      - ${STAGING_DATA_DIR:-~/meshcore-staging-data}:/app/data
-      - caddy-data-staging:/data/caddy
-    environment:
-      - NODE_ENV=staging
-    healthcheck:
-      test: ["CMD", "wget", "-qO-", "http://localhost:3000/api/stats"]
-      interval: 30s
-      timeout: 5s
-      retries: 3
-    profiles:
-      - staging
-
-  staging-go:
-    build:
-      context: .
-      dockerfile: Dockerfile
-      args:
-        APP_VERSION: ${APP_VERSION:-unknown}
-        GIT_COMMIT: ${GIT_COMMIT:-unknown}
-    image: corescope-go:latest
-    container_name: corescope-staging-go
-    restart: unless-stopped
-    ports:
-      - "${STAGING_GO_HTTP_PORT:-82}:80"
-      - "${STAGING_GO_MQTT_PORT:-1885}:1883"
-      - "6060:6060"   # pprof server
-      - "6061:6061"   # pprof ingestor
-    volumes:
-      - ${STAGING_DATA_DIR:-~/meshcore-staging-data}/config.json:/app/config.json:ro
-      - ${STAGING_DATA_DIR:-~/meshcore-staging-data}:/app/data
-      - caddy-data-staging-go:/data/caddy
-    environment:
-      - NODE_ENV=staging
-      - ENABLE_PPROF=true
-    healthcheck:
-      test: ["CMD", "wget", "-qO-", "http://localhost:3000/api/stats"]
-      interval: 30s
-      timeout: 5s
-      retries: 3
-    profiles:
-      - staging-go
-
-volumes:
-  # Named volumes for Caddy TLS certificates (not user data — managed by Caddy internally)
+# All container config lives here. manage.sh is just a wrapper around docker compose.
+# Override defaults via .env or environment variables.
+# CRITICAL: All data mounts use bind mounts (~/path), NOT named volumes.
+# This ensures the DB and theme are visible on the host filesystem for backup.
+
+services:
+  prod:
+    build:
+      context: .
+      args:
+        APP_VERSION: ${APP_VERSION:-unknown}
+        GIT_COMMIT: ${GIT_COMMIT:-unknown}
+        BUILD_TIME: ${BUILD_TIME:-unknown}
+    image: corescope:latest
+    container_name: corescope-prod
+    restart: unless-stopped
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    ports:
+      - "${PROD_HTTP_PORT:-80}:${PROD_HTTP_PORT:-80}"
+      - "${PROD_HTTPS_PORT:-443}:${PROD_HTTPS_PORT:-443}"
+      - "${PROD_MQTT_PORT:-1883}:1883"
+    volumes:
+      - ./config.json:/app/config.json:ro
+      - ./caddy-config/Caddyfile:/etc/caddy/Caddyfile:ro
+      - ${PROD_DATA_DIR:-~/meshcore-data}:/app/data
+      - caddy-data:/data/caddy
+    environment:
+      - NODE_ENV=production
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "http://localhost:3000/api/stats"]
+      interval: 30s
+      timeout: 5s
+      retries: 3
+
+volumes:
+  # Named volumes for Caddy TLS certificates (not user data — managed by Caddy internally)
   caddy-data:
-  caddy-data-staging:
-  caddy-data-staging-go:

docker/entrypoint-go.sh

@@ -1,5 +1,12 @@
 #!/bin/sh
 
+# Fix: Docker creates a directory when bind-mounting a non-existent file.
+# If config.json is a directory (from a failed mount), remove it and use the example.
+if [ -d /app/config.json ]; then
+  echo "[entrypoint] WARNING: config.json is a directory (broken bind mount) — removing and using example"
+  rm -rf /app/config.json
+fi
+
 # Copy example config if no config.json exists (not bind-mounted)
 if [ ! -f /app/config.json ]; then
   echo "[entrypoint] No config.json found, copying from config.example.json"

docker/supervisord-go.conf

@@ -19,6 +19,8 @@ command=/app/corescope-ingestor -config /app/config.json
 directory=/app
 autostart=true
 autorestart=true
+startretries=10
+startsecs=2
 stdout_logfile=/dev/stdout
 stdout_logfile_maxbytes=0
 stderr_logfile=/dev/stderr
@@ -29,6 +31,8 @@ command=/app/corescope-server -config-dir /app -db /app/data/meshcore.db -public
 directory=/app
 autostart=true
 autorestart=true
+startretries=10
+startsecs=2
 stdout_logfile=/dev/stdout
 stdout_logfile_maxbytes=0
 stderr_logfile=/dev/stderr

docker/supervisord.conf

@@ -15,7 +15,7 @@ stderr_logfile=/dev/stderr
 stderr_logfile_maxbytes=0
 
 [program:corescope]
-command=node /app/server.js
+command=/app/corescope-server
 directory=/app
 autostart=true
 autorestart=true

iata-coords.js

@@ -1,90 +0,0 @@
-// IATA airport coordinates for regional node filtering
-// Used by resolve-hops to determine if a node is geographically near an observer's region
-const IATA_COORDS = {
-  // US West Coast
-  SJC: { lat: 37.3626, lon: -121.9290 },
-  SFO: { lat: 37.6213, lon: -122.3790 },
-  OAK: { lat: 37.7213, lon: -122.2208 },
-  SEA: { lat: 47.4502, lon: -122.3088 },
-  PDX: { lat: 45.5898, lon: -122.5951 },
-  LAX: { lat: 33.9425, lon: -118.4081 },
-  SAN: { lat: 32.7338, lon: -117.1933 },
-  SMF: { lat: 38.6954, lon: -121.5908 },
-  MRY: { lat: 36.5870, lon: -121.8430 },
-  EUG: { lat: 44.1246, lon: -123.2119 },
-  RDD: { lat: 40.5090, lon: -122.2934 },
-  MFR: { lat: 42.3742, lon: -122.8735 },
-  FAT: { lat: 36.7762, lon: -119.7181 },
-  SBA: { lat: 34.4262, lon: -119.8405 },
-  RNO: { lat: 39.4991, lon: -119.7681 },
-  BOI: { lat: 43.5644, lon: -116.2228 },
-  LAS: { lat: 36.0840, lon: -115.1537 },
-  PHX: { lat: 33.4373, lon: -112.0078 },
-  SLC: { lat: 40.7884, lon: -111.9778 },
-  // US Mountain/Central
-  DEN: { lat: 39.8561, lon: -104.6737 },
-  DFW: { lat: 32.8998, lon: -97.0403 },
-  IAH: { lat: 29.9844, lon: -95.3414 },
-  AUS: { lat: 30.1975, lon: -97.6664 },
-  MSP: { lat: 44.8848, lon: -93.2223 },
-  // US East Coast
-  ATL: { lat: 33.6407, lon: -84.4277 },
-  ORD: { lat: 41.9742, lon: -87.9073 },
-  JFK: { lat: 40.6413, lon: -73.7781 },
-  EWR: { lat: 40.6895, lon: -74.1745 },
-  BOS: { lat: 42.3656, lon: -71.0096 },
-  MIA: { lat: 25.7959, lon: -80.2870 },
-  IAD: { lat: 38.9531, lon: -77.4565 },
-  CLT: { lat: 35.2144, lon: -80.9473 },
-  DTW: { lat: 42.2124, lon: -83.3534 },
-  MCO: { lat: 28.4312, lon: -81.3081 },
-  BNA: { lat: 36.1263, lon: -86.6774 },
-  RDU: { lat: 35.8801, lon: -78.7880 },
-  // Canada
-  YVR: { lat: 49.1967, lon: -123.1815 },
-  YYZ: { lat: 43.6777, lon: -79.6248 },
-  YYC: { lat: 51.1215, lon: -114.0076 },
-  YEG: { lat: 53.3097, lon: -113.5800 },
-  YOW: { lat: 45.3225, lon: -75.6692 },
-  // Europe
-  LHR: { lat: 51.4700, lon: -0.4543 },
-  CDG: { lat: 49.0097, lon: 2.5479 },
-  FRA: { lat: 50.0379, lon: 8.5622 },
-  AMS: { lat: 52.3105, lon: 4.7683 },
-  MUC: { lat: 48.3537, lon: 11.7750 },
-  SOF: { lat: 42.6952, lon: 23.4062 },
-  // Asia/Pacific
-  NRT: { lat: 35.7720, lon: 140.3929 },
-  HND: { lat: 35.5494, lon: 139.7798 },
-  ICN: { lat: 37.4602, lon: 126.4407 },
-  SYD: { lat: -33.9461, lon: 151.1772 },
-  MEL: { lat: -37.6690, lon: 144.8410 },
-};
-
-// Haversine distance in km
-function haversineKm(lat1, lon1, lat2, lon2) {
-  const R = 6371;
-  const dLat = (lat2 - lat1) * Math.PI / 180;
-  const dLon = (lon2 - lon1) * Math.PI / 180;
-  const a = Math.sin(dLat / 2) ** 2 +
-    Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *
-    Math.sin(dLon / 2) ** 2;
-  return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-}
-
-// Default radius for "near region" — LoRa max realistic range ~300km
-const DEFAULT_REGION_RADIUS_KM = 300;
-
-/**
- * Check if a node is geographically within radius of an IATA region center.
- * Returns { near: boolean, distKm: number } or null if can't determine.
- */
-function nodeNearRegion(nodeLat, nodeLon, iata, radiusKm = DEFAULT_REGION_RADIUS_KM) {
-  const center = IATA_COORDS[iata];
-  if (!center) return null;
-  if (nodeLat == null || nodeLon == null || (nodeLat === 0 && nodeLon === 0)) return null;
-  const distKm = haversineKm(nodeLat, nodeLon, center.lat, center.lon);
-  return { near: distKm <= radiusKm, distKm: Math.round(distKm) };
-}
-
-module.exports = { IATA_COORDS, haversineKm, nodeNearRegion, DEFAULT_REGION_RADIUS_KM };

manage.sh

@@ -18,6 +18,12 @@ STATE_FILE=".setup-state"
 # Resolved paths for prod/staging data (must match docker-compose.yml)
 PROD_DATA="${PROD_DATA_DIR:-$HOME/meshcore-data}"
 STAGING_DATA="${STAGING_DATA_DIR:-$HOME/meshcore-staging-data}"
+STAGING_COMPOSE_FILE="docker-compose.staging.yml"
+
+# Build metadata — exported so docker compose build picks them up via args
+export APP_VERSION=$(node -p "require('./package.json').version" 2>/dev/null || echo "unknown")
+export GIT_COMMIT=$(git rev-parse --short HEAD 2>/dev/null || echo "unknown")
+export BUILD_TIME=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 
 # Colors
 RED='\033[0;31m'
@@ -386,7 +392,7 @@ prepare_staging_db() {
 
 # Copy config.prod.json → config.staging.json with siteName change
 prepare_staging_config() {
-  local prod_config="$PROD_DATA/config.json"
+  local prod_config="./config.json"
   local staging_config="$STAGING_DATA/config.json"
   if [ ! -f "$prod_config" ]; then
     warn "No config.json found at ${prod_config} — staging may not start correctly."
@@ -435,10 +441,11 @@ cmd_start() {
     prepare_staging_config
 
     info "Starting production container (corescope-prod) on ports ${PROD_HTTP_PORT:-80}/${PROD_HTTPS_PORT:-443}..."
-    info "Starting staging container (corescope-staging) on port ${STAGING_HTTP_PORT:-81}..."
-    docker compose --profile staging up -d
+    info "Starting staging container (corescope-staging-go) on port ${STAGING_GO_HTTP_PORT:-82}..."
+    docker compose up -d prod
+    docker compose -f "$STAGING_COMPOSE_FILE" -p corescope-staging up -d staging-go
     log "Production started on ports ${PROD_HTTP_PORT:-80}/${PROD_HTTPS_PORT:-443}/${PROD_MQTT_PORT:-1883}"
-    log "Staging started on port ${STAGING_HTTP_PORT:-81} (MQTT: ${STAGING_MQTT_PORT:-1884})"
+    log "Staging started on port ${STAGING_GO_HTTP_PORT:-82} (MQTT: ${STAGING_GO_MQTT_PORT:-1885})"
   else
     info "Starting production container (corescope-prod) on ports ${PROD_HTTP_PORT:-80}/${PROD_HTTPS_PORT:-443}..."
     docker compose up -d prod
@@ -456,13 +463,16 @@ cmd_stop() {
       log "Production stopped."
       ;;
     staging)
-      info "Stopping staging container (corescope-staging)..."
-      docker compose --profile staging stop staging
-      log "Staging stopped."
+      info "Stopping staging container (corescope-staging-go)..."
+      docker compose -f "$STAGING_COMPOSE_FILE" -p corescope-staging rm -sf staging-go 2>/dev/null || true
+      docker rm -f corescope-staging-go meshcore-staging-go corescope-staging meshcore-staging 2>/dev/null || true
+      log "Staging stopped and cleaned up."
       ;;
     all)
       info "Stopping all containers..."
-      docker compose --profile staging --profile staging-go down
+      docker compose stop prod
+      docker compose -f "$STAGING_COMPOSE_FILE" -p corescope-staging rm -sf staging-go 2>/dev/null || true
+      docker rm -f corescope-staging-go meshcore-staging-go corescope-staging meshcore-staging 2>/dev/null || true
       log "All containers stopped."
       ;;
     *)
@@ -481,13 +491,34 @@ cmd_restart() {
       log "Production restarted."
       ;;
     staging)
-      info "Restarting staging container (corescope-staging)..."
-      docker compose --profile staging up -d --force-recreate staging
+      info "Restarting staging container (corescope-staging-go)..."
+      # Stop and remove old container
+      docker compose -f "$STAGING_COMPOSE_FILE" -p corescope-staging rm -sf staging-go 2>/dev/null || true
+      docker rm -f corescope-staging-go 2>/dev/null || true
+      # Wait for container to be fully gone and memory to be reclaimed
+      # This prevents OOM when old + new containers overlap on small VMs
+      for i in $(seq 1 15); do
+        if ! docker ps -a --format '{{.Names}}' | grep -q 'corescope-staging-go'; then
+          break
+        fi
+        sleep 1
+      done
+      sleep 3  # extra pause for OS to reclaim memory
+      # Verify config exists before starting
+      local staging_config="${STAGING_DATA_DIR:-$HOME/meshcore-staging-data}/config.json"
+      if [ ! -f "$staging_config" ]; then
+        warn "Staging config not found at $staging_config — creating from prod config..."
+        prepare_staging_config
+      fi
+      docker compose -f "$STAGING_COMPOSE_FILE" -p corescope-staging up -d staging-go
       log "Staging restarted."
       ;;
     all)
       info "Restarting all containers..."
-      docker compose --profile staging up -d --force-recreate
+      docker compose up -d --force-recreate prod
+      docker compose -f "$STAGING_COMPOSE_FILE" -p corescope-staging rm -sf staging-go 2>/dev/null || true
+      docker rm -f corescope-staging-go 2>/dev/null || true
+      docker compose -f "$STAGING_COMPOSE_FILE" -p corescope-staging up -d staging-go
       log "All containers restarted."
       ;;
     *)
@@ -539,10 +570,10 @@ cmd_status() {
   echo ""
 
   # Staging
-  if container_running "corescope-staging"; then
-    show_container_status "corescope-staging" "Staging"
+  if container_running "corescope-staging-go"; then
+    show_container_status "corescope-staging-go" "Staging"
   else
-    info "Staging (corescope-staging): Not running (use --with-staging to start both)"
+    info "Staging (corescope-staging-go): Not running (use --with-staging to start both)"
   fi
   echo ""
 
@@ -574,7 +605,7 @@ cmd_logs() {
     staging)
       if container_running "corescope-staging"; then
         info "Tailing staging logs..."
-        docker compose logs -f --tail="$LINES" staging
+        docker compose -f "$STAGING_COMPOSE_FILE" -p corescope-staging logs -f --tail="$LINES" staging-go
       else
         err "Staging container is not running."
         info "Start with: ./manage.sh start --with-staging"
@@ -602,7 +633,7 @@ cmd_promote() {
 
   # Show what's currently running
   local staging_image staging_created prod_image prod_created
-  staging_image=$(docker inspect corescope-staging --format '{{.Config.Image}}' 2>/dev/null || echo "not running")
+  staging_image=$(docker inspect corescope-staging-go --format '{{.Config.Image}}' 2>/dev/null || echo "not running")
   staging_created=$(docker inspect corescope-staging --format '{{.Created}}' 2>/dev/null || echo "N/A")
   prod_image=$(docker inspect corescope-prod --format '{{.Config.Image}}' 2>/dev/null || echo "not running")
   prod_created=$(docker inspect corescope-prod --format '{{.Created}}' 2>/dev/null || echo "N/A")
@@ -848,7 +879,8 @@ cmd_reset() {
     exit 0
   fi
 
-  docker compose --profile staging --profile staging-go down --rmi local 2>/dev/null || true
+  docker compose down --rmi local 2>/dev/null || true
+  docker compose -f "$STAGING_COMPOSE_FILE" -p corescope-staging down --rmi local 2>/dev/null || true
   rm -f "$STATE_FILE"
 
   log "Reset complete. Run './manage.sh setup' to start over."
@@ -869,7 +901,7 @@ cmd_help() {
   echo ""
   printf '%b\n' "  ${BOLD}Run${NC}"
   echo "    start              Start production container"
-  echo "    start --with-staging  Start production + staging (copies prod DB + config)"
+  echo "    start --with-staging  Start production + staging-go (copies prod DB + config)"
   echo "    stop [prod|staging|all]  Stop specific or all containers (default: all)"
   echo "    restart [prod|staging|all]  Restart specific or all containers"
   echo "    status             Show health, stats, and service status"
@@ -882,7 +914,7 @@ cmd_help() {
   echo "    restore <d>        Restore from backup dir or .db file"
   echo "    mqtt-test          Check if MQTT data is flowing"
   echo ""
-  echo "All commands use docker compose with docker-compose.yml."
+  echo "Prod uses docker-compose.yml; staging uses ${STAGING_COMPOSE_FILE}."
   echo ""
 }
 

package.json

@@ -5,7 +5,7 @@
   "main": "index.js",
   "scripts": {
     "test": "npx c8 --reporter=text --reporter=text-summary sh test-all.sh",
-    "test:unit": "node test-packet-filter.js && node test-aging.js && node test-regional-filter.js",
+    "test:unit": "node test-packet-filter.js && node test-aging.js && node test-frontend-helpers.js",
     "test:coverage": "npx c8 --reporter=text --reporter=html sh test-all.sh",
     "test:full-coverage": "sh scripts/combined-coverage.sh"
   },

packet-store.js

@@ -1,752 +0,0 @@
-'use strict';
-
-/**
- * In-memory packet store — loads transmissions + observations from SQLite on startup,
- * serves reads from RAM, writes to both RAM + SQLite.
- * M3: Restructured around transmissions (deduped by hash) with observations.
- * Caps memory at configurable limit (default 1GB).
- */
-class PacketStore {
-  constructor(dbModule, config = {}) {
-    this.dbModule = dbModule;  // The full db module (has .db, .insertTransmission, .getPacket)
-    this.db = dbModule.db;     // Raw better-sqlite3 instance for queries
-    this.maxBytes = (config.maxMemoryMB || 1024) * 1024 * 1024;
-    this.estPacketBytes = config.estimatedPacketBytes || 450;
-    this.maxPackets = Math.floor(this.maxBytes / this.estPacketBytes);
-
-    // SQLite-only mode: skip RAM loading, all reads go to DB
-    this.sqliteOnly = process.env.NO_MEMORY_STORE === '1';
-
-    // Primary storage: transmissions sorted by first_seen DESC (newest first)
-    // Each transmission looks like a packet for backward compat
-    this.packets = [];
-
-    // Indexes
-    this.byId = new Map();           // observation_id → observation object (backward compat for packet detail links)
-    this.byTxId = new Map();         // transmission_id → transmission object
-    this.byHash = new Map();         // hash → transmission object (1:1)
-    this.byObserver = new Map();     // observer_id → [observation objects]
-    this.byNode = new Map();         // pubkey → [transmission objects] (deduped)
-
-    // Track which hashes are indexed per node pubkey (avoid dupes in byNode)
-    this._nodeHashIndex = new Map(); // pubkey → Set<hash>
-    this._advertByObserver = new Map(); // pubkey → Set<observer_id> (ADVERT-only, for region filtering)
-
-    this.loaded = false;
-    this.stats = { totalLoaded: 0, totalObservations: 0, evicted: 0, inserts: 0, queries: 0 };
-  }
-
-  /** Load all packets from SQLite into memory */
-  load() {
-    if (this.sqliteOnly) {
-      console.log('[PacketStore] SQLite-only mode (NO_MEMORY_STORE=1) — all reads go to database');
-      this.loaded = true;
-      return this;
-    }
-
-    const t0 = Date.now();
-
-    // Check if normalized schema exists
-    const hasTransmissions = this.db.prepare(
-      "SELECT name FROM sqlite_master WHERE type='table' AND name='transmissions'"
-    ).get();
-
-    if (hasTransmissions) {
-      this._loadNormalized();
-    } else {
-      this._loadLegacy();
-    }
-
-    this.stats.totalLoaded = this.packets.length;
-    this.loaded = true;
-    const elapsed = Date.now() - t0;
-    console.log(`[PacketStore] Loaded ${this.packets.length} transmissions (${this.stats.totalObservations} observations) in ${elapsed}ms (${Math.round(this.packets.length * this.estPacketBytes / 1024 / 1024)}MB est)`);
-    return this;
-  }
-
-  /** Load from normalized transmissions + observations tables */
-  _loadNormalized() {
-    // Detect v3 schema (observer_idx instead of observer_id in observations)
-    const obsCols = this.db.pragma('table_info(observations)').map(c => c.name);
-    const isV3 = obsCols.includes('observer_idx');
-
-    const sql = isV3
-      ? `SELECT t.id AS transmission_id, t.raw_hex, t.hash, t.first_seen, t.route_type,
-               t.payload_type, t.payload_version, t.decoded_json,
-               o.id AS observation_id, obs.id AS observer_id, obs.name AS observer_name, o.direction,
-               o.snr, o.rssi, o.score, o.path_json, datetime(o.timestamp, 'unixepoch') AS obs_timestamp
-          FROM transmissions t
-          LEFT JOIN observations o ON o.transmission_id = t.id
-          LEFT JOIN observers obs ON obs.rowid = o.observer_idx
-          ORDER BY t.first_seen DESC, o.timestamp DESC`
-      : `SELECT t.id AS transmission_id, t.raw_hex, t.hash, t.first_seen, t.route_type,
-               t.payload_type, t.payload_version, t.decoded_json,
-               o.id AS observation_id, o.observer_id, o.observer_name, o.direction,
-               o.snr, o.rssi, o.score, o.path_json, o.timestamp AS obs_timestamp
-          FROM transmissions t
-          LEFT JOIN observations o ON o.transmission_id = t.id
-          ORDER BY t.first_seen DESC, o.timestamp DESC`;
-
-    for (const row of this.db.prepare(sql).iterate()) {
-      if (this.packets.length >= this.maxPackets && !this.byHash.has(row.hash)) break;
-
-      let tx = this.byHash.get(row.hash);
-      if (!tx) {
-        tx = {
-          id: row.transmission_id,
-          raw_hex: row.raw_hex,
-          hash: row.hash,
-          first_seen: row.first_seen,
-          timestamp: row.first_seen,
-          route_type: row.route_type,
-          payload_type: row.payload_type,
-          decoded_json: row.decoded_json,
-          observations: [],
-          observation_count: 0,
-          // Filled from first observation for backward compat
-          observer_id: null,
-          observer_name: null,
-          snr: null,
-          rssi: null,
-          path_json: null,
-          direction: null,
-        };
-        this.byHash.set(row.hash, tx);
-        this.byHash.set(row.hash, tx);
-        this.packets.push(tx);
-        this.byTxId.set(tx.id, tx);
-        this._indexByNode(tx);
-      }
-
-      if (row.observation_id != null) {
-        const obs = {
-          id: row.observation_id,
-          transmission_id: tx.id,
-          hash: tx.hash,
-          observer_id: row.observer_id,
-          observer_name: row.observer_name,
-          direction: row.direction,
-          snr: row.snr,
-          rssi: row.rssi,
-          score: row.score,
-          path_json: row.path_json,
-          timestamp: row.obs_timestamp,
-        };
-
-        // Dedup: skip if same observer + same path already loaded
-        const isDupeLoad = tx.observations.some(o => o.observer_id === obs.observer_id && (o.path_json || '') === (obs.path_json || ''));
-        if (isDupeLoad) continue;
-
-        tx.observations.push(obs);
-        tx.observation_count++;
-
-        // Fill first observation data into transmission for backward compat
-        if (tx.observer_id == null && obs.observer_id) {
-          tx.observer_id = obs.observer_id;
-          tx.observer_name = obs.observer_name;
-          tx.snr = obs.snr;
-          tx.rssi = obs.rssi;
-          tx.path_json = obs.path_json;
-          tx.direction = obs.direction;
-        }
-
-        // byId maps observation IDs for packet detail links
-        this.byId.set(obs.id, obs);
-
-        // byObserver
-        if (obs.observer_id) {
-          if (!this.byObserver.has(obs.observer_id)) this.byObserver.set(obs.observer_id, []);
-          this.byObserver.get(obs.observer_id).push(obs);
-        }
-
-        this.stats.totalObservations++;
-      }
-    }
-
-    // Post-load: set each transmission's display path to the LONGEST observation path
-    // (most representative of mesh topology — short paths are just nearby observers)
-    for (const tx of this.packets) {
-      if (tx.observations.length > 0) {
-        let best = tx.observations[0];
-        let bestLen = 0;
-        try { bestLen = JSON.parse(best.path_json || '[]').length; } catch {}
-        for (let i = 1; i < tx.observations.length; i++) {
-          let len = 0;
-          try { len = JSON.parse(tx.observations[i].path_json || '[]').length; } catch {}
-          if (len > bestLen) { best = tx.observations[i]; bestLen = len; }
-        }
-        tx.observer_id = best.observer_id;
-        tx.observer_name = best.observer_name;
-        tx.snr = best.snr;
-        tx.rssi = best.rssi;
-        tx.path_json = best.path_json;
-        tx.direction = best.direction;
-      }
-    }
-
-    // Post-load: build ADVERT-by-observer index (needs all observations loaded first)
-    for (const tx of this.packets) {
-      if (tx.payload_type === 4 && tx.decoded_json) {
-        try {
-          const d = JSON.parse(tx.decoded_json);
-          if (d.pubKey) this._indexAdvertObservers(d.pubKey, tx);
-        } catch {}
-      }
-    }
-    console.log(`[PacketStore] ADVERT observer index: ${this._advertByObserver.size} nodes tracked`);
-  }
-
-  /** Fallback: load from legacy packets table */
-  _loadLegacy() {
-    for (const row of this.db.prepare(
-      'SELECT * FROM packets_v ORDER BY timestamp DESC'
-    ).iterate()) {
-      if (this.packets.length >= this.maxPackets) break;
-      this._indexLegacy(row);
-    }
-  }
-
-  /** Index a legacy packet row (old flat structure) — builds transmission + observation */
-  _indexLegacy(pkt) {
-    let tx = this.byHash.get(pkt.hash);
-    if (!tx) {
-      tx = {
-        id: pkt.id,
-        raw_hex: pkt.raw_hex,
-        hash: pkt.hash,
-        first_seen: pkt.timestamp,
-        timestamp: pkt.timestamp,
-        route_type: pkt.route_type,
-        payload_type: pkt.payload_type,
-        decoded_json: pkt.decoded_json,
-        observations: [],
-        observation_count: 0,
-        observer_id: pkt.observer_id,
-        observer_name: pkt.observer_name,
-        snr: pkt.snr,
-        rssi: pkt.rssi,
-        path_json: pkt.path_json,
-        direction: pkt.direction,
-      };
-      this.byHash.set(pkt.hash, tx);
-      this.byHash.set(pkt.hash, tx);
-      this.packets.push(tx);
-        this.byTxId.set(tx.id, tx);
-      this._indexByNode(tx);
-    }
-
-    if (pkt.timestamp < tx.first_seen) {
-      tx.first_seen = pkt.timestamp;
-      tx.timestamp = pkt.timestamp;
-    }
-    // Update display path if new observation has longer path
-    let newPathLen = 0, curPathLen = 0;
-    try { newPathLen = JSON.parse(pkt.path_json || '[]').length; } catch {}
-    try { curPathLen = JSON.parse(tx.path_json || '[]').length; } catch {}
-    if (newPathLen > curPathLen) {
-      tx.observer_id = pkt.observer_id;
-      tx.observer_name = pkt.observer_name;
-      tx.path_json = pkt.path_json;
-    }
-
-    const obs = {
-      id: pkt.id,
-      transmission_id: tx.id,
-      observer_id: pkt.observer_id,
-      observer_name: pkt.observer_name,
-      direction: pkt.direction,
-      snr: pkt.snr,
-      rssi: pkt.rssi,
-      score: pkt.score,
-      path_json: pkt.path_json,
-      timestamp: pkt.timestamp,
-    };
-    // Dedup: skip if same observer + same path already recorded for this transmission
-    const isDupe = tx.observations.some(o => o.observer_id === obs.observer_id && (o.path_json || '') === (obs.path_json || ''));
-    if (isDupe) return tx;
-
-    tx.observations.push(obs);
-    tx.observation_count++;
-
-    this.byId.set(pkt.id, obs);
-
-    if (pkt.observer_id) {
-      if (!this.byObserver.has(pkt.observer_id)) this.byObserver.set(pkt.observer_id, []);
-      this.byObserver.get(pkt.observer_id).push(obs);
-    }
-
-    this.stats.totalObservations++;
-  }
-
-  /** Extract node pubkeys from decoded_json and index transmission in byNode */
-  _indexByNode(tx) {
-    if (!tx.decoded_json) return;
-    try {
-      const decoded = JSON.parse(tx.decoded_json);
-      const keys = new Set();
-      if (decoded.pubKey) keys.add(decoded.pubKey);
-      if (decoded.destPubKey) keys.add(decoded.destPubKey);
-      if (decoded.srcPubKey) keys.add(decoded.srcPubKey);
-      for (const k of keys) {
-        if (!this._nodeHashIndex.has(k)) this._nodeHashIndex.set(k, new Set());
-        if (this._nodeHashIndex.get(k).has(tx.hash)) continue;
-        this._nodeHashIndex.get(k).add(tx.hash);
-        if (!this.byNode.has(k)) this.byNode.set(k, []);
-        this.byNode.get(k).push(tx);
-      }
-    } catch {}
-  }
-
-  /** Track which observers saw an ADVERT from a given pubkey */
-  _indexAdvertObservers(pubkey, tx) {
-    if (!this._advertByObserver.has(pubkey)) this._advertByObserver.set(pubkey, new Set());
-    const s = this._advertByObserver.get(pubkey);
-    for (const obs of tx.observations) {
-      if (obs.observer_id) s.add(obs.observer_id);
-    }
-  }
-
-  /** Get node pubkeys whose ADVERTs were seen by any of the given observer IDs */
-  getNodesByAdvertObservers(observerIds) {
-    const result = new Set();
-    for (const [pubkey, observers] of this._advertByObserver) {
-      for (const obsId of observerIds) {
-        if (observers.has(obsId)) { result.add(pubkey); break; }
-      }
-    }
-    return result;
-  }
-
-  /** Remove oldest transmissions when over memory limit */
-  _evict() {
-    while (this.packets.length > this.maxPackets) {
-      const old = this.packets.pop();
-      this.byHash.delete(old.hash);
-      this.byHash.delete(old.hash);
-      this.byTxId.delete(old.id);
-      // Remove observations from byId and byObserver
-      for (const obs of old.observations) {
-        this.byId.delete(obs.id);
-        if (obs.observer_id && this.byObserver.has(obs.observer_id)) {
-          const arr = this.byObserver.get(obs.observer_id).filter(o => o.id !== obs.id);
-          if (arr.length) this.byObserver.set(obs.observer_id, arr); else this.byObserver.delete(obs.observer_id);
-        }
-      }
-      // Skip node index cleanup (expensive, low value)
-      this.stats.evicted++;
-    }
-  }
-
-  /** Insert a new packet (to both memory and SQLite) */
-  insert(packetData) {
-    // Write to normalized tables and get the transmission ID
-    const txResult = this.dbModule.insertTransmission ? this.dbModule.insertTransmission(packetData) : null;
-    const transmissionId = txResult ? txResult.transmissionId : null;
-    const observationId = txResult ? txResult.observationId : null;
-
-    // Build row directly from packetData — avoids view ID mismatch issues
-    const row = {
-      id: observationId,
-      raw_hex: packetData.raw_hex,
-      hash: packetData.hash,
-      timestamp: packetData.timestamp,
-      route_type: packetData.route_type,
-      payload_type: packetData.payload_type,
-      payload_version: packetData.payload_version,
-      decoded_json: packetData.decoded_json,
-      observer_id: packetData.observer_id,
-      observer_name: packetData.observer_name,
-      snr: packetData.snr,
-      rssi: packetData.rssi,
-      path_json: packetData.path_json,
-      direction: packetData.direction,
-    };
-    if (!this.sqliteOnly) {
-      // Update or create transmission in memory
-      let tx = this.byHash.get(row.hash);
-      if (!tx) {
-        tx = {
-          id: transmissionId || row.id,
-          raw_hex: row.raw_hex,
-          hash: row.hash,
-          first_seen: row.timestamp,
-          timestamp: row.timestamp,
-          route_type: row.route_type,
-          payload_type: row.payload_type,
-          decoded_json: row.decoded_json,
-          observations: [],
-          observation_count: 0,
-          observer_id: row.observer_id,
-          observer_name: row.observer_name,
-          snr: row.snr,
-          rssi: row.rssi,
-          path_json: row.path_json,
-          direction: row.direction,
-        };
-        this.byHash.set(row.hash, tx);
-        this.byHash.set(row.hash, tx);
-        this.packets.unshift(tx); // newest first
-        this.byTxId.set(tx.id, tx);
-        this._indexByNode(tx);
-      } else {
-        // Update first_seen if earlier
-        if (row.timestamp < tx.first_seen) {
-          tx.first_seen = row.timestamp;
-          tx.timestamp = row.timestamp;
-        }
-        // Update display path if new observation has longer path
-        let newPathLen = 0, curPathLen = 0;
-        try { newPathLen = JSON.parse(row.path_json || '[]').length; } catch {}
-        try { curPathLen = JSON.parse(tx.path_json || '[]').length; } catch {}
-        if (newPathLen > curPathLen) {
-          tx.observer_id = row.observer_id;
-          tx.observer_name = row.observer_name;
-          tx.path_json = row.path_json;
-        }
-      }
-
-      // Add observation
-      const obs = {
-        id: row.id,
-        transmission_id: tx.id,
-        hash: tx.hash,
-        observer_id: row.observer_id,
-        observer_name: row.observer_name,
-        direction: row.direction,
-        snr: row.snr,
-        rssi: row.rssi,
-        score: row.score,
-        path_json: row.path_json,
-        timestamp: row.timestamp,
-      };
-      // Dedup: skip if same observer + same path already recorded for this transmission
-      const isDupe = tx.observations.some(o => o.observer_id === obs.observer_id && (o.path_json || '') === (obs.path_json || ''));
-      if (!isDupe) {
-        tx.observations.push(obs);
-        tx.observation_count++;
-      }
-
-      // Update transmission's display fields if this is first observation
-      if (tx.observations.length === 1) {
-        tx.observer_id = obs.observer_id;
-        tx.observer_name = obs.observer_name;
-        tx.snr = obs.snr;
-        tx.rssi = obs.rssi;
-        tx.path_json = obs.path_json;
-      }
-
-      this.byId.set(obs.id, obs);
-      if (obs.observer_id) {
-        if (!this.byObserver.has(obs.observer_id)) this.byObserver.set(obs.observer_id, []);
-        this.byObserver.get(obs.observer_id).push(obs);
-      }
-
-      this.stats.totalObservations++;
-
-      // Update ADVERT observer index for live ingestion
-      if (tx.payload_type === 4 && obs.observer_id && tx.decoded_json) {
-        try {
-          const d = JSON.parse(tx.decoded_json);
-          if (d.pubKey) {
-            if (!this._advertByObserver.has(d.pubKey)) this._advertByObserver.set(d.pubKey, new Set());
-            this._advertByObserver.get(d.pubKey).add(obs.observer_id);
-          }
-        } catch {}
-      }
-
-      this._evict();
-      this.stats.inserts++;
-    }
-    return observationId || transmissionId;
-  }
-
-  /**
-   * Find ALL packets referencing a node — by pubkey index + name + pubkey text search.
-   * Returns unique transmissions (deduped).
-   * @param {string} nodeIdOrName - pubkey or friendly name
-   * @param {Array} [fromPackets] - packet array to filter (defaults to this.packets)
-   * @returns {{ packets: Array, pubkey: string, nodeName: string }}
-   */
-  findPacketsForNode(nodeIdOrName, fromPackets) {
-    let pubkey = nodeIdOrName;
-    let nodeName = nodeIdOrName;
-
-    // Always resolve to get both pubkey and name
-    try {
-      const row = this.db.prepare("SELECT public_key, name FROM nodes WHERE public_key = ? OR name = ? LIMIT 1").get(nodeIdOrName, nodeIdOrName);
-      if (row) { pubkey = row.public_key; nodeName = row.name || nodeIdOrName; }
-    } catch {}
-
-    // Combine: index hits + text search
-    const indexed = this.byNode.get(pubkey);
-    const hashSet = indexed ? new Set(indexed.map(t => t.hash)) : new Set();
-    const source = fromPackets || this.packets;
-    const packets = source.filter(t =>
-      hashSet.has(t.hash) ||
-      (t.decoded_json && (t.decoded_json.includes(nodeName) || t.decoded_json.includes(pubkey)))
-    );
-
-    return { packets, pubkey, nodeName };
-  }
-
-  /** Count transmissions and observations for a node */
-  countForNode(pubkey) {
-    const txs = this.byNode.get(pubkey) || [];
-    let observations = 0;
-    for (const tx of txs) observations += tx.observation_count;
-    return { transmissions: txs.length, observations };
-  }
-
-  /** Query packets with filters — all from memory (or SQLite in fallback mode) */
-  query({ limit = 50, offset = 0, type, route, region, observer, hash, since, until, node, order = 'DESC' } = {}) {
-    this.stats.queries++;
-
-    if (this.sqliteOnly) return this._querySQLite({ limit, offset, type, route, region, observer, hash, since, until, node, order });
-
-    let results = this.packets;
-
-    // Use indexes for single-key filters when possible
-    if (hash && !type && !route && !region && !observer && !since && !until && !node) {
-      const tx = this.byHash.get(hash);
-      results = tx ? [tx] : [];
-    } else if (observer && !type && !route && !region && !hash && !since && !until && !node) {
-      // For observer filter, find unique transmissions where any observation matches
-      results = this._transmissionsForObserver(observer);
-    } else if (node && !type && !route && !region && !observer && !hash && !since && !until) {
-      results = this.findPacketsForNode(node).packets;
-    } else {
-      // Apply filters sequentially
-      if (type !== undefined) {
-        const t = Number(type);
-        results = results.filter(p => p.payload_type === t);
-      }
-      if (route !== undefined) {
-        const r = Number(route);
-        results = results.filter(p => p.route_type === r);
-      }
-      if (observer) results = this._transmissionsForObserver(observer, results);
-      if (hash) {
-        const h = hash.toLowerCase();
-        const tx = this.byHash.get(h);
-        results = tx ? results.filter(p => p.hash === h) : [];
-      }
-      if (since) results = results.filter(p => p.timestamp > since);
-      if (until) results = results.filter(p => p.timestamp < until);
-      if (region) {
-        const regionObservers = new Set();
-        try {
-          const obs = this.db.prepare('SELECT id FROM observers WHERE iata = ?').all(region);
-          obs.forEach(o => regionObservers.add(o.id));
-        } catch {}
-        results = results.filter(p =>
-          p.observations.some(o => regionObservers.has(o.observer_id))
-        );
-      }
-      if (node) {
-        results = this.findPacketsForNode(node, results).packets;
-      }
-    }
-
-    const total = results.length;
-
-    // Sort
-    if (order === 'ASC') {
-      results = results.slice().sort((a, b) => {
-        if (a.timestamp < b.timestamp) return -1;
-        if (a.timestamp > b.timestamp) return 1;
-        return 0;
-      });
-    }
-    // Default DESC — packets array is already sorted newest-first
-
-    // Paginate
-    const paginated = results.slice(Number(offset), Number(offset) + Number(limit));
-    return { packets: paginated, total };
-  }
-
-  /** Find unique transmissions that have at least one observation from given observer */
-  _transmissionsForObserver(observerId, fromTransmissions) {
-    if (fromTransmissions) {
-      return fromTransmissions.filter(tx =>
-        tx.observations.some(o => o.observer_id === observerId)
-      );
-    }
-    // Use byObserver index: get observations, then unique transmissions
-    const obs = this.byObserver.get(observerId) || [];
-    const seen = new Set();
-    const result = [];
-    for (const o of obs) {
-      const txId = o.transmission_id;
-      if (!seen.has(txId)) {
-        seen.add(txId);
-        const tx = this.byTxId.get(txId);
-        if (tx) result.push(tx);
-      }
-    }
-    return result;
-  }
-
-  /** Query with groupByHash — now trivial since packets ARE transmissions */
-  queryGrouped({ limit = 50, offset = 0, type, route, region, observer, hash, since, until, node } = {}) {
-    this.stats.queries++;
-
-    if (this.sqliteOnly) return this._queryGroupedSQLite({ limit, offset, type, route, region, observer, hash, since, until, node });
-
-    // Get filtered transmissions
-    const { packets: filtered, total: filteredTotal } = this.query({
-      limit: 999999, offset: 0, type, route, region, observer, hash, since, until, node
-    });
-
-    // Already grouped by hash — just format for backward compat
-    const sorted = filtered.map(tx => ({
-      hash: tx.hash,
-      first_seen: tx.first_seen || tx.timestamp,
-      count: tx.observation_count,
-      observer_count: new Set(tx.observations.map(o => o.observer_id).filter(Boolean)).size,
-      latest: tx.observations.length ? tx.observations.reduce((max, o) => o.timestamp > max ? o.timestamp : max, tx.observations[0].timestamp) : tx.timestamp,
-      observer_id: tx.observer_id,
-      observer_name: tx.observer_name,
-      path_json: tx.path_json,
-      payload_type: tx.payload_type,
-      route_type: tx.route_type,
-      raw_hex: tx.raw_hex,
-      decoded_json: tx.decoded_json,
-      observation_count: tx.observation_count,
-      snr: tx.snr,
-      rssi: tx.rssi,
-    })).sort((a, b) => b.latest.localeCompare(a.latest));
-
-    const total = sorted.length;
-    const paginated = sorted.slice(Number(offset), Number(offset) + Number(limit));
-    return { packets: paginated, total };
-  }
-
-  /** Get timestamps for sparkline */
-  getTimestamps(since) {
-    if (this.sqliteOnly) {
-      return this.db.prepare('SELECT timestamp FROM packets_v WHERE timestamp > ? ORDER BY timestamp ASC').all(since).map(r => r.timestamp);
-    }
-    const results = [];
-    for (const p of this.packets) {
-      if (p.timestamp <= since) break;
-      results.push(p.timestamp);
-    }
-    return results.reverse();
-  }
-
-  /** Get a single packet by ID — checks observation IDs first (backward compat) */
-  getById(id) {
-    if (this.sqliteOnly) return this.db.prepare('SELECT * FROM packets_v WHERE id = ?').get(id) || null;
-    const obs = this.byId.get(id) || null;
-    return this._enrichObs(obs);
-  }
-
-  /** Get a transmission by its transmission table ID */
-  getByTxId(id) {
-    if (this.sqliteOnly) return this.db.prepare('SELECT * FROM transmissions WHERE id = ?').get(id) || null;
-    return this.byTxId.get(id) || null;
-  }
-
-  /** Get all siblings of a packet (same hash) — returns enriched observations array */
-  getSiblings(hash) {
-    const h = hash.toLowerCase();
-    if (this.sqliteOnly) return this.db.prepare('SELECT * FROM packets_v WHERE hash = ? ORDER BY timestamp DESC').all(h);
-    const tx = this.byHash.get(h);
-    return tx ? tx.observations.map(o => this._enrichObs(o)) : [];
-  }
-
-  /** Get all transmissions (backward compat — returns packets array) */
-  all() {
-    if (this.sqliteOnly) return this.db.prepare('SELECT * FROM packets_v ORDER BY timestamp DESC').all();
-    return this.packets;
-  }
-
-  /** Get all transmissions matching a filter function */
-  filter(fn) {
-    if (this.sqliteOnly) return this.db.prepare('SELECT * FROM packets_v ORDER BY timestamp DESC').all().filter(fn);
-    return this.packets.filter(fn);
-  }
-
-  /** Enrich a lean observation with transmission fields (for API responses) */
-  _enrichObs(obs) {
-    if (!obs) return null;
-    const tx = this.byTxId.get(obs.transmission_id);
-    if (!tx) return obs;
-    return {
-      ...obs,
-      hash: tx.hash,
-      raw_hex: tx.raw_hex,
-      payload_type: tx.payload_type,
-      decoded_json: tx.decoded_json,
-      route_type: tx.route_type,
-    };
-  }
-
-  /** Enrich an array of observations with transmission fields */
-  enrichObservations(observations) {
-    if (!observations || !observations.length) return observations;
-    return observations.map(o => this._enrichObs(o));
-  }
-
-  /** Memory stats */
-  getStats() {
-    return {
-      ...this.stats,
-      inMemory: this.sqliteOnly ? 0 : this.packets.length,
-      sqliteOnly: this.sqliteOnly,
-      maxPackets: this.maxPackets,
-      estimatedMB: this.sqliteOnly ? 0 : Math.round(this.packets.length * this.estPacketBytes / 1024 / 1024),
-      maxMB: Math.round(this.maxBytes / 1024 / 1024),
-      indexes: {
-        byHash: this.byHash.size,
-        byObserver: this.byObserver.size,
-        byNode: this.byNode.size,
-        advertByObserver: this._advertByObserver.size,
-      }
-    };
-  }
-
-  /** SQLite fallback: query with filters */
-  _querySQLite({ limit, offset, type, route, region, observer, hash, since, until, node, order }) {
-    const where = []; const params = [];
-    if (type !== undefined) { where.push('payload_type = ?'); params.push(Number(type)); }
-    if (route !== undefined) { where.push('route_type = ?'); params.push(Number(route)); }
-    if (observer) { where.push('observer_id = ?'); params.push(observer); }
-    if (hash) { where.push('hash = ?'); params.push(hash.toLowerCase()); }
-    if (since) { where.push('timestamp > ?'); params.push(since); }
-    if (until) { where.push('timestamp < ?'); params.push(until); }
-    if (region) { where.push('observer_id IN (SELECT id FROM observers WHERE iata = ?)'); params.push(region); }
-    if (node) { try { const nr = this.db.prepare('SELECT public_key FROM nodes WHERE public_key = ? OR name = ? LIMIT 1').get(node, node); const pk = nr ? nr.public_key : node; where.push('decoded_json LIKE ?'); params.push('%' + pk + '%'); } catch(e) { where.push('decoded_json LIKE ?'); params.push('%' + node + '%'); } }
-    const w = where.length ? 'WHERE ' + where.join(' AND ') : '';
-    const total = this.db.prepare(`SELECT COUNT(*) as c FROM packets_v ${w}`).get(...params).c;
-    const packets = this.db.prepare(`SELECT * FROM packets_v ${w} ORDER BY timestamp ${order === 'ASC' ? 'ASC' : 'DESC'} LIMIT ? OFFSET ?`).all(...params, limit, offset);
-    return { packets, total };
-  }
-
-  /** SQLite fallback: grouped query */
-  _queryGroupedSQLite({ limit, offset, type, route, region, observer, hash, since, until, node }) {
-    const where = []; const params = [];
-    if (type !== undefined) { where.push('payload_type = ?'); params.push(Number(type)); }
-    if (route !== undefined) { where.push('route_type = ?'); params.push(Number(route)); }
-    if (observer) { where.push('observer_id = ?'); params.push(observer); }
-    if (hash) { where.push('hash = ?'); params.push(hash.toLowerCase()); }
-    if (since) { where.push('timestamp > ?'); params.push(since); }
-    if (until) { where.push('timestamp < ?'); params.push(until); }
-    if (region) { where.push('observer_id IN (SELECT id FROM observers WHERE iata = ?)'); params.push(region); }
-    if (node) { try { const nr = this.db.prepare('SELECT public_key FROM nodes WHERE public_key = ? OR name = ? LIMIT 1').get(node, node); const pk = nr ? nr.public_key : node; where.push('decoded_json LIKE ?'); params.push('%' + pk + '%'); } catch(e) { where.push('decoded_json LIKE ?'); params.push('%' + node + '%'); } }
-    const w = where.length ? 'WHERE ' + where.join(' AND ') : '';
-
-    const sql = `SELECT hash, COUNT(*) as count, COUNT(DISTINCT observer_id) as observer_count,
-      MAX(timestamp) as latest, MIN(observer_id) as observer_id, MIN(observer_name) as observer_name,
-      MIN(path_json) as path_json, MIN(payload_type) as payload_type, MIN(route_type) as route_type,
-      MIN(raw_hex) as raw_hex, MIN(decoded_json) as decoded_json, MIN(snr) as snr, MIN(rssi) as rssi
-      FROM packets_v ${w} GROUP BY hash ORDER BY latest DESC LIMIT ? OFFSET ?`;
-    const packets = this.db.prepare(sql).all(...params, limit, offset);
-
-    const countSql = `SELECT COUNT(DISTINCT hash) as c FROM packets_v ${w}`;
-    const total = this.db.prepare(countSql).get(...params).c;
-    return { packets, total };
-  }
-}
-
-module.exports = PacketStore;

public/analytics.js

@@ -876,6 +876,26 @@
             </div>`;
             }).join('')}
           </div>
+          ${data.distributionByRepeaters ? (() => {
+            const dr = data.distributionByRepeaters;
+            const totalRepeaters = (dr[1] || 0) + (dr[2] || 0) + (dr[3] || 0);
+            const rpct = (n) => totalRepeaters ? (n / totalRepeaters * 100).toFixed(1) : '0';
+            const maxRepeaters = Math.max(dr[1] || 0, dr[2] || 0, dr[3] || 0, 1);
+            const colors = { 1: '#ef4444', 2: '#22c55e', 3: '#3b82f6' };
+            return `<h4 style="margin:16px 0 4px">By Repeaters</h4>
+              <p class="text-muted">${totalRepeaters.toLocaleString()} unique repeaters</p>
+              <div class="hash-bars">
+                ${[1, 2, 3].map(size => {
+                  const count = dr[size] || 0;
+                  const width = Math.max((count / maxRepeaters) * 100, count ? 2 : 0);
+                  return `<div class="hash-bar-row">
+                  <div class="hash-bar-label"><strong>${size}-byte</strong></div>
+                  <div class="hash-bar-track"><div class="hash-bar-fill" style="width:${width}%;background:${colors[size]};opacity:0.7"></div></div>
+                  <div class="hash-bar-value">${count.toLocaleString()} <span class="text-muted">(${rpct(count)}%)</span></div>
+                </div>`;
+                }).join('')}
+              </div>`;
+          })() : ''}
         </div>
         <div class="analytics-card flex-1">
           <h3>📈 Hash Size Over Time</h3>

public/index.html

@@ -22,9 +22,9 @@
   <meta name="twitter:title" content="CoreScope">
   <meta name="twitter:description" content="Real-time MeshCore LoRa mesh network analyzer — live packet visualization, node tracking, channel decryption, and route analysis.">
   <meta name="twitter:image" content="https://raw.githubusercontent.com/Kpa-clawbot/corescope/master/public/og-image.png">
-  <link rel="stylesheet" href="style.css?v=1774731523">
-  <link rel="stylesheet" href="home.css?v=1774731523">
-  <link rel="stylesheet" href="live.css?v=1774731523">
+  <link rel="stylesheet" href="style.css?v=1774786038">
+  <link rel="stylesheet" href="home.css?v=1774786038">
+  <link rel="stylesheet" href="live.css?v=1774786038">
   <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css"
     integrity="sha256-p4NxAoJBhIIN+hmNHrzRCf9tD/miZyoHS5obTRR9BMY="
     crossorigin="anonymous">
@@ -81,29 +81,29 @@
   <main id="app" role="main"></main>
 
   <script src="vendor/qrcode.js"></script>
-  <script src="roles.js?v=1774731523"></script>
-  <script src="customize.js?v=1774731523" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="region-filter.js?v=1774731523"></script>
-  <script src="hop-resolver.js?v=1774731523"></script>
-  <script src="hop-display.js?v=1774731523"></script>
-  <script src="app.js?v=1774731523"></script>
-  <script src="home.js?v=1774731523"></script>
-  <script src="packet-filter.js?v=1774731523"></script>
-  <script src="packets.js?v=1774731523"></script>
-  <script src="map.js?v=1774731523" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="channels.js?v=1774731523" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="nodes.js?v=1774731523" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="traces.js?v=1774731523" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="analytics.js?v=1774731523" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="audio.js?v=1774731523" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="audio-v1-constellation.js?v=1774731523" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="audio-v2-constellation.js?v=1774731523" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="audio-lab.js?v=1774731523" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="live.js?v=1774731523" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="observers.js?v=1774731523" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="observer-detail.js?v=1774731523" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="compare.js?v=1774731523" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="node-analytics.js?v=1774731523" onerror="console.error('Failed to load:', this.src)"></script>
-  <script src="perf.js?v=1774731523" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="roles.js?v=1774786038"></script>
+  <script src="customize.js?v=1774786038" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="region-filter.js?v=1774786038"></script>
+  <script src="hop-resolver.js?v=1774786038"></script>
+  <script src="hop-display.js?v=1774786038"></script>
+  <script src="app.js?v=1774786038"></script>
+  <script src="home.js?v=1774786038"></script>
+  <script src="packet-filter.js?v=1774786038"></script>
+  <script src="packets.js?v=1774786038"></script>
+  <script src="map.js?v=1774786038" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="channels.js?v=1774786038" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="nodes.js?v=1774786038" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="traces.js?v=1774786038" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="analytics.js?v=1774786039" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="audio.js?v=1774786038" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="audio-v1-constellation.js?v=1774786038" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="audio-v2-constellation.js?v=1774786038" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="audio-lab.js?v=1774786038" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="live.js?v=1774786038" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="observers.js?v=1774786038" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="observer-detail.js?v=1774786038" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="compare.js?v=1774786038" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="node-analytics.js?v=1774786039" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="perf.js?v=1774786038" onerror="console.error('Failed to load:', this.src)"></script>
 </body>
 </html>

public/nodes.js

@@ -89,7 +89,8 @@
 
   function getStatusTooltip(role, status) {
     const isInfra = role === 'repeater' || role === 'room';
-    const threshold = isInfra ? '72h' : '24h';
+    const threshMs = isInfra ? HEALTH_THRESHOLDS.infraSilentMs : HEALTH_THRESHOLDS.nodeSilentMs;
+    const threshold = threshMs >= 3600000 ? Math.round(threshMs / 3600000) + 'h' : Math.round(threshMs / 60000) + 'm';
     if (status === 'active') {
       return 'Active \u2014 heard within the last ' + threshold + '.' + (isInfra ? ' Repeaters typically advertise every 12-24h.' : '');
     }

public/packets.js

@@ -1512,14 +1512,12 @@
       rows += fieldRow(off + 1, 'Sender', decoded.sender || '—', '');
       if (decoded.sender_timestamp) rows += fieldRow(off + 2, 'Sender Time', decoded.sender_timestamp, '');
     } else if (decoded.type === 'ACK') {
-      rows += fieldRow(off, 'Dest Hash (6B)', decoded.destHash || '', '');
-      rows += fieldRow(off + 6, 'Src Hash (6B)', decoded.srcHash || '', '');
-      rows += fieldRow(off + 12, 'Extra (6B)', decoded.extraHash || '', '');
+      rows += fieldRow(off, 'Checksum (4B)', decoded.ackChecksum || '', '');
     } else if (decoded.destHash !== undefined) {
-      rows += fieldRow(off, 'Dest Hash (6B)', decoded.destHash || '', '');
-      rows += fieldRow(off + 6, 'Src Hash (6B)', decoded.srcHash || '', '');
-      rows += fieldRow(off + 12, 'MAC (4B)', decoded.mac || '', '');
-      rows += fieldRow(off + 16, 'Encrypted Data', truncate(decoded.encryptedData || '', 30), '');
+      rows += fieldRow(off, 'Dest Hash (1B)', decoded.destHash || '', '');
+      rows += fieldRow(off + 1, 'Src Hash (1B)', decoded.srcHash || '', '');
+      rows += fieldRow(off + 2, 'MAC (2B)', decoded.mac || '', '');
+      rows += fieldRow(off + 4, 'Encrypted Data', truncate(decoded.encryptedData || '', 30), '');
     } else {
       rows += fieldRow(off, 'Raw', truncate(buf.slice(off * 2), 40), '');
     }

public/perf.js

@@ -40,12 +40,12 @@
           html += `<h3>🔧 Go Runtime</h3><div style="display:flex;gap:16px;flex-wrap:wrap;margin:8px 0;">
             <div class="perf-card"><div class="perf-num">${gr.goroutines}</div><div class="perf-label">Goroutines</div></div>
             <div class="perf-card"><div class="perf-num">${gr.numGC}</div><div class="perf-label">GC Collections</div></div>
-            <div class="perf-card"><div class="perf-num" style="color:${gcColor}">${gr.pauseTotalMs}ms</div><div class="perf-label">GC Pause Total</div></div>
-            <div class="perf-card"><div class="perf-num">${gr.lastPauseMs}ms</div><div class="perf-label">Last GC Pause</div></div>
-            <div class="perf-card"><div class="perf-num">${gr.heapAllocMB}MB</div><div class="perf-label">Heap Alloc</div></div>
-            <div class="perf-card"><div class="perf-num">${gr.heapSysMB}MB</div><div class="perf-label">Heap Sys</div></div>
-            <div class="perf-card"><div class="perf-num">${gr.heapInuseMB}MB</div><div class="perf-label">Heap Inuse</div></div>
-            <div class="perf-card"><div class="perf-num">${gr.heapIdleMB}MB</div><div class="perf-label">Heap Idle</div></div>
+            <div class="perf-card"><div class="perf-num" style="color:${gcColor}">${(+gr.pauseTotalMs).toFixed(1)}ms</div><div class="perf-label">GC Pause Total</div></div>
+            <div class="perf-card"><div class="perf-num">${(+gr.lastPauseMs).toFixed(1)}ms</div><div class="perf-label">Last GC Pause</div></div>
+            <div class="perf-card"><div class="perf-num">${(+gr.heapAllocMB).toFixed(1)}MB</div><div class="perf-label">Heap Alloc</div></div>
+            <div class="perf-card"><div class="perf-num">${(+gr.heapSysMB).toFixed(1)}MB</div><div class="perf-label">Heap Sys</div></div>
+            <div class="perf-card"><div class="perf-num">${(+gr.heapInuseMB).toFixed(1)}MB</div><div class="perf-label">Heap Inuse</div></div>
+            <div class="perf-card"><div class="perf-num">${(+gr.heapIdleMB).toFixed(1)}MB</div><div class="perf-label">Heap Idle</div></div>
             <div class="perf-card"><div class="perf-num">${gr.numCPU}</div><div class="perf-label">CPUs</div></div>
             <div class="perf-card"><div class="perf-num">${health.websocket.clients}</div><div class="perf-label">WS Clients</div></div>
           </div>`;

public/style.css

@@ -155,7 +155,7 @@ a:focus-visible, button:focus-visible, input:focus-visible, select:focus-visible
 /* === Nav Stats === */
 .nav-stats {
   display: flex; gap: 12px; align-items: center; font-size: 12px; color: var(--nav-text-muted);
-  font-family: var(--mono); margin-right: 4px;
+  font-family: var(--mono); margin-right: 4px; white-space: nowrap;
 }
 .nav-stats .stat-val { color: var(--nav-text); font-weight: 600; transition: color 0.3s ease; }
 .nav-stats .stat-val.updated { color: var(--accent); }

scripts/capture-fixture.sh

@@ -0,0 +1,142 @@
+#!/bin/bash
+# Capture a fixture DB from staging for E2E tests
+# Usage: ./scripts/capture-fixture.sh [source_url]
+#
+# Downloads nodes, observers, and recent packets from the staging API
+# and creates a SQLite database suitable for E2E testing.
+
+set -e
+
+SOURCE_URL="${1:-https://analyzer.00id.net}"
+DB_PATH="test-fixtures/e2e-fixture.db"
+
+echo "Capturing fixture from $SOURCE_URL..."
+
+mkdir -p test-fixtures
+rm -f "$DB_PATH"
+
+# Create schema
+sqlite3 "$DB_PATH" <<'SQL'
+CREATE TABLE nodes (
+    public_key TEXT PRIMARY KEY,
+    name TEXT,
+    role TEXT,
+    lat REAL,
+    lon REAL,
+    last_seen TEXT,
+    first_seen TEXT,
+    advert_count INTEGER DEFAULT 0,
+    battery_mv INTEGER,
+    temperature_c REAL
+);
+
+CREATE TABLE observers (
+    id TEXT PRIMARY KEY,
+    name TEXT,
+    iata TEXT,
+    last_seen TEXT,
+    first_seen TEXT,
+    packet_count INTEGER DEFAULT 0,
+    model TEXT,
+    firmware TEXT,
+    client_version TEXT,
+    radio TEXT,
+    battery_mv INTEGER,
+    uptime_secs INTEGER,
+    noise_floor REAL
+);
+
+CREATE TABLE transmissions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    raw_hex TEXT NOT NULL,
+    hash TEXT NOT NULL UNIQUE,
+    first_seen TEXT NOT NULL,
+    route_type INTEGER,
+    payload_type INTEGER,
+    payload_version INTEGER,
+    decoded_json TEXT,
+    created_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE TABLE observations (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    transmission_id INTEGER NOT NULL REFERENCES transmissions(id),
+    observer_idx INTEGER,
+    direction TEXT,
+    snr REAL,
+    rssi REAL,
+    score INTEGER,
+    path_json TEXT,
+    timestamp INTEGER NOT NULL
+);
+SQL
+
+# Fetch nodes
+echo "Fetching nodes..."
+curl -sf "$SOURCE_URL/api/nodes?limit=200" | python3 -c "
+import json, sys, sqlite3
+data = json.load(sys.stdin)
+nodes = data.get('nodes', data) if isinstance(data, dict) else data
+db = sqlite3.connect('$DB_PATH')
+for n in nodes[:200]:
+    db.execute('INSERT OR IGNORE INTO nodes VALUES (?,?,?,?,?,?,?,?,?,?)',
+        (n.get('public_key',''), n.get('name',''), n.get('role',''),
+         n.get('lat'), n.get('lon'), n.get('last_seen',''), n.get('first_seen',''),
+         n.get('advert_count',0), n.get('battery_mv'), n.get('temperature_c')))
+db.commit()
+print(f'  Inserted {min(len(nodes), 200)} nodes')
+db.close()
+"
+
+# Fetch observers
+echo "Fetching observers..."
+curl -sf "$SOURCE_URL/api/observers" | python3 -c "
+import json, sys, sqlite3
+data = json.load(sys.stdin)
+observers = data.get('observers', data) if isinstance(data, dict) else data
+db = sqlite3.connect('$DB_PATH')
+for o in observers:
+    db.execute('INSERT OR IGNORE INTO observers VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)',
+        (o.get('id',''), o.get('name',''), o.get('iata',''),
+         o.get('last_seen',''), o.get('first_seen',''),
+         o.get('packet_count',0), o.get('model',''), o.get('firmware',''),
+         o.get('client_version',''), o.get('radio',''),
+         o.get('battery_mv'), o.get('uptime_secs'), o.get('noise_floor')))
+db.commit()
+print(f'  Inserted {len(observers)} observers')
+db.close()
+"
+
+# Fetch recent packets
+echo "Fetching recent packets..."
+curl -sf "$SOURCE_URL/api/packets?limit=500" | python3 -c "
+import json, sys, sqlite3
+data = json.load(sys.stdin)
+packets = data.get('packets', data) if isinstance(data, dict) else data
+db = sqlite3.connect('$DB_PATH')
+for p in packets:
+    try:
+        cur = db.execute('INSERT OR IGNORE INTO transmissions (raw_hex, hash, first_seen, route_type, payload_type, payload_version, decoded_json) VALUES (?,?,?,?,?,?,?)',
+            (p.get('raw_hex',''), p.get('hash',''), p.get('first_seen',''),
+             p.get('route_type'), p.get('payload_type'), p.get('payload_version'),
+             p.get('decoded_json')))
+        tid = cur.lastrowid
+        if tid and p.get('observer_id'):
+            db.execute('INSERT INTO observations (transmission_id, observer_idx, direction, snr, rssi, score, path_json, timestamp) VALUES (?,?,?,?,?,?,?,?)',
+                (tid, p.get('observer_id'), p.get('direction'),
+                 p.get('snr'), p.get('rssi'), None,
+                 p.get('path_json'),
+                 int(p.get('timestamp','0')) if p.get('timestamp','').isdigit() else 0))
+    except Exception as e:
+        pass  # Skip duplicates
+db.commit()
+print(f'  Inserted {len(packets)} transmissions')
+db.close()
+"
+
+SIZE=$(du -h "$DB_PATH" | cut -f1)
+echo "✅ Fixture DB created: $DB_PATH ($SIZE)"
+echo "   Nodes: $(sqlite3 "$DB_PATH" 'SELECT COUNT(*) FROM nodes')"
+echo "   Observers: $(sqlite3 "$DB_PATH" 'SELECT COUNT(*) FROM observers')"
+echo "   Transmissions: $(sqlite3 "$DB_PATH" 'SELECT COUNT(*) FROM transmissions')"
+echo "   Observations: $(sqlite3 "$DB_PATH" 'SELECT COUNT(*) FROM observations')"

scripts/combined-coverage.sh

@@ -1,27 +1,10 @@
 #!/bin/sh
-# Run server-side tests with c8, then frontend coverage with nyc
+# Combined coverage: Go backend + frontend via Playwright
+# TODO: Update to use Go server binary instead of removed Node.js server.
+# The old flow used `node server.js` — now use the Go binary from cmd/server/.
 set -e
 
-# 1. Server-side coverage (existing)
-npx c8 --reporter=json --reports-dir=.nyc_output node tools/e2e-test.js
-
-# 2. Instrument frontend
-sh scripts/instrument-frontend.sh
-
-# 3. Start instrumented server
-COVERAGE=1 PORT=13581 node server.js &
-SERVER_PID=$!
-sleep 5
-
-# 4. Run Playwright tests (exercises frontend code)
-BASE_URL=http://localhost:13581 node test-e2e-playwright.js || true
-BASE_URL=http://localhost:13581 node test-e2e-interactions.js || true
-
-# 5. Collect browser coverage
-BASE_URL=http://localhost:13581 node scripts/collect-frontend-coverage.js
-
-# 6. Kill server
-kill $SERVER_PID 2>/dev/null || true
-
-# 7. Generate combined report
-npx nyc report --reporter=text-summary --reporter=text
+echo "⚠️  combined-coverage.sh needs updating for Go server migration."
+echo "   The Node.js server (server.js) has been removed."
+echo "   Update this script to start the Go binary instead."
+exit 1

scripts/validate.sh

@@ -3,7 +3,6 @@
 set -e
 
 echo "=== Syntax check ==="
-node -c server.js
 for f in public/*.js; do node -c "$f"; done
 echo "✅ All JS files parse OK"
 

server-helpers.js

@@ -1,322 +0,0 @@
-'use strict';
-
-const path = require('path');
-const fs = require('fs');
-const crypto = require('crypto');
-
-// Config file loading
-const CONFIG_PATHS = [
-  path.join(__dirname, 'config.json'),
-  path.join(__dirname, 'data', 'config.json')
-];
-
-function loadConfigFile(configPaths) {
-  const paths = configPaths || CONFIG_PATHS;
-  for (const p of paths) {
-    try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch {}
-  }
-  return {};
-}
-
-// Theme file loading
-const THEME_PATHS = [
-  path.join(__dirname, 'theme.json'),
-  path.join(__dirname, 'data', 'theme.json')
-];
-
-function loadThemeFile(themePaths) {
-  const paths = themePaths || THEME_PATHS;
-  for (const p of paths) {
-    try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch {}
-  }
-  return {};
-}
-
-// Health thresholds
-function buildHealthConfig(config) {
-  const _ht = (config && config.healthThresholds) || {};
-  return {
-    infraDegradedMs: _ht.infraDegradedMs || 86400000,
-    infraSilentMs:   _ht.infraSilentMs   || 259200000,
-    nodeDegradedMs:  _ht.nodeDegradedMs  || 3600000,
-    nodeSilentMs:    _ht.nodeSilentMs    || 86400000
-  };
-}
-
-function getHealthMs(role, HEALTH) {
-  const isInfra = role === 'repeater' || role === 'room';
-  return {
-    degradedMs: isInfra ? HEALTH.infraDegradedMs : HEALTH.nodeDegradedMs,
-    silentMs:   isInfra ? HEALTH.infraSilentMs   : HEALTH.nodeSilentMs
-  };
-}
-
-// Hash size flip-flop detection (pure — operates on provided maps)
-function isHashSizeFlipFlop(seq, allSizes) {
-  if (!seq || seq.length < 3) return false;
-  if (!allSizes || allSizes.size < 2) return false;
-  let transitions = 0;
-  for (let i = 1; i < seq.length; i++) {
-    if (seq[i] !== seq[i - 1]) transitions++;
-  }
-  return transitions >= 2;
-}
-
-// Compute content hash from raw hex
-function computeContentHash(rawHex) {
-  try {
-    const buf = Buffer.from(rawHex, 'hex');
-    if (buf.length < 2) return rawHex.slice(0, 16);
-    const pathByte = buf[1];
-    const hashSize = ((pathByte >> 6) & 0x3) + 1;
-    const hashCount = pathByte & 0x3F;
-    const pathBytes = hashSize * hashCount;
-    const payloadStart = 2 + pathBytes;
-    const payload = buf.subarray(payloadStart);
-    const toHash = Buffer.concat([Buffer.from([buf[0]]), payload]);
-    return crypto.createHash('sha256').update(toHash).digest('hex').slice(0, 16);
-  } catch { return rawHex.slice(0, 16); }
-}
-
-// Distance helper (degrees)
-function geoDist(lat1, lon1, lat2, lon2) {
-  return Math.sqrt((lat1 - lat2) ** 2 + (lon1 - lon2) ** 2);
-}
-
-// Derive hashtag channel key
-function deriveHashtagChannelKey(channelName) {
-  return crypto.createHash('sha256').update(channelName).digest('hex').slice(0, 32);
-}
-
-// Build hex breakdown ranges for packet detail view
-function buildBreakdown(rawHex, decoded, decodePacketFn, channelKeys) {
-  if (!rawHex) return {};
-  const buf = Buffer.from(rawHex, 'hex');
-  const ranges = [];
-
-  ranges.push({ start: 0, end: 0, color: 'red', label: 'Header' });
-  if (buf.length < 2) return { ranges };
-
-  ranges.push({ start: 1, end: 1, color: 'orange', label: 'Path Length' });
-
-  const header = decodePacketFn ? decodePacketFn(rawHex, channelKeys || {}) : null;
-  let offset = 2;
-
-  if (header && header.transportCodes) {
-    ranges.push({ start: 2, end: 5, color: 'blue', label: 'Transport Codes' });
-    offset = 6;
-  }
-
-  const pathByte = buf[1];
-  const hashSize = (pathByte >> 6) + 1;
-  const hashCount = pathByte & 0x3F;
-  const pathBytes = hashSize * hashCount;
-  if (pathBytes > 0) {
-    ranges.push({ start: offset, end: offset + pathBytes - 1, color: 'green', label: 'Path' });
-  }
-  const payloadStart = offset + pathBytes;
-
-  if (payloadStart < buf.length) {
-    ranges.push({ start: payloadStart, end: buf.length - 1, color: 'yellow', label: 'Payload' });
-
-    if (decoded && decoded.type === 'ADVERT') {
-      const ps = payloadStart;
-      const subRanges = [];
-      subRanges.push({ start: ps, end: ps + 31, color: '#FFD700', label: 'PubKey' });
-      subRanges.push({ start: ps + 32, end: ps + 35, color: '#FFA500', label: 'Timestamp' });
-      subRanges.push({ start: ps + 36, end: ps + 99, color: '#FF6347', label: 'Signature' });
-      if (buf.length > ps + 100) {
-        subRanges.push({ start: ps + 100, end: ps + 100, color: '#7FFFD4', label: 'Flags' });
-        let off = ps + 101;
-        const flags = buf[ps + 100];
-        if (flags & 0x10 && buf.length >= off + 8) {
-          subRanges.push({ start: off, end: off + 3, color: '#87CEEB', label: 'Latitude' });
-          subRanges.push({ start: off + 4, end: off + 7, color: '#87CEEB', label: 'Longitude' });
-          off += 8;
-        }
-        if (flags & 0x80 && off < buf.length) {
-          subRanges.push({ start: off, end: buf.length - 1, color: '#DDA0DD', label: 'Name' });
-        }
-      }
-      ranges.push(...subRanges);
-    }
-  }
-
-  return { ranges };
-}
-
-// Disambiguate hop prefixes to full nodes
-function disambiguateHops(hops, allNodes, maxHopDist) {
-  const MAX_HOP_DIST = maxHopDist || 1.8;
-
-  if (!allNodes._prefixIdx) {
-    allNodes._prefixIdx = {};
-    allNodes._prefixIdxName = {};
-    for (const n of allNodes) {
-      const pk = n.public_key.toLowerCase();
-      for (let len = 1; len <= 3; len++) {
-        const p = pk.slice(0, len * 2);
-        if (!allNodes._prefixIdx[p]) allNodes._prefixIdx[p] = [];
-        allNodes._prefixIdx[p].push(n);
-        if (!allNodes._prefixIdxName[p]) allNodes._prefixIdxName[p] = n;
-      }
-    }
-  }
-
-  const resolved = hops.map(hop => {
-    const h = hop.toLowerCase();
-    const withCoords = (allNodes._prefixIdx[h] || []).filter(n => n.lat && n.lon && !(n.lat === 0 && n.lon === 0));
-    if (withCoords.length === 1) {
-      return { hop, name: withCoords[0].name, lat: withCoords[0].lat, lon: withCoords[0].lon, pubkey: withCoords[0].public_key, known: true };
-    } else if (withCoords.length > 1) {
-      return { hop, name: hop, lat: null, lon: null, pubkey: null, known: false, candidates: withCoords };
-    }
-    const nameMatch = allNodes._prefixIdxName[h];
-    return { hop, name: nameMatch?.name || hop, lat: null, lon: null, pubkey: nameMatch?.public_key || null, known: false };
-  });
-
-  let lastPos = null;
-  for (const r of resolved) {
-    if (r.known && r.lat) { lastPos = [r.lat, r.lon]; continue; }
-    if (!r.candidates) continue;
-    if (lastPos) r.candidates.sort((a, b) => geoDist(a.lat, a.lon, lastPos[0], lastPos[1]) - geoDist(b.lat, b.lon, lastPos[0], lastPos[1]));
-    const best = r.candidates[0];
-    r.name = best.name; r.lat = best.lat; r.lon = best.lon; r.pubkey = best.public_key; r.known = true;
-    lastPos = [r.lat, r.lon];
-  }
-
-  let nextPos = null;
-  for (let i = resolved.length - 1; i >= 0; i--) {
-    const r = resolved[i];
-    if (r.known && r.lat) { nextPos = [r.lat, r.lon]; continue; }
-    if (!r.candidates || !nextPos) continue;
-    r.candidates.sort((a, b) => geoDist(a.lat, a.lon, nextPos[0], nextPos[1]) - geoDist(b.lat, b.lon, nextPos[0], nextPos[1]));
-    const best = r.candidates[0];
-    r.name = best.name; r.lat = best.lat; r.lon = best.lon; r.pubkey = best.public_key; r.known = true;
-    nextPos = [r.lat, r.lon];
-  }
-
-  // Distance sanity check
-  for (let i = 0; i < resolved.length; i++) {
-    const r = resolved[i];
-    if (!r.lat) continue;
-    const prev = i > 0 && resolved[i-1].lat ? resolved[i-1] : null;
-    const next = i < resolved.length-1 && resolved[i+1].lat ? resolved[i+1] : null;
-    if (!prev && !next) continue;
-    const dPrev = prev ? geoDist(r.lat, r.lon, prev.lat, prev.lon) : 0;
-    const dNext = next ? geoDist(r.lat, r.lon, next.lat, next.lon) : 0;
-    if ((prev && dPrev > MAX_HOP_DIST) && (next && dNext > MAX_HOP_DIST)) { r.unreliable = true; r.lat = null; r.lon = null; }
-    else if (prev && !next && dPrev > MAX_HOP_DIST) { r.unreliable = true; r.lat = null; r.lon = null; }
-    else if (!prev && next && dNext > MAX_HOP_DIST) { r.unreliable = true; r.lat = null; r.lon = null; }
-  }
-
-  return resolved.map(r => ({ hop: r.hop, name: r.name, lat: r.lat, lon: r.lon, pubkey: r.pubkey, known: !!r.known, ambiguous: !!r.candidates, unreliable: !!r.unreliable }));
-}
-
-// Update hash_size maps for a single packet
-function updateHashSizeForPacket(p, hashSizeMap, hashSizeAllMap, hashSizeSeqMap) {
-  if (p.payload_type === 4 && p.raw_hex) {
-    try {
-      const d = typeof p.decoded_json === 'string' ? JSON.parse(p.decoded_json || '{}') : (p.decoded_json || {});
-      const pk = d.pubKey || d.public_key;
-      if (pk) {
-        const pathByte = parseInt(p.raw_hex.slice(2, 4), 16);
-        const hs = ((pathByte >> 6) & 0x3) + 1;
-        hashSizeMap.set(pk, hs);
-        if (!hashSizeAllMap.has(pk)) hashSizeAllMap.set(pk, new Set());
-        hashSizeAllMap.get(pk).add(hs);
-        if (!hashSizeSeqMap.has(pk)) hashSizeSeqMap.set(pk, []);
-        hashSizeSeqMap.get(pk).push(hs);
-      }
-    } catch {}
-  } else if (p.path_json && p.decoded_json) {
-    try {
-      const d = typeof p.decoded_json === 'string' ? JSON.parse(p.decoded_json) : p.decoded_json;
-      const pk = d.pubKey || d.public_key;
-      if (pk && !hashSizeMap.has(pk)) {
-        const hops = typeof p.path_json === 'string' ? JSON.parse(p.path_json) : p.path_json;
-        if (hops.length > 0) {
-          const pathByte = p.raw_hex ? parseInt(p.raw_hex.slice(2, 4), 16) : -1;
-          const hs = pathByte >= 0 ? ((pathByte >> 6) & 0x3) + 1 : (hops[0].length / 2);
-          if (hs >= 1 && hs <= 4) hashSizeMap.set(pk, hs);
-        }
-      }
-    } catch {}
-  }
-}
-
-// Rebuild all hash size maps from packet store
-function rebuildHashSizeMap(packets, hashSizeMap, hashSizeAllMap, hashSizeSeqMap) {
-  hashSizeMap.clear();
-  hashSizeAllMap.clear();
-  hashSizeSeqMap.clear();
-
-  // Pass 1: ADVERT packets
-  for (const p of packets) {
-    if (p.payload_type === 4 && p.raw_hex) {
-      try {
-        const d = JSON.parse(p.decoded_json || '{}');
-        const pk = d.pubKey || d.public_key;
-        if (pk) {
-          const pathByte = parseInt(p.raw_hex.slice(2, 4), 16);
-          const hs = ((pathByte >> 6) & 0x3) + 1;
-          if (!hashSizeMap.has(pk)) hashSizeMap.set(pk, hs);
-          if (!hashSizeAllMap.has(pk)) hashSizeAllMap.set(pk, new Set());
-          hashSizeAllMap.get(pk).add(hs);
-          if (!hashSizeSeqMap.has(pk)) hashSizeSeqMap.set(pk, []);
-          hashSizeSeqMap.get(pk).push(hs);
-        }
-      } catch {}
-    }
-  }
-  for (const [, seq] of hashSizeSeqMap) seq.reverse();
-
-  // Pass 2: fallback from path hops
-  for (const p of packets) {
-    if (p.path_json) {
-      try {
-        const hops = JSON.parse(p.path_json);
-        if (hops.length > 0) {
-          const hopLen = hops[0].length / 2;
-          if (hopLen >= 1 && hopLen <= 4) {
-            const pathByte = p.raw_hex ? parseInt(p.raw_hex.slice(2, 4), 16) : -1;
-            const hs = pathByte >= 0 ? ((pathByte >> 6) & 0x3) + 1 : hopLen;
-            if (p.decoded_json) {
-              const d = JSON.parse(p.decoded_json);
-              const pk = d.pubKey || d.public_key;
-              if (pk && !hashSizeMap.has(pk)) hashSizeMap.set(pk, hs);
-            }
-          }
-        }
-      } catch {}
-    }
-  }
-}
-
-// API key middleware factory
-function requireApiKey(apiKey) {
-  return function(req, res, next) {
-    if (!apiKey) return next();
-    const provided = req.headers['x-api-key'] || req.query.apiKey;
-    if (provided === apiKey) return next();
-    return res.status(401).json({ error: 'Invalid or missing API key' });
-  };
-}
-
-module.exports = {
-  loadConfigFile,
-  loadThemeFile,
-  buildHealthConfig,
-  getHealthMs,
-  isHashSizeFlipFlop,
-  computeContentHash,
-  geoDist,
-  deriveHashtagChannelKey,
-  buildBreakdown,
-  disambiguateHops,
-  updateHashSizeForPacket,
-  rebuildHashSizeMap,
-  requireApiKey,
-  CONFIG_PATHS,
-  THEME_PATHS
-};

test-all.sh

@@ -9,27 +9,12 @@ echo ""
 
 # Unit tests (deterministic, fast)
 echo "── Unit Tests ──"
-node test-decoder.js
-node test-decoder-spec.js
-node test-packet-store.js
 node test-packet-filter.js
 node test-aging.js
 node test-frontend-helpers.js
-node test-regional-filter.js
-node test-server-helpers.js
-node test-server-routes.js
-node test-db.js
-node test-db-migration.js
-
-# Integration tests (spin up temp servers)
-echo ""
-echo "── Integration Tests ──"
-node tools/e2e-test.js
-node tools/frontend-test.js
+node test-perf-go-runtime.js
 
 echo ""
 echo "═══════════════════════════════════════"
 echo "  All tests passed"
 echo "═══════════════════════════════════════"
-node test-server-routes.js
-# test trigger

test-db-migration.js

@@ -1,321 +0,0 @@
-'use strict';
-
-// Test v3 migration: create old-schema DB, run db.js to migrate, verify results
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-const { execSync } = require('child_process');
-const Database = require('better-sqlite3');
-
-let passed = 0, failed = 0;
-function assert(cond, msg) {
-  if (cond) { passed++; console.log(`  ✅ ${msg}`); }
-  else { failed++; console.error(`  ❌ ${msg}`); }
-}
-
-console.log('── db.js v3 migration tests ──\n');
-
-// Helper: create a DB with old (v2) schema and test data
-function createOldSchemaDB(dbPath) {
-  const db = new Database(dbPath);
-  db.pragma('journal_mode = WAL');
-  db.pragma('foreign_keys = ON');
-
-  db.exec(`
-    CREATE TABLE nodes (
-      public_key TEXT PRIMARY KEY,
-      name TEXT,
-      role TEXT,
-      lat REAL,
-      lon REAL,
-      last_seen TEXT,
-      first_seen TEXT,
-      advert_count INTEGER DEFAULT 0
-    );
-
-    CREATE TABLE observers (
-      id TEXT PRIMARY KEY,
-      name TEXT,
-      iata TEXT,
-      last_seen TEXT,
-      first_seen TEXT,
-      packet_count INTEGER DEFAULT 0,
-      model TEXT,
-      firmware TEXT,
-      client_version TEXT,
-      radio TEXT,
-      battery_mv INTEGER,
-      uptime_secs INTEGER,
-      noise_floor INTEGER
-    );
-
-    CREATE TABLE transmissions (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      raw_hex TEXT NOT NULL,
-      hash TEXT NOT NULL UNIQUE,
-      first_seen TEXT NOT NULL,
-      route_type INTEGER,
-      payload_type INTEGER,
-      payload_version INTEGER,
-      decoded_json TEXT,
-      created_at TEXT DEFAULT (datetime('now'))
-    );
-
-    CREATE TABLE observations (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      transmission_id INTEGER NOT NULL REFERENCES transmissions(id),
-      hash TEXT NOT NULL,
-      observer_id TEXT,
-      observer_name TEXT,
-      direction TEXT,
-      snr REAL,
-      rssi REAL,
-      score INTEGER,
-      path_json TEXT,
-      timestamp TEXT NOT NULL,
-      created_at TEXT DEFAULT (datetime('now'))
-    );
-
-    CREATE INDEX idx_transmissions_hash ON transmissions(hash);
-    CREATE INDEX idx_observations_hash ON observations(hash);
-    CREATE INDEX idx_observations_transmission_id ON observations(transmission_id);
-    CREATE INDEX idx_observations_observer_id ON observations(observer_id);
-    CREATE INDEX idx_observations_timestamp ON observations(timestamp);
-    CREATE UNIQUE INDEX idx_observations_dedup ON observations(hash, observer_id, COALESCE(path_json, ''));
-  `);
-
-  // Insert test observers
-  db.prepare(`INSERT INTO observers (id, name, iata, last_seen, first_seen, packet_count) VALUES (?, ?, ?, ?, ?, ?)`).run(
-    'aabbccdd11223344aabbccdd11223344aabbccdd11223344aabbccdd11223344', 'Observer Alpha', 'SFO',
-    '2025-06-01T12:00:00Z', '2025-01-01T00:00:00Z', 100
-  );
-  db.prepare(`INSERT INTO observers (id, name, iata, last_seen, first_seen, packet_count) VALUES (?, ?, ?, ?, ?, ?)`).run(
-    'deadbeef12345678deadbeef12345678deadbeef12345678deadbeef12345678', 'Observer Beta', 'LAX',
-    '2025-06-01T11:00:00Z', '2025-02-01T00:00:00Z', 50
-  );
-
-  // Insert test transmissions
-  db.prepare(`INSERT INTO transmissions (raw_hex, hash, first_seen, route_type, payload_type, decoded_json) VALUES (?, ?, ?, ?, ?, ?)`).run(
-    '0400aabbccdd', 'hash-mig-001', '2025-06-01T10:00:00Z', 1, 4, '{"type":"ADVERT"}'
-  );
-  db.prepare(`INSERT INTO transmissions (raw_hex, hash, first_seen, route_type, payload_type, decoded_json) VALUES (?, ?, ?, ?, ?, ?)`).run(
-    '0400deadbeef', 'hash-mig-002', '2025-06-01T10:30:00Z', 2, 5, '{"type":"GRP_TXT"}'
-  );
-
-  // Insert test observations (old schema: has hash, observer_id, observer_name, text timestamp)
-  db.prepare(`INSERT INTO observations (transmission_id, hash, observer_id, observer_name, direction, snr, rssi, score, path_json, timestamp) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(
-    1, 'hash-mig-001', 'aabbccdd11223344aabbccdd11223344aabbccdd11223344aabbccdd11223344', 'Observer Alpha',
-    'rx', 12.5, -80, 85, '["aabb","ccdd"]', '2025-06-01T10:00:00Z'
-  );
-  db.prepare(`INSERT INTO observations (transmission_id, hash, observer_id, observer_name, direction, snr, rssi, score, path_json, timestamp) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(
-    1, 'hash-mig-001', 'deadbeef12345678deadbeef12345678deadbeef12345678deadbeef12345678', 'Observer Beta',
-    'rx', 8.0, -92, 70, '["aabb"]', '2025-06-01T10:01:00Z'
-  );
-  db.prepare(`INSERT INTO observations (transmission_id, hash, observer_id, observer_name, direction, snr, rssi, score, path_json, timestamp) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(
-    2, 'hash-mig-002', 'aabbccdd11223344aabbccdd11223344aabbccdd11223344aabbccdd11223344', 'Observer Alpha',
-    'rx', 15.0, -75, 90, null, '2025-06-01T10:30:00Z'
-  );
-
-  db.close();
-}
-
-// Helper: require db.js in a child process with a given DB_PATH, return schema info
-function runDbModule(dbPath) {
-  const scriptPath = path.join(os.tmpdir(), 'meshcore-mig-test-script.js');
-  fs.writeFileSync(scriptPath, `
-    process.env.DB_PATH = ${JSON.stringify(dbPath)};
-    const db = require(${JSON.stringify(path.resolve(__dirname, 'db'))});
-    const cols = db.db.pragma('table_info(observations)').map(c => c.name);
-    const sv = db.db.pragma('user_version', { simple: true });
-    const obsCount = db.db.prepare('SELECT COUNT(*) as c FROM observations').get().c;
-    const viewRows = db.db.prepare('SELECT * FROM packets_v ORDER BY id').all();
-    const rawObs = db.db.prepare('SELECT * FROM observations ORDER BY id').all();
-    console.log(JSON.stringify({
-      columns: cols,
-      schemaVersion: sv || 0,
-      obsCount,
-      viewRows,
-      rawObs
-    }));
-    db.db.close();
-  `);
-  const result = execSync(`node ${JSON.stringify(scriptPath)}`, {
-    cwd: __dirname,
-    encoding: 'utf8',
-    timeout: 30000,
-  });
-  fs.unlinkSync(scriptPath);
-  const lines = result.trim().split('\n');
-  for (let i = lines.length - 1; i >= 0; i--) {
-    try { return JSON.parse(lines[i]); } catch {}
-  }
-  throw new Error('No JSON output from child process: ' + result);
-}
-
-// --- Test 1: Migration from old schema ---
-console.log('Migration from old schema:');
-{
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'meshcore-mig-test-'));
-  const dbPath = path.join(tmpDir, 'test-mig.db');
-
-  createOldSchemaDB(dbPath);
-
-  // Run db.js which should trigger migration
-  const info = runDbModule(dbPath);
-
-  // Verify schema
-  assert(info.schemaVersion === 3, 'schema version is 3 after migration');
-  assert(info.columns.includes('observer_idx'), 'has observer_idx column');
-  assert(!info.columns.includes('observer_id'), 'no observer_id column');
-  assert(!info.columns.includes('observer_name'), 'no observer_name column');
-  assert(!info.columns.includes('hash'), 'no hash column');
-
-  // Verify row count
-  assert(info.obsCount === 3, `all 3 rows migrated (got ${info.obsCount})`);
-
-  // Verify raw observation data
-  const obs0 = info.rawObs[0];
-  assert(typeof obs0.timestamp === 'number', 'timestamp is integer');
-  assert(obs0.timestamp === Math.floor(new Date('2025-06-01T10:00:00Z').getTime() / 1000), 'timestamp epoch correct');
-  assert(obs0.observer_idx !== null, 'observer_idx populated');
-
-  // Verify view backward compat
-  const vr0 = info.viewRows[0];
-  assert(vr0.observer_id === 'aabbccdd11223344aabbccdd11223344aabbccdd11223344aabbccdd11223344', 'view observer_id correct');
-  assert(vr0.observer_name === 'Observer Alpha', 'view observer_name correct');
-  assert(typeof vr0.timestamp === 'string', 'view timestamp is string');
-  assert(vr0.hash === 'hash-mig-001', 'view hash correct');
-  assert(vr0.snr === 12.5, 'view snr correct');
-  assert(vr0.path_json === '["aabb","ccdd"]', 'view path_json correct');
-
-  // Third row has null path_json
-  const vr2 = info.viewRows[2];
-  assert(vr2.path_json === null, 'null path_json preserved');
-
-  // Verify backup file created
-  const backups1 = fs.readdirSync(tmpDir).filter(f => f.includes('.pre-v3-backup-'));
-  assert(backups1.length === 1, 'backup file exists');
-
-  fs.rmSync(tmpDir, { recursive: true });
-}
-
-// --- Test 2: Migration doesn't re-run ---
-console.log('\nMigration idempotency:');
-{
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'meshcore-mig-test2-'));
-  const dbPath = path.join(tmpDir, 'test-mig2.db');
-
-  createOldSchemaDB(dbPath);
-
-  // First run — triggers migration
-  let info = runDbModule(dbPath);
-  assert(info.schemaVersion === 3, 'first run migrates to v3');
-
-  // Second run — should NOT re-run migration (no backup overwrite, same data)
-  const backups2pre = fs.readdirSync(tmpDir).filter(f => f.includes('.pre-v3-backup-'));
-  const backupMtime = fs.statSync(path.join(tmpDir, backups2pre[0])).mtimeMs;
-  info = runDbModule(dbPath);
-  assert(info.schemaVersion === 3, 'second run still v3');
-  assert(info.obsCount === 3, 'rows still intact');
-
-  fs.rmSync(tmpDir, { recursive: true });
-}
-
-// --- Test 3: Each migration creates a unique backup ---
-console.log('\nUnique backup per migration:');
-{
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'meshcore-mig-test3-'));
-  const dbPath = path.join(tmpDir, 'test-mig3.db');
-
-  createOldSchemaDB(dbPath);
-
-  const info = runDbModule(dbPath);
-
-  // Migration should have completed
-  assert(info.columns.includes('observer_idx'), 'migration completed');
-  assert(info.schemaVersion === 3, 'schema version is 3');
-
-  // A timestamped backup should exist
-  const backups = fs.readdirSync(tmpDir).filter(f => f.includes('.pre-v3-backup-'));
-  assert(backups.length === 1, 'exactly one backup created');
-  assert(fs.statSync(path.join(tmpDir, backups[0])).size > 0, 'backup is non-empty');
-
-  fs.rmSync(tmpDir, { recursive: true });
-}
-
-// --- Test 4: v3 ingestion via child process ---
-console.log('\nv3 ingestion test:');
-{
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'meshcore-mig-test4-'));
-  const dbPath = path.join(tmpDir, 'test-v3-ingest.db');
-
-  const scriptPath = path.join(os.tmpdir(), 'meshcore-ingest-test-script.js');
-  fs.writeFileSync(scriptPath, `
-    process.env.DB_PATH = ${JSON.stringify(dbPath)};
-    const db = require(${JSON.stringify(path.resolve(__dirname, 'db'))});
-
-    db.upsertObserver({ id: 'test-obs', name: 'Test Obs' });
-
-    const r = db.insertTransmission({
-      raw_hex: '0400ff',
-      hash: 'h-001',
-      timestamp: '2025-06-01T12:00:00Z',
-      observer_id: 'test-obs',
-      observer_name: 'Test Obs',
-      direction: 'rx',
-      snr: 10,
-      rssi: -85,
-      path_json: '["aa"]',
-      route_type: 1,
-      payload_type: 4,
-    });
-
-    const r2 = db.insertTransmission({
-      raw_hex: '0400ff',
-      hash: 'h-001',
-      timestamp: '2025-06-01T12:00:00Z',
-      observer_id: 'test-obs',
-      direction: 'rx',
-      snr: 10,
-      rssi: -85,
-      path_json: '["aa"]',
-    });
-
-    const pkt = db.db.prepare('SELECT * FROM packets_v WHERE hash = ?').get('h-001');
-
-    console.log(JSON.stringify({
-      r1_ok: r !== null && r.transmissionId > 0,
-      r2_deduped: r2.observationId === 0,
-      obs_count: db.db.prepare('SELECT COUNT(*) as c FROM observations').get().c,
-      view_observer_id: pkt.observer_id,
-      view_observer_name: pkt.observer_name,
-      view_ts_type: typeof pkt.timestamp,
-    }));
-    db.db.close();
-  `);
-
-  const result = execSync(`node ${JSON.stringify(scriptPath)}`, {
-    cwd: __dirname, encoding: 'utf8', timeout: 30000,
-  });
-  fs.unlinkSync(scriptPath);
-  const lines = result.trim().split('\n');
-  let info;
-  for (let i = lines.length - 1; i >= 0; i--) {
-    try { info = JSON.parse(lines[i]); break; } catch {}
-  }
-
-  assert(info.r1_ok, 'first insertion succeeded');
-  assert(info.r2_deduped, 'duplicate caught by dedup');
-  assert(info.obs_count === 1, 'only one observation row');
-  assert(info.view_observer_id === 'test-obs', 'view resolves observer_id');
-  assert(info.view_observer_name === 'Test Obs', 'view resolves observer_name');
-  assert(info.view_ts_type === 'string', 'view timestamp is string');
-
-  fs.rmSync(tmpDir, { recursive: true });
-}
-
-console.log(`\n═══════════════════════════════════════`);
-console.log(`  PASSED: ${passed}`);
-console.log(`  FAILED: ${failed}`);
-console.log(`═══════════════════════════════════════`);
-if (failed > 0) process.exit(1);

test-db.js

@@ -1,512 +0,0 @@
-'use strict';
-
-// Test db.js functions with a temp database
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'meshcore-db-test-'));
-const dbPath = path.join(tmpDir, 'test.db');
-process.env.DB_PATH = dbPath;
-
-// Now require db.js — it will use our temp DB
-const db = require('./db');
-
-let passed = 0, failed = 0;
-function assert(cond, msg) {
-  if (cond) { passed++; console.log(`  ✅ ${msg}`); }
-  else { failed++; console.error(`  ❌ ${msg}`); }
-}
-
-function cleanup() {
-  try { db.db.close(); } catch {}
-  try { fs.rmSync(tmpDir, { recursive: true }); } catch {}
-}
-
-console.log('── db.js tests ──\n');
-
-// --- Schema ---
-console.log('Schema:');
-{
-  const tables = db.db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map(r => r.name);
-  assert(tables.includes('nodes'), 'nodes table exists');
-  assert(tables.includes('observers'), 'observers table exists');
-  assert(tables.includes('transmissions'), 'transmissions table exists');
-  assert(tables.includes('observations'), 'observations table exists');
-}
-
-// --- upsertNode ---
-console.log('\nupsertNode:');
-{
-  db.upsertNode({ public_key: 'aabbccdd11223344aabbccdd11223344', name: 'TestNode', role: 'repeater', lat: 37.0, lon: -122.0 });
-  const node = db.getNode('aabbccdd11223344aabbccdd11223344');
-  assert(node !== null, 'node inserted');
-  assert(node.name === 'TestNode', 'name correct');
-  assert(node.role === 'repeater', 'role correct');
-  assert(node.lat === 37.0, 'lat correct');
-
-  // Update
-  db.upsertNode({ public_key: 'aabbccdd11223344aabbccdd11223344', name: 'UpdatedNode', role: 'room' });
-  const node2 = db.getNode('aabbccdd11223344aabbccdd11223344');
-  assert(node2.name === 'UpdatedNode', 'name updated');
-  assert(node2.name === 'UpdatedNode', 'name updated');
-  assert(node2.advert_count === 0, 'advert_count unchanged by upsertNode');
-
-  // advert_count only increments via incrementAdvertCount
-  db.incrementAdvertCount('aabbccdd11223344aabbccdd11223344');
-  const node3 = db.getNode('aabbccdd11223344aabbccdd11223344');
-  assert(node3.advert_count === 1, 'advert_count incremented via incrementAdvertCount');
-}
-
-// --- upsertObserver ---
-console.log('\nupsertObserver:');
-{
-  db.upsertObserver({ id: 'obs-1', name: 'Observer One', iata: 'SFO' });
-  const observers = db.getObservers();
-  assert(observers.length >= 1, 'observer inserted');
-  assert(observers.some(o => o.id === 'obs-1'), 'observer found by id');
-  assert(observers.find(o => o.id === 'obs-1').name === 'Observer One', 'observer name correct');
-
-  // Upsert again
-  db.upsertObserver({ id: 'obs-1', name: 'Observer Updated' });
-  const obs2 = db.getObservers().find(o => o.id === 'obs-1');
-  assert(obs2.name === 'Observer Updated', 'observer name updated');
-  assert(obs2.packet_count === 2, 'packet_count incremented');
-}
-
-// --- updateObserverStatus ---
-console.log('\nupdateObserverStatus:');
-{
-  db.updateObserverStatus({ id: 'obs-2', name: 'Status Observer', iata: 'LAX', model: 'T-Deck' });
-  const obs = db.getObservers().find(o => o.id === 'obs-2');
-  assert(obs !== null, 'observer created via status update');
-  assert(obs.model === 'T-Deck', 'model set');
-  assert(obs.packet_count === 0, 'packet_count stays 0 for status update');
-}
-
-// --- insertTransmission ---
-console.log('\ninsertTransmission:');
-{
-  const result = db.insertTransmission({
-    raw_hex: '0400aabbccdd',
-    hash: 'hash-001',
-    timestamp: '2025-01-01T00:00:00Z',
-    observer_id: 'obs-1',
-    observer_name: 'Observer One',
-    direction: 'rx',
-    snr: 10.5,
-    rssi: -85,
-    route_type: 1,
-    payload_type: 4,
-    payload_version: 1,
-    path_json: '["aabb","ccdd"]',
-    decoded_json: '{"type":"ADVERT","pubKey":"aabbccdd11223344aabbccdd11223344","name":"TestNode"}',
-  });
-  assert(result !== null, 'transmission inserted');
-  assert(result.transmissionId > 0, 'has transmissionId');
-  assert(result.observationId > 0, 'has observationId');
-
-  // Duplicate hash = same transmission, new observation
-  const result2 = db.insertTransmission({
-    raw_hex: '0400aabbccdd',
-    hash: 'hash-001',
-    timestamp: '2025-01-01T00:01:00Z',
-    observer_id: 'obs-2',
-    observer_name: 'Observer Two',
-    direction: 'rx',
-    snr: 8.0,
-    rssi: -90,
-    route_type: 1,
-    payload_type: 4,
-    path_json: '["aabb"]',
-    decoded_json: '{"type":"ADVERT","pubKey":"aabbccdd11223344aabbccdd11223344","name":"TestNode"}',
-  });
-  assert(result2.transmissionId === result.transmissionId, 'same transmissionId for duplicate hash');
-
-  // No hash = null
-  const result3 = db.insertTransmission({ raw_hex: '0400' });
-  assert(result3 === null, 'no hash returns null');
-}
-
-// --- getPackets ---
-console.log('\ngetPackets:');
-{
-  const { rows, total } = db.getPackets({ limit: 10 });
-  assert(total >= 1, 'has packets');
-  assert(rows.length >= 1, 'returns rows');
-  assert(rows[0].hash === 'hash-001', 'correct hash');
-
-  // Filter by type
-  const { rows: r2 } = db.getPackets({ type: 4 });
-  assert(r2.length >= 1, 'filter by type works');
-
-  const { rows: r3 } = db.getPackets({ type: 99 });
-  assert(r3.length === 0, 'filter by nonexistent type returns empty');
-
-  // Filter by hash
-  const { rows: r4 } = db.getPackets({ hash: 'hash-001' });
-  assert(r4.length >= 1, 'filter by hash works');
-}
-
-// --- getPacket ---
-console.log('\ngetPacket:');
-{
-  const { rows } = db.getPackets({ limit: 1 });
-  const pkt = db.getPacket(rows[0].id);
-  assert(pkt !== null, 'getPacket returns packet');
-  assert(pkt.hash === 'hash-001', 'correct packet');
-
-  const missing = db.getPacket(999999);
-  assert(missing === null, 'missing packet returns null');
-}
-
-// --- getTransmission ---
-console.log('\ngetTransmission:');
-{
-  const tx = db.getTransmission(1);
-  assert(tx !== null, 'getTransmission returns data');
-  assert(tx.hash === 'hash-001', 'correct hash');
-
-  const missing = db.getTransmission(999999);
-  assert(missing === null, 'missing transmission returns null');
-}
-
-// --- getNodes ---
-console.log('\ngetNodes:');
-{
-  const { rows, total } = db.getNodes({ limit: 10 });
-  assert(total >= 1, 'has nodes');
-  assert(rows.length >= 1, 'returns node rows');
-
-  // Sort by name
-  const { rows: r2 } = db.getNodes({ sortBy: 'name' });
-  assert(r2.length >= 1, 'sort by name works');
-
-  // Invalid sort falls back to last_seen
-  const { rows: r3 } = db.getNodes({ sortBy: 'DROP TABLE nodes' });
-  assert(r3.length >= 1, 'invalid sort is safe');
-}
-
-// --- getNode ---
-console.log('\ngetNode:');
-{
-  const node = db.getNode('aabbccdd11223344aabbccdd11223344');
-  assert(node !== null, 'getNode returns node');
-  assert(Array.isArray(node.recentPackets), 'has recentPackets');
-
-  const missing = db.getNode('nonexistent');
-  assert(missing === null, 'missing node returns null');
-}
-
-// --- searchNodes ---
-console.log('\nsearchNodes:');
-{
-  const results = db.searchNodes('Updated');
-  assert(results.length >= 1, 'search by name');
-
-  const r2 = db.searchNodes('aabbcc');
-  assert(r2.length >= 1, 'search by pubkey prefix');
-
-  const r3 = db.searchNodes('nonexistent_xyz');
-  assert(r3.length === 0, 'no results for nonexistent');
-}
-
-// --- getStats ---
-console.log('\ngetStats:');
-{
-  const stats = db.getStats();
-  assert(stats.totalNodes >= 1, 'totalNodes');
-  assert(stats.totalObservers >= 1, 'totalObservers');
-  assert(typeof stats.totalPackets === 'number', 'totalPackets is number');
-  assert(typeof stats.packetsLastHour === 'number', 'packetsLastHour is number');
-  assert(typeof stats.totalNodesAllTime === 'number', 'totalNodesAllTime is number');
-  assert(stats.totalNodesAllTime >= stats.totalNodes, 'totalNodesAllTime >= totalNodes');
-}
-
-// --- getStats active node filtering ---
-console.log('\ngetStats active node filtering:');
-{
-  // Insert a node with last_seen 30 days ago (should be excluded from totalNodes)
-  const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 3600000).toISOString();
-  db.upsertNode({ public_key: 'deadnode0000000000000000deadnode00', name: 'DeadNode', role: 'repeater', last_seen: thirtyDaysAgo, first_seen: thirtyDaysAgo });
-
-  // Insert a node with last_seen now (should be included)
-  db.upsertNode({ public_key: 'livenode0000000000000000livenode00', name: 'LiveNode', role: 'companion', last_seen: new Date().toISOString() });
-
-  const stats = db.getStats();
-  assert(stats.totalNodesAllTime > stats.totalNodes, 'dead node excluded from totalNodes but included in totalNodesAllTime');
-
-  // Verify the dead node is in totalNodesAllTime
-  const allTime = stats.totalNodesAllTime;
-  assert(allTime >= 3, 'totalNodesAllTime includes dead + live nodes');
-
-  // Verify active count doesn't include the 30-day-old node
-  // The dead node's last_seen is 30 days ago, window is 7 days
-  const nodeInDb = db.getNode('deadnode0000000000000000deadnode00');
-  assert(nodeInDb !== null, 'dead node exists in DB');
-  const liveNode = db.getNode('livenode0000000000000000livenode00');
-  assert(liveNode !== null, 'live node exists in DB');
-}
-
-// --- getNodeHealth ---
-console.log('\ngetNodeHealth:');
-{
-  const health = db.getNodeHealth('aabbccdd11223344aabbccdd11223344');
-  assert(health !== null, 'returns health data');
-  assert(health.node.name === 'UpdatedNode', 'has node info');
-  assert(typeof health.stats.totalPackets === 'number', 'has totalPackets stat');
-  assert(Array.isArray(health.observers), 'has observers array');
-  assert(Array.isArray(health.recentPackets), 'has recentPackets array');
-
-  const missing = db.getNodeHealth('nonexistent');
-  assert(missing === null, 'missing node returns null');
-}
-
-// --- getNodeAnalytics ---
-console.log('\ngetNodeAnalytics:');
-{
-  const analytics = db.getNodeAnalytics('aabbccdd11223344aabbccdd11223344', 7);
-  assert(analytics !== null, 'returns analytics');
-  assert(analytics.node.name === 'UpdatedNode', 'has node info');
-  assert(Array.isArray(analytics.activityTimeline), 'has activityTimeline');
-  assert(Array.isArray(analytics.snrTrend), 'has snrTrend');
-  assert(Array.isArray(analytics.packetTypeBreakdown), 'has packetTypeBreakdown');
-  assert(Array.isArray(analytics.observerCoverage), 'has observerCoverage');
-  assert(Array.isArray(analytics.hopDistribution), 'has hopDistribution');
-  assert(Array.isArray(analytics.peerInteractions), 'has peerInteractions');
-  assert(Array.isArray(analytics.uptimeHeatmap), 'has uptimeHeatmap');
-  assert(typeof analytics.computedStats.availabilityPct === 'number', 'has availabilityPct');
-  assert(typeof analytics.computedStats.signalGrade === 'string', 'has signalGrade');
-
-  const missing = db.getNodeAnalytics('nonexistent', 7);
-  assert(missing === null, 'missing node returns null');
-}
-
-// --- seed ---
-console.log('\nseed:');
-{
-  if (typeof db.seed === 'function') {
-    // Already has data, should return false
-    const result = db.seed();
-    assert(result === false, 'seed returns false when data exists');
-  } else {
-    console.log('  (skipped — seed not exported)');
-  }
-}
-
-// --- v3 schema tests (fresh DB should be v3) ---
-console.log('\nv3 schema:');
-{
-  assert(db.schemaVersion >= 3, 'fresh DB creates v3 schema');
-
-  // observations table should have observer_idx, not observer_id
-  const cols = db.db.pragma('table_info(observations)').map(c => c.name);
-  assert(cols.includes('observer_idx'), 'observations has observer_idx column');
-  assert(!cols.includes('observer_id'), 'observations does NOT have observer_id column');
-  assert(!cols.includes('observer_name'), 'observations does NOT have observer_name column');
-  assert(!cols.includes('hash'), 'observations does NOT have hash column');
-  assert(!cols.includes('created_at'), 'observations does NOT have created_at column');
-
-  // timestamp should be integer
-  const obsRow = db.db.prepare('SELECT typeof(timestamp) as t FROM observations LIMIT 1').get();
-  if (obsRow) {
-    assert(obsRow.t === 'integer', 'timestamp is stored as integer');
-  }
-
-  // packets_v view should still expose observer_id, observer_name, ISO timestamp
-  const viewRow = db.db.prepare('SELECT * FROM packets_v LIMIT 1').get();
-  if (viewRow) {
-    assert('observer_id' in viewRow, 'packets_v exposes observer_id');
-    assert('observer_name' in viewRow, 'packets_v exposes observer_name');
-    assert(typeof viewRow.timestamp === 'string', 'packets_v timestamp is ISO string');
-  }
-
-  // user_version is 3
-  const sv = db.db.pragma('user_version', { simple: true });
-  assert(sv === 3, 'user_version is 3');
-}
-
-// --- v3 ingestion: observer resolved via observer_idx ---
-console.log('\nv3 ingestion with observer resolution:');
-{
-  // Insert a new observer
-  db.upsertObserver({ id: 'obs-v3-test', name: 'V3 Test Observer' });
-
-  // Insert observation referencing that observer
-  const result = db.insertTransmission({
-    raw_hex: '0400deadbeef',
-    hash: 'hash-v3-001',
-    timestamp: '2025-06-01T12:00:00Z',
-    observer_id: 'obs-v3-test',
-    observer_name: 'V3 Test Observer',
-    direction: 'rx',
-    snr: 12.0,
-    rssi: -80,
-    route_type: 1,
-    payload_type: 4,
-    path_json: '["aabb"]',
-  });
-  assert(result !== null, 'v3 insertion succeeded');
-  assert(result.transmissionId > 0, 'v3 has transmissionId');
-
-  // Verify via packets_v view
-  const pkt = db.db.prepare('SELECT * FROM packets_v WHERE hash = ?').get('hash-v3-001');
-  assert(pkt !== null, 'v3 packet found via view');
-  assert(pkt.observer_id === 'obs-v3-test', 'v3 observer_id resolved in view');
-  assert(pkt.observer_name === 'V3 Test Observer', 'v3 observer_name resolved in view');
-  assert(typeof pkt.timestamp === 'string', 'v3 timestamp is ISO string in view');
-  assert(pkt.timestamp.includes('2025-06-01'), 'v3 timestamp date correct');
-
-  // Raw observation should have integer timestamp
-  const obs = db.db.prepare('SELECT * FROM observations ORDER BY id DESC LIMIT 1').get();
-  assert(typeof obs.timestamp === 'number', 'v3 raw observation timestamp is integer');
-  assert(obs.observer_idx !== null, 'v3 observation has observer_idx');
-}
-
-// --- v3 dedup ---
-console.log('\nv3 dedup:');
-{
-  // Insert same observation again — should be deduped
-  const result = db.insertTransmission({
-    raw_hex: '0400deadbeef',
-    hash: 'hash-v3-001',
-    timestamp: '2025-06-01T12:00:00Z',
-    observer_id: 'obs-v3-test',
-    direction: 'rx',
-    snr: 12.0,
-    rssi: -80,
-    path_json: '["aabb"]',
-  });
-  assert(result.observationId === 0, 'duplicate caught by in-memory dedup');
-
-  // Different observer = not a dupe
-  db.upsertObserver({ id: 'obs-v3-test-2', name: 'V3 Test Observer 2' });
-  const result2 = db.insertTransmission({
-    raw_hex: '0400deadbeef',
-    hash: 'hash-v3-001',
-    timestamp: '2025-06-01T12:01:00Z',
-    observer_id: 'obs-v3-test-2',
-    direction: 'rx',
-    snr: 9.0,
-    rssi: -88,
-    path_json: '["ccdd"]',
-  });
-  assert(result2.observationId > 0, 'different observer is not a dupe');
-}
-
-// --- removePhantomNodes ---
-console.log('\nremovePhantomNodes:');
-{
-  // Insert phantom nodes (short public_keys like hop prefixes)
-  db.upsertNode({ public_key: 'aabb', name: null, role: 'repeater' });
-  db.upsertNode({ public_key: 'ccddee', name: null, role: 'repeater' });
-  db.upsertNode({ public_key: 'ff001122', name: null, role: 'repeater' });
-  db.upsertNode({ public_key: '0011223344556677', name: null, role: 'repeater' }); // 16 chars — still phantom
-
-  // Verify they exist
-  assert(db.getNode('aabb') !== null, 'phantom node aabb exists before cleanup');
-  assert(db.getNode('ccddee') !== null, 'phantom node ccddee exists before cleanup');
-  assert(db.getNode('ff001122') !== null, 'phantom node ff001122 exists before cleanup');
-  assert(db.getNode('0011223344556677') !== null, 'phantom 16-char exists before cleanup');
-
-  // Verify real node still exists
-  assert(db.getNode('aabbccdd11223344aabbccdd11223344') !== null, 'real node exists before cleanup');
-
-  // Run cleanup
-  const removed = db.removePhantomNodes();
-  assert(removed === 4, `removed 4 phantom nodes (got ${removed})`);
-
-  // Verify phantoms are gone
-  assert(db.getNode('aabb') === null, 'phantom aabb removed');
-  assert(db.getNode('ccddee') === null, 'phantom ccddee removed');
-  assert(db.getNode('ff001122') === null, 'phantom ff001122 removed');
-  assert(db.getNode('0011223344556677') === null, 'phantom 16-char removed');
-
-  // Verify real node is still there
-  assert(db.getNode('aabbccdd11223344aabbccdd11223344') !== null, 'real node preserved after cleanup');
-
-  // Running again should remove 0
-  const removed2 = db.removePhantomNodes();
-  assert(removed2 === 0, 'second cleanup removes nothing');
-}
-
-// --- stats exclude phantom nodes ---
-console.log('\nstats exclude phantom nodes:');
-{
-  const statsBefore = db.getStats();
-  const countBefore = statsBefore.totalNodesAllTime;
-
-  // Insert a phantom — should be cleanable
-  db.upsertNode({ public_key: 'deadbeef', name: null, role: 'repeater' });
-  const statsWithPhantom = db.getStats();
-  assert(statsWithPhantom.totalNodesAllTime === countBefore + 1, 'phantom inflates totalNodesAllTime');
-
-  // Clean it
-  db.removePhantomNodes();
-  const statsAfter = db.getStats();
-  assert(statsAfter.totalNodesAllTime === countBefore, 'phantom removed from totalNodesAllTime');
-}
-
-// --- moveStaleNodes ---
-console.log('\nmoveStaleNodes:');
-{
-  // Verify inactive_nodes table exists
-  const tables = db.db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map(r => r.name);
-  assert(tables.includes('inactive_nodes'), 'inactive_nodes table exists');
-
-  // Verify inactive_nodes has same columns as nodes
-  const nodesCols = db.db.pragma('table_info(nodes)').map(c => c.name).sort();
-  const inactiveCols = db.db.pragma('table_info(inactive_nodes)').map(c => c.name).sort();
-  assert(JSON.stringify(nodesCols) === JSON.stringify(inactiveCols), 'inactive_nodes has same columns as nodes');
-
-  // Insert a stale node (last_seen 30 days ago) and a fresh node
-  const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 3600000).toISOString();
-  const now = new Date().toISOString();
-  db.upsertNode({ public_key: 'stale00000000000000000000stale000', name: 'StaleNode', role: 'repeater', last_seen: thirtyDaysAgo, first_seen: thirtyDaysAgo });
-  db.upsertNode({ public_key: 'fresh00000000000000000000fresh000', name: 'FreshNode', role: 'companion', last_seen: now, first_seen: now });
-
-  // Verify both exist in nodes
-  assert(db.getNode('stale00000000000000000000stale000') !== null, 'stale node exists before move');
-  assert(db.getNode('fresh00000000000000000000fresh000') !== null, 'fresh node exists before move');
-
-  // Move stale nodes (7 day threshold)
-  const moved = db.moveStaleNodes(7);
-  assert(moved >= 1, `moveStaleNodes moved at least 1 node (got ${moved})`);
-
-  // Stale node should be gone from nodes
-  assert(db.getNode('stale00000000000000000000stale000') === null, 'stale node removed from nodes');
-
-  // Fresh node should still be in nodes
-  assert(db.getNode('fresh00000000000000000000fresh000') !== null, 'fresh node still in nodes');
-
-  // Stale node should be in inactive_nodes
-  const inactive = db.db.prepare('SELECT * FROM inactive_nodes WHERE public_key = ?').get('stale00000000000000000000stale000');
-  assert(inactive !== null, 'stale node exists in inactive_nodes');
-  assert(inactive.name === 'StaleNode', 'stale node name preserved in inactive_nodes');
-  assert(inactive.role === 'repeater', 'stale node role preserved in inactive_nodes');
-
-  // Fresh node should NOT be in inactive_nodes
-  const freshInactive = db.db.prepare('SELECT * FROM inactive_nodes WHERE public_key = ?').get('fresh00000000000000000000fresh000');
-  assert(!freshInactive, 'fresh node not in inactive_nodes');
-
-  // Running again should move 0 (already moved)
-  const moved2 = db.moveStaleNodes(7);
-  assert(moved2 === 0, 'second moveStaleNodes moves nothing');
-
-  // With nodeDays=0 should be a no-op
-  const moved3 = db.moveStaleNodes(0);
-  assert(moved3 === 0, 'moveStaleNodes(0) is a no-op');
-
-  // With null should be a no-op
-  const moved4 = db.moveStaleNodes(null);
-  assert(moved4 === 0, 'moveStaleNodes(null) is a no-op');
-}
-
-cleanup();
-delete process.env.DB_PATH;
-
-console.log(`\n═══════════════════════════════════════`);
-console.log(`  PASSED: ${passed}`);
-console.log(`  FAILED: ${failed}`);
-console.log(`═══════════════════════════════════════`);
-if (failed > 0) process.exit(1);

test-decoder-spec.js

@@ -1,624 +0,0 @@
-/**
- * Spec-driven tests for MeshCore decoder.
- *
- * Section 1: Spec assertions (from firmware/docs/packet_format.md + payloads.md)
- * Section 2: Golden fixtures (from production data at analyzer.00id.net)
- */
-
-'use strict';
-
-const { decodePacket, validateAdvert, ROUTE_TYPES, PAYLOAD_TYPES } = require('./decoder');
-
-let passed = 0;
-let failed = 0;
-let noted = 0;
-
-function assert(condition, msg) {
-  if (condition) { passed++; }
-  else { failed++; console.error(`  FAIL: ${msg}`); }
-}
-
-function assertEq(actual, expected, msg) {
-  if (actual === expected) { passed++; }
-  else { failed++; console.error(`  FAIL: ${msg} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`); }
-}
-
-function assertDeepEq(actual, expected, msg) {
-  const a = JSON.stringify(actual);
-  const b = JSON.stringify(expected);
-  if (a === b) { passed++; }
-  else { failed++; console.error(`  FAIL: ${msg}\n    expected: ${b}\n    got:      ${a}`); }
-}
-
-function note(msg) {
-  noted++;
-  console.log(`  NOTE: ${msg}`);
-}
-
-// ═══════════════════════════════════════════════════════════
-// Section 1: Spec-based assertions
-// ═══════════════════════════════════════════════════════════
-
-console.log('── Spec Tests: Header Parsing ──');
-
-// Header byte: bits 1-0 = routeType, bits 5-2 = payloadType, bits 7-6 = payloadVersion
-{
-  // 0x11 = 0b00_0100_01 → routeType=1(FLOOD), payloadType=4(ADVERT), version=0
-  const p = decodePacket('1100' + '00'.repeat(101)); // min advert = 100 bytes payload
-  assertEq(p.header.routeType, 1, 'header: routeType from bits 1-0');
-  assertEq(p.header.payloadType, 4, 'header: payloadType from bits 5-2');
-  assertEq(p.header.payloadVersion, 0, 'header: payloadVersion from bits 7-6');
-  assertEq(p.header.routeTypeName, 'FLOOD', 'header: routeTypeName');
-  assertEq(p.header.payloadTypeName, 'ADVERT', 'header: payloadTypeName');
-}
-
-// All four route types
-{
-  const routeNames = { 0: 'TRANSPORT_FLOOD', 1: 'FLOOD', 2: 'DIRECT', 3: 'TRANSPORT_DIRECT' };
-  for (const [val, name] of Object.entries(routeNames)) {
-    assertEq(ROUTE_TYPES[val], name, `ROUTE_TYPES[${val}] = ${name}`);
-  }
-}
-
-// All payload types from spec
-{
-  const specTypes = {
-    0x00: 'REQ', 0x01: 'RESPONSE', 0x02: 'TXT_MSG', 0x03: 'ACK',
-    0x04: 'ADVERT', 0x05: 'GRP_TXT', 0x07: 'ANON_REQ',
-    0x08: 'PATH', 0x09: 'TRACE',
-  };
-  for (const [val, name] of Object.entries(specTypes)) {
-    assertEq(PAYLOAD_TYPES[val], name, `PAYLOAD_TYPES[${val}] = ${name}`);
-  }
-}
-
-// Spec defines 0x06=GRP_DATA, 0x0A=MULTIPART, 0x0B=CONTROL, 0x0F=RAW_CUSTOM — decoder may not have them
-{
-  if (!PAYLOAD_TYPES[0x06]) note('Decoder missing PAYLOAD_TYPE 0x06 (GRP_DATA) — spec defines it');
-  if (!PAYLOAD_TYPES[0x0A]) note('Decoder missing PAYLOAD_TYPE 0x0A (MULTIPART) — spec defines it');
-  if (!PAYLOAD_TYPES[0x0B]) note('Decoder missing PAYLOAD_TYPE 0x0B (CONTROL) — spec defines it');
-  if (!PAYLOAD_TYPES[0x0F]) note('Decoder missing PAYLOAD_TYPE 0x0F (RAW_CUSTOM) — spec defines it');
-}
-
-console.log('── Spec Tests: Path Byte Parsing ──');
-
-// path_length: bits 5-0 = hop count, bits 7-6 = hash_size - 1
-{
-  // 0x00: 0 hops, 1-byte hashes
-  const p0 = decodePacket('0500' + '00'.repeat(10));
-  assertEq(p0.path.hashCount, 0, 'path 0x00: hashCount=0');
-  assertEq(p0.path.hashSize, 1, 'path 0x00: hashSize=1');
-  assertDeepEq(p0.path.hops, [], 'path 0x00: no hops');
-}
-
-{
-  // 0x05: 5 hops, 1-byte hashes → 5 path bytes
-  const p5 = decodePacket('0505' + 'AABBCCDDEE' + '00'.repeat(10));
-  assertEq(p5.path.hashCount, 5, 'path 0x05: hashCount=5');
-  assertEq(p5.path.hashSize, 1, 'path 0x05: hashSize=1');
-  assertEq(p5.path.hops.length, 5, 'path 0x05: 5 hops');
-  assertEq(p5.path.hops[0], 'AA', 'path 0x05: first hop');
-  assertEq(p5.path.hops[4], 'EE', 'path 0x05: last hop');
-}
-
-{
-  // 0x45: 5 hops, 2-byte hashes (bits 7-6 = 01) → 10 path bytes
-  const p45 = decodePacket('0545' + 'AA11BB22CC33DD44EE55' + '00'.repeat(10));
-  assertEq(p45.path.hashCount, 5, 'path 0x45: hashCount=5');
-  assertEq(p45.path.hashSize, 2, 'path 0x45: hashSize=2');
-  assertEq(p45.path.hops.length, 5, 'path 0x45: 5 hops');
-  assertEq(p45.path.hops[0], 'AA11', 'path 0x45: first hop (2-byte)');
-}
-
-{
-  // 0x8A: 10 hops, 3-byte hashes (bits 7-6 = 10) → 30 path bytes
-  const p8a = decodePacket('058A' + 'AA11FF'.repeat(10) + '00'.repeat(10));
-  assertEq(p8a.path.hashCount, 10, 'path 0x8A: hashCount=10');
-  assertEq(p8a.path.hashSize, 3, 'path 0x8A: hashSize=3');
-  assertEq(p8a.path.hops.length, 10, 'path 0x8A: 10 hops');
-}
-
-console.log('── Spec Tests: Transport Codes ──');
-
-{
-  // Route type 0 (TRANSPORT_FLOOD) and 3 (TRANSPORT_DIRECT) should have 4-byte transport codes
-  // Route type 0: header byte = 0bPPPPPP00, e.g. 0x14 = payloadType 5 (GRP_TXT), routeType 0
-  const hex = '1400' + 'AABB' + 'CCDD' + '1A' + '00'.repeat(10); // transport codes + GRP_TXT payload
-  const p = decodePacket(hex);
-  assertEq(p.header.routeType, 0, 'transport: routeType=0 (TRANSPORT_FLOOD)');
-  assert(p.transportCodes !== null, 'transport: transportCodes present for TRANSPORT_FLOOD');
-  assertEq(p.transportCodes.nextHop, 'AABB', 'transport: nextHop');
-  assertEq(p.transportCodes.lastHop, 'CCDD', 'transport: lastHop');
-}
-
-{
-  // Route type 1 (FLOOD) should NOT have transport codes
-  const p = decodePacket('0500' + '00'.repeat(10));
-  assertEq(p.transportCodes, null, 'no transport codes for FLOOD');
-}
-
-console.log('── Spec Tests: Advert Payload ──');
-
-// Advert: pubkey(32) + timestamp(4 LE) + signature(64) + appdata
-{
-  const pubkey = 'AA'.repeat(32);
-  const timestamp = '78563412'; // 0x12345678 LE = 305419896
-  const signature = 'BB'.repeat(64);
-  // flags: 0x92 = repeater(2) | hasLocation(0x10) | hasName(0x80)
-  const flags = '92';
-  // lat: 37000000 = 0x02353A80 LE → 80 3A 35 02
-  const lat = '40933402';
-  // lon: -122100000 = 0xF8B9E260 LE → 60 E2 B9 F8
-  const lon = 'E0E6B8F8';
-  const name = Buffer.from('TestNode').toString('hex');
-
-  const hex = '1200' + pubkey + timestamp + signature + flags + lat + lon + name;
-  const p = decodePacket(hex);
-
-  assertEq(p.payload.type, 'ADVERT', 'advert: payload type');
-  assertEq(p.payload.pubKey, pubkey.toLowerCase(), 'advert: 32-byte pubkey');
-  assertEq(p.payload.timestamp, 0x12345678, 'advert: uint32 LE timestamp');
-  assertEq(p.payload.signature, signature.toLowerCase().repeat(1), 'advert: 64-byte signature');
-
-  // Flags
-  assertEq(p.payload.flags.raw, 0x92, 'advert flags: raw byte');
-  assertEq(p.payload.flags.type, 2, 'advert flags: type enum = 2 (repeater)');
-  assertEq(p.payload.flags.repeater, true, 'advert flags: repeater');
-  assertEq(p.payload.flags.room, false, 'advert flags: not room');
-  assertEq(p.payload.flags.chat, false, 'advert flags: not chat');
-  assertEq(p.payload.flags.sensor, false, 'advert flags: not sensor');
-  assertEq(p.payload.flags.hasLocation, true, 'advert flags: hasLocation (bit 4)');
-  assertEq(p.payload.flags.hasName, true, 'advert flags: hasName (bit 7)');
-
-  // Location: int32 at 1e6 scale
-  assert(Math.abs(p.payload.lat - 37.0) < 0.001, 'advert: lat decoded from int32/1e6');
-  assert(Math.abs(p.payload.lon - (-122.1)) < 0.001, 'advert: lon decoded from int32/1e6');
-
-  // Name
-  assertEq(p.payload.name, 'TestNode', 'advert: name from remaining appdata');
-}
-
-// Advert type enum values per spec
-{
-  // type 0 = none (companion), 1 = chat/companion, 2 = repeater, 3 = room, 4 = sensor
-  const makeAdvert = (flagsByte) => {
-    const hex = '1200' + 'AA'.repeat(32) + '00000000' + 'BB'.repeat(64) + flagsByte.toString(16).padStart(2, '0');
-    return decodePacket(hex).payload;
-  };
-
-  const t1 = makeAdvert(0x01);
-  assertEq(t1.flags.type, 1, 'advert type 1 = chat/companion');
-  assertEq(t1.flags.chat, true, 'type 1: chat=true');
-
-  const t2 = makeAdvert(0x02);
-  assertEq(t2.flags.type, 2, 'advert type 2 = repeater');
-  assertEq(t2.flags.repeater, true, 'type 2: repeater=true');
-
-  const t3 = makeAdvert(0x03);
-  assertEq(t3.flags.type, 3, 'advert type 3 = room');
-  assertEq(t3.flags.room, true, 'type 3: room=true');
-
-  const t4 = makeAdvert(0x04);
-  assertEq(t4.flags.type, 4, 'advert type 4 = sensor');
-  assertEq(t4.flags.sensor, true, 'type 4: sensor=true');
-}
-
-// Advert with no location, no name (flags = 0x02, just repeater)
-{
-  const hex = '1200' + 'CC'.repeat(32) + '00000000' + 'DD'.repeat(64) + '02';
-  const p = decodePacket(hex).payload;
-  assertEq(p.flags.hasLocation, false, 'advert no location: hasLocation=false');
-  assertEq(p.flags.hasName, false, 'advert no name: hasName=false');
-  assertEq(p.lat, undefined, 'advert no location: lat undefined');
-  assertEq(p.name, undefined, 'advert no name: name undefined');
-}
-
-// Telemetry: sensor node with battery + positive temperature
-{
-  const pubkey = 'AA'.repeat(32);
-  const sig = 'BB'.repeat(64);
-  const flags = '84'; // sensor(4) | hasName(0x80)
-  const name = Buffer.from('S1').toString('hex') + '00'; // null-terminated
-  const battBuf = Buffer.alloc(2); battBuf.writeUInt16LE(3700);
-  const tempBuf = Buffer.alloc(2); tempBuf.writeInt16LE(2850); // 28.50°C
-  const hex = '1200' + pubkey + '00000000' + sig + flags + name +
-    battBuf.toString('hex') + tempBuf.toString('hex');
-  const p = decodePacket(hex).payload;
-  assertEq(p.battery_mv, 3700, 'telemetry: battery_mv decoded');
-  assert(Math.abs(p.temperature_c - 28.50) < 0.01, 'telemetry: temperature_c positive');
-}
-
-// Telemetry: sensor node with 0°C must still emit temperature_c
-{
-  const pubkey = 'CC'.repeat(32);
-  const sig = 'DD'.repeat(64);
-  const flags = '84'; // sensor(4) | hasName(0x80)
-  const name = Buffer.from('S2').toString('hex') + '00';
-  const battBuf = Buffer.alloc(2); battBuf.writeUInt16LE(3600);
-  const tempBuf = Buffer.alloc(2); // 0°C
-  const hex = '1200' + pubkey + '00000000' + sig + flags + name +
-    battBuf.toString('hex') + tempBuf.toString('hex');
-  const p = decodePacket(hex).payload;
-  assert(p.temperature_c === 0, 'telemetry: 0°C is valid and emitted');
-}
-
-// Telemetry: non-sensor node with trailing bytes must NOT decode telemetry
-{
-  const pubkey = 'EE'.repeat(32);
-  const sig = 'FF'.repeat(64);
-  const flags = '82'; // repeater(2) | hasName(0x80)
-  const name = Buffer.from('R1').toString('hex') + '00';
-  const extraBytes = 'B40ED403'; // battery-like and temp-like bytes
-  const hex = '1200' + pubkey + '00000000' + sig + flags + name + extraBytes;
-  const p = decodePacket(hex).payload;
-  assertEq(p.battery_mv, undefined, 'telemetry: non-sensor node: battery_mv must be undefined');
-  assertEq(p.temperature_c, undefined, 'telemetry: non-sensor node: temperature_c must be undefined');
-}
-
-console.log('── Spec Tests: Encrypted Payload Format ──');
-
-// NOTE: Spec says v1 encrypted payloads have dest(1) + src(1) + MAC(2) + ciphertext
-// But decoder reads dest(6) + src(6) + MAC(4) + ciphertext
-// This is a known discrepancy — the decoder matches production behavior, not the spec.
-// The spec may describe the firmware's internal addressing while the OTA format differs,
-// or the decoder may be parsing the fields differently. Production data validates the decoder.
-{
-  note('Spec says v1 encrypted payloads: dest(1)+src(1)+MAC(2)+cipher, but decoder reads dest(6)+src(6)+MAC(4)+cipher — decoder matches prod data');
-}
-
-console.log('── Spec Tests: validateAdvert ──');
-
-{
-  const good = { pubKey: 'aa'.repeat(32), flags: { repeater: true, room: false, sensor: false } };
-  assertEq(validateAdvert(good).valid, true, 'validateAdvert: good advert');
-
-  assertEq(validateAdvert(null).valid, false, 'validateAdvert: null');
-  assertEq(validateAdvert({ error: 'bad' }).valid, false, 'validateAdvert: error advert');
-  assertEq(validateAdvert({ pubKey: 'aa' }).valid, false, 'validateAdvert: short pubkey');
-  assertEq(validateAdvert({ pubKey: '00'.repeat(32) }).valid, false, 'validateAdvert: all-zero pubkey');
-
-  const badLat = { pubKey: 'aa'.repeat(32), lat: 999 };
-  assertEq(validateAdvert(badLat).valid, false, 'validateAdvert: invalid lat');
-
-  const badLon = { pubKey: 'aa'.repeat(32), lon: -999 };
-  assertEq(validateAdvert(badLon).valid, false, 'validateAdvert: invalid lon');
-
-  const badName = { pubKey: 'aa'.repeat(32), name: 'test\x00name' };
-  assertEq(validateAdvert(badName).valid, false, 'validateAdvert: control chars in name');
-
-  const longName = { pubKey: 'aa'.repeat(32), name: 'x'.repeat(65) };
-  assertEq(validateAdvert(longName).valid, false, 'validateAdvert: name too long');
-}
-
-// ═══════════════════════════════════════════════════════════
-// Section 2: Golden fixtures (from production)
-// ═══════════════════════════════════════════════════════════
-
-console.log('── Golden Tests: Production Packets ──');
-
-const goldenFixtures = [
-  {
-    "raw_hex": "0A00D69FD7A5A7475DB07337749AE61FA53A4788E976",
-    "payload_type": 2,
-    "route_type": 2,
-    "decoded": "{\"type\":\"TXT_MSG\",\"destHash\":\"d6\",\"srcHash\":\"9f\",\"mac\":\"d7a5\",\"encryptedData\":\"a7475db07337749ae61fa53a4788e976\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 0,
-      "hops": []
-    }
-  },
-  {
-    "raw_hex": "0A009FD605771EE2EB0CDC46D100232B455947E3C2D4B9DD0B8880EACA99A3C5F7EF63183D6D",
-    "payload_type": 2,
-    "route_type": 2,
-    "decoded": "{\"type\":\"TXT_MSG\",\"destHash\":\"9f\",\"srcHash\":\"d6\",\"mac\":\"0577\",\"encryptedData\":\"1ee2eb0cdc46d100232b455947e3c2d4b9dd0b8880eaca99a3c5f7ef63183d6d\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 0,
-      "hops": []
-    }
-  },
-  {
-    "raw_hex": "120046D62DE27D4C5194D7821FC5A34A45565DCC2537B300B9AB6275255CEFB65D840CE5C169C94C9AED39E8BCB6CB6EB0335497A198B33A1A610CD3B03D8DCFC160900E5244280323EE0B44CACAB8F02B5B38B91CFA18BD067B0B5E63E94CFC85F758A8530B9240933402E0E6B8F84D5252322D52",
-    "payload_type": 4,
-    "route_type": 2,
-    "decoded": "{\"type\":\"ADVERT\",\"pubKey\":\"46d62de27d4c5194d7821fc5a34a45565dcc2537b300b9ab6275255cefb65d84\",\"timestamp\":1774314764,\"timestampISO\":\"2026-03-24T01:12:44.000Z\",\"signature\":\"c94c9aed39e8bcb6cb6eb0335497a198b33a1a610cd3b03d8dcfc160900e5244280323ee0b44cacab8f02b5b38b91cfa18bd067b0b5e63e94cfc85f758a8530b\",\"flags\":{\"raw\":146,\"type\":2,\"chat\":false,\"repeater\":true,\"room\":false,\"sensor\":false,\"hasLocation\":true,\"hasName\":true},\"lat\":37,\"lon\":-122.1,\"name\":\"MRR2-R\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 0,
-      "hops": []
-    }
-  },
-  {
-    "raw_hex": "120073CFF971E1CB5754A742C152B2D2E0EB108A19B246D663ED8898A72C4A5AD86EA6768E66694B025EDF6939D5C44CFF719C5D5520E5F06B20680A83AD9C2C61C3227BBB977A85EE462F3553445FECF8EDD05C234ECE217272E503F14D6DF2B1B9B133890C923CDF3002F8FDC1F85045414BF09F8CB3",
-    "payload_type": 4,
-    "route_type": 2,
-    "decoded": "{\"type\":\"ADVERT\",\"pubKey\":\"73cff971e1cb5754a742c152b2d2e0eb108a19b246d663ed8898a72c4a5ad86e\",\"timestamp\":1720612518,\"timestampISO\":\"2024-07-10T11:55:18.000Z\",\"signature\":\"694b025edf6939d5c44cff719c5d5520e5f06b20680a83ad9c2c61c3227bbb977a85ee462f3553445fecf8edd05c234ece217272e503f14d6df2b1b9b133890c\",\"flags\":{\"raw\":146,\"type\":2,\"chat\":false,\"repeater\":true,\"room\":false,\"sensor\":false,\"hasLocation\":true,\"hasName\":true},\"lat\":36.757308,\"lon\":-121.504264,\"name\":\"PEAK🌳\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 0,
-      "hops": []
-    }
-  },
-  {
-    "raw_hex": "06001f33e1bef15f5596b394adf03a77d46b89afa2e3",
-    "payload_type": 1,
-    "route_type": 2,
-    "decoded": "{\"type\":\"RESPONSE\",\"destHash\":\"1f\",\"srcHash\":\"33\",\"mac\":\"e1be\",\"encryptedData\":\"f15f5596b394adf03a77d46b89afa2e3\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 0,
-      "hops": []
-    }
-  },
-  {
-    "raw_hex": "0200331fe52805e05cf6f4bae6a094ac258d57baf045",
-    "payload_type": 0,
-    "route_type": 2,
-    "decoded": "{\"type\":\"REQ\",\"destHash\":\"33\",\"srcHash\":\"1f\",\"mac\":\"e528\",\"encryptedData\":\"05e05cf6f4bae6a094ac258d57baf045\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 0,
-      "hops": []
-    }
-  },
-  {
-    "raw_hex": "15001ABC314305D3CCC94EB3F398D3054B4E95899229027B027E450FD68B4FA4E0A0126AC1",
-    "payload_type": 5,
-    "route_type": 1,
-    "decoded": "{\"type\":\"GRP_TXT\",\"channelHash\":26,\"mac\":\"bc31\",\"encryptedData\":\"4305d3ccc94eb3f398d3054b4e95899229027b027e450fd68b4fa4e0a0126ac1\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 0,
-      "hops": []
-    }
-  },
-  {
-    "raw_hex": "010673a210206cb51e42fee24c4847a99208b9fc1d7ab36c42b10748",
-    "payload_type": 0,
-    "route_type": 1,
-    "decoded": "{\"type\":\"REQ\",\"destHash\":\"1e\",\"srcHash\":\"42\",\"mac\":\"fee2\",\"encryptedData\":\"4c4847a99208b9fc1d7ab36c42b10748\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 6,
-      "hops": [
-        "73",
-        "A2",
-        "10",
-        "20",
-        "6C",
-        "B5"
-      ]
-    }
-  },
-  {
-    "raw_hex": "0101731E42FEE24C4847A99208293810E4A3E335640D8E",
-    "payload_type": 0,
-    "route_type": 1,
-    "decoded": "{\"type\":\"REQ\",\"destHash\":\"1e\",\"srcHash\":\"42\",\"mac\":\"fee2\",\"encryptedData\":\"4c4847a99208293810e4a3e335640d8e\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 1,
-      "hops": [
-        "73"
-      ]
-    }
-  },
-  {
-    "raw_hex": "0106FB10844070101E42BA859D1D939362F79D3F3865333629FF92E9",
-    "payload_type": 0,
-    "route_type": 1,
-    "decoded": "{\"type\":\"REQ\",\"destHash\":\"1e\",\"srcHash\":\"42\",\"mac\":\"ba85\",\"encryptedData\":\"9d1d939362f79d3f3865333629ff92e9\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 6,
-      "hops": [
-        "FB",
-        "10",
-        "84",
-        "40",
-        "70",
-        "10"
-      ]
-    }
-  },
-  {
-    "raw_hex": "0102FB101E42BA859D1D939362F79D3F3865333629FF92D9",
-    "payload_type": 0,
-    "route_type": 1,
-    "decoded": "{\"type\":\"REQ\",\"destHash\":\"1e\",\"srcHash\":\"42\",\"mac\":\"ba85\",\"encryptedData\":\"9d1d939362f79d3f3865333629ff92d9\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 2,
-      "hops": [
-        "FB",
-        "10"
-      ]
-    }
-  },
-  {
-    "raw_hex": "22009FD65B38857C5A7F6F0F28E999CF2632C03ACCCC",
-    "payload_type": 8,
-    "route_type": 2,
-    "decoded": "{\"type\":\"PATH\",\"destHash\":\"9f\",\"srcHash\":\"d6\",\"mac\":\"5b38\",\"pathData\":\"857c5a7f6f0f28e999cf2632c03acccc\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 0,
-      "hops": []
-    }
-  },
-  {
-    "raw_hex": "0506701085AD8573D69F96FA7DD3B1AC3702794035442D9CDAD436D4",
-    "payload_type": 1,
-    "route_type": 1,
-    "decoded": "{\"type\":\"RESPONSE\",\"destHash\":\"d6\",\"srcHash\":\"9f\",\"mac\":\"96fa\",\"encryptedData\":\"7dd3b1ac3702794035442d9cdad436d4\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 6,
-      "hops": [
-        "70",
-        "10",
-        "85",
-        "AD",
-        "85",
-        "73"
-      ]
-    }
-  },
-  {
-    "raw_hex": "0500D69F96FA7DD3B1AC3702794035442D9CDAD43654",
-    "payload_type": 1,
-    "route_type": 1,
-    "decoded": "{\"type\":\"RESPONSE\",\"destHash\":\"d6\",\"srcHash\":\"9f\",\"mac\":\"96fa\",\"encryptedData\":\"7dd3b1ac3702794035442d9cdad43654\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 0,
-      "hops": []
-    }
-  },
-  {
-    "raw_hex": "1E009FD6DFC543C53E826A2B789B072FF9CBE922E57EA093E5643A0CA813E79F42EE9108F855B72A3E0B599C9AC80D3A211E7C7BA2",
-    "payload_type": 7,
-    "route_type": 2,
-    "decoded": "{\"type\":\"ANON_REQ\",\"destHash\":\"9f\",\"ephemeralPubKey\":\"d6dfc543c53e826a2b789b072ff9cbe922e57ea093e5643a0ca813e79f42ee91\",\"mac\":\"08f8\",\"encryptedData\":\"55b72a3e0b599c9ac80d3a211e7c7ba2\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 0,
-      "hops": []
-    }
-  },
-  {
-    "raw_hex": "110146B7F1C45F2ED5888335F79E27085D0DE871A7C8ECB1EF5313435EBD0825BACDC181E3C1695556F51A89C9895E2114D1FECA91B58F82CBBBC1DD2B868ADDC0F7EB8C310D0887C2A2283D6F7D01A5E97B6C2F6A4CC899F27AFA513CC6B295E34ADC84A1F1019240933402E0E6B8F84D6574726F2D52",
-    "payload_type": 4,
-    "route_type": 1,
-    "decoded": "{\"type\":\"ADVERT\",\"pubKey\":\"b7f1c45f2ed5888335f79e27085d0de871a7c8ecb1ef5313435ebd0825bacdc1\",\"timestamp\":1774314369,\"timestampISO\":\"2026-03-24T01:06:09.000Z\",\"signature\":\"5556f51a89c9895e2114d1feca91b58f82cbbbc1dd2b868addc0f7eb8c310d0887c2a2283d6f7d01a5e97b6c2f6a4cc899f27afa513cc6b295e34adc84a1f101\",\"flags\":{\"raw\":146,\"type\":2,\"chat\":false,\"repeater\":true,\"room\":false,\"sensor\":false,\"hasLocation\":true,\"hasName\":true},\"lat\":37,\"lon\":-122.1,\"name\":\"Metro-R\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 1,
-      "hops": [
-        "46"
-      ]
-    }
-  },
-  {
-    "raw_hex": "15001A901C5D927D90572BAF6135D226F91D180AD4F7B90DF20F82EEEA920312D9CCFD9C3F8CA9EFBEB1C37DFA31265F73483BD0640EC94E247902F617B2C320BFA332F50441AD234D8324A48ABAA9A16EB15BD50F2D67029F2424E0836010A635EB45B5DFDB4CDC080C09FC849040AB4B82769E0F",
-    "payload_type": 5,
-    "route_type": 1,
-    "decoded": "{\"type\":\"GRP_TXT\",\"channelHash\":26,\"mac\":\"901c\",\"encryptedData\":\"5d927d90572baf6135d226f91d180ad4f7b90df20f82eeea920312d9ccfd9c3f8ca9efbeb1c37dfa31265f73483bd0640ec94e247902f617b2c320bfa332f50441ad234d8324a48abaa9a16eb15bd50f2d67029f2424e0836010a635eb45b5dfdb4cdc080c09fc849040ab4b82769e0f\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 0,
-      "hops": []
-    }
-  },
-  {
-    "raw_hex": "0A00D69F0E65C6CCDEBE8391ED093D3C76E2D064F525",
-    "payload_type": 2,
-    "route_type": 2,
-    "decoded": "{\"type\":\"TXT_MSG\",\"destHash\":\"d6\",\"srcHash\":\"9f\",\"mac\":\"0e65\",\"encryptedData\":\"c6ccdebe8391ed093d3c76e2d064f525\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 0,
-      "hops": []
-    }
-  },
-  {
-    "raw_hex": "0A00D69F940E0BA255095E9540EE6E23895DA80AAC60",
-    "payload_type": 2,
-    "route_type": 2,
-    "decoded": "{\"type\":\"TXT_MSG\",\"destHash\":\"d6\",\"srcHash\":\"9f\",\"mac\":\"940e\",\"encryptedData\":\"0ba255095e9540ee6e23895da80aac60\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 0,
-      "hops": []
-    }
-  },
-  {
-    "raw_hex": "06001f5d5acf699ea80c7ca1a9349b8af9a1b47d4a1a",
-    "payload_type": 1,
-    "route_type": 2,
-    "decoded": "{\"type\":\"RESPONSE\",\"destHash\":\"1f\",\"srcHash\":\"5d\",\"mac\":\"5acf\",\"encryptedData\":\"699ea80c7ca1a9349b8af9a1b47d4a1a\"}",
-    "path": {
-      "hashSize": 1,
-      "hashCount": 0,
-      "hops": []
-    }
-  }
-];
-
-// One special case: the advert with 1 hop from prod had raw_hex starting with "110146"
-// but the API reported path ["46"]. Let me re-check — header 0x11 = routeType 1, payloadType 4.
-// pathByte 0x01 = 1 hop, 1-byte hash. Next byte is 0x46 = the hop. Correct.
-// However, the raw_hex I captured from the API was "110146B7F1..." but the actual prod JSON showed path ["46"].
-// I need to use the correct raw_hex. Let me fix fixture 15 (Metro-R advert).
-
-for (let i = 0; i < goldenFixtures.length; i++) {
-  const fix = goldenFixtures[i];
-  const expected = typeof fix.decoded === "string" ? JSON.parse(fix.decoded) : fix.decoded;
-  const label = `golden[${i}] ${expected.type}`;
-
-  try {
-    const result = decodePacket(fix.raw_hex);
-
-    // Verify header matches expected route/payload type
-    assertEq(result.header.routeType, fix.route_type, `${label}: routeType`);
-    assertEq(result.header.payloadType, fix.payload_type, `${label}: payloadType`);
-
-    // Verify path hops
-    assertDeepEq(result.path.hops, (fix.path.hops || fix.path), `${label}: path hops`);
-
-    // Verify payload matches prod decoded output
-    // Compare key fields rather than full deep equality (to handle minor serialization diffs)
-    
-    assertEq(result.payload.type, expected.type, `${label}: payload type`);
-
-    if (expected.type === 'ADVERT') {
-      assertEq(result.payload.pubKey, expected.pubKey, `${label}: pubKey`);
-      assertEq(result.payload.timestamp, expected.timestamp, `${label}: timestamp`);
-      assertEq(result.payload.signature, expected.signature, `${label}: signature`);
-      if (expected.flags) {
-        assertEq(result.payload.flags.raw, expected.flags.raw, `${label}: flags.raw`);
-        assertEq(result.payload.flags.type, expected.flags.type, `${label}: flags.type`);
-        assertEq(result.payload.flags.hasLocation, expected.flags.hasLocation, `${label}: hasLocation`);
-        assertEq(result.payload.flags.hasName, expected.flags.hasName, `${label}: hasName`);
-      }
-      if (expected.lat != null) assert(Math.abs(result.payload.lat - expected.lat) < 0.001, `${label}: lat`);
-      if (expected.lon != null) assert(Math.abs(result.payload.lon - expected.lon) < 0.001, `${label}: lon`);
-      if (expected.name) assertEq(result.payload.name, expected.name, `${label}: name`);
-
-      // Spec checks on advert structure
-      assert(result.payload.pubKey.length === 64, `${label}: pubKey is 32 bytes (64 hex chars)`);
-      assert(result.payload.signature.length === 128, `${label}: signature is 64 bytes (128 hex chars)`);
-    } else if (expected.type === 'GRP_TXT' || expected.type === 'CHAN') {
-      assertEq(result.payload.channelHash, expected.channelHash, `${label}: channelHash`);
-      // If decoded as CHAN (with channel key), check sender/text; otherwise check mac/encrypted
-      if (expected.type === 'GRP_TXT') {
-        assertEq(result.payload.mac, expected.mac, `${label}: mac`);
-        assertEq(result.payload.encryptedData, expected.encryptedData, `${label}: encryptedData`);
-      }
-    } else if (expected.type === 'ANON_REQ') {
-      assertEq(result.payload.destHash, expected.destHash, `${label}: destHash`);
-      assertEq(result.payload.ephemeralPubKey, expected.ephemeralPubKey, `${label}: ephemeralPubKey`);
-      assertEq(result.payload.mac, expected.mac, `${label}: mac`);
-    } else {
-      // Encrypted payload types: REQ, RESPONSE, TXT_MSG, PATH
-      assertEq(result.payload.destHash, expected.destHash, `${label}: destHash`);
-      assertEq(result.payload.srcHash, expected.srcHash, `${label}: srcHash`);
-      assertEq(result.payload.mac, expected.mac, `${label}: mac`);
-      if (expected.encryptedData) assertEq(result.payload.encryptedData, expected.encryptedData, `${label}: encryptedData`);
-      if (expected.pathData) assertEq(result.payload.pathData, expected.pathData, `${label}: pathData`);
-    }
-  } catch (e) {
-    failed++;
-    console.error(`  FAIL: ${label} — threw: ${e.message}`);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════
-// Summary
-// ═══════════════════════════════════════════════════════════
-
-console.log('');
-console.log(`═══ Results: ${passed} passed, ${failed} failed, ${noted} notes ═══`);
-if (failed > 0) process.exit(1);

test-decoder.js

@@ -1,630 +0,0 @@
-/* Unit tests for decoder.js */
-'use strict';
-const assert = require('assert');
-const { decodePacket, validateAdvert, ROUTE_TYPES, PAYLOAD_TYPES, VALID_ROLES } = require('./decoder');
-
-let passed = 0, failed = 0;
-function test(name, fn) {
-  try { fn(); passed++; console.log(`  ✅ ${name}`); }
-  catch (e) { failed++; console.log(`  ❌ ${name}: ${e.message}`); }
-}
-
-// === Constants ===
-console.log('\n=== Constants ===');
-test('ROUTE_TYPES has 4 entries', () => assert.strictEqual(Object.keys(ROUTE_TYPES).length, 4));
-test('PAYLOAD_TYPES has 13 entries', () => assert.strictEqual(Object.keys(PAYLOAD_TYPES).length, 13));
-test('VALID_ROLES has repeater, companion, room, sensor', () => {
-  for (const r of ['repeater', 'companion', 'room', 'sensor']) assert(VALID_ROLES.has(r));
-});
-
-// === Header decoding ===
-console.log('\n=== Header decoding ===');
-test('FLOOD + ADVERT = 0x11', () => {
-  const p = decodePacket('1100' + '00'.repeat(101));
-  assert.strictEqual(p.header.routeType, 1);
-  assert.strictEqual(p.header.routeTypeName, 'FLOOD');
-  assert.strictEqual(p.header.payloadType, 4);
-  assert.strictEqual(p.header.payloadTypeName, 'ADVERT');
-});
-
-test('TRANSPORT_FLOOD = routeType 0', () => {
-  // 0x00 = TRANSPORT_FLOOD + REQ(0), needs transport codes + 16 byte payload
-  const hex = '0000' + 'AABB' + 'CCDD' + '00'.repeat(16);
-  const p = decodePacket(hex);
-  assert.strictEqual(p.header.routeType, 0);
-  assert.strictEqual(p.header.routeTypeName, 'TRANSPORT_FLOOD');
-  assert.notStrictEqual(p.transportCodes, null);
-  assert.strictEqual(p.transportCodes.nextHop, 'AABB');
-  assert.strictEqual(p.transportCodes.lastHop, 'CCDD');
-});
-
-test('TRANSPORT_DIRECT = routeType 3', () => {
-  const hex = '0300' + '1122' + '3344' + '00'.repeat(16);
-  const p = decodePacket(hex);
-  assert.strictEqual(p.header.routeType, 3);
-  assert.strictEqual(p.header.routeTypeName, 'TRANSPORT_DIRECT');
-  assert.strictEqual(p.transportCodes.nextHop, '1122');
-});
-
-test('DIRECT = routeType 2, no transport codes', () => {
-  const hex = '0200' + '00'.repeat(16);
-  const p = decodePacket(hex);
-  assert.strictEqual(p.header.routeType, 2);
-  assert.strictEqual(p.header.routeTypeName, 'DIRECT');
-  assert.strictEqual(p.transportCodes, null);
-});
-
-test('payload version extracted', () => {
-  // 0xC1 = 11_0000_01 → version=3, payloadType=0, routeType=1
-  const hex = 'C100' + '00'.repeat(16);
-  const p = decodePacket(hex);
-  assert.strictEqual(p.header.payloadVersion, 3);
-});
-
-// === Path decoding ===
-console.log('\n=== Path decoding ===');
-test('hashSize=1, hashCount=3', () => {
-  // pathByte = 0x03 → (0>>6)+1=1, 3&0x3F=3
-  const hex = '1103' + 'AABBCC' + '00'.repeat(101);
-  const p = decodePacket(hex);
-  assert.strictEqual(p.path.hashSize, 1);
-  assert.strictEqual(p.path.hashCount, 3);
-  assert.strictEqual(p.path.hops.length, 3);
-  assert.strictEqual(p.path.hops[0], 'AA');
-  assert.strictEqual(p.path.hops[1], 'BB');
-  assert.strictEqual(p.path.hops[2], 'CC');
-});
-
-test('hashSize=2, hashCount=2', () => {
-  // pathByte = 0x42 → (1>>0=1)+1=2, 2&0x3F=2
-  const hex = '1142' + 'AABB' + 'CCDD' + '00'.repeat(101);
-  const p = decodePacket(hex);
-  assert.strictEqual(p.path.hashSize, 2);
-  assert.strictEqual(p.path.hashCount, 2);
-  assert.strictEqual(p.path.hops[0], 'AABB');
-  assert.strictEqual(p.path.hops[1], 'CCDD');
-});
-
-test('hashSize=4 from pathByte 0xC1', () => {
-  // 0xC1 = 11_000001 → hashSize=(3)+1=4, hashCount=1
-  const hex = '11C1' + 'DEADBEEF' + '00'.repeat(101);
-  const p = decodePacket(hex);
-  assert.strictEqual(p.path.hashSize, 4);
-  assert.strictEqual(p.path.hashCount, 1);
-  assert.strictEqual(p.path.hops[0], 'DEADBEEF');
-});
-
-test('zero hops', () => {
-  const hex = '1100' + '00'.repeat(101);
-  const p = decodePacket(hex);
-  assert.strictEqual(p.path.hashCount, 0);
-  assert.strictEqual(p.path.hops.length, 0);
-});
-
-// === Payload types ===
-console.log('\n=== ADVERT payload ===');
-test('ADVERT with name and location', () => {
-  const pkt = decodePacket(
-    '11451000D818206D3AAC152C8A91F89957E6D30CA51F36E28790228971C473B755F244F718754CF5EE4A2FD58D944466E42CDED140C66D0CC590183E32BAF40F112BE8F3F2BDF6012B4B2793C52F1D36F69EE054D9A05593286F78453E56C0EC4A3EB95DDA2A7543FCCC00B939CACC009278603902FC12BCF84B706120526F6F6620536F6C6172'
-  );
-  assert.strictEqual(pkt.payload.type, 'ADVERT');
-  assert.strictEqual(pkt.payload.name, 'Kpa Roof Solar');
-  assert(pkt.payload.pubKey.length === 64);
-  assert(pkt.payload.timestamp > 0);
-  assert(pkt.payload.timestampISO);
-  assert(pkt.payload.signature.length === 128);
-});
-
-test('ADVERT flags: chat type=1', () => {
-  const pubKey = 'AB'.repeat(32);
-  const ts = '01000000';
-  const sig = 'CC'.repeat(64);
-  const flags = '01'; // type=1 → chat
-  const hex = '1100' + pubKey + ts + sig + flags;
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.flags.type, 1);
-  assert.strictEqual(p.payload.flags.chat, true);
-  assert.strictEqual(p.payload.flags.repeater, false);
-});
-
-test('ADVERT flags: repeater type=2', () => {
-  const pubKey = 'AB'.repeat(32);
-  const ts = '01000000';
-  const sig = 'CC'.repeat(64);
-  const flags = '02';
-  const hex = '1100' + pubKey + ts + sig + flags;
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.flags.type, 2);
-  assert.strictEqual(p.payload.flags.repeater, true);
-});
-
-test('ADVERT flags: room type=3', () => {
-  const pubKey = 'AB'.repeat(32);
-  const ts = '01000000';
-  const sig = 'CC'.repeat(64);
-  const flags = '03';
-  const hex = '1100' + pubKey + ts + sig + flags;
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.flags.type, 3);
-  assert.strictEqual(p.payload.flags.room, true);
-});
-
-test('ADVERT flags: sensor type=4', () => {
-  const pubKey = 'AB'.repeat(32);
-  const ts = '01000000';
-  const sig = 'CC'.repeat(64);
-  const flags = '04';
-  const hex = '1100' + pubKey + ts + sig + flags;
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.flags.type, 4);
-  assert.strictEqual(p.payload.flags.sensor, true);
-});
-
-test('ADVERT flags: hasLocation', () => {
-  const pubKey = 'AB'.repeat(32);
-  const ts = '01000000';
-  const sig = 'CC'.repeat(64);
-  // flags=0x12 → type=2(repeater), hasLocation=true
-  const flags = '12';
-  const lat = '40420f00'; // 1000000 → 1.0 degrees
-  const lon = '80841e00'; // 2000000 → 2.0 degrees
-  const hex = '1100' + pubKey + ts + sig + flags + lat + lon;
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.flags.hasLocation, true);
-  assert.strictEqual(p.payload.lat, 1.0);
-  assert.strictEqual(p.payload.lon, 2.0);
-});
-
-test('ADVERT flags: hasName', () => {
-  const pubKey = 'AB'.repeat(32);
-  const ts = '01000000';
-  const sig = 'CC'.repeat(64);
-  // flags=0x82 → type=2(repeater), hasName=true
-  const flags = '82';
-  const name = Buffer.from('MyNode').toString('hex');
-  const hex = '1100' + pubKey + ts + sig + flags + name;
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.flags.hasName, true);
-  assert.strictEqual(p.payload.name, 'MyNode');
-});
-
-test('ADVERT too short', () => {
-  const hex = '1100' + '00'.repeat(50);
-  const p = decodePacket(hex);
-  assert(p.payload.error);
-});
-
-console.log('\n=== GRP_TXT payload ===');
-test('GRP_TXT basic decode', () => {
-  // payloadType=5 → (5<<2)|1 = 0x15
-  const hex = '1500' + 'FF' + 'AABB' + 'CCDDEE';
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.type, 'GRP_TXT');
-  assert.strictEqual(p.payload.channelHash, 0xFF);
-  assert.strictEqual(p.payload.mac, 'aabb');
-});
-
-test('GRP_TXT too short', () => {
-  const hex = '1500' + 'FF' + 'AA';
-  const p = decodePacket(hex);
-  assert(p.payload.error);
-});
-
-test('GRP_TXT has channelHashHex field', () => {
-  const hex = '1500' + '1A' + 'AABB' + 'CCDDEE';
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.channelHashHex, '1A');
-});
-
-test('GRP_TXT channelHashHex zero-pads single digit', () => {
-  const hex = '1500' + '03' + 'AABB' + 'CCDDEE';
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.channelHashHex, '03');
-});
-
-test('GRP_TXT decryptionStatus is no_key when no keys provided', () => {
-  const hex = '1500' + 'FF' + 'AABB' + 'CCDDEE112233';
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.decryptionStatus, 'no_key');
-});
-
-test('GRP_TXT decryptionStatus is no_key when keys empty', () => {
-  const hex = '1500' + 'FF' + 'AABB' + 'CCDDEE112233';
-  const p = decodePacket(hex, {});
-  assert.strictEqual(p.payload.decryptionStatus, 'no_key');
-});
-
-test('GRP_TXT decryptionStatus is decryption_failed with bad keys', () => {
-  const hex = '1500' + 'FF' + 'AABB' + 'CCDDEE112233';
-  const p = decodePacket(hex, { '#test': 'deadbeefdeadbeefdeadbeefdeadbeef' });
-  assert.strictEqual(p.payload.decryptionStatus, 'decryption_failed');
-});
-
-test('GRP_TXT decryptionStatus is no_key when encrypted data too short', () => {
-  // encryptedData < 10 hex chars (5 bytes) — not enough to attempt decryption
-  const hex = '1500' + 'FF' + 'AABB' + 'CCDD';
-  const p = decodePacket(hex, { '#test': 'deadbeefdeadbeefdeadbeefdeadbeef' });
-  assert.strictEqual(p.payload.decryptionStatus, 'no_key');
-});
-
-test('GRP_TXT decryptionStatus is decrypted when key matches', () => {
-  // Mock the ChannelCrypto module to simulate successful decryption
-  const cryptoPath = require.resolve('@michaelhart/meshcore-decoder/dist/crypto/channel-crypto');
-  const originalModule = require.cache[cryptoPath];
-  require.cache[cryptoPath] = {
-    id: cryptoPath,
-    exports: {
-      ChannelCrypto: {
-        decryptGroupTextMessage: () => ({
-          success: true,
-          data: { sender: 'TestUser', message: 'Hello world', timestamp: 1700000000, flags: 0 },
-        }),
-      },
-    },
-  };
-  try {
-    const hex = '1500' + 'FF' + 'AABB' + 'CCDDEE112233';
-    const p = decodePacket(hex, { '#general': 'aabbccddaabbccddaabbccddaabbccdd' });
-    assert.strictEqual(p.payload.decryptionStatus, 'decrypted');
-    assert.strictEqual(p.payload.type, 'CHAN');
-    assert.strictEqual(p.payload.channelHashHex, 'FF');
-    assert.strictEqual(p.payload.channel, '#general');
-    assert.strictEqual(p.payload.sender, 'TestUser');
-    assert.strictEqual(p.payload.text, 'TestUser: Hello world');
-    assert.strictEqual(p.payload.sender_timestamp, 1700000000);
-    assert.strictEqual(p.payload.flags, 0);
-    assert.strictEqual(p.payload.channelHash, 0xFF);
-  } finally {
-    if (originalModule) require.cache[cryptoPath] = originalModule;
-    else delete require.cache[cryptoPath];
-  }
-});
-
-test('GRP_TXT decrypted without sender formats text correctly', () => {
-  const cryptoPath = require.resolve('@michaelhart/meshcore-decoder/dist/crypto/channel-crypto');
-  const originalModule = require.cache[cryptoPath];
-  require.cache[cryptoPath] = {
-    id: cryptoPath,
-    exports: {
-      ChannelCrypto: {
-        decryptGroupTextMessage: () => ({
-          success: true,
-          data: { sender: null, message: 'Broadcast msg', timestamp: 1700000001, flags: 1 },
-        }),
-      },
-    },
-  };
-  try {
-    const hex = '1500' + '0A' + 'AABB' + 'CCDDEE112233';
-    const p = decodePacket(hex, { '#alerts': 'deadbeefdeadbeefdeadbeefdeadbeef' });
-    assert.strictEqual(p.payload.decryptionStatus, 'decrypted');
-    assert.strictEqual(p.payload.sender, null);
-    assert.strictEqual(p.payload.text, 'Broadcast msg');
-    assert.strictEqual(p.payload.channelHashHex, '0A');
-  } finally {
-    if (originalModule) require.cache[cryptoPath] = originalModule;
-    else delete require.cache[cryptoPath];
-  }
-});
-
-test('GRP_TXT decrypted tries multiple keys, first match wins', () => {
-  const cryptoPath = require.resolve('@michaelhart/meshcore-decoder/dist/crypto/channel-crypto');
-  const originalModule = require.cache[cryptoPath];
-  let callCount = 0;
-  require.cache[cryptoPath] = {
-    id: cryptoPath,
-    exports: {
-      ChannelCrypto: {
-        decryptGroupTextMessage: (ciphertext, mac, key) => {
-          callCount++;
-          if (key === 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb') {
-            return { success: true, data: { sender: 'Bob', message: 'Found it', timestamp: 0, flags: 0 } };
-          }
-          return { success: false };
-        },
-      },
-    },
-  };
-  try {
-    const hex = '1500' + 'FF' + 'AABB' + 'CCDDEE112233';
-    const p = decodePacket(hex, {
-      '#wrong': 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-      '#right': 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
-    });
-    assert.strictEqual(p.payload.decryptionStatus, 'decrypted');
-    assert.strictEqual(p.payload.channel, '#right');
-    assert.strictEqual(p.payload.sender, 'Bob');
-    assert.strictEqual(callCount, 2);
-  } finally {
-    if (originalModule) require.cache[cryptoPath] = originalModule;
-    else delete require.cache[cryptoPath];
-  }
-});
-
-console.log('\n=== TXT_MSG payload ===');
-test('TXT_MSG decode', () => {
-  // payloadType=2 → (2<<2)|1 = 0x09
-  const hex = '0900' + '00'.repeat(20);
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.type, 'TXT_MSG');
-  assert(p.payload.destHash);
-  assert(p.payload.srcHash);
-  assert(p.payload.mac);
-});
-
-console.log('\n=== ACK payload ===');
-test('ACK decode', () => {
-  // payloadType=3 → (3<<2)|1 = 0x0D
-  const hex = '0D00' + '00'.repeat(18);
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.type, 'ACK');
-  assert(p.payload.destHash);
-  assert(p.payload.srcHash);
-  assert(p.payload.extraHash);
-});
-
-test('ACK too short', () => {
-  const hex = '0D00' + '00'.repeat(3);
-  const p = decodePacket(hex);
-  assert(p.payload.error);
-});
-
-console.log('\n=== REQ payload ===');
-test('REQ decode', () => {
-  // payloadType=0 → (0<<2)|1 = 0x01
-  const hex = '0100' + '00'.repeat(20);
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.type, 'REQ');
-});
-
-console.log('\n=== RESPONSE payload ===');
-test('RESPONSE decode', () => {
-  // payloadType=1 → (1<<2)|1 = 0x05
-  const hex = '0500' + '00'.repeat(20);
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.type, 'RESPONSE');
-});
-
-console.log('\n=== ANON_REQ payload ===');
-test('ANON_REQ decode', () => {
-  // payloadType=7 → (7<<2)|1 = 0x1D
-  const hex = '1D00' + '00'.repeat(50);
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.type, 'ANON_REQ');
-  assert(p.payload.destHash);
-  assert(p.payload.ephemeralPubKey);
-  assert(p.payload.mac);
-});
-
-test('ANON_REQ too short', () => {
-  const hex = '1D00' + '00'.repeat(20);
-  const p = decodePacket(hex);
-  assert(p.payload.error);
-});
-
-console.log('\n=== PATH payload ===');
-test('PATH decode', () => {
-  // payloadType=8 → (8<<2)|1 = 0x21
-  const hex = '2100' + '00'.repeat(20);
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.type, 'PATH');
-  assert(p.payload.destHash);
-  assert(p.payload.srcHash);
-});
-
-test('PATH too short', () => {
-  const hex = '2100' + '00'.repeat(1);
-  const p = decodePacket(hex);
-  assert(p.payload.error);
-});
-
-console.log('\n=== TRACE payload ===');
-test('TRACE decode', () => {
-  // payloadType=9 → (9<<2)|1 = 0x25
-  const hex = '2500' + '00'.repeat(12);
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.type, 'TRACE');
-  assert.strictEqual(p.payload.flags, 0);
-  assert(p.payload.tag !== undefined);
-  assert(p.payload.destHash);
-});
-
-test('TRACE too short', () => {
-  const hex = '2500' + '00'.repeat(5);
-  const p = decodePacket(hex);
-  assert(p.payload.error);
-});
-
-console.log('\n=== UNKNOWN payload ===');
-test('Unknown payload type', () => {
-  // payloadType=6 → (6<<2)|1 = 0x19
-  const hex = '1900' + 'DEADBEEF';
-  const p = decodePacket(hex);
-  assert.strictEqual(p.payload.type, 'UNKNOWN');
-  assert(p.payload.raw);
-});
-
-// === Edge cases ===
-console.log('\n=== Edge cases ===');
-test('Packet too short throws', () => {
-  assert.throws(() => decodePacket('FF'), /too short/);
-});
-
-test('Packet with spaces in hex', () => {
-  const hex = '11 00 ' + '00'.repeat(101);
-  const p = decodePacket(hex);
-  assert.strictEqual(p.header.payloadTypeName, 'ADVERT');
-});
-
-test('Transport route too short throws', () => {
-  assert.throws(() => decodePacket('0000'), /too short for transport/);
-});
-
-test('Corrupt packet #183 — path overflow capped to buffer', () => {
-  const hex = 'BBAD6797EC8751D500BF95A1A776EF580E665BCBF6A0BBE03B5E730707C53489B8C728FD3FB902397197E1263CEC21E52465362243685DBBAD6797EC8751C90A75D9FD8213155D';
-  const p = decodePacket(hex);
-  assert.strictEqual(p.header.routeType, 3, 'routeType should be TRANSPORT_DIRECT');
-  assert.strictEqual(p.header.payloadTypeName, 'UNKNOWN');
-  // pathByte 0xAD claims 45 hops × 3 bytes = 135, but only 65 bytes available
-  assert.strictEqual(p.path.hashSize, 3);
-  assert.strictEqual(p.path.hashCount, 21, 'hashCount capped to fit buffer');
-  assert.strictEqual(p.path.hops.length, 21);
-  assert.strictEqual(p.path.truncated, true);
-  // No empty strings in hops
-  assert(p.path.hops.every(h => h.length > 0), 'no empty hops');
-});
-
-test('path.truncated is false for normal packets', () => {
-  const hex = '1100' + '00'.repeat(101);
-  const p = decodePacket(hex);
-  assert.strictEqual(p.path.truncated, false);
-});
-
-test('path overflow with hashSize=2', () => {
-  // FLOOD + REQ, pathByte=0x45 → hashSize=2, hashCount=5, needs 10 bytes of path
-  // Only provide 7 bytes after pathByte → fits 3 full 2-byte hops
-  const hex = '0145' + 'AABBCCDDEEFF77';
-  const p = decodePacket(hex);
-  assert.strictEqual(p.path.hashCount, 3);
-  assert.strictEqual(p.path.truncated, true);
-  assert.strictEqual(p.path.hops.length, 3);
-  assert.strictEqual(p.path.hops[0], 'AABB');
-  assert.strictEqual(p.path.hops[1], 'CCDD');
-  assert.strictEqual(p.path.hops[2], 'EEFF');
-});
-
-// === Real packets from API ===
-console.log('\n=== Real packets ===');
-test('Real GRP_TXT packet', () => {
-  const p = decodePacket('150115D96CFF1FC90E7917B91729B76C1B509AE7789BBBD87D5AC3837E6C1487B47B0958AED8C7A6');
-  assert.strictEqual(p.header.payloadTypeName, 'GRP_TXT');
-  assert.strictEqual(p.header.routeTypeName, 'FLOOD');
-  assert.strictEqual(p.path.hashCount, 1);
-});
-
-test('Real ADVERT packet FLOOD with 3 hops', () => {
-  const p = decodePacket('11036CEF52206D763E1EACFD52FBAD4EF926887D0694C42A618AAF480A67C41120D3785950EFE0C1');
-  assert.strictEqual(p.header.payloadTypeName, 'ADVERT');
-  assert.strictEqual(p.header.routeTypeName, 'FLOOD');
-  assert.strictEqual(p.path.hashCount, 3);
-  assert.strictEqual(p.path.hashSize, 1);
-  // Payload is too short for full ADVERT but decoder handles it
-  assert.strictEqual(p.payload.type, 'ADVERT');
-});
-
-test('Real DIRECT TXT_MSG packet', () => {
-  // 0x0A = DIRECT(2) + TXT_MSG(2)
-  const p = decodePacket('0A403220AD034C0394C2C449810E3D86399C53AEE7FE355BA67002FFC3627B1175A257A181AE');
-  assert.strictEqual(p.header.payloadTypeName, 'TXT_MSG');
-  assert.strictEqual(p.header.routeTypeName, 'DIRECT');
-});
-
-// === validateAdvert ===
-console.log('\n=== validateAdvert ===');
-test('valid advert', () => {
-  const a = { pubKey: 'AB'.repeat(16), flags: { repeater: true, room: false, sensor: false } };
-  assert.deepStrictEqual(validateAdvert(a), { valid: true });
-});
-
-test('null advert', () => {
-  assert.strictEqual(validateAdvert(null).valid, false);
-});
-
-test('advert with error', () => {
-  assert.strictEqual(validateAdvert({ error: 'bad' }).valid, false);
-});
-
-test('pubkey too short', () => {
-  assert.strictEqual(validateAdvert({ pubKey: 'AABB' }).valid, false);
-});
-
-test('pubkey all zeros', () => {
-  assert.strictEqual(validateAdvert({ pubKey: '0'.repeat(64) }).valid, false);
-});
-
-test('invalid lat', () => {
-  assert.strictEqual(validateAdvert({ pubKey: 'AB'.repeat(16), lat: 200 }).valid, false);
-});
-
-test('invalid lon', () => {
-  assert.strictEqual(validateAdvert({ pubKey: 'AB'.repeat(16), lon: -200 }).valid, false);
-});
-
-test('name with control chars', () => {
-  assert.strictEqual(validateAdvert({ pubKey: 'AB'.repeat(16), name: 'test\x00bad' }).valid, false);
-});
-
-test('name too long', () => {
-  assert.strictEqual(validateAdvert({ pubKey: 'AB'.repeat(16), name: 'A'.repeat(65) }).valid, false);
-});
-
-test('valid name', () => {
-  assert.strictEqual(validateAdvert({ pubKey: 'AB'.repeat(16), name: 'My Node' }).valid, true);
-});
-
-test('valid lat/lon', () => {
-  const r = validateAdvert({ pubKey: 'AB'.repeat(16), lat: 37.3, lon: -121.9 });
-  assert.strictEqual(r.valid, true);
-});
-
-test('NaN lat invalid', () => {
-  assert.strictEqual(validateAdvert({ pubKey: 'AB'.repeat(16), lat: NaN }).valid, false);
-});
-
-// --- GRP_TXT garbage detection (fixes #197) ---
-
-test('GRP_TXT decrypted garbage text marked as decryption_failed', () => {
-  const cryptoPath = require.resolve('@michaelhart/meshcore-decoder/dist/crypto/channel-crypto');
-  const originalModule = require.cache[cryptoPath];
-  require.cache[cryptoPath] = {
-    id: cryptoPath,
-    exports: {
-      ChannelCrypto: {
-        decryptGroupTextMessage: () => ({
-          success: true,
-          data: { sender: 'Node', message: '\x01\x02\x03\x80\x81', timestamp: 1700000000, flags: 0 },
-        }),
-      },
-    },
-  };
-  try {
-    const hex = '1500' + 'FF' + 'AABB' + 'CCDDEE112233';
-    const p = decodePacket(hex, { '#general': 'aabbccddaabbccddaabbccddaabbccdd' });
-    assert.strictEqual(p.payload.decryptionStatus, 'decryption_failed');
-    assert.strictEqual(p.payload.text, null);
-    assert.strictEqual(p.payload.channelHashHex, 'FF');
-    assert.strictEqual(p.payload.channel, '#general');
-  } finally {
-    if (originalModule) require.cache[cryptoPath] = originalModule;
-    else delete require.cache[cryptoPath];
-  }
-});
-
-test('GRP_TXT valid text still marked as decrypted', () => {
-  const cryptoPath = require.resolve('@michaelhart/meshcore-decoder/dist/crypto/channel-crypto');
-  const originalModule = require.cache[cryptoPath];
-  require.cache[cryptoPath] = {
-    id: cryptoPath,
-    exports: {
-      ChannelCrypto: {
-        decryptGroupTextMessage: () => ({
-          success: true,
-          data: { sender: 'Alice', message: 'Hello\nworld', timestamp: 1700000000, flags: 0 },
-        }),
-      },
-    },
-  };
-  try {
-    const hex = '1500' + 'FF' + 'AABB' + 'CCDDEE112233';
-    const p = decodePacket(hex, { '#general': 'aabbccddaabbccddaabbccddaabbccdd' });
-    assert.strictEqual(p.payload.decryptionStatus, 'decrypted');
-    assert.strictEqual(p.payload.text, 'Alice: Hello\nworld');
-  } finally {
-    if (originalModule) require.cache[cryptoPath] = originalModule;
-    else delete require.cache[cryptoPath];
-  }
-});
-
-// === Summary ===
-console.log(`\n${passed} passed, ${failed} failed`);
-if (failed > 0) process.exit(1);

test-e2e-playwright.js

@@ -17,6 +17,8 @@ async function test(name, fn) {
   } catch (err) {
     results.push({ name, pass: false, error: err.message });
     console.log(`  \u274c ${name}: ${err.message}`);
+    console.log(`\nFail-fast: stopping after first failure.`);
+    process.exit(1);
   }
 }
 
@@ -351,13 +353,22 @@ async function run() {
   });
 
   // Test: Clicking a packet row opens detail pane
-  await test('Packets clicking row shows detail pane', async () => {
+  // SKIPPED: flaky test — see https://github.com/Kpa-clawbot/CoreScope/issues/257
+  console.log('  ⏭️  Packets clicking row shows detail pane (SKIPPED — flaky)');
+  /*await test('Packets clicking row shows detail pane', async () => {
     // Fresh navigation to avoid stale row references from previous test
     await page.goto(`${BASE}/#/packets`, { waitUntil: 'domcontentloaded' });
+    // Wait for table rows AND initial API data to settle
     await page.waitForSelector('table tbody tr[data-action]', { timeout: 15000 });
+    await page.waitForLoadState('networkidle');
     const firstRow = await page.$('table tbody tr[data-action]');
     assert(firstRow, 'No clickable packet rows found');
-    await firstRow.click();
+    // Click the row and wait for the /packets/{hash} API response
+    const [response] = await Promise.all([
+      page.waitForResponse(resp => resp.url().includes('/packets/') && resp.status() === 200, { timeout: 15000 }),
+      firstRow.click(),
+    ]);
+    assert(response, 'API response for packet detail not received');
     await page.waitForFunction(() => {
       const panel = document.getElementById('pktRight');
       return panel && !panel.classList.contains('empty');
@@ -375,12 +386,16 @@ async function run() {
     if (!pktRight) {
       await page.goto(`${BASE}/#/packets`, { waitUntil: 'domcontentloaded' });
       await page.waitForSelector('table tbody tr[data-action]', { timeout: 15000 });
+      await page.waitForLoadState('networkidle');
     }
     const panelOpen = await page.$eval('#pktRight', el => !el.classList.contains('empty'));
     if (!panelOpen) {
       const firstRow = await page.$('table tbody tr[data-action]');
       if (!firstRow) { console.log('    ⏭️  Skipped (no clickable rows)'); return; }
-      await firstRow.click();
+      await Promise.all([
+        page.waitForResponse(resp => resp.url().includes('/packets/') && resp.status() === 200, { timeout: 15000 }),
+        firstRow.click(),
+      ]);
       await page.waitForFunction(() => {
         const panel = document.getElementById('pktRight');
         return panel && !panel.classList.contains('empty');
@@ -395,7 +410,8 @@ async function run() {
     }, { timeout: 3000 });
     const panelHidden = await page.$eval('#pktRight', el => el.classList.contains('empty'));
     assert(panelHidden, 'Detail pane should be hidden after clicking ✕');
-  });
+  });*/
+  console.log('  ⏭️  Packet detail pane closes on ✕ click (SKIPPED — depends on flaky test above)');
 
   // Test: GRP_TXT packet detail shows Channel Hash (#123)
   await test('GRP_TXT packet detail shows Channel Hash', async () => {
@@ -829,17 +845,7 @@ async function run() {
     assert(content.length > 10, 'Perf content should still be present after refresh');
   });
 
-  // Test: Node.js perf page shows Event Loop metrics (not Go Runtime)
-  await test('Perf page shows Event Loop on Node server', async () => {
-    const perfText = await page.$eval('#perfContent', el => el.textContent);
-    // Node.js server should show Event Loop metrics
-    const hasEventLoop = perfText.includes('Event Loop') || perfText.includes('event loop');
-    const hasMemory = perfText.includes('Memory') || perfText.includes('RSS');
-    assert(hasEventLoop || hasMemory, 'Node perf page should show Event Loop or Memory metrics');
-    // Should NOT show Go Runtime section on Node.js server
-    const hasGoRuntime = perfText.includes('Go Runtime');
-    assert(!hasGoRuntime, 'Node perf page should NOT show Go Runtime section');
-  });
+
 
   // Test: Go perf page shows Go Runtime section (goroutines, GC)
   // NOTE: This test requires GO_BASE_URL pointing to Go staging (port 82)
@@ -909,6 +915,19 @@ async function run() {
     assert(hexDump, 'Hex dump should be visible after selecting a packet');
   });
 
+  // Extract frontend coverage if instrumented server is running
+  try {
+    const coverage = await page.evaluate(() => window.__coverage__);
+    if (coverage) {
+      const fs = require('fs');
+      const path = require('path');
+      const outDir = path.join(__dirname, '.nyc_output');
+      if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+      fs.writeFileSync(path.join(outDir, 'e2e-coverage.json'), JSON.stringify(coverage));
+      console.log(`Frontend coverage from E2E: ${Object.keys(coverage).length} files`);
+    }
+  } catch {}
+
   await browser.close();
 
   // Summary

test-frontend-helpers.js

@@ -1322,7 +1322,7 @@ console.log('\n=== app.js: formatVersionBadge ===');
     assert.ok(result.includes('>v2.6.0</a>'), 'version text has v prefix');
     assert.ok(result.includes(`href="${GH}/commit/abc1234def5678"`), 'commit links to full hash');
     assert.ok(result.includes('>abc1234</a>'), 'commit display is truncated to 7');
-    assert.ok(result.includes('[node]'), 'should show engine');
+    assert.ok(result.includes('engine-badge'), 'should show engine badge'); assert.ok(result.includes('>node<'), 'should show engine name');
   });
   test('prod port 80: shows version', () => {
     const { formatVersionBadge } = makeBadgeSandbox('80');
@@ -1348,7 +1348,7 @@ console.log('\n=== app.js: formatVersionBadge ===');
     assert.ok(!result.includes('v2.6.0'), 'staging should NOT show version');
     assert.ok(result.includes('>abc1234</a>'), 'should show commit hash');
     assert.ok(result.includes(`href="${GH}/commit/abc1234def5678"`), 'commit is linked');
-    assert.ok(result.includes('[go]'), 'should show engine');
+    assert.ok(result.includes('engine-badge'), 'should show engine badge'); assert.ok(result.includes('>go<'), 'should show engine name');
   });
   test('staging port 81: hides version', () => {
     const { formatVersionBadge } = makeBadgeSandbox('81');
@@ -1369,18 +1369,18 @@ console.log('\n=== app.js: formatVersionBadge ===');
     const result = formatVersionBadge('2.6.0', 'unknown', 'node');
     assert.ok(result.includes('>v2.6.0</a>'), 'should show version');
     assert.ok(!result.includes('unknown'), 'should not show unknown commit');
-    assert.ok(result.includes('[node]'), 'should show engine');
+    assert.ok(result.includes('engine-badge'), 'should show engine badge'); assert.ok(result.includes('>node<'), 'should show engine name');
   });
   test('skips commit when missing', () => {
     const { formatVersionBadge } = makeBadgeSandbox('');
     const result = formatVersionBadge('2.6.0', null, 'go');
     assert.ok(result.includes('>v2.6.0</a>'), 'should show version');
-    assert.ok(result.includes('[go]'), 'should show engine');
+    assert.ok(result.includes('engine-badge'), 'should show engine badge'); assert.ok(result.includes('>go<'), 'should show engine name');
   });
   test('shows only engine when version/commit missing', () => {
     const { formatVersionBadge } = makeBadgeSandbox('3000');
     const result = formatVersionBadge(null, null, 'go');
-    assert.ok(result.includes('[go]'), 'should show engine');
+    assert.ok(result.includes('engine-badge'), 'should show engine badge'); assert.ok(result.includes('>go<'), 'should show engine name');
     assert.ok(result.includes('version-badge'), 'should use version-badge class');
   });
   test('short commit not truncated in display', () => {
@@ -1398,7 +1398,7 @@ console.log('\n=== app.js: formatVersionBadge ===');
     const { formatVersionBadge } = makeBadgeSandbox('8080');
     const result = formatVersionBadge('2.6.0', null, 'go');
     assert.ok(!result.includes('2.6.0'), 'no version on staging');
-    assert.ok(result.includes('[go]'), 'engine shown');
+    assert.ok(result.includes('engine-badge'), 'engine badge shown'); assert.ok(result.includes('>go<'), 'engine name shown');
   });
 }
 

test-packet-store.js

@@ -1,552 +0,0 @@
-/* Unit tests for packet-store.js — uses a mock db module */
-'use strict';
-const assert = require('assert');
-const PacketStore = require('./packet-store');
-
-let passed = 0, failed = 0;
-function test(name, fn) {
-  try { fn(); passed++; console.log(`  ✅ ${name}`); }
-  catch (e) { failed++; console.log(`  ❌ ${name}: ${e.message}`); }
-}
-
-// Mock db module — minimal stubs for PacketStore
-function createMockDb() {
-  let txIdCounter = 1;
-  let obsIdCounter = 1000;
-  return {
-    db: {
-      pragma: (query) => {
-        if (query.includes('table_info(observations)')) return [{ name: 'observer_idx' }];
-        return [];
-      },
-      prepare: (sql) => ({
-        get: (...args) => {
-          if (sql.includes('sqlite_master')) return { name: 'transmissions' };
-          if (sql.includes('nodes')) return null;
-          if (sql.includes('observers')) return [];
-          return null;
-        },
-        all: (...args) => [],
-        iterate: (...args) => [][Symbol.iterator](),
-      }),
-    },
-    insertTransmission: (data) => ({
-      transmissionId: txIdCounter++,
-      observationId: obsIdCounter++,
-    }),
-  };
-}
-
-function makePacketData(overrides = {}) {
-  return {
-    raw_hex: 'AABBCCDD',
-    hash: 'abc123',
-    timestamp: new Date().toISOString(),
-    route_type: 1,
-    payload_type: 5,
-    payload_version: 0,
-    decoded_json: JSON.stringify({ pubKey: 'DEADBEEF'.repeat(8) }),
-    observer_id: 'obs1',
-    observer_name: 'Observer1',
-    snr: 8.5,
-    rssi: -45,
-    path_json: '["AA","BB"]',
-    direction: 'rx',
-    ...overrides,
-  };
-}
-
-// === Constructor ===
-console.log('\n=== PacketStore constructor ===');
-test('creates empty store', () => {
-  const store = new PacketStore(createMockDb());
-  assert.strictEqual(store.packets.length, 0);
-  assert.strictEqual(store.loaded, false);
-});
-
-test('respects maxMemoryMB config', () => {
-  const store = new PacketStore(createMockDb(), { maxMemoryMB: 512 });
-  assert.strictEqual(store.maxBytes, 512 * 1024 * 1024);
-});
-
-// === Load ===
-console.log('\n=== Load ===');
-test('load sets loaded flag', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  assert.strictEqual(store.loaded, true);
-});
-
-test('sqliteOnly mode skips RAM', () => {
-  const orig = process.env.NO_MEMORY_STORE;
-  process.env.NO_MEMORY_STORE = '1';
-  const store = new PacketStore(createMockDb());
-  store.load();
-  assert.strictEqual(store.sqliteOnly, true);
-  assert.strictEqual(store.packets.length, 0);
-  process.env.NO_MEMORY_STORE = orig || '';
-  if (!orig) delete process.env.NO_MEMORY_STORE;
-});
-
-// === Insert ===
-console.log('\n=== Insert ===');
-test('insert adds packet to memory', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData());
-  assert.strictEqual(store.packets.length, 1);
-  assert.strictEqual(store.stats.inserts, 1);
-});
-
-test('insert deduplicates by hash', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'dup1' }));
-  store.insert(makePacketData({ hash: 'dup1', observer_id: 'obs2' }));
-  assert.strictEqual(store.packets.length, 1);
-  assert.strictEqual(store.packets[0].observations.length, 2);
-  assert.strictEqual(store.packets[0].observation_count, 2);
-});
-
-test('insert dedup: same observer+path skipped', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'dup2' }));
-  store.insert(makePacketData({ hash: 'dup2' })); // same observer_id + path_json
-  assert.strictEqual(store.packets[0].observations.length, 1);
-});
-
-test('insert indexes by node pubkey', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  const pk = 'DEADBEEF'.repeat(8);
-  store.insert(makePacketData({ hash: 'n1', decoded_json: JSON.stringify({ pubKey: pk }) }));
-  assert(store.byNode.has(pk));
-  assert.strictEqual(store.byNode.get(pk).length, 1);
-});
-
-test('insert indexes byObserver', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ observer_id: 'obs-test' }));
-  assert(store.byObserver.has('obs-test'));
-});
-
-test('insert updates first_seen for earlier timestamp', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'ts1', timestamp: '2025-01-02T00:00:00Z', observer_id: 'o1' }));
-  store.insert(makePacketData({ hash: 'ts1', timestamp: '2025-01-01T00:00:00Z', observer_id: 'o2' }));
-  assert.strictEqual(store.packets[0].first_seen, '2025-01-01T00:00:00Z');
-});
-
-test('insert indexes ADVERT observer', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  const pk = 'AA'.repeat(32);
-  store.insert(makePacketData({ hash: 'adv1', payload_type: 4, decoded_json: JSON.stringify({ pubKey: pk }), observer_id: 'obs-adv' }));
-  assert(store._advertByObserver.has(pk));
-  assert(store._advertByObserver.get(pk).has('obs-adv'));
-});
-
-// === Query ===
-console.log('\n=== Query ===');
-test('query returns all packets', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'q1' }));
-  store.insert(makePacketData({ hash: 'q2' }));
-  const r = store.query();
-  assert.strictEqual(r.total, 2);
-  assert.strictEqual(r.packets.length, 2);
-});
-
-test('query by type filter', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'qt1', payload_type: 4 }));
-  store.insert(makePacketData({ hash: 'qt2', payload_type: 5 }));
-  const r = store.query({ type: 4 });
-  assert.strictEqual(r.total, 1);
-  assert.strictEqual(r.packets[0].payload_type, 4);
-});
-
-test('query by route filter', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'qr1', route_type: 0 }));
-  store.insert(makePacketData({ hash: 'qr2', route_type: 1 }));
-  const r = store.query({ route: 1 });
-  assert.strictEqual(r.total, 1);
-});
-
-test('query by hash (index path)', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'qh1' }));
-  store.insert(makePacketData({ hash: 'qh2' }));
-  const r = store.query({ hash: 'qh1' });
-  assert.strictEqual(r.total, 1);
-  assert.strictEqual(r.packets[0].hash, 'qh1');
-});
-
-test('query by observer (index path)', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'qo1', observer_id: 'obsA' }));
-  store.insert(makePacketData({ hash: 'qo2', observer_id: 'obsB' }));
-  const r = store.query({ observer: 'obsA' });
-  assert.strictEqual(r.total, 1);
-});
-
-test('query with limit and offset', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  for (let i = 0; i < 10; i++) store.insert(makePacketData({ hash: `ql${i}`, observer_id: `o${i}` }));
-  const r = store.query({ limit: 3, offset: 2 });
-  assert.strictEqual(r.packets.length, 3);
-  assert.strictEqual(r.total, 10);
-});
-
-test('query by since filter', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'qs1', timestamp: '2025-01-01T00:00:00Z' }));
-  store.insert(makePacketData({ hash: 'qs2', timestamp: '2025-06-01T00:00:00Z', observer_id: 'o2' }));
-  const r = store.query({ since: '2025-03-01T00:00:00Z' });
-  assert.strictEqual(r.total, 1);
-});
-
-test('query by until filter', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'qu1', timestamp: '2025-01-01T00:00:00Z' }));
-  store.insert(makePacketData({ hash: 'qu2', timestamp: '2025-06-01T00:00:00Z', observer_id: 'o2' }));
-  const r = store.query({ until: '2025-03-01T00:00:00Z' });
-  assert.strictEqual(r.total, 1);
-});
-
-test('query ASC order', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'qa1', timestamp: '2025-06-01T00:00:00Z' }));
-  store.insert(makePacketData({ hash: 'qa2', timestamp: '2025-01-01T00:00:00Z', observer_id: 'o2' }));
-  const r = store.query({ order: 'ASC' });
-  assert(r.packets[0].timestamp < r.packets[1].timestamp);
-});
-
-// === queryGrouped ===
-console.log('\n=== queryGrouped ===');
-test('queryGrouped returns grouped data', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'qg1' }));
-  store.insert(makePacketData({ hash: 'qg1', observer_id: 'obs2' }));
-  store.insert(makePacketData({ hash: 'qg2', observer_id: 'obs3' }));
-  const r = store.queryGrouped();
-  assert.strictEqual(r.total, 2);
-  const g1 = r.packets.find(p => p.hash === 'qg1');
-  assert(g1);
-  assert.strictEqual(g1.observation_count, 2);
-  assert.strictEqual(g1.observer_count, 2);
-});
-
-// === getNodesByAdvertObservers ===
-console.log('\n=== getNodesByAdvertObservers ===');
-test('finds nodes by observer', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  const pk = 'BB'.repeat(32);
-  store.insert(makePacketData({ hash: 'nao1', payload_type: 4, decoded_json: JSON.stringify({ pubKey: pk }), observer_id: 'obs-x' }));
-  const result = store.getNodesByAdvertObservers(['obs-x']);
-  assert(result.has(pk));
-});
-
-test('returns empty for unknown observer', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  const result = store.getNodesByAdvertObservers(['nonexistent']);
-  assert.strictEqual(result.size, 0);
-});
-
-// === Other methods ===
-console.log('\n=== Other methods ===');
-test('getById returns observation', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  const id = store.insert(makePacketData({ hash: 'gbi1' }));
-  const obs = store.getById(id);
-  assert(obs);
-});
-
-test('getSiblings returns observations for hash', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'sib1' }));
-  store.insert(makePacketData({ hash: 'sib1', observer_id: 'obs2' }));
-  const sibs = store.getSiblings('sib1');
-  assert.strictEqual(sibs.length, 2);
-});
-
-test('getSiblings empty for unknown hash', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  assert.deepStrictEqual(store.getSiblings('nope'), []);
-});
-
-test('all() returns packets', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'all1' }));
-  assert.strictEqual(store.all().length, 1);
-});
-
-test('filter() works', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'f1', payload_type: 4 }));
-  store.insert(makePacketData({ hash: 'f2', payload_type: 5, observer_id: 'o2' }));
-  assert.strictEqual(store.filter(p => p.payload_type === 4).length, 1);
-});
-
-test('countForNode returns counts', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  const pk = 'CC'.repeat(32);
-  store.insert(makePacketData({ hash: 'cn1', decoded_json: JSON.stringify({ pubKey: pk }) }));
-  store.insert(makePacketData({ hash: 'cn1', decoded_json: JSON.stringify({ pubKey: pk }), observer_id: 'o2' }));
-  const c = store.countForNode(pk);
-  assert.strictEqual(c.transmissions, 1);
-  assert.strictEqual(c.observations, 2);
-});
-
-test('getStats returns stats object', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  const s = store.getStats();
-  assert.strictEqual(s.inMemory, 0);
-  assert(s.indexes);
-  assert.strictEqual(s.sqliteOnly, false);
-});
-
-test('getTimestamps returns timestamps', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'gt1', timestamp: '2025-06-01T00:00:00Z' }));
-  store.insert(makePacketData({ hash: 'gt2', timestamp: '2025-06-02T00:00:00Z', observer_id: 'o2' }));
-  const ts = store.getTimestamps('2025-05-01T00:00:00Z');
-  assert.strictEqual(ts.length, 2);
-});
-
-// === Eviction ===
-console.log('\n=== Eviction ===');
-test('evicts oldest when over maxPackets', () => {
-  const store = new PacketStore(createMockDb(), { maxMemoryMB: 1, estimatedPacketBytes: 500000 });
-  // maxPackets will be very small
-  store.load();
-  for (let i = 0; i < 10; i++) store.insert(makePacketData({ hash: `ev${i}`, observer_id: `o${i}` }));
-  assert(store.packets.length <= store.maxPackets);
-  assert(store.stats.evicted > 0);
-});
-
-// === findPacketsForNode ===
-console.log('\n=== findPacketsForNode ===');
-test('finds by pubkey', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  const pk = 'DD'.repeat(32);
-  store.insert(makePacketData({ hash: 'fpn1', decoded_json: JSON.stringify({ pubKey: pk }) }));
-  store.insert(makePacketData({ hash: 'fpn2', decoded_json: JSON.stringify({ pubKey: 'other' }), observer_id: 'o2' }));
-  const r = store.findPacketsForNode(pk);
-  assert.strictEqual(r.packets.length, 1);
-  assert.strictEqual(r.pubkey, pk);
-});
-
-test('finds by text search in decoded_json', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'fpn3', decoded_json: JSON.stringify({ name: 'MySpecialNode' }) }));
-  const r = store.findPacketsForNode('MySpecialNode');
-  assert.strictEqual(r.packets.length, 1);
-});
-
-// === Memory optimization: observation deduplication ===
-console.log('\n=== Observation deduplication (transmission_id refs) ===');
-
-test('observations don\'t duplicate transmission fields', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'dedup1', raw_hex: 'FF00FF00', decoded_json: '{"pubKey":"ABCD"}' }));
-  const tx = store.byHash.get('dedup1');
-  assert(tx, 'transmission should exist');
-  assert(tx.observations.length >= 1, 'should have at least 1 observation');
-  const obs = tx.observations[0];
-  // Observation should NOT have its own copies of transmission fields
-  assert(!obs.hasOwnProperty('raw_hex'), 'obs should not have own raw_hex');
-  assert(!obs.hasOwnProperty('decoded_json'), 'obs should not have own decoded_json');
-  // Observation should reference its parent transmission
-  assert(obs.hasOwnProperty('transmission_id'), 'obs should have transmission_id');
-});
-
-test('transmission fields accessible through lookup', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'lookup1', raw_hex: 'DEADBEEF', decoded_json: '{"pubKey":"CAFE"}' }));
-  const tx = store.byHash.get('lookup1');
-  const obs = tx.observations[0];
-  // Look up the transmission via the observation's transmission_id
-  const parentTx = store.byTxId.get(obs.transmission_id);
-  assert(parentTx, 'should find parent transmission via transmission_id');
-  assert.strictEqual(parentTx.raw_hex, 'DEADBEEF');
-  assert.strictEqual(parentTx.decoded_json, '{"pubKey":"CAFE"}');
-  assert.strictEqual(parentTx.hash, 'lookup1');
-});
-
-test('query results still contain transmission fields (backward compat)', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'compat1', raw_hex: 'AABB', decoded_json: '{"test":true}' }));
-  const r = store.query();
-  assert.strictEqual(r.total, 1);
-  const pkt = r.packets[0];
-  // Query results (transmissions) should still have these fields
-  assert.strictEqual(pkt.raw_hex, 'AABB');
-  assert.strictEqual(pkt.decoded_json, '{"test":true}');
-  assert.strictEqual(pkt.hash, 'compat1');
-});
-
-test('all() results contain transmission fields', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'allcompat1', raw_hex: 'CCDD', decoded_json: '{"x":1}' }));
-  const pkts = store.all();
-  assert.strictEqual(pkts.length, 1);
-  assert.strictEqual(pkts[0].raw_hex, 'CCDD');
-  assert.strictEqual(pkts[0].decoded_json, '{"x":1}');
-});
-
-test('multiple observations share one transmission', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'shared1', observer_id: 'obs-A', raw_hex: 'FFFF' }));
-  store.insert(makePacketData({ hash: 'shared1', observer_id: 'obs-B', raw_hex: 'FFFF' }));
-  store.insert(makePacketData({ hash: 'shared1', observer_id: 'obs-C', raw_hex: 'FFFF' }));
-  // Only 1 transmission should exist
-  assert.strictEqual(store.packets.length, 1);
-  const tx = store.byHash.get('shared1');
-  assert.strictEqual(tx.observations.length, 3);
-  // All observations should reference the same transmission_id
-  const txId = tx.observations[0].transmission_id;
-  assert(txId != null, 'transmission_id should be set');
-  assert.strictEqual(tx.observations[1].transmission_id, txId);
-  assert.strictEqual(tx.observations[2].transmission_id, txId);
-  // Only 1 entry in byTxId for this transmission
-  assert(store.byTxId.has(txId), 'byTxId should have the shared transmission');
-});
-
-test('getSiblings still returns observation data after dedup', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'sibdedup1', observer_id: 'obs-X', snr: 5.0 }));
-  store.insert(makePacketData({ hash: 'sibdedup1', observer_id: 'obs-Y', snr: 9.0 }));
-  const sibs = store.getSiblings('sibdedup1');
-  assert.strictEqual(sibs.length, 2);
-  // Each sibling should have observer-specific fields
-  const obsIds = sibs.map(s => s.observer_id).sort();
-  assert.deepStrictEqual(obsIds, ['obs-X', 'obs-Y']);
-});
-
-test('queryGrouped still returns transmission fields after dedup', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  store.insert(makePacketData({ hash: 'grpdedup1', raw_hex: 'AABB', decoded_json: '{"g":1}', observer_id: 'o1' }));
-  store.insert(makePacketData({ hash: 'grpdedup1', observer_id: 'o2' }));
-  const r = store.queryGrouped();
-  assert.strictEqual(r.total, 1);
-  const g = r.packets[0];
-  assert.strictEqual(g.raw_hex, 'AABB');
-  assert.strictEqual(g.decoded_json, '{"g":1}');
-  assert.strictEqual(g.observation_count, 2);
-});
-
-test('memory estimate reflects deduplication savings', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-  // Insert 50 unique transmissions, each with 5 observers
-  const longHex = 'AA'.repeat(200);
-  const longJson = JSON.stringify({ pubKey: 'BB'.repeat(32), name: 'TestNode', data: 'X'.repeat(200) });
-  for (let i = 0; i < 50; i++) {
-    for (let j = 0; j < 5; j++) {
-      store.insert(makePacketData({
-        hash: `mem${i}`,
-        observer_id: `obs-mem-${j}`,
-        raw_hex: longHex,
-        decoded_json: longJson,
-      }));
-    }
-  }
-  assert.strictEqual(store.packets.length, 50);
-  // Verify observations don't bloat memory with duplicate strings
-  let obsWithRawHex = 0;
-  for (const tx of store.packets) {
-    for (const obs of tx.observations) {
-      if (obs.hasOwnProperty('raw_hex')) obsWithRawHex++;
-    }
-  }
-  assert.strictEqual(obsWithRawHex, 0, 'no observation should have own raw_hex property');
-});
-
-// === Regression: packetsLastHour must count live-appended observations (#182) ===
-console.log('\n=== packetsLastHour byObserver regression (#182) ===');
-
-test('byObserver counts recent packets regardless of insertion order', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-
-  const twoHoursAgo = new Date(Date.now() - 7200000).toISOString();
-  const thirtyMinAgo = new Date(Date.now() - 1800000).toISOString();
-  const fiveMinAgo   = new Date(Date.now() - 300000).toISOString();
-
-  // Simulate initial DB load: oldest packets pushed first (as if loaded DESC then reversed)
-  store.insert(makePacketData({ hash: 'old1', timestamp: twoHoursAgo, observer_id: 'obs-hr' }));
-  // Simulate live-ingested packet (appended at end, most recent)
-  store.insert(makePacketData({ hash: 'new1', timestamp: thirtyMinAgo, observer_id: 'obs-hr' }));
-  store.insert(makePacketData({ hash: 'new2', timestamp: fiveMinAgo, observer_id: 'obs-hr' }));
-
-  const obsPackets = store.byObserver.get('obs-hr');
-  assert.strictEqual(obsPackets.length, 3, 'should have 3 observations');
-
-  // Count packets in the last hour — the same way the fixed /api/observers does
-  const oneHourAgo = new Date(Date.now() - 3600000).toISOString();
-  let count = 0;
-  for (const obs of obsPackets) {
-    if (obs.timestamp > oneHourAgo) count++;
-  }
-  assert.strictEqual(count, 2, 'should count 2 recent packets, not 0 (regression #182)');
-});
-
-test('byObserver early-break bug: old item at front must not abort count', () => {
-  const store = new PacketStore(createMockDb());
-  store.load();
-
-  const twoHoursAgo = new Date(Date.now() - 7200000).toISOString();
-  const tenMinAgo   = new Date(Date.now() - 600000).toISOString();
-
-  // Old observation first, then recent — simulates the mixed-order array
-  store.insert(makePacketData({ hash: 'h1', timestamp: twoHoursAgo, observer_id: 'obs-bug' }));
-  store.insert(makePacketData({ hash: 'h2', timestamp: tenMinAgo,   observer_id: 'obs-bug' }));
-
-  const obsPackets = store.byObserver.get('obs-bug');
-  const oneHourAgo = new Date(Date.now() - 3600000).toISOString();
-
-  // BUGGY code (break on first old item) would return 0 here
-  let count = 0;
-  for (const obs of obsPackets) {
-    if (obs.timestamp > oneHourAgo) count++;
-  }
-  assert.strictEqual(count, 1, 'must not skip recent packet after old one');
-});
-
-// === Summary ===
-console.log(`\n${passed} passed, ${failed} failed`);
-if (failed > 0) process.exit(1);

test-regional-filter.js

@@ -1,135 +0,0 @@
-#!/usr/bin/env node
-// Test: Regional hop resolution filtering
-// Validates that resolve-hops correctly filters candidates by geography and observer region
-
-const { IATA_COORDS, haversineKm, nodeNearRegion } = require('./iata-coords');
-
-let pass = 0, fail = 0;
-
-function assert(condition, msg) {
-  if (condition) { pass++; console.log(`  ✅ ${msg}`); }
-  else { fail++; console.error(`  ❌ FAIL: ${msg}`); }
-}
-
-// === 1. Haversine distance tests ===
-console.log('\n=== Haversine Distance ===');
-
-const sjcToSea = haversineKm(37.3626, -121.9290, 47.4502, -122.3088);
-assert(sjcToSea > 1100 && sjcToSea < 1150, `SJC→SEA = ${Math.round(sjcToSea)}km (expect ~1125km)`);
-
-const sjcToOak = haversineKm(37.3626, -121.9290, 37.7213, -122.2208);
-assert(sjcToOak > 40 && sjcToOak < 55, `SJC→OAK = ${Math.round(sjcToOak)}km (expect ~48km)`);
-
-const sjcToSjc = haversineKm(37.3626, -121.9290, 37.3626, -121.9290);
-assert(sjcToSjc === 0, `SJC→SJC = ${sjcToSjc}km (expect 0)`);
-
-const sjcToEug = haversineKm(37.3626, -121.9290, 44.1246, -123.2119);
-assert(sjcToEug > 750 && sjcToEug < 780, `SJC→EUG = ${Math.round(sjcToEug)}km (expect ~762km)`);
-
-// === 2. nodeNearRegion tests ===
-console.log('\n=== Node Near Region ===');
-
-// Node in San Jose, check against SJC region
-const sjNode = nodeNearRegion(37.35, -121.95, 'SJC');
-assert(sjNode && sjNode.near, `San Jose node near SJC: ${sjNode.distKm}km`);
-
-// Node in Seattle, check against SJC region — should NOT be near
-const seaNode = nodeNearRegion(47.45, -122.30, 'SJC');
-assert(seaNode && !seaNode.near, `Seattle node NOT near SJC: ${seaNode.distKm}km`);
-
-// Node in Seattle, check against SEA region — should be near
-const seaNodeSea = nodeNearRegion(47.45, -122.30, 'SEA');
-assert(seaNodeSea && seaNodeSea.near, `Seattle node near SEA: ${seaNodeSea.distKm}km`);
-
-// Node in Eugene, check against EUG — should be near
-const eugNode = nodeNearRegion(44.05, -123.10, 'EUG');
-assert(eugNode && eugNode.near, `Eugene node near EUG: ${eugNode.distKm}km`);
-
-// Eugene node should NOT be near SJC (~762km)
-const eugNodeSjc = nodeNearRegion(44.05, -123.10, 'SJC');
-assert(eugNodeSjc && !eugNodeSjc.near, `Eugene node NOT near SJC: ${eugNodeSjc.distKm}km`);
-
-// Node with no location — returns null
-const noLoc = nodeNearRegion(null, null, 'SJC');
-assert(noLoc === null, 'Null lat/lon returns null');
-
-// Node at 0,0 — returns null
-const zeroLoc = nodeNearRegion(0, 0, 'SJC');
-assert(zeroLoc === null, 'Zero lat/lon returns null');
-
-// Unknown IATA — returns null
-const unkIata = nodeNearRegion(37.35, -121.95, 'ZZZ');
-assert(unkIata === null, 'Unknown IATA returns null');
-
-// === 3. Edge cases: nodes just inside/outside 300km radius ===
-console.log('\n=== Boundary Tests (300km radius) ===');
-
-// Sacramento is ~145km from SJC — inside
-const smfNode = nodeNearRegion(38.58, -121.49, 'SJC');
-assert(smfNode && smfNode.near, `Sacramento near SJC: ${smfNode.distKm}km (expect ~145)`);
-
-// Fresno is ~235km from SJC — inside
-const fatNode = nodeNearRegion(36.74, -119.79, 'SJC');
-assert(fatNode && fatNode.near, `Fresno near SJC: ${fatNode.distKm}km (expect ~235)`);
-
-// Redding is ~400km from SJC — outside
-const rddNode = nodeNearRegion(40.59, -122.39, 'SJC');
-assert(rddNode && !rddNode.near, `Redding NOT near SJC: ${rddNode.distKm}km (expect ~400)`);
-
-// === 4. Simulate the core issue: 1-byte hop with cross-regional collision ===
-console.log('\n=== Cross-Regional Collision Simulation ===');
-
-// Two nodes with pubkeys starting with "D6": one in SJC area, one in SEA area
-const candidates = [
-  { name: 'Redwood Mt. Tam', pubkey: 'D6...sjc', lat: 37.92, lon: -122.60 },  // Marin County, CA
-  { name: 'VE7RSC North Repeater', pubkey: 'D6...sea', lat: 49.28, lon: -123.12 }, // Vancouver, BC
-  { name: 'KK7RXY Lynden', pubkey: 'D6...bel', lat: 48.94, lon: -122.47 }, // Bellingham, WA
-];
-
-// Packet observed in SJC region
-const packetIata = 'SJC';
-const geoFiltered = candidates.filter(c => {
-  const check = nodeNearRegion(c.lat, c.lon, packetIata);
-  return check && check.near;
-});
-assert(geoFiltered.length === 1, `Geo filter SJC: ${geoFiltered.length} candidates (expect 1)`);
-assert(geoFiltered[0].name === 'Redwood Mt. Tam', `Winner: ${geoFiltered[0].name} (expect Redwood Mt. Tam)`);
-
-// Packet observed in SEA region
-const seaFiltered = candidates.filter(c => {
-  const check = nodeNearRegion(c.lat, c.lon, 'SEA');
-  return check && check.near;
-});
-assert(seaFiltered.length === 2, `Geo filter SEA: ${seaFiltered.length} candidates (expect 2 — Vancouver + Bellingham)`);
-
-// Packet observed in EUG region — Eugene is ~300km from SEA nodes
-const eugFiltered = candidates.filter(c => {
-  const check = nodeNearRegion(c.lat, c.lon, 'EUG');
-  return check && check.near;
-});
-assert(eugFiltered.length === 0, `Geo filter EUG: ${eugFiltered.length} candidates (expect 0 — all too far)`);
-
-// === 5. Layered fallback logic ===
-console.log('\n=== Layered Fallback ===');
-
-const nodeWithGps = { lat: 37.92, lon: -122.60 }; // has GPS
-const nodeNoGps = { lat: null, lon: null }; // no GPS
-const observerSawNode = true; // observer-based filter says yes
-
-// Layer 1: GPS check
-const gpsCheck = nodeNearRegion(nodeWithGps.lat, nodeWithGps.lon, 'SJC');
-assert(gpsCheck && gpsCheck.near, 'Layer 1 (GPS): node with GPS near SJC');
-
-// Layer 2: No GPS, fall back to observer
-const gpsCheckNoLoc = nodeNearRegion(nodeNoGps.lat, nodeNoGps.lon, 'SJC');
-assert(gpsCheckNoLoc === null, 'Layer 2: no GPS returns null → use observer-based fallback');
-
-// Bridged WA node with GPS — should be REJECTED by SJC even though observer saw it
-const bridgedWaNode = { lat: 47.45, lon: -122.30 }; // Seattle
-const bridgedCheck = nodeNearRegion(bridgedWaNode.lat, bridgedWaNode.lon, 'SJC');
-assert(bridgedCheck && !bridgedCheck.near, `Bridge test: WA node rejected by SJC geo filter (${bridgedCheck.distKm}km)`);
-
-// === Summary ===
-console.log(`\n${'='.repeat(40)}`);
-console.log(`Results: ${pass} passed, ${fail} failed`);
-process.exit(fail > 0 ? 1 : 0);

test-regional-integration.js

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-// Integration test: Verify layered filtering works against live prod API
-// Tests that resolve-hops returns regional metadata and correct filtering
-
-const https = require('https');
-const BASE = 'https://analyzer.00id.net';
-
-function apiGet(path) {
-  return new Promise((resolve, reject) => {
-    https.get(BASE + path, { timeout: 10000 }, (res) => {
-      let data = '';
-      res.on('data', d => data += d);
-      res.on('end', () => { try { resolve(JSON.parse(data)); } catch (e) { reject(e); } });
-    }).on('error', reject);
-  });
-}
-
-let pass = 0, fail = 0;
-function assert(condition, msg) {
-  if (condition) { pass++; console.log(`  ✅ ${msg}`); }
-  else { fail++; console.error(`  ❌ FAIL: ${msg}`); }
-}
-
-async function run() {
-  console.log('\n=== Integration: resolve-hops API with regional filtering ===\n');
-
-  // 1. Get a packet with short hops and a known observer
-  const packets = await apiGet('/api/packets?limit=100&groupByHash=true');
-  const pkt = packets.packets.find(p => {
-    const path = JSON.parse(p.path_json || '[]');
-    return path.length > 0 && path.some(h => h.length <= 2) && p.observer_id;
-  });
-
-  if (!pkt) {
-    console.log('  ⚠ No packets with short hops found — skipping API tests');
-    return;
-  }
-
-  const path = JSON.parse(pkt.path_json);
-  const shortHops = path.filter(h => h.length <= 2);
-  console.log(`  Using packet ${pkt.hash.slice(0,12)} observed by ${pkt.observer_name || pkt.observer_id.slice(0,12)}`);
-  console.log(`  Path: ${path.join(' → ')} (${shortHops.length} short hops)`);
-
-  // 2. Resolve WITH observer (should get regional filtering)
-  const withObs = await apiGet(`/api/resolve-hops?hops=${path.join(',')}&observer=${pkt.observer_id}`);
-
-  assert(withObs.region != null, `Response includes region: ${withObs.region}`);
-
-  // 3. Check that conflicts have filterMethod field
-  let hasFilterMethod = false;
-  let hasDistKm = false;
-  for (const [hop, info] of Object.entries(withObs.resolved)) {
-    if (info.conflicts && info.conflicts.length > 0) {
-      for (const c of info.conflicts) {
-        if (c.filterMethod) hasFilterMethod = true;
-        if (c.distKm != null) hasDistKm = true;
-      }
-    }
-    if (info.filterMethods) {
-      assert(Array.isArray(info.filterMethods), `Hop ${hop}: filterMethods is array: ${JSON.stringify(info.filterMethods)}`);
-    }
-  }
-  assert(hasFilterMethod, 'At least one conflict has filterMethod');
-
-  // 4. Resolve WITHOUT observer (no regional filtering)
-  const withoutObs = await apiGet(`/api/resolve-hops?hops=${path.join(',')}`);
-  assert(withoutObs.region === null, `Without observer: region is null`);
-
-  // 5. Compare: with observer should have same or fewer candidates per ambiguous hop
-  for (const hop of shortHops) {
-    const withInfo = withObs.resolved[hop];
-    const withoutInfo = withoutObs.resolved[hop];
-    if (withInfo && withoutInfo && withInfo.conflicts && withoutInfo.conflicts) {
-      const withCount = withInfo.totalRegional || withInfo.conflicts.length;
-      const withoutCount = withoutInfo.totalGlobal || withoutInfo.conflicts.length;
-      assert(withCount <= withoutCount + 1,
-        `Hop ${hop}: regional(${withCount}) <= global(${withoutCount}) — ${withInfo.name || '?'}`);
-    }
-  }
-
-  // 6. Check that geo-filtered candidates have distKm
-  for (const [hop, info] of Object.entries(withObs.resolved)) {
-    if (info.conflicts) {
-      const geoFiltered = info.conflicts.filter(c => c.filterMethod === 'geo');
-      for (const c of geoFiltered) {
-        assert(c.distKm != null, `Hop ${hop} candidate ${c.name}: has distKm=${c.distKm}km (geo filter)`);
-      }
-    }
-  }
-
-  console.log(`\n${'='.repeat(40)}`);
-  console.log(`Results: ${pass} passed, ${fail} failed`);
-  process.exit(fail > 0 ? 1 : 0);
-}
-
-run().catch(e => { console.error('Test error:', e); process.exit(1); });

test-server-helpers.js

@@ -1,319 +0,0 @@
-'use strict';
-
-const helpers = require('./server-helpers');
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-let passed = 0, failed = 0;
-function assert(cond, msg) {
-  if (cond) { passed++; console.log(`  ✅ ${msg}`); }
-  else { failed++; console.error(`  ❌ ${msg}`); }
-}
-
-console.log('── server-helpers tests ──\n');
-
-// --- loadConfigFile ---
-console.log('loadConfigFile:');
-{
-  // Returns {} when no files exist
-  const result = helpers.loadConfigFile(['/nonexistent/path.json']);
-  assert(typeof result === 'object' && Object.keys(result).length === 0, 'returns {} for missing files');
-
-  // Loads valid JSON
-  const tmp = path.join(os.tmpdir(), `test-config-${Date.now()}.json`);
-  fs.writeFileSync(tmp, JSON.stringify({ hello: 'world' }));
-  const result2 = helpers.loadConfigFile([tmp]);
-  assert(result2.hello === 'world', 'loads valid JSON file');
-  fs.unlinkSync(tmp);
-
-  // Falls back to second path
-  const tmp2 = path.join(os.tmpdir(), `test-config2-${Date.now()}.json`);
-  fs.writeFileSync(tmp2, JSON.stringify({ fallback: true }));
-  const result3 = helpers.loadConfigFile(['/nonexistent.json', tmp2]);
-  assert(result3.fallback === true, 'falls back to second path');
-  fs.unlinkSync(tmp2);
-
-  // Handles malformed JSON
-  const tmp3 = path.join(os.tmpdir(), `test-config3-${Date.now()}.json`);
-  fs.writeFileSync(tmp3, 'not json{{{');
-  const result4 = helpers.loadConfigFile([tmp3]);
-  assert(Object.keys(result4).length === 0, 'returns {} for malformed JSON');
-  fs.unlinkSync(tmp3);
-}
-
-// --- loadThemeFile ---
-console.log('\nloadThemeFile:');
-{
-  const result = helpers.loadThemeFile(['/nonexistent/theme.json']);
-  assert(typeof result === 'object' && Object.keys(result).length === 0, 'returns {} for missing files');
-
-  const tmp = path.join(os.tmpdir(), `test-theme-${Date.now()}.json`);
-  fs.writeFileSync(tmp, JSON.stringify({ theme: { accent: '#ff0000' } }));
-  const result2 = helpers.loadThemeFile([tmp]);
-  assert(result2.theme.accent === '#ff0000', 'loads theme file');
-  fs.unlinkSync(tmp);
-}
-
-// --- buildHealthConfig ---
-console.log('\nbuildHealthConfig:');
-{
-  const h = helpers.buildHealthConfig({});
-  assert(h.infraDegradedMs === 86400000, 'default infraDegradedMs');
-  assert(h.infraSilentMs === 259200000, 'default infraSilentMs');
-  assert(h.nodeDegradedMs === 3600000, 'default nodeDegradedMs');
-  assert(h.nodeSilentMs === 86400000, 'default nodeSilentMs');
-
-  const h2 = helpers.buildHealthConfig({ healthThresholds: { infraDegradedMs: 1000 } });
-  assert(h2.infraDegradedMs === 1000, 'custom infraDegradedMs');
-  assert(h2.nodeDegradedMs === 3600000, 'other defaults preserved');
-
-  const h3 = helpers.buildHealthConfig(null);
-  assert(h3.infraDegradedMs === 86400000, 'handles null config');
-}
-
-// --- getHealthMs ---
-console.log('\ngetHealthMs:');
-{
-  const HEALTH = helpers.buildHealthConfig({});
-
-  const rep = helpers.getHealthMs('repeater', HEALTH);
-  assert(rep.degradedMs === 86400000, 'repeater uses infra degraded');
-  assert(rep.silentMs === 259200000, 'repeater uses infra silent');
-
-  const room = helpers.getHealthMs('room', HEALTH);
-  assert(room.degradedMs === 86400000, 'room uses infra degraded');
-
-  const comp = helpers.getHealthMs('companion', HEALTH);
-  assert(comp.degradedMs === 3600000, 'companion uses node degraded');
-  assert(comp.silentMs === 86400000, 'companion uses node silent');
-
-  const sensor = helpers.getHealthMs('sensor', HEALTH);
-  assert(sensor.degradedMs === 3600000, 'sensor uses node degraded');
-
-  const undef = helpers.getHealthMs(undefined, HEALTH);
-  assert(undef.degradedMs === 3600000, 'undefined role uses node degraded');
-}
-
-// --- isHashSizeFlipFlop ---
-console.log('\nisHashSizeFlipFlop:');
-{
-  assert(helpers.isHashSizeFlipFlop(null, null) === false, 'null seq returns false');
-  assert(helpers.isHashSizeFlipFlop([1, 2], new Set([1, 2])) === false, 'too few samples');
-  assert(helpers.isHashSizeFlipFlop([1, 1, 1], new Set([1])) === false, 'single size');
-  assert(helpers.isHashSizeFlipFlop([1, 1, 1, 2, 2, 2], new Set([1, 2])) === false, 'clean upgrade (1 transition)');
-  assert(helpers.isHashSizeFlipFlop([1, 2, 1], new Set([1, 2])) === true, 'flip-flop detected');
-  assert(helpers.isHashSizeFlipFlop([1, 2, 1, 2], new Set([1, 2])) === true, 'repeated flip-flop');
-  assert(helpers.isHashSizeFlipFlop([2, 1, 2], new Set([1, 2])) === true, 'reverse flip-flop');
-  assert(helpers.isHashSizeFlipFlop([1, 2, 3], new Set([1, 2, 3])) === true, 'three sizes, 2 transitions');
-}
-
-// --- computeContentHash ---
-console.log('\ncomputeContentHash:');
-{
-  // Minimal packet: header + path byte + payload
-  // header=0x04, path_byte=0x00 (hash_size=1, 0 hops), payload=0xABCD
-  const hex1 = '0400abcd';
-  const h1 = helpers.computeContentHash(hex1);
-  assert(typeof h1 === 'string' && h1.length === 16, 'returns 16-char hash');
-
-  // Same payload, different path should give same hash
-  // header=0x04, path_byte=0x41 (hash_size=2, 1 hop), path=0x1234, payload=0xABCD
-  const hex2 = '04411234abcd';
-  const h2 = helpers.computeContentHash(hex2);
-  assert(h1 === h2, 'same content different path = same hash');
-
-  // Different payload = different hash
-  const hex3 = '0400ffff';
-  const h3 = helpers.computeContentHash(hex3);
-  assert(h3 !== h1, 'different payload = different hash');
-
-  // Very short hex
-  const h4 = helpers.computeContentHash('04');
-  assert(h4 === '04', 'short hex returns prefix');
-
-  // Invalid hex
-  const h5 = helpers.computeContentHash('xyz');
-  assert(typeof h5 === 'string', 'handles invalid hex gracefully');
-}
-
-// --- geoDist ---
-console.log('\ngeoDist:');
-{
-  assert(helpers.geoDist(0, 0, 0, 0) === 0, 'same point = 0');
-  assert(helpers.geoDist(0, 0, 3, 4) === 5, 'pythagorean triple');
-  assert(helpers.geoDist(37.7749, -122.4194, 37.7749, -122.4194) === 0, 'SF to SF = 0');
-  const d = helpers.geoDist(37.0, -122.0, 38.0, -122.0);
-  assert(Math.abs(d - 1.0) < 0.001, '1 degree latitude diff');
-}
-
-// --- deriveHashtagChannelKey ---
-console.log('\nderiveHashtagChannelKey:');
-{
-  const k1 = helpers.deriveHashtagChannelKey('test');
-  assert(typeof k1 === 'string' && k1.length === 32, 'returns 32-char key');
-  const k2 = helpers.deriveHashtagChannelKey('test');
-  assert(k1 === k2, 'deterministic');
-  const k3 = helpers.deriveHashtagChannelKey('other');
-  assert(k3 !== k1, 'different input = different key');
-}
-
-// --- buildBreakdown ---
-console.log('\nbuildBreakdown:');
-{
-  const r1 = helpers.buildBreakdown(null, null, null, null);
-  assert(JSON.stringify(r1) === '{}', 'null rawHex returns empty');
-
-  const r2 = helpers.buildBreakdown('04', null, null, null);
-  assert(r2.ranges.length === 1, 'single-byte returns header only');
-  assert(r2.ranges[0].label === 'Header', 'header range');
-
-  // 2 bytes: header + path byte, no payload
-  const r3 = helpers.buildBreakdown('0400', null, null, null);
-  assert(r3.ranges.length === 2, 'two bytes: header + path length');
-  assert(r3.ranges[1].label === 'Path Length', 'path length range');
-
-  // With payload: header=04, path_byte=00, payload=abcd
-  const r4 = helpers.buildBreakdown('0400abcd', null, null, null);
-  assert(r4.ranges.some(r => r.label === 'Payload'), 'has payload range');
-
-  // With path hops: header=04, path_byte=0x41 (size=2, count=1), path=1234, payload=ff
-  const r5 = helpers.buildBreakdown('04411234ff', null, null, null);
-  assert(r5.ranges.some(r => r.label === 'Path'), 'has path range');
-
-  // ADVERT with enough payload
-  // flags=0x90 (0x10=GPS + 0x80=Name)
-  const advertHex = '0400' + 'aa'.repeat(32) + 'bb'.repeat(4) + 'cc'.repeat(64) + '90' + 'dddddddddddddddd' + '48656c6c6f';
-  const r6 = helpers.buildBreakdown(advertHex, { type: 'ADVERT' }, null, null);
-  assert(r6.ranges.some(r => r.label === 'PubKey'), 'ADVERT has PubKey sub-range');
-  assert(r6.ranges.some(r => r.label === 'Flags'), 'ADVERT has Flags sub-range');
-  assert(r6.ranges.some(r => r.label === 'Latitude'), 'ADVERT with GPS flag has Latitude');
-  assert(r6.ranges.some(r => r.label === 'Name'), 'ADVERT with name flag has Name');
-}
-
-// --- disambiguateHops ---
-console.log('\ndisambiguateHops:');
-{
-  const nodes = [
-    { public_key: 'aabb11223344', name: 'Node-A', lat: 37.0, lon: -122.0 },
-    { public_key: 'ccdd55667788', name: 'Node-C', lat: 37.1, lon: -122.1 },
-  ];
-  // Single unique match
-  const r1 = helpers.disambiguateHops(['aabb'], nodes);
-  assert(r1.length === 1, 'resolves single hop');
-  assert(r1[0].name === 'Node-A', 'resolves to correct node');
-  assert(r1[0].pubkey === 'aabb11223344', 'includes pubkey');
-
-  // Unknown hop
-  delete nodes._prefixIdx; delete nodes._prefixIdxName;
-  const r2 = helpers.disambiguateHops(['ffff'], nodes);
-  assert(r2[0].name === 'ffff', 'unknown hop uses hex as name');
-
-  // Multiple hops
-  delete nodes._prefixIdx; delete nodes._prefixIdxName;
-  const r3 = helpers.disambiguateHops(['aabb', 'ccdd'], nodes);
-  assert(r3.length === 2, 'resolves multiple hops');
-  assert(r3[0].name === 'Node-A' && r3[1].name === 'Node-C', 'both resolved');
-}
-
-// --- updateHashSizeForPacket ---
-console.log('\nupdateHashSizeForPacket:');
-{
-  const map = new Map(), allMap = new Map(), seqMap = new Map();
-
-  // ADVERT packet (payload_type=4)
-  // path byte 0x40 = hash_size 2 (bits 7-6 = 01)
-  const p1 = {
-    payload_type: 4,
-    raw_hex: '0440' + 'aa'.repeat(100),
-    decoded_json: JSON.stringify({ pubKey: 'abc123' }),
-    path_json: null
-  };
-  helpers.updateHashSizeForPacket(p1, map, allMap, seqMap);
-  assert(map.get('abc123') === 2, 'ADVERT sets hash_size=2');
-  assert(allMap.get('abc123').has(2), 'all map has size 2');
-  assert(seqMap.get('abc123')[0] === 2, 'seq map records size');
-
-  // Non-ADVERT with path_json fallback
-  const map2 = new Map(), allMap2 = new Map(), seqMap2 = new Map();
-  const p2 = {
-    payload_type: 1,
-    raw_hex: '0140ff',  // path byte 0x40 = hash_size 2
-    decoded_json: JSON.stringify({ pubKey: 'def456' }),
-    path_json: JSON.stringify(['aabb'])
-  };
-  helpers.updateHashSizeForPacket(p2, map2, allMap2, seqMap2);
-  assert(map2.get('def456') === 2, 'non-ADVERT falls back to path byte');
-
-  // Already-parsed decoded_json (object, not string)
-  const map3 = new Map(), allMap3 = new Map(), seqMap3 = new Map();
-  const p3 = {
-    payload_type: 4,
-    raw_hex: '04c0' + 'aa'.repeat(100),  // 0xC0 = bits 7-6 = 11 = hash_size 4
-    decoded_json: { pubKey: 'ghi789' },
-    path_json: null
-  };
-  helpers.updateHashSizeForPacket(p3, map3, allMap3, seqMap3);
-  assert(map3.get('ghi789') === 4, 'handles object decoded_json');
-}
-
-// --- rebuildHashSizeMap ---
-console.log('\nrebuildHashSizeMap:');
-{
-  const map = new Map(), allMap = new Map(), seqMap = new Map();
-  const packets = [
-    // Newest first (as packet store provides)
-    { payload_type: 4, raw_hex: '0480' + 'bb'.repeat(50), decoded_json: JSON.stringify({ pubKey: 'node1' }), path_json: null },
-    { payload_type: 4, raw_hex: '0440' + 'aa'.repeat(50), decoded_json: JSON.stringify({ pubKey: 'node1' }), path_json: null },
-  ];
-  helpers.rebuildHashSizeMap(packets, map, allMap, seqMap);
-  assert(map.get('node1') === 3, 'first seen (newest) wins for map');
-  assert(allMap.get('node1').size === 2, 'all map has both sizes');
-  // Seq should be reversed to chronological: [2, 3]
-  const seq = seqMap.get('node1');
-  assert(seq[0] === 2 && seq[1] === 3, 'sequence is chronological (reversed)');
-
-  // Pass 2 fallback: node without advert
-  const map2 = new Map(), allMap2 = new Map(), seqMap2 = new Map();
-  const packets2 = [
-    { payload_type: 1, raw_hex: '0140ff', decoded_json: JSON.stringify({ pubKey: 'node2' }), path_json: JSON.stringify(['aabb']) },
-  ];
-  helpers.rebuildHashSizeMap(packets2, map2, allMap2, seqMap2);
-  assert(map2.get('node2') === 2, 'pass 2 fallback from path');
-}
-
-// --- requireApiKey ---
-console.log('\nrequireApiKey:');
-{
-  // No API key configured
-  const mw1 = helpers.requireApiKey(null);
-  let nextCalled = false;
-  mw1({headers: {}, query: {}}, {}, () => { nextCalled = true; });
-  assert(nextCalled, 'no key configured = passes through');
-
-  // Valid key
-  const mw2 = helpers.requireApiKey('secret123');
-  nextCalled = false;
-  mw2({headers: {'x-api-key': 'secret123'}, query: {}}, {}, () => { nextCalled = true; });
-  assert(nextCalled, 'valid header key passes');
-
-  // Valid key via query
-  nextCalled = false;
-  mw2({headers: {}, query: {apiKey: 'secret123'}}, {}, () => { nextCalled = true; });
-  assert(nextCalled, 'valid query key passes');
-
-  // Invalid key
-  let statusCode = null, jsonBody = null;
-  const mockRes = {
-    status(code) { statusCode = code; return { json(body) { jsonBody = body; } }; }
-  };
-  nextCalled = false;
-  mw2({headers: {'x-api-key': 'wrong'}, query: {}}, mockRes, () => { nextCalled = true; });
-  assert(!nextCalled && statusCode === 401, 'invalid key returns 401');
-}
-
-console.log(`\n═══════════════════════════════════════`);
-console.log(`  PASSED: ${passed}`);
-console.log(`  FAILED: ${failed}`);
-console.log(`═══════════════════════════════════════`);
-if (failed > 0) process.exit(1);

tools/e2e-test.js

@@ -1,476 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * MeshCore Analyzer — End-to-End Validation Test (M12)
- *
- * Starts the server with a temp DB, injects 100+ synthetic packets,
- * validates every API endpoint, WebSocket broadcasts, and optionally MQTT.
- */
-
-const { spawn, execSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-const crypto = require('crypto');
-const WebSocket = require('ws');
-
-const PROJECT_DIR = path.join(__dirname, '..');
-const PORT = 13579; // avoid conflict with dev server
-const BASE = `http://localhost:${PORT}`;
-
-// ── Helpers ──────────────────────────────────────────────────────────
-
-let passed = 0, failed = 0;
-const failures = [];
-
-function assert(cond, label) {
-  if (cond) { passed++; }
-  else { failed++; failures.push(label); console.error(`  ❌ FAIL: ${label}`); }
-}
-
-async function get(path) {
-  const r = await fetch(`${BASE}${path}`);
-  return { status: r.status, data: await r.json() };
-}
-
-async function post(path, body) {
-  const r = await fetch(`${BASE}${path}`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-  });
-  return { status: r.status, data: await r.json() };
-}
-
-function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
-
-// ── Packet generation (inline from generate-packets.js logic) ────────
-
-const OBSERVERS = [
-  { id: 'E2E-SJC-1', iata: 'SJC' },
-  { id: 'E2E-SFO-2', iata: 'SFO' },
-  { id: 'E2E-OAK-3', iata: 'OAK' },
-];
-
-const NODE_NAMES = [
-  'TestNode Alpha', 'TestNode Beta', 'TestNode Gamma', 'TestNode Delta',
-  'TestNode Epsilon', 'TestNode Zeta', 'TestNode Eta', 'TestNode Theta',
-];
-
-function rand(a, b) { return Math.random() * (b - a) + a; }
-function randInt(a, b) { return Math.floor(rand(a, b + 1)); }
-function pick(a) { return a[randInt(0, a.length - 1)]; }
-function randomBytes(n) { return crypto.randomBytes(n); }
-
-function pubkeyFor(name) {
-  return crypto.createHash('sha256').update(name).digest();
-}
-
-function encodeHeader(routeType, payloadType, ver = 0) {
-  return (routeType & 0x03) | ((payloadType & 0x0F) << 2) | ((ver & 0x03) << 6);
-}
-
-function buildPath(hopCount, hashSize = 2) {
-  const pathByte = ((hashSize - 1) << 6) | (hopCount & 0x3F);
-  const hops = crypto.randomBytes(hashSize * hopCount);
-  return { pathByte, hops };
-}
-
-function buildAdvert(name, role) {
-  const pubKey = pubkeyFor(name);
-  const ts = Buffer.alloc(4); ts.writeUInt32LE(Math.floor(Date.now() / 1000));
-  const sig = randomBytes(64);
-  let flags = 0x80 | 0x10; // hasName + hasLocation
-  if (role === 'repeater') flags |= 0x02;
-  else if (role === 'room') flags |= 0x04;
-  else if (role === 'sensor') flags |= 0x08;
-  else flags |= 0x01;
-  const nameBuf = Buffer.from(name, 'utf8');
-  const appdata = Buffer.alloc(9 + nameBuf.length);
-  appdata[0] = flags;
-  appdata.writeInt32LE(Math.round(37.34 * 1e6), 1);
-  appdata.writeInt32LE(Math.round(-121.89 * 1e6), 5);
-  nameBuf.copy(appdata, 9);
-  const payload = Buffer.concat([pubKey, ts, sig, appdata]);
-  const header = encodeHeader(1, 0x04, 0); // FLOOD + ADVERT
-  const { pathByte, hops } = buildPath(randInt(0, 3));
-  return Buffer.concat([Buffer.from([header, pathByte]), hops, payload]);
-}
-
-function buildGrpTxt(channelHash = 0) {
-  const mac = randomBytes(2);
-  const enc = randomBytes(randInt(10, 40));
-  const payload = Buffer.concat([Buffer.from([channelHash]), mac, enc]);
-  const header = encodeHeader(1, 0x05, 0); // FLOOD + GRP_TXT
-  const { pathByte, hops } = buildPath(randInt(0, 3));
-  return Buffer.concat([Buffer.from([header, pathByte]), hops, payload]);
-}
-
-function buildAck() {
-  const payload = randomBytes(18);
-  const header = encodeHeader(2, 0x03, 0);
-  const { pathByte, hops } = buildPath(randInt(0, 2));
-  return Buffer.concat([Buffer.from([header, pathByte]), hops, payload]);
-}
-
-function buildTxtMsg() {
-  const payload = Buffer.concat([randomBytes(6), randomBytes(6), randomBytes(4), randomBytes(20)]);
-  const header = encodeHeader(2, 0x02, 0);
-  const { pathByte, hops } = buildPath(randInt(0, 2));
-  return Buffer.concat([Buffer.from([header, pathByte]), hops, payload]);
-}
-
-// ── Main ─────────────────────────────────────────────────────────────
-
-async function main() {
-  // 1. Create temp DB
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'meshcore-e2e-'));
-  const dbPath = path.join(tmpDir, 'test.db');
-  console.log(`Temp DB: ${dbPath}`);
-
-  // 2. Start server
-  console.log('Starting server...');
-  const srv = spawn('node', ['server.js'], {
-    cwd: PROJECT_DIR,
-    env: { ...process.env, DB_PATH: dbPath, PORT: String(PORT) },
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-
-  let serverOutput = '';
-  srv.stdout.on('data', d => { serverOutput += d; });
-  srv.stderr.on('data', d => { serverOutput += d; });
-
-  // We need the server to respect PORT env — check if config is hard-coded
-  // The server uses config.port from config.json. We need to patch that or
-  // monkey-patch. Let's just use port 3000 if the server doesn't read PORT env.
-  // Actually let me check...
-
-  const cleanup = () => {
-    try { srv.kill('SIGTERM'); } catch {}
-    try { fs.unlinkSync(dbPath); fs.rmdirSync(tmpDir); } catch {}
-  };
-
-  process.on('SIGINT', () => { cleanup(); process.exit(1); });
-  process.on('uncaughtException', (e) => { console.error(e); cleanup(); process.exit(1); });
-
-  // 3. Wait for server ready
-  let ready = false;
-  for (let i = 0; i < 30; i++) {
-    await sleep(500);
-    try {
-      const r = await fetch(`${BASE}/api/stats`);
-      if (r.ok) { ready = true; break; }
-    } catch {}
-  }
-
-  if (!ready) {
-    console.error('Server did not start in time. Output:', serverOutput);
-    cleanup();
-    process.exit(1);
-  }
-  console.log('Server ready.\n');
-
-  // 4. Connect WebSocket
-  const wsMessages = [];
-  const ws = new WebSocket(`ws://localhost:${PORT}`);
-  await new Promise((resolve, reject) => {
-    ws.on('open', resolve);
-    ws.on('error', reject);
-    setTimeout(() => reject(new Error('WS timeout')), 5000);
-  });
-  ws.on('message', (data) => {
-    try { wsMessages.push(JSON.parse(data.toString())); } catch {}
-  });
-  console.log('WebSocket connected.\n');
-
-  // 5. Generate and inject packets
-  const roles = ['repeater', 'room', 'companion', 'sensor'];
-  const injected = [];
-  const advertNodes = {}; // name -> {role, pubkey, count}
-  const grpTxtCount = { total: 0, byChannel: {} };
-  const observerCounts = {}; // id -> count
-  const hashToObservers = {}; // hash -> Set(observer)
-
-  // Generate ADVERT packets — ensure at least one of each role
-  for (let ri = 0; ri < roles.length; ri++) {
-    const name = NODE_NAMES[ri];
-    const role = roles[ri];
-    const buf = buildAdvert(name, role);
-    const hex = buf.toString('hex').toUpperCase();
-    const hash = crypto.createHash('md5').update(hex).digest('hex').slice(0, 16);
-    const obs = OBSERVERS[ri % OBSERVERS.length];
-    injected.push({ hex, observer: obs.id, region: obs.iata, hash, snr: 5.0, rssi: -80 });
-    advertNodes[name] = { role, pubkey: pubkeyFor(name).toString('hex'), count: 1 };
-    observerCounts[obs.id] = (observerCounts[obs.id] || 0) + 1;
-    if (!hashToObservers[hash]) hashToObservers[hash] = new Set();
-    hashToObservers[hash].add(obs.id);
-  }
-
-  // More ADVERTs
-  for (let i = 0; i < 40; i++) {
-    const name = pick(NODE_NAMES);
-    const role = pick(roles);
-    const buf = buildAdvert(name, role);
-    const hex = buf.toString('hex').toUpperCase();
-    const hash = crypto.createHash('md5').update(hex).digest('hex').slice(0, 16);
-    // Multi-observer: 30% chance heard by 2 observers
-    const obsCount = Math.random() < 0.3 ? 2 : 1;
-    const shuffled = [...OBSERVERS].sort(() => Math.random() - 0.5);
-    for (let o = 0; o < obsCount; o++) {
-      const obs = shuffled[o];
-      injected.push({ hex, observer: obs.id, region: obs.iata, hash, snr: rand(-2, 10), rssi: rand(-110, -60) });
-      observerCounts[obs.id] = (observerCounts[obs.id] || 0) + 1;
-      if (!hashToObservers[hash]) hashToObservers[hash] = new Set();
-      hashToObservers[hash].add(obs.id);
-    }
-    if (!advertNodes[name]) advertNodes[name] = { role, pubkey: pubkeyFor(name).toString('hex'), count: 0 };
-    advertNodes[name].count++;
-  }
-
-  // GRP_TXT packets
-  for (let i = 0; i < 30; i++) {
-    const ch = randInt(0, 3);
-    const buf = buildGrpTxt(ch);
-    const hex = buf.toString('hex').toUpperCase();
-    const hash = crypto.createHash('md5').update(hex).digest('hex').slice(0, 16);
-    const obs = pick(OBSERVERS);
-    injected.push({ hex, observer: obs.id, region: obs.iata, hash, snr: 3.0, rssi: -90 });
-    grpTxtCount.total++;
-    grpTxtCount.byChannel[ch] = (grpTxtCount.byChannel[ch] || 0) + 1;
-    observerCounts[obs.id] = (observerCounts[obs.id] || 0) + 1;
-    if (!hashToObservers[hash]) hashToObservers[hash] = new Set();
-    hashToObservers[hash].add(obs.id);
-  }
-
-  // ACK + TXT_MSG
-  for (let i = 0; i < 20; i++) {
-    const buf = i < 10 ? buildAck() : buildTxtMsg();
-    const hex = buf.toString('hex').toUpperCase();
-    const hash = crypto.createHash('md5').update(hex).digest('hex').slice(0, 16);
-    const obs = pick(OBSERVERS);
-    injected.push({ hex, observer: obs.id, region: obs.iata, hash, snr: 1.0, rssi: -95 });
-    observerCounts[obs.id] = (observerCounts[obs.id] || 0) + 1;
-    if (!hashToObservers[hash]) hashToObservers[hash] = new Set();
-    hashToObservers[hash].add(obs.id);
-  }
-
-  // Find a hash with multiple observers for trace testing
-  let traceHash = null;
-  for (const [h, obs] of Object.entries(hashToObservers)) {
-    if (obs.size >= 2) { traceHash = h; break; }
-  }
-  // If none, create one explicitly
-  if (!traceHash) {
-    const buf = buildAck();
-    const hex = buf.toString('hex').toUpperCase();
-    traceHash = crypto.createHash('md5').update(hex).digest('hex').slice(0, 16);
-    injected.push({ hex, observer: OBSERVERS[0].id, region: OBSERVERS[0].iata, hash: traceHash, snr: 5, rssi: -80 });
-    injected.push({ hex, observer: OBSERVERS[1].id, region: OBSERVERS[1].iata, hash: traceHash, snr: 3, rssi: -90 });
-    observerCounts[OBSERVERS[0].id] = (observerCounts[OBSERVERS[0].id] || 0) + 1;
-    observerCounts[OBSERVERS[1].id] = (observerCounts[OBSERVERS[1].id] || 0) + 1;
-  }
-
-  console.log(`Injecting ${injected.length} packets...`);
-  let injectOk = 0, injectFail = 0;
-  for (const pkt of injected) {
-    const r = await post('/api/packets', pkt);
-    if (r.status === 200) injectOk++;
-    else { injectFail++; if (injectFail <= 3) console.error('  Inject fail:', r.data); }
-  }
-  console.log(`Injected: ${injectOk} ok, ${injectFail} fail\n`);
-  assert(injectFail === 0, 'All packets injected successfully');
-  assert(injected.length >= 100, `Injected 100+ packets (got ${injected.length})`);
-
-  // Wait a moment for WS messages to arrive
-  await sleep(500);
-
-  // ── Validate ───────────────────────────────────────────────────────
-
-  // 5a. Stats
-  console.log('── Stats ──');
-  const stats = (await get('/api/stats')).data;
-  // totalPackets includes seed packet, so should be >= injected.length
-  assert(stats.totalPackets > 0, `stats.totalPackets (${stats.totalPackets}) >= ${injected.length}`);
-  assert(stats.totalNodes > 0, `stats.totalNodes > 0 (${stats.totalNodes})`);
-  assert(stats.totalObservers >= OBSERVERS.length, `stats.totalObservers >= ${OBSERVERS.length} (${stats.totalObservers})`);
-  console.log(`  totalPackets=${stats.totalPackets} totalNodes=${stats.totalNodes} totalObservers=${stats.totalObservers}\n`);
-
-  // 5b. Packets API - basic list
-  console.log('── Packets API ──');
-  const pktsAll = (await get('/api/packets?limit=200')).data;
-  assert(pktsAll.total > 0, `packets total (${pktsAll.total}) > 0`);
-  assert(pktsAll.packets.length > 0, 'packets array not empty');
-
-  // Filter by type (ADVERT = 4)
-  const pktsAdvert = (await get('/api/packets?type=4&limit=200')).data;
-  assert(pktsAdvert.total > 0, `filter by type=ADVERT returns results (${pktsAdvert.total})`);
-  assert(pktsAdvert.packets.every(p => p.payload_type === 4), 'all filtered packets are ADVERT');
-
-  // Filter by observer
-  const testObs = OBSERVERS[0].id;
-  const pktsObs = (await get(`/api/packets?observer=${testObs}&limit=200`)).data;
-  assert(pktsObs.total > 0, `filter by observer=${testObs} returns results`);
-  assert(pktsObs.packets.length > 0, 'observer filter returns packets');
-
-  // Filter by region
-  const pktsRegion = (await get('/api/packets?region=SJC&limit=200')).data;
-  assert(pktsRegion.total > 0, 'filter by region=SJC returns results');
-
-  // Pagination
-  const page1 = (await get('/api/packets?limit=5&offset=0')).data;
-  const page2 = (await get('/api/packets?limit=5&offset=5')).data;
-  assert(page1.packets.length === 5, 'pagination: page1 has 5');
-  assert(page2.packets.length === 5, 'pagination: page2 has 5');
-  if (page1.packets.length && page2.packets.length) {
-    assert(page1.packets[0].id !== page2.packets[0].id, 'pagination: pages are different');
-  }
-
-  // groupByHash
-  const grouped = (await get('/api/packets?groupByHash=true&limit=200')).data;
-  assert(grouped.total > 0, `groupByHash returns results (${grouped.total})`);
-  assert(grouped.packets[0].hash !== undefined, 'groupByHash entries have hash');
-  assert(grouped.packets[0].count !== undefined, 'groupByHash entries have count');
-  // Find a multi-observer group
-  const multiObs = grouped.packets.find(p => p.observer_count >= 2);
-  assert(!!multiObs, 'groupByHash has entry with observer_count >= 2');
-  console.log('  ✓ Packets API checks passed\n');
-
-  // 5c. Packet detail
-  console.log('── Packet Detail ──');
-  const firstPkt = pktsAll.packets[0];
-  const detail = (await get(`/api/packets/${firstPkt.id}`)).data;
-  assert(detail.packet !== undefined, 'detail has packet');
-  assert(detail.breakdown !== undefined, 'detail has breakdown');
-  assert(detail.breakdown.ranges !== undefined, 'breakdown has ranges');
-  assert(detail.breakdown.ranges.length > 0, 'breakdown has color ranges');
-  assert(detail.breakdown.ranges[0].color !== undefined, 'ranges have color field');
-  assert(detail.breakdown.ranges[0].start !== undefined, 'ranges have start field');
-  console.log(`  ✓ Detail: ${detail.breakdown.ranges.length} color ranges\n`);
-
-  // 5d. Nodes
-  console.log('── Nodes ──');
-  const nodesResp = (await get('/api/nodes?limit=50')).data;
-  assert(nodesResp.total > 0, `nodes total > 0 (${nodesResp.total})`);
-  assert(nodesResp.nodes.length > 0, 'nodes array not empty');
-  assert(nodesResp.counts !== undefined, 'nodes response has counts');
-
-  // Role filtering
-  const repNodes = (await get('/api/nodes?role=repeater')).data;
-  assert(repNodes.nodes.every(n => n.role === 'repeater'), 'role filter works for repeater');
-
-  // Node detail
-  const someNode = nodesResp.nodes[0];
-  const nodeDetail = (await get(`/api/nodes/${someNode.public_key}`)).data;
-  assert(nodeDetail.node !== undefined, 'node detail has node');
-  assert(nodeDetail.node.public_key === someNode.public_key, 'node detail matches pubkey');
-  assert(nodeDetail.recentAdverts !== undefined, 'node detail has recentAdverts');
-  console.log(`  ✓ Nodes: ${nodesResp.total} total, detail works\n`);
-
-  // 5e. Channels
-  console.log('── Channels ──');
-  const chResp = (await get('/api/channels')).data;
-  const chList = chResp.channels || [];
-  assert(Array.isArray(chList), 'channels response is array');
-  if (chList.length > 0) {
-    const someCh = chList[0];
-    assert(someCh.messageCount > 0, `channel has messages (${someCh.messageCount})`);
-    const msgResp = (await get(`/api/channels/${encodeURIComponent(someCh.hash)}/messages`)).data;
-    assert(msgResp.messages.length > 0, 'channel has message list');
-    assert(msgResp.messages[0].sender !== undefined, 'message has sender');
-    console.log(`  ✓ Channels: ${chList.length} channels\n`);
-  } else {
-    console.log(`  ⚠ Channels: 0 (synthetic packets don't produce decodable channel messages)\n`);
-  }
-
-  // 5f. Observers
-  console.log('── Observers ──');
-  const obsResp = (await get('/api/observers')).data;
-  assert(obsResp.observers.length >= OBSERVERS.length, `observers >= ${OBSERVERS.length} (${obsResp.observers.length})`);
-  for (const expObs of OBSERVERS) {
-    const found = obsResp.observers.find(o => o.id === expObs.id);
-    assert(!!found, `observer ${expObs.id} exists`);
-    if (found) {
-      assert(found.packet_count > 0, `observer ${expObs.id} has packet_count > 0 (${found.packet_count})`);
-    }
-  }
-  console.log(`  ✓ Observers: ${obsResp.observers.length}\n`);
-
-  // 5g. Traces
-  console.log('── Traces ──');
-  if (traceHash) {
-    const traceResp = (await get(`/api/traces/${traceHash}`)).data;
-    assert(Array.isArray(traceResp.traces), 'trace response is array');
-    if (traceResp.traces.length >= 2) {
-      const traceObservers = new Set(traceResp.traces.map(t => t.observer));
-      assert(traceObservers.size >= 2, `trace has >= 2 distinct observers (${traceObservers.size})`);
-    }
-    console.log(`  ✓ Traces: ${traceResp.traces.length} entries for hash\n`);
-  } else {
-    console.log('  ⚠ No multi-observer hash available for trace test\n');
-  }
-
-  // 5h. WebSocket
-  console.log('── WebSocket ──');
-  assert(wsMessages.length > 0, `WebSocket received messages (${wsMessages.length})`);
-  assert(wsMessages.length >= injected.length * 0.5, `WS got >= 50% of injected (${wsMessages.length}/${injected.length})`);
-  const wsPacketMsgs = wsMessages.filter(m => m.type === 'packet');
-  assert(wsPacketMsgs.length > 0, 'WS has packet-type messages');
-  console.log(`  ✓ WebSocket: ${wsMessages.length} messages received\n`);
-
-  // 6. MQTT (optional)
-  console.log('── MQTT ──');
-  let mqttAvailable = false;
-  try {
-    execSync('which mosquitto_pub', { stdio: 'ignore' });
-    mqttAvailable = true;
-  } catch {}
-
-  if (mqttAvailable) {
-    console.log('  mosquitto_pub found, testing MQTT path...');
-    // Would need a running mosquitto broker — skip if not running
-    try {
-      const mqttMod = require('mqtt');
-      const mc = mqttMod.connect('mqtt://localhost:1883', { connectTimeout: 2000 });
-      await new Promise((resolve, reject) => {
-        mc.on('connect', resolve);
-        mc.on('error', reject);
-        setTimeout(() => reject(new Error('timeout')), 2000);
-      });
-      const mqttHex = buildAdvert('MQTTTestNode', 'repeater').toString('hex').toUpperCase();
-      const mqttHash = 'mqtt-test-hash-001';
-      mc.publish('meshcore/SJC/MQTT-OBS-1/packets', JSON.stringify({
-        raw: mqttHex, SNR: 8.0, RSSI: -75, hash: mqttHash,
-      }));
-      await sleep(1000);
-      mc.end();
-      const mqttTrace = (await get(`/api/traces/${mqttHash}`)).data;
-      assert(mqttTrace.traces.length >= 1, 'MQTT packet appeared in traces');
-      console.log('  ✓ MQTT path works\n');
-    } catch (e) {
-      console.log(`  ⚠ MQTT broker not reachable: ${e.message}\n`);
-    }
-  } else {
-    console.log('  ⚠ mosquitto not available, skipping MQTT test\n');
-  }
-
-  // 7. Summary
-  ws.close();
-  cleanup();
-
-  console.log('═══════════════════════════════════════');
-  console.log(`  PASSED: ${passed}`);
-  console.log(`  FAILED: ${failed}`);
-  if (failures.length) {
-    console.log('  Failures:');
-    failures.forEach(f => console.log(`    - ${f}`));
-  }
-  console.log('═══════════════════════════════════════');
-
-  process.exit(failed > 0 ? 1 : 0);
-}
-
-main().catch(e => {
-  console.error('Fatal:', e);
-  process.exit(1);
-});

tools/frontend-test.js

@@ -1,320 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * MeshCore Analyzer — Frontend Smoke Tests (M13)
- *
- * Starts the server with a temp DB, injects synthetic packets,
- * then validates HTML pages, JS syntax, and API data shapes.
- */
-
-const { spawn } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-const crypto = require('crypto');
-
-const PROJECT_DIR = path.join(__dirname, '..');
-const PORT = 13580;
-const BASE = `http://localhost:${PORT}`;
-
-// ── Helpers ──────────────────────────────────────────────────────────
-
-let passed = 0, failed = 0;
-const failures = [];
-
-function assert(cond, label) {
-  if (cond) { passed++; }
-  else { failed++; failures.push(label); console.error(`  ❌ FAIL: ${label}`); }
-}
-
-function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
-
-async function get(urlPath) {
-  const r = await fetch(`${BASE}${urlPath}`);
-  return { status: r.status, data: await r.json() };
-}
-
-async function getHtml(urlPath) {
-  const r = await fetch(`${BASE}${urlPath}`);
-  return { status: r.status, text: await r.text() };
-}
-
-async function post(urlPath, body) {
-  const r = await fetch(`${BASE}${urlPath}`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-  });
-  return { status: r.status, data: await r.json() };
-}
-
-// ── Packet builders (from e2e-test.js) ───────────────────────────────
-
-function rand(a, b) { return Math.random() * (b - a) + a; }
-function randInt(a, b) { return Math.floor(rand(a, b + 1)); }
-function pick(a) { return a[randInt(0, a.length - 1)]; }
-
-function pubkeyFor(name) {
-  return crypto.createHash('sha256').update(name).digest();
-}
-
-function encodeHeader(routeType, payloadType, ver = 0) {
-  return (routeType & 0x03) | ((payloadType & 0x0F) << 2) | ((ver & 0x03) << 6);
-}
-
-function buildPath(hopCount, hashSize = 2) {
-  const pathByte = ((hashSize - 1) << 6) | (hopCount & 0x3F);
-  const hops = crypto.randomBytes(hashSize * hopCount);
-  return { pathByte, hops };
-}
-
-function buildAdvert(name, role) {
-  const pubKey = pubkeyFor(name);
-  const ts = Buffer.alloc(4); ts.writeUInt32LE(Math.floor(Date.now() / 1000));
-  const sig = crypto.randomBytes(64);
-  let flags = 0x80 | 0x10;
-  if (role === 'repeater') flags |= 0x02;
-  else if (role === 'room') flags |= 0x04;
-  else if (role === 'sensor') flags |= 0x08;
-  else flags |= 0x01;
-  const nameBuf = Buffer.from(name, 'utf8');
-  const appdata = Buffer.alloc(9 + nameBuf.length);
-  appdata[0] = flags;
-  appdata.writeInt32LE(Math.round(37.34 * 1e6), 1);
-  appdata.writeInt32LE(Math.round(-121.89 * 1e6), 5);
-  nameBuf.copy(appdata, 9);
-  const payload = Buffer.concat([pubKey, ts, sig, appdata]);
-  const header = encodeHeader(1, 0x04, 0);
-  const { pathByte, hops } = buildPath(randInt(0, 3));
-  return Buffer.concat([Buffer.from([header, pathByte]), hops, payload]);
-}
-
-function buildGrpTxt(channelHash = 0) {
-  const mac = crypto.randomBytes(2);
-  const enc = crypto.randomBytes(randInt(10, 40));
-  const payload = Buffer.concat([Buffer.from([channelHash]), mac, enc]);
-  const header = encodeHeader(1, 0x05, 0);
-  const { pathByte, hops } = buildPath(randInt(0, 3));
-  return Buffer.concat([Buffer.from([header, pathByte]), hops, payload]);
-}
-
-function buildAck() {
-  const payload = crypto.randomBytes(18);
-  const header = encodeHeader(2, 0x03, 0);
-  const { pathByte, hops } = buildPath(randInt(0, 2));
-  return Buffer.concat([Buffer.from([header, pathByte]), hops, payload]);
-}
-
-// ── Main ─────────────────────────────────────────────────────────────
-
-const OBSERVERS = [
-  { id: 'FE-SJC-1', iata: 'SJC' },
-  { id: 'FE-SFO-2', iata: 'SFO' },
-];
-
-const NODE_NAMES = ['FENode Alpha', 'FENode Beta', 'FENode Gamma', 'FENode Delta'];
-
-async function main() {
-  // 1. Temp DB
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'meshcore-fe-'));
-  const dbPath = path.join(tmpDir, 'test.db');
-  console.log(`Temp DB: ${dbPath}`);
-
-  // 2. Start server
-  console.log('Starting server...');
-  const srv = spawn('node', ['server.js'], {
-    cwd: PROJECT_DIR,
-    env: { ...process.env, DB_PATH: dbPath, PORT: String(PORT) },
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-
-  let serverOutput = '';
-  srv.stdout.on('data', d => { serverOutput += d; });
-  srv.stderr.on('data', d => { serverOutput += d; });
-
-  const cleanup = () => {
-    try { srv.kill('SIGTERM'); } catch {}
-    try { fs.unlinkSync(dbPath); fs.rmdirSync(tmpDir); } catch {}
-  };
-
-  process.on('SIGINT', () => { cleanup(); process.exit(1); });
-
-  // 3. Wait for ready
-  let ready = false;
-  for (let i = 0; i < 30; i++) {
-    await sleep(500);
-    try {
-      const r = await fetch(`${BASE}/api/stats`);
-      if (r.ok) { ready = true; break; }
-    } catch {}
-  }
-  if (!ready) {
-    console.error('Server did not start. Output:', serverOutput);
-    cleanup();
-    process.exit(1);
-  }
-  console.log('Server ready.\n');
-
-  // 4. Inject test data
-  const injected = [];
-  const roles = ['repeater', 'room', 'companion', 'sensor'];
-  for (let i = 0; i < NODE_NAMES.length; i++) {
-    const buf = buildAdvert(NODE_NAMES[i], roles[i]);
-    const hex = buf.toString('hex').toUpperCase();
-    const hash = crypto.createHash('md5').update(hex).digest('hex').slice(0, 16);
-    const obs = OBSERVERS[i % OBSERVERS.length];
-    injected.push({ hex, observer: obs.id, region: obs.iata, hash, snr: 5.0, rssi: -80 });
-  }
-  for (let i = 0; i < 20; i++) {
-    const buf = buildGrpTxt(i % 3);
-    const hex = buf.toString('hex').toUpperCase();
-    const hash = crypto.createHash('md5').update(hex).digest('hex').slice(0, 16);
-    const obs = pick(OBSERVERS);
-    injected.push({ hex, observer: obs.id, region: obs.iata, hash, snr: 3.0, rssi: -90 });
-  }
-  for (let i = 0; i < 10; i++) {
-    const buf = buildAck();
-    const hex = buf.toString('hex').toUpperCase();
-    const hash = crypto.createHash('md5').update(hex).digest('hex').slice(0, 16);
-    const obs = pick(OBSERVERS);
-    injected.push({ hex, observer: obs.id, region: obs.iata, hash, snr: 1.0, rssi: -95 });
-  }
-
-  console.log(`Injecting ${injected.length} packets...`);
-  let injectFail = 0;
-  for (const pkt of injected) {
-    const r = await post('/api/packets', pkt);
-    if (r.status !== 200) injectFail++;
-  }
-  assert(injectFail === 0, `All ${injected.length} packets injected`);
-  console.log(`Injected: ${injected.length - injectFail} ok, ${injectFail} fail\n`);
-
-  // ── HTML & Nav Tests ───────────────────────────────────────────────
-  console.log('── HTML & Navigation ──');
-  const { status: htmlStatus, text: html } = await getHtml('/');
-  assert(htmlStatus === 200, 'index.html returns 200');
-  assert(html.includes('<nav'), 'index.html contains <nav>');
-
-  const expectedLinks = ['#/packets', '#/map', '#/channels', '#/nodes', '#/traces', '#/observers'];
-  for (const link of expectedLinks) {
-    assert(html.includes(`href="${link}"`), `nav contains link to ${link}`);
-  }
-
-  // ── JS File References ─────────────────────────────────────────────
-  console.log('\n── JS File References ──');
-  const jsFiles = ['app.js', 'packets.js', 'map.js', 'channels.js', 'nodes.js', 'traces.js', 'observers.js'];
-  for (const jsFile of jsFiles) {
-    assert(html.includes(`src="${jsFile}`) || html.includes(`src="${jsFile}?`), `index.html references ${jsFile}`);
-  }
-
-  // ── JS Syntax Validation ───────────────────────────────────────────
-  console.log('\n── JS Syntax Validation ──');
-  for (const jsFile of jsFiles) {
-    const jsPath = path.join(PROJECT_DIR, 'public', jsFile);
-    try {
-      const source = fs.readFileSync(jsPath, 'utf8');
-      // Use the vm module's Script to check for syntax errors
-      new (require('vm')).Script(source, { filename: jsFile });
-      assert(true, `${jsFile} has valid syntax`);
-    } catch (e) {
-      assert(false, `${jsFile} syntax error: ${e.message}`);
-    }
-  }
-
-  // ── JS Files Fetchable from Server ─────────────────────────────────
-  console.log('\n── JS Files Served ──');
-  for (const jsFile of jsFiles) {
-    const resp = await getHtml(`/${jsFile}`);
-    assert(resp.status === 200, `${jsFile} served with 200`);
-    assert(resp.text.length > 0, `${jsFile} is non-empty`);
-  }
-
-  // ── API Data Shape Validation ──────────────────────────────────────
-  console.log('\n── API: /api/stats ──');
-  const stats = (await get('/api/stats')).data;
-  assert(typeof stats.totalPackets === 'number', 'stats.totalPackets is number');
-  assert(typeof stats.totalNodes === 'number', 'stats.totalNodes is number');
-  assert(typeof stats.totalObservers === 'number', 'stats.totalObservers is number');
-  assert(stats.totalPackets > 0, `stats.totalPackets > 0 (${stats.totalPackets})`);
-
-  console.log('\n── API: /api/packets (packets page) ──');
-  const pkts = (await get('/api/packets?limit=10')).data;
-  assert(typeof pkts.total === 'number', 'packets response has total');
-  assert(Array.isArray(pkts.packets), 'packets response has packets array');
-  assert(pkts.packets.length > 0, 'packets array non-empty');
-  const pkt0 = pkts.packets[0];
-  assert(pkt0.id !== undefined, 'packet has id');
-  assert(pkt0.raw_hex !== undefined, 'packet has raw_hex');
-  assert(pkt0.payload_type !== undefined, 'packet has payload_type');
-  assert(pkt0.observer_id !== undefined, 'packet has observer_id');
-
-  // Packet detail (byte breakdown)
-  const detail = (await get(`/api/packets/${pkt0.id}`)).data;
-  assert(detail.packet !== undefined, 'packet detail has packet');
-  assert(detail.breakdown !== undefined, 'packet detail has breakdown');
-  assert(Array.isArray(detail.breakdown.ranges), 'breakdown has ranges array');
-
-  console.log('\n── API: /api/packets?groupByHash (map page) ──');
-  const grouped = (await get('/api/packets?groupByHash=true&limit=10')).data;
-  assert(typeof grouped.total === 'number', 'groupByHash has total');
-  assert(Array.isArray(grouped.packets), 'groupByHash has packets array');
-
-  console.log('\n── API: /api/channels (channels page) ──');
-  const ch = (await get('/api/channels')).data;
-  assert(Array.isArray(ch.channels), 'channels response has channels array');
-  if (ch.channels.length > 0) {
-    assert(ch.channels[0].hash !== undefined, 'channel has hash');
-    assert(ch.channels[0].messageCount !== undefined, 'channel has messageCount');
-    const chMsgs = (await get(`/api/channels/${ch.channels[0].hash}/messages`)).data;
-    assert(Array.isArray(chMsgs.messages || []), 'channel messages is array');
-  } else {
-    console.log('  ⚠ No channels (synthetic packets are not decodable channel messages)');
-  }
-
-  console.log('\n── API: /api/nodes (nodes page) ──');
-  const nodes = (await get('/api/nodes?limit=10')).data;
-  assert(typeof nodes.total === 'number', 'nodes has total');
-  assert(Array.isArray(nodes.nodes), 'nodes has nodes array');
-  assert(nodes.nodes.length > 0, 'nodes non-empty');
-  const n0 = nodes.nodes[0];
-  assert(n0.public_key !== undefined, 'node has public_key');
-  assert(n0.name !== undefined, 'node has name');
-
-  // Node detail
-  const nd = (await get(`/api/nodes/${n0.public_key}`)).data;
-  assert(nd.node !== undefined, 'node detail has node');
-  assert(nd.recentAdverts !== undefined, 'node detail has recentAdverts');
-
-  console.log('\n── API: /api/observers (observers page) ──');
-  const obs = (await get('/api/observers')).data;
-  assert(Array.isArray(obs.observers), 'observers is array');
-  assert(obs.observers.length > 0, 'observers non-empty');
-  assert(obs.observers[0].id !== undefined, 'observer has id');
-  assert(obs.observers[0].packet_count !== undefined, 'observer has packet_count');
-
-  console.log('\n── API: /api/traces (traces page) ──');
-  // Use a known hash from injected packets
-  const knownHash = crypto.createHash('md5').update(injected[0].hex).digest('hex').slice(0, 16);
-  const traces = (await get(`/api/traces/${knownHash}`)).data;
-  assert(Array.isArray(traces.traces), 'traces is array');
-
-  // ── Summary ────────────────────────────────────────────────────────
-  cleanup();
-
-  console.log('\n═══════════════════════════════════════');
-  console.log(`  PASSED: ${passed}`);
-  console.log(`  FAILED: ${failed}`);
-  if (failures.length) {
-    console.log('  Failures:');
-    failures.forEach(f => console.log(`    - ${f}`));
-  }
-  console.log('═══════════════════════════════════════');
-
-  process.exit(failed > 0 ? 1 : 0);
-}
-
-main().catch(e => {
-  console.error('Fatal:', e);
-  process.exit(1);
-});