feat(share): short /share/<code> links with a compact versioned view format (#1418)

* feat(share): add compact versioned share-view codec

Add a standalone codec for `#s=<base64url>` share links: a version byte
followed by protobuf-style tag-length-value fields. Settings equal to
their default are omitted and refilled from the same table on decode;
unknown fields are skipped by wire type, so new fields never break
older apps. Views are a place (camera) or a thing (an aircraft,
military aircraft, vessel or satellite to follow, with camera offset
and last-known fix); an unknown kind falls back to the camera.

The decoder bounds its input and rejects malformed payloads with a
reason instead of throwing. A converter maps the long form's parsed
state to and from the codec state; the long form is unchanged.

* fix(share): tighten codec decoding after review

Unknown detection mode and allocation names now fall back to their
defaults instead of reaching the lenient long-form migration. Future
panel values and style-parameter tokens are skipped rather than applied
or rejected, and layer options are accepted only under their owner
layer. Wrap longitudes before scaling, normalize negative zero, reuse
the layer-state tracking ID grammar, and align the format doc with the
decoder.

* feat(share): let a host share the link its own way

ShareLinkManager.buildLink() returns the current share link without
copying it, and copyLink() now copies exactly that. The share button
passes the link to an optional services.shareLink(url), which resolves
to 'shared', 'copied', 'cancelled' or false; 'cancelled' shows no toast
and 'shared' shows the new "Link shared" (es, ru, zh-CN). Without the
service the button copies as before.

* feat(share): open and make short /share/<code> links

The share button now makes `<app>/share/<code>` links with the compact
share-view code, and the app opens them at start-up through the same
restore pipeline as long links. Once the app next writes the address, the
share path is replaced (no new history entry) by the app's own address and
the live long-form hash, so a reload follows the live view. A host can pass
the code as `initialShareCode` instead. A code that fails to decode restores
nothing and shows "This share link can't be opened".

The code gains a trailing CRC-8 check byte, so any single mistyped
character is rejected instead of opening a different view. Thing views no
longer store a camera: it is derived from the entity's last-known fix and
the follow offset on a sphere, the entity kind is implied by the id's
field, and the followed entity's layer bit is implied; an aircraft followed
from the app's own camera is a 42-character code. The `#s=` hash form is
gone.

While the camera follows an aircraft, military aircraft or satellite, the
link is a thing view with the camera's offset and the entity's position.
Opening one turns the layer on and follows the entity through the existing
shared-follow restore, then swings the camera round to the shared offset; a
vessel view selects the vessel once the vessel feed has it. If the entity
is not reporting within its window, the view stays at its last-known fix
and says so. The panel and style-parameter tables now come from the codec,
and a host share hook that returns a plain value or throws still gets a
toast.

* fix(share): encode style settings against the style's own look

Settings a style applies when selected (bloom, sharpen, HUD, detection,
celestial ring and the style's shader parameters) now default, per field,
to what that style applies in a fresh session, read from the tables the
app applies (the first-load baseline, the style presets and the shader
defaults). The encoder compares against the view's style and the decoder
fills omitted settings from the decoded style, so a view that keeps its
style's look costs only its camera and style. The previous defaults did not
match a fresh session (sharpen, HUD and detection were off), so every link
paid for them, and a style's own shader parameters were always written.

A test pins the per-style defaults as frozen v1 meanings. A followed
aircraft in Noir is now 44 characters and the real long-link example 39.

* docs: changelog for #1418

src/ui/applicationShell.js

@@ -35,6 +35,10 @@ import * as Cesium from 'cesium';
 import { aircraftTrackingTarget } from '../cockpitTracking.js';
 
 import { ShellFeedback } from './shellFeedback.js';
+import {
+  applyShareFollowOffset,
+  readShareFollowSubject,
+} from './shareFollow.js';
 
 import { runCctvLayerEnableTransition } from '../cctvFocusPolicy.js';
 
@@ -74,7 +78,13 @@ export class StyleManager extends ShellFacade {
    */
   constructor(
     viewer,
-    { mapStackController = null, placeSearch, services, requestServices } = {},
+    {
+      mapStackController = null,
+      placeSearch,
+      services,
+      requestServices,
+      initialShareCode = null,
+    } = {},
   ) {
     super();
     const {
@@ -165,6 +175,8 @@ export class StyleManager extends ShellFacade {
         this._showGlobalStatusNotice(message, options),
       feedback: this._feedback,
       updateFeedback: () => this._updateGlobalLoadingFeedback(),
+      applyFollowOffset: (entity, offset) =>
+        applyShareFollowOffset(viewer, entity, offset),
     });
 
     this._visualSettings = new VisualSettings({
@@ -430,7 +442,12 @@ export class StyleManager extends ShellFacade {
       isNavigationCurrent: (generation) =>
         generation === this._navigationGeneration,
       cancelOwnedNavigation: () => this.viewer.camera.cancelFlight(),
+      // A host may open a share code without a `/share/<code>` address.
+      initialShareCode,
     });
+    this.shareLinkManager.setFollowSubjectProvider(({ nowMs }) =>
+      readShareFollowSubject({ viewer: this.viewer, nowMs }),
+    );
     this.shareLinkManager.setPanelStateProvider(() =>
       this._buildSharePanelState(),
     );
@@ -1652,14 +1669,35 @@ export class StyleManager extends ShellFacade {
   // ── Share Button ─────────────────────────────
 
   /**
-   * Wires the share button click to copy the current share link to the clipboard.
+   * Wires the share button. By default it copies the current share link to the
+   * clipboard; a host may pass `services.shareLink(url)` to share it another way
+   * (a system share sheet, for example). It resolves to 'shared', 'copied',
+   * 'cancelled' (no toast) or false (failed).
    * @returns {void}
    */
   _initShareButton() {
     this._lifetime.listen(this._shareBtn, 'click', async () => {
-      const success = await this.shareLinkManager.copyLink();
-      if (!this._disposed)
-        this._showToast(success ? t('Link copied!') : t('Copy failed'));
+      const share = this.services.shareLink;
+      let result;
+      if (typeof share === 'function') {
+        // A host's hook may return a plain value or throw; both are answers.
+        result = await Promise.resolve()
+          .then(() => {
+            const href = this.shareLinkManager.buildLink();
+            return href ? share(href) : false;
+          })
+          .catch(() => false);
+      } else {
+        result = (await this.shareLinkManager.copyLink()) ? 'copied' : false;
+      }
+      if (this._disposed || result === 'cancelled') return;
+      this._showToast(
+        result === 'shared'
+          ? t('Link shared')
+          : result === 'copied'
+            ? t('Link copied!')
+            : t('Copy failed'),
+      );
     });
   }
 

src/ui/shareButton.test.mjs

@@ -0,0 +1,160 @@
+// The share button copies by default; a host's `services.shareLink` shares the
+// link its own way and reports how it went.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { StyleManager } from './applicationShell.js';
+import { ShareLinkManager } from '../sharelink.js';
+import { parseSharePath } from '../share/shareLinkPath.js';
+import { decodeShareView } from '../share/viewCodec.js';
+
+/** The decoded view of a `/share/<code>` link. */
+const sharedState = (href) =>
+  decodeShareView(parseSharePath(new URL(href).pathname).code).state;
+const SHARE_LINK = /^https:\/\/gev\.example\/share\/[A-Za-z0-9_-]+$/;
+
+function makeManager(href, { positioned = true } = {}) {
+  globalThis.window = { location: { href, hash: new URL(href).hash } };
+  globalThis.history = { replaceState() {} };
+  const viewer = {
+    camera: {
+      changed: { addEventListener() {} },
+      positionCartographic: positioned
+        ? { latitude: 0, longitude: 0, height: 1000 }
+        : undefined,
+      heading: 0,
+      pitch: -Math.PI / 2,
+      roll: 0,
+    },
+  };
+  return new ShareLinkManager(viewer);
+}
+
+function installClipboard(writeText) {
+  Object.defineProperty(globalThis, 'navigator', {
+    configurable: true,
+    value: { clipboard: { writeText } },
+  });
+}
+
+/** Wire the real share button handler onto a minimal shell; return a click. */
+function shell({ manager, services = {} }) {
+  const toasts = [];
+  let click;
+  const owner = {
+    services,
+    shareLinkManager: manager,
+    _shareBtn: {},
+    _disposed: false,
+    _lifetime: { listen: (_el, _type, handler) => (click = handler) },
+    _showToast: (message) => toasts.push(message),
+  };
+  StyleManager.prototype._initShareButton.call(owner);
+  return { toasts, click: () => click() };
+}
+
+test('buildLink is a /share link stamped with its creation time, without ?lang', () => {
+  const manager = makeManager('https://gev.example/?lang=ru#v=2&lat=10&lon=20');
+  const href = manager.buildLink({ nowMs: 5_000_000 });
+  assert.match(href, SHARE_LINK);
+  const link = new URL(href);
+  assert.equal(link.searchParams.get('lang'), null);
+  assert.equal(link.hash, '');
+  assert.equal(sharedState(href).sharedAtMs, 5_000_000);
+  // The camera is the live one, not the address bar's.
+  assert.equal(sharedState(href).lat, 0);
+  assert.equal(
+    makeManager('https://gev.example/', { positioned: false }).buildLink(),
+    null,
+  );
+});
+
+test('copyLink copies exactly what buildLink builds', async () => {
+  let copied = null;
+  installClipboard(async (url) => {
+    copied = url;
+  });
+  const manager = makeManager('https://gev.example/#v=2');
+  assert.equal(await manager.copyLink({ nowMs: 7_000_000 }), true);
+  assert.equal(copied, manager.buildLink({ nowMs: 7_000_000 }));
+});
+
+test('without a host hook the button copies the link', async () => {
+  let copied = null;
+  installClipboard(async (url) => {
+    copied = url;
+  });
+  const { toasts, click } = shell({
+    manager: makeManager('https://gev.example/#v=2'),
+  });
+  await click();
+  assert.match(copied, SHARE_LINK);
+  assert.deepEqual(toasts, ['Link copied!']);
+
+  installClipboard(async () => {
+    throw new Error('denied');
+  });
+  await click();
+  assert.deepEqual(toasts, ['Link copied!', 'Copy failed']);
+});
+
+test('a host hook receives the link and its result picks the toast', async () => {
+  installClipboard(async () => assert.fail('the host shares instead'));
+  const shared = [];
+  const results = ['shared', 'copied', 'cancelled', false];
+  const { toasts, click } = shell({
+    manager: makeManager('https://gev.example/#v=2'),
+    services: {
+      shareLink: async (url) => {
+        shared.push(url);
+        return results.shift();
+      },
+    },
+  });
+  for (let i = 0; i < 4; i++) await click();
+  assert.equal(shared.length, 4);
+  assert.match(shared[0], SHARE_LINK);
+  // 'cancelled' (the user closed the sheet) shows nothing.
+  assert.deepEqual(toasts, ['Link shared', 'Link copied!', 'Copy failed']);
+});
+
+test('a failing host hook, or no camera position, reports a failure', async () => {
+  const failing = shell({
+    manager: makeManager('https://gev.example/#v=2'),
+    services: { shareLink: async () => Promise.reject(new Error('no sheet')) },
+  });
+  await failing.click();
+  assert.deepEqual(failing.toasts, ['Copy failed']);
+
+  let called = false;
+  const unpositioned = shell({
+    manager: makeManager('https://gev.example/', { positioned: false }),
+    services: {
+      shareLink: async () => {
+        called = true;
+        return 'shared';
+      },
+    },
+  });
+  await unpositioned.click();
+  assert.equal(called, false);
+  assert.deepEqual(unpositioned.toasts, ['Copy failed']);
+});
+
+test('a host hook that answers without a promise, or throws, still gets a toast', async () => {
+  for (const [shareLink, toast] of [
+    [() => 'shared', 'Link shared'],
+    [
+      () => {
+        throw new Error('no sheet');
+      },
+      'Copy failed',
+    ],
+  ]) {
+    const { toasts, click } = shell({
+      manager: makeManager('https://gev.example/#v=2'),
+      services: { shareLink },
+    });
+    await click();
+    assert.deepEqual(toasts, [toast]);
+  }
+});

src/ui/shareFollow.js

@@ -0,0 +1,190 @@
+import * as Cesium from 'cesium';
+import { trackedDisplayPositionForCamera } from '../data/trackedCamera.js';
+import {
+  SHARE_VIEW_ENTITY_KINDS,
+  followOffsetFromEnu,
+  followOffsetToEnu,
+} from '../share/follow.js';
+
+/**
+ * The bridge between the camera following an entity and a share link's thing
+ * view: what the camera follows now, in the share format's terms, and the
+ * stored follow offset applied to an entity the camera has started to follow.
+ */
+
+const KIND_BY_LAYER = new Map(
+  SHARE_VIEW_ENTITY_KINDS.map((entry) => [entry.layerId, entry.kind]),
+);
+const MAX_FRAMES = 120;
+
+/** `position`'s local east/north/up offset from `origin`, in metres. */
+function enuOffset(origin, position) {
+  const frame = Cesium.Transforms.eastNorthUpToFixedFrame(origin);
+  const local = Cesium.Matrix4.multiplyByPoint(
+    Cesium.Matrix4.inverseTransformation(frame, new Cesium.Matrix4()),
+    position,
+    new Cesium.Cartesian3(),
+  );
+  return { east: local.x, north: local.y, up: local.z };
+}
+
+/**
+ * The entity the camera follows as `{ kind, id, offset, lastKnown }`, with
+ * the camera's offset from it and its displayed position as of `nowMs`; null
+ * when the camera follows nothing a share link can name. A selected vessel is
+ * not followed (the camera stays where the user puts it), so a link made then
+ * keeps its own camera.
+ */
+export function readShareFollowSubject({ viewer, nowMs = Date.now() }) {
+  const cameraPosition = viewer?.camera?.positionWC;
+  if (!cameraPosition) return null;
+  const tracked = viewer.trackedEntity;
+  const trackedId = String(tracked?.gevTrackedId || '');
+  const separator = trackedId.indexOf(':');
+  if (separator <= 0) return null;
+  const kind = KIND_BY_LAYER.get(trackedId.slice(0, separator));
+  const id = trackedId.slice(separator + 1);
+  const target = kind
+    ? trackedDisplayPositionForCamera(
+        tracked,
+        viewer.clock.currentTime,
+        new Cesium.Cartesian3(),
+      )
+    : null;
+  if (!kind || !id || !target) return null;
+  const offset = followOffsetFromEnu(enuOffset(target, cameraPosition));
+  const fix = Cesium.Cartographic.fromCartesian(target);
+  if (!offset || !fix) return null;
+  return {
+    kind,
+    id,
+    offset,
+    lastKnown: {
+      lat: Cesium.Math.toDegrees(fix.latitude),
+      lon: Cesium.Math.toDegrees(fix.longitude),
+      alt: fix.height,
+      observedAtMs: nowMs,
+    },
+  };
+}
+
+/** Largest turn, in radians, the camera makes around the entity per frame. */
+const MAX_TURN_PER_FRAME = Math.PI / 3;
+
+/**
+ * Put the camera at a shared follow offset from `entity` once following it
+ * has framed the camera. Cesium keeps the offset afterwards, as it keeps one
+ * the user orbits to. The camera swings round the entity at most 60° a frame:
+ * the follow's own guard treats a jump to the far side as the camera crossing
+ * through the entity and puts it back. Returns a disposer.
+ */
+export function applyShareFollowOffset(viewer, entity, offset) {
+  if (!viewer?.scene?.preUpdate || !entity || !(offset?.range > 0))
+    return () => {};
+  const local = followOffsetToEnu(offset);
+  let frames = 0;
+  let remove = null;
+  const stop = () => {
+    remove?.();
+    remove = null;
+  };
+  remove = viewer.scene.preUpdate.addEventListener(() => {
+    if (viewer.isDestroyed?.() || viewer.trackedEntity !== entity) {
+      stop();
+      return;
+    }
+    frames += 1;
+    const camera = viewer.camera;
+    // Let the follow frame the camera first (its first frame), then move it.
+    const framed =
+      frames > 1 &&
+      !Cesium.Matrix4.equals(camera.transform, Cesium.Matrix4.IDENTITY);
+    const target = framed
+      ? trackedDisplayPositionForCamera(
+          entity,
+          viewer.clock.currentTime,
+          new Cesium.Cartesian3(),
+        )
+      : null;
+    if (!target) {
+      if (frames >= MAX_FRAMES) stop();
+      return;
+    }
+    // The offset is east/north/up at the entity; the follow's own frame may
+    // differ, so place the camera in world space and re-express it there.
+    const world = Cesium.Matrix4.multiplyByPoint(
+      Cesium.Transforms.eastNorthUpToFixedFrame(target),
+      new Cesium.Cartesian3(local.east, local.north, local.up),
+      new Cesium.Cartesian3(),
+    );
+    const goal = Cesium.Matrix4.multiplyByPoint(
+      Cesium.Matrix4.inverseTransformation(
+        camera.transform,
+        new Cesium.Matrix4(),
+      ),
+      world,
+      new Cesium.Cartesian3(),
+    );
+    const from = Cesium.Cartesian3.clone(
+      camera.position,
+      new Cesium.Cartesian3(),
+    );
+    const angle =
+      Cesium.Cartesian3.magnitude(from) > 0
+        ? Cesium.Cartesian3.angleBetween(from, goal)
+        : 0;
+    const done = !(angle > MAX_TURN_PER_FRAME);
+    const next = done ? goal : turnToward(from, goal, MAX_TURN_PER_FRAME);
+    camera.lookAtTransform(camera.transform, next);
+    viewer.scene.requestRender?.();
+    if (done) stop();
+  });
+  return stop;
+}
+
+/**
+ * `from` turned `step` radians toward `to`, with its length moved the same
+ * fraction of the way: one frame of the swing round the entity.
+ */
+function turnToward(from, to, step) {
+  const angle = Cesium.Cartesian3.angleBetween(from, to);
+  const unitFrom = Cesium.Cartesian3.normalize(from, new Cesium.Cartesian3());
+  // The direction perpendicular to `from` in the plane toward `to` (or any
+  // perpendicular when they are opposite).
+  let toward = Cesium.Cartesian3.subtract(
+    Cesium.Cartesian3.normalize(to, new Cesium.Cartesian3()),
+    Cesium.Cartesian3.multiplyByScalar(
+      unitFrom,
+      Math.cos(angle),
+      new Cesium.Cartesian3(),
+    ),
+    new Cesium.Cartesian3(),
+  );
+  if (Cesium.Cartesian3.magnitude(toward) < 1e-9)
+    toward = Cesium.Cartesian3.cross(
+      unitFrom,
+      Math.abs(unitFrom.z) < 0.9
+        ? Cesium.Cartesian3.UNIT_Z
+        : Cesium.Cartesian3.UNIT_X,
+      new Cesium.Cartesian3(),
+    );
+  Cesium.Cartesian3.normalize(toward, toward);
+  const length =
+    Cesium.Cartesian3.magnitude(from) +
+    (Cesium.Cartesian3.magnitude(to) - Cesium.Cartesian3.magnitude(from)) *
+      (step / angle);
+  const direction = Cesium.Cartesian3.add(
+    Cesium.Cartesian3.multiplyByScalar(
+      unitFrom,
+      Math.cos(step),
+      new Cesium.Cartesian3(),
+    ),
+    Cesium.Cartesian3.multiplyByScalar(
+      toward,
+      Math.sin(step),
+      new Cesium.Cartesian3(),
+    ),
+    new Cesium.Cartesian3(),
+  );
+  return Cesium.Cartesian3.multiplyByScalar(direction, length, direction);
+}

src/ui/shareLinks.test.mjs

@@ -0,0 +1,554 @@
+// Short share links: `/share/<code>` opens through the start-up restore
+// pipeline, the address then follows the live view, and the share button
+// makes `/share/<code>` links (following an entity when the camera does).
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import * as Cesium from 'cesium';
+import { ShareLinkManager } from '../sharelink.js';
+import { ShareRestoration, sharedFixNotice } from './shareRestoration.js';
+import {
+  applyShareFollowOffset,
+  readShareFollowSubject,
+} from './shareFollow.js';
+import { createDefaultLayerState } from '../data/layerState.js';
+import { parseSharePath, shareLinkUrl } from '../share/shareLinkPath.js';
+import {
+  decodeShareView,
+  encodeShareView,
+  followCameraFor,
+  followOffsetToEnu,
+} from '../share/viewCodec.js';
+
+const NOW_MS = Date.now();
+const FIX = { lat: 37.6213, lon: -122.379, alt: 3200 };
+const OFFSET = { range: 5800, heading: 0, pitch: -35 };
+
+const PLACE_CODE = encodeShareView({
+  lat: 48.8584,
+  lon: 2.2945,
+  alt: 1200,
+  heading: 120,
+  pitch: -25,
+  style: 'noir',
+  panelState: { specs: [{ id: 'data-panel', collapsed: false }] },
+  sharedAtMs: NOW_MS - 60_000,
+});
+
+function aircraftCode() {
+  const layerState = createDefaultLayerState();
+  layerState.enabledLayerIds = ['flights'];
+  return encodeShareView({
+    view: {
+      kind: 'thing',
+      entity: { kind: 'aircraft', id: 'a1b2c3' },
+      offset: OFFSET,
+      lastKnown: { ...FIX, observedAtMs: NOW_MS - 120_000 },
+    },
+    layerState,
+    sharedAtMs: NOW_MS - 120_000,
+  });
+}
+
+/**
+ * A page at `href`. `history.replaceState` rewrites the address in place and
+ * is counted; `pushState` (a new history entry) is counted too.
+ */
+function installPage(t, href) {
+  const prior = { window: globalThis.window, history: globalThis.history };
+  const target = new EventTarget();
+  const location = new URL(href);
+  target.location = location;
+  globalThis.window = target;
+  const writes = { replaced: 0, pushed: 0 };
+  globalThis.history = {
+    replaceState(_state, _title, next) {
+      writes.replaced += 1;
+      location.href = new URL(next, location.href).href;
+    },
+    pushState() {
+      writes.pushed += 1;
+    },
+  };
+  t.after(() => Object.assign(globalThis, prior));
+  return { location, writes, target };
+}
+
+function installManualTimers(t) {
+  const prior = {
+    setTimeout: globalThis.setTimeout,
+    clearTimeout: globalThis.clearTimeout,
+  };
+  const timers = new Map();
+  let timerId = 0;
+  globalThis.setTimeout = (fn) => {
+    timers.set(++timerId, fn);
+    return timerId;
+  };
+  globalThis.clearTimeout = (id) => timers.delete(id);
+  t.after(() => Object.assign(globalThis, prior));
+  return {
+    timers,
+    runAll() {
+      for (const [id, fn] of [...timers]) {
+        timers.delete(id);
+        fn();
+      }
+    },
+  };
+}
+
+/** A viewer whose camera flights land at once. */
+function fakeViewer() {
+  const flights = [];
+  return {
+    flights,
+    canvas: new EventTarget(),
+    camera: {
+      changed: { addEventListener: () => () => {} },
+      positionCartographic: { latitude: 0, longitude: 0, height: 1000 },
+      heading: 0,
+      pitch: -Math.PI / 2,
+      roll: 0,
+      flyTo(options) {
+        flights.push(options);
+        options.complete?.();
+      },
+      setView() {},
+    },
+  };
+}
+
+const flush = () => new Promise((resolve) => setImmediate(resolve));
+
+/** A ShareRestoration over a real ShareLinkManager, as the shell wires them. */
+function openPage(t, href, { managerOptions = {}, tracking = null } = {}) {
+  const page = installPage(t, href);
+  const clock = installManualTimers(t);
+  const viewer = fakeViewer();
+  const restores = [];
+  const manager = new ShareLinkManager(viewer, {
+    onRestore: async (state) => restores.push(state),
+    isNavigationCurrent: () => true,
+    ...managerOptions,
+  });
+  const notices = [];
+  let generation = 0;
+  const owner = new ShareRestoration({
+    viewer,
+    navigation: {
+      _beginDeferredNavigation: () => ++generation,
+      _reassertNavigationHandoff: () => true,
+      _stampNavigation() {},
+    },
+    syncShareState() {},
+    syncModels3d() {},
+    showStatus() {},
+    feedback: {},
+    updateFeedback() {},
+    applyFollowOffset: (entity, offset) =>
+      applyShareFollowOffset(viewer, entity, offset),
+  });
+  // Notices are checked by message; their start-up-cover timing is not.
+  owner._presentAfterStartupCover = (message) => notices.push(message);
+  owner.attachLinks(manager);
+  owner._layerStateCoordinator = {
+    applyShareLayerState: () => Promise.resolve([]),
+    getDurableState: () => null,
+    cancelPendingShareTracking: () => false,
+    restoreShareTrackingSelection: async () => tracking?.(owner) ?? null,
+    destroy() {},
+  };
+  owner.start();
+  t.after(() => owner.destroy());
+  return { ...page, ...clock, viewer, manager, owner, restores, notices };
+}
+
+/** Run the delayed start-up restore and let it settle. */
+async function restore(page) {
+  page.runAll();
+  const result = await page.owner.initialRestorePromise;
+  await flush();
+  return result;
+}
+
+test('a /share/<code> address opens its place view through the start-up restore', async (t) => {
+  const page = openPage(t, `http://localhost/share/${PLACE_CODE}`);
+  assert.equal(page.timers.size, 1, 'the restore waits for its delayed flight');
+  assert.equal(page.manager._initialRestorePending, true);
+  const result = await restore(page);
+  assert.equal(result.status, 'settled');
+  assert.equal(result.share.camera, 'applied');
+  assert.equal(page.restores[0].style, 'noir');
+  assert.deepEqual(page.restores[0].panelState.specs, [
+    { id: 'data-panel', collapsed: false, pinned: null },
+  ]);
+  const destination = Cesium.Cartographic.fromCartesian(
+    page.viewer.flights[0].destination,
+  );
+  assert.ok(
+    Math.abs(Cesium.Math.toDegrees(destination.latitude) - 48.8584) < 1e-6,
+  );
+  assert.equal(page.manager._initialRestorePending, false);
+  assert.deepEqual(page.notices, []);
+});
+
+test('after a restore the address becomes the app root and the long hash, with no new history entry', async (t) => {
+  for (const [href, root] of [
+    [`http://localhost/share/${PLACE_CODE}`, 'http://localhost/'],
+    [
+      `http://localhost:4173/gev/share/${PLACE_CODE}`,
+      'http://localhost:4173/gev/',
+    ],
+  ]) {
+    const page = openPage(t, href);
+    await restore(page);
+    page.manager._updateHash();
+    assert.equal(`${page.location.origin}${page.location.pathname}`, root);
+    // The live view's long form, as written for any other page.
+    const params = new URLSearchParams(page.location.hash.slice(1));
+    assert.equal(params.get('v'), '2');
+    assert.ok(params.has('lat') && params.has('style'));
+    assert.equal(page.writes.pushed, 0);
+    assert.equal(page.writes.replaced, 1);
+    page.manager.destroy();
+  }
+});
+
+test('a host can pass the share code instead of the address', async (t) => {
+  const page = openPage(t, 'http://localhost/', {
+    managerOptions: { initialShareCode: PLACE_CODE },
+  });
+  await restore(page);
+  assert.equal(page.restores[0].style, 'noir');
+});
+
+test('a code that fails its check restores nothing and says so', async (t) => {
+  // One character changed: the check byte no longer matches.
+  const last = PLACE_CODE.at(-2) === 'A' ? 'B' : 'A';
+  const typo = `${PLACE_CODE.slice(0, -2)}${last}${PLACE_CODE.at(-1)}`;
+  const page = openPage(t, `http://localhost/share/${typo}`);
+  assert.equal(page.manager.rejectedShareCode, 'checksum');
+  assert.notEqual(page.owner._hasShareState, true);
+  assert.equal(page.timers.size, 0, 'nothing to restore');
+  assert.equal(
+    (await page.owner.initialRestorePromise).status,
+    'not-requested',
+  );
+  assert.deepEqual(page.notices, ["This share link can't be opened"]);
+  // The default start's first address write leaves the bad link behind.
+  page.manager._updateHash();
+  assert.equal(page.location.pathname, '/');
+});
+
+test('a thing view turns its layer on, follows by id and frames the shared offset', async (t) => {
+  let entity = null;
+  const page = openPage(t, `http://localhost/share/${aircraftCode()}`, {
+    tracking: (owner) => {
+      // What the coordinator does when the aircraft is in the feed.
+      owner.viewer.trackedEntity = entity;
+      owner._handleShareTrackingRestoreStatus({
+        layerId: 'flights',
+        targetId: 'a1b2c3',
+        classification: 'followed',
+      });
+      return { classification: 'followed' };
+    },
+  });
+  const target = Cesium.Cartesian3.fromDegrees(FIX.lon, FIX.lat, FIX.alt);
+  const listeners = [];
+  const looks = [];
+  Object.assign(page.viewer, {
+    clock: { currentTime: Cesium.JulianDate.now() },
+    scene: {
+      preUpdate: {
+        addEventListener(fn) {
+          listeners.push(fn);
+          return () => listeners.splice(listeners.indexOf(fn), 1);
+        },
+      },
+    },
+    isDestroyed: () => false,
+  });
+  Object.assign(page.viewer.camera, {
+    transform: Cesium.Transforms.eastNorthUpToFixedFrame(target),
+    // The app's own follow framing: south of the aircraft and above it.
+    position: new Cesium.Cartesian3(0, -4800, 3300),
+    lookAtTransform(transform, offset) {
+      looks.push(offset);
+      this.position = Cesium.Cartesian3.clone(offset);
+    },
+  });
+  entity = {
+    gevTrackedId: 'flights:a1b2c3',
+    gevDisplayPosition: () => target,
+  };
+
+  const parsed = page.manager._parseShareCode(aircraftCode());
+  assert.deepEqual(parsed.layerState.enabledLayerIds, ['flights']);
+  assert.equal(
+    parsed.layerState.options.flights.selectedFlightsTrackingId,
+    'a1b2c3',
+  );
+  await restore(page);
+  // The opening flight goes where following the fix puts the camera.
+  const camera = followCameraFor(FIX, OFFSET);
+  const destination = Cesium.Cartographic.fromCartesian(
+    page.viewer.flights[0].destination,
+  );
+  assert.ok(
+    Math.abs(Cesium.Math.toDegrees(destination.latitude) - camera.lat) < 1e-3,
+  );
+  assert.ok(
+    Math.abs(Cesium.Math.toDegrees(destination.longitude) - camera.lon) < 1e-3,
+  );
+  // Once followed, the camera takes the shared offset after the follow's
+  // own first frame.
+  assert.equal(listeners.length, 1);
+  listeners[0]();
+  assert.equal(looks.length, 0);
+  listeners[0]?.();
+  assert.equal(looks.length, 1);
+  const expected = followOffsetToEnu(OFFSET);
+  assert.ok(Math.abs(looks[0].x - expected.east) < 1);
+  assert.ok(Math.abs(looks[0].y - expected.north) < 1);
+  assert.ok(Math.abs(looks[0].z - expected.up) < 1);
+  assert.equal(listeners.length, 0, 'the offset is applied once');
+  assert.deepEqual(page.notices, []);
+});
+
+test('a thing that is not reporting leaves the view at its last-known fix, with a notice', async (t) => {
+  const page = openPage(t, `http://localhost/share/${aircraftCode()}`, {
+    tracking: (owner) => {
+      // The coordinator's verdict once the follow window has passed.
+      const result = {
+        layerId: 'flights',
+        targetId: 'a1b2c3',
+        label: 'flight',
+        classification: 'expired',
+      };
+      owner._handleShareTrackingRestoreStatus(result);
+      return result;
+    },
+  });
+  await restore(page);
+  await flush();
+  assert.equal(page.notices.length, 1);
+  assert.match(
+    page.notices[0],
+    /^A1B2C3 isn't reporting now — showing where it was at .+/,
+  );
+  // A long link names no fix and keeps the existing notice.
+  page.owner._initialShareState = { shareView: null };
+  page.owner._handleShareTrackingRestoreStatus({
+    layerId: 'flights',
+    targetId: 'a1b2c3',
+    label: 'flight',
+    classification: 'expired',
+  });
+  assert.equal(page.notices[1], 'Shared flight follow expired');
+});
+
+test('the not-reporting notice names the id and the time of the fix', () => {
+  const at = new Date(2026, 9, 26, 14, 5).getTime();
+  assert.match(
+    sharedFixNotice({ kind: 'aircraft', id: 'a1b2c3' }, at, at + 60_000),
+    /^A1B2C3 isn't reporting now — showing where it was at .*05/,
+  );
+  assert.equal(
+    sharedFixNotice({ kind: 'vessel', id: '366999712' }, null),
+    "366999712 isn't reporting now — showing where it was last seen",
+  );
+});
+
+test('a shared vessel is selected once the vessel feed has it', async (t) => {
+  t.mock.timers.enable({ apis: ['Date'], now: NOW_MS });
+  const page = openPage(t, 'http://localhost/');
+  const selected = [];
+  let present = false;
+  page.owner._dataManager = {
+    layers: new Map([
+      [
+        'ais-live-vessels',
+        {
+          module: {
+            hasContact: (id) => present && id === '366999712',
+            selectById: (id) => selected.push(id) > 0,
+          },
+        },
+      ],
+    ]),
+  };
+  const view = {
+    kind: 'thing',
+    entity: { kind: 'vessel', id: '366999712' },
+    lastKnown: { lat: 1, lon: 2, alt: 0, observedAtMs: NOW_MS - 30_000 },
+  };
+  const found = page.owner._restoreSharedVessel(view, () => true);
+  await flush();
+  present = true;
+  page.runAll();
+  assert.equal(await found, true);
+  assert.deepEqual(selected, ['366999712']);
+
+  present = false;
+  const missing = page.owner._restoreSharedVessel(view, () => true);
+  for (let i = 0; i < 61; i += 1) {
+    await flush();
+    t.mock.timers.tick(2_000);
+    page.runAll();
+  }
+  assert.equal(await missing, false);
+  assert.match(page.notices.at(-1), /^366999712 isn't reporting now/);
+});
+
+test('the share button links to /share/<code>, following the followed entity', (t) => {
+  installPage(t, 'https://gev.example/?lang=ru#v=2&lat=1&lon=2');
+  const manager = new ShareLinkManager(fakeViewer());
+  // A fresh session's look, as the app reports it at start-up.
+  manager.onToggleChange(false, true, {
+    hudVisible: true,
+    detectionMode: 'DENSE',
+    detectionDensity: 75,
+  });
+  // No entity: a place view at the live camera.
+  const place = manager.buildLink({ nowMs: NOW_MS });
+  assert.match(place, /^https:\/\/gev\.example\/share\/[A-Za-z0-9_-]+$/);
+  assert.equal(
+    decodeShareView(parseSharePath(new URL(place).pathname).code).state.view
+      .kind,
+    'place',
+  );
+
+  manager.setFollowSubjectProvider(() => ({
+    kind: 'aircraft',
+    id: 'a1b2c3',
+    offset: OFFSET,
+    lastKnown: { ...FIX, observedAtMs: NOW_MS },
+  }));
+  const href = manager.buildLink({ nowMs: NOW_MS });
+  const code = parseSharePath(new URL(href).pathname).code;
+  const { state } = decodeShareView(code, { nowMs: NOW_MS });
+  assert.deepEqual(state.view, {
+    kind: 'thing',
+    entity: { kind: 'aircraft', id: 'a1b2c3' },
+    offset: OFFSET,
+    lastKnown: { ...FIX, observedAtMs: Math.floor(NOW_MS / 1000) * 1000 },
+  });
+  // The followed aircraft's layer is implied; the camera is derived.
+  assert.ok(code.length <= 45, `${code.length} characters`);
+  assert.equal(href, shareLinkUrl(code, 'https://gev.example/'));
+  manager.destroy();
+});
+
+test('the followed entity is read in the share format, and its offset round-trips', () => {
+  const target = Cesium.Cartesian3.fromDegrees(FIX.lon, FIX.lat, FIX.alt);
+  const offset = { range: 2400, heading: 30, pitch: -20 };
+  const local = followOffsetToEnu(offset);
+  const cameraPosition = Cesium.Matrix4.multiplyByPoint(
+    Cesium.Transforms.eastNorthUpToFixedFrame(target),
+    new Cesium.Cartesian3(local.east, local.north, local.up),
+    new Cesium.Cartesian3(),
+  );
+  const viewer = {
+    camera: { positionWC: cameraPosition },
+    clock: { currentTime: Cesium.JulianDate.now() },
+    trackedEntity: {
+      gevTrackedId: 'military:ae1234',
+      gevDisplayPosition: () => target,
+    },
+  };
+  const subject = readShareFollowSubject({ viewer, nowMs: NOW_MS });
+  assert.equal(subject.kind, 'military_aircraft');
+  assert.equal(subject.id, 'ae1234');
+  assert.deepEqual(subject.offset, offset);
+  assert.ok(Math.abs(subject.lastKnown.lat - FIX.lat) < 1e-9);
+  assert.ok(Math.abs(subject.lastKnown.alt - FIX.alt) < 1e-3);
+  // A followed entity the share format has no kind for is not a thing view.
+  viewer.trackedEntity.gevTrackedId = 'local-adsb:abc';
+  assert.equal(readShareFollowSubject({ viewer }), null);
+  // Nor is a camera that follows nothing (a selected vessel is not followed).
+  viewer.trackedEntity = undefined;
+  assert.equal(readShareFollowSubject({ viewer }), null);
+});
+
+test('a shared offset on the far side swings round, never jumping through the entity', () => {
+  const target = Cesium.Cartesian3.fromDegrees(FIX.lon, FIX.lat, FIX.alt);
+  const listeners = [];
+  const looks = [];
+  const entity = { gevDisplayPosition: () => target };
+  const viewer = {
+    clock: { currentTime: Cesium.JulianDate.now() },
+    scene: {
+      preUpdate: {
+        addEventListener(fn) {
+          listeners.push(fn);
+          return () => listeners.splice(listeners.indexOf(fn), 1);
+        },
+      },
+    },
+    trackedEntity: entity,
+    camera: {
+      transform: Cesium.Transforms.eastNorthUpToFixedFrame(target),
+      position: new Cesium.Cartesian3(0, -4800, 3300),
+      lookAtTransform(transform, offset) {
+        looks.push(Cesium.Cartesian3.clone(offset));
+        this.position = Cesium.Cartesian3.clone(offset);
+      },
+    },
+  };
+  // Looking south at the nose: the opposite side of the app's framing.
+  const offset = { range: 5800, heading: 180, pitch: -35 };
+  applyShareFollowOffset(viewer, entity, offset);
+  let previous = viewer.camera.position;
+  for (let frame = 0; frame < 10 && listeners.length; frame += 1) {
+    listeners[0]();
+    const now = viewer.camera.position;
+    // The follow's guard treats a turn of 90° or more as a crossing.
+    assert.ok(Cesium.Cartesian3.angleBetween(previous, now) < Math.PI / 2);
+    previous = now;
+  }
+  assert.equal(listeners.length, 0, 'it arrives');
+  assert.ok(looks.length >= 2, `${looks.length} steps`);
+  const expected = followOffsetToEnu(offset);
+  const last = looks.at(-1);
+  assert.ok(Math.abs(last.x - expected.east) < 1);
+  assert.ok(Math.abs(last.y - expected.north) < 1);
+  assert.ok(Math.abs(last.z - expected.up) < 1);
+});
+
+test('applying a follow offset gives up when the follow ends', () => {
+  const listeners = [];
+  const viewer = {
+    scene: {
+      preUpdate: {
+        addEventListener(fn) {
+          listeners.push(fn);
+          return () => listeners.splice(listeners.indexOf(fn), 1);
+        },
+      },
+    },
+    trackedEntity: null,
+  };
+  applyShareFollowOffset(viewer, {}, OFFSET);
+  listeners[0]();
+  assert.equal(listeners.length, 0);
+});
+
+test('long links and hash navigation are unaffected by a share code start', async (t) => {
+  // A long link still opens from the hash.
+  const long = openPage(t, 'http://localhost/#v=2&lat=10&lon=20&style=nvg');
+  await restore(long);
+  assert.equal(long.restores[0].style, 'surveillance');
+  assert.equal(long.restores[0].shareView, undefined);
+  long.manager._updateHash();
+  assert.equal(long.location.pathname, '/');
+
+  // After a /share start, navigating to a long link restores it (#1416).
+  const page = openPage(t, `http://localhost/share/${PLACE_CODE}`);
+  await restore(page);
+  page.location.hash = 'v=2&lat=1.0000&lon=2.0000&style=normal';
+  page.target.dispatchEvent(new Event('hashchange'));
+  await flush();
+  assert.equal(page.restores.length, 2);
+  assert.equal(page.restores[1].style, 'normal');
+});

src/ui/shareRestoration.js

@@ -1,9 +1,18 @@
 import { LayerStateCoordinator } from '../data/layerStateCoordinator.js';
 import { stampInitialShareGesture } from '../navigationPolicy.js';
 import { canPresentDeferredStatusNotice } from '../loadingFeedback.js';
-import { t, msg } from '../i18n/index.js';
+import { t, msg, formatDate } from '../i18n/index.js';
+import { SHARE_VIEW_ENTITY_KINDS } from '../share/follow.js';
 import { UiLifetime } from './uiLifetime.js';
 
+/** How long a shared vessel may take to appear in the vessel feed. */
+export const SHARED_VESSEL_WAIT_MS = 120_000;
+const SHARED_VESSEL_POLL_MS = 2_000;
+const DAY_MS = 86_400_000;
+const ENTITY_BY_KIND = new Map(
+  SHARE_VIEW_ENTITY_KINDS.map((entry) => [entry.kind, entry]),
+);
+
 // One ready-made sentence per restore policy (SHARE_TRACKING_RESTORE_POLICIES
 // label) and outcome: a label dropped into a template cannot take the case or
 // article the sentence needs in every language. The generic template stays
@@ -51,6 +60,36 @@ export function shareTrackingRestoreNotice(result) {
       : t('Shared {subject} is unavailable', { subject });
 }
 
+/**
+ * The notice for a shared entity that is not reporting: the view shows where
+ * it was when the link was made.
+ * @param {{kind: string, id: string}} entity
+ * @param {number|null} observedAtMs
+ * @param {number} [nowMs]
+ * @returns {string}
+ */
+export function sharedFixNotice(entity, observedAtMs, nowMs = Date.now()) {
+  // ICAO addresses read as they are written on the aircraft: upper case.
+  const id =
+    ENTITY_BY_KIND.get(entity.kind)?.idForm === 'hex24'
+      ? String(entity.id).toUpperCase()
+      : String(entity.id);
+  if (!Number.isFinite(observedAtMs))
+    return t("{id} isn't reporting now — showing where it was last seen", {
+      id,
+    });
+  const time = formatDate(
+    observedAtMs,
+    nowMs - observedAtMs < DAY_MS
+      ? { hour: '2-digit', minute: '2-digit' }
+      : { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' },
+  );
+  return t("{id} isn't reporting now — showing where it was at {time}", {
+    id,
+    time,
+  });
+}
+
 /** Own initial share restoration, durable layer state and restoration notices. */
 export class ShareRestoration {
   constructor({
@@ -61,6 +100,7 @@ export class ShareRestoration {
     showStatus,
     feedback,
     updateFeedback,
+    applyFollowOffset = null,
   }) {
     Object.assign(this, {
       viewer,
@@ -70,6 +110,9 @@ export class ShareRestoration {
       showStatus,
       feedback,
       updateFeedback,
+      // (entity, offset) => disposer: frame a followed entity from a shared
+      // follow offset (shareFollow.js).
+      applyFollowOffset,
     });
     this._lifetime = new UiLifetime();
     this._disposed = false;
@@ -84,6 +127,10 @@ export class ShareRestoration {
     // settles later must neither apply follow-up work nor release URL writes.
     this._shareRestoreGeneration = 0;
     this._navigatedShareRestoreActive = false;
+    this._stopFollowOffset = null;
+    // Bumped to abandon the wait for a shared vessel.
+    this._sharedVesselGeneration = 0;
+    this._sharedVesselPending = false;
   }
   attachLinks(shareLinkManager) {
     this.shareLinkManager = shareLinkManager;
@@ -121,11 +168,21 @@ export class ShareRestoration {
       }, 1500);
     } else {
       this.syncShareState();
+      if (this.shareLinkManager?.rejectedShareCode)
+        this._presentAfterStartupCover(
+          t("This share link can't be opened"),
+          ++this._shareTrackingNoticeGeneration,
+        );
     }
     // A recipient can orbit before or during the delayed share flight. That
     // gesture keeps ordinary layer state but revokes the passive base camera
     // and selected-subject Follow so delayed work cannot seize navigation.
     this._initialShareGestureHandler = () => {
+      // The recipient taking the camera also ends the wait for a vessel.
+      if (this._sharedVesselPending) {
+        this._sharedVesselGeneration += 1;
+        this._sharedVesselPending = false;
+      }
       if (
         this._disposed ||
         !this._hasShareState ||
@@ -191,6 +248,10 @@ export class ShareRestoration {
             };
       if (!current()) return;
       this.shareLinkManager.completeInitialRestore(state.restoreToken);
+      // Selecting a vessel leaves the camera alone, so it does not depend on
+      // the shared flight having landed.
+      const vessel = this._sharedVessel(state);
+      if (vessel) void this._restoreSharedVessel(vessel, current);
       settle({ status: 'settled', share, layers, tracking });
     } catch (error) {
       if (!current()) return;
@@ -301,7 +362,79 @@ export class ShareRestoration {
       });
     }
   }
+  /** The shared vessel a share's thing view selects, if it names one. */
+  _sharedVessel(state) {
+    const view = state?.shareView;
+    return view?.kind === 'thing' && view.entity.kind === 'vessel'
+      ? view
+      : null;
+  }
+
+  /**
+   * Select a shared vessel once the vessel feed has it. Vessels are selected,
+   * not followed: the camera is already at the shared view. If the vessel does
+   * not appear in time, the view stays where it was when the link was made.
+   */
+  async _restoreSharedVessel(view, current) {
+    const generation = ++this._sharedVesselGeneration;
+    const live = () => current() && generation === this._sharedVesselGeneration;
+    const deadline = Date.now() + SHARED_VESSEL_WAIT_MS;
+    const { id } = view.entity;
+    const { layerId } = ENTITY_BY_KIND.get(view.entity.kind);
+    this._sharedVesselPending = true;
+    try {
+      while (live()) {
+        const vessels = this._dataManager?.layers?.get?.(layerId)?.module;
+        if (vessels?.hasContact?.(id) && vessels.selectById(id)) return true;
+        if (Date.now() >= deadline) break;
+        await new Promise((resolve) =>
+          this._lifetime.timeout(resolve, SHARED_VESSEL_POLL_MS),
+        );
+      }
+    } finally {
+      if (generation === this._sharedVesselGeneration)
+        this._sharedVesselPending = false;
+    }
+    if (!live()) return false;
+    this._presentAfterStartupCover(
+      view.lastKnown
+        ? sharedFixNotice(view.entity, view.lastKnown.observedAtMs)
+        : t('Shared vessel is unavailable'),
+      ++this._shareTrackingNoticeGeneration,
+    );
+    return false;
+  }
+
+  /** The current share's thing view when `result` is about its entity. */
+  _sharedThingFor(result) {
+    const view = this._initialShareState?.shareView;
+    if (view?.kind !== 'thing') return null;
+    const entry = ENTITY_BY_KIND.get(view.entity.kind);
+    return entry?.tracking === result?.layerId &&
+      String(view.entity.id) === String(result?.targetId)
+      ? view
+      : null;
+  }
+
+  /** Frame a shared entity the camera now follows from the shared offset. */
+  _applySharedFollowOffset(result) {
+    const view = this._sharedThingFor(result);
+    const entity = this.viewer?.trackedEntity;
+    // Only a link made while following carries a real offset (with the fix);
+    // a long link's follow keeps the app's own framing.
+    if (
+      !view?.lastKnown ||
+      String(entity?.gevTrackedId || '') !==
+        `${result.layerId}:${result.targetId}`
+    )
+      return;
+    this._stopFollowOffset?.();
+    this._stopFollowOffset = this.applyFollowOffset?.(entity, view.offset);
+  }
+
   cancelSelection() {
+    // An explicit navigation also ends the wait for a shared vessel.
+    this._sharedVesselGeneration += 1;
     if (
       this._hasShareState &&
       this._resolveInitialShareRestore &&
@@ -347,17 +480,39 @@ export class ShareRestoration {
         this.updateFeedback();
       }
     }
-    if (
-      result.classification === 'followed' ||
-      result.classification === 'cancelled'
-    )
+    if (result.classification === 'followed') {
+      this._applySharedFollowOffset(result);
       return;
+    }
+    if (result.classification === 'cancelled') return;
     // A stale terminal result must never replace a newer target's acquisition.
     if (this._shareTrackingAcquiringKey) return;
     const noticeGeneration = ownsAcquiringNotice
       ? this._shareTrackingNoticeGeneration
       : ++this._shareTrackingNoticeGeneration;
-    const message = shareTrackingRestoreNotice(result);
+    // A share link that knows where the entity was says so; the view is
+    // already there.
+    const fix = this._sharedThingFor(result)?.lastKnown;
+    const message = fix
+      ? sharedFixNotice(
+          this._initialShareState.shareView.entity,
+          fix.observedAtMs,
+        )
+      : shareTrackingRestoreNotice(result);
+    if (this._resolveInitialShareRestore) {
+      void this.initialRestorePromise.then(() =>
+        this._presentAfterStartupCover(message, noticeGeneration),
+      );
+      return;
+    }
+    this._presentAfterStartupCover(message, noticeGeneration);
+  }
+
+  /**
+   * Show a status notice once the start-up cover is gone, unless a newer
+   * notice (generation) has taken its place.
+   */
+  _presentAfterStartupCover(message, noticeGeneration) {
     const showAfterStartupCover = () => {
       this._lifetime.frame(() => {
         if (
@@ -399,10 +554,6 @@ export class ShareRestoration {
         fallbackTimer = this._lifetime.timeout(showOnce, 1000);
       });
     };
-    if (this._resolveInitialShareRestore) {
-      void this.initialRestorePromise.then(showAfterStartupCover);
-      return;
-    }
     showAfterStartupCover();
   }
   _settleInitialShareRestore(result) {
@@ -419,6 +570,9 @@ export class ShareRestoration {
     this._disposed = true;
     this._shareTrackingNoticeGeneration += 1;
     this._shareTrackingAcquiringKey = null;
+    this._sharedVesselGeneration += 1;
+    this._stopFollowOffset?.();
+    this._stopFollowOffset = null;
     this._layerStateCoordinator?.destroy();
     this._layerStateCoordinator = null;
     this._layerStateRestorePromise = null;