Refresh vendored REPO_POLICIES.md

PASSIVE checkpoints may not fully checkpoint when writers are active.
TRUNCATE mode blocks writers briefly but ensures complete checkpointing,
keeping the WAL small for consistent read performance under heavy load.

.gitignore

@@ -6,6 +6,9 @@
 *.dylib
 /bin/
 
+.DS_Store
+log.txt
+
 # Test binary, built with `go test -c`
 *.test
 
@@ -35,4 +38,4 @@ pkg/asinfo/asdata.json
 
 # Debug output files
 out
-log.txt
+log.txt

Dockerfile

@@ -0,0 +1,65 @@
+# Build stage
+FROM golang:1.24-bookworm AS builder
+
+# Install build dependencies (zstd for archive, gcc for CGO/sqlite3)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    zstd \
+    gcc \
+    libc6-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /src
+
+# Copy everything
+COPY . .
+
+# Vendor dependencies (must be after copying source)
+RUN go mod download && go mod vendor
+
+# Build the binary with CGO enabled (required for sqlite3)
+RUN CGO_ENABLED=1 GOOS=linux go build -o /routewatch ./cmd/routewatch
+
+# Create source archive with vendored dependencies
+RUN tar --zstd -cf /routewatch-source.tar.zst \
+    --exclude='.git' \
+    --exclude='*.tar.zst' \
+    .
+
+# Runtime stage
+FROM debian:bookworm-slim
+
+# Install runtime dependencies
+# - ca-certificates: for HTTPS connections
+# - curl: for health checks
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create non-root user
+RUN useradd -r -u 1000 -m routewatch
+
+RUN mkdir -p /var/lib/berlin.sneak.app.routewatch && chown routewatch:routewatch /var/lib/berlin.sneak.app.routewatch
+
+RUN mkdir /app
+WORKDIR /app
+
+# Copy binary and source archive from builder
+COPY --from=builder /routewatch /app/routewatch
+COPY --from=builder /routewatch-source.tar.zst /app/source/routewatch-source.tar.zst
+
+# Set ownership
+RUN chown -R routewatch:routewatch /app
+
+ENV XDG_DATA_HOME=/var/lib
+
+# Expose HTTP port
+EXPOSE 8080
+
+COPY ./entrypoint.sh /entrypoint.sh
+
+# Health check using the health endpoint
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+    CMD curl -sf http://localhost:8080/.well-known/healthcheck.json || exit 1
+
+ENTRYPOINT ["/bin/bash", "/entrypoint.sh" ]

Makefile

@@ -1,27 +1,56 @@
 export DEBUG = routewatch
 
-.PHONY: test fmt lint build clean run asupdate
+# Git revision for version embedding
+GIT_REVISION := $(shell git rev-parse HEAD 2>/dev/null || echo "unknown")
+GIT_REVISION_SHORT := $(shell git rev-parse --short HEAD 2>/dev/null || echo "unknown")
+VERSION_PKG := git.eeqj.de/sneak/routewatch/internal/version
+LDFLAGS := -X $(VERSION_PKG).GitRevision=$(GIT_REVISION) -X $(VERSION_PKG).GitRevisionShort=$(GIT_REVISION_SHORT)
+
+.PHONY: bootstrap setup check test lint fmt fmt-check docker hooks build clean run asupdate
 
 all: test
 
-test: lint
-	go test -v ./...
+# Install all development dependencies.
+bootstrap:
+	@script/bootstrap
+
+# Prepare a fresh clone: bootstrap plus pre-commit hook.
+setup:
+	@script/setup
+
+# Combined pre-commit/CI gate: tests, lint, format check.
+check:
+	@script/check
+
+test:
+	@script/test
 
 fmt:
-	go fmt ./...
+	@script/fmt
+
+# Check if code is formatted (read-only).
+fmt-check:
+	@script/fmt-check
 
 lint:
-	go vet ./...
-	golangci-lint run
+	@script/lint
+
+# Build Docker image.
+docker:
+	@script/docker
+
+# Install pre-commit hook.
+hooks:
+	@script/install-precommit
 
 build:
-	CGO_ENABLED=1 go build -o bin/routewatch cmd/routewatch/main.go
+	CGO_ENABLED=1 go build -ldflags "$(LDFLAGS)" -o bin/routewatch cmd/routewatch/main.go
 
 clean:
 	rm -rf bin/
 
 run: build
-	./bin/routewatch
+	DEBUG=routewatch ./bin/routewatch 2>&1 | tee log.txt
 
 asupdate:
 	@echo "Updating AS info data..."

README.md

@@ -0,0 +1,223 @@
+# RouteWatch
+
+RouteWatch is a real-time BGP routing table monitor that streams BGP UPDATE messages from the RIPE RIS Live service, maintains a live routing table in SQLite, and provides HTTP APIs for querying routing information.
+
+
+## Features
+
+- Real-time streaming of BGP updates from RIPE RIS Live
+- Maintains live IPv4 and IPv6 routing tables
+- Tracks AS peering relationships
+- HTTP API for IP-to-AS lookups, prefix details, and AS information
+- Automatic reconnection with exponential backoff
+- Batched database writes for high performance
+- Backpressure handling to prevent memory exhaustion
+
+## Installation
+
+```bash
+go build -o routewatch ./cmd/routewatch
+```
+
+## Usage
+
+```bash
+# Run the daemon (listens on port 8080 by default)
+./routewatch
+
+# Set custom port
+PORT=3000 ./routewatch
+
+# Enable debug logging
+DEBUG=routewatch ./routewatch
+```
+
+## HTTP Endpoints
+
+### Web Interface
+- `GET /` - Redirects to /status
+- `GET /status` - HTML status dashboard
+- `GET /status.json` - JSON statistics
+- `GET /as/{asn}` - AS detail page (HTML)
+- `GET /prefix/{prefix}` - Prefix detail page (HTML)
+- `GET /prefixlength/{length}` - IPv4 prefixes by mask length
+- `GET /prefixlength6/{length}` - IPv6 prefixes by mask length
+- `GET /ip/{ip}` - Redirects to prefix containing the IP
+
+### API v1
+- `GET /api/v1/stats` - Detailed statistics with handler metrics
+- `GET /api/v1/ip/{ip}` - Look up AS information for an IP address
+- `GET /api/v1/as/{asn}` - Get prefixes announced by an AS
+- `GET /api/v1/prefix/{prefix}` - Get routes for a specific prefix
+
+## Code Structure
+
+```
+routewatch/
+├── cmd/
+│   ├── routewatch/         # Main daemon entry point
+│   ├── asinfo-gen/         # Utility to generate AS info data
+│   └── streamdumper/       # Debug utility for raw stream output
+├── internal/
+│   ├── routewatch/         # Core application logic
+│   ├── server/             # HTTP server and handlers
+│   ├── database/           # SQLite storage layer
+│   ├── streamer/           # RIPE RIS Live client
+│   ├── ristypes/           # BGP message data structures
+│   ├── logger/             # Structured logging wrapper
+│   ├── metrics/            # Performance metrics tracking
+│   ├── config/             # Configuration management
+│   └── templates/          # HTML templates
+└── pkg/
+    └── asinfo/             # AS information lookup (public API)
+```
+
+## Architecture Overview
+
+### Component Relationships
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                         RouteWatch                               │
+│  (internal/routewatch/app.go - main orchestrator)               │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐       │
+│  │   Streamer   │───▶│   Handlers   │───▶│   Database   │       │
+│  │              │    │              │    │              │       │
+│  │ RIS Live     │    │ - ASHandler  │    │ SQLite with  │       │
+│  │ WebSocket    │    │ - PeerHandler│    │ WAL mode     │       │
+│  │ client       │    │ - PrefixHdlr │    │              │       │
+│  │              │    │ - PeeringHdlr│    │ Tables:      │       │
+│  └──────────────┘    └──────────────┘    │ - asns       │       │
+│                                          │ - prefixes   │       │
+│  ┌──────────────┐    ┌──────────────┐    │ - live_routes│       │
+│  │    Server    │───▶│   Handlers   │───▶│ - peerings   │       │
+│  │              │    │              │    │ - bgp_peers  │       │
+│  │ Chi router   │    │ Status, API  │    └──────────────┘       │
+│  │ port 8080    │    │ AS, Prefix   │                           │
+│  └──────────────┘    └──────────────┘                           │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### Execution Flow
+
+1. **Startup** (`cmd/routewatch/main.go` → `internal/routewatch/cli.go`)
+   - Uber fx dependency injection initializes all components
+   - Signal handlers registered for graceful shutdown
+
+2. **Initialization** (`internal/routewatch/app.go`)
+   - Database created with SQLite schema (WAL mode, 3GB cache)
+   - Message handlers registered with the streamer
+   - HTTP server started on configured port
+
+3. **Message Processing Pipeline**
+   ```
+   RIS Live Stream → JSON Parser → Message Dispatcher → Handler Queues → Batch Writers → SQLite
+   ```
+   - Streamer connects to `ris-live.ripe.net` via HTTP
+   - Parses BGP UPDATE messages from JSON stream
+   - Dispatches to registered handlers based on message type
+   - Each handler has its own queue with backpressure handling
+   - Handlers batch writes for efficiency (25K-30K ops, 1-2s timeout)
+
+4. **Handler Details**
+   - **ASHandler**: Tracks all ASNs seen in AS paths
+   - **PeerHandler**: Records BGP peer information
+   - **PrefixHandler**: Maintains live routing table (upserts on announcement, deletes on withdrawal)
+   - **PeeringHandler**: Extracts AS peering relationships from AS paths
+
+5. **HTTP Request Flow**
+   ```
+   Request → Chi Router → Middleware (timeout, logging) → Handler → Database Query → Response
+   ```
+
+### Key Design Patterns
+
+- **Batched Writes**: All database operations are batched for performance
+- **Backpressure**: Probabilistic message dropping when queues exceed 50% capacity
+- **Graceful Shutdown**: 60-second timeout, flushes all pending batches
+- **Reconnection**: Exponential backoff (5s-320s) with reset after 30s of stable connection
+- **IPv4 Optimization**: IP ranges stored as uint32 for O(1) lookups
+
+### Database Schema
+
+```sql
+-- Core tables
+asns(id, number, handle, description, first_seen, last_seen)
+prefixes_v4(id, prefix, mask_length, first_seen, last_seen)
+prefixes_v6(id, prefix, mask_length, first_seen, last_seen)
+
+-- Live routing tables (one per IP version)
+live_routes_v4(id, prefix, mask_length, origin_asn, peer_ip, as_path,
+               next_hop, last_updated, v4_ip_start, v4_ip_end)
+live_routes_v6(id, prefix, mask_length, origin_asn, peer_ip, as_path,
+               next_hop, last_updated)
+
+-- Relationship tracking
+peerings(id, as_a, as_b, first_seen, last_seen)
+bgp_peers(id, peer_ip, peer_asn, last_message_type, last_seen)
+```
+
+## Configuration
+
+Configuration is handled via environment variables and OS-specific paths:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `PORT` | `8080` | HTTP server port |
+| `DEBUG` | (empty) | Set to `routewatch` for debug logging |
+
+State directory (database location):
+- macOS: `~/Library/Application Support/routewatch/`
+- Linux: `/var/lib/routewatch/` or `~/.local/share/routewatch/`
+
+## Development
+
+```bash
+# Run tests
+make test
+
+# Format code
+make fmt
+
+# Run linter
+make lint
+
+# Build
+make
+```
+
+## Entrypoints
+
+This repository adheres to the
+[Scripts to Rule Them All](https://github.com/github/scripts-to-rule-them-all)
+standard: normalized scripts in `script/` are the entrypoints for the
+development workflow, and the Makefile targets are thin shims that call
+them. We provide:
+
+- `script/bootstrap` — install all development dependencies (go,
+  golangci-lint, Go module download)
+- `script/setup` — make a fresh clone ready for development: runs
+  `script/bootstrap`, then `script/install-precommit`
+- `script/projectname` — print the project name (used for the Docker
+  image tag)
+- `script/test` — run the test suite
+  (`go test -timeout 30s -race -cover ./...`, verbose rerun on failure)
+- `script/lint` — run `go vet ./...` and `golangci-lint run`
+- `script/fmt` — format all code (writes)
+- `script/fmt-check` — check formatting (read-only)
+- `script/check` — run `script/test`, `script/lint`, and
+  `script/fmt-check`
+- `script/docker` — build the Docker image tagged via
+  `script/projectname`
+- `script/cibuild` — CI entrypoint: `docker build .`
+- `script/precommit` — pre-commit gate: `go mod tidy` + `go fmt` (must
+  not change files), then `script/check`
+- `script/install-precommit` — install the git pre-commit hook that
+  runs `script/precommit`
+
+## License
+
+See LICENSE file.

REPO_POLICIES.md

@@ -0,0 +1,408 @@
+---
+title: Repository Policies
+last_modified: 2026-07-06
+---
+
+This document covers repository structure, tooling, and workflow standards. Code
+style conventions are in separate documents:
+
+- [Code Styleguide](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/CODE_STYLEGUIDE.md)
+  (general, bash, Docker)
+- [Go](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/CODE_STYLEGUIDE_GO.md)
+- [JavaScript](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/CODE_STYLEGUIDE_JS.md)
+- [Python](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/CODE_STYLEGUIDE_PYTHON.md)
+- [Go HTTP Server Conventions](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/GO_HTTP_SERVER_CONVENTIONS.md)
+
+---
+
+- Cross-project documentation (such as this file) must include
+  `last_modified: YYYY-MM-DD` in the YAML front matter so it can be kept in sync
+  with the authoritative source as policies evolve.
+
+- **ALL external references must be pinned by cryptographic hash.** This
+  includes Docker base images, Go modules, npm packages, GitHub Actions, and
+  anything else fetched from a remote source. Version tags (`@v4`, `@latest`,
+  `:3.21`, etc.) are server-mutable and therefore remote code execution
+  vulnerabilities. The ONLY acceptable way to reference an external dependency
+  is by its content hash (Docker `@sha256:...`, Go module hash in `go.sum`, npm
+  integrity hash in lockfile, GitHub Actions `@<commit-sha>`). No exceptions.
+  This also means never `curl | bash` to install tools like pyenv, nvm, rustup,
+  etc. Instead, download a specific release archive from GitHub, verify its hash
+  (hardcoded in the Dockerfile or script), and only then install. Unverified
+  install scripts are arbitrary remote code execution. This is the single most
+  important rule in this document. Double-check every external reference in
+  every file before committing. There are zero exceptions to this rule.
+
+- Every repo with software must have a root `Makefile` with these targets:
+  `make bootstrap`, `make setup`, `make test`, `make lint`, `make fmt` (writes),
+  `make fmt-check` (read-only), `make check` (runs `test`, `lint`, `fmt-check`),
+  `make docker`, and `make hooks` (installs pre-commit hook). A model Makefile
+  is at `https://git.eeqj.de/sneak/prompts/raw/branch/main/Makefile`.
+
+- Repos follow the
+  [Scripts to Rule Them All](https://github.com/github/scripts-to-rule-them-all)
+  pattern: the implementation of each Makefile target lives in an executable
+  script in `script/` (`script/bootstrap`, `script/setup`, `script/test`,
+  `script/lint`, `script/fmt`, `script/fmt-check`, `script/check`,
+  `script/docker`), and the Makefile targets are thin shims that call them. The
+  scripts must be POSIX sh (`#!/bin/sh`, `set -eu`, no bashisms) so they run in
+  minimal containers (e.g. alpine images have no bash); locate the repo root
+  with `$(cd "$(dirname "$0")/.." && pwd -P)` and `cd` there before acting. From
+  the standard's canonical set we use `bootstrap`, `setup` (make the repo ready
+  for development after a fresh clone: runs `bootstrap`, then
+  `install-precommit`, plus any repo-specific initialization), `test`, and
+  `cibuild`. `script/bootstrap` installs all dependencies idempotently and
+  assumes nothing is present: base tools come from nix, apt, brew, or apk
+  (detected in that order; apt runs noninteractive). For node it uses the
+  installed node if present; otherwise it installs a PINNED node version via
+  nvm, first installing nvm itself if missing — from a hash-verified GitHub
+  release archive (never `curl | sh`), with bash installed as an explicit
+  prerequisite since nvm requires bash. yarn is then pinned via
+  `corepack prepare yarn@<version> --activate`. Never install "latest" or "lts";
+  always exact versions. `script/cibuild` runs the CI build: it changes to the
+  repo root and runs `docker build .`; the Gitea workflow calls it. Four further
+  scripts are our own extensions to the standard: `script/check` runs
+  `script/test`, `script/lint`, and `script/fmt-check`; `script/precommit` is
+  what the git pre-commit hook runs, and it calls `script/check`;
+  `script/install-precommit` installs the git pre-commit hook (the `make hooks`
+  target shims to it); and `script/projectname` (literally that filename) simply
+  outputs the project's name. Scripts that need the name call
+  `script/projectname` — e.g. `script/docker` assembles its image tag from it —
+  so those scripts stay byte-identical across all repos. Repo-type-specific
+  pre-commit extras (e.g. `go mod tidy` verification in Go repos) belong in
+  `script/precommit`, not in the hook itself. Model scripts are at
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/script/<name>`. The README
+  must document the provided scripts in an **Entrypoints** section (see the
+  README requirements below).
+
+- Always use Makefile targets (`make fmt`, `make test`, `make lint`, etc.)
+  instead of invoking the underlying tools directly. The Makefile is the single
+  source of truth for how these operations are run.
+
+- The Makefile is authoritative documentation for how the repo is used. Beyond
+  the required targets above, it should have targets for every common operation:
+  running a local development server (`make run`, `make dev`), re-initializing
+  or migrating the database (`make db-reset`, `make migrate`), building
+  artifacts (`make build`), generating code, seeding data, or anything else a
+  developer would do regularly. If someone checks out the repo and types
+  `make<tab>`, they should see every meaningful operation available. A new
+  contributor should be able to understand the entire development workflow by
+  reading the Makefile.
+
+- Every repo should have a `Dockerfile`. All Dockerfiles must run `make check`
+  as a build step so the build fails if the branch is not green. For non-server
+  repos, the Dockerfile should bring up a development environment and run
+  `make check`. For server repos, `make check` should run as an early build
+  stage before the final image is assembled. Dockerfiles install development
+  prerequisites by running `script/bootstrap` rather than duplicating installs
+  inline; COPY `script/` and the dependency manifests (`package.json` +
+  `yarn.lock`, `go.mod` + `go.sum`, etc.) before running it so the bootstrap
+  layer stays cached until dependencies change.
+
+- **Dockerfiles must use a separate lint stage for fail-fast feedback.** Go
+  repos use a multistage build where linting runs in an independent stage based
+  on the `golangci/golangci-lint` image (pinned by hash). This stage runs
+  `make fmt-check` and `make lint` before the full build begins. The build stage
+  then declares an explicit dependency on the lint stage via
+  `COPY --from=lint /src/go.sum /dev/null`, which forces BuildKit to complete
+  linting before proceeding to compilation and tests. This ensures lint failures
+  surface in seconds rather than minutes, without blocking on dependency
+  download or compilation in the build stage.
+
+    The standard pattern for a Go repo Dockerfile is:
+
+    ```dockerfile
+    # Lint stage — fast feedback on formatting and lint issues
+    # golangci/golangci-lint:v2.x.x, YYYY-MM-DD
+    FROM golangci/golangci-lint@sha256:... AS lint
+    WORKDIR /src
+    COPY go.mod go.sum ./
+    RUN go mod download
+    COPY . .
+    RUN make fmt-check
+    RUN make lint
+
+    # Build stage
+    # golang:1.x-alpine, YYYY-MM-DD
+    FROM golang@sha256:... AS builder
+    WORKDIR /src
+
+    # Force BuildKit to run the lint stage before proceeding
+    COPY --from=lint /src/go.sum /dev/null
+
+    COPY go.mod go.sum ./
+    RUN go mod download
+    COPY . .
+    RUN make test
+
+    ARG VERSION=dev
+    RUN CGO_ENABLED=0 go build -trimpath \
+        -ldflags="-s -w -X main.Version=${VERSION}" \
+        -o /app ./cmd/app/
+
+    # Runtime stage
+    FROM alpine@sha256:...
+    COPY --from=builder /app /usr/local/bin/app
+    ENTRYPOINT ["app"]
+    ```
+
+    Key points:
+    - The lint stage uses the `golangci/golangci-lint` image directly (it
+      includes both Go and the linter), so there is no need to install the
+      linter separately.
+    - `COPY --from=lint /src/go.sum /dev/null` is a no-op file copy that creates
+      a stage dependency. BuildKit runs stages in parallel by default; without
+      this line, the build stage would not wait for lint to finish and a lint
+      failure might not fail the overall build.
+    - If the project uses `//go:embed` directives that reference build artifacts
+      (e.g. a web frontend compiled in a separate stage), the lint stage must
+      create placeholder files so the embed directives resolve. Example:
+      `RUN mkdir -p web/dist && touch web/dist/index.html web/dist/style.css`.
+      The lint stage should not depend on the actual build output — it exists to
+      fail fast.
+    - If the project requires CGO or system libraries for linting (e.g.
+      `vips-dev`), install them in the lint stage with `apk add`.
+    - The build stage runs `make test` after compilation setup. Tests run in the
+      build stage, not the lint stage, because they may require compiled
+      artifacts or heavier dependencies.
+
+- Every repo should have a Gitea Actions workflow (`.gitea/workflows/`) that
+  runs `script/cibuild` (which runs `docker build .`) on push. Since the
+  Dockerfile already runs `make check`, a successful build implies all checks
+  pass.
+
+- Use platform-standard formatters: `black` for Python, `prettier` for
+  JS/CSS/Markdown/HTML, `go fmt` for Go. Always use default configuration with
+  two exceptions: four-space indents (except Go), and `proseWrap: always` for
+  Markdown (hard-wrap at 80 columns). Documentation and writing repos (Markdown,
+  HTML, CSS) should also have `.prettierrc` and `.prettierignore`.
+
+- Pre-commit hook: runs `script/precommit`, which calls `script/check`. If local
+  testing is not possible in the repo, `script/precommit` may skip `script/test`
+  and run only `script/lint` and `script/fmt-check`. The hook is installed by
+  `script/install-precommit`; the Makefile must provide a `make hooks` target
+  that shims to it.
+
+- All repos with software must have tests that run via the platform-standard
+  test framework (`go test`, `pytest`, `jest`/`vitest`, etc.). If no meaningful
+  tests exist yet, add the most minimal test possible — e.g. importing the
+  module under test to verify it compiles/parses. There is no excuse for
+  `make test` to be a no-op.
+
+- `make test` must complete in under 20 seconds. Add a 30-second timeout in the
+  Makefile.
+
+- **`make test` should use the conditional verbose rerun pattern.** Run tests
+  without `-v` (verbose) first. If tests fail, automatically rerun with `-v` to
+  show full output. This keeps CI logs and `docker build` output clean on
+  success (just package/suite summaries) while providing full diagnostic detail
+  on failure (every test case, every assertion). The general shell pattern:
+
+    ```makefile
+    test:
+    	@<test-command> || \
+    		{ echo "--- Rerunning with -v for details ---"; \
+    		  <test-command-with-v>; exit 1; }
+    ```
+
+    Go example:
+
+    ```makefile
+    test:
+    	@go test -timeout 30s -race -cover ./... || \
+    		{ echo "--- Rerunning with -v for details ---"; \
+    		  go test -timeout 30s -race -v ./...; exit 1; }
+    ```
+
+    Python example:
+
+    ```makefile
+    test:
+    	@python -m pytest || \
+    		{ echo "--- Rerunning with -v for details ---"; \
+    		  python -m pytest -v; exit 1; }
+    ```
+
+    The `exit 1` ensures the target always fails after a rerun — the first run
+    already proved the tests are broken, so the build must not pass even if a
+    flaky test happens to succeed on the second attempt. The rerun exists solely
+    for diagnostic output.
+
+- Docker builds must complete in under 5 minutes.
+
+- `make check` must not modify any files in the repo. Tests may use temporary
+  directories.
+
+- `main` must always pass `make check`, no exceptions.
+
+- Never commit secrets. `.env` files, credentials, API keys, and private keys
+  must be in `.gitignore`. No exceptions.
+
+- `.gitignore` should be comprehensive from the start: OS files (`.DS_Store`),
+  editor files (`.swp`, `*~`), language build artifacts, and `node_modules/`.
+  Fetch the standard `.gitignore` from
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitignore` when setting up
+  a new repo.
+
+- **No build artifacts in version control.** Code-derived data (compiled
+  bundles, minified output, generated assets) must never be committed to the
+  repository if it can be avoided. The build process (e.g. Dockerfile, Makefile)
+  should generate these at build time. Notable exception: Go protobuf generated
+  files (`.pb.go`) ARE committed because repos need to work with `go get`, which
+  downloads code but does not execute code generation.
+
+- Never use `git add -A` or `git add .`. Always stage files explicitly by name.
+
+- Never force-push to `main`.
+
+- Make all changes on a feature branch. You can do whatever you want on a
+  feature branch.
+
+- `.golangci.yml` is standardized and must _NEVER_ be modified by an agent, only
+  manually by the user. Fetch from
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.golangci.yml`.
+
+- When pinning images or packages by hash, add a comment above the reference
+  with the version and date (YYYY-MM-DD).
+
+- Use `yarn`, not `npm`.
+
+- Write all dates as YYYY-MM-DD (ISO 8601).
+
+- Simple projects should be configured with environment variables.
+
+- Dockerized web services listen on port 8080 by default, overridable with
+  `PORT`.
+
+- **HTTP/web services must be hardened for production internet exposure before
+  tagging 1.0.** This means full compliance with security best practices
+  including, without limitation, all of the following:
+    - **Security headers** on every response:
+        - `Strict-Transport-Security` (HSTS) with `max-age` of at least one year
+          and `includeSubDomains`.
+        - `Content-Security-Policy` (CSP) with a restrictive default policy
+          (`default-src 'self'` as a baseline, tightened per-resource as
+          needed). Never use `unsafe-inline` or `unsafe-eval` unless
+          unavoidable, and document the reason.
+        - `X-Frame-Options: DENY` (or `SAMEORIGIN` if framing is required).
+          Prefer the `frame-ancestors` CSP directive as the primary control.
+        - `X-Content-Type-Options: nosniff`.
+        - `Referrer-Policy: strict-origin-when-cross-origin` (or stricter).
+        - `Permissions-Policy` restricting access to browser features the
+          application does not use (camera, microphone, geolocation, etc.).
+    - **Request and response limits:**
+        - Maximum request body size enforced on all endpoints (e.g. Go
+          `http.MaxBytesReader`). Choose a sane default per-route; never accept
+          unbounded input.
+        - Maximum response body size where applicable (e.g. paginated APIs).
+        - `ReadTimeout` and `ReadHeaderTimeout` on the `http.Server` to defend
+          against slowloris attacks.
+        - `WriteTimeout` on the `http.Server`.
+        - `IdleTimeout` on the `http.Server`.
+        - Per-handler execution time limits via `context.WithTimeout` or
+          chi/stdlib `middleware.Timeout`.
+    - **Authentication and session security:**
+        - Rate limiting on password-based authentication endpoints. API keys are
+          high-entropy and not susceptible to brute force, so they are exempt.
+        - CSRF tokens on all state-mutating HTML forms. API endpoints
+          authenticated via `Authorization` header (Bearer token, API key) are
+          exempt because the browser does not attach these automatically.
+        - Passwords stored using bcrypt, scrypt, or argon2 — never plain-text,
+          MD5, or SHA.
+        - Session cookies set with `HttpOnly`, `Secure`, and `SameSite=Lax` (or
+          `Strict`) attributes.
+    - **Reverse proxy awareness:**
+        - True client IP detection when behind a reverse proxy
+          (`X-Forwarded-For`, `X-Real-IP`). The application must accept
+          forwarded headers only from a configured set of trusted proxy
+          addresses — never trust `X-Forwarded-For` unconditionally.
+    - **CORS:**
+        - Authenticated endpoints must restrict `Access-Control-Allow-Origin` to
+          an explicit allowlist of known origins. Wildcard (`*`) is acceptable
+          only for public, unauthenticated read-only APIs.
+    - **Error handling:**
+        - Internal errors must never leak stack traces, SQL queries, file paths,
+          or other implementation details to the client. Return generic error
+          messages in production; detailed errors only when `DEBUG` is enabled.
+    - **TLS:**
+        - Services never terminate TLS directly. They are always deployed behind
+          a TLS-terminating reverse proxy. The service itself listens on plain
+          HTTP. However, HSTS headers and `Secure` cookie flags must still be
+          set by the application so that the browser enforces HTTPS end-to-end.
+
+    This list is non-exhaustive. Apply defense-in-depth: if a standard security
+    hardening measure exists for HTTP services and is not listed here, it is
+    still expected. When in doubt, harden.
+
+- `README.md` is the primary documentation. Required sections:
+    - **Description**: First line must include the project name, purpose,
+      category (web server, SPA, CLI tool, etc.), license, and author. Example:
+      "µPaaS is an MIT-licensed Go web application by @sneak that receives
+      git-frontend webhooks and deploys applications via Docker in realtime."
+    - **Getting Started**: Copy-pasteable install/usage code block.
+    - **Entrypoints**: Opens by stating that the repo adheres to the
+      [Scripts to Rule Them All](https://github.com/github/scripts-to-rule-them-all)
+      standard (with that link), then documents each provided `script/`
+      entrypoint and its purpose.
+    - **Rationale**: Why does this exist?
+    - **Design**: How is the program structured?
+    - **TODO**: Update meticulously, even between commits. When planning, put
+      the todo list in the README so a new agent can pick up where the last one
+      left off.
+    - **License**: MIT, GPL, or WTFPL. Ask the user for new projects. Include a
+      `LICENSE` file in the repo root and a License section in the README.
+    - **Author**: [@sneak](https://sneak.berlin).
+
+- First commit of a new repo should contain only `README.md`.
+
+- Go module root: `sneak.berlin/go/<name>`. Always run `go mod tidy` before
+  committing.
+
+- Use SemVer.
+
+- Database migrations live in `internal/db/migrations/` and must be embedded in
+  the binary.
+    - `000_migration.sql` — contains ONLY the creation of the migrations
+      tracking table itself. Nothing else.
+    - `001_schema.sql` — the full application schema.
+    - **Pre-1.0.0:** never add additional migration files (002, 003, etc.).
+      There is no installed base to migrate. Edit `001_schema.sql` directly.
+    - **Post-1.0.0:** add new numbered migration files for each schema change.
+      Never edit existing migrations after release.
+
+- All repos should have an `.editorconfig` enforcing the project's indentation
+  settings.
+
+- Avoid putting files in the repo root unless necessary. Root should contain
+  only project-level config files (`README.md`, `Makefile`, `Dockerfile`,
+  `LICENSE`, `.gitignore`, `.editorconfig`, `REPO_POLICIES.md`, and
+  language-specific config). Everything else goes in a subdirectory. Canonical
+  subdirectory names:
+    - `bin/` — executable scripts and tools
+    - `cmd/` — Go command entrypoints
+    - `configs/` — configuration templates and examples
+    - `deploy/` — deployment manifests (k8s, compose, terraform)
+    - `docs/` — documentation and markdown (README.md stays in root)
+    - `internal/` — Go internal packages
+    - `internal/db/migrations/` — database migrations
+    - `pkg/` — Go library packages
+    - `share/` — systemd units, data files
+    - `static/` — static assets (images, fonts, etc.)
+    - `web/` — web frontend source
+
+- When setting up a new repo, files from the `prompts` repo may be used as
+  templates. Fetch them from
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/<path>`.
+
+- New repos must contain at minimum:
+    - `README.md`, `.git`, `.gitignore`, `.editorconfig`
+    - `LICENSE`, `REPO_POLICIES.md` (copy from the `prompts` repo)
+    - `Makefile`
+    - `script/` entrypoints (`bootstrap`, `setup`, `projectname`, `test`,
+      `lint`, `fmt`, `fmt-check`, `check`, `docker`, `cibuild`, `precommit`,
+      `install-precommit`)
+    - `Dockerfile`, `.dockerignore`
+    - `.gitea/workflows/check.yml`
+    - Go: `go.mod`, `go.sum`, `.golangci.yml`
+    - JS: `package.json`, `yarn.lock`, `.prettierrc`, `.prettierignore`
+    - Python: `pyproject.toml`

TODO.md

@@ -0,0 +1,48 @@
+# Workflow
+
+* branch (from `main`)
+* do the work in Next Step
+* move Next Step to the top of Completed Steps
+* move the top item of Future Steps into Next Step
+* commit (`TODO.md` changes in the same commit as the work)
+* merge to `main` if the branch is not protected, otherwise open a PR
+* push
+
+# Status
+
+pre-1.0. No git tags. Runs in production-style Docker deployment, but
+the policy compliance branch (repo-policies-compliance, make check
+passing, clean tree) is unmerged to main and the CI workflow is missing.
+
+# Next Step
+
+Merge repo-policies-compliance into main (3 commits: policy files and
+.gitignore, Makefile targets fmt-check/check/docker/hooks, gofmt pass),
+then add .gitea/workflows/check.yml as a small follow-up commit so CI
+runs make check on main.
+
+# Completed Steps
+
+- 2026-07-07 Adopted scripts-to-rule-them-all: `script/` entrypoints,
+  Makefile shims, README Entrypoints section
+- 2026-02-22: repo policy compliance: required policy files, .gitignore
+  update, Makefile fmt-check/check/docker/hooks targets, gofmt pass
+  (repo-policies-compliance, unmerged)
+- 2026-01-01: WAL checkpointing: periodic (5s), on startup with logging,
+  TRUNCATE mode; fixed slow queries
+- 2025-12-31: status page: navbar, home page with search, oldest/newest
+  route timestamps, NULL handling in WHOIS stats; container runs as
+  routewatch user with proper state dir
+- 2025-12-30: structured HTTP request logging, increased timeouts,
+  CIDR prefix URL routing fixes, status page metrics and footer
+- 2025-12-29: Dockerfile multi-stage build with source archive; SQLite
+  incremental vacuum for non-blocking space reclamation
+- 2025-07-27: initial RouteWatch BGP stream monitor
+
+# Future Steps
+
+- Verify main is green after the merge: make check locally and the new
+  CI workflow passing
+- Review stale remote branches fix-min-time-calculation and
+  optimize-sqlite-settings: land or delete
+- Clean up the tmp/ directory at the repo root: gitignore or remove

entrypoint.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+cd /var/lib/berlin.sneak.app.routewatch
+chown -R routewatch:routewatch .
+chmod 700 .
+
+exec runuser -u routewatch -- /app/routewatch

go.mod

@@ -3,18 +3,18 @@ module git.eeqj.de/sneak/routewatch
 go 1.24.4
 
 require (
+	github.com/dustin/go-humanize v1.0.1
 	github.com/go-chi/chi/v5 v5.2.2
 	github.com/google/uuid v1.6.0
 	github.com/mattn/go-sqlite3 v1.14.29
 	github.com/rcrowley/go-metrics v0.0.0-20250401214520-65e299d6c5c9
 	go.uber.org/fx v1.24.0
+	golang.org/x/term v0.33.0
 )
 
 require (
-	github.com/dustin/go-humanize v1.0.1 // indirect
 	go.uber.org/dig v1.19.0 // indirect
 	go.uber.org/multierr v1.10.0 // indirect
 	go.uber.org/zap v1.26.0 // indirect
 	golang.org/x/sys v0.34.0 // indirect
-	golang.org/x/term v0.33.0 // indirect
 )

internal/database/interface.go

@@ -1,10 +1,14 @@
+// Package database provides SQLite storage for BGP routing data including ASNs,
+// prefixes, announcements, peerings, and live route tables.
 package database
 
 import (
+	"context"
 	"time"
 )
 
-// Stats contains database statistics
+// Stats contains database statistics including counts for ASNs, prefixes,
+// peerings, peers, and live routes, as well as file size and prefix distribution data.
 type Stats struct {
 	ASNs                   int
 	Prefixes               int
@@ -14,11 +18,15 @@ type Stats struct {
 	Peers                  int
 	FileSizeBytes          int64
 	LiveRoutes             int
+	OldestRoute            *time.Time
+	NewestRoute            *time.Time
 	IPv4PrefixDistribution []PrefixDistribution
 	IPv6PrefixDistribution []PrefixDistribution
 }
 
-// Store defines the interface for database operations
+// Store defines the interface for database operations. It provides methods for
+// managing ASNs, prefixes, announcements, peerings, BGP peers, and live routes.
+// Implementations must be safe for concurrent use.
 type Store interface {
 	// ASN operations
 	GetOrCreateASN(number int, timestamp time.Time) (*ASN, error)
@@ -26,6 +34,7 @@ type Store interface {
 
 	// Prefix operations
 	GetOrCreatePrefix(prefix string, timestamp time.Time) (*Prefix, error)
+	UpdatePrefixesBatch(prefixes map[string]time.Time) error
 
 	// Announcement operations
 	RecordAnnouncement(announcement *Announcement) error
@@ -35,6 +44,7 @@ type Store interface {
 
 	// Statistics
 	GetStats() (Stats, error)
+	GetStatsContext(ctx context.Context) (Stats, error)
 
 	// Peer operations
 	UpdatePeer(peerIP string, peerASN int, messageType string, timestamp time.Time) error
@@ -46,17 +56,39 @@ type Store interface {
 	DeleteLiveRoute(prefix string, originASN int, peerIP string) error
 	DeleteLiveRouteBatch(deletions []LiveRouteDeletion) error
 	GetPrefixDistribution() (ipv4 []PrefixDistribution, ipv6 []PrefixDistribution, err error)
+	GetPrefixDistributionContext(ctx context.Context) (ipv4 []PrefixDistribution, ipv6 []PrefixDistribution, err error)
 	GetLiveRouteCounts() (ipv4Count, ipv6Count int, err error)
+	GetLiveRouteCountsContext(ctx context.Context) (ipv4Count, ipv6Count int, err error)
 
 	// IP lookup operations
 	GetASInfoForIP(ip string) (*ASInfo, error)
+	GetASInfoForIPContext(ctx context.Context, ip string) (*ASInfo, error)
+	GetIPInfo(ip string) (*IPInfo, error)
+	GetIPInfoContext(ctx context.Context, ip string) (*IPInfo, error)
+
+	// ASN WHOIS operations
+	GetNextStaleASN(ctx context.Context, staleThreshold time.Duration) (int, error)
+	UpdateASNWHOIS(ctx context.Context, update *ASNWHOISUpdate) error
+	GetWHOISStats(ctx context.Context, staleThreshold time.Duration) (*WHOISStats, error)
 
 	// AS and prefix detail operations
 	GetASDetails(asn int) (*ASN, []LiveRoute, error)
+	GetASDetailsContext(ctx context.Context, asn int) (*ASN, []LiveRoute, error)
+	GetASPeers(asn int) ([]ASPeer, error)
+	GetASPeersContext(ctx context.Context, asn int) ([]ASPeer, error)
 	GetPrefixDetails(prefix string) ([]LiveRoute, error)
+	GetPrefixDetailsContext(ctx context.Context, prefix string) ([]LiveRoute, error)
+	GetRandomPrefixesByLength(maskLength, ipVersion, limit int) ([]LiveRoute, error)
+	GetRandomPrefixesByLengthContext(ctx context.Context, maskLength, ipVersion, limit int) ([]LiveRoute, error)
 
 	// Lifecycle
 	Close() error
+
+	// Maintenance operations
+	Vacuum(ctx context.Context) error
+	Analyze(ctx context.Context) error
+	Checkpoint(ctx context.Context) error
+	Ping(ctx context.Context) error
 }
 
 // Ensure Database implements Store

internal/database/models.go

@@ -1,3 +1,4 @@
+// Package database provides SQLite storage for BGP routing data.
 package database
 
 import (
@@ -6,17 +7,34 @@ import (
 	"github.com/google/uuid"
 )
 
-// ASN represents an Autonomous System Number
+// ASN represents an Autonomous System Number with its metadata including
+// handle, description, WHOIS data, and first/last seen timestamps.
 type ASN struct {
-	ID          uuid.UUID `json:"id"`
-	Number      int       `json:"number"`
-	Handle      string    `json:"handle"`
-	Description string    `json:"description"`
-	FirstSeen   time.Time `json:"first_seen"`
-	LastSeen    time.Time `json:"last_seen"`
+	ASN         int    `json:"asn"`
+	Handle      string `json:"handle"`
+	Description string `json:"description"`
+	// WHOIS parsed fields
+	ASName      string     `json:"as_name,omitempty"`
+	OrgName     string     `json:"org_name,omitempty"`
+	OrgID       string     `json:"org_id,omitempty"`
+	Address     string     `json:"address,omitempty"`
+	CountryCode string     `json:"country_code,omitempty"`
+	AbuseEmail  string     `json:"abuse_email,omitempty"`
+	AbusePhone  string     `json:"abuse_phone,omitempty"`
+	TechEmail   string     `json:"tech_email,omitempty"`
+	TechPhone   string     `json:"tech_phone,omitempty"`
+	RIR         string     `json:"rir,omitempty"` // ARIN, RIPE, APNIC, LACNIC, AFRINIC
+	RIRRegDate  *time.Time `json:"rir_registration_date,omitempty"`
+	RIRLastMod  *time.Time `json:"rir_last_modified,omitempty"`
+	WHOISRaw    string     `json:"whois_raw,omitempty"`
+	// Timestamps
+	FirstSeen      time.Time  `json:"first_seen"`
+	LastSeen       time.Time  `json:"last_seen"`
+	WHOISUpdatedAt *time.Time `json:"whois_updated_at,omitempty"`
 }
 
-// Prefix represents an IP prefix (CIDR block)
+// Prefix represents an IP prefix (CIDR block) with its IP version (4 or 6)
+// and first/last seen timestamps.
 type Prefix struct {
 	ID        uuid.UUID `json:"id"`
 	Prefix    string    `json:"prefix"`
@@ -25,23 +43,25 @@ type Prefix struct {
 	LastSeen  time.Time `json:"last_seen"`
 }
 
-// Announcement represents a BGP announcement
+// Announcement represents a BGP announcement or withdrawal event,
+// containing the prefix, AS path, origin ASN, peer ASN, next hop, and timestamp.
 type Announcement struct {
 	ID           uuid.UUID `json:"id"`
 	PrefixID     uuid.UUID `json:"prefix_id"`
-	ASNID        uuid.UUID `json:"asn_id"`
-	OriginASNID  uuid.UUID `json:"origin_asn_id"`
+	PeerASN      int       `json:"peer_asn"`
+	OriginASN    int       `json:"origin_asn"`
 	Path         string    `json:"path"` // JSON-encoded AS path
 	NextHop      string    `json:"next_hop"`
 	Timestamp    time.Time `json:"timestamp"`
 	IsWithdrawal bool      `json:"is_withdrawal"`
 }
 
-// ASNPeering represents a peering relationship between two ASNs
+// ASNPeering represents a peering relationship between two ASNs,
+// stored with the lower ASN as ASA and the higher as ASB.
 type ASNPeering struct {
 	ID        uuid.UUID `json:"id"`
-	FromASNID uuid.UUID `json:"from_asn_id"`
-	ToASNID   uuid.UUID `json:"to_asn_id"`
+	ASA       int       `json:"as_a"`
+	ASB       int       `json:"as_b"`
 	FirstSeen time.Time `json:"first_seen"`
 	LastSeen  time.Time `json:"last_seen"`
 }
@@ -68,7 +88,7 @@ type PrefixDistribution struct {
 	Count      int `json:"count"`
 }
 
-// ASInfo represents AS information for an IP lookup
+// ASInfo represents AS information for an IP lookup (legacy format)
 type ASInfo struct {
 	ASN         int       `json:"asn"`
 	Handle      string    `json:"handle"`
@@ -78,11 +98,38 @@ type ASInfo struct {
 	Age         string    `json:"age"`
 }
 
+// IPInfo represents comprehensive IP information for the /ip endpoint
+type IPInfo struct {
+	IP         string   `json:"ip"`
+	PTR        []string `json:"ptr,omitempty"`
+	Netblock   string   `json:"netblock"`
+	MaskLength int      `json:"mask_length"`
+	IPVersion  int      `json:"ip_version"`
+	NumPeers   int      `json:"num_peers"`
+	// AS information
+	ASN         int    `json:"asn"`
+	ASName      string `json:"as_name,omitempty"`
+	Handle      string `json:"handle,omitempty"`
+	Description string `json:"description,omitempty"`
+	OrgName     string `json:"org_name,omitempty"`
+	OrgID       string `json:"org_id,omitempty"`
+	Address     string `json:"address,omitempty"`
+	CountryCode string `json:"country_code,omitempty"`
+	AbuseEmail  string `json:"abuse_email,omitempty"`
+	RIR         string `json:"rir,omitempty"`
+	// Timestamps
+	FirstSeen time.Time `json:"first_seen"`
+	LastSeen  time.Time `json:"last_seen"`
+	// Indicates if WHOIS data needs refresh (not serialized)
+	NeedsWHOISRefresh bool `json:"-"`
+}
+
 // LiveRouteDeletion represents parameters for deleting a live route
 type LiveRouteDeletion struct {
 	Prefix    string
 	OriginASN int
 	PeerIP    string
+	IPVersion int
 }
 
 // PeerUpdate represents parameters for updating a peer
@@ -92,3 +139,21 @@ type PeerUpdate struct {
 	MessageType string
 	Timestamp   time.Time
 }
+
+// ASNWHOISUpdate contains WHOIS data for updating an ASN record.
+type ASNWHOISUpdate struct {
+	ASN         int
+	ASName      string
+	OrgName     string
+	OrgID       string
+	Address     string
+	CountryCode string
+	AbuseEmail  string
+	AbusePhone  string
+	TechEmail   string
+	TechPhone   string
+	RIR         string
+	RIRRegDate  *time.Time
+	RIRLastMod  *time.Time
+	WHOISRaw    string
+}

internal/database/schema.sql

@@ -1,16 +1,44 @@
+-- IMPORTANT: This is the ONLY place where schema changes should be made.
+-- We do NOT support migrations. All schema changes MUST be in this file.
+-- DO NOT make schema changes anywhere else in the codebase.
+
 CREATE TABLE IF NOT EXISTS asns (
-	id TEXT PRIMARY KEY,
-	number INTEGER UNIQUE NOT NULL,
+	asn INTEGER PRIMARY KEY,
 	handle TEXT,
 	description TEXT,
+	-- WHOIS parsed fields
+	as_name TEXT,
+	org_name TEXT,
+	org_id TEXT,
+	address TEXT,                -- full address (may be multi-line)
+	country_code TEXT,
+	abuse_email TEXT,
+	abuse_phone TEXT,
+	tech_email TEXT,
+	tech_phone TEXT,
+	rir TEXT,                    -- ARIN, RIPE, APNIC, LACNIC, AFRINIC
+	rir_registration_date DATETIME,
+	rir_last_modified DATETIME,
+	-- Raw WHOIS response
+	whois_raw TEXT,              -- complete WHOIS response text
+	-- Timestamps
+	first_seen DATETIME NOT NULL,
+	last_seen DATETIME NOT NULL,
+	whois_updated_at DATETIME    -- when we last fetched WHOIS data
+);
+
+-- IPv4 prefixes table
+CREATE TABLE IF NOT EXISTS prefixes_v4 (
+	id TEXT PRIMARY KEY,
+	prefix TEXT UNIQUE NOT NULL,
 	first_seen DATETIME NOT NULL,
 	last_seen DATETIME NOT NULL
 );
 
-CREATE TABLE IF NOT EXISTS prefixes (
+-- IPv6 prefixes table
+CREATE TABLE IF NOT EXISTS prefixes_v6 (
 	id TEXT PRIMARY KEY,
 	prefix TEXT UNIQUE NOT NULL,
-	ip_version INTEGER NOT NULL, -- 4 for IPv4, 6 for IPv6
 	first_seen DATETIME NOT NULL,
 	last_seen DATETIME NOT NULL
 );
@@ -18,15 +46,14 @@ CREATE TABLE IF NOT EXISTS prefixes (
 CREATE TABLE IF NOT EXISTS announcements (
 	id TEXT PRIMARY KEY,
 	prefix_id TEXT NOT NULL,
-	asn_id TEXT NOT NULL,
-	origin_asn_id TEXT NOT NULL,
+	peer_asn INTEGER NOT NULL,
+	origin_asn INTEGER NOT NULL,
 	path TEXT NOT NULL,
 	next_hop TEXT,
 	timestamp DATETIME NOT NULL,
 	is_withdrawal BOOLEAN NOT NULL DEFAULT 0,
-	FOREIGN KEY (prefix_id) REFERENCES prefixes(id),
-	FOREIGN KEY (asn_id) REFERENCES asns(id),
-	FOREIGN KEY (origin_asn_id) REFERENCES asns(id)
+	FOREIGN KEY (peer_asn) REFERENCES asns(asn),
+	FOREIGN KEY (origin_asn) REFERENCES asns(asn)
 );
 
 CREATE TABLE IF NOT EXISTS peerings (
@@ -48,47 +75,72 @@ CREATE TABLE IF NOT EXISTS bgp_peers (
 	last_message_type TEXT
 );
 
-CREATE INDEX IF NOT EXISTS idx_prefixes_ip_version ON prefixes(ip_version);
-CREATE INDEX IF NOT EXISTS idx_prefixes_version_prefix ON prefixes(ip_version, prefix);
+-- Indexes for prefixes_v4 table
+CREATE INDEX IF NOT EXISTS idx_prefixes_v4_prefix ON prefixes_v4(prefix);
+
+-- Indexes for prefixes_v6 table
+CREATE INDEX IF NOT EXISTS idx_prefixes_v6_prefix ON prefixes_v6(prefix);
 CREATE INDEX IF NOT EXISTS idx_announcements_timestamp ON announcements(timestamp);
 CREATE INDEX IF NOT EXISTS idx_announcements_prefix_id ON announcements(prefix_id);
-CREATE INDEX IF NOT EXISTS idx_announcements_asn_id ON announcements(asn_id);
+CREATE INDEX IF NOT EXISTS idx_announcements_peer_asn ON announcements(peer_asn);
+CREATE INDEX IF NOT EXISTS idx_announcements_origin_asn ON announcements(origin_asn);
 CREATE INDEX IF NOT EXISTS idx_peerings_as_a ON peerings(as_a);
 CREATE INDEX IF NOT EXISTS idx_peerings_as_b ON peerings(as_b);
 CREATE INDEX IF NOT EXISTS idx_peerings_lookup ON peerings(as_a, as_b);
 
--- Additional indexes for prefixes table
-CREATE INDEX IF NOT EXISTS idx_prefixes_prefix ON prefixes(prefix);
-
 -- Indexes for asns table
-CREATE INDEX IF NOT EXISTS idx_asns_number ON asns(number);
+CREATE INDEX IF NOT EXISTS idx_asns_asn ON asns(asn);
+CREATE INDEX IF NOT EXISTS idx_asns_whois_updated_at ON asns(whois_updated_at);
 
 -- Indexes for bgp_peers table
 CREATE INDEX IF NOT EXISTS idx_bgp_peers_asn ON bgp_peers(peer_asn);
 CREATE INDEX IF NOT EXISTS idx_bgp_peers_last_seen ON bgp_peers(last_seen);
 CREATE INDEX IF NOT EXISTS idx_bgp_peers_ip ON bgp_peers(peer_ip);
 
--- Live routing table maintained by PrefixHandler
-CREATE TABLE IF NOT EXISTS live_routes (
+-- IPv4 routing table maintained by PrefixHandler
+CREATE TABLE IF NOT EXISTS live_routes_v4 (
 	id TEXT PRIMARY KEY,
 	prefix TEXT NOT NULL,
-	mask_length INTEGER NOT NULL, -- CIDR mask length (0-32 for IPv4, 0-128 for IPv6)
-	ip_version INTEGER NOT NULL, -- 4 or 6
+	mask_length INTEGER NOT NULL, -- CIDR mask length (0-32)
 	origin_asn INTEGER NOT NULL,
 	peer_ip TEXT NOT NULL,
 	as_path TEXT NOT NULL, -- JSON array
 	next_hop TEXT NOT NULL,
 	last_updated DATETIME NOT NULL,
-	-- IPv4 range columns for fast lookups (NULL for IPv6)
-	v4_ip_start INTEGER, -- Start of IPv4 range as 32-bit unsigned int
-	v4_ip_end INTEGER,   -- End of IPv4 range as 32-bit unsigned int
+	-- IPv4 range columns for fast lookups
+	ip_start INTEGER NOT NULL, -- Start of IPv4 range as 32-bit unsigned int
+	ip_end INTEGER NOT NULL,    -- End of IPv4 range as 32-bit unsigned int
 	UNIQUE(prefix, origin_asn, peer_ip)
 );
 
--- Indexes for live_routes table
-CREATE INDEX IF NOT EXISTS idx_live_routes_prefix ON live_routes(prefix);
-CREATE INDEX IF NOT EXISTS idx_live_routes_mask_length ON live_routes(mask_length);
-CREATE INDEX IF NOT EXISTS idx_live_routes_ip_version_mask ON live_routes(ip_version, mask_length);
-CREATE INDEX IF NOT EXISTS idx_live_routes_last_updated ON live_routes(last_updated);
+-- IPv6 routing table maintained by PrefixHandler
+CREATE TABLE IF NOT EXISTS live_routes_v6 (
+	id TEXT PRIMARY KEY,
+	prefix TEXT NOT NULL,
+	mask_length INTEGER NOT NULL, -- CIDR mask length (0-128)
+	origin_asn INTEGER NOT NULL,
+	peer_ip TEXT NOT NULL,
+	as_path TEXT NOT NULL, -- JSON array
+	next_hop TEXT NOT NULL,
+	last_updated DATETIME NOT NULL,
+	-- Note: IPv6 doesn't use integer range columns
+	UNIQUE(prefix, origin_asn, peer_ip)
+);
+
+-- Indexes for live_routes_v4 table
+CREATE INDEX IF NOT EXISTS idx_live_routes_v4_prefix ON live_routes_v4(prefix);
+CREATE INDEX IF NOT EXISTS idx_live_routes_v4_mask_length ON live_routes_v4(mask_length);
+CREATE INDEX IF NOT EXISTS idx_live_routes_v4_origin_asn ON live_routes_v4(origin_asn);
+CREATE INDEX IF NOT EXISTS idx_live_routes_v4_last_updated ON live_routes_v4(last_updated);
 -- Indexes for IPv4 range queries
-CREATE INDEX IF NOT EXISTS idx_live_routes_ipv4_range ON live_routes(v4_ip_start, v4_ip_end) WHERE ip_version = 4;
+CREATE INDEX IF NOT EXISTS idx_live_routes_v4_ip_range ON live_routes_v4(ip_start, ip_end);
+-- Index to optimize prefix distribution queries
+CREATE INDEX IF NOT EXISTS idx_live_routes_v4_mask_prefix ON live_routes_v4(mask_length, prefix);
+
+-- Indexes for live_routes_v6 table
+CREATE INDEX IF NOT EXISTS idx_live_routes_v6_prefix ON live_routes_v6(prefix);
+CREATE INDEX IF NOT EXISTS idx_live_routes_v6_mask_length ON live_routes_v6(mask_length);
+CREATE INDEX IF NOT EXISTS idx_live_routes_v6_origin_asn ON live_routes_v6(origin_asn);
+CREATE INDEX IF NOT EXISTS idx_live_routes_v6_last_updated ON live_routes_v6(last_updated);
+-- Index to optimize prefix distribution queries
+CREATE INDEX IF NOT EXISTS idx_live_routes_v6_mask_prefix ON live_routes_v6(mask_length, prefix);

internal/database/slowquery.go

@@ -8,7 +8,7 @@ import (
 	"git.eeqj.de/sneak/routewatch/internal/logger"
 )
 
-const slowQueryThreshold = 50 * time.Millisecond
+const slowQueryThreshold = 25 * time.Millisecond
 
 // logSlowQuery logs queries that take longer than slowQueryThreshold
 func logSlowQuery(logger *logger.Logger, query string, start time.Time) {
@@ -19,6 +19,7 @@ func logSlowQuery(logger *logger.Logger, query string, start time.Time) {
 }
 
 // queryRow wraps QueryRow with slow query logging
+// nolint:unused // kept for consistency with other query wrappers
 func (d *Database) queryRow(query string, args ...interface{}) *sql.Row {
 	start := time.Now()
 	defer logSlowQuery(d.logger, query, start)

internal/logger/logger.go

@@ -1,4 +1,8 @@
-// Package logger provides a structured logger with source location tracking
+// Package logger provides a structured logger with source location tracking.
+// It wraps the standard library's log/slog package and automatically enriches
+// log messages with the file name, line number, and function name of the caller.
+// The output format is automatically selected based on the runtime environment:
+// human-readable text for terminals, JSON for non-terminal output.
 package logger
 
 import (
@@ -12,17 +16,25 @@ import (
 	"golang.org/x/term"
 )
 
-// Logger wraps slog.Logger to add source location information
+// Logger wraps slog.Logger to add automatic source location information
+// to all log messages. It embeds slog.Logger and provides the same logging
+// methods (Debug, Info, Warn, Error) but enriches each message with the
+// file name, line number, and function name of the caller.
 type Logger struct {
 	*slog.Logger
 }
 
-// AsSlog returns the underlying slog.Logger
+// AsSlog returns the underlying slog.Logger for use with APIs that require
+// a standard slog.Logger instance rather than the custom Logger type.
 func (l *Logger) AsSlog() *slog.Logger {
 	return l.Logger
 }
 
-// New creates a new logger with appropriate handler based on environment
+// New creates a new Logger with an appropriate handler based on the runtime
+// environment. If stdout is a terminal, it uses a human-readable text format;
+// otherwise, it outputs JSON for structured log aggregation. The log level
+// defaults to Info, but can be set to Debug by including "routewatch" in the
+// DEBUG environment variable.
 func New() *Logger {
 	level := slog.LevelInfo
 	if debug := os.Getenv("DEBUG"); strings.Contains(debug, "routewatch") {
@@ -45,7 +57,10 @@ func New() *Logger {
 	return &Logger{Logger: slog.New(handler)}
 }
 
-const sourceSkipLevel = 2 // Skip levels for source location tracking
+// sourceSkipLevel defines the number of call stack frames to skip when
+// determining the caller's source location. This accounts for the logger
+// method itself and the getSourceAttrs helper function.
+const sourceSkipLevel = 2
 
 // getSourceAttrs returns attributes for the calling source location
 func getSourceAttrs() []slog.Attr {
@@ -75,7 +90,10 @@ func getSourceAttrs() []slog.Attr {
 	return attrs
 }
 
-// Debug logs at debug level with source location
+// Debug logs a message at debug level with automatic source location tracking.
+// Additional structured attributes can be passed as key-value pairs in args.
+// Debug messages are only output when the DEBUG environment variable contains
+// "routewatch".
 func (l *Logger) Debug(msg string, args ...any) {
 	sourceAttrs := getSourceAttrs()
 	allArgs := make([]any, 0, len(args)+len(sourceAttrs)*2)
@@ -91,7 +109,8 @@ func (l *Logger) Debug(msg string, args ...any) {
 	l.Logger.Debug(msg, allArgs...)
 }
 
-// Info logs at info level with source location
+// Info logs a message at info level with automatic source location tracking.
+// Additional structured attributes can be passed as key-value pairs in args.
 func (l *Logger) Info(msg string, args ...any) {
 	sourceAttrs := getSourceAttrs()
 	allArgs := make([]any, 0, len(args)+len(sourceAttrs)*2)
@@ -107,7 +126,8 @@ func (l *Logger) Info(msg string, args ...any) {
 	l.Logger.Info(msg, allArgs...)
 }
 
-// Warn logs at warn level with source location
+// Warn logs a message at warn level with automatic source location tracking.
+// Additional structured attributes can be passed as key-value pairs in args.
 func (l *Logger) Warn(msg string, args ...any) {
 	sourceAttrs := getSourceAttrs()
 	allArgs := make([]any, 0, len(args)+len(sourceAttrs)*2)
@@ -123,7 +143,8 @@ func (l *Logger) Warn(msg string, args ...any) {
 	l.Logger.Warn(msg, allArgs...)
 }
 
-// Error logs at error level with source location
+// Error logs a message at error level with automatic source location tracking.
+// Additional structured attributes can be passed as key-value pairs in args.
 func (l *Logger) Error(msg string, args ...any) {
 	sourceAttrs := getSourceAttrs()
 	allArgs := make([]any, 0, len(args)+len(sourceAttrs)*2)
@@ -139,12 +160,16 @@ func (l *Logger) Error(msg string, args ...any) {
 	l.Logger.Error(msg, allArgs...)
 }
 
-// With returns a new logger with additional attributes
+// With returns a new Logger with additional structured attributes that will
+// be included in all subsequent log messages. The args parameter accepts
+// key-value pairs in the same format as the logging methods.
 func (l *Logger) With(args ...any) *Logger {
 	return &Logger{Logger: l.Logger.With(args...)}
 }
 
-// WithGroup returns a new logger with a group prefix
+// WithGroup returns a new Logger that adds the specified group name as a
+// prefix to all attribute keys in subsequent log messages. This is useful
+// for organizing related attributes under a common namespace.
 func (l *Logger) WithGroup(name string) *Logger {
 	return &Logger{Logger: l.Logger.WithGroup(name)}
 }

internal/metrics/metrics.go

@@ -15,16 +15,29 @@ type Tracker struct {
 	registry       metrics.Registry
 	connectedSince time.Time
 	isConnected    atomic.Bool
+	reconnectCount atomic.Uint64
 
-	// Stream metrics
+	// Stream metrics (decompressed data)
 	messageCounter metrics.Counter
 	byteCounter    metrics.Counter
 	messageRate    metrics.Meter
 	byteRate       metrics.Meter
 
+	// Wire bytes metrics (actual bytes on the wire, before decompression)
+	wireByteCounter metrics.Counter
+	wireByteRate    metrics.Meter
+
 	// Route update metrics
 	ipv4UpdateRate metrics.Meter
 	ipv6UpdateRate metrics.Meter
+
+	// Announcement/withdrawal metrics
+	announcementCounter metrics.Counter
+	withdrawalCounter   metrics.Counter
+	churnRate           metrics.Meter // combined announcements + withdrawals per second
+
+	// BGP peer tracking
+	bgpPeerCount atomic.Int32
 }
 
 // New creates a new metrics tracker
@@ -32,32 +45,46 @@ func New() *Tracker {
 	registry := metrics.NewRegistry()
 
 	return &Tracker{
-		registry:       registry,
-		messageCounter: metrics.NewCounter(),
-		byteCounter:    metrics.NewCounter(),
-		messageRate:    metrics.NewMeter(),
-		byteRate:       metrics.NewMeter(),
-		ipv4UpdateRate: metrics.NewMeter(),
-		ipv6UpdateRate: metrics.NewMeter(),
+		registry:            registry,
+		messageCounter:      metrics.NewCounter(),
+		byteCounter:         metrics.NewCounter(),
+		messageRate:         metrics.NewMeter(),
+		byteRate:            metrics.NewMeter(),
+		wireByteCounter:     metrics.NewCounter(),
+		wireByteRate:        metrics.NewMeter(),
+		ipv4UpdateRate:      metrics.NewMeter(),
+		ipv6UpdateRate:      metrics.NewMeter(),
+		announcementCounter: metrics.NewCounter(),
+		withdrawalCounter:   metrics.NewCounter(),
+		churnRate:           metrics.NewMeter(),
 	}
 }
 
 // SetConnected updates the connection status
 func (t *Tracker) SetConnected(connected bool) {
-	t.isConnected.Store(connected)
+	wasConnected := t.isConnected.Swap(connected)
 	if connected {
 		t.mu.Lock()
 		t.connectedSince = time.Now()
 		t.mu.Unlock()
+		// Increment reconnect count (but not for the initial connection)
+		if wasConnected || t.reconnectCount.Load() > 0 {
+			t.reconnectCount.Add(1)
+		}
 	}
 }
 
+// GetReconnectCount returns the number of reconnections since startup
+func (t *Tracker) GetReconnectCount() uint64 {
+	return t.reconnectCount.Load()
+}
+
 // IsConnected returns the current connection status
 func (t *Tracker) IsConnected() bool {
 	return t.isConnected.Load()
 }
 
-// RecordMessage records a received message and its size
+// RecordMessage records a received message and its decompressed size
 func (t *Tracker) RecordMessage(bytes int64) {
 	t.messageCounter.Inc(1)
 	t.byteCounter.Inc(bytes)
@@ -65,6 +92,12 @@ func (t *Tracker) RecordMessage(bytes int64) {
 	t.byteRate.Mark(bytes)
 }
 
+// RecordWireBytes records actual bytes received on the wire (before decompression)
+func (t *Tracker) RecordWireBytes(bytes int64) {
+	t.wireByteCounter.Inc(bytes)
+	t.wireByteRate.Mark(bytes)
+}
+
 // GetStreamMetrics returns current streaming metrics
 func (t *Tracker) GetStreamMetrics() StreamMetrics {
 	t.mu.RLock()
@@ -76,22 +109,29 @@ func (t *Tracker) GetStreamMetrics() StreamMetrics {
 	// Safely convert counters to uint64
 	msgCount := t.messageCounter.Count()
 	byteCount := t.byteCounter.Count()
+	wireByteCount := t.wireByteCounter.Count()
 
-	var totalMessages, totalBytes uint64
+	var totalMessages, totalBytes, totalWireBytes uint64
 	if msgCount >= 0 {
 		totalMessages = uint64(msgCount)
 	}
 	if byteCount >= 0 {
 		totalBytes = uint64(byteCount)
 	}
+	if wireByteCount >= 0 {
+		totalWireBytes = uint64(wireByteCount)
+	}
 
 	return StreamMetrics{
 		TotalMessages:  totalMessages,
 		TotalBytes:     totalBytes,
+		TotalWireBytes: totalWireBytes,
 		ConnectedSince: connectedSince,
 		Connected:      t.isConnected.Load(),
 		MessagesPerSec: t.messageRate.Rate1(),
 		BitsPerSec:     t.byteRate.Rate1() * bitsPerByte,
+		WireBitsPerSec: t.wireByteRate.Rate1() * bitsPerByte,
+		ReconnectCount: t.reconnectCount.Load(),
 	}
 }
 
@@ -105,6 +145,56 @@ func (t *Tracker) RecordIPv6Update() {
 	t.ipv6UpdateRate.Mark(1)
 }
 
+// RecordAnnouncement records a route announcement
+func (t *Tracker) RecordAnnouncement() {
+	t.announcementCounter.Inc(1)
+	t.churnRate.Mark(1)
+}
+
+// RecordWithdrawal records a route withdrawal
+func (t *Tracker) RecordWithdrawal() {
+	t.withdrawalCounter.Inc(1)
+	t.churnRate.Mark(1)
+}
+
+// SetBGPPeerCount updates the current BGP peer count
+func (t *Tracker) SetBGPPeerCount(count int) {
+	// BGP peer count is always small (< 1000), so int32 is safe
+	if count > 0 && count < 1<<31 {
+		t.bgpPeerCount.Store(int32(count)) //nolint:gosec // count is validated
+	}
+}
+
+// GetBGPPeerCount returns the current BGP peer count
+func (t *Tracker) GetBGPPeerCount() int {
+	return int(t.bgpPeerCount.Load())
+}
+
+// GetAnnouncementCount returns the total announcement count
+func (t *Tracker) GetAnnouncementCount() uint64 {
+	count := t.announcementCounter.Count()
+	if count < 0 {
+		return 0
+	}
+
+	return uint64(count)
+}
+
+// GetWithdrawalCount returns the total withdrawal count
+func (t *Tracker) GetWithdrawalCount() uint64 {
+	count := t.withdrawalCounter.Count()
+	if count < 0 {
+		return 0
+	}
+
+	return uint64(count)
+}
+
+// GetChurnRate returns the route churn rate per second
+func (t *Tracker) GetChurnRate() float64 {
+	return t.churnRate.Rate1()
+}
+
 // GetRouteMetrics returns current route update metrics
 func (t *Tracker) GetRouteMetrics() RouteMetrics {
 	return RouteMetrics{
@@ -115,16 +205,30 @@ func (t *Tracker) GetRouteMetrics() RouteMetrics {
 
 // StreamMetrics contains streaming statistics
 type StreamMetrics struct {
-	TotalMessages  uint64
-	TotalBytes     uint64
+	// TotalMessages is the total number of messages received since startup
+	TotalMessages uint64
+	// TotalBytes is the total number of decompressed bytes received since startup
+	TotalBytes uint64
+	// TotalWireBytes is the total number of bytes received on the wire (before decompression)
+	TotalWireBytes uint64
+	// ConnectedSince is the time when the current connection was established
 	ConnectedSince time.Time
-	Connected      bool
+	// Connected indicates whether the stream is currently connected
+	Connected bool
+	// MessagesPerSec is the rate of messages received per second (1-minute average)
 	MessagesPerSec float64
-	BitsPerSec     float64
+	// BitsPerSec is the rate of decompressed bits received per second (1-minute average)
+	BitsPerSec float64
+	// WireBitsPerSec is the rate of bits received on the wire per second (1-minute average)
+	WireBitsPerSec float64
+	// ReconnectCount is the number of reconnections since startup
+	ReconnectCount uint64
 }
 
 // RouteMetrics contains route update statistics
 type RouteMetrics struct {
+	// IPv4UpdatesPerSec is the rate of IPv4 route updates per second (1-minute average)
 	IPv4UpdatesPerSec float64
+	// IPv6UpdatesPerSec is the rate of IPv6 route updates per second (1-minute average)
 	IPv6UpdatesPerSec float64
 }

internal/ristypes/ris.go

@@ -6,10 +6,14 @@ import (
 	"time"
 )
 
-// ASPath represents an AS path that may contain nested AS sets
+// ASPath represents a BGP AS path as a slice of AS numbers.
+// It handles JSON unmarshaling of both simple arrays and nested AS sets,
+// flattening any nested structures into a single sequence of AS numbers.
 type ASPath []int
 
-// UnmarshalJSON implements custom JSON unmarshaling to flatten nested arrays
+// UnmarshalJSON implements the json.Unmarshaler interface for ASPath.
+// It handles both simple integer arrays [1, 2, 3] and nested AS sets
+// like [1, [2, 3], 4], flattening them into a single slice of integers.
 func (p *ASPath) UnmarshalJSON(data []byte) error {
 	// First try to unmarshal as a simple array of integers
 	var simple []int
@@ -46,13 +50,18 @@ func (p *ASPath) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-// RISLiveMessage represents the outer wrapper from the RIS Live stream
+// RISLiveMessage represents the outer wrapper message from the RIPE RIS Live stream.
+// Each message contains a Type field indicating the message type and a Data field
+// containing the actual BGP message payload.
 type RISLiveMessage struct {
 	Type string     `json:"type"`
 	Data RISMessage `json:"data"`
 }
 
-// RISMessage represents a message from the RIS Live stream
+// RISMessage represents a BGP update message from the RIPE RIS Live stream.
+// It contains metadata about the BGP session (peer, ASN, host) along with
+// the actual BGP update data including AS path, communities, announcements,
+// and withdrawals.
 type RISMessage struct {
 	Type            string            `json:"type"`
 	Timestamp       float64           `json:"timestamp"`
@@ -74,7 +83,9 @@ type RISMessage struct {
 	Raw             string            `json:"raw,omitempty"`
 }
 
-// RISAnnouncement represents announcement data within a RIS message
+// RISAnnouncement represents a BGP route announcement within a RIS message.
+// It contains the next hop IP address and the list of prefixes being announced
+// via that next hop.
 type RISAnnouncement struct {
 	NextHop  string   `json:"next_hop"`
 	Prefixes []string `json:"prefixes"`

internal/routewatch/app.go

@@ -43,6 +43,8 @@ type RouteWatch struct {
 	peerHandler    *PeerHandler
 	prefixHandler  *PrefixHandler
 	peeringHandler *PeeringHandler
+	asnFetcher     *ASNFetcher
+	dbMaintainer   *DBMaintainer
 }
 
 // New creates a new RouteWatch instance
@@ -109,6 +111,15 @@ func (rw *RouteWatch) Run(ctx context.Context) error {
 		return err
 	}
 
+	// Start ASN WHOIS fetcher for background updates
+	rw.asnFetcher = NewASNFetcher(rw.db, rw.logger.Logger)
+	rw.asnFetcher.Start()
+	rw.server.SetASNFetcher(rw.asnFetcher)
+
+	// Start database maintenance goroutine
+	rw.dbMaintainer = NewDBMaintainer(rw.db, rw.logger.Logger)
+	rw.dbMaintainer.Start()
+
 	// Wait for context cancellation
 	<-ctx.Done()
 
@@ -144,6 +155,16 @@ func (rw *RouteWatch) Shutdown() {
 		rw.peeringHandler.Stop()
 	}
 
+	// Stop ASN WHOIS fetcher
+	if rw.asnFetcher != nil {
+		rw.asnFetcher.Stop()
+	}
+
+	// Stop database maintainer
+	if rw.dbMaintainer != nil {
+		rw.dbMaintainer.Stop()
+	}
+
 	// Stop services
 	rw.streamer.Stop()
 

internal/routewatch/app_integration_test.go

@@ -61,8 +61,7 @@ func (m *mockStore) GetOrCreateASN(number int, timestamp time.Time) (*database.A
 	}
 
 	asn := &database.ASN{
-		ID:        uuid.New(),
-		Number:    number,
+		ASN:       number,
 		FirstSeen: timestamp,
 		LastSeen:  timestamp,
 	}
@@ -72,6 +71,37 @@ func (m *mockStore) GetOrCreateASN(number int, timestamp time.Time) (*database.A
 	return asn, nil
 }
 
+// UpdatePrefixesBatch mock implementation
+func (m *mockStore) UpdatePrefixesBatch(prefixes map[string]time.Time) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	for prefix, timestamp := range prefixes {
+		if p, exists := m.Prefixes[prefix]; exists {
+			p.LastSeen = timestamp
+		} else {
+			const (
+				ipVersionV4 = 4
+				ipVersionV6 = 6
+			)
+
+			ipVersion := ipVersionV4
+			if strings.Contains(prefix, ":") {
+				ipVersion = ipVersionV6
+			}
+
+			m.Prefixes[prefix] = &database.Prefix{
+				ID:        uuid.New(),
+				Prefix:    prefix,
+				IPVersion: ipVersion,
+				FirstSeen: timestamp,
+				LastSeen:  timestamp,
+			}
+		}
+	}
+	return nil
+}
+
 // GetOrCreatePrefix mock implementation
 func (m *mockStore) GetOrCreatePrefix(prefix string, timestamp time.Time) (*database.Prefix, error) {
 	m.mu.Lock()
@@ -163,6 +193,11 @@ func (m *mockStore) GetStats() (database.Stats, error) {
 	}, nil
 }
 
+// GetStatsContext returns statistics about the mock store with context support
+func (m *mockStore) GetStatsContext(ctx context.Context) (database.Stats, error) {
+	return m.GetStats()
+}
+
 // UpsertLiveRoute mock implementation
 func (m *mockStore) UpsertLiveRoute(route *database.LiveRoute) error {
 	// Simple mock - just return nil
@@ -181,12 +216,22 @@ func (m *mockStore) GetPrefixDistribution() (ipv4 []database.PrefixDistribution,
 	return nil, nil, nil
 }
 
+// GetPrefixDistributionContext mock implementation with context support
+func (m *mockStore) GetPrefixDistributionContext(ctx context.Context) (ipv4 []database.PrefixDistribution, ipv6 []database.PrefixDistribution, err error) {
+	return m.GetPrefixDistribution()
+}
+
 // GetLiveRouteCounts mock implementation
 func (m *mockStore) GetLiveRouteCounts() (ipv4Count, ipv6Count int, err error) {
 	// Return mock counts
 	return m.RouteCount / 2, m.RouteCount / 2, nil
 }
 
+// GetLiveRouteCountsContext mock implementation with context support
+func (m *mockStore) GetLiveRouteCountsContext(ctx context.Context) (ipv4Count, ipv6Count int, err error) {
+	return m.GetLiveRouteCounts()
+}
+
 // GetASInfoForIP mock implementation
 func (m *mockStore) GetASInfoForIP(ip string) (*database.ASInfo, error) {
 	// Simple mock - return a test AS
@@ -201,6 +246,11 @@ func (m *mockStore) GetASInfoForIP(ip string) (*database.ASInfo, error) {
 	}, nil
 }
 
+// GetASInfoForIPContext mock implementation with context support
+func (m *mockStore) GetASInfoForIPContext(ctx context.Context, ip string) (*database.ASInfo, error) {
+	return m.GetASInfoForIP(ip)
+}
+
 // GetASDetails mock implementation
 func (m *mockStore) GetASDetails(asn int) (*database.ASN, []database.LiveRoute, error) {
 	m.mu.Lock()
@@ -215,12 +265,89 @@ func (m *mockStore) GetASDetails(asn int) (*database.ASN, []database.LiveRoute,
 	return nil, nil, database.ErrNoRoute
 }
 
+// GetASDetailsContext mock implementation with context support
+func (m *mockStore) GetASDetailsContext(ctx context.Context, asn int) (*database.ASN, []database.LiveRoute, error) {
+	return m.GetASDetails(asn)
+}
+
 // GetPrefixDetails mock implementation
 func (m *mockStore) GetPrefixDetails(prefix string) ([]database.LiveRoute, error) {
 	// Return empty routes for now
 	return []database.LiveRoute{}, nil
 }
 
+// GetPrefixDetailsContext mock implementation with context support
+func (m *mockStore) GetPrefixDetailsContext(ctx context.Context, prefix string) ([]database.LiveRoute, error) {
+	return m.GetPrefixDetails(prefix)
+}
+
+func (m *mockStore) GetRandomPrefixesByLength(maskLength, ipVersion, limit int) ([]database.LiveRoute, error) {
+	// Return empty routes for now
+	return []database.LiveRoute{}, nil
+}
+
+// GetRandomPrefixesByLengthContext mock implementation with context support
+func (m *mockStore) GetRandomPrefixesByLengthContext(ctx context.Context, maskLength, ipVersion, limit int) ([]database.LiveRoute, error) {
+	return m.GetRandomPrefixesByLength(maskLength, ipVersion, limit)
+}
+
+// GetASPeers mock implementation
+func (m *mockStore) GetASPeers(asn int) ([]database.ASPeer, error) {
+	// Return empty peers for now
+	return []database.ASPeer{}, nil
+}
+
+// GetASPeersContext mock implementation with context support
+func (m *mockStore) GetASPeersContext(ctx context.Context, asn int) ([]database.ASPeer, error) {
+	return m.GetASPeers(asn)
+}
+
+// GetIPInfo mock implementation
+func (m *mockStore) GetIPInfo(ip string) (*database.IPInfo, error) {
+	return m.GetIPInfoContext(context.Background(), ip)
+}
+
+// GetIPInfoContext mock implementation with context support
+func (m *mockStore) GetIPInfoContext(ctx context.Context, ip string) (*database.IPInfo, error) {
+	now := time.Now()
+	return &database.IPInfo{
+		IP:          ip,
+		Netblock:    "8.8.8.0/24",
+		MaskLength:  24,
+		IPVersion:   4,
+		NumPeers:    3,
+		ASN:         15169,
+		Handle:      "GOOGLE",
+		Description: "Google LLC",
+		CountryCode: "US",
+		FirstSeen:   now.Add(-24 * time.Hour),
+		LastSeen:    now,
+	}, nil
+}
+
+// GetNextStaleASN mock implementation
+func (m *mockStore) GetNextStaleASN(ctx context.Context, staleThreshold time.Duration) (int, error) {
+	return 0, database.ErrNoStaleASN
+}
+
+// UpdateASNWHOIS mock implementation
+func (m *mockStore) UpdateASNWHOIS(ctx context.Context, update *database.ASNWHOISUpdate) error {
+	return nil
+}
+
+// GetWHOISStats mock implementation
+func (m *mockStore) GetWHOISStats(ctx context.Context, staleThreshold time.Duration) (*database.WHOISStats, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	return &database.WHOISStats{
+		TotalASNs:    len(m.ASNs),
+		FreshASNs:    0,
+		StaleASNs:    0,
+		NeverFetched: len(m.ASNs),
+	}, nil
+}
+
 // UpsertLiveRouteBatch mock implementation
 func (m *mockStore) UpsertLiveRouteBatch(routes []*database.LiveRoute) error {
 	m.mu.Lock()
@@ -262,8 +389,7 @@ func (m *mockStore) GetOrCreateASNBatch(asns map[int]time.Time) error {
 	for number, timestamp := range asns {
 		if _, exists := m.ASNs[number]; !exists {
 			m.ASNs[number] = &database.ASN{
-				ID:        uuid.New(),
-				Number:    number,
+				ASN:       number,
 				FirstSeen: timestamp,
 				LastSeen:  timestamp,
 			}
@@ -279,6 +405,26 @@ func (m *mockStore) UpdatePeerBatch(peers map[string]database.PeerUpdate) error
 	return nil
 }
 
+// Vacuum mock implementation
+func (m *mockStore) Vacuum(ctx context.Context) error {
+	return nil
+}
+
+// Analyze mock implementation
+func (m *mockStore) Analyze(ctx context.Context) error {
+	return nil
+}
+
+// Checkpoint mock implementation
+func (m *mockStore) Checkpoint(ctx context.Context) error {
+	return nil
+}
+
+// Ping mock implementation
+func (m *mockStore) Ping(ctx context.Context) error {
+	return nil
+}
+
 func TestRouteWatchLiveFeed(t *testing.T) {
 
 	// Create mock database

internal/routewatch/ashandler.go

@@ -11,16 +11,21 @@ import (
 
 const (
 	// asHandlerQueueSize is the queue capacity for ASN operations
+	// DO NOT set this higher than 100000 without explicit instructions
 	asHandlerQueueSize = 100000
 
 	// asnBatchSize is the number of ASN operations to batch together
-	asnBatchSize = 10000
+	asnBatchSize = 30000
 
 	// asnBatchTimeout is the maximum time to wait before flushing a batch
+	// DO NOT reduce this timeout - larger batches are more efficient
 	asnBatchTimeout = 2 * time.Second
 )
 
-// ASHandler handles ASN information from BGP messages using batched operations
+// ASHandler processes Autonomous System Number (ASN) information extracted from
+// BGP UPDATE messages. It uses batched database operations to efficiently store
+// ASN data, collecting operations into batches that are flushed either when the
+// batch reaches a size threshold or after a timeout period.
 type ASHandler struct {
 	db     database.Store
 	logger *logger.Logger
@@ -38,7 +43,11 @@ type asnOp struct {
 	timestamp time.Time
 }
 
-// NewASHandler creates a new batched ASN handler
+// NewASHandler creates and returns a new ASHandler instance. It initializes
+// the batching system and starts a background goroutine that periodically
+// flushes accumulated ASN operations to the database. The caller must call
+// Stop when finished to ensure all pending operations are flushed and the
+// background goroutine is terminated.
 func NewASHandler(db database.Store, logger *logger.Logger) *ASHandler {
 	h := &ASHandler{
 		db:        db,
@@ -55,19 +64,27 @@ func NewASHandler(db database.Store, logger *logger.Logger) *ASHandler {
 	return h
 }
 
-// WantsMessage returns true if this handler wants to process messages of the given type
+// WantsMessage reports whether this handler should process messages of the
+// given type. ASHandler only processes "UPDATE" messages, as these contain
+// the AS path information needed to track autonomous systems.
 func (h *ASHandler) WantsMessage(messageType string) bool {
 	// We only care about UPDATE messages for the database
 	return messageType == "UPDATE"
 }
 
-// QueueCapacity returns the desired queue capacity for this handler
+// QueueCapacity returns the recommended message queue size for this handler.
+// ASHandler uses a large queue capacity to accommodate high-volume BGP streams,
+// as the batching mechanism allows efficient processing of accumulated messages.
 func (h *ASHandler) QueueCapacity() int {
 	// Batching allows us to use a larger queue
 	return asHandlerQueueSize
 }
 
-// HandleMessage processes a RIS message and queues database operations
+// HandleMessage processes a RIS Live BGP message by extracting all ASNs from
+// the AS path and queuing them for batch insertion into the database. The
+// origin ASN (last element in the path) and all transit ASNs are recorded
+// with their associated timestamps. The batch is automatically flushed when
+// it reaches the configured size threshold.
 func (h *ASHandler) HandleMessage(msg *ristypes.RISMessage) {
 	// Use the pre-parsed timestamp
 	timestamp := msg.ParsedTimestamp
@@ -154,7 +171,11 @@ func (h *ASHandler) flushBatchLocked() {
 	h.lastFlush = time.Now()
 }
 
-// Stop gracefully stops the handler and flushes remaining batches
+// Stop gracefully shuts down the ASHandler by signaling the background flush
+// goroutine to terminate and waiting for it to complete. Any pending ASN
+// operations in the current batch are flushed to the database before Stop
+// returns. This method should be called during application shutdown to ensure
+// no data is lost.
 func (h *ASHandler) Stop() {
 	close(h.stopCh)
 	h.wg.Wait()

internal/routewatch/asnfetcher.go

@@ -0,0 +1,324 @@
+// Package routewatch contains the ASN WHOIS fetcher for background updates.
+package routewatch
+
+import (
+	"context"
+	"log/slog"
+	"sync"
+	"time"
+
+	"git.eeqj.de/sneak/routewatch/internal/database"
+	"git.eeqj.de/sneak/routewatch/internal/server"
+	"git.eeqj.de/sneak/routewatch/internal/whois"
+)
+
+// ASN fetcher configuration constants.
+const (
+	// baseInterval is the starting interval between fetch attempts.
+	baseInterval = 15 * time.Second
+
+	// minInterval is the minimum interval after successes (rate limit).
+	minInterval = 1 * time.Second
+
+	// maxInterval is the maximum interval after failures (backoff cap).
+	maxInterval = 5 * time.Minute
+
+	// backoffMultiplier is how much to multiply interval on failure.
+	backoffMultiplier = 2
+
+	// whoisStaleThreshold is how old WHOIS data can be before refresh.
+	whoisStaleThreshold = 30 * 24 * time.Hour // 30 days
+
+	// immediateQueueSize is the buffer size for immediate fetch requests.
+	immediateQueueSize = 100
+
+	// statsWindow is how long to keep stats for.
+	statsWindow = time.Hour
+)
+
+// ASNFetcher handles background WHOIS lookups for ASNs.
+type ASNFetcher struct {
+	db             database.Store
+	whoisClient    *whois.Client
+	logger         *slog.Logger
+	immediateQueue chan int
+	stopCh         chan struct{}
+	wg             sync.WaitGroup
+
+	// fetchMu ensures only one fetch runs at a time
+	fetchMu sync.Mutex
+
+	// interval tracking with mutex protection
+	intervalMu       sync.Mutex
+	currentInterval  time.Duration
+	consecutiveFails int
+
+	// hourly stats tracking
+	statsMu      sync.Mutex
+	successTimes []time.Time
+	errorTimes   []time.Time
+}
+
+// NewASNFetcher creates a new ASN fetcher.
+func NewASNFetcher(db database.Store, logger *slog.Logger) *ASNFetcher {
+	return &ASNFetcher{
+		db:              db,
+		whoisClient:     whois.NewClient(),
+		logger:          logger.With("component", "asn_fetcher"),
+		immediateQueue:  make(chan int, immediateQueueSize),
+		stopCh:          make(chan struct{}),
+		currentInterval: baseInterval,
+		successTimes:    make([]time.Time, 0),
+		errorTimes:      make([]time.Time, 0),
+	}
+}
+
+// Start begins the background ASN fetcher goroutine.
+func (f *ASNFetcher) Start() {
+	f.wg.Add(1)
+	go f.run()
+	f.logger.Info("ASN fetcher started",
+		"base_interval", baseInterval,
+		"min_interval", minInterval,
+		"max_interval", maxInterval,
+	)
+}
+
+// Stop gracefully shuts down the fetcher.
+func (f *ASNFetcher) Stop() {
+	close(f.stopCh)
+	f.wg.Wait()
+	f.logger.Info("ASN fetcher stopped")
+}
+
+// QueueImmediate queues an ASN for immediate WHOIS lookup.
+// Non-blocking - if queue is full, the request is dropped.
+func (f *ASNFetcher) QueueImmediate(asn int) {
+	select {
+	case f.immediateQueue <- asn:
+		f.logger.Debug("Queued immediate WHOIS lookup", "asn", asn)
+	default:
+		f.logger.Debug("Immediate queue full, dropping request", "asn", asn)
+	}
+}
+
+// GetStats returns statistics about fetcher activity.
+func (f *ASNFetcher) GetStats() server.ASNFetcherStats {
+	f.statsMu.Lock()
+	defer f.statsMu.Unlock()
+
+	f.intervalMu.Lock()
+	interval := f.currentInterval
+	fails := f.consecutiveFails
+	f.intervalMu.Unlock()
+
+	// Prune old entries and count
+	cutoff := time.Now().Add(-statsWindow)
+	f.successTimes = pruneOldTimes(f.successTimes, cutoff)
+	f.errorTimes = pruneOldTimes(f.errorTimes, cutoff)
+
+	return server.ASNFetcherStats{
+		SuccessesLastHour: len(f.successTimes),
+		ErrorsLastHour:    len(f.errorTimes),
+		CurrentInterval:   interval,
+		ConsecutiveFails:  fails,
+	}
+}
+
+// pruneOldTimes removes times older than cutoff and returns the pruned slice.
+func pruneOldTimes(times []time.Time, cutoff time.Time) []time.Time {
+	result := make([]time.Time, 0, len(times))
+	for _, t := range times {
+		if t.After(cutoff) {
+			result = append(result, t)
+		}
+	}
+
+	return result
+}
+
+// getInterval returns the current fetch interval.
+func (f *ASNFetcher) getInterval() time.Duration {
+	f.intervalMu.Lock()
+	defer f.intervalMu.Unlock()
+
+	return f.currentInterval
+}
+
+// recordSuccess decreases the interval on successful fetch.
+func (f *ASNFetcher) recordSuccess() {
+	f.intervalMu.Lock()
+	f.consecutiveFails = 0
+
+	// Decrease interval by half, but not below minimum
+	newInterval := f.currentInterval / backoffMultiplier
+	if newInterval < minInterval {
+		newInterval = minInterval
+	}
+
+	if newInterval != f.currentInterval {
+		f.logger.Debug("Decreased fetch interval",
+			"old_interval", f.currentInterval,
+			"new_interval", newInterval,
+		)
+		f.currentInterval = newInterval
+	}
+	f.intervalMu.Unlock()
+
+	// Record success time for stats
+	f.statsMu.Lock()
+	f.successTimes = append(f.successTimes, time.Now())
+	f.statsMu.Unlock()
+}
+
+// recordFailure increases the interval on failed fetch using exponential backoff.
+func (f *ASNFetcher) recordFailure() {
+	f.intervalMu.Lock()
+	f.consecutiveFails++
+
+	// Exponential backoff: multiply by 2, capped at max
+	newInterval := f.currentInterval * backoffMultiplier
+	if newInterval > maxInterval {
+		newInterval = maxInterval
+	}
+
+	if newInterval != f.currentInterval {
+		f.logger.Debug("Increased fetch interval due to failure",
+			"old_interval", f.currentInterval,
+			"new_interval", newInterval,
+			"consecutive_failures", f.consecutiveFails,
+		)
+		f.currentInterval = newInterval
+	}
+	f.intervalMu.Unlock()
+
+	// Record error time for stats
+	f.statsMu.Lock()
+	f.errorTimes = append(f.errorTimes, time.Now())
+	f.statsMu.Unlock()
+}
+
+// run is the main background loop.
+func (f *ASNFetcher) run() {
+	defer f.wg.Done()
+
+	timer := time.NewTimer(f.getInterval())
+	defer timer.Stop()
+
+	for {
+		select {
+		case <-f.stopCh:
+			return
+
+		case asn := <-f.immediateQueue:
+			// Process immediate request (respects lock)
+			f.tryFetch(asn)
+			// Reset timer after immediate fetch
+			timer.Reset(f.getInterval())
+
+		case <-timer.C:
+			// Background fetch of stale/missing ASN
+			f.fetchNextStale()
+			// Reset timer with potentially updated interval
+			timer.Reset(f.getInterval())
+		}
+	}
+}
+
+// tryFetch attempts to fetch and update an ASN, respecting the fetch lock.
+// Returns true if fetch was successful.
+func (f *ASNFetcher) tryFetch(asn int) bool {
+	// Try to acquire lock, skip if another fetch is running
+	if !f.fetchMu.TryLock() {
+		f.logger.Debug("Skipping fetch, another fetch in progress", "asn", asn)
+
+		return false
+	}
+	defer f.fetchMu.Unlock()
+
+	return f.fetchAndUpdate(asn)
+}
+
+// fetchNextStale finds and fetches the next ASN needing WHOIS data.
+func (f *ASNFetcher) fetchNextStale() {
+	// Try to acquire lock, skip if another fetch is running
+	if !f.fetchMu.TryLock() {
+		f.logger.Debug("Skipping stale fetch, another fetch in progress")
+
+		return
+	}
+	defer f.fetchMu.Unlock()
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+
+	asn, err := f.db.GetNextStaleASN(ctx, whoisStaleThreshold)
+	if err != nil {
+		if err != database.ErrNoStaleASN {
+			f.logger.Error("Failed to get stale ASN", "error", err)
+			f.recordFailure()
+		}
+		// No stale ASN is not a failure, just nothing to do
+
+		return
+	}
+
+	f.fetchAndUpdate(asn)
+}
+
+// fetchAndUpdate performs a WHOIS lookup and updates the database.
+// Returns true if successful.
+func (f *ASNFetcher) fetchAndUpdate(asn int) bool {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+
+	f.logger.Info("Fetching WHOIS data", "asn", asn)
+
+	info, err := f.whoisClient.LookupASN(ctx, asn)
+	if err != nil {
+		f.logger.Error("WHOIS lookup failed", "asn", asn, "error", err)
+		f.recordFailure()
+
+		return false
+	}
+
+	// Update database with WHOIS data
+	err = f.db.UpdateASNWHOIS(ctx, &database.ASNWHOISUpdate{
+		ASN:         asn,
+		ASName:      info.ASName,
+		OrgName:     info.OrgName,
+		OrgID:       info.OrgID,
+		Address:     info.Address,
+		CountryCode: info.CountryCode,
+		AbuseEmail:  info.AbuseEmail,
+		AbusePhone:  info.AbusePhone,
+		TechEmail:   info.TechEmail,
+		TechPhone:   info.TechPhone,
+		RIR:         info.RIR,
+		RIRRegDate:  info.RegDate,
+		RIRLastMod:  info.LastMod,
+		WHOISRaw:    info.RawResponse,
+	})
+	if err != nil {
+		f.logger.Error("Failed to update ASN WHOIS data", "asn", asn, "error", err)
+		f.recordFailure()
+
+		return false
+	}
+
+	f.recordSuccess()
+	f.logger.Info("Updated ASN WHOIS data",
+		"asn", asn,
+		"org_name", info.OrgName,
+		"country", info.CountryCode,
+		"rir", info.RIR,
+		"next_interval", f.getInterval(),
+	)
+
+	return true
+}
+
+// GetStaleThreshold returns the WHOIS stale threshold duration.
+func GetStaleThreshold() time.Duration {
+	return whoisStaleThreshold
+}

internal/routewatch/cli.go

@@ -53,7 +53,11 @@ func logDebugStats(logger *logger.Logger) {
 	}
 }
 
-// CLIEntry is the main entry point for the CLI
+// CLIEntry is the main entry point for the routewatch command-line interface.
+// It initializes the application using the fx dependency injection framework,
+// sets up signal handling for graceful shutdown, and starts the RouteWatch service.
+// This function blocks until the application receives a shutdown signal or encounters
+// a fatal error.
 func CLIEntry() {
 	app := fx.New(
 		getModule(),

internal/routewatch/dbmaintainer.go

@@ -0,0 +1,189 @@
+// Package routewatch contains the database maintainer for background maintenance tasks.
+package routewatch
+
+import (
+	"context"
+	"log/slog"
+	"sync"
+	"time"
+
+	"git.eeqj.de/sneak/routewatch/internal/database"
+)
+
+// Database maintenance configuration constants.
+const (
+	// checkpointInterval is how often to run WAL checkpoint.
+	// Frequent checkpoints keep the WAL small, improving read performance.
+	// Under heavy write load, we need aggressive checkpointing.
+	checkpointInterval = 5 * time.Second
+
+	// vacuumInterval is how often to run incremental vacuum.
+	// Since incremental vacuum only frees ~1000 pages (~4MB) per run,
+	// we run it frequently to keep up with deletions.
+	vacuumInterval = 10 * time.Minute
+
+	// analyzeInterval is how often to run ANALYZE.
+	analyzeInterval = 1 * time.Hour
+
+	// checkpointTimeout is the max time for WAL checkpoint.
+	checkpointTimeout = 10 * time.Second
+
+	// vacuumTimeout is the max time for incremental vacuum (should be quick).
+	vacuumTimeout = 30 * time.Second
+
+	// analyzeTimeout is the max time for ANALYZE.
+	analyzeTimeout = 5 * time.Minute
+)
+
+// DBMaintainer handles background database maintenance tasks.
+type DBMaintainer struct {
+	db     database.Store
+	logger *slog.Logger
+	stopCh chan struct{}
+	wg     sync.WaitGroup
+
+	// Stats tracking
+	statsMu             sync.Mutex
+	lastCheckpoint      time.Time
+	lastVacuum          time.Time
+	lastAnalyze         time.Time
+	checkpointCount     int
+	vacuumCount         int
+	analyzeCount        int
+	lastCheckpointError error
+	lastVacuumError     error
+	lastAnalyzeError    error
+}
+
+// NewDBMaintainer creates a new database maintainer.
+func NewDBMaintainer(db database.Store, logger *slog.Logger) *DBMaintainer {
+	return &DBMaintainer{
+		db:     db,
+		logger: logger.With("component", "db_maintainer"),
+		stopCh: make(chan struct{}),
+	}
+}
+
+// Start begins the background maintenance goroutine.
+func (m *DBMaintainer) Start() {
+	m.wg.Add(1)
+	go m.run()
+	m.logger.Info("Database maintainer started",
+		"checkpoint_interval", checkpointInterval,
+		"vacuum_interval", vacuumInterval,
+		"analyze_interval", analyzeInterval,
+	)
+}
+
+// Stop gracefully shuts down the maintainer.
+func (m *DBMaintainer) Stop() {
+	close(m.stopCh)
+	m.wg.Wait()
+	m.logger.Info("Database maintainer stopped")
+}
+
+// run is the main background loop.
+func (m *DBMaintainer) run() {
+	defer m.wg.Done()
+
+	// Use different timers for each task
+	checkpointTimer := time.NewTimer(checkpointInterval)
+	vacuumTimer := time.NewTimer(vacuumInterval)
+	analyzeTimer := time.NewTimer(analyzeInterval)
+	defer checkpointTimer.Stop()
+	defer vacuumTimer.Stop()
+	defer analyzeTimer.Stop()
+
+	for {
+		select {
+		case <-m.stopCh:
+			return
+
+		case <-checkpointTimer.C:
+			m.runCheckpoint()
+			checkpointTimer.Reset(checkpointInterval)
+
+		case <-vacuumTimer.C:
+			m.runVacuum()
+			vacuumTimer.Reset(vacuumInterval)
+
+		case <-analyzeTimer.C:
+			m.runAnalyze()
+			analyzeTimer.Reset(analyzeInterval)
+		}
+	}
+}
+
+// runCheckpoint performs a WAL checkpoint to keep the WAL file small.
+func (m *DBMaintainer) runCheckpoint() {
+	ctx, cancel := context.WithTimeout(context.Background(), checkpointTimeout)
+	defer cancel()
+
+	startTime := time.Now()
+
+	err := m.db.Checkpoint(ctx)
+
+	m.statsMu.Lock()
+	m.lastCheckpoint = time.Now()
+	m.lastCheckpointError = err
+	if err == nil {
+		m.checkpointCount++
+	}
+	m.statsMu.Unlock()
+
+	if err != nil {
+		m.logger.Error("WAL checkpoint failed", "error", err, "duration", time.Since(startTime))
+	} else {
+		m.logger.Debug("WAL checkpoint completed", "duration", time.Since(startTime))
+	}
+}
+
+// runVacuum performs an incremental vacuum operation on the database.
+func (m *DBMaintainer) runVacuum() {
+	ctx, cancel := context.WithTimeout(context.Background(), vacuumTimeout)
+	defer cancel()
+
+	m.logger.Debug("Running incremental vacuum")
+	startTime := time.Now()
+
+	err := m.db.Vacuum(ctx)
+
+	m.statsMu.Lock()
+	m.lastVacuum = time.Now()
+	m.lastVacuumError = err
+	if err == nil {
+		m.vacuumCount++
+	}
+	m.statsMu.Unlock()
+
+	if err != nil {
+		m.logger.Error("Incremental vacuum failed", "error", err, "duration", time.Since(startTime))
+	} else {
+		m.logger.Debug("Incremental vacuum completed", "duration", time.Since(startTime))
+	}
+}
+
+// runAnalyze performs an ANALYZE operation on the database.
+func (m *DBMaintainer) runAnalyze() {
+	ctx, cancel := context.WithTimeout(context.Background(), analyzeTimeout)
+	defer cancel()
+
+	m.logger.Info("Starting database ANALYZE")
+	startTime := time.Now()
+
+	err := m.db.Analyze(ctx)
+
+	m.statsMu.Lock()
+	m.lastAnalyze = time.Now()
+	m.lastAnalyzeError = err
+	if err == nil {
+		m.analyzeCount++
+	}
+	m.statsMu.Unlock()
+
+	if err != nil {
+		m.logger.Error("ANALYZE failed", "error", err, "duration", time.Since(startTime))
+	} else {
+		m.logger.Info("ANALYZE completed", "duration", time.Since(startTime))
+	}
+}

internal/routewatch/handler.go

@@ -5,14 +5,20 @@ import (
 	"git.eeqj.de/sneak/routewatch/internal/ristypes"
 )
 
-// SimpleHandler is a basic implementation of streamer.MessageHandler
+// SimpleHandler is a basic implementation of streamer.MessageHandler that
+// filters messages by type and delegates processing to a callback function.
+// It provides a simple way to handle specific RIS message types without
+// implementing the full MessageHandler interface from scratch.
 type SimpleHandler struct {
 	logger       *logger.Logger
 	messageTypes []string
 	callback     func(*ristypes.RISMessage)
 }
 
-// NewSimpleHandler creates a handler that accepts specific message types
+// NewSimpleHandler creates a new SimpleHandler that accepts specific message types.
+// The messageTypes parameter specifies which RIS message types this handler will process.
+// If messageTypes is empty, the handler will accept all message types.
+// The callback function is invoked for each message that passes the type filter.
 func NewSimpleHandler(
 	logger *logger.Logger,
 	messageTypes []string,
@@ -25,7 +31,9 @@ func NewSimpleHandler(
 	}
 }
 
-// WantsMessage returns true if this handler wants to process messages of the given type
+// WantsMessage returns true if this handler wants to process messages of the given type.
+// It checks whether messageType is in the handler's configured list of accepted types.
+// If no specific types were configured (empty messageTypes slice), it returns true for all types.
 func (h *SimpleHandler) WantsMessage(messageType string) bool {
 	// If no specific types are set, accept all messages
 	if len(h.messageTypes) == 0 {
@@ -41,7 +49,8 @@ func (h *SimpleHandler) WantsMessage(messageType string) bool {
 	return false
 }
 
-// HandleMessage processes a RIS message
+// HandleMessage processes a RIS message by invoking the configured callback function.
+// If no callback was provided during construction, the message is silently ignored.
 func (h *SimpleHandler) HandleMessage(msg *ristypes.RISMessage) {
 	if h.callback != nil {
 		h.callback(msg)

internal/routewatch/peerhandler.go

@@ -1,5 +1,8 @@
 package routewatch
 
+// peerhandler.go provides batched peer tracking functionality for BGP route monitoring.
+// It tracks BGP peers from all incoming RIS messages and maintains peer state in the database.
+
 import (
 	"strconv"
 	"sync"
@@ -21,7 +24,10 @@ const (
 	peerBatchTimeout = 2 * time.Second
 )
 
-// PeerHandler tracks BGP peers from all message types using batched operations
+// PeerHandler tracks BGP peers from all message types using batched operations.
+// It maintains a queue of peer updates and periodically flushes them to the database
+// in batches to improve performance. The handler deduplicates peer updates within
+// each batch, keeping only the most recent update for each peer IP address.
 type PeerHandler struct {
 	db     database.Store
 	logger *logger.Logger
@@ -41,7 +47,10 @@ type peerUpdate struct {
 	timestamp   time.Time
 }
 
-// NewPeerHandler creates a new batched peer tracking handler
+// NewPeerHandler creates a new PeerHandler with the given database store and logger.
+// It initializes the peer batch buffer and starts a background goroutine that
+// periodically flushes accumulated peer updates to the database. The handler
+// should be stopped by calling Stop when it is no longer needed.
 func NewPeerHandler(db database.Store, logger *logger.Logger) *PeerHandler {
 	h := &PeerHandler{
 		db:        db,
@@ -58,18 +67,25 @@ func NewPeerHandler(db database.Store, logger *logger.Logger) *PeerHandler {
 	return h
 }
 
-// WantsMessage returns true for all message types since we track peers from all messages
+// WantsMessage returns true for all message types since peer information
+// is extracted from every RIS message regardless of type. This satisfies
+// the MessageHandler interface.
 func (h *PeerHandler) WantsMessage(_ string) bool {
 	return true
 }
 
-// QueueCapacity returns the desired queue capacity for this handler
+// QueueCapacity returns the desired queue capacity for this handler.
+// The PeerHandler uses a large queue capacity because batching allows
+// for efficient processing of many updates at once.
 func (h *PeerHandler) QueueCapacity() int {
 	// Batching allows us to use a larger queue
 	return peerHandlerQueueSize
 }
 
-// HandleMessage processes a message to track peer information
+// HandleMessage processes a RIS message to track peer information.
+// It extracts the peer IP address and ASN from the message and adds
+// the update to an internal batch. When the batch reaches peerBatchSize
+// or the batch timeout expires, the batch is flushed to the database.
 func (h *PeerHandler) HandleMessage(msg *ristypes.RISMessage) {
 	// Parse peer ASN from string
 	peerASN := 0

internal/routewatch/peeringhandler.go

@@ -11,23 +11,36 @@ import (
 )
 
 const (
-	// peeringHandlerQueueSize is the queue capacity for peering operations
+	// peeringHandlerQueueSize defines the buffer capacity for the peering
+	// handler's message queue. This should be large enough to handle bursts
+	// of BGP UPDATE messages without blocking.
 	peeringHandlerQueueSize = 100000
 
-	// minPathLengthForPeering is the minimum AS path length to extract peerings
+	// minPathLengthForPeering specifies the minimum number of ASNs required
+	// in a BGP AS path to extract peering relationships. A path with fewer
+	// than 2 ASNs cannot contain any peering information.
 	minPathLengthForPeering = 2
 
-	// pathExpirationTime is how long to keep AS paths in memory
+	// pathExpirationTime determines how long AS paths are kept in memory
+	// before being eligible for pruning. Paths older than this are removed
+	// to prevent unbounded memory growth.
 	pathExpirationTime = 30 * time.Minute
 
-	// peeringProcessInterval is how often to process AS paths into peerings
-	peeringProcessInterval = 2 * time.Minute
+	// peeringProcessInterval controls how frequently the handler processes
+	// accumulated AS paths and extracts peering relationships to store
+	// in the database.
+	peeringProcessInterval = 30 * time.Second
 
-	// pathPruneInterval is how often to prune old AS paths
+	// pathPruneInterval determines how often the handler checks for and
+	// removes expired AS paths from memory.
 	pathPruneInterval = 5 * time.Minute
 )
 
-// PeeringHandler handles AS peering relationships from BGP path data
+// PeeringHandler processes BGP UPDATE messages to extract and track
+// AS peering relationships. It accumulates AS paths in memory and
+// periodically processes them to extract unique peering pairs, which
+// are then stored in the database. The handler implements the Handler
+// interface for integration with the message processing pipeline.
 type PeeringHandler struct {
 	db     database.Store
 	logger *logger.Logger
@@ -39,7 +52,11 @@ type PeeringHandler struct {
 	stopCh chan struct{}
 }
 
-// NewPeeringHandler creates a new batched peering handler
+// NewPeeringHandler creates and initializes a new PeeringHandler with the
+// provided database store and logger. It starts two background goroutines:
+// one for periodic processing of accumulated AS paths into peering records,
+// and one for pruning expired paths from memory. The handler begins
+// processing immediately upon creation.
 func NewPeeringHandler(db database.Store, logger *logger.Logger) *PeeringHandler {
 	h := &PeeringHandler{
 		db:      db,
@@ -55,18 +72,25 @@ func NewPeeringHandler(db database.Store, logger *logger.Logger) *PeeringHandler
 	return h
 }
 
-// WantsMessage returns true if this handler wants to process messages of the given type
+// WantsMessage reports whether the handler should receive messages of the
+// given type. PeeringHandler only processes UPDATE messages, as these contain
+// the AS path information needed to extract peering relationships.
 func (h *PeeringHandler) WantsMessage(messageType string) bool {
 	// We only care about UPDATE messages that have AS paths
 	return messageType == "UPDATE"
 }
 
-// QueueCapacity returns the desired queue capacity for this handler
+// QueueCapacity returns the buffer size for the handler's message queue.
+// This value is used by the message dispatcher to allocate the channel
+// buffer when registering the handler.
 func (h *PeeringHandler) QueueCapacity() int {
 	return peeringHandlerQueueSize
 }
 
-// HandleMessage processes a message to extract AS paths
+// HandleMessage processes a BGP UPDATE message by storing its AS path
+// in memory for later batch processing. Messages with AS paths shorter
+// than minPathLengthForPeering are ignored as they cannot contain valid
+// peering information.
 func (h *PeeringHandler) HandleMessage(msg *ristypes.RISMessage) {
 	// Skip if no AS path or only one AS
 	if len(msg.Path) < minPathLengthForPeering {
@@ -141,7 +165,9 @@ func (h *PeeringHandler) prunePaths() {
 	}
 }
 
-// ProcessPeeringsNow forces immediate processing of peerings (for testing)
+// ProcessPeeringsNow triggers immediate processing of all accumulated AS
+// paths into peering records. This bypasses the normal periodic processing
+// schedule and is primarily intended for testing purposes.
 func (h *PeeringHandler) ProcessPeeringsNow() {
 	h.processPeerings()
 }
@@ -222,7 +248,10 @@ func (h *PeeringHandler) processPeerings() {
 	)
 }
 
-// Stop gracefully stops the handler and processes remaining peerings
+// Stop gracefully shuts down the handler by signaling the background
+// goroutines to stop and performing a final synchronous processing of
+// any remaining AS paths. This ensures no peering data is lost during
+// shutdown.
 func (h *PeeringHandler) Stop() {
 	close(h.stopCh)
 	// Process any remaining peerings synchronously

internal/routewatch/prefixhandler.go

@@ -15,12 +15,14 @@ import (
 
 const (
 	// prefixHandlerQueueSize is the queue capacity for prefix tracking operations
+	// DO NOT set this higher than 100000 without explicit instructions
 	prefixHandlerQueueSize = 100000
 
 	// prefixBatchSize is the number of prefix updates to batch together
-	prefixBatchSize = 5000
+	prefixBatchSize = 25000
 
 	// prefixBatchTimeout is the maximum time to wait before flushing a batch
+	// DO NOT reduce this timeout - larger batches are more efficient
 	prefixBatchTimeout = 1 * time.Second
 
 	// IP version constants
@@ -111,6 +113,10 @@ func (h *PrefixHandler) HandleMessage(msg *ristypes.RISMessage) {
 				timestamp:   timestamp,
 				path:        msg.Path,
 			})
+			// Record announcement in metrics
+			if h.metrics != nil {
+				h.metrics.RecordAnnouncement()
+			}
 		}
 	}
 
@@ -124,6 +130,10 @@ func (h *PrefixHandler) HandleMessage(msg *ristypes.RISMessage) {
 			timestamp:   timestamp,
 			path:        msg.Path,
 		})
+		// Record withdrawal in metrics
+		if h.metrics != nil {
+			h.metrics.RecordWithdrawal()
+		}
 	}
 
 	// Check if we need to flush
@@ -180,9 +190,15 @@ func (h *PrefixHandler) flushBatchLocked() {
 	var routesToUpsert []*database.LiveRoute
 	var routesToDelete []database.LiveRouteDeletion
 
-	// Skip the prefix table updates entirely - just update live_routes
-	// The prefix table is not critical for routing lookups
+	// Collect unique prefixes to update
+	prefixesToUpdate := make(map[string]time.Time)
+
 	for _, update := range prefixMap {
+		// Track prefix for both announcements and withdrawals
+		if _, exists := prefixesToUpdate[update.prefix]; !exists || update.timestamp.After(prefixesToUpdate[update.prefix]) {
+			prefixesToUpdate[update.prefix] = update.timestamp
+		}
+
 		if update.messageType == "announcement" && update.originASN > 0 {
 			// Create live route for batch upsert
 			route := h.createLiveRoute(update)
@@ -190,11 +206,20 @@ func (h *PrefixHandler) flushBatchLocked() {
 				routesToUpsert = append(routesToUpsert, route)
 			}
 		} else if update.messageType == "withdrawal" {
+			// Parse CIDR to get IP version
+			_, ipVersion, err := parseCIDR(update.prefix)
+			if err != nil {
+				h.logger.Error("Failed to parse CIDR for withdrawal", "prefix", update.prefix, "error", err)
+
+				continue
+			}
+
 			// Create deletion record for batch delete
 			routesToDelete = append(routesToDelete, database.LiveRouteDeletion{
 				Prefix:    update.prefix,
 				OriginASN: update.originASN,
 				PeerIP:    update.peer,
+				IPVersion: ipVersion,
 			})
 		}
 	}
@@ -217,6 +242,13 @@ func (h *PrefixHandler) flushBatchLocked() {
 		}
 	}
 
+	// Update prefix tables
+	if len(prefixesToUpdate) > 0 {
+		if err := h.db.UpdatePrefixesBatch(prefixesToUpdate); err != nil {
+			h.logger.Error("Failed to update prefix batch", "error", err, "count", len(prefixesToUpdate))
+		}
+	}
+
 	elapsed := time.Since(startTime)
 	h.logger.Debug("Flushed prefix batch",
 		"batch_size", batchSize,

internal/server/middleware.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"log/slog"
 	"net/http"
 	"sync"
 	"time"
@@ -44,7 +45,12 @@ func (rw *responseWriter) Header() http.Header {
 	return rw.ResponseWriter.Header()
 }
 
-// JSONResponseMiddleware wraps all JSON responses with metadata
+// JSONResponseMiddleware is an HTTP middleware that wraps all JSON responses
+// with a @meta field containing execution metadata. The metadata includes the
+// time zone (always UTC), API version, and request execution time in milliseconds.
+//
+// Endpoints "/" and "/status" are excluded from this processing and passed through
+// unchanged. Non-JSON responses and empty responses are also passed through unchanged.
 func JSONResponseMiddleware(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		// Skip non-JSON endpoints
@@ -108,6 +114,7 @@ type timeoutWriter struct {
 	http.ResponseWriter
 	mu      sync.Mutex
 	written bool
+	header  http.Header // cached header to prevent concurrent access
 }
 
 func (tw *timeoutWriter) Write(b []byte) (int, error) {
@@ -133,6 +140,18 @@ func (tw *timeoutWriter) WriteHeader(statusCode int) {
 }
 
 func (tw *timeoutWriter) Header() http.Header {
+	tw.mu.Lock()
+	defer tw.mu.Unlock()
+
+	if tw.written {
+		// Return a copy to prevent modifications after timeout
+		if tw.header == nil {
+			tw.header = make(http.Header)
+		}
+
+		return tw.header
+	}
+
 	return tw.ResponseWriter.Header()
 }
 
@@ -142,8 +161,14 @@ func (tw *timeoutWriter) markWritten() {
 	tw.written = true
 }
 
-// TimeoutMiddleware creates a timeout middleware that returns JSON errors
-func TimeoutMiddleware(timeout time.Duration) func(http.Handler) http.Handler {
+// TimeoutMiddleware creates an HTTP middleware that enforces a request timeout.
+// If the handler does not complete within the specified duration, the middleware
+// returns a JSON error response with HTTP status 408 (Request Timeout).
+//
+// The timeout parameter specifies the maximum duration allowed for request processing.
+// The returned middleware handles panics from the wrapped handler by re-panicking
+// after cleanup, and prevents concurrent writes to the response after timeout occurs.
+func TimeoutMiddleware(timeout time.Duration, logger *slog.Logger) func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			startTime := time.Now()
@@ -153,6 +178,7 @@ func TimeoutMiddleware(timeout time.Duration) func(http.Handler) http.Handler {
 
 			tw := &timeoutWriter{
 				ResponseWriter: w,
+				header:         make(http.Header),
 			}
 
 			done := make(chan struct{})
@@ -178,8 +204,20 @@ func TimeoutMiddleware(timeout time.Duration) func(http.Handler) http.Handler {
 				tw.markWritten() // Prevent the handler from writing after timeout
 				execTime := time.Since(startTime)
 
+				// Log the timeout as a warning
+				logger.Warn("Request timeout",
+					"method", r.Method,
+					"path", r.URL.Path,
+					"duration_ms", execTime.Milliseconds(),
+					"remote_addr", r.RemoteAddr,
+				)
+
+				// Write directly to the underlying writer since we've marked tw as written
+				// This is safe because markWritten() prevents the handler from writing
+				tw.mu.Lock()
 				w.Header().Set("Content-Type", "application/json")
 				w.WriteHeader(http.StatusRequestTimeout)
+				tw.mu.Unlock()
 
 				response := map[string]interface{}{
 					"status": "error",
@@ -199,3 +237,147 @@ func TimeoutMiddleware(timeout time.Duration) func(http.Handler) http.Handler {
 		})
 	}
 }
+
+// JSONValidationMiddleware is an HTTP middleware that validates JSON API responses.
+// It ensures that responses with Content-Type "application/json" contain valid JSON.
+//
+// If a response is not valid JSON or is empty when JSON is expected, the middleware
+// returns a properly formatted JSON error response. For timeout errors (status 408),
+// the error message will be "Request timeout". For other errors, it returns
+// "Internal server error" with status 500 if the original status was 200.
+//
+// Non-JSON responses are passed through unchanged.
+func JSONValidationMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Create a custom response writer to capture the response
+		rw := &responseWriter{
+			ResponseWriter: w,
+			body:           &bytes.Buffer{},
+			statusCode:     http.StatusOK,
+		}
+
+		// Serve the request
+		next.ServeHTTP(rw, r)
+
+		// Check if it's meant to be a JSON response
+		contentType := rw.Header().Get("Content-Type")
+		isJSON := contentType == "application/json" || contentType == ""
+
+		// If it's not JSON or has content, pass through
+		if !isJSON && rw.body.Len() > 0 {
+			w.WriteHeader(rw.statusCode)
+			_, _ = w.Write(rw.body.Bytes())
+
+			return
+		}
+
+		// For JSON responses, validate the JSON
+		if rw.body.Len() > 0 {
+			var testParse interface{}
+			if err := json.Unmarshal(rw.body.Bytes(), &testParse); err == nil {
+				// Valid JSON, write it out
+				w.Header().Set("Content-Type", "application/json")
+				w.WriteHeader(rw.statusCode)
+				_, _ = w.Write(rw.body.Bytes())
+
+				return
+			}
+		}
+
+		// If we get here, either there's no body or invalid JSON
+		// Write a proper error response
+		w.Header().Set("Content-Type", "application/json")
+
+		// Determine appropriate status code
+		statusCode := rw.statusCode
+		if statusCode == http.StatusOK {
+			statusCode = http.StatusInternalServerError
+		}
+		w.WriteHeader(statusCode)
+
+		errorMsg := "Internal server error"
+		if statusCode == http.StatusRequestTimeout {
+			errorMsg = "Request timeout"
+		}
+
+		response := map[string]interface{}{
+			"status": "error",
+			"error": map[string]interface{}{
+				"msg":  errorMsg,
+				"code": statusCode,
+			},
+		}
+		_ = json.NewEncoder(w).Encode(response)
+	})
+}
+
+// statusWriter wraps http.ResponseWriter to capture the status code
+type statusWriter struct {
+	http.ResponseWriter
+	statusCode int
+	written    bool
+}
+
+func (sw *statusWriter) WriteHeader(statusCode int) {
+	if !sw.written {
+		sw.statusCode = statusCode
+		sw.written = true
+	}
+	sw.ResponseWriter.WriteHeader(statusCode)
+}
+
+func (sw *statusWriter) Write(b []byte) (int, error) {
+	if !sw.written {
+		sw.statusCode = http.StatusOK
+		sw.written = true
+	}
+
+	return sw.ResponseWriter.Write(b)
+}
+
+// RequestLoggerMiddleware creates a structured logging middleware using slog.
+func RequestLoggerMiddleware(logger *slog.Logger) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			start := time.Now()
+
+			// Wrap response writer to capture status
+			sw := &statusWriter{ResponseWriter: w, statusCode: http.StatusOK}
+
+			// Log request start
+			logger.Debug("HTTP request started",
+				"method", r.Method,
+				"path", r.URL.Path,
+				"remote_addr", r.RemoteAddr,
+				"user_agent", r.UserAgent(),
+			)
+
+			// Serve the request
+			next.ServeHTTP(sw, r)
+
+			// Log request completion
+			duration := time.Since(start)
+			logLevel := slog.LevelInfo
+
+			// Slow query threshold (1 second)
+			const slowQueryThreshold = 1 * time.Second
+
+			if sw.statusCode >= http.StatusInternalServerError {
+				logLevel = slog.LevelError
+			} else if sw.statusCode >= http.StatusBadRequest {
+				logLevel = slog.LevelWarn
+			} else if duration >= slowQueryThreshold {
+				logLevel = slog.LevelWarn
+			}
+
+			logger.Log(r.Context(), logLevel, "HTTP request completed",
+				"method", r.Method,
+				"path", r.URL.Path,
+				"status", sw.statusCode,
+				"duration_ms", duration.Milliseconds(),
+				"remote_addr", r.RemoteAddr,
+				"slow", duration >= slowQueryThreshold,
+			)
+		})
+	}
+}

internal/server/routes.go

@@ -14,28 +14,38 @@ func (s *Server) setupRoutes() {
 	// Middleware
 	r.Use(middleware.RequestID)
 	r.Use(middleware.RealIP)
-	r.Use(middleware.Logger)
+	r.Use(RequestLoggerMiddleware(s.logger.Logger)) // Structured request logging
 	r.Use(middleware.Recoverer)
-	const requestTimeout = 2 * time.Second
-	r.Use(TimeoutMiddleware(requestTimeout))
+	const requestTimeout = 30 * time.Second // Increased from 8s for slow queries
+	r.Use(TimeoutMiddleware(requestTimeout, s.logger.Logger))
 	r.Use(JSONResponseMiddleware)
 
 	// Routes
-	r.Get("/", s.handleRoot())
+	r.Get("/", s.handleIndex())
 	r.Get("/status", s.handleStatusHTML())
-	r.Get("/status.json", s.handleStatusJSON())
+	r.Get("/status.json", JSONValidationMiddleware(s.handleStatusJSON()).ServeHTTP)
+	r.Get("/.well-known/healthcheck.json", JSONValidationMiddleware(s.handleHealthCheck()).ServeHTTP)
 
 	// AS and prefix detail pages
 	r.Get("/as/{asn}", s.handleASDetail())
-	r.Get("/prefix/{prefix}", s.handlePrefixDetail())
-	r.Get("/ip/{ip}", s.handleIPRedirect())
+	r.Get("/prefix/{prefix}/{len}", s.handlePrefixDetail())
+	r.Get("/prefixlength/{length}", s.handlePrefixLength())
+	r.Get("/prefixlength6/{length}", s.handlePrefixLength6())
+
+	// IP info JSON endpoints (replaces old /ip redirect)
+	r.Route("/ip", func(r chi.Router) {
+		r.Use(JSONValidationMiddleware)
+		r.Get("/", s.handleIPInfo())       // Client IP
+		r.Get("/{addr}", s.handleIPInfo()) // Specified IP
+	})
 
 	// API routes
 	r.Route("/api/v1", func(r chi.Router) {
+		r.Use(JSONValidationMiddleware)
 		r.Get("/stats", s.handleStats())
 		r.Get("/ip/{ip}", s.handleIPLookup())
 		r.Get("/as/{asn}", s.handleASDetailJSON())
-		r.Get("/prefix/{prefix}", s.handlePrefixDetailJSON())
+		r.Get("/prefix/{prefix}/{len}", s.handlePrefixDetailJSON())
 	})
 
 	s.router = r

internal/server/server.go

@@ -13,13 +13,28 @@ import (
 	"github.com/go-chi/chi/v5"
 )
 
+// ASNFetcherStats contains WHOIS fetcher statistics.
+type ASNFetcherStats struct {
+	SuccessesLastHour int
+	ErrorsLastHour    int
+	CurrentInterval   time.Duration
+	ConsecutiveFails  int
+}
+
+// ASNFetcher is an interface for queuing ASN WHOIS lookups.
+type ASNFetcher interface {
+	QueueImmediate(asn int)
+	GetStats() ASNFetcherStats
+}
+
 // Server provides HTTP endpoints for status monitoring
 type Server struct {
-	router   *chi.Mux
-	db       database.Store
-	streamer *streamer.Streamer
-	logger   *logger.Logger
-	srv      *http.Server
+	router     *chi.Mux
+	db         database.Store
+	streamer   *streamer.Streamer
+	logger     *logger.Logger
+	srv        *http.Server
+	asnFetcher ASNFetcher
 }
 
 // New creates a new HTTP server
@@ -42,16 +57,27 @@ func (s *Server) Start() error {
 		port = "8080"
 	}
 
-	const readHeaderTimeout = 10 * time.Second
+	const (
+		readHeaderTimeout = 40 * time.Second
+		readTimeout       = 60 * time.Second
+		writeTimeout      = 60 * time.Second
+		idleTimeout       = 120 * time.Second
+	)
+
 	s.srv = &http.Server{
 		Addr:              ":" + port,
 		Handler:           s.router,
 		ReadHeaderTimeout: readHeaderTimeout,
+		ReadTimeout:       readTimeout,
+		WriteTimeout:      writeTimeout,
+		IdleTimeout:       idleTimeout,
 	}
 
-	s.logger.Info("Starting HTTP server", "port", port)
+	s.logger.Info("Starting HTTP server", "port", port, "addr", s.srv.Addr)
 
+	// Start in goroutine but log when actually listening
 	go func() {
+		s.logger.Info("HTTP server listening", "addr", s.srv.Addr)
 		if err := s.srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 			s.logger.Error("HTTP server error", "error", err)
 		}
@@ -70,3 +96,8 @@ func (s *Server) Stop(ctx context.Context) error {
 
 	return s.srv.Shutdown(ctx)
 }
+
+// SetASNFetcher sets the ASN WHOIS fetcher for on-demand lookups.
+func (s *Server) SetASNFetcher(fetcher ASNFetcher) {
+	s.asnFetcher = fetcher
+}

internal/streamer/streamer.go

@@ -4,11 +4,14 @@ package streamer
 
 import (
 	"bufio"
+	"compress/gzip"
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
+	"math"
+	"math/rand"
 	"net/http"
-	"os"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -18,40 +21,75 @@ import (
 	"git.eeqj.de/sneak/routewatch/internal/ristypes"
 )
 
+// countingReader wraps an io.Reader and counts bytes read
+type countingReader struct {
+	reader io.Reader
+	count  int64
+}
+
+// Read implements io.Reader and counts bytes
+func (c *countingReader) Read(p []byte) (int, error) {
+	n, err := c.reader.Read(p)
+	atomic.AddInt64(&c.count, int64(n))
+
+	return n, err
+}
+
+// Count returns the total bytes read
+func (c *countingReader) Count() int64 {
+	return atomic.LoadInt64(&c.count)
+}
+
+// Configuration constants for the RIS Live streamer.
 const (
-	risLiveURL            = "https://ris-live.ripe.net/v1/stream/?format=json"
+	risLiveURL = "https://ris-live.ripe.net/v1/stream/?format=json&" +
+		"client=https%3A%2F%2Fgit.eeqj.de%2Fsneak%2Froutewatch"
 	metricsWindowSize     = 60 // seconds for rolling average
 	metricsUpdateRate     = time.Second
+	minBackoffDelay       = 5 * time.Second
+	maxBackoffDelay       = 320 * time.Second
 	metricsLogInterval    = 10 * time.Second
 	bytesPerKB            = 1024
 	bytesPerMB            = 1024 * 1024
 	maxConcurrentHandlers = 800 // Maximum number of concurrent message handlers
+
+	// Backpressure constants
+	backpressureThreshold = 0.5 // Start dropping at 50% queue utilization
+	backpressureSlope     = 2.0 // Slope for linear drop probability increase
 )
 
-// MessageHandler is an interface for handling RIS messages
+// MessageHandler defines the interface for processing RIS messages.
+// Implementations must specify which message types they want to receive,
+// how to process messages, and their desired queue capacity.
 type MessageHandler interface {
-	// WantsMessage returns true if this handler wants to process messages of the given type
+	// WantsMessage returns true if this handler wants to process messages of the given type.
 	WantsMessage(messageType string) bool
 
-	// HandleMessage processes a RIS message
+	// HandleMessage processes a RIS message. This method is called from a dedicated
+	// goroutine for each handler, so implementations do not need to be goroutine-safe
+	// with respect to other handlers.
 	HandleMessage(msg *ristypes.RISMessage)
 
-	// QueueCapacity returns the desired queue capacity for this handler
-	// Handlers that process quickly can have larger queues
+	// QueueCapacity returns the desired queue capacity for this handler.
+	// Handlers that process quickly can have larger queues to buffer bursts.
+	// When the queue fills up, messages will be dropped according to the
+	// backpressure algorithm.
 	QueueCapacity() int
 }
 
-// RawMessageHandler is a callback for handling raw JSON lines from the stream
+// RawMessageHandler is a function type for processing raw JSON lines from the stream.
+// It receives the unmodified JSON line as a string before any parsing occurs.
 type RawMessageHandler func(line string)
 
 // handlerMetrics tracks performance metrics for a handler
 type handlerMetrics struct {
-	processedCount uint64        // Total messages processed
-	droppedCount   uint64        // Total messages dropped
-	totalTime      time.Duration // Total processing time (for average calculation)
-	minTime        time.Duration // Minimum processing time
-	maxTime        time.Duration // Maximum processing time
-	mu             sync.Mutex    // Protects the metrics
+	processedCount     uint64        // Total messages processed
+	droppedCount       uint64        // Total messages dropped
+	totalTime          time.Duration // Total processing time (for average calculation)
+	minTime            time.Duration // Minimum processing time
+	maxTime            time.Duration // Maximum processing time
+	queueHighWaterMark int           // Maximum queue length seen
+	mu                 sync.Mutex    // Protects the metrics
 }
 
 // handlerInfo wraps a handler with its queue and metrics
@@ -61,7 +99,10 @@ type handlerInfo struct {
 	metrics handlerMetrics
 }
 
-// Streamer handles streaming BGP updates from RIS Live
+// Streamer manages a connection to the RIPE RIS Live streaming API for receiving
+// real-time BGP UPDATE messages. It handles automatic reconnection with exponential
+// backoff, dispatches messages to registered handlers via per-handler queues, and
+// implements backpressure to prevent queue overflow during high traffic periods.
 type Streamer struct {
 	logger       *logger.Logger
 	client       *http.Client
@@ -71,22 +112,36 @@ type Streamer struct {
 	cancel       context.CancelFunc
 	running      bool
 	metrics      *metrics.Tracker
-	totalDropped uint64 // Total dropped messages across all handlers
+	totalDropped uint64          // Total dropped messages across all handlers
+	random       *rand.Rand      // Random number generator for backpressure drops
+	bgpPeers     map[string]bool // Track active BGP peers by peer IP
+	bgpPeersMu   sync.RWMutex    // Protects bgpPeers map
 }
 
-// New creates a new RIS streamer
+// New creates a new Streamer instance configured to connect to the RIS Live API.
+// The logger is used for structured logging of connection events and errors.
+// The metrics tracker is used to record message counts, bytes received, and connection status.
 func New(logger *logger.Logger, metrics *metrics.Tracker) *Streamer {
 	return &Streamer{
 		logger: logger,
 		client: &http.Client{
 			Timeout: 0, // No timeout for streaming
+			Transport: &http.Transport{
+				// Disable automatic gzip decompression so we can measure wire bytes
+				DisableCompression: true,
+			},
 		},
 		handlers: make([]*handlerInfo, 0),
 		metrics:  metrics,
+		//nolint:gosec // Non-cryptographic randomness is fine for backpressure
+		random:   rand.New(rand.NewSource(time.Now().UnixNano())),
+		bgpPeers: make(map[string]bool),
 	}
 }
 
-// RegisterHandler adds a callback for message processing
+// RegisterHandler adds a MessageHandler to receive parsed RIS messages.
+// Each handler gets its own dedicated queue and worker goroutine for processing.
+// If the streamer is already running, the handler's worker is started immediately.
 func (s *Streamer) RegisterHandler(handler MessageHandler) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -95,6 +150,9 @@ func (s *Streamer) RegisterHandler(handler MessageHandler) {
 	info := &handlerInfo{
 		handler: handler,
 		queue:   make(chan *ristypes.RISMessage, handler.QueueCapacity()),
+		metrics: handlerMetrics{
+			minTime: time.Duration(math.MaxInt64), // Initialize to max so first value sets the floor
+		},
 	}
 
 	s.handlers = append(s.handlers, info)
@@ -105,14 +163,19 @@ func (s *Streamer) RegisterHandler(handler MessageHandler) {
 	}
 }
 
-// RegisterRawHandler sets a callback for raw message lines
+// RegisterRawHandler sets a callback to receive raw JSON lines from the stream
+// before they are parsed. Only one raw handler can be registered at a time;
+// subsequent calls will replace the previous handler.
 func (s *Streamer) RegisterRawHandler(handler RawMessageHandler) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	s.rawHandler = handler
 }
 
-// Start begins streaming in a goroutine
+// Start begins streaming BGP updates from the RIS Live API in a background goroutine.
+// It starts worker goroutines for each registered handler and manages automatic
+// reconnection with exponential backoff on connection failures.
+// Returns an error if the streamer is already running.
 func (s *Streamer) Start() error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -131,9 +194,7 @@ func (s *Streamer) Start() error {
 	}
 
 	go func() {
-		if err := s.stream(ctx); err != nil {
-			s.logger.Error("Streaming error", "error", err)
-		}
+		s.streamWithReconnect(ctx)
 		s.mu.Lock()
 		s.running = false
 		s.mu.Unlock()
@@ -142,7 +203,9 @@ func (s *Streamer) Start() error {
 	return nil
 }
 
-// Stop halts the streaming
+// Stop halts the streaming connection and shuts down all handler workers.
+// It cancels the streaming context, closes all handler queues, and updates
+// the connection status in metrics. This method is safe to call multiple times.
 func (s *Streamer) Stop() {
 	s.mu.Lock()
 	if s.cancel != nil {
@@ -170,7 +233,7 @@ func (s *Streamer) runHandlerWorker(info *handlerInfo) {
 		info.metrics.totalTime += elapsed
 
 		// Update min time
-		if info.metrics.minTime == 0 || elapsed < info.metrics.minTime {
+		if elapsed < info.metrics.minTime {
 			info.metrics.minTime = elapsed
 		}
 
@@ -182,7 +245,8 @@ func (s *Streamer) runHandlerWorker(info *handlerInfo) {
 	}
 }
 
-// IsRunning returns whether the streamer is currently active
+// IsRunning reports whether the streamer is currently connected and processing messages.
+// This is safe to call concurrently from multiple goroutines.
 func (s *Streamer) IsRunning() bool {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
@@ -190,29 +254,36 @@ func (s *Streamer) IsRunning() bool {
 	return s.running
 }
 
-// GetMetrics returns current streaming metrics
+// GetMetrics returns the current streaming metrics including message counts,
+// bytes received, and throughput rates. The returned struct is a snapshot
+// of the current state and is safe to use without synchronization.
 func (s *Streamer) GetMetrics() metrics.StreamMetrics {
 	return s.metrics.GetStreamMetrics()
 }
 
-// GetMetricsTracker returns the metrics tracker instance
+// GetMetricsTracker returns the underlying metrics.Tracker instance for direct access
+// to metrics recording and retrieval functionality.
 func (s *Streamer) GetMetricsTracker() *metrics.Tracker {
 	return s.metrics
 }
 
-// HandlerStats represents metrics for a single handler
+// HandlerStats contains performance metrics for a single message handler.
+// It includes queue utilization, message counts, and processing time statistics.
 type HandlerStats struct {
-	Name           string
-	QueueLength    int
-	QueueCapacity  int
-	ProcessedCount uint64
-	DroppedCount   uint64
-	AvgProcessTime time.Duration
-	MinProcessTime time.Duration
-	MaxProcessTime time.Duration
+	Name               string
+	QueueLength        int
+	QueueCapacity      int
+	QueueHighWaterMark int
+	ProcessedCount     uint64
+	DroppedCount       uint64
+	AvgProcessTime     time.Duration
+	MinProcessTime     time.Duration
+	MaxProcessTime     time.Duration
 }
 
-// GetHandlerStats returns current handler statistics
+// GetHandlerStats returns a snapshot of performance statistics for all registered
+// handlers. The returned slice contains one HandlerStats entry per handler with
+// current queue depth, processed/dropped counts, and processing time statistics.
 func (s *Streamer) GetHandlerStats() []HandlerStats {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
@@ -223,13 +294,14 @@ func (s *Streamer) GetHandlerStats() []HandlerStats {
 		info.metrics.mu.Lock()
 
 		hs := HandlerStats{
-			Name:           fmt.Sprintf("%T", info.handler),
-			QueueLength:    len(info.queue),
-			QueueCapacity:  cap(info.queue),
-			ProcessedCount: info.metrics.processedCount,
-			DroppedCount:   info.metrics.droppedCount,
-			MinProcessTime: info.metrics.minTime,
-			MaxProcessTime: info.metrics.maxTime,
+			Name:               fmt.Sprintf("%T", info.handler),
+			QueueLength:        len(info.queue),
+			QueueCapacity:      cap(info.queue),
+			QueueHighWaterMark: info.metrics.queueHighWaterMark,
+			ProcessedCount:     info.metrics.processedCount,
+			DroppedCount:       info.metrics.droppedCount,
+			MinProcessTime:     info.metrics.minTime,
+			MaxProcessTime:     info.metrics.maxTime,
 		}
 
 		// Calculate average time
@@ -251,7 +323,9 @@ func (s *Streamer) GetHandlerStats() []HandlerStats {
 	return stats
 }
 
-// GetDroppedMessages returns the total number of dropped messages
+// GetDroppedMessages returns the total number of messages dropped across all handlers
+// due to queue overflow or backpressure. This counter is monotonically increasing
+// and is safe to call concurrently.
 func (s *Streamer) GetDroppedMessages() uint64 {
 	return atomic.LoadUint64(&s.totalDropped)
 }
@@ -270,16 +344,18 @@ func (s *Streamer) logMetrics() {
 		uptime,
 		"total_messages",
 		metrics.TotalMessages,
-		"total_bytes",
+		"wire_bytes",
+		metrics.TotalWireBytes,
+		"wire_mb",
+		fmt.Sprintf("%.2f", float64(metrics.TotalWireBytes)/bytesPerMB),
+		"wire_mbps",
+		fmt.Sprintf("%.2f", metrics.WireBitsPerSec/bitsPerMegabit),
+		"decompressed_bytes",
 		metrics.TotalBytes,
-		"total_mb",
+		"decompressed_mb",
 		fmt.Sprintf("%.2f", float64(metrics.TotalBytes)/bytesPerMB),
 		"messages_per_sec",
 		fmt.Sprintf("%.2f", metrics.MessagesPerSec),
-		"bits_per_sec",
-		fmt.Sprintf("%.0f", metrics.BitsPerSec),
-		"mbps",
-		fmt.Sprintf("%.2f", metrics.BitsPerSec/bitsPerMegabit),
 		"total_dropped",
 		totalDropped,
 	)
@@ -320,12 +396,81 @@ func (s *Streamer) updateMetrics(messageBytes int) {
 	s.metrics.RecordMessage(int64(messageBytes))
 }
 
+// streamWithReconnect handles streaming with automatic reconnection and exponential backoff
+func (s *Streamer) streamWithReconnect(ctx context.Context) {
+	backoffDelay := minBackoffDelay
+	consecutiveFailures := 0
+
+	for {
+		select {
+		case <-ctx.Done():
+			s.logger.Info("Stream context cancelled, stopping reconnection attempts")
+
+			return
+		default:
+		}
+
+		// Attempt to stream
+		startTime := time.Now()
+		err := s.stream(ctx)
+		streamDuration := time.Since(startTime)
+
+		if err == nil {
+			// Clean exit (context cancelled)
+			return
+		}
+
+		// Log the error
+		s.logger.Error("Stream disconnected",
+			"error", err,
+			"consecutive_failures", consecutiveFailures+1,
+			"stream_duration", streamDuration)
+		s.metrics.SetConnected(false)
+
+		// Check if context is cancelled
+		if ctx.Err() != nil {
+			return
+		}
+
+		// If we streamed for more than 30 seconds, reset the backoff
+		// This indicates we had a successful connection that received data
+		if streamDuration > 30*time.Second {
+			s.logger.Info("Resetting backoff delay due to successful connection",
+				"stream_duration", streamDuration)
+			backoffDelay = minBackoffDelay
+			consecutiveFailures = 0
+		} else {
+			// Increment consecutive failures
+			consecutiveFailures++
+		}
+
+		// Wait with exponential backoff
+		s.logger.Info("Waiting before reconnection attempt",
+			"delay_seconds", backoffDelay.Seconds(),
+			"consecutive_failures", consecutiveFailures)
+
+		select {
+		case <-ctx.Done():
+			return
+		case <-time.After(backoffDelay):
+			// Double the backoff delay for next time, up to max
+			backoffDelay *= 2
+			if backoffDelay > maxBackoffDelay {
+				backoffDelay = maxBackoffDelay
+			}
+		}
+	}
+}
+
 func (s *Streamer) stream(ctx context.Context) error {
 	req, err := http.NewRequestWithContext(ctx, "GET", risLiveURL, nil)
 	if err != nil {
 		return fmt.Errorf("failed to create request: %w", err)
 	}
 
+	// Explicitly request gzip compression
+	req.Header.Set("Accept-Encoding", "gzip")
+
 	resp, err := s.client.Do(req)
 	if err != nil {
 		return fmt.Errorf("failed to connect to RIS Live: %w", err)
@@ -340,9 +485,28 @@ func (s *Streamer) stream(ctx context.Context) error {
 		return fmt.Errorf("unexpected status code: %d", resp.StatusCode)
 	}
 
-	s.logger.Info("Connected to RIS Live stream")
+	// Wrap body with counting reader to track actual wire bytes
+	wireCounter := &countingReader{reader: resp.Body}
+
+	// Check if response is gzip-compressed and decompress if needed
+	var reader io.Reader = wireCounter
+	if resp.Header.Get("Content-Encoding") == "gzip" {
+		gzReader, err := gzip.NewReader(wireCounter)
+		if err != nil {
+			return fmt.Errorf("failed to create gzip reader: %w", err)
+		}
+		defer func() { _ = gzReader.Close() }()
+		reader = gzReader
+		s.logger.Info("Connected to RIS Live stream", "compression", "gzip")
+	} else {
+		s.logger.Info("Connected to RIS Live stream", "compression", "none")
+	}
+
 	s.metrics.SetConnected(true)
 
+	// Track wire bytes for metrics updates
+	var lastWireBytes int64
+
 	// Start metrics logging goroutine
 	metricsTicker := time.NewTicker(metricsLogInterval)
 	defer metricsTicker.Stop()
@@ -358,7 +522,27 @@ func (s *Streamer) stream(ctx context.Context) error {
 		}
 	}()
 
-	scanner := bufio.NewScanner(resp.Body)
+	// Wire byte update ticker - update metrics with actual wire bytes periodically
+	wireUpdateTicker := time.NewTicker(time.Second)
+	defer wireUpdateTicker.Stop()
+
+	go func() {
+		for {
+			select {
+			case <-wireUpdateTicker.C:
+				currentBytes := wireCounter.Count()
+				delta := currentBytes - lastWireBytes
+				if delta > 0 {
+					s.metrics.RecordWireBytes(delta)
+					lastWireBytes = currentBytes
+				}
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
+
+	scanner := bufio.NewScanner(reader)
 
 	for scanner.Scan() {
 		select {
@@ -374,7 +558,7 @@ func (s *Streamer) stream(ctx context.Context) error {
 			continue
 		}
 
-		// Update metrics with message size
+		// Update metrics with decompressed message size
 		s.updateMetrics(len(line))
 
 		// Call raw handler if registered
@@ -390,10 +574,13 @@ func (s *Streamer) stream(ctx context.Context) error {
 		// Parse the message first
 		var wrapper ristypes.RISLiveMessage
 		if err := json.Unmarshal(line, &wrapper); err != nil {
-			// Output the raw line and panic on parse failure
-			fmt.Fprintf(os.Stderr, "Failed to parse JSON: %v\n", err)
-			fmt.Fprintf(os.Stderr, "Raw line: %s\n", string(line))
-			panic(fmt.Sprintf("JSON parse error: %v", err))
+			// Log the error and return to trigger reconnection
+			s.logger.Error("Failed to parse JSON",
+				"error", err,
+				"line", string(line),
+				"line_length", len(line))
+
+			return fmt.Errorf("JSON parse error: %w", err)
 		}
 
 		// Check if it's a ris_message wrapper
@@ -424,18 +611,32 @@ func (s *Streamer) stream(ctx context.Context) error {
 			// BGP keepalive messages - silently process
 			continue
 		case "OPEN":
-			// BGP open messages
+			// BGP open messages - track peer as active
+			s.bgpPeersMu.Lock()
+			s.bgpPeers[msg.Peer] = true
+			peerCount := len(s.bgpPeers)
+			s.bgpPeersMu.Unlock()
+			s.metrics.SetBGPPeerCount(peerCount)
+
 			s.logger.Info("BGP session opened",
 				"peer", msg.Peer,
 				"peer_asn", msg.PeerASN,
+				"total_peers", peerCount,
 			)
 
 			continue
 		case "NOTIFICATION":
-			// BGP notification messages (errors)
+			// BGP notification messages (session closed)
+			s.bgpPeersMu.Lock()
+			delete(s.bgpPeers, msg.Peer)
+			peerCount := len(s.bgpPeers)
+			s.bgpPeersMu.Unlock()
+			s.metrics.SetBGPPeerCount(peerCount)
+
 			s.logger.Warn("BGP notification",
 				"peer", msg.Peer,
 				"peer_asn", msg.PeerASN,
+				"total_peers", peerCount,
 			)
 
 			continue
@@ -443,32 +644,43 @@ func (s *Streamer) stream(ctx context.Context) error {
 			// Peer state changes - silently ignore
 			continue
 		default:
-			fmt.Fprintf(
-				os.Stderr,
-				"UNKNOWN MESSAGE TYPE: %s\nRAW MESSAGE: %s\n",
-				msg.Type,
-				string(line),
-			)
-			panic(
-				fmt.Sprintf(
-					"Unknown RIS message type: %s",
-					msg.Type,
-				),
+			s.logger.Warn("Unknown message type, skipping",
+				"type", msg.Type,
 			)
+
+			continue
 		}
 
 		// Dispatch to interested handlers
 		s.mu.RLock()
 		for _, info := range s.handlers {
-			if info.handler.WantsMessage(msg.Type) {
-				select {
-				case info.queue <- &msg:
-					// Message queued successfully
-				default:
-					// Queue is full, drop the message
-					atomic.AddUint64(&info.metrics.droppedCount, 1)
-					atomic.AddUint64(&s.totalDropped, 1)
+			if !info.handler.WantsMessage(msg.Type) {
+				continue
+			}
+
+			// Check if we should drop due to backpressure
+			if s.shouldDropForBackpressure(info) {
+				atomic.AddUint64(&info.metrics.droppedCount, 1)
+				atomic.AddUint64(&s.totalDropped, 1)
+
+				continue
+			}
+
+			// Try to queue the message
+			select {
+			case info.queue <- &msg:
+				// Message queued successfully
+				// Update high water mark if needed
+				queueLen := len(info.queue)
+				info.metrics.mu.Lock()
+				if queueLen > info.metrics.queueHighWaterMark {
+					info.metrics.queueHighWaterMark = queueLen
 				}
+				info.metrics.mu.Unlock()
+			default:
+				// Queue is full, drop the message
+				atomic.AddUint64(&info.metrics.droppedCount, 1)
+				atomic.AddUint64(&s.totalDropped, 1)
 			}
 		}
 		s.mu.RUnlock()
@@ -480,3 +692,25 @@ func (s *Streamer) stream(ctx context.Context) error {
 
 	return nil
 }
+
+// shouldDropForBackpressure determines if a message should be dropped based on queue utilization
+func (s *Streamer) shouldDropForBackpressure(info *handlerInfo) bool {
+	// Calculate queue utilization
+	queueLen := len(info.queue)
+	queueCap := cap(info.queue)
+	utilization := float64(queueLen) / float64(queueCap)
+
+	// No drops below threshold
+	if utilization < backpressureThreshold {
+		return false
+	}
+
+	// Calculate drop probability (0.0 at threshold, 1.0 at 100% full)
+	dropProbability := (utilization - backpressureThreshold) * backpressureSlope
+	if dropProbability > 1.0 {
+		dropProbability = 1.0
+	}
+
+	// Random drop based on probability
+	return s.random.Float64() < dropProbability
+}

internal/templates/as_detail.html

@@ -3,15 +3,78 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>AS{{.ASN.Number}} - {{.ASN.Handle}} - RouteWatch</title>
+    <title>AS{{.ASN.ASN}} - {{.ASN.Handle}} - RouteWatch</title>
     <style>
+        * {
+            box-sizing: border-box;
+        }
         body {
             font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
             margin: 0;
-            padding: 20px;
+            padding: 0;
             background: #f5f5f5;
             color: #333;
         }
+
+        /* Navbar styles */
+        .navbar {
+            background: #2c3e50;
+            padding: 0 20px;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            height: 56px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .navbar-brand {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 18px;
+            font-weight: 600;
+        }
+        .navbar-brand a {
+            color: white;
+            text-decoration: none;
+        }
+        .navbar-brand a:hover {
+            color: #ecf0f1;
+        }
+        .navbar-brand .by {
+            font-weight: normal;
+            color: #95a5a6;
+            font-size: 14px;
+        }
+        .navbar-brand .author {
+            color: #3498db;
+            font-weight: normal;
+        }
+        .navbar-brand .author:hover {
+            text-decoration: underline;
+        }
+        .navbar-links {
+            display: flex;
+            gap: 20px;
+        }
+        .navbar-links a {
+            color: #ecf0f1;
+            text-decoration: none;
+            font-size: 14px;
+            padding: 8px 12px;
+            border-radius: 4px;
+            transition: background-color 0.2s;
+        }
+        .navbar-links a:hover {
+            background: rgba(255,255,255,0.1);
+        }
+        .navbar-links a.active {
+            background: rgba(255,255,255,0.15);
+        }
+
+        /* Main content */
+        .main-content {
+            padding: 20px;
+        }
         .container {
             max-width: 1200px;
             margin: 0 auto;
@@ -133,10 +196,22 @@
     </style>
 </head>
 <body>
+    <nav class="navbar">
+        <div class="navbar-brand">
+            <a href="/">routewatch</a>
+            <span class="by">by</span>
+            <a href="https://sneak.berlin" class="author">@sneak</a>
+        </div>
+        <div class="navbar-links">
+            <a href="/">Home</a>
+            <a href="/status">Status</a>
+        </div>
+    </nav>
+
+    <main class="main-content">
     <div class="container">
-        <a href="/status" class="nav-link">← Back to Status</a>
         
-        <h1>AS{{.ASN.Number}}{{if .ASN.Handle}} - {{.ASN.Handle}}{{end}}</h1>
+        <h1>AS{{.ASN.ASN}}{{if .ASN.Handle}} - {{.ASN.Handle}}{{end}}</h1>
         {{if .ASN.Description}}
         <p class="subtitle">{{.ASN.Description}}</p>
         {{end}}
@@ -154,6 +229,10 @@
                 <div class="info-label">IPv6 Prefixes</div>
                 <div class="info-value">{{.IPv6Count}}</div>
             </div>
+            <div class="info-card">
+                <div class="info-label">Peer ASNs</div>
+                <div class="info-value">{{.PeerCount}}</div>
+            </div>
             <div class="info-card">
                 <div class="info-label">First Seen</div>
                 <div class="info-value">{{.ASN.FirstSeen.Format "2006-01-02"}}</div>
@@ -178,7 +257,7 @@
                 <tbody>
                     {{range .IPv4Prefixes}}
                     <tr>
-                        <td><a href="/prefix/{{.Prefix | urlEncode}}" class="prefix-link">{{.Prefix}}</a></td>
+                        <td><a href="{{.Prefix | prefixURL}}" class="prefix-link">{{.Prefix}}</a></td>
                         <td>/{{.MaskLength}}</td>
                         <td>{{.LastUpdated.Format "2006-01-02 15:04:05"}}</td>
                         <td class="age">{{.LastUpdated | timeSince}}</td>
@@ -207,7 +286,7 @@
                 <tbody>
                     {{range .IPv6Prefixes}}
                     <tr>
-                        <td><a href="/prefix/{{.Prefix | urlEncode}}" class="prefix-link">{{.Prefix}}</a></td>
+                        <td><a href="{{.Prefix | prefixURL}}" class="prefix-link">{{.Prefix}}</a></td>
                         <td>/{{.MaskLength}}</td>
                         <td>{{.LastUpdated.Format "2006-01-02 15:04:05"}}</td>
                         <td class="age">{{.LastUpdated | timeSince}}</td>
@@ -223,6 +302,45 @@
             <p>No prefixes announced by this AS</p>
         </div>
         {{end}}
+
+        {{if .Peers}}
+        <div class="prefix-section">
+            <div class="prefix-header">
+                <h2>Peer ASNs</h2>
+                <span class="prefix-count">{{.PeerCount}}</span>
+            </div>
+            <table class="prefix-table">
+                <thead>
+                    <tr>
+                        <th>ASN</th>
+                        <th>Handle</th>
+                        <th>Description</th>
+                        <th>First Seen</th>
+                        <th>Last Seen</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {{range .Peers}}
+                    <tr>
+                        <td><a href="/as/{{.ASN}}" class="prefix-link">AS{{.ASN}}</a></td>
+                        <td>{{if .Handle}}{{.Handle}}{{else}}-{{end}}</td>
+                        <td>{{if .Description}}{{.Description}}{{else}}-{{end}}</td>
+                        <td>{{.FirstSeen.Format "2006-01-02"}}</td>
+                        <td>{{.LastSeen.Format "2006-01-02"}}</td>
+                    </tr>
+                    {{end}}
+                </tbody>
+            </table>
+        </div>
+        {{else}}
+        <div class="prefix-section">
+            <h2>Peer ASNs</h2>
+            <div class="empty-state">
+                <p>No peering relationships found for this AS</p>
+            </div>
+        </div>
+        {{end}}
     </div>
+    </main>
 </body>
 </html>

internal/templates/index.html

@@ -0,0 +1,447 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>RouteWatch - BGP Route Monitor</title>
+    <style>
+        * {
+            box-sizing: border-box;
+        }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            margin: 0;
+            padding: 0;
+            background: #f5f5f5;
+            color: #333;
+        }
+
+        /* Navbar styles */
+        .navbar {
+            background: #2c3e50;
+            padding: 0 20px;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            height: 56px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .navbar-brand {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 18px;
+            font-weight: 600;
+        }
+        .navbar-brand a {
+            color: white;
+            text-decoration: none;
+        }
+        .navbar-brand a:hover {
+            color: #ecf0f1;
+        }
+        .navbar-brand .by {
+            font-weight: normal;
+            color: #95a5a6;
+            font-size: 14px;
+        }
+        .navbar-brand .author {
+            color: #3498db;
+            font-weight: normal;
+        }
+        .navbar-brand .author:hover {
+            text-decoration: underline;
+        }
+        .navbar-links {
+            display: flex;
+            gap: 20px;
+        }
+        .navbar-links a {
+            color: #ecf0f1;
+            text-decoration: none;
+            font-size: 14px;
+            padding: 8px 12px;
+            border-radius: 4px;
+            transition: background-color 0.2s;
+        }
+        .navbar-links a:hover {
+            background: rgba(255,255,255,0.1);
+        }
+        .navbar-links a.active {
+            background: rgba(255,255,255,0.15);
+        }
+
+        /* Main content */
+        .main-content {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 30px 20px;
+        }
+
+        /* Stats overview */
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 20px;
+            margin-bottom: 40px;
+        }
+        .stat-card {
+            background: white;
+            padding: 24px;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            text-align: center;
+        }
+        .stat-value {
+            font-size: 32px;
+            font-weight: bold;
+            color: #2c3e50;
+            margin-bottom: 8px;
+        }
+        .stat-label {
+            font-size: 14px;
+            color: #7f8c8d;
+            text-transform: uppercase;
+            letter-spacing: 0.5px;
+        }
+        .stat-card.connected .stat-value {
+            color: #27ae60;
+        }
+        .stat-card.disconnected .stat-value {
+            color: #e74c3c;
+        }
+
+        /* Search section */
+        .search-section {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(350px, 1fr));
+            gap: 24px;
+            margin-bottom: 40px;
+        }
+        .search-card {
+            background: white;
+            padding: 24px;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .search-card h2 {
+            margin: 0 0 16px 0;
+            font-size: 18px;
+            color: #2c3e50;
+        }
+        .search-input-group {
+            display: flex;
+            gap: 10px;
+        }
+        .search-input-group input {
+            flex: 1;
+            padding: 12px 16px;
+            border: 1px solid #ddd;
+            border-radius: 6px;
+            font-size: 14px;
+            outline: none;
+            transition: border-color 0.2s;
+        }
+        .search-input-group input:focus {
+            border-color: #3498db;
+        }
+        .search-input-group button {
+            padding: 12px 24px;
+            background: #3498db;
+            color: white;
+            border: none;
+            border-radius: 6px;
+            font-size: 14px;
+            cursor: pointer;
+            transition: background-color 0.2s;
+        }
+        .search-input-group button:hover {
+            background: #2980b9;
+        }
+        .search-input-group button:disabled {
+            background: #bdc3c7;
+            cursor: not-allowed;
+        }
+        .search-hint {
+            font-size: 12px;
+            color: #95a5a6;
+            margin-top: 8px;
+        }
+
+        /* IP Lookup result */
+        .ip-result {
+            margin-top: 16px;
+            display: none;
+        }
+        .ip-result.visible {
+            display: block;
+        }
+        .ip-result-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 8px;
+        }
+        .ip-result-header h3 {
+            margin: 0;
+            font-size: 14px;
+            color: #2c3e50;
+        }
+        .ip-result-header button {
+            background: none;
+            border: none;
+            color: #e74c3c;
+            cursor: pointer;
+            font-size: 12px;
+        }
+        .ip-result pre {
+            background: #2c3e50;
+            color: #ecf0f1;
+            padding: 16px;
+            border-radius: 6px;
+            overflow-x: auto;
+            font-size: 12px;
+            line-height: 1.5;
+            margin: 0;
+            max-height: 400px;
+            overflow-y: auto;
+        }
+        .ip-result .error {
+            background: #fee;
+            color: #c00;
+            padding: 12px;
+            border-radius: 6px;
+            font-size: 14px;
+        }
+        .ip-result .loading {
+            color: #7f8c8d;
+            font-style: italic;
+        }
+
+        /* Footer */
+        .footer {
+            margin-top: 40px;
+            padding: 20px;
+            background: white;
+            border-radius: 8px;
+            box-shadow: 0 -2px 10px rgba(0,0,0,0.05);
+            text-align: center;
+            color: #7f8c8d;
+            font-size: 14px;
+        }
+        .footer a {
+            color: #3498db;
+            text-decoration: none;
+        }
+        .footer a:hover {
+            text-decoration: underline;
+        }
+        .footer .separator {
+            margin: 0 10px;
+            color: #ddd;
+        }
+    </style>
+</head>
+<body>
+    <nav class="navbar">
+        <div class="navbar-brand">
+            <a href="/">routewatch</a>
+            <span class="by">by</span>
+            <a href="https://sneak.berlin" class="author">@sneak</a>
+        </div>
+        <div class="navbar-links">
+            <a href="/" class="active">Home</a>
+            <a href="/status">Status</a>
+        </div>
+    </nav>
+
+    <main class="main-content">
+        <div class="stats-grid">
+            <div class="stat-card" id="status-card">
+                <div class="stat-value" id="stat-status">-</div>
+                <div class="stat-label">Status</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="stat-routes">-</div>
+                <div class="stat-label">Live Routes</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="stat-asns">-</div>
+                <div class="stat-label">Autonomous Systems</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="stat-prefixes">-</div>
+                <div class="stat-label">Prefixes</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="stat-peers">-</div>
+                <div class="stat-label">BGP Peers</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="stat-updates">-</div>
+                <div class="stat-label">Updates/sec</div>
+            </div>
+        </div>
+
+        <div class="search-section">
+            <div class="search-card">
+                <h2>AS Number Lookup</h2>
+                <form id="asn-form" class="search-input-group">
+                    <input type="text" id="asn-input" placeholder="e.g., 15169 or AS15169" autocomplete="off">
+                    <button type="submit">Lookup</button>
+                </form>
+                <p class="search-hint">Enter an AS number to view its announced prefixes and peers</p>
+            </div>
+
+            <div class="search-card">
+                <h2>AS Name Search</h2>
+                <form id="asname-form" class="search-input-group">
+                    <input type="text" id="asname-input" placeholder="e.g., Google, Cloudflare" autocomplete="off">
+                    <button type="submit">Search</button>
+                </form>
+                <p class="search-hint">Search for autonomous systems by organization name</p>
+                <div id="asname-results"></div>
+            </div>
+
+            <div class="search-card">
+                <h2>IP Address Lookup</h2>
+                <form id="ip-form" class="search-input-group">
+                    <input type="text" id="ip-input" placeholder="e.g., 8.8.8.8 or 2001:4860:4860::8888" autocomplete="off">
+                    <button type="submit">Lookup</button>
+                </form>
+                <p class="search-hint">Get routing information for any IP address</p>
+                <div id="ip-result" class="ip-result">
+                    <div class="ip-result-header">
+                        <h3>Result</h3>
+                        <button type="button" id="ip-result-close">Clear</button>
+                    </div>
+                    <pre id="ip-result-content"></pre>
+                </div>
+            </div>
+        </div>
+    </main>
+
+    <footer class="footer">
+        <span><a href="{{appRepoURL}}">{{appName}}</a> by <a href="{{appAuthorURL}}">{{appAuthor}}</a></span>
+        <span class="separator">|</span>
+        <span>{{appLicense}}</span>
+        <span class="separator">|</span>
+        <span><a href="{{appGitCommitURL}}">{{appGitRevision}}</a></span>
+    </footer>
+
+    <script>
+        function formatNumber(num) {
+            if (num >= 1000000) {
+                return (num / 1000000).toFixed(1) + 'M';
+            } else if (num >= 1000) {
+                return (num / 1000).toFixed(1) + 'K';
+            }
+            return num.toLocaleString();
+        }
+
+        // Fetch and display stats
+        function updateStats() {
+            fetch('/api/v1/stats')
+                .then(response => response.json())
+                .then(response => {
+                    if (response.status !== 'ok') return;
+                    const data = response.data;
+
+                    const statusCard = document.getElementById('status-card');
+                    const statusEl = document.getElementById('stat-status');
+                    statusEl.textContent = data.connected ? 'Connected' : 'Disconnected';
+                    statusCard.className = 'stat-card ' + (data.connected ? 'connected' : 'disconnected');
+
+                    document.getElementById('stat-routes').textContent = formatNumber(data.live_routes);
+                    document.getElementById('stat-asns').textContent = formatNumber(data.asns);
+                    document.getElementById('stat-prefixes').textContent = formatNumber(data.prefixes);
+
+                    if (data.stream) {
+                        document.getElementById('stat-peers').textContent = formatNumber(data.stream.bgp_peer_count);
+                    }
+
+                    const totalUpdates = data.ipv4_updates_per_sec + data.ipv6_updates_per_sec;
+                    document.getElementById('stat-updates').textContent = totalUpdates.toFixed(1);
+                })
+                .catch(() => {
+                    document.getElementById('stat-status').textContent = 'Error';
+                    document.getElementById('status-card').className = 'stat-card disconnected';
+                });
+        }
+
+        // ASN lookup
+        document.getElementById('asn-form').addEventListener('submit', function(e) {
+            e.preventDefault();
+            let asn = document.getElementById('asn-input').value.trim();
+            // Remove 'AS' prefix if present
+            asn = asn.replace(/^AS/i, '');
+            if (asn && /^\d+$/.test(asn)) {
+                window.location.href = '/as/' + asn;
+            }
+        });
+
+        // AS name search
+        document.getElementById('asname-form').addEventListener('submit', function(e) {
+            e.preventDefault();
+            const query = document.getElementById('asname-input').value.trim();
+            if (!query) return;
+
+            const resultsDiv = document.getElementById('asname-results');
+            resultsDiv.innerHTML = '<p class="loading" style="color: #7f8c8d; margin-top: 12px;">Searching...</p>';
+
+            // Use a simple client-side search against the asinfo data
+            // For now, redirect to AS page if it looks like an ASN
+            if (/^\d+$/.test(query)) {
+                window.location.href = '/as/' + query;
+                return;
+            }
+
+            // Show a message that server-side search is coming
+            resultsDiv.innerHTML = '<p style="color: #7f8c8d; margin-top: 12px; font-size: 13px;">AS name search coming soon. For now, try an AS number.</p>';
+        });
+
+        // IP lookup
+        document.getElementById('ip-form').addEventListener('submit', function(e) {
+            e.preventDefault();
+            const ip = document.getElementById('ip-input').value.trim();
+            if (!ip) return;
+
+            const resultDiv = document.getElementById('ip-result');
+            const contentEl = document.getElementById('ip-result-content');
+
+            resultDiv.classList.add('visible');
+            contentEl.className = '';
+            contentEl.textContent = 'Loading...';
+            contentEl.classList.add('loading');
+
+            fetch('/ip/' + encodeURIComponent(ip))
+                .then(response => response.json())
+                .then(response => {
+                    contentEl.classList.remove('loading');
+                    if (response.status === 'error') {
+                        contentEl.className = 'error';
+                        contentEl.textContent = 'Error: ' + response.error.msg;
+                    } else {
+                        contentEl.className = '';
+                        contentEl.textContent = JSON.stringify(response.data, null, 2);
+                    }
+                })
+                .catch(error => {
+                    contentEl.classList.remove('loading');
+                    contentEl.className = 'error';
+                    contentEl.textContent = 'Error: ' + error.message;
+                });
+        });
+
+        // Close IP result
+        document.getElementById('ip-result-close').addEventListener('click', function() {
+            document.getElementById('ip-result').classList.remove('visible');
+            document.getElementById('ip-input').value = '';
+        });
+
+        // Initial load and refresh stats every 5 seconds
+        updateStats();
+        setInterval(updateStats, 5000);
+    </script>
+</body>
+</html>

internal/templates/prefix_detail.html

@@ -5,15 +5,79 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>{{.Prefix}} - RouteWatch</title>
     <style>
+        * {
+            box-sizing: border-box;
+        }
         body {
             font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
             margin: 0;
-            padding: 20px;
+            padding: 0;
             background: #f5f5f5;
             color: #333;
         }
+
+        /* Navbar styles */
+        .navbar {
+            background: #2c3e50;
+            padding: 0 20px;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            height: 56px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .navbar-brand {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 18px;
+            font-weight: 600;
+        }
+        .navbar-brand a {
+            color: white;
+            text-decoration: none;
+        }
+        .navbar-brand a:hover {
+            color: #ecf0f1;
+        }
+        .navbar-brand .by {
+            font-weight: normal;
+            color: #95a5a6;
+            font-size: 14px;
+        }
+        .navbar-brand .author {
+            color: #3498db;
+            font-weight: normal;
+        }
+        .navbar-brand .author:hover {
+            text-decoration: underline;
+        }
+        .navbar-links {
+            display: flex;
+            gap: 20px;
+        }
+        .navbar-links a {
+            color: #ecf0f1;
+            text-decoration: none;
+            font-size: 14px;
+            padding: 8px 12px;
+            border-radius: 4px;
+            transition: background-color 0.2s;
+        }
+        .navbar-links a:hover {
+            background: rgba(255,255,255,0.1);
+        }
+        .navbar-links a.active {
+            background: rgba(255,255,255,0.15);
+        }
+
+        /* Main content */
+        .main-content {
+            padding: 20px;
+        }
         .container {
-            max-width: 1200px;
+            width: 90%;
+            max-width: 1600px;
             margin: 0 auto;
             background: white;
             padding: 30px;
@@ -91,6 +155,7 @@
         .route-table td {
             padding: 12px;
             border-bottom: 1px solid #e0e0e0;
+            white-space: nowrap;
         }
         .route-table tr:hover {
             background: #f8f9fa;
@@ -114,9 +179,13 @@
             font-family: monospace;
             font-size: 13px;
             color: #666;
-            max-width: 300px;
-            overflow-x: auto;
-            white-space: nowrap;
+            max-width: 600px;
+            word-wrap: break-word;
+            white-space: normal !important;
+            line-height: 1.5;
+        }
+        .as-path .as-link {
+            font-weight: 600;
         }
         .age {
             color: #7f8c8d;
@@ -168,15 +237,26 @@
                 font-size: 14px;
             }
             .as-path {
-                max-width: 150px;
+                max-width: 100%;
             }
         }
     </style>
 </head>
 <body>
+    <nav class="navbar">
+        <div class="navbar-brand">
+            <a href="/">routewatch</a>
+            <span class="by">by</span>
+            <a href="https://sneak.berlin" class="author">@sneak</a>
+        </div>
+        <div class="navbar-links">
+            <a href="/">Home</a>
+            <a href="/status">Status</a>
+        </div>
+    </nav>
+
+    <main class="main-content">
     <div class="container">
-        <a href="/status" class="nav-link">← Back to Status</a>
-        
         <h1>{{.Prefix}}</h1>
         <p class="subtitle">IPv{{.IPVersion}} Prefix{{if .MaskLength}} • /{{.MaskLength}}{{end}}</p>
         
@@ -201,7 +281,7 @@
             <div class="origin-list">
                 {{range .Origins}}
                 <div class="origin-item">
-                    <a href="/as/{{.Number}}" class="as-link">AS{{.Number}}</a>
+                    <a href="/as/{{.ASN}}" class="as-link">AS{{.ASN}}</a>
                     {{if .Handle}} ({{.Handle}}){{end}}
                     <span style="color: #7f8c8d; margin-left: 10px;">{{.PeerCount}} peer{{if ne .PeerCount 1}}s{{end}}</span>
                 </div>
@@ -234,7 +314,7 @@
                             <a href="/as/{{.OriginASN}}" class="as-link">AS{{.OriginASN}}</a>
                         </td>
                         <td class="peer-ip">{{.PeerIP}}</td>
-                        <td class="as-path">{{range $i, $as := .ASPath}}{{if $i}} → {{end}}{{$as}}{{end}}</td>
+                        <td class="as-path">{{range $i, $as := .ASPathWithHandle}}{{if $i}} → {{end}}<a href="/as/{{$as.ASN}}" class="as-link">{{if $as.Handle}}{{$as.Handle}}{{else}}AS{{$as.ASN}}{{end}}</a>{{end}}</td>
                         <td class="peer-ip">{{.NextHop}}</td>
                         <td>{{.LastUpdated.Format "2006-01-02 15:04:05"}}</td>
                         <td class="age">{{.LastUpdated | timeSince}}</td>
@@ -249,5 +329,6 @@
         </div>
         {{end}}
     </div>
+    </main>
 </body>
 </html>

internal/templates/prefix_length.html

@@ -0,0 +1,185 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Prefixes with /{{ .MaskLength }} - RouteWatch</title>
+    <style>
+        * {
+            box-sizing: border-box;
+        }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            margin: 0;
+            padding: 0;
+            background: #f5f5f5;
+        }
+
+        /* Navbar styles */
+        .navbar {
+            background: #2c3e50;
+            padding: 0 20px;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            height: 56px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .navbar-brand {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 18px;
+            font-weight: 600;
+        }
+        .navbar-brand a {
+            color: white;
+            text-decoration: none;
+        }
+        .navbar-brand a:hover {
+            color: #ecf0f1;
+        }
+        .navbar-brand .by {
+            font-weight: normal;
+            color: #95a5a6;
+            font-size: 14px;
+        }
+        .navbar-brand .author {
+            color: #3498db;
+            font-weight: normal;
+        }
+        .navbar-brand .author:hover {
+            text-decoration: underline;
+        }
+        .navbar-links {
+            display: flex;
+            gap: 20px;
+        }
+        .navbar-links a {
+            color: #ecf0f1;
+            text-decoration: none;
+            font-size: 14px;
+            padding: 8px 12px;
+            border-radius: 4px;
+            transition: background-color 0.2s;
+        }
+        .navbar-links a:hover {
+            background: rgba(255,255,255,0.1);
+        }
+        .navbar-links a.active {
+            background: rgba(255,255,255,0.15);
+        }
+
+        /* Main content */
+        .main-content {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+        h1 {
+            color: #333;
+            margin-bottom: 10px;
+        }
+        .subtitle {
+            color: #666;
+            margin-bottom: 30px;
+        }
+        .info-card {
+            background: white;
+            padding: 20px;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            margin-bottom: 20px;
+        }
+        table {
+            width: 100%;
+            border-collapse: collapse;
+            background: white;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            border-radius: 8px;
+            overflow: hidden;
+        }
+        th {
+            background: #f8f9fa;
+            padding: 12px;
+            text-align: left;
+            font-weight: 600;
+            color: #333;
+            border-bottom: 2px solid #dee2e6;
+        }
+        td {
+            padding: 12px;
+            border-bottom: 1px solid #eee;
+        }
+        tr:last-child td {
+            border-bottom: none;
+        }
+        tr:hover {
+            background: #f8f9fa;
+        }
+        a {
+            color: #0066cc;
+            text-decoration: none;
+        }
+        a:hover {
+            text-decoration: underline;
+        }
+        .prefix-link {
+            font-family: 'SF Mono', Monaco, 'Cascadia Mono', 'Roboto Mono', Consolas, 'Courier New', monospace;
+        }
+        .as-link {
+            white-space: nowrap;
+        }
+        .age {
+            color: #666;
+            font-size: 0.9em;
+        }
+        .back-link {
+            display: inline-block;
+            margin-bottom: 20px;
+            color: #0066cc;
+        }
+    </style>
+</head>
+<body>
+    <nav class="navbar">
+        <div class="navbar-brand">
+            <a href="/">routewatch</a>
+            <span class="by">by</span>
+            <a href="https://sneak.berlin" class="author">@sneak</a>
+        </div>
+        <div class="navbar-links">
+            <a href="/">Home</a>
+            <a href="/status">Status</a>
+        </div>
+    </nav>
+
+    <main class="main-content">
+    <h1>IPv{{ .IPVersion }} Prefixes with /{{ .MaskLength }}</h1>
+    <p class="subtitle">Showing {{ .Count }} randomly selected prefixes</p>
+    
+    <table>
+        <thead>
+            <tr>
+                <th>Prefix</th>
+                <th>Age</th>
+                <th>Origin AS</th>
+            </tr>
+        </thead>
+        <tbody>
+            {{ range .Prefixes }}
+            <tr>
+                <td><a href="{{ .Prefix | prefixURL }}" class="prefix-link">{{ .Prefix }}</a></td>
+                <td class="age">{{ .Age }}</td>
+                <td>
+                    <a href="/as/{{ .OriginASN }}" class="as-link">
+                        AS{{ .OriginASN }}{{ if .OriginASDescription }} ({{ .OriginASDescription }}){{ end }}
+                    </a>
+                </td>
+            </tr>
+            {{ end }}
+        </tbody>
+    </table>
+    </main>
+</body>
+</html>

internal/templates/status.html

@@ -5,12 +5,76 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>RouteWatch Status</title>
     <style>
+        * {
+            box-sizing: border-box;
+        }
         body {
             font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            margin: 0;
+            padding: 0;
+            background: #f5f5f5;
+        }
+
+        /* Navbar styles */
+        .navbar {
+            background: #2c3e50;
+            padding: 0 20px;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            height: 56px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .navbar-brand {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 18px;
+            font-weight: 600;
+        }
+        .navbar-brand a {
+            color: white;
+            text-decoration: none;
+        }
+        .navbar-brand a:hover {
+            color: #ecf0f1;
+        }
+        .navbar-brand .by {
+            font-weight: normal;
+            color: #95a5a6;
+            font-size: 14px;
+        }
+        .navbar-brand .author {
+            color: #3498db;
+            font-weight: normal;
+        }
+        .navbar-brand .author:hover {
+            text-decoration: underline;
+        }
+        .navbar-links {
+            display: flex;
+            gap: 20px;
+        }
+        .navbar-links a {
+            color: #ecf0f1;
+            text-decoration: none;
+            font-size: 14px;
+            padding: 8px 12px;
+            border-radius: 4px;
+            transition: background-color 0.2s;
+        }
+        .navbar-links a:hover {
+            background: rgba(255,255,255,0.1);
+        }
+        .navbar-links a.active {
+            background: rgba(255,255,255,0.15);
+        }
+
+        /* Main content */
+        .main-content {
             max-width: 1200px;
             margin: 0 auto;
             padding: 20px;
-            background: #f5f5f5;
         }
         h1 {
             color: #333;
@@ -49,6 +113,16 @@
             font-family: 'SF Mono', Monaco, 'Cascadia Mono', 'Roboto Mono', Consolas, 'Courier New', monospace;
             color: #333;
         }
+        .metric-value.metric-link {
+            text-decoration: underline;
+            text-decoration-style: dashed;
+            text-underline-offset: 2px;
+            cursor: pointer;
+        }
+        .metric-value.metric-link:hover {
+            color: #0066cc;
+            text-decoration-style: solid;
+        }
         .connected {
             color: #22c55e;
         }
@@ -62,10 +136,43 @@
             border-radius: 4px;
             margin-top: 20px;
         }
+        .footer {
+            margin-top: 40px;
+            padding: 20px;
+            background: white;
+            border-radius: 8px;
+            box-shadow: 0 -2px 10px rgba(0,0,0,0.1);
+            text-align: center;
+            color: #666;
+            font-size: 14px;
+        }
+        .footer a {
+            color: #0066cc;
+            text-decoration: none;
+        }
+        .footer a:hover {
+            text-decoration: underline;
+        }
+        .footer .separator {
+            margin: 0 10px;
+            color: #ccc;
+        }
     </style>
 </head>
 <body>
-    <h1>RouteWatch Status</h1>
+    <nav class="navbar">
+        <div class="navbar-brand">
+            <a href="/">routewatch</a>
+            <span class="by">by</span>
+            <a href="https://sneak.berlin" class="author">@sneak</a>
+        </div>
+        <div class="navbar-links">
+            <a href="/">Home</a>
+            <a href="/status" class="active">Status</a>
+        </div>
+    </nav>
+
+    <main class="main-content">
     <div id="error" class="error" style="display: none;"></div>
     <div class="status-grid">
         <div class="status-card">
@@ -94,6 +201,18 @@
         
         <div class="status-card">
             <h2>Stream Statistics</h2>
+            <div class="metric">
+                <span class="metric-label">Connection Duration</span>
+                <span class="metric-value" id="connection_duration">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Reconnections</span>
+                <span class="metric-value" id="reconnect_count">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">BGP Peers</span>
+                <span class="metric-value" id="bgp_peer_count">-</span>
+            </div>
             <div class="metric">
                 <span class="metric-label">Total Messages</span>
                 <span class="metric-value" id="total_messages">-</span>
@@ -102,13 +221,49 @@
                 <span class="metric-label">Messages/sec</span>
                 <span class="metric-value" id="messages_per_sec">-</span>
             </div>
+            <div class="metric">
+                <span class="metric-label">Announcements</span>
+                <span class="metric-value" id="announcements">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Withdrawals</span>
+                <span class="metric-value" id="withdrawals">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Route Churn/sec</span>
+                <span class="metric-value" id="route_churn_per_sec">-</span>
+            </div>
             <div class="metric">
                 <span class="metric-label">Total Data</span>
-                <span class="metric-value" id="total_bytes">-</span>
+                <span class="metric-value" id="total_wire_bytes">-</span>
             </div>
             <div class="metric">
                 <span class="metric-label">Throughput</span>
-                <span class="metric-value" id="mbits_per_sec">-</span>
+                <span class="metric-value" id="wire_mbits_per_sec">-</span>
+            </div>
+        </div>
+
+        <div class="status-card">
+            <h2>GC Statistics</h2>
+            <div class="metric">
+                <span class="metric-label">GC Runs</span>
+                <span class="metric-value" id="gc_num">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Total Pause</span>
+                <span class="metric-value" id="gc_total_pause">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Last Pause</span>
+                <span class="metric-value" id="gc_last_pause">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Heap Alloc</span>
+                <span class="metric-value" id="gc_heap_alloc">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Heap Sys</span>
+                <span class="metric-value" id="gc_heap_sys">-</span>
             </div>
         </div>
         
@@ -166,9 +321,49 @@
                 <span class="metric-label">IPv6 Updates/sec</span>
                 <span class="metric-value" id="ipv6_updates_per_sec">-</span>
             </div>
+            <div class="metric">
+                <span class="metric-label">Oldest Route</span>
+                <span class="metric-value" id="oldest_route">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Newest Route</span>
+                <span class="metric-value" id="newest_route">-</span>
+            </div>
+        </div>
+
+        <div class="status-card">
+            <h2>WHOIS Fetcher</h2>
+            <div class="metric">
+                <span class="metric-label">Fresh ASNs</span>
+                <span class="metric-value" id="whois_fresh">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Stale ASNs</span>
+                <span class="metric-value" id="whois_stale">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Never Fetched</span>
+                <span class="metric-value" id="whois_never">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Fresh %</span>
+                <span class="metric-value" id="whois_percent">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Successes (1h)</span>
+                <span class="metric-value" id="whois_successes">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Errors (1h)</span>
+                <span class="metric-value" id="whois_errors">-</span>
+            </div>
+            <div class="metric">
+                <span class="metric-label">Current Interval</span>
+                <span class="metric-value" id="whois_interval">-</span>
+            </div>
         </div>
     </div>
-    
+
     <div class="status-grid">
         <div class="status-card">
             <h2>IPv4 Prefix Distribution</h2>
@@ -213,7 +408,23 @@
                 return ms.toFixed(2) + ' ms';
             }
         }
-        
+
+        function formatRelativeTime(isoString) {
+            if (!isoString) return '-';
+            const date = new Date(isoString);
+            const now = new Date();
+            const diffMs = now - date;
+            const diffSec = Math.floor(diffMs / 1000);
+            const diffMin = Math.floor(diffSec / 60);
+            const diffHour = Math.floor(diffMin / 60);
+            const diffDay = Math.floor(diffHour / 24);
+
+            if (diffSec < 60) return diffSec + 's ago';
+            if (diffMin < 60) return diffMin + 'm ago';
+            if (diffHour < 24) return diffHour + 'h ' + (diffMin % 60) + 'm ago';
+            return diffDay + 'd ' + (diffHour % 24) + 'h ago';
+        }
+
         function updatePrefixDistribution(elementId, distribution) {
             const container = document.getElementById(elementId);
             container.innerHTML = '';
@@ -226,12 +437,16 @@
             // Sort by mask length
             distribution.sort((a, b) => a.mask_length - b.mask_length);
             
+            // Determine the URL path based on whether this is IPv4 or IPv6
+            const isIPv6 = elementId.includes('ipv6');
+            const urlPath = isIPv6 ? '/prefixlength6/' : '/prefixlength/';
+            
             distribution.forEach(item => {
                 const metric = document.createElement('div');
                 metric.className = 'metric';
                 metric.innerHTML = `
                     <span class="metric-label">/${item.mask_length}</span>
-                    <span class="metric-value">${formatNumber(item.count)}</span>
+                    <a href="${urlPath}${item.mask_length}" class="metric-value metric-link">${formatNumber(item.count)}</a>
                 `;
                 container.appendChild(metric);
             });
@@ -254,6 +469,10 @@
                         <span class="metric-label">Queue</span>
                         <span class="metric-value">${handler.queue_length}/${handler.queue_capacity}</span>
                     </div>
+                    <div class="metric">
+                        <span class="metric-label">High Water Mark</span>
+                        <span class="metric-value">${handler.queue_high_water_mark}/${handler.queue_capacity} (${Math.round(handler.queue_high_water_mark * 100 / handler.queue_capacity)}%)</span>
+                    </div>
                     <div class="metric">
                         <span class="metric-label">Processed</span>
                         <span class="metric-value">${formatNumber(handler.processed_count)}</span>
@@ -276,6 +495,60 @@
             });
         }
         
+        function resetAllFields() {
+            // Reset all metric fields to '-'
+            document.getElementById('connected').textContent = '-';
+            document.getElementById('connected').className = 'metric-value';
+            document.getElementById('uptime').textContent = '-';
+            document.getElementById('go_version').textContent = '-';
+            document.getElementById('goroutines').textContent = '-';
+            document.getElementById('memory_usage').textContent = '-';
+            document.getElementById('connection_duration').textContent = '-';
+            document.getElementById('reconnect_count').textContent = '-';
+            document.getElementById('bgp_peer_count').textContent = '-';
+            document.getElementById('total_messages').textContent = '-';
+            document.getElementById('messages_per_sec').textContent = '-';
+            document.getElementById('announcements').textContent = '-';
+            document.getElementById('withdrawals').textContent = '-';
+            document.getElementById('route_churn_per_sec').textContent = '-';
+            document.getElementById('total_wire_bytes').textContent = '-';
+            document.getElementById('wire_mbits_per_sec').textContent = '-';
+            document.getElementById('gc_num').textContent = '-';
+            document.getElementById('gc_total_pause').textContent = '-';
+            document.getElementById('gc_last_pause').textContent = '-';
+            document.getElementById('gc_heap_alloc').textContent = '-';
+            document.getElementById('gc_heap_sys').textContent = '-';
+            document.getElementById('asns').textContent = '-';
+            document.getElementById('prefixes').textContent = '-';
+            document.getElementById('ipv4_prefixes').textContent = '-';
+            document.getElementById('ipv6_prefixes').textContent = '-';
+            document.getElementById('peerings').textContent = '-';
+            document.getElementById('peers').textContent = '-';
+            document.getElementById('database_size').textContent = '-';
+            document.getElementById('live_routes').textContent = '-';
+            document.getElementById('ipv4_routes').textContent = '-';
+            document.getElementById('ipv6_routes').textContent = '-';
+            document.getElementById('ipv4_updates_per_sec').textContent = '-';
+            document.getElementById('ipv6_updates_per_sec').textContent = '-';
+            document.getElementById('oldest_route').textContent = '-';
+            document.getElementById('newest_route').textContent = '-';
+            document.getElementById('whois_fresh').textContent = '-';
+            document.getElementById('whois_stale').textContent = '-';
+            document.getElementById('whois_never').textContent = '-';
+            document.getElementById('whois_percent').textContent = '-';
+            document.getElementById('whois_successes').textContent = '-';
+            document.getElementById('whois_errors').textContent = '-';
+            document.getElementById('whois_errors').className = 'metric-value';
+            document.getElementById('whois_interval').textContent = '-';
+
+            // Clear handler stats
+            document.getElementById('handler-stats-container').innerHTML = '';
+            
+            // Clear prefix distributions
+            document.getElementById('ipv4-prefix-distribution').innerHTML = '<div class="metric"><span class="metric-label">No data</span></div>';
+            document.getElementById('ipv6-prefix-distribution').innerHTML = '<div class="metric"><span class="metric-label">No data</span></div>';
+        }
+        
         function updateStatus() {
             fetch('/api/v1/stats')
                 .then(response => response.json())
@@ -284,6 +557,7 @@
                     if (response.status === 'error') {
                         document.getElementById('error').textContent = 'Error: ' + response.error.msg;
                         document.getElementById('error').style.display = 'block';
+                        resetAllFields();
                         return;
                     }
                     
@@ -300,10 +574,12 @@
                     document.getElementById('go_version').textContent = data.go_version;
                     document.getElementById('goroutines').textContent = formatNumber(data.goroutines);
                     document.getElementById('memory_usage').textContent = data.memory_usage;
+                    document.getElementById('connection_duration').textContent = data.connection_duration;
+                    document.getElementById('reconnect_count').textContent = formatNumber(data.reconnect_count);
                     document.getElementById('total_messages').textContent = formatNumber(data.total_messages);
                     document.getElementById('messages_per_sec').textContent = data.messages_per_sec.toFixed(1);
-                    document.getElementById('total_bytes').textContent = formatBytes(data.total_bytes);
-                    document.getElementById('mbits_per_sec').textContent = data.mbits_per_sec.toFixed(2) + ' Mbps';
+                    document.getElementById('total_wire_bytes').textContent = formatBytes(data.total_wire_bytes);
+                    document.getElementById('wire_mbits_per_sec').textContent = data.wire_mbits_per_sec.toFixed(2) + ' Mbps';
                     document.getElementById('asns').textContent = formatNumber(data.asns);
                     document.getElementById('prefixes').textContent = formatNumber(data.prefixes);
                     document.getElementById('ipv4_prefixes').textContent = formatNumber(data.ipv4_prefixes);
@@ -316,7 +592,39 @@
                     document.getElementById('ipv6_routes').textContent = formatNumber(data.ipv6_routes);
                     document.getElementById('ipv4_updates_per_sec').textContent = data.ipv4_updates_per_sec.toFixed(1);
                     document.getElementById('ipv6_updates_per_sec').textContent = data.ipv6_updates_per_sec.toFixed(1);
-                    
+                    document.getElementById('oldest_route').textContent = formatRelativeTime(data.oldest_route);
+                    document.getElementById('newest_route').textContent = formatRelativeTime(data.newest_route);
+
+                    // Update stream stats
+                    if (data.stream) {
+                        document.getElementById('bgp_peer_count').textContent = formatNumber(data.stream.bgp_peer_count);
+                        document.getElementById('announcements').textContent = formatNumber(data.stream.announcements);
+                        document.getElementById('withdrawals').textContent = formatNumber(data.stream.withdrawals);
+                        document.getElementById('route_churn_per_sec').textContent = data.stream.route_churn_per_sec.toFixed(1);
+                    }
+
+                    // Update GC stats
+                    if (data.gc) {
+                        document.getElementById('gc_num').textContent = formatNumber(data.gc.num_gc);
+                        document.getElementById('gc_total_pause').textContent = data.gc.total_pause_ms + ' ms';
+                        document.getElementById('gc_last_pause').textContent = data.gc.last_pause_ms.toFixed(3) + ' ms';
+                        document.getElementById('gc_heap_alloc').textContent = formatBytes(data.gc.heap_alloc_bytes);
+                        document.getElementById('gc_heap_sys').textContent = formatBytes(data.gc.heap_sys_bytes);
+                    }
+
+                    // Update WHOIS stats
+                    if (data.whois_stats) {
+                        document.getElementById('whois_fresh').textContent = formatNumber(data.whois_stats.fresh_asns);
+                        document.getElementById('whois_stale').textContent = formatNumber(data.whois_stats.stale_asns);
+                        document.getElementById('whois_never').textContent = formatNumber(data.whois_stats.never_fetched);
+                        document.getElementById('whois_percent').textContent = data.whois_stats.fresh_percent.toFixed(1) + '%';
+                        document.getElementById('whois_successes').textContent = formatNumber(data.whois_stats.successes_last_hour);
+                        const errorsEl = document.getElementById('whois_errors');
+                        errorsEl.textContent = formatNumber(data.whois_stats.errors_last_hour);
+                        errorsEl.className = 'metric-value' + (data.whois_stats.errors_last_hour > 0 ? ' disconnected' : '');
+                        document.getElementById('whois_interval').textContent = data.whois_stats.current_interval;
+                    }
+
                     // Update handler stats
                     updateHandlerStats(data.handler_stats || []);
                     
@@ -330,12 +638,22 @@
                 .catch(error => {
                     document.getElementById('error').textContent = 'Error fetching status: ' + error;
                     document.getElementById('error').style.display = 'block';
+                    resetAllFields();
                 });
         }
         
-        // Update immediately and then every 500ms
+        // Update immediately and then every 2 seconds
         updateStatus();
-        setInterval(updateStatus, 500);
+        setInterval(updateStatus, 2000);
     </script>
+    </main>
+
+    <footer class="footer">
+        <span><a href="{{appRepoURL}}">{{appName}}</a> by <a href="{{appAuthorURL}}">{{appAuthor}}</a></span>
+        <span class="separator">|</span>
+        <span>{{appLicense}}</span>
+        <span class="separator">|</span>
+        <span><a href="{{appGitCommitURL}}">{{appGitRevision}}</a></span>
+    </footer>
 </body>
 </html>

internal/templates/templates.go

@@ -5,10 +5,16 @@ import (
 	_ "embed"
 	"html/template"
 	"net/url"
+	"strings"
 	"sync"
 	"time"
+
+	"git.eeqj.de/sneak/routewatch/internal/version"
 )
 
+//go:embed index.html
+var indexHTML string
+
 //go:embed status.html
 var statusHTML string
 
@@ -18,11 +24,21 @@ var asDetailHTML string
 //go:embed prefix_detail.html
 var prefixDetailHTML string
 
+//go:embed prefix_length.html
+var prefixLengthHTML string
+
 // Templates contains all parsed templates
 type Templates struct {
-	Status       *template.Template
-	ASDetail     *template.Template
+	// Index is the template for the home page
+	Index *template.Template
+	// Status is the template for the main status page
+	Status *template.Template
+	// ASDetail is the template for displaying AS (Autonomous System) details
+	ASDetail *template.Template
+	// PrefixDetail is the template for displaying prefix details
 	PrefixDetail *template.Template
+	// PrefixLength is the template for displaying prefixes by length
+	PrefixLength *template.Template
 }
 
 var (
@@ -33,8 +49,9 @@ var (
 )
 
 const (
-	hoursPerDay  = 24
-	daysPerMonth = 30
+	hoursPerDay   = 24
+	daysPerMonth  = 30
+	cidrPartCount = 2 // A CIDR has two parts: prefix and length
 )
 
 // timeSince returns a human-readable duration since the given time
@@ -70,6 +87,20 @@ func timeSince(t time.Time) string {
 	return t.Format("2006-01-02")
 }
 
+// prefixURL generates a URL path for a prefix in CIDR notation.
+// Takes a prefix like "192.168.1.0/24" and returns "/prefix/192.168.1.0/24"
+// with the prefix part URL-encoded to handle IPv6 colons.
+func prefixURL(cidr string) string {
+	// Split CIDR into prefix and length
+	parts := strings.SplitN(cidr, "/", cidrPartCount)
+	if len(parts) != cidrPartCount {
+		// Fallback if no slash found
+		return "/prefix/" + url.PathEscape(cidr) + "/0"
+	}
+
+	return "/prefix/" + url.PathEscape(parts[0]) + "/" + parts[1]
+}
+
 // initTemplates parses all embedded templates
 func initTemplates() {
 	var err error
@@ -78,12 +109,26 @@ func initTemplates() {
 
 	// Create common template functions
 	funcs := template.FuncMap{
-		"timeSince": timeSince,
-		"urlEncode": url.QueryEscape,
+		"timeSince":       timeSince,
+		"urlEncode":       url.QueryEscape,
+		"prefixURL":       prefixURL,
+		"appName":         func() string { return version.Name },
+		"appAuthor":       func() string { return version.Author },
+		"appAuthorURL":    func() string { return version.AuthorURL },
+		"appLicense":      func() string { return version.License },
+		"appRepoURL":      func() string { return version.RepoURL },
+		"appGitRevision":  func() string { return version.GitRevisionShort },
+		"appGitCommitURL": func() string { return version.CommitURL() },
+	}
+
+	// Parse index template
+	defaultTemplates.Index, err = template.New("index").Funcs(funcs).Parse(indexHTML)
+	if err != nil {
+		panic("failed to parse index template: " + err.Error())
 	}
 
 	// Parse status template
-	defaultTemplates.Status, err = template.New("status").Parse(statusHTML)
+	defaultTemplates.Status, err = template.New("status").Funcs(funcs).Parse(statusHTML)
 	if err != nil {
 		panic("failed to parse status template: " + err.Error())
 	}
@@ -99,6 +144,12 @@ func initTemplates() {
 	if err != nil {
 		panic("failed to parse prefix detail template: " + err.Error())
 	}
+
+	// Parse prefix length template
+	defaultTemplates.PrefixLength, err = template.New("prefixLength").Funcs(funcs).Parse(prefixLengthHTML)
+	if err != nil {
+		panic("failed to parse prefix length template: " + err.Error())
+	}
 }
 
 // Get returns the singleton Templates instance
@@ -108,6 +159,11 @@ func Get() *Templates {
 	return defaultTemplates
 }
 
+// IndexTemplate returns the parsed index template
+func IndexTemplate() *template.Template {
+	return Get().Index
+}
+
 // StatusTemplate returns the parsed status template
 func StatusTemplate() *template.Template {
 	return Get().Status
@@ -122,3 +178,8 @@ func ASDetailTemplate() *template.Template {
 func PrefixDetailTemplate() *template.Template {
 	return Get().PrefixDetail
 }
+
+// PrefixLengthTemplate returns the parsed prefix length template
+func PrefixLengthTemplate() *template.Template {
+	return Get().PrefixLength
+}

internal/version/version.go

@@ -0,0 +1,34 @@
+// Package version provides build version information
+package version
+
+// Build-time variables set via ldflags
+//
+//nolint:gochecknoglobals // These must be variables to allow ldflags injection at build time
+var (
+	// GitRevision is the git commit hash
+	GitRevision = "unknown"
+	// GitRevisionShort is the short git commit hash (7 chars)
+	GitRevisionShort = "unknown"
+)
+
+const (
+	// Name is the program name
+	Name = "routewatch"
+	// Author is the program author
+	Author = "@sneak"
+	// AuthorURL is the author's website
+	AuthorURL = "https://sneak.berlin"
+	// License is the program license
+	License = "WTFPL"
+	// RepoURL is the git repository URL
+	RepoURL = "https://git.eeqj.de/sneak/routewatch"
+)
+
+// CommitURL returns the URL to view the current commit
+func CommitURL() string {
+	if GitRevision == "unknown" {
+		return RepoURL
+	}
+
+	return RepoURL + "/commit/" + GitRevision
+}

internal/whois/whois.go

@@ -0,0 +1,347 @@
+// Package whois provides WHOIS lookup functionality for ASN information.
+package whois
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"net"
+	"regexp"
+	"strings"
+	"time"
+)
+
+// Timeout constants for WHOIS queries.
+const (
+	dialTimeout  = 10 * time.Second
+	readTimeout  = 30 * time.Second
+	writeTimeout = 5 * time.Second
+)
+
+// Parsing constants.
+const (
+	keyValueParts       = 2 // Expected parts when splitting "key: value"
+	lacnicDateFormatLen = 8 // Length of YYYYMMDD date format
+)
+
+// WHOIS server addresses.
+const (
+	whoisServerIANA    = "whois.iana.org:43"
+	whoisServerARIN    = "whois.arin.net:43"
+	whoisServerRIPE    = "whois.ripe.net:43"
+	whoisServerAPNIC   = "whois.apnic.net:43"
+	whoisServerLACNIC  = "whois.lacnic.net:43"
+	whoisServerAFRINIC = "whois.afrinic.net:43"
+)
+
+// RIR identifiers.
+const (
+	RIRARIN   = "ARIN"
+	RIRRIPE   = "RIPE"
+	RIRAPNIC  = "APNIC"
+	RIRLACNIC = "LACNIC"
+	RIRAFRNIC = "AFRINIC"
+)
+
+// ASNInfo contains parsed WHOIS information for an ASN.
+type ASNInfo struct {
+	ASN         int
+	ASName      string
+	OrgName     string
+	OrgID       string
+	Address     string
+	CountryCode string
+	AbuseEmail  string
+	AbusePhone  string
+	TechEmail   string
+	TechPhone   string
+	RIR         string
+	RegDate     *time.Time
+	LastMod     *time.Time
+	RawResponse string
+}
+
+// Client performs WHOIS lookups for ASNs.
+type Client struct {
+	// Dialer for creating connections (can be overridden for testing)
+	dialer *net.Dialer
+}
+
+// NewClient creates a new WHOIS client.
+func NewClient() *Client {
+	return &Client{
+		dialer: &net.Dialer{
+			Timeout: dialTimeout,
+		},
+	}
+}
+
+// LookupASN queries WHOIS for the given ASN and returns parsed information.
+func (c *Client) LookupASN(ctx context.Context, asn int) (*ASNInfo, error) {
+	// Query IANA first to find the authoritative RIR
+	query := fmt.Sprintf("AS%d", asn)
+
+	ianaResp, err := c.query(ctx, whoisServerIANA, query)
+	if err != nil {
+		return nil, fmt.Errorf("IANA query failed: %w", err)
+	}
+
+	// Determine RIR from IANA response
+	rir, whoisServer := c.parseIANAReferral(ianaResp)
+	if whoisServer == "" {
+		// No referral, try to parse what we have
+		return c.parseResponse(asn, rir, ianaResp), nil
+	}
+
+	// Query the authoritative RIR
+	rirResp, err := c.query(ctx, whoisServer, query)
+	if err != nil {
+		// Return partial data from IANA if RIR query fails
+		info := c.parseResponse(asn, rir, ianaResp)
+		info.RawResponse = ianaResp + "\n--- RIR query failed: " + err.Error() + " ---\n"
+
+		return info, nil
+	}
+
+	// Combine responses and parse
+	fullResponse := ianaResp + "\n" + rirResp
+	info := c.parseResponse(asn, rir, fullResponse)
+	info.RawResponse = fullResponse
+
+	return info, nil
+}
+
+// query performs a raw WHOIS query to the specified server.
+func (c *Client) query(ctx context.Context, server, query string) (string, error) {
+	conn, err := c.dialer.DialContext(ctx, "tcp", server)
+	if err != nil {
+		return "", fmt.Errorf("dial %s: %w", server, err)
+	}
+	defer func() { _ = conn.Close() }()
+
+	// Set deadlines
+	if err := conn.SetWriteDeadline(time.Now().Add(writeTimeout)); err != nil {
+		return "", fmt.Errorf("set write deadline: %w", err)
+	}
+
+	// Send query
+	if _, err := fmt.Fprintf(conn, "%s\r\n", query); err != nil {
+		return "", fmt.Errorf("write query: %w", err)
+	}
+
+	// Read response
+	if err := conn.SetReadDeadline(time.Now().Add(readTimeout)); err != nil {
+		return "", fmt.Errorf("set read deadline: %w", err)
+	}
+
+	var sb strings.Builder
+	scanner := bufio.NewScanner(conn)
+	for scanner.Scan() {
+		sb.WriteString(scanner.Text())
+		sb.WriteString("\n")
+	}
+
+	if err := scanner.Err(); err != nil {
+		return sb.String(), fmt.Errorf("read response: %w", err)
+	}
+
+	return sb.String(), nil
+}
+
+// parseIANAReferral extracts the RIR and WHOIS server from an IANA response.
+func (c *Client) parseIANAReferral(response string) (rir, whoisServer string) {
+	lines := strings.Split(response, "\n")
+
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+
+		// Look for "refer:" line
+		if strings.HasPrefix(strings.ToLower(line), "refer:") {
+			server := strings.TrimSpace(strings.TrimPrefix(line, "refer:"))
+			server = strings.TrimSpace(strings.TrimPrefix(server, "Refer:"))
+
+			switch {
+			case strings.Contains(server, "arin"):
+				return RIRARIN, whoisServerARIN
+			case strings.Contains(server, "ripe"):
+				return RIRRIPE, whoisServerRIPE
+			case strings.Contains(server, "apnic"):
+				return RIRAPNIC, whoisServerAPNIC
+			case strings.Contains(server, "lacnic"):
+				return RIRLACNIC, whoisServerLACNIC
+			case strings.Contains(server, "afrinic"):
+				return RIRAFRNIC, whoisServerAFRINIC
+			default:
+				// Unknown server, add port if missing
+				if !strings.Contains(server, ":") {
+					server += ":43"
+				}
+
+				return "", server
+			}
+		}
+
+		// Also check organisation line for RIR hints
+		if strings.HasPrefix(strings.ToLower(line), "organisation:") {
+			org := strings.ToLower(line)
+			switch {
+			case strings.Contains(org, "arin"):
+				rir = RIRARIN
+			case strings.Contains(org, "ripe"):
+				rir = RIRRIPE
+			case strings.Contains(org, "apnic"):
+				rir = RIRAPNIC
+			case strings.Contains(org, "lacnic"):
+				rir = RIRLACNIC
+			case strings.Contains(org, "afrinic"):
+				rir = RIRAFRNIC
+			}
+		}
+	}
+
+	return rir, ""
+}
+
+// parseResponse extracts ASN information from a WHOIS response.
+func (c *Client) parseResponse(asn int, rir, response string) *ASNInfo {
+	info := &ASNInfo{
+		ASN:         asn,
+		RIR:         rir,
+		RawResponse: response,
+	}
+
+	lines := strings.Split(response, "\n")
+	var addressLines []string
+
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "%") || strings.HasPrefix(line, "#") {
+			continue
+		}
+
+		// Split on first colon
+		parts := strings.SplitN(line, ":", keyValueParts)
+		if len(parts) != keyValueParts {
+			continue
+		}
+
+		key := strings.TrimSpace(strings.ToLower(parts[0]))
+		value := strings.TrimSpace(parts[1])
+
+		if value == "" {
+			continue
+		}
+
+		switch key {
+		// AS Name (varies by RIR)
+		case "asname", "as-name":
+			if info.ASName == "" {
+				info.ASName = value
+			}
+
+		// Organization
+		case "orgname", "org-name", "owner":
+			if info.OrgName == "" {
+				info.OrgName = value
+			}
+		case "orgid", "org-id", "org":
+			if info.OrgID == "" {
+				info.OrgID = value
+			}
+
+		// Address (collect multiple lines)
+		case "address":
+			addressLines = append(addressLines, value)
+
+		// Country
+		case "country":
+			if info.CountryCode == "" && len(value) == 2 {
+				info.CountryCode = strings.ToUpper(value)
+			}
+
+		// Abuse contact
+		case "orgabuseemail", "abuse-mailbox":
+			if info.AbuseEmail == "" {
+				info.AbuseEmail = value
+			}
+		case "orgabusephone":
+			if info.AbusePhone == "" {
+				info.AbusePhone = value
+			}
+
+		// Tech contact
+		case "orgtechemail":
+			if info.TechEmail == "" {
+				info.TechEmail = value
+			}
+		case "orgtechphone":
+			if info.TechPhone == "" {
+				info.TechPhone = value
+			}
+
+		// Registration dates
+		case "regdate", "created":
+			if info.RegDate == nil {
+				info.RegDate = c.parseDate(value)
+			}
+		case "updated", "last-modified", "changed":
+			if info.LastMod == nil {
+				info.LastMod = c.parseDate(value)
+			}
+		}
+	}
+
+	// Combine address lines
+	if len(addressLines) > 0 {
+		info.Address = strings.Join(addressLines, "\n")
+	}
+
+	// Extract abuse email from comment lines (common in ARIN responses)
+	if info.AbuseEmail == "" {
+		info.AbuseEmail = c.extractAbuseEmail(response)
+	}
+
+	return info
+}
+
+// parseDate attempts to parse various date formats used in WHOIS responses.
+func (c *Client) parseDate(value string) *time.Time {
+	// Common formats
+	formats := []string{
+		"2006-01-02",
+		"2006-01-02T15:04:05Z",
+		"2006-01-02T15:04:05-07:00",
+		"20060102",
+		"02-Jan-2006",
+	}
+
+	// Clean up value
+	value = strings.TrimSpace(value)
+	// Handle "YYYYMMDD" format from LACNIC
+	if len(value) == lacnicDateFormatLen {
+		if _, err := time.Parse("20060102", value); err == nil {
+			t, _ := time.Parse("20060102", value)
+
+			return &t
+		}
+	}
+
+	for _, format := range formats {
+		if t, err := time.Parse(format, value); err == nil {
+			return &t
+		}
+	}
+
+	return nil
+}
+
+// extractAbuseEmail extracts abuse email from response using regex.
+func (c *Client) extractAbuseEmail(response string) string {
+	// Look for "Abuse contact for 'AS...' is 'email@domain'"
+	re := regexp.MustCompile(`[Aa]buse contact.*?is\s+['"]?([^\s'"]+@[^\s'"]+)['"]?`)
+	if matches := re.FindStringSubmatch(response); len(matches) > 1 {
+		return matches[1]
+	}
+
+	return ""
+}

script/bootstrap

@@ -0,0 +1,73 @@
+#!/bin/sh
+# script/bootstrap: install all dependencies needed to build and develop
+# this repo. Idempotent: every install is guarded by a check so already
+# installed tools are skipped. Base tooling comes from nix, apt, brew,
+# or apk (detected in that order); assumes NOTHING is present (not git,
+# make, or go).
+set -eu
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
+
+PKGMGR=""
+SUDO=""
+
+detect_pkgmgr() {
+    [ -n "$PKGMGR" ] && return 0
+    if command -v nix-env >/dev/null 2>&1; then
+        PKGMGR="nix"
+    elif command -v apt-get >/dev/null 2>&1; then
+        PKGMGR="apt"
+    elif command -v brew >/dev/null 2>&1; then
+        PKGMGR="brew"
+    elif command -v apk >/dev/null 2>&1; then
+        PKGMGR="apk"
+    else
+        echo "bootstrap: no supported package manager (nix, apt, brew, apk)" >&2
+        exit 1
+    fi
+    if [ "$PKGMGR" = "apt" ]; then
+        export DEBIAN_FRONTEND=noninteractive
+        if [ "$(id -u)" != "0" ]; then
+            SUDO="sudo"
+        fi
+    fi
+}
+
+# pkg_install <nix-attr> <apt-pkg> <brew-formula> <apk-pkg>
+pkg_install() {
+    detect_pkgmgr
+    case "$PKGMGR" in
+        nix) nix-env -iA "nixpkgs.$1" ;;
+        apt) $SUDO env DEBIAN_FRONTEND=noninteractive apt-get install -y "$2" ;;
+        brew) brew install "$3" ;;
+        apk) apk add --no-cache "$4" ;;
+    esac
+}
+
+missing() {
+    ! command -v "$1" >/dev/null 2>&1
+}
+
+main() {
+    cd "$ROOT"
+
+    # Base tooling (every repo)
+    if missing git; then pkg_install git git git git; fi
+    if missing make; then pkg_install gnumake make make make; fi
+
+    # Go toolchain
+    if missing go; then pkg_install go golang go go; fi
+
+    # golangci-lint: packaged in nix, brew, and apk. There is no apt
+    # package; on apt systems install it manually from a hash-verified
+    # GitHub release archive (never curl | sh).
+    if missing golangci-lint; then
+        pkg_install golangci-lint golangci-lint golangci-lint golangci-lint
+    fi
+
+    go mod download
+
+    echo "bootstrap complete"
+}
+
+main "$@"

script/check

@@ -0,0 +1,15 @@
+#!/bin/sh
+# script/check: run all checks (test, lint, fmt-check). Our own
+# extension to scripts-to-rule-them-all. Must not modify any files.
+# Generic: usually needs no adaptation.
+set -eu
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+
+main() {
+    "$SCRIPT_DIR/test"
+    "$SCRIPT_DIR/lint"
+    "$SCRIPT_DIR/fmt-check"
+}
+
+main "$@"

script/cibuild

@@ -0,0 +1,14 @@
+#!/bin/sh
+# script/cibuild: run the CI build. The Dockerfile runs script/check
+# (via make check), so a successful build implies all checks pass.
+# Generic: needs no adaptation. The Gitea workflow runs this on push.
+set -eu
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
+
+main() {
+    cd "$ROOT"
+    docker build .
+}
+
+main "$@"

script/docker

@@ -0,0 +1,15 @@
+#!/bin/sh
+# script/docker: build the Docker image tagged with the project name.
+# Identical in all repos; the tag comes from script/projectname.
+# Generic: needs no adaptation.
+set -eu
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
+
+main() {
+    cd "$ROOT"
+    docker build -t "$("$SCRIPT_DIR/projectname")" .
+}
+
+main "$@"

script/fmt

@@ -0,0 +1,12 @@
+#!/bin/sh
+# script/fmt: format all files (writes).
+set -eu
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
+
+main() {
+    cd "$ROOT"
+    go fmt ./...
+}
+
+main "$@"

script/fmt-check

@@ -0,0 +1,18 @@
+#!/bin/sh
+# script/fmt-check: check formatting (read-only). Same scope as
+# script/fmt, but fails instead of writing.
+set -eu
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
+
+main() {
+    cd "$ROOT"
+    unformatted="$(gofmt -l .)"
+    if [ -n "$unformatted" ]; then
+        echo "Files not formatted:" >&2
+        echo "$unformatted" >&2
+        exit 1
+    fi
+}
+
+main "$@"

script/install-precommit

@@ -0,0 +1,17 @@
+#!/bin/sh
+# script/install-precommit: install the git pre-commit hook that runs
+# script/precommit. Our own extension to scripts-to-rule-them-all.
+# Generic: needs no adaptation.
+set -eu
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
+
+main() {
+    cd "$ROOT"
+    hook=".git/hooks/pre-commit"
+    printf '#!/bin/sh\nset -e\nscript/precommit\n' > .git/hooks/pre-commit
+    chmod +x .git/hooks/pre-commit
+    echo "pre-commit hook installed: runs script/precommit"
+}
+
+main "$@"

script/lint

@@ -0,0 +1,13 @@
+#!/bin/sh
+# script/lint: run the linters.
+set -eu
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
+
+main() {
+    cd "$ROOT"
+    go vet ./...
+    golangci-lint run
+}
+
+main "$@"

script/precommit

@@ -0,0 +1,21 @@
+#!/bin/sh
+# script/precommit: run by the git pre-commit hook; fails the commit if
+# checks fail. Our own extension to scripts-to-rule-them-all. Go repo
+# extras: go mod tidy and go fmt must leave the tree unchanged.
+set -eu
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
+
+main() {
+    cd "$ROOT"
+    go mod tidy
+    go fmt ./...
+    git diff --exit-code -- go.mod go.sum || {
+        echo "go mod tidy changed files; please stage and retry"
+        exit 1
+    }
+    "$SCRIPT_DIR/check"
+}
+
+main "$@"

script/projectname

@@ -0,0 +1,12 @@
+#!/bin/sh
+# script/projectname: output the name of this project. Our own
+# extension to scripts-to-rule-them-all. Other scripts that need the
+# name (e.g. script/docker) call this, so they can stay identical
+# across all repos.
+set -eu
+
+main() {
+    echo "routewatch"
+}
+
+main "$@"

script/setup

@@ -0,0 +1,14 @@
+#!/bin/sh
+# script/setup: set up the repo for development after a fresh clone:
+# installs dependencies (script/bootstrap) and the git pre-commit hook.
+# Add any repo-specific initialization (db init, .env template) here.
+set -eu
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+
+main() {
+    "$SCRIPT_DIR/bootstrap"
+    "$SCRIPT_DIR/install-precommit"
+}
+
+main "$@"

script/test

@@ -0,0 +1,17 @@
+#!/bin/sh
+# script/test: run the test suite. On failure, rerun verbosely so the
+# failing tests are visible in the output.
+set -eu
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
+
+main() {
+    cd "$ROOT"
+    go test -timeout 30s -race -cover ./... || {
+        echo "--- Rerunning with -v for details ---"
+        go test -timeout 30s -race -v ./...
+        exit 1
+    }
+}
+
+main "$@"