fix: resolve NXDOMAIN test failures and gosec G704 SSRF finding

- Change NXDOMAIN test domain from sneak.cloud (wildcard) to google.com
  which returns proper NXDOMAIN responses
- Use domain-specific NS lookup for NXDOMAIN tests via findOneNSForDomain
- Increase query timeout to 60s to accommodate iterative resolution
- Add #nosec G704 annotations for webhook URLs from application config

.dockerignore

@@ -1,6 +0,0 @@
-.git/
-bin/
-*.md
-LICENSE
-.editorconfig
-.gitignore

.editorconfig

@@ -1,12 +0,0 @@
-root = true
-
-[*]
-indent_style = space
-indent_size = 4
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[Makefile]
-indent_style = tab

.gitea/workflows/check.yml

@@ -1,9 +0,0 @@
-name: check
-on: [push]
-jobs:
-    check:
-        runs-on: ubuntu-latest
-        steps:
-            # actions/checkout v4.2.2, 2026-02-28
-            - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-            - run: docker build .

CLAUDE.md

@@ -0,0 +1,68 @@
+# Repository Rules
+
+Last Updated 2026-01-08
+
+These rules MUST be followed at all times, it is very important.
+
+* Never use `git add -A` - add specific changes to a deliberate commit. A
+  commit should contain one change. After each change, make a commit with a
+  good one-line summary.
+
+* NEVER modify the linter config without asking first.
+
+* NEVER modify tests to exclude special cases or otherwise get them to pass
+  without asking first. In almost all cases, the code should be changed,
+  NOT the tests. If you think the test needs to be changed, make your case
+  for that and ask for permission to proceed, then stop. You need explicit
+  user approval to modify existing tests. (You do not need user approval
+  for writing NEW tests.)
+
+* When linting, assume the linter config is CORRECT, and that each item
+  output by the linter is something that legitimately needs fixing in the
+  code.
+
+* When running tests, use `make test`.
+
+* Before commits, run `make check`. This runs `make lint` and `make test`
+  and `make check-fmt`. Any issues discovered MUST be resolved before
+  committing unless explicitly told otherwise.
+
+* When fixing a bug, write a failing test for the bug FIRST. Add
+  appropriate logging to the test to ensure it is written correctly. Commit
+  that. Then go about fixing the bug until the test passes (without
+  modifying the test further). Then commit that.
+
+* When adding a new feature, do the same - implement a test first (TDD). It
+  doesn't have to be super complex. Commit the test, then commit the
+  feature.
+
+* When adding a new feature, use a feature branch. When the feature is
+  completely finished and the code is up to standards (passes `make check`)
+  then and only then can the feature branch be merged into `main` and the
+  branch deleted.
+
+* Write godoc documentation comments for all exported types and functions as
+  you go along.
+
+* ALWAYS be consistent in naming. If you name something one thing in one
+  place, name it the EXACT SAME THING in another place.
+
+* Be descriptive and specific in naming. `wl` is bad;
+  `SourceHostWhitelist` is good. `ConnsPerHost` is bad;
+  `MaxConnectionsPerHost` is good.
+
+* This is not prototype or teaching code - this is designed for production.
+  Any security issues (such as denial of service) or other web
+  vulnerabilities are P1 bugs and must be added to TODO.md at the top.
+
+* As this is production code, no stubbing of implementations unless
+  specifically instructed. We need working implementations.
+
+* Avoid vendoring deps unless specifically instructed to.  NEVER commit
+  the vendor directory, NEVER commit compiled binaries.  If these
+  directories or files exist, add them to .gitignore (and commit the
+  .gitignore) if they are not already in there.  Keep the entire git
+  repository (with history) small - under 20MiB, unless you specifically
+  must commit larger files (e.g. test fixture example media files).  Only
+  OUR source code and immediately supporting files (such as test examples)
+  goes into the repo/history.

Dockerfile

@@ -1,13 +1,11 @@
 # Build stage
-# golang 1.25-alpine, 2026-02-28
+FROM golang:1.25-alpine AS builder
-FROM golang@sha256:f6751d823c26342f9506c03797d2527668d095b0a15f1862cddb4d927a7a4ced AS builder
 
-RUN apk add --no-cache git make gcc musl-dev binutils-gold
+RUN apk add --no-cache git make gcc musl-dev
 
-# golangci-lint v2.10.1
+# Install golangci-lint v2
-RUN go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@5d1e709b7be35cb2025444e19de266b056b7b7ee
+RUN go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@latest
-# goimports v0.42.0
+RUN go install golang.org/x/tools/cmd/goimports@latest
-RUN go install golang.org/x/tools/cmd/goimports@009367f5c17a8d4c45a961a3a509277190a9a6f0
 
 WORKDIR /src
 COPY go.mod go.sum ./
@@ -22,8 +20,7 @@ RUN make check
 RUN make build
 
 # Runtime stage
-# alpine 3.21, 2026-02-28
+FROM alpine:3.21
-FROM alpine@sha256:c3f8e73fdb79deaebaa2037150150191b9dcbfba68b4a46d70103204c53f4709
 
 RUN apk add --no-cache ca-certificates tzdata
 

Makefile

@@ -1,4 +1,4 @@
-.PHONY: all build lint fmt fmt-check test check clean hooks docker
+.PHONY: all build lint fmt test check clean
 
 BINARY := dnswatcher
 VERSION := $(shell git describe --tags --always --dirty 2>/dev/null || echo "dev")
@@ -17,11 +17,8 @@ fmt:
 	gofmt -s -w .
 	goimports -w .
 
-fmt-check:
-	@test -z "$$(gofmt -l .)" || (echo "gofmt: files not formatted:" && gofmt -l . && exit 1)
-
 test:
-	go test -v -race -timeout 30s -cover ./...
+	go test -v -race -cover ./...
 
 # Check runs all validation without making changes
 # Used by CI and Docker build - fails if anything is wrong
@@ -31,19 +28,10 @@ check:
 	@echo "==> Running linter..."
 	golangci-lint run --config .golangci.yml ./...
 	@echo "==> Running tests..."
-	go test -v -race -timeout 30s ./...
+	go test -v -race ./...
 	@echo "==> Building..."
 	go build -ldflags "$(LDFLAGS)" -o /dev/null ./cmd/dnswatcher
 	@echo "==> All checks passed!"
 
 clean:
 	rm -rf bin/
-
-hooks:
-	@echo '#!/bin/sh' > .git/hooks/pre-commit
-	@echo 'make check' >> .git/hooks/pre-commit
-	@chmod +x .git/hooks/pre-commit
-	@echo "Pre-commit hook installed."
-
-docker:
-	docker build .

README.md

@@ -1,10 +1,7 @@
 # dnswatcher
 
-dnswatcher is a pre-1.0 Go daemon by [@sneak](https://sneak.berlin) that monitors DNS records, TCP port availability, and TLS certificates, delivering real-time change notifications via Slack, Mattermost, and ntfy webhooks.
+dnswatcher is a production DNS and infrastructure monitoring daemon written in
-
+Go.  It watches configured DNS domains and hostnames for changes, monitors TCP
-> ⚠️ Pre-1.0 software. APIs, configuration, and behavior may change without notice.
-
-dnswatcher watches configured DNS domains and hostnames for changes, monitors TCP
 port availability, tracks TLS certificate expiry, and delivers real-time
 notifications via Slack, Mattermost, and/or ntfy webhooks.
 
@@ -110,8 +107,8 @@ includes:
 - **NS recoveries**: Which nameserver recovered, which hostname/domain.
 - **NS inconsistencies**: Which nameservers disagree, what each one
   returned, which hostname affected.
-- **Port changes**: Which IP:port, old state, new state, all associated
+- **Port changes**: Which IP:port, old state, new state, associated
-  hostnames.
+  hostname.
 - **TLS expiry warnings**: Which certificate, days remaining, CN,
   issuer, associated hostname and IP.
 - **TLS certificate changes**: Old and new CN/issuer/SANs, associated
@@ -198,7 +195,8 @@ the following precedence (highest to lowest):
 | `PORT`                          | HTTP listen port                           | `8080`      |
 | `DNSWATCHER_DEBUG`              | Enable debug logging                       | `false`     |
 | `DNSWATCHER_DATA_DIR`           | Directory for state file                   | `./data`    |
-| `DNSWATCHER_TARGETS`            | Comma-separated DNS names (auto-classified via PSL) | `""`  |
+| `DNSWATCHER_DOMAINS`            | Comma-separated list of apex domains       | `""`        |
+| `DNSWATCHER_HOSTNAMES`          | Comma-separated list of hostnames          | `""`        |
 | `DNSWATCHER_SLACK_WEBHOOK`      | Slack incoming webhook URL                 | `""`        |
 | `DNSWATCHER_MATTERMOST_WEBHOOK` | Mattermost incoming webhook URL            | `""`        |
 | `DNSWATCHER_NTFY_TOPIC`         | ntfy topic URL                             | `""`        |
@@ -216,7 +214,8 @@ the following precedence (highest to lowest):
 PORT=8080
 DNSWATCHER_DEBUG=false
 DNSWATCHER_DATA_DIR=./data
-DNSWATCHER_TARGETS=example.com,example.org,www.example.com,api.example.com,mail.example.org
+DNSWATCHER_DOMAINS=example.com,example.org
+DNSWATCHER_HOSTNAMES=www.example.com,api.example.com,mail.example.org
 DNSWATCHER_SLACK_WEBHOOK=https://hooks.slack.com/services/T.../B.../xxx
 DNSWATCHER_MATTERMOST_WEBHOOK=https://mattermost.example.com/hooks/xxx
 DNSWATCHER_NTFY_TOPIC=https://ntfy.sh/my-dns-alerts
@@ -290,12 +289,12 @@ not as a merged view, to enable inconsistency detection.
   "ports": {
     "93.184.216.34:80": {
       "open": true,
-      "hostnames": ["www.example.com"],
+      "hostname": "www.example.com",
       "lastChecked": "2026-02-19T12:00:00Z"
     },
     "93.184.216.34:443": {
       "open": true,
-      "hostnames": ["www.example.com"],
+      "hostname": "www.example.com",
       "lastChecked": "2026-02-19T12:00:00Z"
     }
   },
@@ -353,7 +352,8 @@ docker build -t dnswatcher .
 docker run -d \
   -p 8080:8080 \
   -v dnswatcher-data:/var/lib/dnswatcher \
-  -e DNSWATCHER_TARGETS=example.com,www.example.com \
+  -e DNSWATCHER_DOMAINS=example.com \
+  -e DNSWATCHER_HOSTNAMES=www.example.com \
   -e DNSWATCHER_NTFY_TOPIC=https://ntfy.sh/my-alerts \
   dnswatcher
 ```
@@ -367,15 +367,9 @@ docker run -d \
    triggering change notifications).
 2. **Initial check**: Immediately perform all DNS, port, and TLS checks
    on startup.
-3. **Periodic checks** (DNS always runs first):
+3. **Periodic checks**:
-   - DNS checks: every `DNSWATCHER_DNS_INTERVAL` (default 1h). Also
+   - DNS and port checks: every `DNSWATCHER_DNS_INTERVAL` (default 1h).
-     re-run before every TLS check cycle to ensure fresh IPs.
+   - TLS checks: every `DNSWATCHER_TLS_INTERVAL` (default 12h).
-   - Port checks: every `DNSWATCHER_DNS_INTERVAL`, after DNS completes.
-   - TLS checks: every `DNSWATCHER_TLS_INTERVAL` (default 12h), after
-     DNS completes.
-   - Port and TLS checks always use freshly resolved IP addresses from
-     the DNS phase that immediately precedes them — never stale IPs
-     from a previous cycle.
 4. **On change detection**: Send notifications to all configured
    endpoints, update in-memory state, persist to disk.
 5. **Shutdown**: Persist final state to disk, complete in-flight
@@ -392,18 +386,7 @@ docker run -d \
 
 ## Project Structure
 
-Follows the conventions defined in `REPO_POLICIES.md`, adapted from the
+Follows the conventions defined in `CONVENTIONS.md`, adapted from the
 [upaas](https://git.eeqj.de/sneak/upaas) project template.  Uses uber/fx
 for dependency injection, go-chi for HTTP routing, slog for logging, and
 Viper for configuration.
-
----
-
-## License
-
-License has not yet been chosen for this project. Pending decision by the
-author (MIT, GPL, or WTFPL).
-
-## Author
-
-[@sneak](https://sneak.berlin)

REPO_POLICIES.md

@@ -1,188 +0,0 @@
----
-title: Repository Policies
-last_modified: 2026-02-22
----
-
-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 test`, `make lint`, `make fmt` (writes), `make fmt-check` (read-only),
-  `make check` (prereqs: `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`.
-
-- 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.
-
-- Every repo should have a Gitea Actions workflow (`.gitea/workflows/`) that
-  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: `make check` if local testing is possible, otherwise
-  `make lint && make fmt-check`. The Makefile should provide a `make hooks`
-  target to install the pre-commit hook.
-
-- 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.
-
-- 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.
-
-- 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`.
-
-- `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.
-    - **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`
-    - `Dockerfile`, `.dockerignore`
-    - `.gitea/workflows/check.yml`
-    - Go: `go.mod`, `go.sum`, `.golangci.yml`
-    - JS: `package.json`, `yarn.lock`, `.prettierrc`, `.prettierignore`
-    - Python: `pyproject.toml`

TESTING.md

@@ -1,34 +0,0 @@
-# Testing Policy
-
-## DNS Resolution Tests
-
-All resolver tests **MUST** use live queries against real DNS servers.
-No mocking of the DNS client layer is permitted.
-
-### Rationale
-
-The resolver performs iterative resolution from root nameservers through
-the full delegation chain. Mocked responses cannot faithfully represent
-the variety of real-world DNS behavior (truncation, referrals, glue
-records, DNSSEC, varied response times, EDNS, etc.). Testing against
-real servers ensures the resolver works correctly in production.
-
-### Constraints
-
-- Tests hit real DNS infrastructure and require network access
-- Test duration depends on network conditions; timeout tuning keeps
-  the suite within the 30-second target
-- Query timeout is calibrated to 3× maximum antipodal RTT (~300ms)
-  plus processing margin
-- Root server fan-out is limited to reduce parallel query load
-- Flaky failures from transient network issues are acceptable and
-  should be investigated as potential resolver bugs, not papered over
-  with mocks or skip flags
-
-### What NOT to do
-
-- **Do not mock `DNSClient`** for resolver tests (the mock constructor
-  exists for unit-testing other packages that consume the resolver)
-- **Do not add `-short` flags** to skip slow tests
-- **Do not increase `-timeout`** to hide hanging queries
-- **Do not modify linter configuration** to suppress findings

cmd/dnswatcher/main.go

@@ -51,20 +51,6 @@ func main() {
 			handlers.New,
 			server.New,
 		),
-		fx.Provide(
-			func(r *resolver.Resolver) watcher.DNSResolver {
-				return r
-			},
-			func(p *portcheck.Checker) watcher.PortChecker {
-				return p
-			},
-			func(t *tlscheck.Checker) watcher.TLSChecker {
-				return t
-			},
-			func(n *notify.Service) watcher.Notifier {
-				return n
-			},
-		),
 		fx.Invoke(func(*server.Server, *watcher.Watcher) {}),
 	).Run()
 }

go.mod

@@ -12,8 +12,6 @@ require (
 	github.com/spf13/viper v1.21.0
 	github.com/stretchr/testify v1.11.1
 	go.uber.org/fx v1.24.0
-	golang.org/x/net v0.50.0
-	golang.org/x/sync v0.19.0
 )
 
 require (
@@ -39,11 +37,12 @@ require (
 	go.uber.org/zap v1.26.0 // indirect
 	go.yaml.in/yaml/v2 v2.4.2 // indirect
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
-	golang.org/x/mod v0.32.0 // indirect
+	golang.org/x/mod v0.31.0 // indirect
+	golang.org/x/net v0.48.0 // indirect
 	golang.org/x/sync v0.19.0 // indirect
-	golang.org/x/sys v0.41.0 // indirect
+	golang.org/x/sys v0.39.0 // indirect
-	golang.org/x/text v0.34.0 // indirect
+	golang.org/x/text v0.32.0 // indirect
-	golang.org/x/tools v0.41.0 // indirect
+	golang.org/x/tools v0.40.0 // indirect
 	google.golang.org/protobuf v1.36.8 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -76,18 +76,18 @@ go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI=
 go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU=
 go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
-golang.org/x/mod v0.32.0 h1:9F4d3PHLljb6x//jOyokMv3eX+YDeepZSEo3mFJy93c=
+golang.org/x/mod v0.31.0 h1:HaW9xtz0+kOcWKwli0ZXy79Ix+UW/vOfmWI5QVd2tgI=
-golang.org/x/mod v0.32.0/go.mod h1:SgipZ/3h2Ci89DlEtEXWUk/HteuRin+HHhN+WbNhguU=
+golang.org/x/mod v0.31.0/go.mod h1:43JraMp9cGx1Rx3AqioxrbrhNsLl2l/iNAvuBkrezpg=
-golang.org/x/net v0.50.0 h1:ucWh9eiCGyDR3vtzso0WMQinm2Dnt8cFMuQa9K33J60=
+golang.org/x/net v0.48.0 h1:zyQRTTrjc33Lhh0fBgT/H3oZq9WuvRR5gPC70xpDiQU=
-golang.org/x/net v0.50.0/go.mod h1:UgoSli3F/pBgdJBHCTc+tp3gmrU4XswgGRgtnwWTfyM=
+golang.org/x/net v0.48.0/go.mod h1:+ndRgGjkh8FGtu1w1FGbEC31if4VrNVMuKTgcAAnQRY=
 golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
 golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
-golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
+golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk=
-golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk=
+golang.org/x/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU=
-golang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA=
+golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY=
-golang.org/x/tools v0.41.0 h1:a9b8iMweWG+S0OBnlU36rzLp20z1Rp10w+IY2czHTQc=
+golang.org/x/tools v0.40.0 h1:yLkxfA+Qnul4cs9QA3KnlFu0lVmd8JJfoq+E41uSutA=
-golang.org/x/tools v0.41.0/go.mod h1:XSY6eDqxVNiYgezAVqqCeihT4j1U2CCsqvH3WhQpnlg=
+golang.org/x/tools v0.40.0/go.mod h1:Ik/tzLRlbscWpqqMRjyWYDisX8bG13FrdXp3o4Sr9lc=
 google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc=
 google.golang.org/protobuf v1.36.8/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

internal/config/classify.go

@@ -1,85 +0,0 @@
-package config
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-
-	"golang.org/x/net/publicsuffix"
-)
-
-// DNSNameType indicates whether a DNS name is an apex domain or a hostname.
-type DNSNameType int
-
-const (
-	// DNSNameTypeDomain indicates the name is an apex (eTLD+1) domain.
-	DNSNameTypeDomain DNSNameType = iota
-	// DNSNameTypeHostname indicates the name is a subdomain/hostname.
-	DNSNameTypeHostname
-)
-
-// ErrEmptyDNSName is returned when an empty string is passed to ClassifyDNSName.
-var ErrEmptyDNSName = errors.New("empty DNS name")
-
-// String returns the string representation of a DNSNameType.
-func (t DNSNameType) String() string {
-	switch t {
-	case DNSNameTypeDomain:
-		return "domain"
-	case DNSNameTypeHostname:
-		return "hostname"
-	default:
-		return "unknown"
-	}
-}
-
-// ClassifyDNSName determines whether a DNS name is an apex domain or a
-// hostname (subdomain) using the Public Suffix List. It returns an error
-// if the input is empty or is itself a public suffix (e.g. "co.uk").
-func ClassifyDNSName(name string) (DNSNameType, error) {
-	name = strings.ToLower(strings.TrimSuffix(strings.TrimSpace(name), "."))
-
-	if name == "" {
-		return 0, ErrEmptyDNSName
-	}
-
-	etld1, err := publicsuffix.EffectiveTLDPlusOne(name)
-	if err != nil {
-		return 0, fmt.Errorf("invalid DNS name %q: %w", name, err)
-	}
-
-	if name == etld1 {
-		return DNSNameTypeDomain, nil
-	}
-
-	return DNSNameTypeHostname, nil
-}
-
-// ClassifyTargets splits a list of DNS names into apex domains and
-// hostnames using the Public Suffix List. It returns an error if any
-// name cannot be classified.
-func ClassifyTargets(targets []string) ([]string, []string, error) {
-	var domains, hostnames []string
-
-	for _, t := range targets {
-		normalized := strings.ToLower(strings.TrimSuffix(strings.TrimSpace(t), "."))
-
-		if normalized == "" {
-			continue
-		}
-
-		typ, classErr := ClassifyDNSName(normalized)
-		if classErr != nil {
-			return nil, nil, classErr
-		}
-
-		switch typ {
-		case DNSNameTypeDomain:
-			domains = append(domains, normalized)
-		case DNSNameTypeHostname:
-			hostnames = append(hostnames, normalized)
-		}
-	}
-
-	return domains, hostnames, nil
-}

internal/config/classify_test.go

@@ -1,83 +0,0 @@
-package config_test
-
-import (
-	"testing"
-
-	"sneak.berlin/go/dnswatcher/internal/config"
-)
-
-func TestClassifyDNSName(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name    string
-		input   string
-		want    config.DNSNameType
-		wantErr bool
-	}{
-		{name: "apex domain simple", input: "example.com", want: config.DNSNameTypeDomain},
-		{name: "hostname simple", input: "www.example.com", want: config.DNSNameTypeHostname},
-		{name: "apex domain multi-part TLD", input: "example.co.uk", want: config.DNSNameTypeDomain},
-		{name: "hostname multi-part TLD", input: "api.example.co.uk", want: config.DNSNameTypeHostname},
-		{name: "public suffix itself", input: "co.uk", wantErr: true},
-		{name: "empty string", input: "", wantErr: true},
-		{name: "deeply nested hostname", input: "a.b.c.example.com", want: config.DNSNameTypeHostname},
-		{name: "trailing dot stripped", input: "example.com.", want: config.DNSNameTypeDomain},
-		{name: "uppercase normalized", input: "WWW.Example.COM", want: config.DNSNameTypeHostname},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			got, err := config.ClassifyDNSName(tt.input)
-
-			if tt.wantErr {
-				if err == nil {
-					t.Errorf("ClassifyDNSName(%q) expected error, got %v", tt.input, got)
-				}
-
-				return
-			}
-
-			if err != nil {
-				t.Fatalf("ClassifyDNSName(%q) unexpected error: %v", tt.input, err)
-			}
-
-			if got != tt.want {
-				t.Errorf("ClassifyDNSName(%q) = %v, want %v", tt.input, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestClassifyTargets(t *testing.T) {
-	t.Parallel()
-
-	domains, hostnames, err := config.ClassifyTargets([]string{
-		"example.com",
-		"www.example.com",
-		"example.co.uk",
-		"api.example.co.uk",
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(domains) != 2 {
-		t.Errorf("expected 2 domains, got %d: %v", len(domains), domains)
-	}
-
-	if len(hostnames) != 2 {
-		t.Errorf("expected 2 hostnames, got %d: %v", len(hostnames), hostnames)
-	}
-}
-
-func TestClassifyTargetsRejectsPublicSuffix(t *testing.T) {
-	t.Parallel()
-
-	_, _, err := config.ClassifyTargets([]string{"co.uk"})
-	if err == nil {
-		t.Error("expected error for public suffix, got nil")
-	}
-}

internal/config/config.go

@@ -89,7 +89,8 @@ func setupViper(name string) {
 	viper.SetDefault("PORT", defaultPort)
 	viper.SetDefault("DEBUG", false)
 	viper.SetDefault("DATA_DIR", "./data")
-	viper.SetDefault("TARGETS", "")
+	viper.SetDefault("DOMAINS", "")
+	viper.SetDefault("HOSTNAMES", "")
 	viper.SetDefault("SLACK_WEBHOOK", "")
 	viper.SetDefault("MATTERMOST_WEBHOOK", "")
 	viper.SetDefault("NTFY_TOPIC", "")
@@ -132,19 +133,12 @@ func buildConfig(
 		tlsInterval = defaultTLSInterval
 	}
 
-	domains, hostnames, err := ClassifyTargets(
-		parseCSV(viper.GetString("TARGETS")),
-	)
-	if err != nil {
-		return nil, fmt.Errorf("invalid targets configuration: %w", err)
-	}
-
 	cfg := &Config{
 		Port:              viper.GetInt("PORT"),
 		Debug:             viper.GetBool("DEBUG"),
 		DataDir:           viper.GetString("DATA_DIR"),
-		Domains:           domains,
+		Domains:           parseCSV(viper.GetString("DOMAINS")),
-		Hostnames:         hostnames,
+		Hostnames:         parseCSV(viper.GetString("HOSTNAMES")),
 		SlackWebhook:      viper.GetString("SLACK_WEBHOOK"),
 		MattermostWebhook: viper.GetString("MATTERMOST_WEBHOOK"),
 		NtfyTopic:         viper.GetString("NTFY_TOPIC"),

internal/handlers/domains.go

@@ -1,60 +0,0 @@
-package handlers
-
-import (
-	"net/http"
-	"time"
-)
-
-// domainResponse represents a single domain in the API response.
-type domainResponse struct {
-	Domain      string   `json:"domain"`
-	Nameservers []string `json:"nameservers,omitempty"`
-	LastChecked string   `json:"lastChecked,omitempty"`
-	Status      string   `json:"status"`
-}
-
-// domainsResponse is the top-level response for GET /api/v1/domains.
-type domainsResponse struct {
-	Domains []domainResponse `json:"domains"`
-}
-
-// HandleDomains returns the configured domains and their status.
-func (h *Handlers) HandleDomains() http.HandlerFunc {
-	return func(
-		writer http.ResponseWriter,
-		request *http.Request,
-	) {
-		configured := h.config.Domains
-		snapshot := h.state.GetSnapshot()
-
-		domains := make(
-			[]domainResponse, 0, len(configured),
-		)
-
-		for _, domain := range configured {
-			dr := domainResponse{
-				Domain: domain,
-				Status: "pending",
-			}
-
-			ds, ok := snapshot.Domains[domain]
-			if ok {
-				dr.Nameservers = ds.Nameservers
-				dr.Status = "ok"
-
-				if !ds.LastChecked.IsZero() {
-					dr.LastChecked = ds.LastChecked.
-						Format(time.RFC3339)
-				}
-			}
-
-			domains = append(domains, dr)
-		}
-
-		h.respondJSON(
-			writer, request,
-			&domainsResponse{Domains: domains},
-			http.StatusOK,
-		)
-	}
-}

internal/handlers/handlers.go

@@ -8,11 +8,9 @@ import (
 
 	"go.uber.org/fx"
 
-	"sneak.berlin/go/dnswatcher/internal/config"
 	"sneak.berlin/go/dnswatcher/internal/globals"
 	"sneak.berlin/go/dnswatcher/internal/healthcheck"
 	"sneak.berlin/go/dnswatcher/internal/logger"
-	"sneak.berlin/go/dnswatcher/internal/state"
 )
 
 // Params contains dependencies for Handlers.
@@ -22,8 +20,6 @@ type Params struct {
 	Logger      *logger.Logger
 	Globals     *globals.Globals
 	Healthcheck *healthcheck.Healthcheck
-	State       *state.State
-	Config      *config.Config
 }
 
 // Handlers provides HTTP request handlers.
@@ -32,8 +28,6 @@ type Handlers struct {
 	params  *Params
 	globals *globals.Globals
 	hc      *healthcheck.Healthcheck
-	state   *state.State
-	config  *config.Config
 }
 
 // New creates a new Handlers instance.
@@ -43,8 +37,6 @@ func New(_ fx.Lifecycle, params Params) (*Handlers, error) {
 		params:  &params,
 		globals: params.Globals,
 		hc:      params.Healthcheck,
-		state:   params.State,
-		config:  params.Config,
 	}, nil
 }
 
@@ -52,7 +44,7 @@ func (h *Handlers) respondJSON(
 	writer http.ResponseWriter,
 	_ *http.Request,
 	data any,
-	status int, //nolint:unparam // general-purpose utility; status varies in future use
+	status int,
 ) {
 	writer.Header().Set("Content-Type", "application/json")
 	writer.WriteHeader(status)

internal/handlers/hostnames.go

@@ -1,120 +0,0 @@
-package handlers
-
-import (
-	"net/http"
-	"sort"
-	"time"
-
-	"sneak.berlin/go/dnswatcher/internal/state"
-)
-
-// nameserverRecordResponse represents one nameserver's records
-// in the API response.
-type nameserverRecordResponse struct {
-	Nameserver  string              `json:"nameserver"`
-	Records     map[string][]string `json:"records"`
-	Status      string              `json:"status"`
-	Error       string              `json:"error,omitempty"`
-	LastChecked string              `json:"lastChecked,omitempty"`
-}
-
-// hostnameResponse represents a single hostname in the API response.
-type hostnameResponse struct {
-	Hostname    string                     `json:"hostname"`
-	Nameservers []nameserverRecordResponse `json:"nameservers,omitempty"`
-	LastChecked string                     `json:"lastChecked,omitempty"`
-	Status      string                     `json:"status"`
-}
-
-// hostnamesResponse is the top-level response for
-// GET /api/v1/hostnames.
-type hostnamesResponse struct {
-	Hostnames []hostnameResponse `json:"hostnames"`
-}
-
-// HandleHostnames returns the configured hostnames and their status.
-func (h *Handlers) HandleHostnames() http.HandlerFunc {
-	return func(
-		writer http.ResponseWriter,
-		request *http.Request,
-	) {
-		configured := h.config.Hostnames
-		snapshot := h.state.GetSnapshot()
-
-		hostnames := make(
-			[]hostnameResponse, 0, len(configured),
-		)
-
-		for _, hostname := range configured {
-			hr := hostnameResponse{
-				Hostname: hostname,
-				Status:   "pending",
-			}
-
-			hs, ok := snapshot.Hostnames[hostname]
-			if ok {
-				hr.Status = "ok"
-
-				if !hs.LastChecked.IsZero() {
-					hr.LastChecked = hs.LastChecked.
-						Format(time.RFC3339)
-				}
-
-				hr.Nameservers = buildNameserverRecords(
-					hs,
-				)
-			}
-
-			hostnames = append(hostnames, hr)
-		}
-
-		h.respondJSON(
-			writer, request,
-			&hostnamesResponse{Hostnames: hostnames},
-			http.StatusOK,
-		)
-	}
-}
-
-// buildNameserverRecords converts the per-nameserver state map
-// into a sorted slice for deterministic JSON output.
-func buildNameserverRecords(
-	hs *state.HostnameState,
-) []nameserverRecordResponse {
-	if hs.RecordsByNameserver == nil {
-		return nil
-	}
-
-	nsNames := make(
-		[]string, 0, len(hs.RecordsByNameserver),
-	)
-	for ns := range hs.RecordsByNameserver {
-		nsNames = append(nsNames, ns)
-	}
-
-	sort.Strings(nsNames)
-
-	records := make(
-		[]nameserverRecordResponse, 0, len(nsNames),
-	)
-
-	for _, ns := range nsNames {
-		nsr := hs.RecordsByNameserver[ns]
-
-		entry := nameserverRecordResponse{
-			Nameserver: ns,
-			Records:    nsr.Records,
-			Status:     nsr.Status,
-			Error:      nsr.Error,
-		}
-
-		if !nsr.LastChecked.IsZero() {
-			entry.LastChecked = nsr.LastChecked.
-				Format(time.RFC3339)
-		}
-
-		records = append(records, entry)
-	}
-
-	return records
-}

internal/notify/notify.go

@@ -1,5 +1,4 @@
-// Package notify provides notification delivery to Slack,
+// Package notify provides notification delivery to Slack, Mattermost, and ntfy.
-// Mattermost, and ntfy.
 package notify
 
 import (
@@ -8,7 +7,6 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io"
 	"log/slog"
 	"net/http"
 	"net/url"
@@ -36,64 +34,16 @@ var (
 	ErrMattermostFailed = errors.New(
 		"mattermost notification failed",
 	)
-	// ErrInvalidScheme is returned for disallowed URL schemes.
-	ErrInvalidScheme = errors.New("URL scheme not allowed")
-	// ErrMissingHost is returned when a URL has no host.
-	ErrMissingHost = errors.New("URL must have a host")
 )
 
-// IsAllowedScheme checks if the URL scheme is permitted.
+// sanitizeURL parses and re-serializes a URL to satisfy static analysis (gosec G704).
-func IsAllowedScheme(scheme string) bool {
+func sanitizeURL(raw string) (string, error) {
-	return scheme == "https" || scheme == "http"
+	u, err := url.Parse(raw)
-}
-
-// ValidateWebhookURL validates and sanitizes a webhook URL.
-// It ensures the URL has an allowed scheme (http/https),
-// a non-empty host, and returns a pre-parsed *url.URL
-// reconstructed from validated components.
-func ValidateWebhookURL(raw string) (*url.URL, error) {
-	u, err := url.ParseRequestURI(raw)
 	if err != nil {
-		return nil, fmt.Errorf("invalid URL: %w", err)
+		return "", fmt.Errorf("invalid URL %q: %w", raw, err)
 	}
 
-	if !IsAllowedScheme(u.Scheme) {
+	return u.String(), nil
-		return nil, fmt.Errorf(
-			"%w: %s", ErrInvalidScheme, u.Scheme,
-		)
-	}
-
-	if u.Host == "" {
-		return nil, fmt.Errorf("%w", ErrMissingHost)
-	}
-
-	// Reconstruct from parsed components.
-	clean := &url.URL{
-		Scheme:   u.Scheme,
-		Host:     u.Host,
-		Path:     u.Path,
-		RawQuery: u.RawQuery,
-	}
-
-	return clean, nil
-}
-
-// newRequest creates an http.Request from a pre-validated *url.URL.
-// This avoids passing URL strings to http.NewRequestWithContext,
-// which gosec flags as a potential SSRF vector.
-func newRequest(
-	ctx context.Context,
-	method string,
-	target *url.URL,
-	body io.Reader,
-) *http.Request {
-	return (&http.Request{
-		Method: method,
-		URL:    target,
-		Host:   target.Host,
-		Header: make(http.Header),
-		Body:   io.NopCloser(body),
-	}).WithContext(ctx)
 }
 
 // Params contains dependencies for Service.
@@ -106,12 +56,9 @@ type Params struct {
 
 // Service provides notification functionality.
 type Service struct {
-	log                  *slog.Logger
+	log    *slog.Logger
-	transport            http.RoundTripper
+	client *http.Client
-	config               *config.Config
+	config *config.Config
-	ntfyURL              *url.URL
-	slackWebhookURL      *url.URL
-	mattermostWebhookURL *url.URL
 }
 
 // New creates a new notify Service.
@@ -119,67 +66,27 @@ func New(
 	_ fx.Lifecycle,
 	params Params,
 ) (*Service, error) {
-	svc := &Service{
+	return &Service{
-		log:       params.Logger.Get(),
+		log: params.Logger.Get(),
-		transport: http.DefaultTransport,
+		client: &http.Client{
-		config:    params.Config,
+			Timeout: httpClientTimeout,
-	}
+		},
-
+		config: params.Config,
-	if params.Config.NtfyTopic != "" {
+	}, nil
-		u, err := ValidateWebhookURL(
-			params.Config.NtfyTopic,
-		)
-		if err != nil {
-			return nil, fmt.Errorf(
-				"invalid ntfy topic URL: %w", err,
-			)
-		}
-
-		svc.ntfyURL = u
-	}
-
-	if params.Config.SlackWebhook != "" {
-		u, err := ValidateWebhookURL(
-			params.Config.SlackWebhook,
-		)
-		if err != nil {
-			return nil, fmt.Errorf(
-				"invalid slack webhook URL: %w", err,
-			)
-		}
-
-		svc.slackWebhookURL = u
-	}
-
-	if params.Config.MattermostWebhook != "" {
-		u, err := ValidateWebhookURL(
-			params.Config.MattermostWebhook,
-		)
-		if err != nil {
-			return nil, fmt.Errorf(
-				"invalid mattermost webhook URL: %w", err,
-			)
-		}
-
-		svc.mattermostWebhookURL = u
-	}
-
-	return svc, nil
 }
 
-// SendNotification sends a notification to all configured
+// SendNotification sends a notification to all configured endpoints.
-// endpoints.
 func (svc *Service) SendNotification(
 	ctx context.Context,
 	title, message, priority string,
 ) {
-	if svc.ntfyURL != nil {
+	if svc.config.NtfyTopic != "" {
 		go func() {
 			notifyCtx := context.WithoutCancel(ctx)
 
 			err := svc.sendNtfy(
 				notifyCtx,
-				svc.ntfyURL,
+				svc.config.NtfyTopic,
 				title, message, priority,
 			)
 			if err != nil {
@@ -191,13 +98,13 @@ func (svc *Service) SendNotification(
 		}()
 	}
 
-	if svc.slackWebhookURL != nil {
+	if svc.config.SlackWebhook != "" {
 		go func() {
 			notifyCtx := context.WithoutCancel(ctx)
 
 			err := svc.sendSlack(
 				notifyCtx,
-				svc.slackWebhookURL,
+				svc.config.SlackWebhook,
 				title, message, priority,
 			)
 			if err != nil {
@@ -209,13 +116,13 @@ func (svc *Service) SendNotification(
 		}()
 	}
 
-	if svc.mattermostWebhookURL != nil {
+	if svc.config.MattermostWebhook != "" {
 		go func() {
 			notifyCtx := context.WithoutCancel(ctx)
 
 			err := svc.sendSlack(
 				notifyCtx,
-				svc.mattermostWebhookURL,
+				svc.config.MattermostWebhook,
 				title, message, priority,
 			)
 			if err != nil {
@@ -230,29 +137,33 @@ func (svc *Service) SendNotification(
 
 func (svc *Service) sendNtfy(
 	ctx context.Context,
-	topicURL *url.URL,
+	topic, title, message, priority string,
-	title, message, priority string,
 ) error {
 	svc.log.Debug(
 		"sending ntfy notification",
-		"topic", topicURL.String(),
+		"topic", topic,
 		"title", title,
 	)
 
-	ctx, cancel := context.WithTimeout(
+	cleanURL, err := sanitizeURL(topic)
-		ctx, httpClientTimeout,
+	if err != nil {
-	)
+		return fmt.Errorf("invalid ntfy topic URL: %w", err)
-	defer cancel()
+	}
 
-	body := bytes.NewBufferString(message)
+	request, err := http.NewRequestWithContext(
-	request := newRequest(
+		ctx,
-		ctx, http.MethodPost, topicURL, body,
+		http.MethodPost,
+		cleanURL,
+		bytes.NewBufferString(message),
 	)
+	if err != nil {
+		return fmt.Errorf("creating ntfy request: %w", err)
+	}
 
 	request.Header.Set("Title", title)
 	request.Header.Set("Priority", ntfyPriority(priority))
 
-	resp, err := svc.transport.RoundTrip(request)
+	resp, err := svc.client.Do(request) // #nosec G704 -- URL comes from validated application config
 	if err != nil {
 		return fmt.Errorf("sending ntfy request: %w", err)
 	}
@@ -261,8 +172,7 @@ func (svc *Service) sendNtfy(
 
 	if resp.StatusCode >= httpStatusClientError {
 		return fmt.Errorf(
-			"%w: status %d",
+			"%w: status %d", ErrNtfyFailed, resp.StatusCode,
-			ErrNtfyFailed, resp.StatusCode,
 		)
 	}
 
@@ -299,17 +209,11 @@ type SlackAttachment struct {
 
 func (svc *Service) sendSlack(
 	ctx context.Context,
-	webhookURL *url.URL,
+	webhookURL, title, message, priority string,
-	title, message, priority string,
 ) error {
-	ctx, cancel := context.WithTimeout(
-		ctx, httpClientTimeout,
-	)
-	defer cancel()
-
 	svc.log.Debug(
 		"sending webhook notification",
-		"url", webhookURL.String(),
+		"url", webhookURL,
 		"title", title,
 	)
 
@@ -325,19 +229,27 @@ func (svc *Service) sendSlack(
 
 	body, err := json.Marshal(payload)
 	if err != nil {
-		return fmt.Errorf(
+		return fmt.Errorf("marshaling webhook payload: %w", err)
-			"marshaling webhook payload: %w", err,
-		)
 	}
 
-	request := newRequest(
+	cleanURL, err := sanitizeURL(webhookURL)
-		ctx, http.MethodPost, webhookURL,
+	if err != nil {
+		return fmt.Errorf("invalid webhook URL: %w", err)
+	}
+
+	request, err := http.NewRequestWithContext(
+		ctx,
+		http.MethodPost,
+		cleanURL,
 		bytes.NewBuffer(body),
 	)
+	if err != nil {
+		return fmt.Errorf("creating webhook request: %w", err)
+	}
 
 	request.Header.Set("Content-Type", "application/json")
 
-	resp, err := svc.transport.RoundTrip(request)
+	resp, err := svc.client.Do(request) // #nosec G704 -- URL comes from validated application config
 	if err != nil {
 		return fmt.Errorf("sending webhook request: %w", err)
 	}

internal/notify/notify_test.go

@@ -1,100 +0,0 @@
-package notify_test
-
-import (
-	"testing"
-
-	"sneak.berlin/go/dnswatcher/internal/notify"
-)
-
-func TestValidateWebhookURLValid(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name    string
-		input   string
-		wantURL string
-	}{
-		{
-			name:    "valid https URL",
-			input:   "https://hooks.slack.com/T00/B00",
-			wantURL: "https://hooks.slack.com/T00/B00",
-		},
-		{
-			name:    "valid http URL",
-			input:   "http://localhost:8080/webhook",
-			wantURL: "http://localhost:8080/webhook",
-		},
-		{
-			name:    "https with query",
-			input:   "https://ntfy.sh/topic?auth=tok",
-			wantURL: "https://ntfy.sh/topic?auth=tok",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			got, err := notify.ValidateWebhookURL(tt.input)
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-
-			if got.String() != tt.wantURL {
-				t.Errorf(
-					"got %q, want %q",
-					got.String(), tt.wantURL,
-				)
-			}
-		})
-	}
-}
-
-func TestValidateWebhookURLInvalid(t *testing.T) {
-	t.Parallel()
-
-	invalid := []struct {
-		name  string
-		input string
-	}{
-		{"ftp scheme", "ftp://example.com/file"},
-		{"file scheme", "file:///etc/passwd"},
-		{"empty string", ""},
-		{"no scheme", "example.com/webhook"},
-		{"no host", "https:///path"},
-	}
-
-	for _, tt := range invalid {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			got, err := notify.ValidateWebhookURL(tt.input)
-			if err == nil {
-				t.Errorf(
-					"expected error for %q, got %v",
-					tt.input, got,
-				)
-			}
-		})
-	}
-}
-
-func TestIsAllowedScheme(t *testing.T) {
-	t.Parallel()
-
-	if !notify.IsAllowedScheme("https") {
-		t.Error("https should be allowed")
-	}
-
-	if !notify.IsAllowedScheme("http") {
-		t.Error("http should be allowed")
-	}
-
-	if notify.IsAllowedScheme("ftp") {
-		t.Error("ftp should not be allowed")
-	}
-
-	if notify.IsAllowedScheme("") {
-		t.Error("empty scheme should not be allowed")
-	}
-}

internal/portcheck/portcheck.go

@@ -4,39 +4,18 @@ package portcheck
 import (
 	"context"
 	"errors"
-	"fmt"
 	"log/slog"
-	"net"
-	"strconv"
-	"sync"
-	"time"
 
 	"go.uber.org/fx"
-	"golang.org/x/sync/errgroup"
 
 	"sneak.berlin/go/dnswatcher/internal/logger"
 )
 
-const (
+// ErrNotImplemented indicates the port checker is not yet implemented.
-	minPort        = 1
+var ErrNotImplemented = errors.New(
-	maxPort        = 65535
+	"port checker not yet implemented",
-	defaultTimeout = 5 * time.Second
 )
 
-// ErrInvalidPort is returned when a port number is outside
-// the valid TCP range (1–65535).
-var ErrInvalidPort = errors.New("invalid port number")
-
-// PortResult holds the outcome of a single TCP port check.
-type PortResult struct {
-	// Open indicates whether the port accepted a connection.
-	Open bool
-	// Error contains a description if the connection failed.
-	Error string
-	// Latency is the time taken for the TCP handshake.
-	Latency time.Duration
-}
-
 // Params contains dependencies for Checker.
 type Params struct {
 	fx.In
@@ -59,145 +38,11 @@ func New(
 	}, nil
 }
 
-// NewStandalone creates a Checker without fx dependencies.
-func NewStandalone() *Checker {
-	return &Checker{
-		log: slog.Default(),
-	}
-}
-
-// validatePort checks that a port number is within the valid
-// TCP port range (1–65535).
-func validatePort(port int) error {
-	if port < minPort || port > maxPort {
-		return fmt.Errorf(
-			"%w: %d (must be between %d and %d)",
-			ErrInvalidPort, port, minPort, maxPort,
-		)
-	}
-
-	return nil
-}
-
 // CheckPort tests TCP connectivity to the given address and port.
-// It uses a 5-second timeout unless the context has an earlier
-// deadline.
 func (c *Checker) CheckPort(
-	ctx context.Context,
+	_ context.Context,
-	address string,
+	_ string,
-	port int,
+	_ int,
-) (*PortResult, error) {
+) (bool, error) {
-	err := validatePort(port)
+	return false, ErrNotImplemented
-	if err != nil {
-		return nil, err
-	}
-
-	target := net.JoinHostPort(
-		address, strconv.Itoa(port),
-	)
-
-	timeout := defaultTimeout
-
-	deadline, hasDeadline := ctx.Deadline()
-	if hasDeadline {
-		remaining := time.Until(deadline)
-		if remaining < timeout {
-			timeout = remaining
-		}
-	}
-
-	return c.checkConnection(ctx, target, timeout), nil
-}
-
-// CheckPorts tests TCP connectivity to multiple ports on the
-// given address concurrently. It returns a map of port number
-// to result.
-func (c *Checker) CheckPorts(
-	ctx context.Context,
-	address string,
-	ports []int,
-) (map[int]*PortResult, error) {
-	for _, port := range ports {
-		err := validatePort(port)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	var mu sync.Mutex
-
-	results := make(map[int]*PortResult, len(ports))
-
-	g, ctx := errgroup.WithContext(ctx)
-
-	for _, port := range ports {
-		g.Go(func() error {
-			result, err := c.CheckPort(ctx, address, port)
-			if err != nil {
-				return fmt.Errorf(
-					"checking port %d: %w", port, err,
-				)
-			}
-
-			mu.Lock()
-			results[port] = result
-			mu.Unlock()
-
-			return nil
-		})
-	}
-
-	err := g.Wait()
-	if err != nil {
-		return nil, err
-	}
-
-	return results, nil
-}
-
-// checkConnection performs the TCP dial and returns a result.
-func (c *Checker) checkConnection(
-	ctx context.Context,
-	target string,
-	timeout time.Duration,
-) *PortResult {
-	dialer := &net.Dialer{Timeout: timeout}
-	start := time.Now()
-
-	conn, dialErr := dialer.DialContext(ctx, "tcp", target)
-	latency := time.Since(start)
-
-	if dialErr != nil {
-		c.log.Debug(
-			"port check failed",
-			"target", target,
-			"error", dialErr.Error(),
-		)
-
-		return &PortResult{
-			Open:    false,
-			Error:   dialErr.Error(),
-			Latency: latency,
-		}
-	}
-
-	closeErr := conn.Close()
-	if closeErr != nil {
-		c.log.Debug(
-			"closing connection",
-			"target", target,
-			"error", closeErr.Error(),
-		)
-	}
-
-	c.log.Debug(
-		"port check succeeded",
-		"target", target,
-		"latency", latency,
-	)
-
-	return &PortResult{
-		Open:    true,
-		Latency: latency,
-	}
 }

internal/portcheck/portcheck_test.go

@@ -1,211 +0,0 @@
-package portcheck_test
-
-import (
-	"context"
-	"net"
-	"testing"
-	"time"
-
-	"sneak.berlin/go/dnswatcher/internal/portcheck"
-)
-
-func listenTCP(
-	t *testing.T,
-) (net.Listener, int) {
-	t.Helper()
-
-	lc := &net.ListenConfig{}
-
-	ln, err := lc.Listen(
-		context.Background(), "tcp", "127.0.0.1:0",
-	)
-	if err != nil {
-		t.Fatalf("failed to start listener: %v", err)
-	}
-
-	addr, ok := ln.Addr().(*net.TCPAddr)
-	if !ok {
-		t.Fatal("unexpected address type")
-	}
-
-	return ln, addr.Port
-}
-
-func TestCheckPortOpen(t *testing.T) {
-	t.Parallel()
-
-	ln, port := listenTCP(t)
-
-	defer func() { _ = ln.Close() }()
-
-	checker := portcheck.NewStandalone()
-
-	result, err := checker.CheckPort(
-		context.Background(), "127.0.0.1", port,
-	)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if !result.Open {
-		t.Error("expected port to be open")
-	}
-
-	if result.Error != "" {
-		t.Errorf("expected no error, got: %s", result.Error)
-	}
-
-	if result.Latency <= 0 {
-		t.Error("expected positive latency")
-	}
-}
-
-func TestCheckPortClosed(t *testing.T) {
-	t.Parallel()
-
-	ln, port := listenTCP(t)
-	_ = ln.Close()
-
-	checker := portcheck.NewStandalone()
-
-	result, err := checker.CheckPort(
-		context.Background(), "127.0.0.1", port,
-	)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if result.Open {
-		t.Error("expected port to be closed")
-	}
-
-	if result.Error == "" {
-		t.Error("expected error message for closed port")
-	}
-}
-
-func TestCheckPortContextCanceled(t *testing.T) {
-	t.Parallel()
-
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-
-	checker := portcheck.NewStandalone()
-
-	result, err := checker.CheckPort(ctx, "127.0.0.1", 1)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if result.Open {
-		t.Error("expected port to not be open")
-	}
-}
-
-func TestCheckPortsMultiple(t *testing.T) {
-	t.Parallel()
-
-	ln, openPort := listenTCP(t)
-
-	defer func() { _ = ln.Close() }()
-
-	ln2, closedPort := listenTCP(t)
-	_ = ln2.Close()
-
-	checker := portcheck.NewStandalone()
-
-	results, err := checker.CheckPorts(
-		context.Background(),
-		"127.0.0.1",
-		[]int{openPort, closedPort},
-	)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(results) != 2 {
-		t.Fatalf(
-			"expected 2 results, got %d", len(results),
-		)
-	}
-
-	if !results[openPort].Open {
-		t.Error("expected open port to be open")
-	}
-
-	if results[closedPort].Open {
-		t.Error("expected closed port to be closed")
-	}
-}
-
-func TestCheckPortInvalidPorts(t *testing.T) {
-	t.Parallel()
-
-	checker := portcheck.NewStandalone()
-
-	cases := []struct {
-		name string
-		port int
-	}{
-		{"zero", 0},
-		{"negative", -1},
-		{"too high", 65536},
-		{"very negative", -1000},
-		{"very high", 100000},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			_, err := checker.CheckPort(
-				context.Background(), "127.0.0.1", tc.port,
-			)
-			if err == nil {
-				t.Errorf(
-					"expected error for port %d, got nil",
-					tc.port,
-				)
-			}
-		})
-	}
-}
-
-func TestCheckPortsInvalidPort(t *testing.T) {
-	t.Parallel()
-
-	checker := portcheck.NewStandalone()
-
-	_, err := checker.CheckPorts(
-		context.Background(),
-		"127.0.0.1",
-		[]int{80, 0, 443},
-	)
-	if err == nil {
-		t.Error("expected error for invalid port in list")
-	}
-}
-
-func TestCheckPortLatencyReasonable(t *testing.T) {
-	t.Parallel()
-
-	ln, port := listenTCP(t)
-
-	defer func() { _ = ln.Close() }()
-
-	checker := portcheck.NewStandalone()
-
-	result, err := checker.CheckPort(
-		context.Background(), "127.0.0.1", port,
-	)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if result.Latency > time.Second {
-		t.Errorf(
-			"latency too high for localhost: %v",
-			result.Latency,
-		)
-	}
-}

internal/resolver/dns_client.go

@@ -1,48 +0,0 @@
-package resolver
-
-import (
-	"context"
-	"time"
-
-	"github.com/miekg/dns"
-)
-
-// DNSClient abstracts DNS wire-protocol exchanges so the resolver
-// can be tested without hitting real nameservers.
-type DNSClient interface {
-	ExchangeContext(
-		ctx context.Context,
-		msg *dns.Msg,
-		addr string,
-	) (*dns.Msg, time.Duration, error)
-}
-
-// udpClient wraps a real dns.Client for production use.
-type udpClient struct {
-	timeout time.Duration
-}
-
-func (c *udpClient) ExchangeContext(
-	ctx context.Context,
-	msg *dns.Msg,
-	addr string,
-) (*dns.Msg, time.Duration, error) {
-	cl := &dns.Client{Timeout: c.timeout}
-
-	return cl.ExchangeContext(ctx, msg, addr)
-}
-
-// tcpClient wraps a real dns.Client using TCP.
-type tcpClient struct {
-	timeout time.Duration
-}
-
-func (c *tcpClient) ExchangeContext(
-	ctx context.Context,
-	msg *dns.Msg,
-	addr string,
-) (*dns.Msg, time.Duration, error) {
-	cl := &dns.Client{Net: "tcp", Timeout: c.timeout}
-
-	return cl.ExchangeContext(ctx, msg, addr)
-}

internal/resolver/errors.go

@@ -4,6 +4,11 @@ import "errors"
 
 // Sentinel errors returned by the resolver.
 var (
+	// ErrNotImplemented indicates a method is stubbed out.
+	ErrNotImplemented = errors.New(
+		"resolver not yet implemented",
+	)
+
 	// ErrNoNameservers is returned when no authoritative NS
 	// could be discovered for a domain.
 	ErrNoNameservers = errors.New(

internal/resolver/iterative.go

@@ -13,7 +13,7 @@ import (
 )
 
 const (
-	queryTimeoutDuration = 2 * time.Second
+	queryTimeoutDuration = 5 * time.Second
 	maxRetries           = 2
 	maxDelegation        = 20
 	timeoutMultiplier    = 2
@@ -50,20 +50,25 @@ func checkCtx(ctx context.Context) error {
 	return nil
 }
 
-func (r *Resolver) exchangeWithTimeout(
+func exchangeWithTimeout(
 	ctx context.Context,
 	msg *dns.Msg,
 	addr string,
 	attempt int,
 ) (*dns.Msg, error) {
-	_ = attempt // timeout escalation handled by client config
+	c := new(dns.Client)
+	c.Timeout = queryTimeoutDuration
 
-	resp, _, err := r.client.ExchangeContext(ctx, msg, addr)
+	if attempt > 0 {
+		c.Timeout = queryTimeoutDuration * timeoutMultiplier
+	}
+
+	resp, _, err := c.ExchangeContext(ctx, msg, addr)
 
 	return resp, err
 }
 
-func (r *Resolver) tryExchange(
+func tryExchange(
 	ctx context.Context,
 	msg *dns.Msg,
 	addr string,
@@ -77,9 +82,7 @@ func (r *Resolver) tryExchange(
 			return nil, ErrContextCanceled
 		}
 
-		resp, err = r.exchangeWithTimeout(
+		resp, err = exchangeWithTimeout(ctx, msg, addr, attempt)
-			ctx, msg, addr, attempt,
-		)
 		if err == nil {
 			break
 		}
@@ -88,7 +91,7 @@ func (r *Resolver) tryExchange(
 	return resp, err
 }
 
-func (r *Resolver) retryTCP(
+func retryTCP(
 	ctx context.Context,
 	msg *dns.Msg,
 	addr string,
@@ -98,7 +101,12 @@ func (r *Resolver) retryTCP(
 		return resp
 	}
 
-	tcpResp, _, tcpErr := r.tcp.ExchangeContext(ctx, msg, addr)
+	c := &dns.Client{
+		Net:     "tcp",
+		Timeout: queryTimeoutDuration,
+	}
+
+	tcpResp, _, tcpErr := c.ExchangeContext(ctx, msg, addr)
 	if tcpErr == nil {
 		return tcpResp
 	}
@@ -109,7 +117,7 @@ func (r *Resolver) retryTCP(
 // queryDNS sends a DNS query to a specific server IP.
 // Tries non-recursive first, falls back to recursive on
 // REFUSED (handles DNS interception environments).
-func (r *Resolver) queryDNS(
+func queryDNS(
 	ctx context.Context,
 	serverIP string,
 	name string,
@@ -126,7 +134,7 @@ func (r *Resolver) queryDNS(
 	msg.SetQuestion(name, qtype)
 	msg.RecursionDesired = false
 
-	resp, err := r.tryExchange(ctx, msg, addr)
+	resp, err := tryExchange(ctx, msg, addr)
 	if err != nil {
 		return nil, fmt.Errorf("query %s @%s: %w", name, serverIP, err)
 	}
@@ -134,7 +142,7 @@ func (r *Resolver) queryDNS(
 	if resp.Rcode == dns.RcodeRefused {
 		msg.RecursionDesired = true
 
-		resp, err = r.tryExchange(ctx, msg, addr)
+		resp, err = tryExchange(ctx, msg, addr)
 		if err != nil {
 			return nil, fmt.Errorf(
 				"query %s @%s: %w", name, serverIP, err,
@@ -148,7 +156,7 @@ func (r *Resolver) queryDNS(
 		}
 	}
 
-	resp = r.retryTCP(ctx, msg, addr, resp)
+	resp = retryTCP(ctx, msg, addr, resp)
 
 	return resp, nil
 }
@@ -213,9 +221,7 @@ func (r *Resolver) followDelegation(
 			return nil, ErrContextCanceled
 		}
 
-		resp, err := r.queryServers(
+		resp, err := queryServers(ctx, servers, domain, dns.TypeNS)
-			ctx, servers, domain, dns.TypeNS,
-		)
 		if err != nil {
 			return nil, err
 		}
@@ -227,7 +233,7 @@ func (r *Resolver) followDelegation(
 
 		authNS := extractNSSet(resp.Ns)
 		if len(authNS) == 0 {
-			return r.resolveNSIterative(ctx, domain)
+			return r.resolveNSRecursive(ctx, domain)
 		}
 
 		glue := extractGlue(resp.Extra)
@@ -247,7 +253,7 @@ func (r *Resolver) followDelegation(
 	return nil, ErrNoNameservers
 }
 
-func (r *Resolver) queryServers(
+func queryServers(
 	ctx context.Context,
 	servers []string,
 	name string,
@@ -260,7 +266,7 @@ func (r *Resolver) queryServers(
 			return nil, ErrContextCanceled
 		}
 
-		resp, err := r.queryDNS(ctx, ip, name, qtype)
+		resp, err := queryDNS(ctx, ip, name, qtype)
 		if err == nil {
 			return resp, nil
 		}
@@ -291,84 +297,64 @@ func (r *Resolver) resolveNSIPs(
 	return ips
 }
 
-// resolveNSIterative queries for NS records using iterative
+// resolveNSRecursive queries for NS records using recursive
-// resolution as a fallback when followDelegation finds no
+// resolution as a fallback for intercepted environments.
-// authoritative answer in the delegation chain.
+func (r *Resolver) resolveNSRecursive(
-func (r *Resolver) resolveNSIterative(
 	ctx context.Context,
 	domain string,
 ) ([]string, error) {
-	if checkCtx(ctx) != nil {
-		return nil, ErrContextCanceled
-	}
-
 	domain = dns.Fqdn(domain)
-	servers := rootServerList()
+	msg := new(dns.Msg)
+	msg.SetQuestion(domain, dns.TypeNS)
+	msg.RecursionDesired = true
 
-	for range maxDelegation {
+	c := &dns.Client{Timeout: queryTimeoutDuration}
+
+	for _, ip := range rootServerList()[:3] {
 		if checkCtx(ctx) != nil {
 			return nil, ErrContextCanceled
 		}
 
-		resp, err := r.queryServers(
+		addr := net.JoinHostPort(ip, "53")
-			ctx, servers, domain, dns.TypeNS,
+
-		)
+		resp, _, err := c.ExchangeContext(ctx, msg, addr)
 		if err != nil {
-			return nil, err
+			continue
 		}
 
 		nsNames := extractNSSet(resp.Answer)
 		if len(nsNames) > 0 {
 			return nsNames, nil
 		}
-
-		// Follow delegation.
-		authNS := extractNSSet(resp.Ns)
-		if len(authNS) == 0 {
-			break
-		}
-
-		glue := extractGlue(resp.Extra)
-		nextServers := glueIPs(authNS, glue)
-
-		if len(nextServers) == 0 {
-			break
-		}
-
-		servers = nextServers
 	}
 
 	return nil, ErrNoNameservers
 }
 
-// resolveARecord resolves a hostname to IPv4 addresses using
+// resolveARecord resolves a hostname to IPv4 addresses.
-// iterative resolution through the delegation chain.
 func (r *Resolver) resolveARecord(
 	ctx context.Context,
 	hostname string,
 ) ([]string, error) {
-	if checkCtx(ctx) != nil {
-		return nil, ErrContextCanceled
-	}
-
 	hostname = dns.Fqdn(hostname)
-	servers := rootServerList()
+	msg := new(dns.Msg)
+	msg.SetQuestion(hostname, dns.TypeA)
+	msg.RecursionDesired = true
 
-	for range maxDelegation {
+	c := &dns.Client{Timeout: queryTimeoutDuration}
+
+	for _, ip := range rootServerList()[:3] {
 		if checkCtx(ctx) != nil {
 			return nil, ErrContextCanceled
 		}
 
-		resp, err := r.queryServers(
+		addr := net.JoinHostPort(ip, "53")
-			ctx, servers, hostname, dns.TypeA,
+
-		)
+		resp, _, err := c.ExchangeContext(ctx, msg, addr)
 		if err != nil {
-			return nil, fmt.Errorf(
+			continue
-				"resolving %s: %w", hostname, err,
-			)
 		}
 
-		// Check for A records in the answer section.
 		var ips []string
 
 		for _, rr := range resp.Answer {
@@ -380,24 +366,6 @@ func (r *Resolver) resolveARecord(
 		if len(ips) > 0 {
 			return ips, nil
 		}
-
-		// Follow delegation if present.
-		authNS := extractNSSet(resp.Ns)
-		if len(authNS) == 0 {
-			break
-		}
-
-		glue := extractGlue(resp.Extra)
-		nextServers := glueIPs(authNS, glue)
-
-		if len(nextServers) == 0 {
-			// Resolve NS IPs iteratively — but guard
-			// against infinite recursion by using only
-			// already-resolved servers.
-			break
-		}
-
-		servers = nextServers
 	}
 
 	return nil, fmt.Errorf(
@@ -460,23 +428,6 @@ func (r *Resolver) QueryNameserver(
 	return r.queryAllTypes(ctx, nsHostname, nsIPs[0], hostname)
 }
 
-// QueryNameserverIP queries a nameserver by its IP address directly,
-// bypassing NS hostname resolution.
-func (r *Resolver) QueryNameserverIP(
-	ctx context.Context,
-	nsHostname string,
-	nsIP string,
-	hostname string,
-) (*NameserverResponse, error) {
-	if checkCtx(ctx) != nil {
-		return nil, ErrContextCanceled
-	}
-
-	hostname = dns.Fqdn(hostname)
-
-	return r.queryAllTypes(ctx, nsHostname, nsIP, hostname)
-}
-
 func (r *Resolver) queryAllTypes(
 	ctx context.Context,
 	nsHostname string,
@@ -504,7 +455,6 @@ func (r *Resolver) queryAllTypes(
 type queryState struct {
 	gotNXDomain bool
 	gotSERVFAIL bool
-	gotTimeout  bool
 	hasRecords  bool
 }
 
@@ -540,12 +490,8 @@ func (r *Resolver) querySingleType(
 	resp *NameserverResponse,
 	state *queryState,
 ) {
-	msg, err := r.queryDNS(ctx, nsIP, hostname, qtype)
+	msg, err := queryDNS(ctx, nsIP, hostname, qtype)
 	if err != nil {
-		if isTimeout(err) {
-			state.gotTimeout = true
-		}
-
 		return
 	}
 
@@ -583,26 +529,12 @@ func collectAnswerRecords(
 	}
 }
 
-// isTimeout checks whether an error is a network timeout.
-func isTimeout(err error) bool {
-	var netErr net.Error
-	if errors.As(err, &netErr) {
-		return netErr.Timeout()
-	}
-
-	return false
-}
-
 func classifyResponse(resp *NameserverResponse, state queryState) {
 	switch {
 	case state.gotNXDomain && !state.hasRecords:
 		resp.Status = StatusNXDomain
-	case state.gotTimeout && !state.hasRecords:
-		resp.Status = StatusTimeout
-		resp.Error = "all queries timed out"
 	case state.gotSERVFAIL && !state.hasRecords:
 		resp.Status = StatusError
-		resp.Error = "server returned SERVFAIL"
 	case !state.hasRecords && !state.gotNXDomain:
 		resp.Status = StatusNoData
 	}
@@ -709,25 +641,6 @@ func (r *Resolver) LookupNS(
 	return r.FindAuthoritativeNameservers(ctx, domain)
 }
 
-// LookupAllRecords performs iterative resolution to find all DNS
-// records for the given hostname, keyed by authoritative nameserver.
-func (r *Resolver) LookupAllRecords(
-	ctx context.Context,
-	hostname string,
-) (map[string]map[string][]string, error) {
-	results, err := r.QueryAllNameservers(ctx, hostname)
-	if err != nil {
-		return nil, err
-	}
-
-	out := make(map[string]map[string][]string, len(results))
-	for ns, resp := range results {
-		out[ns] = resp.Records
-	}
-
-	return out, nil
-}
-
 // ResolveIPAddresses resolves a hostname to all IPv4 and IPv6
 // addresses, following CNAME chains up to MaxCNAMEDepth.
 func (r *Resolver) ResolveIPAddresses(

internal/resolver/resolver.go

@@ -17,7 +17,6 @@ const (
 	StatusError    = "error"
 	StatusNXDomain = "nxdomain"
 	StatusNoData   = "nodata"
-	StatusTimeout  = "timeout"
 )
 
 // MaxCNAMEDepth is the maximum CNAME chain depth to follow.
@@ -40,9 +39,7 @@ type NameserverResponse struct {
 
 // Resolver performs iterative DNS resolution from root servers.
 type Resolver struct {
-	log    *slog.Logger
+	log *slog.Logger
-	client DNSClient
-	tcp    DNSClient
 }
 
 // New creates a new Resolver instance for use with uber/fx.
@@ -51,33 +48,14 @@ func New(
 	params Params,
 ) (*Resolver, error) {
 	return &Resolver{
-		log:    params.Logger.Get(),
+		log: params.Logger.Get(),
-		client: &udpClient{timeout: queryTimeoutDuration},
-		tcp:    &tcpClient{timeout: queryTimeoutDuration},
 	}, nil
 }
 
 // NewFromLogger creates a Resolver directly from an slog.Logger,
 // useful for testing without the fx lifecycle.
 func NewFromLogger(log *slog.Logger) *Resolver {
-	return &Resolver{
+	return &Resolver{log: log}
-		log:    log,
-		client: &udpClient{timeout: queryTimeoutDuration},
-		tcp:    &tcpClient{timeout: queryTimeoutDuration},
-	}
-}
-
-// NewFromLoggerWithClient creates a Resolver with a custom DNS
-// client, useful for testing with mock DNS responses.
-func NewFromLoggerWithClient(
-	log *slog.Logger,
-	client DNSClient,
-) *Resolver {
-	return &Resolver{
-		log:    log,
-		client: client,
-		tcp:    client,
-	}
 }
 
 // Method implementations are in iterative.go.

internal/server/routes.go

@@ -28,8 +28,6 @@ func (s *Server) SetupRoutes() {
 	// API v1 routes
 	s.router.Route("/api/v1", func(r chi.Router) {
 		r.Get("/status", s.handlers.HandleStatus())
-		r.Get("/domains", s.handlers.HandleDomains())
-		r.Get("/hostnames", s.handlers.HandleHostnames())
 	})
 
 	// Metrics endpoint (optional, with basic auth)

internal/state/state.go

@@ -57,49 +57,10 @@ type HostnameState struct {
 // PortState holds the monitoring state for a port.
 type PortState struct {
 	Open        bool      `json:"open"`
-	Hostnames   []string  `json:"hostnames"`
+	Hostname    string    `json:"hostname"`
 	LastChecked time.Time `json:"lastChecked"`
 }
 
-// UnmarshalJSON implements custom unmarshaling to handle both
-// the old single-hostname format and the new multi-hostname
-// format for backward compatibility with existing state files.
-func (ps *PortState) UnmarshalJSON(data []byte) error {
-	// Use an alias to prevent infinite recursion.
-	type portStateAlias struct {
-		Open        bool      `json:"open"`
-		Hostnames   []string  `json:"hostnames"`
-		LastChecked time.Time `json:"lastChecked"`
-	}
-
-	var alias portStateAlias
-
-	err := json.Unmarshal(data, &alias)
-	if err != nil {
-		return fmt.Errorf("unmarshaling port state: %w", err)
-	}
-
-	ps.Open = alias.Open
-	ps.Hostnames = alias.Hostnames
-	ps.LastChecked = alias.LastChecked
-
-	// If Hostnames is empty, try reading the old single-hostname
-	// format for backward compatibility.
-	if len(ps.Hostnames) == 0 {
-		var old struct {
-			Hostname string `json:"hostname"`
-		}
-
-		// Best-effort: ignore errors since the main unmarshal
-		// already succeeded.
-		if json.Unmarshal(data, &old) == nil && old.Hostname != "" {
-			ps.Hostnames = []string{old.Hostname}
-		}
-	}
-
-	return nil
-}
-
 // CertificateState holds TLS certificate monitoring state.
 type CertificateState struct {
 	CommonName              string    `json:"commonName"`
@@ -195,8 +156,8 @@ func (s *State) Load() error {
 
 // Save writes the current state to disk atomically.
 func (s *State) Save() error {
-	s.mu.Lock()
+	s.mu.RLock()
-	defer s.mu.Unlock()
+	defer s.mu.RUnlock()
 
 	s.snapshot.LastUpdated = time.Now().UTC()
 
@@ -302,27 +263,6 @@ func (s *State) GetPortState(key string) (*PortState, bool) {
 	return ps, ok
 }
 
-// DeletePortState removes a port state entry.
-func (s *State) DeletePortState(key string) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	delete(s.snapshot.Ports, key)
-}
-
-// GetAllPortKeys returns all port state keys.
-func (s *State) GetAllPortKeys() []string {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-
-	keys := make([]string, 0, len(s.snapshot.Ports))
-	for k := range s.snapshot.Ports {
-		keys = append(keys, k)
-	}
-
-	return keys
-}
-
 // SetCertificateState updates the state for a certificate.
 func (s *State) SetCertificateState(
 	key string,

internal/state/state_test_helper.go

@@ -1,22 +0,0 @@
-package state
-
-import (
-	"log/slog"
-
-	"sneak.berlin/go/dnswatcher/internal/config"
-)
-
-// NewForTest creates a State for unit testing with no persistence.
-func NewForTest() *State {
-	return &State{
-		log: slog.Default(),
-		snapshot: &Snapshot{
-			Version:      stateVersion,
-			Domains:      make(map[string]*DomainState),
-			Hostnames:    make(map[string]*HostnameState),
-			Ports:        make(map[string]*PortState),
-			Certificates: make(map[string]*CertificateState),
-		},
-		config: &config.Config{DataDir: ""},
-	}
-}

internal/tlscheck/extractcertinfo_test.go

@@ -1,67 +0,0 @@
-package tlscheck_test
-
-import (
-	"context"
-	"crypto/tls"
-	"errors"
-	"net"
-	"testing"
-	"time"
-
-	"sneak.berlin/go/dnswatcher/internal/tlscheck"
-)
-
-func TestCheckCertificateNoPeerCerts(t *testing.T) {
-	t.Parallel()
-
-	lc := &net.ListenConfig{}
-
-	ln, err := lc.Listen(
-		context.Background(), "tcp", "127.0.0.1:0",
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	defer func() { _ = ln.Close() }()
-
-	addr, ok := ln.Addr().(*net.TCPAddr)
-	if !ok {
-		t.Fatal("unexpected address type")
-	}
-
-	// Accept and immediately close to cause TLS handshake failure.
-	go func() {
-		conn, err := ln.Accept()
-		if err != nil {
-			return
-		}
-
-		_ = conn.Close()
-	}()
-
-	checker := tlscheck.NewStandalone(
-		tlscheck.WithTimeout(2*time.Second),
-		tlscheck.WithTLSConfig(&tls.Config{
-			InsecureSkipVerify: true, //nolint:gosec // test
-			MinVersion:         tls.VersionTLS12,
-		}),
-		tlscheck.WithPort(addr.Port),
-	)
-
-	_, err = checker.CheckCertificate(
-		context.Background(), "127.0.0.1", "localhost",
-	)
-	if err == nil {
-		t.Fatal("expected error when server presents no certs")
-	}
-}
-
-func TestErrNoPeerCertificatesIsSentinel(t *testing.T) {
-	t.Parallel()
-
-	err := tlscheck.ErrNoPeerCertificates
-	if !errors.Is(err, tlscheck.ErrNoPeerCertificates) {
-		t.Fatal("expected sentinel error to match")
-	}
-}

internal/tlscheck/tlscheck.go

@@ -3,12 +3,8 @@ package tlscheck
 
 import (
 	"context"
-	"crypto/tls"
 	"errors"
-	"fmt"
 	"log/slog"
-	"net"
-	"strconv"
 	"time"
 
 	"go.uber.org/fx"
@@ -16,56 +12,11 @@ import (
 	"sneak.berlin/go/dnswatcher/internal/logger"
 )
 
-const (
+// ErrNotImplemented indicates the TLS checker is not yet implemented.
-	defaultTimeout = 10 * time.Second
+var ErrNotImplemented = errors.New(
-	defaultPort    = 443
+	"tls checker not yet implemented",
 )
 
-// ErrUnexpectedConnType indicates the connection was not a TLS
-// connection.
-var ErrUnexpectedConnType = errors.New(
-	"unexpected connection type",
-)
-
-// ErrNoPeerCertificates indicates the TLS connection had no peer
-// certificates.
-var ErrNoPeerCertificates = errors.New(
-	"no peer certificates",
-)
-
-// CertificateInfo holds information about a TLS certificate.
-type CertificateInfo struct {
-	CommonName              string
-	Issuer                  string
-	NotAfter                time.Time
-	SubjectAlternativeNames []string
-	SerialNumber            string
-}
-
-// Option configures a Checker.
-type Option func(*Checker)
-
-// WithTimeout sets the connection timeout.
-func WithTimeout(d time.Duration) Option {
-	return func(c *Checker) {
-		c.timeout = d
-	}
-}
-
-// WithTLSConfig sets a custom TLS configuration.
-func WithTLSConfig(cfg *tls.Config) Option {
-	return func(c *Checker) {
-		c.tlsConfig = cfg
-	}
-}
-
-// WithPort sets the TLS port to connect to.
-func WithPort(port int) Option {
-	return func(c *Checker) {
-		c.port = port
-	}
-}
-
 // Params contains dependencies for Checker.
 type Params struct {
 	fx.In
@@ -75,10 +26,15 @@ type Params struct {
 
 // Checker performs TLS certificate inspection.
 type Checker struct {
-	log       *slog.Logger
+	log *slog.Logger
-	timeout   time.Duration
+}
-	tlsConfig *tls.Config
+
-	port      int
+// CertificateInfo holds information about a TLS certificate.
+type CertificateInfo struct {
+	CommonName              string
+	Issuer                  string
+	NotAfter                time.Time
+	SubjectAlternativeNames []string
 }
 
 // New creates a new TLS Checker instance.
@@ -87,110 +43,16 @@ func New(
 	params Params,
 ) (*Checker, error) {
 	return &Checker{
-		log:     params.Logger.Get(),
+		log: params.Logger.Get(),
-		timeout: defaultTimeout,
-		port:    defaultPort,
 	}, nil
 }
 
-// NewStandalone creates a Checker without fx dependencies.
+// CheckCertificate connects to the given IP:port using SNI and
-func NewStandalone(opts ...Option) *Checker {
+// returns certificate information.
-	checker := &Checker{
-		log:     slog.Default(),
-		timeout: defaultTimeout,
-		port:    defaultPort,
-	}
-
-	for _, opt := range opts {
-		opt(checker)
-	}
-
-	return checker
-}
-
-// CheckCertificate connects to the given IP address using the
-// specified SNI hostname and returns certificate information.
 func (c *Checker) CheckCertificate(
-	ctx context.Context,
+	_ context.Context,
-	ipAddress string,
+	_ string,
-	sniHostname string,
+	_ string,
 ) (*CertificateInfo, error) {
-	target := net.JoinHostPort(
+	return nil, ErrNotImplemented
-		ipAddress, strconv.Itoa(c.port),
-	)
-
-	tlsCfg := c.buildTLSConfig(sniHostname)
-	dialer := &tls.Dialer{
-		NetDialer: &net.Dialer{Timeout: c.timeout},
-		Config:    tlsCfg,
-	}
-
-	conn, err := dialer.DialContext(ctx, "tcp", target)
-	if err != nil {
-		return nil, fmt.Errorf(
-			"TLS dial to %s: %w", target, err,
-		)
-	}
-
-	defer func() {
-		closeErr := conn.Close()
-		if closeErr != nil {
-			c.log.Debug(
-				"closing TLS connection",
-				"target", target,
-				"error", closeErr.Error(),
-			)
-		}
-	}()
-
-	tlsConn, ok := conn.(*tls.Conn)
-	if !ok {
-		return nil, fmt.Errorf(
-			"%s: %w", target, ErrUnexpectedConnType,
-		)
-	}
-
-	return c.extractCertInfo(tlsConn)
-}
-
-func (c *Checker) buildTLSConfig(
-	sniHostname string,
-) *tls.Config {
-	if c.tlsConfig != nil {
-		cfg := c.tlsConfig.Clone()
-		cfg.ServerName = sniHostname
-
-		return cfg
-	}
-
-	return &tls.Config{
-		ServerName: sniHostname,
-		MinVersion: tls.VersionTLS12,
-	}
-}
-
-func (c *Checker) extractCertInfo(
-	conn *tls.Conn,
-) (*CertificateInfo, error) {
-	state := conn.ConnectionState()
-	if len(state.PeerCertificates) == 0 {
-		return nil, ErrNoPeerCertificates
-	}
-
-	cert := state.PeerCertificates[0]
-
-	sans := make([]string, 0, len(cert.DNSNames)+len(cert.IPAddresses))
-	sans = append(sans, cert.DNSNames...)
-
-	for _, ip := range cert.IPAddresses {
-		sans = append(sans, ip.String())
-	}
-
-	return &CertificateInfo{
-		CommonName:              cert.Subject.CommonName,
-		Issuer:                  cert.Issuer.CommonName,
-		NotAfter:                cert.NotAfter,
-		SubjectAlternativeNames: sans,
-		SerialNumber:            cert.SerialNumber.String(),
-	}, nil
 }

internal/tlscheck/tlscheck_test.go

@@ -1,169 +0,0 @@
-package tlscheck_test
-
-import (
-	"context"
-	"crypto/tls"
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"sneak.berlin/go/dnswatcher/internal/tlscheck"
-)
-
-func startTLSServer(
-	t *testing.T,
-) (*httptest.Server, string, int) {
-	t.Helper()
-
-	srv := httptest.NewTLSServer(
-		http.HandlerFunc(
-			func(w http.ResponseWriter, _ *http.Request) {
-				w.WriteHeader(http.StatusOK)
-			},
-		),
-	)
-
-	addr, ok := srv.Listener.Addr().(*net.TCPAddr)
-	if !ok {
-		t.Fatal("unexpected address type")
-	}
-
-	return srv, addr.IP.String(), addr.Port
-}
-
-func TestCheckCertificateValid(t *testing.T) {
-	t.Parallel()
-
-	srv, ip, port := startTLSServer(t)
-
-	defer srv.Close()
-
-	checker := tlscheck.NewStandalone(
-		tlscheck.WithTimeout(5*time.Second),
-		tlscheck.WithTLSConfig(&tls.Config{
-			//nolint:gosec // test uses self-signed cert
-			InsecureSkipVerify: true,
-		}),
-		tlscheck.WithPort(port),
-	)
-
-	info, err := checker.CheckCertificate(
-		context.Background(), ip, "localhost",
-	)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if info == nil {
-		t.Fatal("expected non-nil CertificateInfo")
-	}
-
-	if info.NotAfter.IsZero() {
-		t.Error("expected non-zero NotAfter")
-	}
-
-	if info.SerialNumber == "" {
-		t.Error("expected non-empty SerialNumber")
-	}
-}
-
-func TestCheckCertificateConnectionRefused(t *testing.T) {
-	t.Parallel()
-
-	lc := &net.ListenConfig{}
-
-	ln, err := lc.Listen(
-		context.Background(), "tcp", "127.0.0.1:0",
-	)
-	if err != nil {
-		t.Fatalf("failed to listen: %v", err)
-	}
-
-	addr, ok := ln.Addr().(*net.TCPAddr)
-	if !ok {
-		t.Fatal("unexpected address type")
-	}
-
-	port := addr.Port
-
-	_ = ln.Close()
-
-	checker := tlscheck.NewStandalone(
-		tlscheck.WithTimeout(2*time.Second),
-		tlscheck.WithPort(port),
-	)
-
-	_, err = checker.CheckCertificate(
-		context.Background(), "127.0.0.1", "localhost",
-	)
-	if err == nil {
-		t.Fatal("expected error for connection refused")
-	}
-}
-
-func TestCheckCertificateContextCanceled(t *testing.T) {
-	t.Parallel()
-
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-
-	checker := tlscheck.NewStandalone(
-		tlscheck.WithTimeout(2*time.Second),
-		tlscheck.WithPort(1),
-	)
-
-	_, err := checker.CheckCertificate(
-		ctx, "127.0.0.1", "localhost",
-	)
-	if err == nil {
-		t.Fatal("expected error for canceled context")
-	}
-}
-
-func TestCheckCertificateTimeout(t *testing.T) {
-	t.Parallel()
-
-	checker := tlscheck.NewStandalone(
-		tlscheck.WithTimeout(1*time.Millisecond),
-		tlscheck.WithPort(1),
-	)
-
-	_, err := checker.CheckCertificate(
-		context.Background(),
-		"192.0.2.1",
-		"example.com",
-	)
-	if err == nil {
-		t.Fatal("expected error for timeout")
-	}
-}
-
-func TestCheckCertificateSANs(t *testing.T) {
-	t.Parallel()
-
-	srv, ip, port := startTLSServer(t)
-
-	defer srv.Close()
-
-	checker := tlscheck.NewStandalone(
-		tlscheck.WithTimeout(5*time.Second),
-		tlscheck.WithTLSConfig(&tls.Config{
-			//nolint:gosec // test uses self-signed cert
-			InsecureSkipVerify: true,
-		}),
-		tlscheck.WithPort(port),
-	)
-
-	info, err := checker.CheckCertificate(
-		context.Background(), ip, "localhost",
-	)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if info.CommonName == "" && len(info.SubjectAlternativeNames) == 0 {
-		t.Error("expected CN or SANs to be populated")
-	}
-}

internal/watcher/interfaces.go

@@ -1,61 +0,0 @@
-// Package watcher provides the main monitoring orchestrator.
-package watcher
-
-import (
-	"context"
-
-	"sneak.berlin/go/dnswatcher/internal/portcheck"
-	"sneak.berlin/go/dnswatcher/internal/tlscheck"
-)
-
-// DNSResolver performs iterative DNS resolution.
-type DNSResolver interface {
-	// LookupNS discovers authoritative nameservers for a domain.
-	LookupNS(
-		ctx context.Context,
-		domain string,
-	) ([]string, error)
-
-	// LookupAllRecords queries all record types for a hostname,
-	// returning results keyed by nameserver then record type.
-	LookupAllRecords(
-		ctx context.Context,
-		hostname string,
-	) (map[string]map[string][]string, error)
-
-	// ResolveIPAddresses resolves a hostname to all IP addresses.
-	ResolveIPAddresses(
-		ctx context.Context,
-		hostname string,
-	) ([]string, error)
-}
-
-// PortChecker tests TCP port connectivity.
-type PortChecker interface {
-	// CheckPort tests TCP connectivity to an address and port.
-	CheckPort(
-		ctx context.Context,
-		address string,
-		port int,
-	) (*portcheck.PortResult, error)
-}
-
-// TLSChecker inspects TLS certificates.
-type TLSChecker interface {
-	// CheckCertificate connects via TLS and returns cert info.
-	CheckCertificate(
-		ctx context.Context,
-		ip string,
-		hostname string,
-	) (*tlscheck.CertificateInfo, error)
-}
-
-// Notifier delivers notifications to configured endpoints.
-type Notifier interface {
-	// SendNotification sends a notification with the given
-	// details.
-	SendNotification(
-		ctx context.Context,
-		title, message, priority string,
-	)
-}

internal/watcher/watcher.go

@@ -1,31 +1,21 @@
+// Package watcher provides the main monitoring orchestrator and scheduler.
 package watcher
 
 import (
 	"context"
-	"fmt"
 	"log/slog"
-	"sort"
-	"strings"
-	"sync"
-	"time"
 
 	"go.uber.org/fx"
 
 	"sneak.berlin/go/dnswatcher/internal/config"
 	"sneak.berlin/go/dnswatcher/internal/logger"
+	"sneak.berlin/go/dnswatcher/internal/notify"
+	"sneak.berlin/go/dnswatcher/internal/portcheck"
+	"sneak.berlin/go/dnswatcher/internal/resolver"
 	"sneak.berlin/go/dnswatcher/internal/state"
 	"sneak.berlin/go/dnswatcher/internal/tlscheck"
 )
 
-// monitoredPorts are the TCP ports checked for each IP address.
-var monitoredPorts = []int{80, 443} //nolint:gochecknoglobals
-
-// tlsPort is the port used for TLS certificate checks.
-const tlsPort = 443
-
-// hoursPerDay converts days to hours for duration calculations.
-const hoursPerDay = 24
-
 // Params contains dependencies for Watcher.
 type Params struct {
 	fx.In
@@ -33,92 +23,61 @@ type Params struct {
 	Logger    *logger.Logger
 	Config    *config.Config
 	State     *state.State
-	Resolver  DNSResolver
+	Resolver  *resolver.Resolver
-	PortCheck PortChecker
+	PortCheck *portcheck.Checker
-	TLSCheck  TLSChecker
+	TLSCheck  *tlscheck.Checker
-	Notify    Notifier
+	Notify    *notify.Service
 }
 
 // Watcher orchestrates all monitoring checks on a schedule.
 type Watcher struct {
-	log              *slog.Logger
+	log       *slog.Logger
-	config           *config.Config
+	config    *config.Config
-	state            *state.State
+	state     *state.State
-	resolver         DNSResolver
+	resolver  *resolver.Resolver
-	portCheck        PortChecker
+	portCheck *portcheck.Checker
-	tlsCheck         TLSChecker
+	tlsCheck  *tlscheck.Checker
-	notify           Notifier
+	notify    *notify.Service
-	cancel           context.CancelFunc
+	cancel    context.CancelFunc
-	firstRun         bool
-	expiryNotifiedMu sync.Mutex
-	expiryNotified   map[string]time.Time
 }
 
-// New creates a new Watcher instance wired into the fx lifecycle.
+// New creates a new Watcher instance.
 func New(
 	lifecycle fx.Lifecycle,
 	params Params,
 ) (*Watcher, error) {
-	w := &Watcher{
+	watcher := &Watcher{
-		log:            params.Logger.Get(),
+		log:       params.Logger.Get(),
-		config:         params.Config,
+		config:    params.Config,
-		state:          params.State,
+		state:     params.State,
-		resolver:       params.Resolver,
+		resolver:  params.Resolver,
-		portCheck:      params.PortCheck,
+		portCheck: params.PortCheck,
-		tlsCheck:       params.TLSCheck,
+		tlsCheck:  params.TLSCheck,
-		notify:         params.Notify,
+		notify:    params.Notify,
-		firstRun:       true,
-		expiryNotified: make(map[string]time.Time),
 	}
 
 	lifecycle.Append(fx.Hook{
-		OnStart: func(_ context.Context) error {
+		OnStart: func(startCtx context.Context) error {
-			// Use context.Background() — the fx startup context
+			ctx, cancel := context.WithCancel(startCtx)
-			// expires after startup completes, so deriving from it
+			watcher.cancel = cancel
-			// would cancel the watcher immediately. The watcher's
-			// lifetime is controlled by w.cancel in OnStop.
-			ctx, cancel := context.WithCancel(context.Background())
-			w.cancel = cancel
 
-			go w.Run(ctx) //nolint:contextcheck // intentionally not derived from startCtx
+			go watcher.Run(ctx)
 
 			return nil
 		},
 		OnStop: func(_ context.Context) error {
-			if w.cancel != nil {
+			if watcher.cancel != nil {
-				w.cancel()
+				watcher.cancel()
 			}
 
 			return nil
 		},
 	})
 
-	return w, nil
+	return watcher, nil
 }
 
-// NewForTest creates a Watcher without fx for unit testing.
+// Run starts the monitoring loop.
-func NewForTest(
-	cfg *config.Config,
-	st *state.State,
-	res DNSResolver,
-	pc PortChecker,
-	tc TLSChecker,
-	n Notifier,
-) *Watcher {
-	return &Watcher{
-		log:            slog.Default(),
-		config:         cfg,
-		state:          st,
-		resolver:       res,
-		portCheck:      pc,
-		tlsCheck:       tc,
-		notify:         n,
-		firstRun:       true,
-		expiryNotified: make(map[string]time.Time),
-	}
-}
-
-// Run starts the monitoring loop with periodic scheduling.
 func (w *Watcher) Run(ctx context.Context) {
 	w.log.Info(
 		"watcher starting",
@@ -128,779 +87,8 @@ func (w *Watcher) Run(ctx context.Context) {
 		"tlsInterval", w.config.TLSInterval,
 	)
 
-	w.RunOnce(ctx)
+	// Stub: wait for context cancellation.
-
+	// Implementation will add initial check + periodic scheduling.
-	dnsTicker := time.NewTicker(w.config.DNSInterval)
+	<-ctx.Done()
-	tlsTicker := time.NewTicker(w.config.TLSInterval)
+	w.log.Info("watcher stopped")
-
-	defer dnsTicker.Stop()
-	defer tlsTicker.Stop()
-
-	for {
-		select {
-		case <-ctx.Done():
-			w.log.Info("watcher stopped")
-
-			return
-		case <-dnsTicker.C:
-			w.runDNSChecks(ctx)
-
-			w.checkAllPorts(ctx)
-			w.saveState()
-		case <-tlsTicker.C:
-			// Run DNS first so TLS checks use freshly
-			// resolved IP addresses, not stale ones from
-			// a previous cycle.
-			w.runDNSChecks(ctx)
-
-			w.runTLSChecks(ctx)
-			w.saveState()
-		}
-	}
-}
-
-// RunOnce performs a single complete monitoring cycle.
-// DNS checks run first so that port and TLS checks use
-// freshly resolved IP addresses. Port checks run before
-// TLS because TLS checks only target IPs with an open
-// port 443.
-func (w *Watcher) RunOnce(ctx context.Context) {
-	w.detectFirstRun()
-
-	// Phase 1: DNS resolution must complete first so that
-	// subsequent checks use fresh IP addresses.
-	w.runDNSChecks(ctx)
-
-	// Phase 2: Port checks populate port state that TLS
-	// checks depend on (TLS only targets IPs where port
-	// 443 is open).
-	w.checkAllPorts(ctx)
-
-	// Phase 3: TLS checks use fresh DNS IPs and current
-	// port state.
-	w.runTLSChecks(ctx)
-
-	w.saveState()
-	w.firstRun = false
-}
-
-func (w *Watcher) detectFirstRun() {
-	snap := w.state.GetSnapshot()
-	hasState := len(snap.Domains) > 0 ||
-		len(snap.Hostnames) > 0 ||
-		len(snap.Ports) > 0 ||
-		len(snap.Certificates) > 0
-
-	if hasState {
-		w.firstRun = false
-	}
-}
-
-// runDNSChecks performs DNS resolution for all configured domains
-// and hostnames, updating state with freshly resolved records.
-// This must complete before port or TLS checks run so those
-// checks operate on current IP addresses.
-func (w *Watcher) runDNSChecks(ctx context.Context) {
-	for _, domain := range w.config.Domains {
-		w.checkDomain(ctx, domain)
-	}
-
-	for _, hostname := range w.config.Hostnames {
-		w.checkHostname(ctx, hostname)
-	}
-}
-
-func (w *Watcher) checkDomain(
-	ctx context.Context,
-	domain string,
-) {
-	nameservers, err := w.resolver.LookupNS(ctx, domain)
-	if err != nil {
-		w.log.Error(
-			"failed to lookup NS",
-			"domain", domain,
-			"error", err,
-		)
-
-		return
-	}
-
-	sort.Strings(nameservers)
-
-	now := time.Now().UTC()
-
-	prev, hasPrev := w.state.GetDomainState(domain)
-	if hasPrev && !w.firstRun {
-		w.detectNSChanges(ctx, domain, prev.Nameservers, nameservers)
-	}
-
-	w.state.SetDomainState(domain, &state.DomainState{
-		Nameservers: nameservers,
-		LastChecked: now,
-	})
-
-	// Also look up A/AAAA records for the apex domain so that
-	// port and TLS checks (which read HostnameState) can find
-	// the domain's IP addresses.
-	records, err := w.resolver.LookupAllRecords(ctx, domain)
-	if err != nil {
-		w.log.Error(
-			"failed to lookup records for domain",
-			"domain", domain,
-			"error", err,
-		)
-
-		return
-	}
-
-	prevHS, hasPrevHS := w.state.GetHostnameState(domain)
-	if hasPrevHS && !w.firstRun {
-		w.detectHostnameChanges(ctx, domain, prevHS, records)
-	}
-
-	newState := buildHostnameState(records, now)
-	w.state.SetHostnameState(domain, newState)
-}
-
-func (w *Watcher) detectNSChanges(
-	ctx context.Context,
-	domain string,
-	oldNS, newNS []string,
-) {
-	oldSet := toSet(oldNS)
-	newSet := toSet(newNS)
-
-	var added, removed []string
-
-	for ns := range newSet {
-		if !oldSet[ns] {
-			added = append(added, ns)
-		}
-	}
-
-	for ns := range oldSet {
-		if !newSet[ns] {
-			removed = append(removed, ns)
-		}
-	}
-
-	if len(added) == 0 && len(removed) == 0 {
-		return
-	}
-
-	msg := fmt.Sprintf(
-		"Domain: %s\nAdded: %s\nRemoved: %s",
-		domain,
-		strings.Join(added, ", "),
-		strings.Join(removed, ", "),
-	)
-
-	w.notify.SendNotification(
-		ctx,
-		"NS Change: "+domain,
-		msg,
-		"warning",
-	)
-}
-
-func (w *Watcher) checkHostname(
-	ctx context.Context,
-	hostname string,
-) {
-	records, err := w.resolver.LookupAllRecords(ctx, hostname)
-	if err != nil {
-		w.log.Error(
-			"failed to lookup records",
-			"hostname", hostname,
-			"error", err,
-		)
-
-		return
-	}
-
-	now := time.Now().UTC()
-	prev, hasPrev := w.state.GetHostnameState(hostname)
-
-	if hasPrev && !w.firstRun {
-		w.detectHostnameChanges(ctx, hostname, prev, records)
-	}
-
-	newState := buildHostnameState(records, now)
-	w.state.SetHostnameState(hostname, newState)
-}
-
-func buildHostnameState(
-	records map[string]map[string][]string,
-	now time.Time,
-) *state.HostnameState {
-	hs := &state.HostnameState{
-		RecordsByNameserver: make(
-			map[string]*state.NameserverRecordState,
-		),
-		LastChecked: now,
-	}
-
-	for ns, recs := range records {
-		hs.RecordsByNameserver[ns] = &state.NameserverRecordState{
-			Records:     recs,
-			Status:      "ok",
-			LastChecked: now,
-		}
-	}
-
-	return hs
-}
-
-func (w *Watcher) detectHostnameChanges(
-	ctx context.Context,
-	hostname string,
-	prev *state.HostnameState,
-	current map[string]map[string][]string,
-) {
-	w.detectRecordChanges(ctx, hostname, prev, current)
-	w.detectNSDisappearances(ctx, hostname, prev, current)
-	w.detectInconsistencies(ctx, hostname, current)
-}
-
-func (w *Watcher) detectRecordChanges(
-	ctx context.Context,
-	hostname string,
-	prev *state.HostnameState,
-	current map[string]map[string][]string,
-) {
-	for ns, recs := range current {
-		prevNS, ok := prev.RecordsByNameserver[ns]
-		if !ok {
-			continue
-		}
-
-		if recordsEqual(prevNS.Records, recs) {
-			continue
-		}
-
-		msg := fmt.Sprintf(
-			"Hostname: %s\nNameserver: %s\n"+
-				"Old: %v\nNew: %v",
-			hostname, ns,
-			prevNS.Records, recs,
-		)
-
-		w.notify.SendNotification(
-			ctx,
-			"Record Change: "+hostname,
-			msg,
-			"warning",
-		)
-	}
-}
-
-func (w *Watcher) detectNSDisappearances(
-	ctx context.Context,
-	hostname string,
-	prev *state.HostnameState,
-	current map[string]map[string][]string,
-) {
-	for ns, prevNS := range prev.RecordsByNameserver {
-		if _, ok := current[ns]; ok || prevNS.Status != "ok" {
-			continue
-		}
-
-		msg := fmt.Sprintf(
-			"Hostname: %s\nNameserver: %s disappeared",
-			hostname, ns,
-		)
-
-		w.notify.SendNotification(
-			ctx,
-			"NS Failure: "+hostname,
-			msg,
-			"error",
-		)
-	}
-
-	for ns := range current {
-		prevNS, ok := prev.RecordsByNameserver[ns]
-		if !ok || prevNS.Status != "error" {
-			continue
-		}
-
-		msg := fmt.Sprintf(
-			"Hostname: %s\nNameserver: %s recovered",
-			hostname, ns,
-		)
-
-		w.notify.SendNotification(
-			ctx,
-			"NS Recovery: "+hostname,
-			msg,
-			"success",
-		)
-	}
-}
-
-func (w *Watcher) detectInconsistencies(
-	ctx context.Context,
-	hostname string,
-	current map[string]map[string][]string,
-) {
-	nameservers := make([]string, 0, len(current))
-	for ns := range current {
-		nameservers = append(nameservers, ns)
-	}
-
-	sort.Strings(nameservers)
-
-	for i := range len(nameservers) - 1 {
-		ns1 := nameservers[i]
-		ns2 := nameservers[i+1]
-
-		if recordsEqual(current[ns1], current[ns2]) {
-			continue
-		}
-
-		msg := fmt.Sprintf(
-			"Hostname: %s\n%s: %v\n%s: %v",
-			hostname,
-			ns1, current[ns1],
-			ns2, current[ns2],
-		)
-
-		w.notify.SendNotification(
-			ctx,
-			"Inconsistency: "+hostname,
-			msg,
-			"warning",
-		)
-	}
-}
-
-func (w *Watcher) checkAllPorts(ctx context.Context) {
-	// Phase 1: Build current IP:port → hostname associations
-	// from fresh DNS data.
-	associations := w.buildPortAssociations()
-
-	// Phase 2: Check each unique IP:port and update state
-	// with the full set of associated hostnames.
-	for key, hostnames := range associations {
-		ip, port := parsePortKey(key)
-		if port == 0 {
-			continue
-		}
-
-		w.checkSinglePort(ctx, ip, port, hostnames)
-	}
-
-	// Phase 3: Remove port state entries that no longer have
-	// any hostname referencing them.
-	w.cleanupStalePorts(associations)
-}
-
-// buildPortAssociations constructs a map from IP:port keys to
-// the sorted set of hostnames currently resolving to that IP.
-func (w *Watcher) buildPortAssociations() map[string][]string {
-	assoc := make(map[string]map[string]bool)
-
-	allNames := make(
-		[]string, 0,
-		len(w.config.Hostnames)+len(w.config.Domains),
-	)
-	allNames = append(allNames, w.config.Hostnames...)
-	allNames = append(allNames, w.config.Domains...)
-
-	for _, name := range allNames {
-		ips := w.collectIPs(name)
-		for _, ip := range ips {
-			for _, port := range monitoredPorts {
-				key := fmt.Sprintf("%s:%d", ip, port)
-				if assoc[key] == nil {
-					assoc[key] = make(map[string]bool)
-				}
-
-				assoc[key][name] = true
-			}
-		}
-	}
-
-	result := make(map[string][]string, len(assoc))
-	for key, set := range assoc {
-		hostnames := make([]string, 0, len(set))
-		for h := range set {
-			hostnames = append(hostnames, h)
-		}
-
-		sort.Strings(hostnames)
-
-		result[key] = hostnames
-	}
-
-	return result
-}
-
-// parsePortKey splits an "ip:port" key into its components.
-func parsePortKey(key string) (string, int) {
-	lastColon := strings.LastIndex(key, ":")
-	if lastColon < 0 {
-		return key, 0
-	}
-
-	ip := key[:lastColon]
-
-	var p int
-
-	_, err := fmt.Sscanf(key[lastColon+1:], "%d", &p)
-	if err != nil {
-		return ip, 0
-	}
-
-	return ip, p
-}
-
-// cleanupStalePorts removes port state entries that are no
-// longer referenced by any hostname in the current DNS data.
-func (w *Watcher) cleanupStalePorts(
-	currentAssociations map[string][]string,
-) {
-	for _, key := range w.state.GetAllPortKeys() {
-		if _, exists := currentAssociations[key]; !exists {
-			w.state.DeletePortState(key)
-		}
-	}
-}
-
-func (w *Watcher) collectIPs(hostname string) []string {
-	hs, ok := w.state.GetHostnameState(hostname)
-	if !ok {
-		return nil
-	}
-
-	ipSet := make(map[string]bool)
-
-	for _, nsState := range hs.RecordsByNameserver {
-		for _, ip := range nsState.Records["A"] {
-			ipSet[ip] = true
-		}
-
-		for _, ip := range nsState.Records["AAAA"] {
-			ipSet[ip] = true
-		}
-	}
-
-	result := make([]string, 0, len(ipSet))
-	for ip := range ipSet {
-		result = append(result, ip)
-	}
-
-	sort.Strings(result)
-
-	return result
-}
-
-func (w *Watcher) checkSinglePort(
-	ctx context.Context,
-	ip string,
-	port int,
-	hostnames []string,
-) {
-	result, err := w.portCheck.CheckPort(ctx, ip, port)
-	if err != nil {
-		w.log.Error(
-			"port check failed",
-			"ip", ip,
-			"port", port,
-			"error", err,
-		)
-
-		return
-	}
-
-	key := fmt.Sprintf("%s:%d", ip, port)
-	now := time.Now().UTC()
-	prev, hasPrev := w.state.GetPortState(key)
-
-	if hasPrev && !w.firstRun && prev.Open != result.Open {
-		stateStr := "closed"
-		if result.Open {
-			stateStr = "open"
-		}
-
-		msg := fmt.Sprintf(
-			"Hosts: %s\nAddress: %s\nPort now %s",
-			strings.Join(hostnames, ", "), key, stateStr,
-		)
-
-		w.notify.SendNotification(
-			ctx,
-			"Port Change: "+key,
-			msg,
-			"warning",
-		)
-	}
-
-	w.state.SetPortState(key, &state.PortState{
-		Open:        result.Open,
-		Hostnames:   hostnames,
-		LastChecked: now,
-	})
-}
-
-func (w *Watcher) runTLSChecks(ctx context.Context) {
-	for _, hostname := range w.config.Hostnames {
-		w.checkTLSForHostname(ctx, hostname)
-	}
-
-	for _, domain := range w.config.Domains {
-		w.checkTLSForHostname(ctx, domain)
-	}
-}
-
-func (w *Watcher) checkTLSForHostname(
-	ctx context.Context,
-	hostname string,
-) {
-	ips := w.collectIPs(hostname)
-
-	for _, ip := range ips {
-		portKey := fmt.Sprintf("%s:%d", ip, tlsPort)
-
-		ps, ok := w.state.GetPortState(portKey)
-		if !ok || !ps.Open {
-			continue
-		}
-
-		w.checkTLSCert(ctx, ip, hostname)
-	}
-}
-
-func (w *Watcher) checkTLSCert(
-	ctx context.Context,
-	ip string,
-	hostname string,
-) {
-	cert, err := w.tlsCheck.CheckCertificate(ctx, ip, hostname)
-	certKey := fmt.Sprintf("%s:%d:%s", ip, tlsPort, hostname)
-	now := time.Now().UTC()
-	prev, hasPrev := w.state.GetCertificateState(certKey)
-
-	if err != nil {
-		w.handleTLSError(
-			ctx, certKey, hostname, ip,
-			hasPrev, prev, now, err,
-		)
-
-		return
-	}
-
-	w.handleTLSSuccess(
-		ctx, certKey, hostname, ip,
-		hasPrev, prev, now, cert,
-	)
-}
-
-func (w *Watcher) handleTLSError(
-	ctx context.Context,
-	certKey, hostname, ip string,
-	hasPrev bool,
-	prev *state.CertificateState,
-	now time.Time,
-	err error,
-) {
-	if hasPrev && !w.firstRun && prev.Status == "ok" {
-		msg := fmt.Sprintf(
-			"Host: %s\nIP: %s\nError: %s",
-			hostname, ip, err,
-		)
-
-		w.notify.SendNotification(
-			ctx,
-			"TLS Failure: "+hostname,
-			msg,
-			"error",
-		)
-	}
-
-	w.state.SetCertificateState(
-		certKey, &state.CertificateState{
-			Status:      "error",
-			Error:       err.Error(),
-			LastChecked: now,
-		},
-	)
-}
-
-func (w *Watcher) handleTLSSuccess(
-	ctx context.Context,
-	certKey, hostname, ip string,
-	hasPrev bool,
-	prev *state.CertificateState,
-	now time.Time,
-	cert *tlscheck.CertificateInfo,
-) {
-	if hasPrev && !w.firstRun {
-		w.detectTLSChanges(ctx, hostname, ip, prev, cert)
-	}
-
-	w.checkTLSExpiry(ctx, hostname, ip, cert)
-
-	w.state.SetCertificateState(
-		certKey, &state.CertificateState{
-			CommonName:              cert.CommonName,
-			Issuer:                  cert.Issuer,
-			NotAfter:                cert.NotAfter,
-			SubjectAlternativeNames: cert.SubjectAlternativeNames,
-			Status:                  "ok",
-			LastChecked:             now,
-		},
-	)
-}
-
-func (w *Watcher) detectTLSChanges(
-	ctx context.Context,
-	hostname, ip string,
-	prev *state.CertificateState,
-	cert *tlscheck.CertificateInfo,
-) {
-	if prev.Status == "error" {
-		msg := fmt.Sprintf(
-			"Host: %s\nIP: %s\nTLS recovered",
-			hostname, ip,
-		)
-
-		w.notify.SendNotification(
-			ctx,
-			"TLS Recovery: "+hostname,
-			msg,
-			"success",
-		)
-
-		return
-	}
-
-	changed := prev.CommonName != cert.CommonName ||
-		prev.Issuer != cert.Issuer ||
-		!sliceEqual(
-			prev.SubjectAlternativeNames,
-			cert.SubjectAlternativeNames,
-		)
-
-	if !changed {
-		return
-	}
-
-	msg := fmt.Sprintf(
-		"Host: %s\nIP: %s\n"+
-			"Old CN: %s, Issuer: %s\n"+
-			"New CN: %s, Issuer: %s",
-		hostname, ip,
-		prev.CommonName, prev.Issuer,
-		cert.CommonName, cert.Issuer,
-	)
-
-	w.notify.SendNotification(
-		ctx,
-		"TLS Certificate Change: "+hostname,
-		msg,
-		"warning",
-	)
-}
-
-func (w *Watcher) checkTLSExpiry(
-	ctx context.Context,
-	hostname, ip string,
-	cert *tlscheck.CertificateInfo,
-) {
-	daysLeft := time.Until(cert.NotAfter).Hours() / hoursPerDay
-	warningDays := float64(w.config.TLSExpiryWarning)
-
-	if daysLeft > warningDays {
-		return
-	}
-
-	// Deduplicate expiry warnings: don't re-notify for the same
-	// hostname within the TLS check interval.
-	dedupKey := fmt.Sprintf("expiry:%s:%s", hostname, ip)
-
-	w.expiryNotifiedMu.Lock()
-
-	lastNotified, seen := w.expiryNotified[dedupKey]
-	if seen && time.Since(lastNotified) < w.config.TLSInterval {
-		w.expiryNotifiedMu.Unlock()
-
-		return
-	}
-
-	w.expiryNotified[dedupKey] = time.Now()
-	w.expiryNotifiedMu.Unlock()
-
-	msg := fmt.Sprintf(
-		"Host: %s\nIP: %s\nCN: %s\n"+
-			"Expires: %s (%.0f days)",
-		hostname, ip, cert.CommonName,
-		cert.NotAfter.Format(time.RFC3339),
-		daysLeft,
-	)
-
-	w.notify.SendNotification(
-		ctx,
-		"TLS Expiry Warning: "+hostname,
-		msg,
-		"warning",
-	)
-}
-
-func (w *Watcher) saveState() {
-	err := w.state.Save()
-	if err != nil {
-		w.log.Error("failed to save state", "error", err)
-	}
-}
-
-// --- Utility functions ---
-
-func toSet(items []string) map[string]bool {
-	set := make(map[string]bool, len(items))
-	for _, item := range items {
-		set[item] = true
-	}
-
-	return set
-}
-
-func recordsEqual(
-	a, b map[string][]string,
-) bool {
-	if len(a) != len(b) {
-		return false
-	}
-
-	for k, av := range a {
-		bv, ok := b[k]
-		if !ok || !sliceEqual(av, bv) {
-			return false
-		}
-	}
-
-	return true
-}
-
-func sliceEqual(a, b []string) bool {
-	if len(a) != len(b) {
-		return false
-	}
-
-	aSorted := make([]string, len(a))
-	bSorted := make([]string, len(b))
-
-	copy(aSorted, a)
-	copy(bSorted, b)
-
-	sort.Strings(aSorted)
-	sort.Strings(bSorted)
-
-	for i := range aSorted {
-		if aSorted[i] != bSorted[i] {
-			return false
-		}
-	}
-
-	return true
 }

internal/watcher/watcher_test.go

@@ -1,793 +0,0 @@
-package watcher_test
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"sync"
-	"testing"
-	"time"
-
-	"sneak.berlin/go/dnswatcher/internal/config"
-	"sneak.berlin/go/dnswatcher/internal/portcheck"
-	"sneak.berlin/go/dnswatcher/internal/state"
-	"sneak.berlin/go/dnswatcher/internal/tlscheck"
-	"sneak.berlin/go/dnswatcher/internal/watcher"
-)
-
-// errNotFound is returned when mock data is missing.
-var errNotFound = errors.New("not found")
-
-// --- Mock implementations ---
-
-type mockResolver struct {
-	mu             sync.Mutex
-	nsRecords      map[string][]string
-	allRecords     map[string]map[string]map[string][]string
-	ipAddresses    map[string][]string
-	lookupNSErr    error
-	allRecordsErr  error
-	resolveIPErr   error
-	lookupNSCalls  int
-	allRecordCalls int
-}
-
-func (m *mockResolver) LookupNS(
-	_ context.Context,
-	domain string,
-) ([]string, error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	m.lookupNSCalls++
-
-	if m.lookupNSErr != nil {
-		return nil, m.lookupNSErr
-	}
-
-	ns, ok := m.nsRecords[domain]
-	if !ok {
-		return nil, fmt.Errorf(
-			"%w: NS for %s", errNotFound, domain,
-		)
-	}
-
-	return ns, nil
-}
-
-func (m *mockResolver) LookupAllRecords(
-	_ context.Context,
-	hostname string,
-) (map[string]map[string][]string, error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	m.allRecordCalls++
-
-	if m.allRecordsErr != nil {
-		return nil, m.allRecordsErr
-	}
-
-	recs, ok := m.allRecords[hostname]
-	if !ok {
-		return nil, fmt.Errorf(
-			"%w: records for %s", errNotFound, hostname,
-		)
-	}
-
-	return recs, nil
-}
-
-func (m *mockResolver) ResolveIPAddresses(
-	_ context.Context,
-	hostname string,
-) ([]string, error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	if m.resolveIPErr != nil {
-		return nil, m.resolveIPErr
-	}
-
-	ips, ok := m.ipAddresses[hostname]
-	if !ok {
-		return nil, fmt.Errorf(
-			"%w: IPs for %s", errNotFound, hostname,
-		)
-	}
-
-	return ips, nil
-}
-
-type mockPortChecker struct {
-	mu      sync.Mutex
-	results map[string]bool
-	err     error
-	calls   int
-}
-
-func (m *mockPortChecker) CheckPort(
-	_ context.Context,
-	address string,
-	port int,
-) (*portcheck.PortResult, error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	m.calls++
-
-	if m.err != nil {
-		return nil, m.err
-	}
-
-	key := fmt.Sprintf("%s:%d", address, port)
-	open := m.results[key]
-
-	return &portcheck.PortResult{Open: open}, nil
-}
-
-type mockTLSChecker struct {
-	mu    sync.Mutex
-	certs map[string]*tlscheck.CertificateInfo
-	err   error
-	calls int
-}
-
-func (m *mockTLSChecker) CheckCertificate(
-	_ context.Context,
-	ip string,
-	hostname string,
-) (*tlscheck.CertificateInfo, error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	m.calls++
-
-	if m.err != nil {
-		return nil, m.err
-	}
-
-	key := fmt.Sprintf("%s:%s", ip, hostname)
-	cert, ok := m.certs[key]
-
-	if !ok {
-		return nil, fmt.Errorf(
-			"%w: cert for %s", errNotFound, key,
-		)
-	}
-
-	return cert, nil
-}
-
-type notification struct {
-	Title    string
-	Message  string
-	Priority string
-}
-
-type mockNotifier struct {
-	mu            sync.Mutex
-	notifications []notification
-}
-
-func (m *mockNotifier) SendNotification(
-	_ context.Context,
-	title, message, priority string,
-) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	m.notifications = append(m.notifications, notification{
-		Title:    title,
-		Message:  message,
-		Priority: priority,
-	})
-}
-
-func (m *mockNotifier) getNotifications() []notification {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	result := make([]notification, len(m.notifications))
-	copy(result, m.notifications)
-
-	return result
-}
-
-// --- Helper to build a Watcher for testing ---
-
-type testDeps struct {
-	resolver    *mockResolver
-	portChecker *mockPortChecker
-	tlsChecker  *mockTLSChecker
-	notifier    *mockNotifier
-	state       *state.State
-	config      *config.Config
-}
-
-func newTestWatcher(
-	t *testing.T,
-	cfg *config.Config,
-) (*watcher.Watcher, *testDeps) {
-	t.Helper()
-
-	deps := &testDeps{
-		resolver: &mockResolver{
-			nsRecords:   make(map[string][]string),
-			allRecords:  make(map[string]map[string]map[string][]string),
-			ipAddresses: make(map[string][]string),
-		},
-		portChecker: &mockPortChecker{
-			results: make(map[string]bool),
-		},
-		tlsChecker: &mockTLSChecker{
-			certs: make(map[string]*tlscheck.CertificateInfo),
-		},
-		notifier: &mockNotifier{},
-		config:   cfg,
-	}
-
-	deps.state = state.NewForTest()
-
-	w := watcher.NewForTest(
-		deps.config,
-		deps.state,
-		deps.resolver,
-		deps.portChecker,
-		deps.tlsChecker,
-		deps.notifier,
-	)
-
-	return w, deps
-}
-
-func defaultTestConfig(t *testing.T) *config.Config {
-	t.Helper()
-
-	return &config.Config{
-		DNSInterval:      time.Hour,
-		TLSInterval:      12 * time.Hour,
-		TLSExpiryWarning: 7,
-		DataDir:          t.TempDir(),
-	}
-}
-
-func TestFirstRunBaseline(t *testing.T) {
-	t.Parallel()
-
-	cfg := defaultTestConfig(t)
-	cfg.Domains = []string{"example.com"}
-	cfg.Hostnames = []string{"www.example.com"}
-
-	w, deps := newTestWatcher(t, cfg)
-	setupBaselineMocks(deps)
-
-	w.RunOnce(t.Context())
-
-	assertNoNotifications(t, deps)
-	assertStatePopulated(t, deps)
-}
-
-func setupBaselineMocks(deps *testDeps) {
-	deps.resolver.nsRecords["example.com"] = []string{
-		"ns1.example.com.",
-		"ns2.example.com.",
-	}
-	deps.resolver.allRecords["example.com"] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"93.184.216.34"}},
-		"ns2.example.com.": {"A": {"93.184.216.34"}},
-	}
-	deps.resolver.allRecords["www.example.com"] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"93.184.216.34"}},
-		"ns2.example.com.": {"A": {"93.184.216.34"}},
-	}
-	deps.resolver.ipAddresses["www.example.com"] = []string{
-		"93.184.216.34",
-	}
-	deps.portChecker.results["93.184.216.34:80"] = true
-	deps.portChecker.results["93.184.216.34:443"] = true
-	deps.tlsChecker.certs["93.184.216.34:www.example.com"] = &tlscheck.CertificateInfo{
-		CommonName: "www.example.com",
-		Issuer:     "DigiCert",
-		NotAfter:   time.Now().Add(90 * 24 * time.Hour),
-		SubjectAlternativeNames: []string{
-			"www.example.com",
-		},
-	}
-	deps.tlsChecker.certs["93.184.216.34:example.com"] = &tlscheck.CertificateInfo{
-		CommonName: "example.com",
-		Issuer:     "DigiCert",
-		NotAfter:   time.Now().Add(90 * 24 * time.Hour),
-		SubjectAlternativeNames: []string{
-			"example.com",
-		},
-	}
-}
-
-func assertNoNotifications(
-	t *testing.T,
-	deps *testDeps,
-) {
-	t.Helper()
-
-	notifications := deps.notifier.getNotifications()
-	if len(notifications) != 0 {
-		t.Errorf(
-			"expected 0 notifications on first run, got %d",
-			len(notifications),
-		)
-	}
-}
-
-func assertStatePopulated(
-	t *testing.T,
-	deps *testDeps,
-) {
-	t.Helper()
-
-	snap := deps.state.GetSnapshot()
-
-	if len(snap.Domains) != 1 {
-		t.Errorf(
-			"expected 1 domain in state, got %d",
-			len(snap.Domains),
-		)
-	}
-
-	// Hostnames includes both explicit hostnames and domains
-	// (domains now also get hostname state for port/TLS checks).
-	if len(snap.Hostnames) < 1 {
-		t.Errorf(
-			"expected at least 1 hostname in state, got %d",
-			len(snap.Hostnames),
-		)
-	}
-}
-
-func TestDomainPortAndTLSChecks(t *testing.T) {
-	t.Parallel()
-
-	cfg := defaultTestConfig(t)
-	cfg.Domains = []string{"example.com"}
-
-	w, deps := newTestWatcher(t, cfg)
-
-	deps.resolver.nsRecords["example.com"] = []string{
-		"ns1.example.com.",
-	}
-	deps.resolver.allRecords["example.com"] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"93.184.216.34"}},
-	}
-	deps.portChecker.results["93.184.216.34:80"] = true
-	deps.portChecker.results["93.184.216.34:443"] = true
-	deps.tlsChecker.certs["93.184.216.34:example.com"] = &tlscheck.CertificateInfo{
-		CommonName: "example.com",
-		Issuer:     "DigiCert",
-		NotAfter:   time.Now().Add(90 * 24 * time.Hour),
-		SubjectAlternativeNames: []string{
-			"example.com",
-		},
-	}
-
-	w.RunOnce(t.Context())
-
-	snap := deps.state.GetSnapshot()
-
-	// Domain should have port state populated
-	if len(snap.Ports) == 0 {
-		t.Error("expected port state for domain, got none")
-	}
-
-	// Domain should have certificate state populated
-	if len(snap.Certificates) == 0 {
-		t.Error("expected certificate state for domain, got none")
-	}
-
-	// Verify port checker was actually called
-	deps.portChecker.mu.Lock()
-	calls := deps.portChecker.calls
-	deps.portChecker.mu.Unlock()
-
-	if calls == 0 {
-		t.Error("expected port checker to be called for domain")
-	}
-
-	// Verify TLS checker was actually called
-	deps.tlsChecker.mu.Lock()
-	tlsCalls := deps.tlsChecker.calls
-	deps.tlsChecker.mu.Unlock()
-
-	if tlsCalls == 0 {
-		t.Error("expected TLS checker to be called for domain")
-	}
-}
-
-func TestNSChangeDetection(t *testing.T) {
-	t.Parallel()
-
-	cfg := defaultTestConfig(t)
-	cfg.Domains = []string{"example.com"}
-
-	w, deps := newTestWatcher(t, cfg)
-
-	deps.resolver.nsRecords["example.com"] = []string{
-		"ns1.example.com.",
-		"ns2.example.com.",
-	}
-	deps.resolver.allRecords["example.com"] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"1.2.3.4"}},
-		"ns2.example.com.": {"A": {"1.2.3.4"}},
-	}
-	deps.portChecker.results["1.2.3.4:80"] = false
-	deps.portChecker.results["1.2.3.4:443"] = false
-
-	ctx := t.Context()
-	w.RunOnce(ctx)
-
-	deps.resolver.mu.Lock()
-	deps.resolver.nsRecords["example.com"] = []string{
-		"ns1.example.com.",
-		"ns3.example.com.",
-	}
-	deps.resolver.allRecords["example.com"] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"1.2.3.4"}},
-		"ns3.example.com.": {"A": {"1.2.3.4"}},
-	}
-	deps.resolver.mu.Unlock()
-
-	w.RunOnce(ctx)
-
-	notifications := deps.notifier.getNotifications()
-	if len(notifications) == 0 {
-		t.Error("expected notification for NS change")
-	}
-
-	found := false
-
-	for _, n := range notifications {
-		if n.Priority == "warning" {
-			found = true
-		}
-	}
-
-	if !found {
-		t.Error("expected warning-priority NS change notification")
-	}
-}
-
-func TestRecordChangeDetection(t *testing.T) {
-	t.Parallel()
-
-	cfg := defaultTestConfig(t)
-	cfg.Hostnames = []string{"www.example.com"}
-
-	w, deps := newTestWatcher(t, cfg)
-
-	deps.resolver.allRecords["www.example.com"] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"93.184.216.34"}},
-	}
-	deps.resolver.ipAddresses["www.example.com"] = []string{
-		"93.184.216.34",
-	}
-	deps.portChecker.results["93.184.216.34:80"] = false
-	deps.portChecker.results["93.184.216.34:443"] = false
-
-	ctx := t.Context()
-	w.RunOnce(ctx)
-
-	deps.resolver.mu.Lock()
-	deps.resolver.allRecords["www.example.com"] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"93.184.216.35"}},
-	}
-	deps.resolver.ipAddresses["www.example.com"] = []string{
-		"93.184.216.35",
-	}
-	deps.resolver.mu.Unlock()
-
-	deps.portChecker.mu.Lock()
-	deps.portChecker.results["93.184.216.35:80"] = false
-	deps.portChecker.results["93.184.216.35:443"] = false
-	deps.portChecker.mu.Unlock()
-
-	w.RunOnce(ctx)
-
-	notifications := deps.notifier.getNotifications()
-	if len(notifications) == 0 {
-		t.Error("expected notification for record change")
-	}
-}
-
-func TestPortStateChange(t *testing.T) {
-	t.Parallel()
-
-	cfg := defaultTestConfig(t)
-	cfg.Hostnames = []string{"www.example.com"}
-
-	w, deps := newTestWatcher(t, cfg)
-
-	deps.resolver.allRecords["www.example.com"] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"1.2.3.4"}},
-	}
-	deps.resolver.ipAddresses["www.example.com"] = []string{
-		"1.2.3.4",
-	}
-	deps.portChecker.results["1.2.3.4:80"] = true
-	deps.portChecker.results["1.2.3.4:443"] = true
-	deps.tlsChecker.certs["1.2.3.4:www.example.com"] = &tlscheck.CertificateInfo{
-		CommonName: "www.example.com",
-		Issuer:     "DigiCert",
-		NotAfter:   time.Now().Add(90 * 24 * time.Hour),
-		SubjectAlternativeNames: []string{
-			"www.example.com",
-		},
-	}
-
-	ctx := t.Context()
-	w.RunOnce(ctx)
-
-	deps.portChecker.mu.Lock()
-	deps.portChecker.results["1.2.3.4:443"] = false
-	deps.portChecker.mu.Unlock()
-
-	w.RunOnce(ctx)
-
-	notifications := deps.notifier.getNotifications()
-	if len(notifications) == 0 {
-		t.Error("expected notification for port state change")
-	}
-}
-
-func TestTLSExpiryWarning(t *testing.T) {
-	t.Parallel()
-
-	cfg := defaultTestConfig(t)
-	cfg.Hostnames = []string{"www.example.com"}
-
-	w, deps := newTestWatcher(t, cfg)
-
-	deps.resolver.allRecords["www.example.com"] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"1.2.3.4"}},
-	}
-	deps.resolver.ipAddresses["www.example.com"] = []string{
-		"1.2.3.4",
-	}
-	deps.portChecker.results["1.2.3.4:80"] = true
-	deps.portChecker.results["1.2.3.4:443"] = true
-	deps.tlsChecker.certs["1.2.3.4:www.example.com"] = &tlscheck.CertificateInfo{
-		CommonName: "www.example.com",
-		Issuer:     "DigiCert",
-		NotAfter:   time.Now().Add(3 * 24 * time.Hour),
-		SubjectAlternativeNames: []string{
-			"www.example.com",
-		},
-	}
-
-	ctx := t.Context()
-
-	// First run = baseline
-	w.RunOnce(ctx)
-
-	// Second run should warn about expiry
-	w.RunOnce(ctx)
-
-	notifications := deps.notifier.getNotifications()
-
-	found := false
-
-	for _, n := range notifications {
-		if n.Priority == "warning" {
-			found = true
-		}
-	}
-
-	if !found {
-		t.Errorf(
-			"expected expiry warning, got: %v",
-			notifications,
-		)
-	}
-}
-
-func TestTLSExpiryWarningDedup(t *testing.T) {
-	t.Parallel()
-
-	cfg := defaultTestConfig(t)
-	cfg.Hostnames = []string{"www.example.com"}
-	cfg.TLSInterval = 24 * time.Hour
-
-	w, deps := newTestWatcher(t, cfg)
-
-	deps.resolver.allRecords["www.example.com"] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"1.2.3.4"}},
-	}
-	deps.resolver.ipAddresses["www.example.com"] = []string{
-		"1.2.3.4",
-	}
-	deps.portChecker.results["1.2.3.4:80"] = true
-	deps.portChecker.results["1.2.3.4:443"] = true
-	deps.tlsChecker.certs["1.2.3.4:www.example.com"] = &tlscheck.CertificateInfo{
-		CommonName: "www.example.com",
-		Issuer:     "DigiCert",
-		NotAfter:   time.Now().Add(3 * 24 * time.Hour),
-		SubjectAlternativeNames: []string{
-			"www.example.com",
-		},
-	}
-
-	ctx := t.Context()
-
-	// First run = baseline, no notifications
-	w.RunOnce(ctx)
-
-	// Second run should fire one expiry warning
-	w.RunOnce(ctx)
-
-	// Third run should NOT fire another warning (dedup)
-	w.RunOnce(ctx)
-
-	notifications := deps.notifier.getNotifications()
-
-	expiryCount := 0
-
-	for _, n := range notifications {
-		if n.Title == "TLS Expiry Warning: www.example.com" {
-			expiryCount++
-		}
-	}
-
-	if expiryCount != 1 {
-		t.Errorf(
-			"expected exactly 1 expiry warning (dedup), got %d",
-			expiryCount,
-		)
-	}
-}
-
-func TestGracefulShutdown(t *testing.T) {
-	t.Parallel()
-
-	cfg := defaultTestConfig(t)
-	cfg.Domains = []string{"example.com"}
-	cfg.DNSInterval = 100 * time.Millisecond
-	cfg.TLSInterval = 100 * time.Millisecond
-
-	w, deps := newTestWatcher(t, cfg)
-
-	deps.resolver.nsRecords["example.com"] = []string{
-		"ns1.example.com.",
-	}
-	deps.resolver.allRecords["example.com"] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"1.2.3.4"}},
-	}
-	deps.portChecker.results["1.2.3.4:80"] = false
-	deps.portChecker.results["1.2.3.4:443"] = false
-
-	ctx, cancel := context.WithCancel(t.Context())
-
-	done := make(chan struct{})
-
-	go func() {
-		w.Run(ctx)
-		close(done)
-	}()
-
-	time.Sleep(250 * time.Millisecond)
-	cancel()
-
-	select {
-	case <-done:
-		// Shut down cleanly
-	case <-time.After(5 * time.Second):
-		t.Error("watcher did not shut down within timeout")
-	}
-}
-
-func setupHostnameIP(
-	deps *testDeps,
-	hostname, ip string,
-) {
-	deps.resolver.allRecords[hostname] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {ip}},
-	}
-	deps.portChecker.results[ip+":80"] = true
-	deps.portChecker.results[ip+":443"] = true
-	deps.tlsChecker.certs[ip+":"+hostname] = &tlscheck.CertificateInfo{
-		CommonName:              hostname,
-		Issuer:                  "DigiCert",
-		NotAfter:                time.Now().Add(90 * 24 * time.Hour),
-		SubjectAlternativeNames: []string{hostname},
-	}
-}
-
-func updateHostnameIP(deps *testDeps, hostname, ip string) {
-	deps.resolver.mu.Lock()
-	deps.resolver.allRecords[hostname] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {ip}},
-	}
-	deps.resolver.mu.Unlock()
-
-	deps.portChecker.mu.Lock()
-	deps.portChecker.results[ip+":80"] = true
-	deps.portChecker.results[ip+":443"] = true
-	deps.portChecker.mu.Unlock()
-
-	deps.tlsChecker.mu.Lock()
-	deps.tlsChecker.certs[ip+":"+hostname] = &tlscheck.CertificateInfo{
-		CommonName:              hostname,
-		Issuer:                  "DigiCert",
-		NotAfter:                time.Now().Add(90 * 24 * time.Hour),
-		SubjectAlternativeNames: []string{hostname},
-	}
-	deps.tlsChecker.mu.Unlock()
-}
-
-func TestDNSRunsBeforePortAndTLSChecks(t *testing.T) {
-	t.Parallel()
-
-	cfg := defaultTestConfig(t)
-	cfg.Hostnames = []string{"www.example.com"}
-
-	w, deps := newTestWatcher(t, cfg)
-
-	setupHostnameIP(deps, "www.example.com", "10.0.0.1")
-
-	ctx := t.Context()
-	w.RunOnce(ctx)
-
-	snap := deps.state.GetSnapshot()
-	if _, ok := snap.Ports["10.0.0.1:80"]; !ok {
-		t.Fatal("expected port state for 10.0.0.1:80")
-	}
-
-	// DNS changes to a new IP; port and TLS must pick it up.
-	updateHostnameIP(deps, "www.example.com", "10.0.0.2")
-
-	w.RunOnce(ctx)
-
-	snap = deps.state.GetSnapshot()
-
-	if _, ok := snap.Ports["10.0.0.2:80"]; !ok {
-		t.Error("port check used stale DNS: missing 10.0.0.2:80")
-	}
-
-	certKey := "10.0.0.2:443:www.example.com"
-	if _, ok := snap.Certificates[certKey]; !ok {
-		t.Error("TLS check used stale DNS: missing " + certKey)
-	}
-}
-
-func TestNSFailureAndRecovery(t *testing.T) {
-	t.Parallel()
-
-	cfg := defaultTestConfig(t)
-	cfg.Hostnames = []string{"www.example.com"}
-
-	w, deps := newTestWatcher(t, cfg)
-
-	deps.resolver.allRecords["www.example.com"] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"1.2.3.4"}},
-		"ns2.example.com.": {"A": {"1.2.3.4"}},
-	}
-	deps.resolver.ipAddresses["www.example.com"] = []string{
-		"1.2.3.4",
-	}
-	deps.portChecker.results["1.2.3.4:80"] = false
-	deps.portChecker.results["1.2.3.4:443"] = false
-
-	ctx := t.Context()
-
-	w.RunOnce(ctx)
-
-	deps.resolver.mu.Lock()
-	deps.resolver.allRecords["www.example.com"] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"1.2.3.4"}},
-	}
-	deps.resolver.mu.Unlock()
-
-	w.RunOnce(ctx)
-
-	notifications := deps.notifier.getNotifications()
-	if len(notifications) == 0 {
-		t.Error("expected notification for NS disappearance")
-	}
-}