@meri-imperiumi/signalk-dead-reckoning 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -5,6 +5,30 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.0] - 2026-08-28
+
+### Added
+- **AIS targets on the DR chart (work doc #23)** — the DR webapp now
+  renders AIS traffic on the map and lets you take a bearing to a
+  vessel you can see, even in open water with no charted objects in
+  range. Targets arrive on the same stream under a second `vessels.*`
+  subscription (throttled to 2 s per path; static name/MMSI seeded from
+  a REST snapshot and re-seeded on reconnect), and render as a
+  plotter-style tri-state: active (violet arrow, green for AIS buddies,
+  rotated to heading/COG, with a 6-minute velocity leader), expiring
+  after 3 minutes without a report (grey, leader dropped, tooltip says
+  how old the report is), then aged out and evicted entirely after 20
+  minutes. Marks ride their dead-reckoned track between reports —
+  position is predicted forward from the last report along SOG/COG
+  (capped at the expiring threshold) — so right-click → "Bearing to
+  <name>" seeds the sight form from where the vessel actually is at
+  pick time, with the sight time defaulting to that same instant.
+  Targets are range-filtered around the own boat (default 24 nm),
+  own vessel and the DR shadow vessel are excluded, and an "AIS
+  traffic" checkbox in the layers control de-clutters the chart.
+  `GET /status` now reports the shadow vessel's context
+  (`shadowVesselContext`) so the webapp can filter it.
+
 ## [0.4.0] - 2026-08-28
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meri-imperiumi/signalk-dead-reckoning",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Offline-first dead reckoning and sensor fusion engine for Signal K",
   "main": "plugin/index.js",
   "scripts": {

package/plugin/index.js

@@ -426,6 +426,15 @@ module.exports = (app) => {
   /** @type {{publish: Function, stop: Function}|null} shadow vessel publisher (work doc #21) */
   let shadow = null;
 
+  /**
+   * The shadow vessel's stable `vessels.<uuid>` context (work doc #21),
+   * when the shadow is enabled — mirrored into GET /status so the DR
+   * webapp's AIS layer can filter it out (it already draws the DR marker
+   * itself; rendering the shadow again as "traffic" would double-draw).
+   * @type {string|null}
+   */
+  let shadowContext = null;
+
   /**
    * Manual set-and-drift override (§6.2 tier 1): watchstander input,
    * honored while its TTL lasts. Set/cleared via
@@ -756,6 +765,7 @@ module.exports = (app) => {
           shadowCtx = `vessels.urn:mrn:signalk:uuid:${crypto.randomUUID()}`;
           deps.setState(db, "shadow_vessel_context", shadowCtx);
         }
+        shadowContext = shadowCtx;
         shadow = deps.createShadowVesselPublisher({
           app,
           context: shadowCtx,
@@ -878,6 +888,7 @@ module.exports = (app) => {
       statusTileExamplesTeardown = null;
       shadow?.stop();
       shadow = null;
+      shadowContext = null;
       // Hygiene: clear a live advisory so it doesn't linger after the
       // plugin stops monitoring.
       if (divergence?.active) {
@@ -2016,6 +2027,10 @@ module.exports = (app) => {
         // the UI's header readout can bootstrap without a delta.
         current: lastCurrent,
         manualCurrent,
+        // Work doc #23: the shadow vessel's context, when enabled, so
+        // the DR webapp can filter it from its AIS target layer (the
+        // webapp already renders the DR position as its own marker).
+        shadowVesselContext: shadowContext,
       });
     });
 

package/public/dr-app.js

@@ -6,6 +6,10 @@
  * the Signal K WebSocket stream through the view-model (tracks,
  * sparkline) into `<dr-map-view>`; REST overlays (fixes, LOPs, CPLs,
  * snap vectors) refresh on a slow poll and after any confirm POST.
+ * AIS targets (work doc #23) ride the same stream under `vessels.*`,
+ * accumulate in a pure store (dr-viewmodel), and render through the
+ * map's AIS layer — right-clicking a target seeds a bearing from its
+ * predicted position.
  *
  * @file dr-app.js
  */
@@ -229,11 +233,14 @@ class DrApp extends HTMLElement {
       ?.addEventListener("click", () => this.map?.recenter());
     // Chart pick: right-click an object on the map → open the sight
     // dialog with the object position pre-seeded (and its charted name,
-    // when the picked symbol carries one — light, seamark, peak…).
+    // when the picked symbol carries one — light, seamark, peak…). AIS
+    // picks (work doc #23) also carry tMs — the instant the seeded
+    // (predicted) position is valid for — so the sight time defaults to
+    // the moment the target was clicked.
     this.map?.addEventListener("dr-pick-position", (e) => {
-      const { lat, lng, mode, label } = e.detail;
+      const { lat, lng, mode, label, tMs } = e.detail;
       openSight();
-      this.sight?.seedObjectPosition(lat, lng, mode, label);
+      this.sight?.seedObjectPosition(lat, lng, mode, label, tMs);
     });
 
     /** @type {HTMLDialogElement|null} */
@@ -365,6 +372,19 @@ class DrApp extends HTMLElement {
     /** History-API backfill tracks (null until a provider answers). */
     this.gpsHistory = [];
     this.ghostHistory = [];
+    /**
+     * AIS target store (work doc #23): context → target state, fed by
+     * `vessels.*` deltas + the REST snapshot seed, rendered through
+     * `aisTargetsForRender`. Owned by dr-viewmodel's pure helpers.
+     * @type {Map<string, object>}
+     */
+    this.aisStore = new Map();
+    /**
+     * DR shadow vessel context (work doc #21), filtered from the AIS
+     * layer — the webapp already draws the DR position as its own marker.
+     * @type {string|null}
+     */
+    this.shadowContext = null;
     this.snap = {
       drPosition: null,
       gpsPosition: null,
@@ -387,7 +407,7 @@ class DrApp extends HTMLElement {
     this.connectStream();
     this.loadPluginConfig();
     this.bootstrapSelf();
-    this.fetchStatus();
+    this.fetchStatus().then(() => this.bootstrapAis());
     this.refreshOverlays();
     this.refreshTrackHistory();
     // Slow REST refresh for persisted overlays; stream drives the live parts.
@@ -397,6 +417,10 @@ class DrApp extends HTMLElement {
       this.refreshOverlays();
       this.fetchStatus();
     }, 30000);
+    // AIS tick (work doc #23): predictions, expiring styling, and
+    // age-out must advance even when nothing else flows (moored, DR
+    // idle, quiet targets) — a slow dedicated pulse.
+    setInterval(() => this.renderAis(), 5000);
   }
 
   /**
@@ -427,6 +451,23 @@ class DrApp extends HTMLElement {
       "environment.current.setTrue",
       "environment.current.drift",
     ]);
+    // AIS targets (work doc #23): same socket, `vessels.*` scope — the
+    // protocol scopes each subscribe message to its context. Static
+    // data (name/mmsi) seeds from the REST snapshot (bootstrapAis);
+    // these paths carry the live motion. The "" root path catches
+    // identification from providers that publish it only as root
+    // values (the common AIS-plugin pattern — Freeboard-SK subscribes
+    // "" for the same reason); the reducer picks name/mmsi/buddy out
+    // of root values and ignores the rest.
+    stream.subscribeAis([
+      "navigation.position",
+      "navigation.courseOverGroundTrue",
+      "navigation.speedOverGround",
+      "navigation.headingTrue",
+      "name",
+      "mmsi",
+      "",
+    ]);
     stream.on((delta) => this.onDelta(delta));
     stream.onStatus((s) => this.renderLinkStatus(s));
   }
@@ -529,12 +570,69 @@ class DrApp extends HTMLElement {
   }
 
   /**
-   * Streams a delta into the view-model and re-renders.
+   * Seeds the AIS target store from the REST vessel snapshot (work doc
+   * #23): static data (name/mmsi) arrives here; live motion rides the
+   * `vessels.*` deltas. Also re-run on stream reconnect — targets that
+   * aged out while offline come straight back with names intact.
+   *
+   * @returns {Promise<void>}
+   */
+  async bootstrapAis() {
+    try {
+      const res = await fetch("/signalk/v1/api/vessels");
+      if (!res.ok) return;
+      const body = await res.json();
+      vm.seedAisFromSnapshot(this.aisStore, body, {
+        selfContext: window.drSignalkStream?.selfContext,
+        shadowContext: this.shadowContext,
+      });
+      this.renderAis();
+    } catch {
+      /* REST unavailable — deltas will drive when they can */
+    }
+  }
+
+  /**
+   * Renders the AIS layer (work doc #23): prunes aged-out targets, then
+   * pushes range-filtered marker specs to the map with the prediction
+   * instant. Own position prefers DR (the chart's own-boat reference);
+   * GPS when DR hasn't started.
+   *
+   * @returns {void}
+   */
+  renderAis() {
+    const nowMs = Date.now();
+    vm.pruneAisStore(this.aisStore, nowMs);
+    const own = this.snap.drPosition ?? this.snap.gpsPosition;
+    this.map?.renderAis(
+      vm.aisTargetsForRender(this.aisStore, nowMs, own),
+      nowMs,
+    );
+  }
+
+  /**
+   * Streams a delta into the view-model and re-renders. Deltas from
+   * other vessels (the `vessels.*` AIS subscription, work doc #23) feed
+   * the target store instead — own vessel (by real context or the
+   * literal `vessels.self`) and the DR shadow vessel are excluded.
    *
    * @param {object} delta
    * @returns {void}
    */
   onDelta(delta) {
+    const ctx = delta?.context;
+    const selfCtx = window.drSignalkStream?.selfContext;
+    if (
+      typeof ctx === "string" &&
+      ctx.startsWith("vessels.") &&
+      ctx !== "vessels.self" &&
+      ctx !== selfCtx &&
+      ctx !== this.shadowContext
+    ) {
+      vm.applyAisDelta(this.aisStore, delta);
+      this.renderAis();
+      return;
+    }
     for (const update of delta?.updates ?? []) {
       for (const v of update.values ?? []) {
         this.applyValue(v.path, v.value);
@@ -790,6 +888,9 @@ class DrApp extends HTMLElement {
     this.shadowRoot.querySelector("#dr-divergence").textContent =
       vm.divergenceText(this.snap.divergence);
     this.map?.render(this.snap);
+    // AIS ranges/leaders move with the own boat — cheap to re-shape
+    // alongside the snapshot (markers are reused in the map).
+    this.renderAis();
   }
 
   /**
@@ -806,7 +907,11 @@ class DrApp extends HTMLElement {
       const body = await res.json();
       this.snap.current = body.current ?? this.snap.current;
       this.snap.manualCurrent = body.manualCurrent ?? null;
+      // Shadow vessel context (work doc #21/#23): once known, the AIS
+      // layer filters it (the DR marker already covers that position).
+      this.shadowContext = body.shadowVesselContext ?? this.shadowContext;
       this.renderCurrent();
+      this.renderAis();
     } catch {
       /* REST unavailable — stream will drive when it can */
     }
@@ -928,6 +1033,10 @@ class DrApp extends HTMLElement {
     } else if (status.state === "retrying") {
       panel.classList.add("retrying");
       text.textContent = "Signal K link lost — reconnecting…";
+    } else if (status.state === "open") {
+      // Re-seed AIS static data on (re)connect (work doc #23) — names
+      // and MMSIs don't ride position deltas.
+      this.bootstrapAis();
     }
     // "open" — let the DR state panel take over once data flows.
   }

package/public/dr-map-view.js

@@ -17,6 +17,12 @@
  * through MapLibre GL, vendored at ./vendor/maplibre-gl/ and mounted
  * as one Leaflet layer via the official bridge (work doc #20).
  *
+ * AIS targets (work doc #23) render in their own layer group from
+ * specs pushed by dr-app (`renderAis`, outside the snapshot path —
+ * targets tick independently of DR ticks). Right-clicking a target
+ * seeds the sight form from its predicted position, with the sight
+ * time anchored to the prediction instant.
+ *
  * @file dr-map-view.js
  */
 
@@ -114,6 +120,17 @@ class DrMapView extends HTMLElement {
         box-shadow: none !important;
         font: 11px ui-monospace, "Fira Code", monospace !important;
       }
+      /* AIS target glyphs (work doc #23): a rotated arrow on a bare
+         divIcon (Leaflet's default .leaflet-div-icon white box is
+         replaced by className); the inner glyph's rotation eases
+         between renders — the mark turns with the target. */
+      .dr-ais-marker {
+        background: transparent;
+        border: none;
+      }
+      .dr-ais-glyph {
+        transition: transform 0.5s linear;
+      }
     `;
     root.appendChild(style);
     // Leaflet's CSS must live INSIDE the shadow root — a document-level
@@ -172,9 +189,20 @@ class DrMapView extends HTMLElement {
       drMarker: null,
       candidate: null,
       advancements: null,
+      ais: null,
     };
     this.tileLayers = {};
     this.follow = true;
+    /**
+     * Rendered AIS entries by target context (work doc #23) — markers
+     * are reused across renderAis calls (position/style updates in
+     * place) so ~1 Hz re-renders don't churn DOM and flicker tooltips.
+     * @type {Map<string, {spec: object, marker: object, leader: object|null}>}
+     */
+    this._aisRendered = new Map();
+    /** Instant the rendered AIS predictions are valid for — a pick
+     * from a target dispatches it as the sight-time anchor. */
+    this._aisRenderNowMs = null;
   }
 
   connectedCallback() {
@@ -215,9 +243,20 @@ class DrMapView extends HTMLElement {
     // Chart pick: right-click / long-press opens a small context menu
     // to pre-seed a sight form with the picked object position (and the
     // object's charted name, when a symbol was hit — see pickSymbolName).
-    this.map.on("contextmenu", (e) =>
-      this.showPickMenu(e.latlng, e.containerPoint),
-    );
+    // An AIS target under the cursor (work doc #23) wins over the chart:
+    // its *predicted* position seeds the bearing, with the sight time
+    // anchored to the prediction instant.
+    this.map.on("contextmenu", (e) => {
+      const target = this._aisTargetAt(e.containerPoint);
+      if (target) {
+        this.showPickMenu(target.position, e.containerPoint, {
+          label: target.label,
+          tMs: this._aisRenderNowMs ?? Date.now(),
+        });
+        return;
+      }
+      this.showPickMenu(e.latlng, e.containerPoint);
+    });
     // Hover cursor: over a charted point object you can take a bearing
     // to (light, beacon, buoy, named peak, cape, landmark), the cursor
     // becomes a crosshair signalling "right-click to take a bearing
@@ -233,7 +272,9 @@ class DrMapView extends HTMLElement {
         const pt = this._hoverPoint;
         this._hoverPoint = null;
         this.mapEl.style.cursor =
-          pt && this.isBearingableAt(pt) ? "crosshair" : "";
+          pt && (this.isBearingableAt(pt) || this._aisTargetAt(pt) != null)
+            ? "crosshair"
+            : "";
       });
     });
     this.map.on("mouseout", () => {
@@ -331,9 +372,16 @@ class DrMapView extends HTMLElement {
           this.tileLayers[charts[0].identifier] ??
           ordered[0];
         first?.addTo(this.map);
-        if (Object.keys(bases).length > 1 || configured.length === 0) {
-          L.control.layers(bases, {}, { collapsed: true }).addTo(this.map);
-        }
+        // Always mounted (even single-chart installs): the AIS traffic
+        // overlay (work doc #23) needs its checkbox so the chart can be
+        // de-cluttered.
+        L.control
+          .layers(
+            bases,
+            { "AIS traffic": this.layers.ais },
+            { collapsed: true },
+          )
+          .addTo(this.map);
       })
       .catch((e) => {
         // Offline stays tile-less by design, but a chart that fails to
@@ -469,20 +517,54 @@ class DrMapView extends HTMLElement {
     return vm.isBearingablePointHit(this._queryChartHits(containerPoint, 10));
   }
 
+  /**
+   * Finds the rendered AIS target nearest a Leaflet container point
+   * (work doc #23), within a finger-friendly catchment — targets are
+   * picked by proximity to the rendered glyph, not by DOM hit-testing,
+   * so it works identically for touch long-presses. Returns the target's
+   * render spec (whose `position` is the predicted position the pick
+   * will seed) or null.
+   *
+   * @param {L.Point|null|undefined} containerPoint
+   * @returns {object|null}
+   */
+  _aisTargetAt(containerPoint) {
+    if (!this.map || !containerPoint || this._aisRendered.size === 0) {
+      return null;
+    }
+    let best = null;
+    let bestD = 16;
+    for (const entry of this._aisRendered.values()) {
+      const p = this.map.latLngToContainerPoint(entry.spec.position);
+      const d = p.distanceTo(containerPoint);
+      if (d < bestD) {
+        bestD = d;
+        best = entry.spec;
+      }
+    }
+    return best;
+  }
+
   /**
    * Shows a small context menu at a chart point offering to pre-seed a
    * sight form with that position as the object. Dispatches
-   * `dr-pick-position` (composed, bubbles) with `{ lat, lng, mode, label }`
-   * — `label` carries the picked symbol's charted name, when one was hit.
+   * `dr-pick-position` (composed, bubbles) with `{ lat, lng, mode,
+   * label, tMs }` — `label` carries the picked symbol's charted name
+   * (or an AIS target's name, work doc #23), `tMs` the pick instant the
+   * position is valid for (an AIS target's predicted position is
+   * anchored to it).
    *
-   * @param {L.LatLng} latlng
+   * @param {L.LatLng|[number, number]} latlng
    * @param {L.Point|null|undefined} [containerPoint]
+   * @param {{label?: string|null, tMs?: number}|null} [preset] - AIS
+   *   picks resolve label/time here instead of the chart query
    * @returns {void}
    */
-  showPickMenu(latlng, containerPoint) {
+  showPickMenu(latlng, containerPoint, preset = null) {
     // Remove any prior menu.
     this.hidePickMenu();
-    const label = this.pickSymbolName(containerPoint);
+    const label = preset?.label ?? this.pickSymbolName(containerPoint);
+    const tMs = Number.isFinite(preset?.tMs) ? preset.tMs : Date.now();
     const menu = document.createElement("div");
     menu.className = "dr-pick-menu";
     const what = label ?? "this point";
@@ -501,9 +583,10 @@ class DrMapView extends HTMLElement {
             bubbles: true,
             composed: true,
             detail: {
-              lat: latlng.lat,
-              lng: latlng.lng,
+              lat: Array.isArray(latlng) ? latlng[0] : latlng.lat,
+              lng: Array.isArray(latlng) ? latlng[1] : latlng.lng,
               mode: it.mode,
+              tMs,
               ...(label ? { label } : {}),
             },
           }),
@@ -862,6 +945,114 @@ class DrMapView extends HTMLElement {
     }
   }
 
+  /**
+   * Builds the divIcon for an AIS target glyph (work doc #23): a bare
+   * rotated arrow (className drops Leaflet's default white box), sized
+   * for a finger-ish target without covering the chart. Expiring marks
+   * drop opacity — the plotter's "data decaying" cue.
+   *
+   * @param {object} spec - aisMarkerSpec result
+   * @returns {object} Leaflet divIcon
+   */
+  _aisIcon(spec) {
+    const rot =
+      spec.rotationDeg != null
+        ? `transform:rotate(${Math.round(spec.rotationDeg)}deg);`
+        : "";
+    const opacity = spec.expiring ? "opacity:0.55;" : "";
+    return L.divIcon({
+      className: "dr-ais-marker",
+      iconSize: [16, 16],
+      iconAnchor: [8, 8],
+      html: `<div class="dr-ais-glyph" style="${rot}${opacity}"><svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg"><path d="M8 1.5 L13.5 13.5 L8 10.8 L2.5 13.5 Z" fill="${spec.color}" stroke="${spec.color}" stroke-width="0.6"/></svg></div>`,
+    });
+  }
+
+  /**
+   * Renders the AIS target set (work doc #23). Dr-app pushes specs built
+   * by `aisTargetsForRender` — outside `render(snap)`, since targets tick
+   * independently of the DR snapshot. Markers are REUSED across calls
+   * (position/rotation/leader update in place) so ~1 Hz refreshes don't
+   * churn DOM or flicker tooltips. Targets absent from `specs` (aged
+   * out, range-filtered) are removed.
+   *
+   * @param {Array<object>} specs - aisMarkerSpec results
+   * @param {number} nowMs - instant the predicted positions are valid
+   *   for; a right-click pick dispatches it as the sight-time anchor
+   * @returns {void}
+   */
+  renderAis(specs, nowMs) {
+    if (!this.map) return;
+    this._aisRenderNowMs = nowMs;
+    const incoming = new Map(specs.map((s) => [s.context, s]));
+    for (const [ctx, entry] of this._aisRendered) {
+      if (incoming.has(ctx)) continue;
+      this.layers.ais?.removeLayer(entry.marker);
+      if (entry.leader) this.layers.ais?.removeLayer(entry.leader);
+      this._aisRendered.delete(ctx);
+    }
+    for (const spec of incoming.values()) {
+      let entry = this._aisRendered.get(spec.context);
+      if (!entry) {
+        const icon = this._aisIcon(spec);
+        icon._drAis = {
+          rotationDeg: spec.rotationDeg,
+          color: spec.color,
+          expiring: spec.expiring,
+        };
+        const marker = L.marker(spec.position, { icon })
+          .bindTooltip(spec.tooltip, { direction: "top" })
+          .addTo(this.layers.ais);
+        entry = { spec, marker, leader: null };
+        this._aisRendered.set(spec.context, entry);
+      } else {
+        entry.spec = spec;
+        entry.marker.setLatLng(spec.position);
+        // Icon rebuild only when something visible changed — setIcon
+        // recreates the DOM node, so skip it when only position moved.
+        const prev = entry.marker.options?.icon ?? null;
+        const changed =
+          !prev ||
+          prev._drAis?.rotationDeg !== spec.rotationDeg ||
+          prev._drAis?.color !== spec.color ||
+          prev._drAis?.expiring !== spec.expiring;
+        if (changed) {
+          const icon = this._aisIcon(spec);
+          icon._drAis = {
+            rotationDeg: spec.rotationDeg,
+            color: spec.color,
+            expiring: spec.expiring,
+          };
+          entry.marker.setIcon(icon);
+        }
+        entry.marker.setTooltipContent?.(spec.tooltip);
+      }
+      // Velocity leader: 6-minute run from the predicted position;
+      // drops when the target expires (nothing trustworthy to project).
+      if (spec.leader) {
+        const pts = [spec.leader.from, spec.leader.to];
+        if (entry.leader) {
+          entry.leader.setLatLngs(pts);
+          entry.leader.setStyle({
+            color: spec.color,
+            opacity: spec.expiring ? 0.4 : 0.8,
+          });
+        } else {
+          entry.leader = L.polyline(pts, {
+            color: spec.color,
+            weight: 1,
+            opacity: spec.expiring ? 0.4 : 0.8,
+            dashArray: "2 4",
+            interactive: false,
+          }).addTo(this.layers.ais);
+        }
+      } else if (entry.leader) {
+        this.layers.ais?.removeLayer(entry.leader);
+        entry.leader = null;
+      }
+    }
+  }
+
   /**
    * @param {{distance_nm: number, bearing_true: number}|null} divergence
    * @param {object|null} [sparkStats]

package/public/dr-sight-panel.js

@@ -572,17 +572,23 @@ class DrSightPanel extends HTMLElement {
    * → "Add bearing to here" / "Distance CPL at here"). Switches to the
    * matching tab and fills the object/center coordinates (overwriting any
    * prior value — a fresh pick is intentional), plus the object *name*
-   * when the pick resolved a charted symbol (light, seamark, peak…):
-   * bearings are taken to identified objects, not bare coordinates.
+   * when the pick resolved a charted symbol (light, seamark, peak…) or an
+   * AIS target (work doc #23): bearings are taken to identified objects,
+   * not bare coordinates. `tMs` (the pick instant) pre-fills the sight
+   * time — for an AIS target the seeded position is its *predicted*
+   * position valid at exactly that instant, so position and timestamp
+   * stay consistent. Marked dirty so the tz toggle converts it in place
+   * instead of re-seeding to "now".
    * Used by dr-app when the map dispatches `dr-pick-position`.
    *
    * @param {number} lat
    * @param {number} lon
    * @param {"bearing"|"vertical"} mode
-   * @param {string} [label] - charted name of the picked object, if any
+   * @param {string} [label] - charted name / AIS target name, if any
+   * @param {number} [tMs] - pick instant the position is valid for
    * @returns {void}
    */
-  seedObjectPosition(lat, lon, mode, label) {
+  seedObjectPosition(lat, lon, mode, label, tMs = null) {
     const prefix = mode === "vertical" ? "center" : "object";
     const tab = mode === "vertical" ? "vertical" : "bearing";
     this.switchTab(tab);
@@ -594,6 +600,16 @@ class DrSightPanel extends HTMLElement {
       const nameInput = form?.querySelector('input[name="object"]');
       if (nameInput) nameInput.value = label;
     }
+    if (Number.isFinite(tMs)) {
+      const input = form?.querySelector('input[name="sight_time"]');
+      if (input) {
+        input.value = vm.isoToSightTimeInput(
+          new Date(tMs).toISOString(),
+          this.loadSightTz(),
+        );
+        input.dataset.dirty = "true";
+      }
+    }
     if (!fs) return;
     // Force-fill (a chart pick overwrites, no dirty check).
     seedCoord(fs, "lat", lat, true);