meta-sovereign 0.53.1 → 0.53.3

package/README.md

@@ -61,7 +61,7 @@ The hosted app is the default UI: `serve` prints its address, <https://link-foun
 
 On macOS, interactive `serve` now handles the full setup: it protects this installation’s TLS key with Secure Enclave, detects existing certificate trust, requests trust only when needed, and opens the GitHub Pages app. For a headless launch use `node js/bin/meta-sovereign.js serve --trust=true --open=true`. `--trust=false` and `--open=false` opt out. The Swift helper needs the macOS Command Line Tools; `--hardware-key=false` explicitly opts into a file key on unsupported Macs. Hardware protection applies to the key on disk; Node uses it in memory. See [local server setup and security](docs/LOCAL-SERVER-SECURITY.md) for the exact access rules and limits.
 
-Open conversations load first and show loading or retry status until their history is ready. Earlier history loads automatically on scroll in Chat and Operator. Message selection and menus work across the full row; unread cards use refreshed Telegram counters and retain cached data during connection failures. All / Private / Groups / Channels filters remain available inside every Telegram folder. Drag the vertical dividers to resize columns; widths are remembered. Calls is in the main menu after Chat, and Telegram account editing is under Profile. The default dark controls use white line icons. The JS server keeps its store under your OS user: `~/Library/Application Support/Meta Sovereign/store` on macOS, `%APPDATA%/Meta Sovereign/store` on Windows, and `${XDG_CONFIG_HOME:-~/.config}/Meta Sovereign/store` on Linux. Starting `serve` from an older checkout migrates its `.meta-sovereign` store once, preserving messages, contacts, sessions, media and certificate; a compatibility link preserves old paths. Restarts and a different working directory reuse the same store. `--store` or `META_SOVEREIGN_STORE_DIR` override it. See [chat readiness and data storage](docs/CHAT-READINESS.md).
+Open conversations load first. History loads automatically on scroll, with a compact indicator inside the message list while requesting or retrying; no history status panel or manual loading button is shown. Earlier history loads automatically on scroll in Chat and Operator. Message selection and menus work across the full row; unread cards use refreshed Telegram counters and retain cached data during connection failures. All / Private / Groups / Channels filters remain available inside every Telegram folder. Drag the vertical dividers to resize columns; widths are remembered. Calls is in the main menu after Chat, and Telegram account editing is under Profile. The default dark controls use white line icons. Buttons and action links have nonzero spacing and aligned control padding. Stories is off by default; Settings → Stories enables its display and requests. The JS server keeps its store under your OS user: `~/Library/Application Support/Meta Sovereign/store` on macOS, `%APPDATA%/Meta Sovereign/store` on Windows, and `${XDG_CONFIG_HOME:-~/.config}/Meta Sovereign/store` on Linux. Starting `serve` from an older checkout migrates its `.meta-sovereign` store once, preserving messages, contacts, sessions, media and certificate; a compatibility link preserves old paths. Restarts and a different working directory reuse the same store. `--store` or `META_SOVEREIGN_STORE_DIR` override it. See [chat readiness and data storage](docs/CHAT-READINESS.md).
 
 ## Connect the SPA to your server
 
@@ -370,3 +370,5 @@ The CI/CD pipeline inherited from `js-ai-driven-development-pipeline-template` c
 ## License
 
 [Unlicense](LICENSE) - Public Domain
+
+Reloads and browser history preserve your section and conversation context; see [navigation](docs/NAVIGATION.md). [Mini App recovery](docs/MINI-APPS.md) documents SDK compatibility and external-site limitations.

package/js/src/crm/reengage.js

@@ -22,6 +22,10 @@ import {
   definedOnly,
   defaultAddressRules,
 } from './address-form.js';
+import {
+  telegramChatUrl,
+  isTelegramWebUrl,
+} from '../sources/telegram-chat-url.js';
 import { addressFormOf } from './person-learn.js';
 import {
   batchStopReason,
@@ -300,12 +304,18 @@ export const templateFor = (templates, form) =>
  * where the platform documents one; `null` elsewhere (copy the text).
  *
  * - e-mail: RFC 6068 `mailto:<addr>?body=` (line breaks as %0D%0A).
- * - Telegram: `tg://user?id=<id>` opens the chat with that user (Bot
- *   API docs); the text still has to be pasted, because Telegram has no
- *   pre-fill parameter for a user chat.
+ * - Telegram: documented username/phone links can prefill text; numeric-only
+ *   peers open the specific chat in Telegram Web (sign-in may be required).
  * - VK: `https://vk.com/im?sel=<peer>` opens the dialog with a user.
  */
-export const prefillLinkFor = ({ source, contact, chat, text }) => {
+export const prefillLinkFor = ({
+  source,
+  contact,
+  chat,
+  text,
+  username,
+  phone,
+}) => {
   const id = String(contact ?? '');
   const peer = String(chat ?? id);
   if (source === 'email' && /^[^\s@]+@[^\s@]+$/.test(id)) {
@@ -319,7 +329,10 @@ export const prefillLinkFor = ({ source, contact, chat, text }) => {
   }
   const tg = source === 'telegram' ? id.match(/^(?:user)?(\d+)$/) : null;
   if (tg) {
-    return { url: `tg://user?id=${tg[1]}`, prefillsText: false };
+    const url = telegramChatUrl({ source, chat: tg[1], username, phone, text });
+    return url
+      ? { url, prefillsText: Boolean(text) && !isTelegramWebUrl(url) }
+      : null;
   }
   return null;
 };

package/js/src/server/local-certificate-check.js

@@ -0,0 +1,82 @@
+// Verify our ECDSA certificate using portable crypto primitives. Deno exposes
+// X509Certificate but omits verify(), checkPrivateKey() and subjectAltName.
+import crypto from 'node:crypto';
+
+const der = (data, start = 0) => {
+  const tag = data[start];
+  let length = data[start + 1];
+  let offset = start + 2;
+  if (length & 0x80) {
+    const count = length & 0x7f;
+    if (!count || count > 4) {
+      throw new Error('invalid DER length');
+    }
+    length = 0;
+    for (let n = 0; n < count; n++) {
+      length = length * 256 + data[offset++];
+    }
+  }
+  const end = offset + length;
+  if (!Number.isInteger(end) || end > data.length) {
+    throw new Error('truncated DER');
+  }
+  return {
+    tag,
+    end,
+    raw: data.subarray(start, end),
+    body: data.subarray(offset, end),
+  };
+};
+const children = (data) => {
+  const parts = [];
+  for (let offset = 0; offset < data.length;) {
+    const part = der(data, offset);
+    parts.push(part);
+    offset = part.end;
+  }
+  return parts;
+};
+const SAN_OID = Buffer.from('0603551d11', 'hex');
+const ECDSA_SHA256 = Buffer.from('300a06082a8648ce3d040302', 'hex');
+
+export const matchesLocalCertificate = (cert, key, { now, renewMs, san }) => {
+  try {
+    const x509 = new crypto.X509Certificate(cert);
+    if (
+      x509.ca ||
+      Date.parse(x509.validFrom) > now ||
+      Date.parse(x509.validTo) - now <= renewMs
+    ) {
+      return false;
+    }
+    const encoded = String(cert).replace(/-----[^-]+-----|\s/g, '');
+    const root = der(Buffer.from(encoded, 'base64'));
+    const [tbs, algorithm, signature] = children(root.body);
+    if (!algorithm.raw.equals(ECDSA_SHA256) || signature.body[0] !== 0) {
+      return false;
+    }
+    const fields = children(tbs.body);
+    const extensions = children(
+      children(fields.find((field) => field.tag === 0xa3).body)[0].body
+    );
+    const names = extensions.filter((ext) =>
+      children(ext.body)[0].raw.equals(SAN_OID)
+    );
+    if (names.length !== 1 || !names[0].raw.equals(san)) {
+      return false;
+    }
+    const publicKey = crypto.createPublicKey(crypto.createPrivateKey(key));
+    const exportKey = (value) => value.export({ type: 'spki', format: 'der' });
+    return (
+      exportKey(publicKey).equals(exportKey(x509.publicKey)) &&
+      crypto.verify(
+        'sha256',
+        tbs.raw,
+        x509.publicKey,
+        signature.body.subarray(1)
+      )
+    );
+  } catch {
+    return false;
+  }
+};

package/js/src/server/local-tls.js

@@ -17,10 +17,11 @@
  */
 
 import crypto from 'node:crypto';
+import { matchesLocalCertificate } from './local-certificate-check.js';
 import { promises as fs } from 'node:fs';
 import net from 'node:net';
 import path from 'node:path';
-import tls from 'node:tls';
+import http2 from 'node:http2';
 import { DIR_MODE, tighten, writeFileDurable } from '../storage/durable.js';
 import {
   certificateFingerprint,
@@ -155,25 +156,19 @@ export const makeLocalCertificate = ({
   };
 };
 
-const usable = (cert, key, now) => {
-  try {
-    const x509 = new crypto.X509Certificate(cert);
-    return (
-      !x509.ca &&
-      x509.verify(x509.publicKey) &&
-      x509.checkPrivateKey(crypto.createPrivateKey(key)) &&
-      Date.parse(x509.validFrom) <= now &&
-      Date.parse(x509.validTo) - now > RENEW_DAYS * DAY_MS &&
-      x509.subjectAltName?.split(', ').length === 3 &&
-      x509.subjectAltName.includes('DNS:localhost') &&
-      x509.subjectAltName.includes('IP Address:127.0.0.1') &&
-      (x509.subjectAltName.includes('IP Address:0:0:0:0:0:0:0:1') ||
-        x509.subjectAltName.includes('IP Address:::1'))
-    );
-  } catch {
-    return false;
-  }
-};
+const usable = (cert, key, now) =>
+  matchesLocalCertificate(cert, key, {
+    now,
+    renewMs: RENEW_DAYS * DAY_MS,
+    san: extension(
+      '2.5.29.17',
+      seq(
+        tlv(0x82, Buffer.from('localhost')),
+        tlv(0x87, Buffer.from([127, 0, 0, 1])),
+        tlv(0x87, LOOPBACK_V6)
+      )
+    ),
+  });
 
 /** Where the certificate of a store lives. */
 export const localTlsPaths = (storeDir) => {
@@ -265,8 +260,19 @@ export const listenHttpAndHttps = (
   host = '127.0.0.1'
 ) =>
   new Promise((resolve, reject) => {
-    const secure = tls.createServer({ key, cert }, (socket) =>
-      httpServer.emit('connection', socket)
+    // Multiplex API calls, media and event streams over HTTPS. HTTP/1's six
+    // browser connections can otherwise all wait behind long media downloads.
+    const secure = http2.createSecureServer(
+      { key, cert, allowHTTP1: true },
+      (req, res) => {
+        // Keep the existing strict Host and Origin checks for HTTP/2 too.
+        req.headers.host ??= req.headers[':authority'];
+        httpServer.emit('request', req, res);
+      }
+    );
+    secure.requestTimeout = httpServer.requestTimeout;
+    secure.on('upgrade', (req, socket, head) =>
+      httpServer.emit('upgrade', req, socket, head)
     );
     // A browser that does not trust the certificate yet hangs up.
     secure.on('tlsClientError', () => {});

package/js/src/server/routes-events.js

@@ -69,7 +69,7 @@ export const handleEventRoutes = (store, req, res, p, ctx) => {
   res.writeHead(200, {
     'content-type': 'text/event-stream; charset=utf-8',
     'cache-control': 'no-cache, no-transform',
-    connection: 'keep-alive',
+    ...(req.httpVersionMajor === 2 ? {} : { connection: 'keep-alive' }),
     'x-accel-buffering': 'no',
   });
   // Reconnect quickly after the server restarts.

package/js/src/sources/telegram-chat-info.js

@@ -377,6 +377,11 @@ const extrasOf = (user, full) => ({
 const botRevenueOf = (user, full) =>
   user.bot && full.canViewRevenue ? { canViewStarsRevenue: true } : {};
 
+const contactReach = (user) => ({
+  username: user.username ?? null,
+  phone: user.phone ?? null,
+});
+
 const fetchUser = async (client, Api, helpers, inputPeer, peers, chat) => {
   const storedPeer = inputPeer ?? (await peers.input(chat));
   const id = inputUserOf(Api, helpers, storedPeer, chat);
@@ -389,7 +394,7 @@ const fetchUser = async (client, Api, helpers, inputPeer, peers, chat) => {
     title: nameOf(user),
     members: 1,
     online,
-    username: user.username ?? null,
+    ...contactReach(user),
     about: full.about ?? null,
     photo: hasPhoto(user.photo),
     pinned: full.pinnedMsgId ?? null,

package/js/src/sources/telegram-chat-url.js

@@ -0,0 +1,46 @@
+// Normal Telegram clients ignore tg://user?id (a Bot API abstraction).
+// Use documented username/phone/message links; numeric-only peers use Web A's
+// signed-in chat route instead of launching a native app without a destination.
+// References: core.telegram.org/api/links; Ajaxy/telegram-tt src/util/routing.ts.
+const resolvedLink = (handle, number, native) =>
+  /^[a-zA-Z][a-zA-Z0-9_]{3,31}$/.test(handle)
+    ? native
+      ? `tg://resolve?domain=${handle}`
+      : `https://t.me/${handle}`
+    : /^[1-9]\d{6,14}$/.test(number)
+      ? native
+        ? `tg://resolve?phone=${number}`
+        : `https://t.me/+${number}`
+      : null;
+
+export const telegramChatUrl = ({
+  source,
+  chat,
+  username,
+  phone,
+  lastId,
+  text,
+  native = false,
+} = {}) => {
+  if (source !== 'telegram' || !/^-?[1-9]\d*$/.test(String(chat))) {
+    return null;
+  }
+  const handle = String(username ?? '').replace(/^@/, '');
+  const number = String(phone ?? '').replace(/[\s()+-]/g, '');
+  const resolved = resolvedLink(handle, number, native);
+  if (resolved) {
+    return text
+      ? `${resolved}${native ? '&' : '?'}text=${encodeURIComponent(text)}`
+      : resolved;
+  }
+  const id = String(chat);
+  if (/^-100\d+$/.test(id) && /^[1-9]\d*$/.test(String(lastId))) {
+    return native
+      ? `tg://privatepost?channel=${id.slice(4)}&post=${lastId}`
+      : `https://t.me/c/${id.slice(4)}/${lastId}`;
+  }
+  return `https://web.telegram.org/a/#${id}`;
+};
+
+export const isTelegramWebUrl = (url) =>
+  String(url ?? '').startsWith('https://web.telegram.org/a/#');

package/js/src/storage/doublets-mirror.js

@@ -42,6 +42,10 @@ export const snapshotInWorker = (from, to) =>
     let result = null;
     worker.once('message', (message) => {
       result = message;
+      // The message follows the durable rename. Deno's worker compatibility
+      // layer can keep its port alive without emitting an exit event.
+      resolve(message);
+      Promise.resolve(worker.terminate()).catch(() => {});
     });
     worker.once('error', reject);
     worker.once('exit', (code) => {
@@ -92,6 +96,7 @@ const createSnapshots = ({
   let lastAt = 0;
   let lastCost = 0;
   let failures = 0;
+  let closed = false;
   const once = async () => {
     const started = clock.now();
     try {
@@ -115,6 +120,9 @@ const createSnapshots = ({
   };
   let later = null;
   const now = () => {
+    if (closed) {
+      return Promise.resolve(null);
+    }
     clock.clearTimeout(timer);
     timer = null;
     if (queued) {
@@ -123,7 +131,7 @@ const createSnapshots = ({
     if (!inFlight) {
       inFlight = once().finally(() => {
         inFlight = null;
-        if (wanted && !queued) {
+        if (wanted && !queued && !closed) {
           wanted = false;
           later();
         }
@@ -139,7 +147,7 @@ const createSnapshots = ({
     return queued;
   };
   later = () => {
-    if (timer) {
+    if (closed || timer) {
       return;
     }
     if (inFlight || queued) {
@@ -157,7 +165,14 @@ const createSnapshots = ({
     }, wait);
     timer.unref?.();
   };
-  return { now, later };
+  const close = async () => {
+    closed = true;
+    wanted = false;
+    clock.clearTimeout(timer);
+    timer = null;
+    await (queued ?? inFlight);
+  };
+  return { now, later, close };
 };
 
 /**
@@ -230,6 +245,7 @@ export const createDoubletsMirror = async (
     },
     /** Write the snapshot now (after the log) and wait for it. */
     flush: () => snapshots.now(),
+    close: () => snapshots.close(),
     /** A snapshot older than the log is written again, in the background. */
     async refresh() {
       const behind = await stale();

package/js/src/storage/dual-store.js

@@ -245,7 +245,17 @@ export const openDualStore = async (
       // What a backup streams, and the flush of just the log (R-Z16).
       logFile: text.filePath,
       flushLog: () => text.flush(),
-      close: lock.release,
+      async close() {
+        try {
+          await binary.close();
+        } finally {
+          try {
+            await text.flush();
+          } finally {
+            lock.release();
+          }
+        }
+      },
     };
   } catch (error) {
     lock.release();

package/js/src/web/app-navigation.js

@@ -0,0 +1,61 @@
+import { useEffect, useLayoutEffect, useSyncExternalStore } from 'react';
+import { appNavigation } from './app-route.js';
+
+// Wait for async section content to be tall enough before restoring its scroll.
+// User input cancels restoration so it cannot pull the page away afterwards.
+const restoreScroll = (scroll, done) => {
+  const [x, y] = scroll ?? [0, 0];
+  let frame;
+  let stopped = false;
+  const end = () => {
+    stopped = true;
+    globalThis.cancelAnimationFrame(frame);
+    done();
+  };
+  const until = Date.now() + 5000;
+  const apply = () => {
+    const height = globalThis.document.scrollingElement?.scrollHeight ?? 0;
+    if (height - globalThis.innerHeight >= y || Date.now() >= until) {
+      globalThis.scrollTo?.(x, y);
+      end();
+    } else if (!stopped) {
+      frame = globalThis.requestAnimationFrame(apply);
+    }
+  };
+  const events = ['wheel', 'pointerdown', 'touchstart', 'keydown'];
+  events.forEach((event) =>
+    globalThis.addEventListener(event, end, { passive: true, once: true })
+  );
+  apply();
+  return () => {
+    end();
+    events.forEach((event) => globalThis.removeEventListener(event, end));
+  };
+};
+
+export const useAppNavigation = () => {
+  const navigation = appNavigation();
+  const route = useSyncExternalStore(
+    navigation.subscribe,
+    navigation.snapshot,
+    navigation.snapshot
+  );
+  useLayoutEffect(() => navigation.start(), [navigation]);
+  useEffect(() => {
+    const onNavigate = (event) => navigation.go(event.detail ?? {});
+    globalThis.addEventListener('meta-sovereign:navigate', onNavigate);
+    return () =>
+      globalThis.removeEventListener('meta-sovereign:navigate', onNavigate);
+  }, [navigation]);
+  useLayoutEffect(() => {
+    const previous = globalThis.history.scrollRestoration;
+    globalThis.history.scrollRestoration = 'manual';
+    navigation.restoring(true);
+    const stop = restoreScroll(route.scroll, () => navigation.restoring(false));
+    return () => {
+      stop();
+      globalThis.history.scrollRestoration = previous;
+    };
+  }, [route, navigation]);
+  return [route, navigation.go];
+};

package/js/src/web/app-route.js

@@ -0,0 +1,205 @@
+// Section routes coexist with the original chat and provider deep links.
+import { navItems } from './nav-items.js';
+
+export const APP_ROUTE_KEY = 'metaSovereignNavigation';
+const VIEWS = new Set(navItems.map(([view]) => view));
+
+export const splitChatAddress = (key) => {
+  const match = /^([a-z0-9_-]+):(.+)$/i.exec(String(key ?? ''));
+  return match ? { source: match[1], chat: match[2] } : null;
+};
+
+export const parseAppRoute = (hash = '') => {
+  const anchor = String(hash);
+  if (/^#conn-[a-z0-9-]+(?:\/manual)?$/i.test(anchor)) {
+    return { view: 'connections', anchor };
+  }
+  if (anchor.startsWith('#chat=')) {
+    try {
+      const chat = splitChatAddress(decodeURIComponent(anchor.slice(6)));
+      return chat ? { view: 'chat', anchor, chat } : null;
+    } catch {
+      return null;
+    }
+  }
+  const match = /^#\/?([a-z][a-z0-9-]*)(?:\?(.*))?$/.exec(anchor);
+  if (!match || !VIEWS.has(match[1])) {
+    return null;
+  }
+  const view = match[1];
+  const chat = splitChatAddress(new URLSearchParams(match[2]).get('chat'));
+  return { view, anchor, ...(chat ? { chat } : {}) };
+};
+
+export const sectionHash = (view) => `#/${view}`;
+export const operatorHash = (key) =>
+  key ? `#/operator?chat=${encodeURIComponent(key)}` : sectionHash('operator');
+export const chatHash = ({ source, chat }) =>
+  `#chat=${source}:${encodeURIComponent(chat)}`;
+
+const remembered = (env) => {
+  try {
+    const value = JSON.parse(
+      env.sessionStorage?.getItem(APP_ROUTE_KEY) ?? 'null'
+    );
+    return value && typeof value === 'object' ? value : {};
+  } catch {
+    return {};
+  }
+};
+
+const targetFor = (view, anchor, hashes) => {
+  const wanted = anchor === undefined ? hashes[view] : anchor;
+  const next = parseAppRoute(wanted);
+  return next?.view === view ? next : { view, anchor: sectionHash(view) };
+};
+
+const visit = (target, before, replace) => ({
+  ...target,
+  previous: replace ? before.previous : before.anchor,
+  scroll: replace && before.view === target.view ? before.scroll : [0, 0],
+});
+
+/** Browser history is the authority; session storage only remembers sections. */
+export const createAppNavigation = (env = globalThis) => {
+  const memory = remembered(env);
+  const hashes = { ...memory.hashes };
+  const initial = parseAppRoute(env.location?.hash) ??
+    parseAppRoute(hashes[memory.view]) ?? { view: 'chat', anchor: '#/chat' };
+  let route = {
+    ...initial,
+    previous: env.history?.state?.[APP_ROUTE_KEY]?.previous,
+    scroll: env.history?.state?.[APP_ROUTE_KEY]?.scroll ?? [0, 0],
+  };
+  let url = env.location?.hash;
+  let restoring = false;
+  const listeners = new Set();
+  const notify = () => listeners.forEach((listener) => listener());
+  const remember = () => {
+    hashes[route.view] = route.anchor;
+    try {
+      env.sessionStorage?.setItem(
+        APP_ROUTE_KEY,
+        JSON.stringify({ view: route.view, hashes })
+      );
+    } catch {
+      // The URL and history still work with browser storage disabled.
+    }
+  };
+  const write = (next, replace) => {
+    const state = {
+      ...env.history?.state,
+      [APP_ROUTE_KEY]: { ...next, scroll: next.scroll },
+    };
+    env.history?.[replace ? 'replaceState' : 'pushState']?.(
+      state,
+      '',
+      `${env.location?.pathname ?? ''}${env.location?.search ?? ''}${next.anchor}`
+    );
+    url = env.location?.hash;
+  };
+  const saveScroll = () => {
+    if (restoring) {
+      return;
+    }
+    env.history?.replaceState?.(
+      {
+        ...env.history.state,
+        [APP_ROUTE_KEY]: {
+          ...route,
+          scroll: [env.scrollX ?? 0, env.scrollY ?? 0],
+        },
+      },
+      '',
+      env.location?.href
+    );
+  };
+  const accept = () => {
+    if (env.location?.hash === url) {
+      return;
+    }
+    const next = parseAppRoute(env.location?.hash);
+    url = env.location?.hash;
+    if (!next) {
+      return; // In-page anchors such as #root do not switch sections.
+    }
+    const kept = env.history?.state?.[APP_ROUTE_KEY];
+    route = {
+      ...next,
+      previous: kept?.anchor === next.anchor ? kept.previous : route.anchor,
+      scroll: kept?.anchor === next.anchor ? kept.scroll : [0, 0],
+    };
+    write(route, true);
+    remember();
+    notify();
+  };
+  const go = ({ view, anchor } = {}, { replace = false } = {}) => {
+    if (!VIEWS.has(view)) {
+      return;
+    }
+    if (anchor === undefined && route.view === view) {
+      return;
+    }
+    const target = targetFor(view, anchor, hashes);
+    if (
+      route.anchor === target.anchor &&
+      env.location?.hash === target.anchor
+    ) {
+      return;
+    }
+    saveScroll();
+    const oldURL = env.location?.href;
+    route = visit(target, route, replace);
+    write(route, replace);
+    remember();
+    notify();
+    // pushState does not emit hashchange; existing chat/provider listeners need it.
+    if (env.HashChangeEvent) {
+      env.dispatchEvent(
+        new env.HashChangeEvent('hashchange', {
+          oldURL,
+          newURL: env.location?.href,
+        })
+      );
+    }
+  };
+  return {
+    snapshot: () => route,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    go,
+    restoring: (active) => {
+      restoring = active;
+    },
+    back: (detail) => {
+      const target = targetFor(detail.view, detail.anchor, hashes);
+      if (route.previous === target.anchor) {
+        env.history.back();
+      } else {
+        go(detail, { replace: true });
+      }
+    },
+    start: () => {
+      accept();
+      write(route, true);
+      remember();
+      env.addEventListener?.('popstate', accept);
+      env.addEventListener?.('hashchange', accept);
+      env.addEventListener?.('scroll', saveScroll, { passive: true });
+      return () => {
+        env.removeEventListener?.('popstate', accept);
+        env.removeEventListener?.('hashchange', accept);
+        env.removeEventListener?.('scroll', saveScroll);
+      };
+    },
+  };
+};
+
+let browserNavigation;
+export const appNavigation = () =>
+  (browserNavigation ??= createAppNavigation());
+export const navigateApp = (detail, options) =>
+  appNavigation().go(detail, options);
+export const backInApp = (detail) => appNavigation().back(detail);