signalk-wakelogger 0.2.0-beta.0

package/docs/original-plan-gap-audit.md

@@ -0,0 +1,47 @@
+# Original plan gap audit
+
+This audit compares the implementation with the original 44-section implementation plan. “Implemented” means code and automated coverage exist; it does not substitute for hardware or fleet evidence.
+
+| Original plan area | Status | Evidence or remaining gate |
+|---|---|---|
+| Purpose, scope and cloud/plugin boundary | Implemented | Live transport only; no archive upload, jurisdiction logic, cloud business rules or Signal K Track API provider. |
+| TypeScript plugin lifecycle and offline startup | Implemented | Idempotent lifecycle and unpaired/offline integration test. |
+| Signal K acquisition and normalization | Implemented for approved scope | Position/time, SOG, COG, true/magnetic heading, depth and apparent wind. Machinery, battery and tank data were removed by product decision. |
+| Path sampling and remote profiles | Implemented | Versioned per-path periods for all three network modes; approved cloud profiles are persisted and acknowledged. |
+| JSON protocol, batching and persistent sequence | Implemented | Protocol v1, bounded payloads, durable sequence assignment and cloud deduplication/ACK contract. |
+| Durable outbox and retention | Implemented | Database API-preferred abstraction, native-free file fallback, crash-tail recovery, bounds, explicit sequence gaps and credential-bound backend selection that rejects partial-state sequence resets. Real released Database API compatibility remains an upstream availability gate. |
+| MQTT 5, TLS, QoS 1 and ACL isolation | Implemented | Verified TLS, scoped topics, Last Will, reconnect jitter and app-level durable ACK. Disposable real-Mosquitto CI and the packaged Signal K Docker scenario verify TLS transport and crash recovery; release-environment ACL isolation remains a release-candidate gate. |
+| Reconnect priority and constrained transport | Implemented | Retained current state, live sample priority, four bounded in-flight backlog batches, byte-rate limits and ACK/reconnect health modes. |
+| Pairing and credential handling | Implemented | Short-lived single-use pairing, bounded retry, per-device credentials, protected storage, transactional replacement, explicit revocation status and an admin-only local forget action that preserves retired outboxes/sequences. |
+| Tracking and trip evidence | Implemented within Wake Logger protocol | Persistent local evidence state; cloud remains authoritative. Evidence never creates a competing Signal K track service. |
+| Status and cloud operations | Implemented | Queue, disk, age, drops, backend, mode, ACK latency, reconnect and profile revision metrics. |
+| Unit, crash and integration testing | Implemented; hardware soak remains | Automated normalization, file/database outbox, corruption, lifecycle, real-broker transport, profile/adaptive, accelerated 24-hour restart/ACK recovery, three-day sampling and legacy-profile upgrade tests exist. A packaged Docker scenario adds real Signal K sample input, verified HTTPS/MQTT TLS, broker outage, `SIGKILL` and volume recovery. The extended outage and upgrade matrix must still run on target hardware. |
+| Signal K CI and registry preparation | Implemented and passing | Normal Node 20/22 CI and the reusable Signal K matrix pass on Linux x64, Linux ARM64, ARMv7/Cerbo emulation, macOS and Windows. Signal K Server latest installs, enables and starts the packaged plugin on Node 22/24. The official registry harness preflight loads and activates it without configuration or unstubbed API use; install/tests/audit/changelog/screenshots meet the current 100-point criteria. |
+| Bandwidth, CPU and memory validation | External evidence pending | Measure on the target Raspberry Pi/ARM installation under live, outage and replay workloads; do not infer hardware results from development hosts. |
+| Raspberry Pi/ARM and real-vessel test | External evidence pending | Required before first-vessel and stable-production sign-off, but not for an npm beta. The beta is the field-validation channel. Hardware targets are intentionally not embedded in this public repository. |
+| npm/AppStore publication | Prepared, not executed | Physical hardware is not a beta prerequisite. The beta-only OIDC workflow uses an exact version tag, main ancestry, Node 24/npm 12 and the `beta` dist-tag. The available package name requires a documented one-time 2FA bootstrap before OIDC can be configured. No stable release is automated until its acceptance gate is agreed. |
+
+## npm beta gate
+
+- Normal CI and the Signal K reusable plugin matrix pass on the exact `main` commit.
+- The packaged Signal K/TLS/MQTT Docker recovery scenario passes on that commit.
+- The installed-package audit, package contents, metadata, changelog and public-repository scan pass.
+- The release uses a prerelease version and npm's `beta` dist-tag.
+
+Raspberry Pi, real-vessel, soak and target-hardware resource measurements are explicitly outside this publication gate. They remain product-readiness evidence and can be collected from the published beta.
+
+## First-vessel blockers
+
+- Repeat the green normal and reusable Signal K matrices against the exact release-candidate commit after any further code change.
+- Repeat the packaged TLS broker/ingestion scenario on the exact release-candidate commit and release environment.
+- Run restart, 30-minute outage and constrained-link scenarios on the intended Signal K host.
+- Record bandwidth, CPU, memory and queue disk results on that host.
+- Verify the documented install, upgrade and full-data-removal/re-pair semantics on the target host; partial credential-only restoration is rejected by design.
+
+## Stable public-release blockers
+
+- Complete multi-day poor-connectivity and upgrade soak evidence.
+- Complete real-vessel and ARM evidence.
+- Confirm the authoritative Signal K registry score and rendered screenshots after the first npm beta becomes discoverable in the actual AppStore.
+- Test credential revocation and broker ACL isolation in the release environment.
+- Agree the stable-release gate; the current workflow deliberately publishes beta tags only.

package/docs/pairing.md

@@ -0,0 +1,17 @@
+# Pairing and credentials
+
+The plugin POSTs `{ "code": "...", "name": "Signal K ..." }` to the configured HTTPS pairing endpoint. A valid response provides a nested device and credentials object containing device ID, required MQTT client ID, username, one-time password, host, port, TLS requirement, telemetry profile, association-status URL and device-scoped association token. Non-production endpoint overrides belong only in local Signal K configuration and must never be committed.
+
+The plugin accepts only HTTPS endpoints, bounded identifiers, DNS hostnames and valid TCP ports. The service should issue codes that are hashed at rest, single-use, account-authorized and expire after ten minutes. Each broker identity must be restricted to publishing its telemetry/state/status/events topics and subscribing only to its acknowledgement topic.
+
+Credentials are stored beneath `app.getDataDirPath()` with directory mode `0700` and file mode `0600`. Rotation should preserve device ID and sequence space. Device replacement creates a new device identity; Wake Logger keeps the current device active until provisioning the replacement succeeds, then revokes and disconnects the old broker client. There is no insecure TLS fallback and production credentials must never be placed in source, plugin configuration, screenshots or logs.
+
+Pairing retries only temporary network, timeout, rate-limit and server failures. It makes at most six attempts with 2, 4, 8, 16 and 30 second delays. An HTTP 400 means the code is invalid or expired and is not retried. If replacement pairing exhausts its retries, the existing credential remains active. Signal K status shows the attempt and delay so the operator can distinguish `Retry pairing` from a rejected code.
+
+The credential record keeps only a SHA-256 fingerprint of the last consumed pairing code. Restarting with that same single-use code does not retry pairing. Supplying a different code explicitly pairs a replacement device and atomically replaces the credential record; the raw pairing code is never copied into credential storage. Outboxes are device-scoped: a replacement starts its own sequence space while the retired device's unacknowledged files remain preserved locally and are never published under the new identity.
+
+Newly provisioned credentials can query their own association state over authenticated outbound HTTPS. After broker authentication fails, the plugin checks that endpoint. A confirmed revocation changes status to `Device revoked — enter a new pairing code` and stops local sampling/transmission; unavailable or inconclusive status checks leave the normal authentication failure intact. Older credentials without this status token remain compatible but cannot distinguish revocation until they pair once again.
+
+Signal K administrators may invoke `POST /plugins/signalk-wakelogger/forget-credentials`. The action closes active transport and removes only `credentials.json`. It records a non-secret retirement tombstone so the consumed code is not replayed, and preserves the installation identity, device-scoped outbox directories, sequence state and diagnostics. The operator must enter a different, fresh pairing code. This local action does not revoke cloud broker access by itself; use Wake Logger's vessel or site-admin revoke workflow when retiring the association.
+
+After the first outbox opens, the credential record is atomically bound to its selected `file` or `database` backend. If credentials survive but the backend marker is later missing or disagrees, startup fails visibly instead of recreating sequence 1 for the same cloud device. A normal upgrade or reinstall with the plugin data directory preserved retains credentials, binding and sequence state. Removing the entire data directory also removes credentials and requires pairing a newly provisioned device identity; selectively restoring credentials without their bound outbox state is intentionally rejected.

package/docs/release.md

@@ -0,0 +1,52 @@
+# Release process
+
+The repository is beta-only until the stable acceptance gate is agreed. A `prepublishOnly` guard rejects any version that does not end in `-beta.<number>` and any publish without the explicit `--tag beta` option. The GitHub workflow accepts only an exact `v<package-version>` tag and requires the tagged commit to be reachable from `main`. There is no stable or `latest` publishing path.
+
+Physical Raspberry Pi, target-hardware and real-vessel testing are not prerequisites for an npm beta. Beta publication is the supported way to collect that field evidence. Those results remain required before declaring the plugin first-vessel or stable-production ready.
+
+## npm beta gate
+
+An npm beta release candidate must:
+
+- be merged to `main` with normal CI and Signal K reusable plugin CI passing;
+- pass `npm run check` and `npm audit --omit=dev --audit-level=high`;
+- pass the packaged `npm run test:docker` Signal K/TLS/MQTT recovery scenario;
+- pass `npm pack --dry-run`, with the intended files, beta version and Signal K metadata present; and
+- have an updated changelog and no production or non-production Wake Logger endpoints, credentials or environment details in the public package.
+
+Physical hardware results do not affect this gate. Record them separately under the first-vessel and stable-release gates.
+
+## One-time npm bootstrap
+
+The unscoped `signalk-wakelogger` package does not yet exist in npm. npm trusted-publisher configuration requires an existing package, so the first beta must be bootstrapped deliberately by the package owner:
+
+1. Merge an approved release-candidate pull request to `main` after the npm beta gate above passes.
+2. From a clean checkout of that exact `main` commit, use Node.js 24 and npm 12.0.2.
+3. Run `npm ci --ignore-scripts`, `npm run check`, `npm audit --omit=dev --audit-level=high`, `npm run test:docker`, and `npm pack --dry-run`; inspect the file list.
+4. With the npm account protected by 2FA, run `npm publish --access public --tag beta`. The prepublish guard verifies the beta version/tag and repeats the complete check automatically; a bare `npm publish` is rejected.
+5. Confirm that npm shows the version under `beta`, not `latest`.
+
+This is the only manual package publication. Do not create the Git tag before the package bootstrap succeeds.
+
+## Configure trusted publishing
+
+After the package exists, configure its npm trusted publisher with:
+
+- provider: GitHub Actions
+- repository: `nerdynigel/signalk-wakelogger`
+- workflow filename: `publish.yml`
+- allowed action: `npm publish`
+- environment: `npm`
+
+Create the GitHub `npm` environment and require a maintainer reviewer before deployment. The workflow uses a GitHub-hosted runner with `id-token: write`, Node.js 24 and npm 12.0.2. npm generates provenance automatically for trusted publication from this public repository. After the first successful OIDC beta, disallow traditional publish tokens in npm package settings.
+
+After configuring trust, create and push the exact bootstrap-version tag. The workflow detects that the manually bootstrapped version already exists, does not republish it, and creates the matching GitHub prerelease. This also makes a safe workflow retry idempotent after npm succeeds but GitHub release creation fails.
+
+## Subsequent betas
+
+1. Change `package.json` and the lockfile to the next beta version and update `CHANGELOG.md`.
+2. Merge only a release candidate that passes the npm beta gate to `main`.
+3. Create and push the exact matching tag, such as `v0.2.0-beta.1`.
+4. Verify the Publish workflow, npm provenance, `beta` dist-tag, GitHub prerelease notes and Signal K registry result.
+
+Never reuse or move a published tag. A stable workflow must be introduced separately and reviewed against an explicitly agreed stable-release gate.

package/docs/telemetry-protocol.md

@@ -0,0 +1,50 @@
+# Telemetry protocol v1
+
+All topics are beneath `wakelogger/v1/devices/<deviceId>`:
+
+| Suffix | Direction | Retained | Purpose |
+|---|---|---:|---|
+| `telemetry` | device → cloud | no | Ordered sample batches |
+| `state` | device → cloud | yes | Latest sample for reconnect priority |
+| `status` | device → cloud | yes | Online/offline state, Last Will and bounded plugin/outbox diagnostics |
+| `events` | device → cloud | no | Advisory trip evidence |
+| `ack` | cloud → device | yes | Highest contiguously committed sequence, restored on reconnect |
+| `profile` | cloud → device | yes | Approved, versioned sampling and transport profile |
+| `profile-ack` | device → cloud | yes | Applied/rejected profile revision result |
+
+Telemetry is JSON and bounded to 64 KiB. A batch has `v`, `deviceId`, optional `droppedThrough`, and up to 60 `samples`. `droppedThrough` explicitly closes a sequence gap caused by local retention or corrupt-tail recovery so the cloud can advance its contiguous cursor while recording data loss. Each sample contains:
+
+```json
+{
+  "v": 1,
+  "deviceId": "dev_xxx",
+  "sequence": 184291,
+  "capturedAt": 1788143912000,
+  "receivedAt": 1788143912050,
+  "trackingSessionId": "optional-uuid",
+  "values": {
+    "lat": -27.41238,
+    "lon": 153.18291,
+    "sog_kn": 6.42,
+    "cog_deg": 241.3,
+    "heading_deg": 238.8,
+    "heading_reference": "true",
+    "depth_m": 12.4,
+    "aws_kn": 15.2,
+    "awa_deg": 315
+  },
+  "quality": {
+    "timestamp": "source"
+  }
+}
+```
+
+Times are UTC Unix milliseconds. Latitude/longitude are decimal degrees; speeds are knots; angles are degrees in `[0,360)`; depth is metres. Apparent wind angle follows Signal K's starboard-positive convention after normalization. Heading uses true heading when present and explicitly marks magnetic fallback.
+
+An acknowledgement is `{"v":1,"deviceId":"dev_xxx","ackSequence":184291,"acknowledgedAt":1788143912200}`. It means every sequence through that value was durably accepted or intentionally rejected under a server policy. Older backlog may arrive after retained current state; it must still be inserted by capture time. Current state changes only when `capturedAt` is newer.
+
+Trip evidence is also embedded in its source sample for durable recovery. The event topic is a convenience notification and consumers must deduplicate by `deviceId + sequence`.
+
+The retained status document includes `v`, `state` and `at`. A running plugin also reports `pluginVersion`, `queueMessageCount`, `queueDiskBytes`, optional `queueOldestCapturedAt`, `queueDroppedCount`, `acknowledgedSequence`, `currentSequence` and optional `trackingState`. These fields contain operational counters only—never credentials or telemetry values—and allow Wake Logger administrators to identify vessel-side backlog and loss.
+
+Status also reports `storageBackend`, `networkMode`, `modeReason`, `profileId`, `profileRevision`, `lastAcknowledgedAt`, `acknowledgementLatencyMs`, `reconnectCount` and `publishedBytes`. Profiles contain exactly the supported fields (`position`, `sog`, `cog`, `heading`, `depth`, `apparentWind`) with enabled flags and millisecond periods for `NORMAL`, `CONSTRAINED` and `OFFLINE`, plus bounded batching and replay byte rates. Position cannot be disabled. A profile acknowledgement reports `profileId`, `revision`, `status`, `at`, and a bounded error code when rejected.

package/docs/trip-detection.md

@@ -0,0 +1,7 @@
+# Trip detection
+
+The plugin emits evidence; Wake Logger remains authoritative for provisional and final trip boundaries.
+
+The state machine is `STOPPED → START_CANDIDATE → MOVING → STOP_CANDIDATE → STOPPED`. A start candidate begins when SOG exceeds 1.5 kn or the vessel moves more than 200 m from its stationary cluster. Two minutes of credible movement confirms it and backdates the effective time. A stop candidate begins below 0.5 kn; remaining within 75 m for 15 minutes confirms it and backdates the effective end.
+
+The stationary origin uses a slowly adjusted centroid only while points remain inside the 75 m berth cluster. This absorbs normal GPS drift without dragging the origin along a slow marina departure. Engine data is neither subscribed nor required, so engine-off sailing remains valid. Connectivity and sensor interruption never end a tracking session. Evidence includes effective time, speed, distance and dwell duration. State is persisted across Signal K and vessel restarts.

package/docs/validation.md

@@ -0,0 +1,35 @@
+# Validation evidence
+
+Automated checks cover lifecycle startup without configuration/network, supported-path normalization, managed profiles, adaptive modes, MQTT scheduling, application acknowledgements, file/database outbox restart continuity, corrupt file-tail repair, retention gaps and sequence-safe backend selection. Pairing tests additionally cover bounded transient retry, immediate invalid-code rejection, device-scoped revocation checks and local credential forgetting without deletion or reuse of retired outbox/sequence state. Accelerated release scenarios cover a 24-hour file-outbox outage with restart and partial application ACK, a three-day NORMAL/OFFLINE/CONSTRAINED sampling timeline, and conversion of the earlier telemetry-profile shape.
+
+A disposable Mosquitto 2 CI job exercises the real MQTT.js network path independently of Wake Logger infrastructure. It verifies MQTT 5/QoS 1 publication, retained current-state priority, ordered backlog delivery and removal only after an application ACK delivered through the broker.
+
+The Docker end-to-end job builds the exact local npm tarball, installs it into a pinned official Signal K image and consumes Signal K's synthesized NMEA 2000 stream. It asserts the resulting telemetry contains position, SOG, COG, true heading, depth and both apparent-wind values. A runtime-generated two-day CA secures both the mock HTTPS pairing service and TLS-only MQTT broker; the plugin uses normal hostname and certificate verification. The mock service syncs each received event to disk before publishing its application ACK. The scenario then stops the broker, kills Signal K with `SIGKILL`, preserves the Signal K data volume, and verifies recovered sequences, current-state-before-backlog ordering and an empty queue after ACK. No test-only branch exists in plugin runtime code. Scoped broker ACL enforcement remains covered in the private cloud integration suite and must be repeated against the release environment.
+
+On 2026-09-01 the final local x64 Docker scenario acknowledged sequence 3 before the outage and sequence 17 after restart, recovering 14 samples produced during the outage. It observed current state before backlog and the final zero-message queue status. A one-shot post-recovery snapshot reported about 276 MiB for the complete Signal K container, 45 MiB for the durable mock service and 3.2 MiB for Mosquitto. These transient development-container values are smoke evidence only: they include the full server, are not a soak average, and do not replace target ARM measurements. Every run prints its own CPU, memory, network and block-I/O snapshot.
+
+On 2026-09-01 the rewritten pull-request commit passed normal CI on Node.js 20/22 and the Signal K reusable matrix on Linux x64, Linux ARM64, macOS and Windows with Node.js 22/24, plus ARMv7/Cerbo emulation on Node.js 20. The integration matrix installed, enabled and started the packaged plugin in Signal K Server latest on Node.js 22/24. This is portable package evidence, not a substitute for resource measurements on the target vessel hardware.
+
+The 2026-09-01 official Signal K plugin-registry harness preflight reported `loads`, `activates`, `activatesWithoutConfig` and `hasSchema` as true, with no provider requirement, error messages or unstubbed API accesses. Together with the lifecycle-script-free install, passing source tests, clean runtime audit, packaged changelog and screenshots, the unpublished package satisfies the current 100-point criteria in preflight. Only a published npm version can receive an authoritative registry score and AppStore listing.
+
+An npm 11 release dry-run executed the real `prepublishOnly` guard and complete check, then produced an 80-file, 69.2 kB beta tarball with public access and the `beta` dist-tag. A separate negative invocation confirmed the guard rejects `latest`. No package, tag or release was published.
+
+`npm run measure:protocol` encodes a synthetic 24-hour, 1 Hz stream with every supported optional field. It counts normal online application payloads: one retained state and one single-sample telemetry batch each second, plus a representative status document every ten seconds. MQTT/TCP/TLS overhead and storage/Signal K resource use are intentionally excluded. The checked target is below 1 KiB/s before transport overhead.
+
+The benchmark is reproducible, but development-host CPU time and RSS are not vessel hardware evidence. Record release-candidate results here only after running the packaged plugin on the target Signal K ARM host:
+
+The 2026-08-31 Node.js 20 x64 protocol run encoded 86,400 seconds in 1.45 seconds and measured 340 bytes per full sample and 780 application bytes/second for normal online traffic. A checksummed file record is approximately 376 bytes, or 31.0 MiB for a 24-hour 1 Hz worst-case queue. Process RSS was about 32 MiB during this encoding-only run. These values pass the pre-transport bandwidth target but are not full-plugin or ARM measurements.
+
+A 2026-09-01 Node.js 22 x64 accelerated production file-outbox run wrote and synced 300 full samples in 1.34 seconds. It measured 339.84 disk bytes per sample, a 28.0 MiB/day projection, 970 ms user CPU, 147 ms system CPU and 37.29 MiB peak process RSS. This development-host stress evidence confirms the queue-size estimate and provides a regression baseline; it is neither real-time operation nor ARM evidence.
+
+| Evidence | Development gate | First-vessel gate |
+|---|---|---|
+| Protocol application bytes | Automated 24-hour encoding model | Capture actual MQTT/TLS bytes during normal and replay traffic |
+| CPU and memory | CI regression/no leak checks | Multi-day process metrics on target ARM host |
+| Outbox disk and writes | Bounded/corruption unit tests | 24-hour offline queue growth and disk-write measurement |
+| Reconnect/replay | Deterministic scheduler plus real Signal K/TLS/broker crash recovery | Poor-link and real-time 30-minute/24-hour target scenarios |
+| Install/upgrade | npm package dry run, lifecycle CI and packaged Docker install/restart | Version upgrade, reboot and uninstall/reinstall on target |
+
+Do not mark ARM or real-vessel rows complete using x64 development-host results.
+
+For repeatable target-host collection, install the published beta (or build the exact release commit before publication) and run `npm run measure:outbox -- 3600` as an initial accelerated synced-write comparison, then run the installed plugin in real time for the required outage. Archive the JSON output with the commit, device model, storage medium and Signal K/Node versions. The stress tool uses production file-outbox code but does not exercise Signal K subscriptions, MQTT/TLS, scheduling or Database API storage, so it cannot by itself satisfy the first-vessel hardware gate. This evidence is not required to publish an npm beta.

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "signalk-wakelogger",
+  "version": "0.2.0-beta.0",
+  "description": "Resilient live Signal K telemetry transport for Wake Logger",
+  "license": "Apache-2.0",
+  "author": "Nigel George",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nerdynigel/signalk-wakelogger.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nerdynigel/signalk-wakelogger/issues"
+  },
+  "homepage": "https://github.com/nerdynigel/signalk-wakelogger#readme",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "assets",
+    "docs",
+    "README.md",
+    "CHANGELOG.md",
+    "SECURITY.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "signalk-node-server-plugin",
+    "signalk-category-cloud",
+    "signalk",
+    "marine",
+    "telemetry",
+    "mqtt"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:integration": "vitest run test/integration",
+    "test:broker": "vitest run test/integration/mqtt-broker.test.ts",
+    "test:docker": "node scripts/test-signalk-docker.mjs",
+    "test:watch": "vitest",
+    "lint": "eslint src test scripts --max-warnings=0",
+    "check:public": "node scripts/check-public-repo.mjs",
+    "measure:protocol": "node scripts/measure-protocol.mjs",
+    "measure:outbox": "npm run build && node scripts/measure-outbox.mjs",
+    "prepublishOnly": "node scripts/verify-release.mjs && npm run check",
+    "check": "npm run check:public && npm run lint && npm run typecheck && npm test && npm run build"
+  },
+  "dependencies": {
+    "mqtt": "^5.15.2"
+  },
+  "devDependencies": {
+    "@signalk/server-api": "^2.31.1",
+    "@types/node": "^20.17.30",
+    "@typescript-eslint/eslint-plugin": "^8.28.0",
+    "@typescript-eslint/parser": "^8.28.0",
+    "eslint": "^9.23.0",
+    "typescript": "^5.8.2",
+    "vitest": "^2.1.9"
+  },
+  "signalk": {
+    "displayName": "Wake Logger",
+    "appIcon": "./assets/wakelogger.svg",
+    "screenshots": [
+      "./assets/screenshots/plugin-status.png",
+      "./assets/screenshots/plugin-config.png"
+    ]
+  },
+  "signalk-plugin-enabled-by-default": false
+}