@rapidmx/web-client 0.20.0 → 0.22.0

package/apps/shared/search/localIndexKey.ts

@@ -14,7 +14,7 @@
  * already uniformly random) and avoids needing to persist, transmit, or ever lose a random salt just to
  * re-derive the same key on the next unlock.
  */
-import { hkdfDerive } from "@rapidmx/react-shared/crypto/masterKey.js";
+import { hkdfDerive } from "../../../lib/crypto/masterKey.js";
 
 /** Fixed, non-secret HKDF salt - see this module's own doc comment for why a fixed salt is fine here. */
 const FIXED_SALT = new TextEncoder().encode("rapidmx-local-search-index-v1");

package/apps/shared/search/localIndexRpcClient.ts

@@ -25,8 +25,20 @@
  * every pending request and drops the module-level `worker` reference so the next `call()` spawns a
  * replacement. `searchTier2.ts` additionally races its own calls against a timeout, since a Worker that's
  * merely stuck (not crashed) posts no `error` event at all.
+ *
+ * **Swappable transport**: everything above is specific to this one implementation - the Worker/OPFS-backed
+ * default. Every function this module exports below (`initLocalIndex`, `searchLocal`, `destroyLocalIndex`, ...)
+ * is a thin delegator to whichever `LocalIndexTransport` (`localIndexTransport.ts`) is "current," which defaults
+ * to `workerLocalIndexTransport` - this file's own implementation, wrapped - and can be swapped once, at startup,
+ * via `setLocalIndexTransport()`. A host app with a different storage backend (no Worker, no OPFS, no WASM at
+ * all - `tauri-client`'s native SQLCipher/`rusqlite` index) installs its own transport there; every call site
+ * that already goes through this file's exports (`searchTier2.ts`, `LocalIndexLifecycle.tsx`,
+ * `localIndexBuilder.ts`, and the rest) then runs against that backend instead, unmodified. The three
+ * module-level constants below (`SIGN_OUT_CHANNEL`, `PENDING_DELETIONS_KEY`, `DESTROY_ALL_TIMEOUT_MS`) remain
+ * plain exports, not part of the swappable interface - they name this one transport's own cross-tab/localStorage
+ * mechanics, which a different transport has no reason to share.
  */
-import type { ParsedSearchQuery } from "@rapidmx/react-shared/search/queryGrammar.js";
+import type { ParsedSearchQuery } from "../../../lib/search/queryGrammar.js";
 import type {
     Coverage,
     DestroyParams,
@@ -48,6 +60,7 @@ import type {
 } from "./localIndexWorker.js";
 import type { LocalIndexEntity } from "./localIndexSchema.js";
 import { removeLocalIndexDirectories, removeLocalIndexDirectory } from "./localIndexStorage.js";
+import type { LocalIndexTransport, PruneLocalEntitiesOptions, SetLocalIndexBuildingCompletion } from "./localIndexTransport.js";
 
 let worker: Worker | undefined;
 let nextRequestId = 1;
@@ -61,7 +74,7 @@ const initializedMailboxes = new Set<string>();
 let generationCounter = 0;
 
 /** A fresh generation - see this module's doc comment. */
-export function nextLocalIndexGeneration(): number {
+function nextLocalIndexGenerationImpl(): number {
     generationCounter += 1;
     return generationCounter;
 }
@@ -141,7 +154,7 @@ function listenForSignOut(): void {
 async function closeEverythingInThisTab(): Promise<void> {
     signedOut = true;
     initializedMailboxes.clear();
-    await call("destroyAll", { generation: nextLocalIndexGeneration() } satisfies GenerationParams).catch(() => undefined);
+    await call("destroyAll", { generation: nextLocalIndexGenerationImpl() } satisfies GenerationParams).catch(() => undefined);
 }
 
 function call<T>(method: LocalIndexRequest["method"], params?: unknown): Promise<T> {
@@ -194,7 +207,7 @@ let pendingRetry: Promise<void> | undefined;
 
 /** Retries every deletion an earlier page load couldn't finish. Runs once per page load (memoized), before
  * this tab's first `init` - so it never races an index this tab itself opens. Never rejects. */
-export function retryPendingLocalIndexDeletions(): Promise<void> {
+function retryPendingLocalIndexDeletionsImpl(): Promise<void> {
     pendingRetry ??= (async () => {
         const uids = readPendingDeletions();
         if (uids.length === 0) {
@@ -214,8 +227,8 @@ export function retryPendingLocalIndexDeletions(): Promise<void> {
     return pendingRetry;
 }
 
-export async function initLocalIndex(params: InitParams): Promise<void> {
-    await retryPendingLocalIndexDeletions();
+async function initLocalIndexImpl(params: InitParams): Promise<void> {
+    await retryPendingLocalIndexDeletionsImpl();
     if (signedOut) {
         throw new Error("Signed out - the local search index is unavailable in this tab.");
     }
@@ -223,13 +236,13 @@ export async function initLocalIndex(params: InitParams): Promise<void> {
     initializedMailboxes.add(params.mailboxUid);
 }
 
-export function indexLocalEntities(mailboxUid: string, entities: LocalIndexEntity[], generation?: number): Promise<IndexEntitiesResult> {
+function indexLocalEntitiesImpl(mailboxUid: string, entities: LocalIndexEntity[], generation?: number): Promise<IndexEntitiesResult> {
     return call("indexEntities", { mailboxUid, entities, generation } satisfies IndexEntitiesParams);
 }
 
 /** Drops one message from this session's local index (a delete). A no-op for a mailbox not indexed in
  * this tab - a later build pass prunes it instead. Never rejects: best-effort housekeeping. */
-export async function removeLocalEntity(mailboxUid: string, entityUid: string): Promise<void> {
+async function removeLocalEntityImpl(mailboxUid: string, entityUid: string): Promise<void> {
     if (!initializedMailboxes.has(mailboxUid)) {
         return;
     }
@@ -237,44 +250,35 @@ export async function removeLocalEntity(mailboxUid: string, entityUid: string):
 }
 
 /** Re-points one indexed message at its new folder (archive, cancel-scheduled-send) so `folder:`-scoped
- * local searches stay correct. Same no-op/never-rejects rules as `removeLocalEntity()`. */
-export async function moveLocalEntity(mailboxUid: string, entityUid: string, folderUid: string): Promise<void> {
+ * local searches stay correct. Same no-op/never-rejects rules as `removeLocalEntityImpl()`. */
+async function moveLocalEntityImpl(mailboxUid: string, entityUid: string, folderUid: string): Promise<void> {
     if (!initializedMailboxes.has(mailboxUid)) {
         return;
     }
     await call("moveEntity", { mailboxUid, entityUid, folderUid } satisfies MoveEntityParams).catch(() => undefined);
 }
 
-export function getIndexedVersions(mailboxUid: string, entityUids: string[]): Promise<Record<string, string>> {
+function getIndexedVersionsImpl(mailboxUid: string, entityUids: string[]): Promise<Record<string, string>> {
     return call("indexedVersions", { mailboxUid, entityUids } satisfies IndexedVersionsParams);
 }
 
-export function pruneLocalEntities(
-    mailboxUid: string,
-    keepEntityUids: string[],
-    since: string | undefined,
-    options: { folderUids?: string[]; generation?: number } = {},
-): Promise<number> {
+function pruneLocalEntitiesImpl(mailboxUid: string, keepEntityUids: string[], since: string | undefined, options: PruneLocalEntitiesOptions): Promise<number> {
     return call("pruneEntities", { mailboxUid, keepEntityUids, since, ...options } satisfies PruneEntitiesParams);
 }
 
-export function searchLocal(mailboxUid: string, parsed: ParsedSearchQuery, limit: number, offset = 0): Promise<LocalSearchPage> {
+function searchLocalImpl(mailboxUid: string, parsed: ParsedSearchQuery, limit: number, offset: number): Promise<LocalSearchPage> {
     return call("search", { mailboxUid, parsed, limit, offset } satisfies SearchParams);
 }
 
-export function getLocalCoverage(mailboxUid: string): Promise<Coverage> {
+function getLocalCoverageImpl(mailboxUid: string): Promise<Coverage> {
     return call("coverage", mailboxUid);
 }
 
-export function setLocalIndexWindow(mailboxUid: string, timeFloorMonths: number, byteBudgetBytes: number, generation?: number): Promise<WindowState> {
+function setLocalIndexWindowImpl(mailboxUid: string, timeFloorMonths: number, byteBudgetBytes: number, generation?: number): Promise<WindowState> {
     return call("setWindow", { mailboxUid, timeFloorMonths, byteBudgetBytes, generation } satisfies SetWindowParams);
 }
 
-export function setLocalIndexBuilding(
-    mailboxUid: string,
-    building: boolean,
-    completion: { complete: boolean; coveredFrom?: string; coveredUntil?: string; generation?: number } = { complete: false },
-): Promise<void> {
+function setLocalIndexBuildingImpl(mailboxUid: string, building: boolean, completion: SetLocalIndexBuildingCompletion): Promise<void> {
     return call("setBuilding", { mailboxUid, building, ...completion } satisfies SetBuildingParams);
 }
 
@@ -283,10 +287,10 @@ export function setLocalIndexBuilding(
  * lifecycle hooks where a failure mustn't block key destruction) but resolves `false` - and logs why -
  * when the index could not be removed, e.g. because another tab still has it open; the deletion is then
  * retried on the next page load. */
-export async function destroyLocalIndex(mailboxUid: string): Promise<boolean> {
+async function destroyLocalIndexImpl(mailboxUid: string): Promise<boolean> {
     updatePendingDeletions((current) => current.add(mailboxUid));
     try {
-        await call("destroy", { mailboxUid, generation: nextLocalIndexGeneration() } satisfies DestroyParams);
+        await call("destroy", { mailboxUid, generation: nextLocalIndexGenerationImpl() } satisfies DestroyParams);
         updatePendingDeletions((current) => current.delete(mailboxUid));
         return true;
     } catch (err) {
@@ -309,7 +313,7 @@ export const DESTROY_ALL_TIMEOUT_MS = 3_000;
  * would be waste), then removes the directories. Anything left behind is retried on the next load. Resolves
  * `true` when everything was removed within `timeoutMs`; never rejects.
  */
-export async function destroyAllLocalIndexes(timeoutMs = DESTROY_ALL_TIMEOUT_MS): Promise<boolean> {
+async function destroyAllLocalIndexesImpl(timeoutMs: number): Promise<boolean> {
     signedOut = true;
     writePendingDeletions([ALL_INDEXES]);
     try {
@@ -320,7 +324,7 @@ export async function destroyAllLocalIndexes(timeoutMs = DESTROY_ALL_TIMEOUT_MS)
     const work = (async () => {
         let ok = true;
         if (worker) {
-            const { failed } = await call<{ failed: string[] }>("destroyAll", { generation: nextLocalIndexGeneration() } satisfies GenerationParams).catch(() => ({
+            const { failed } = await call<{ failed: string[] }>("destroyAll", { generation: nextLocalIndexGenerationImpl() } satisfies GenerationParams).catch(() => ({
                 failed: ["(worker)"],
             }));
             ok = failed.length === 0;
@@ -344,6 +348,122 @@ export async function destroyAllLocalIndexes(timeoutMs = DESTROY_ALL_TIMEOUT_MS)
 
 /** Removes local indexes for mailboxes outside `accessibleMailboxUids` - e.g. left behind by a different
  * user who signed in on this device without signing out. Never rejects. */
-export async function pruneInaccessibleLocalIndexes(accessibleMailboxUids: Iterable<string>): Promise<void> {
+async function pruneInaccessibleLocalIndexesImpl(accessibleMailboxUids: Iterable<string>): Promise<void> {
     await removeLocalIndexDirectories(new Set(accessibleMailboxUids)).catch(() => undefined);
 }
+
+/**
+ * This file's own Worker/OPFS-backed implementation, wrapping the functions above - see this module's own doc
+ * comment ("Swappable transport"). The default `LocalIndexTransport` (`localIndexTransport.ts`); every export
+ * below delegates to whichever transport `setLocalIndexTransport()` has made current, which starts out as this
+ * one.
+ */
+export const workerLocalIndexTransport: LocalIndexTransport = {
+    nextGeneration: nextLocalIndexGenerationImpl,
+    init: initLocalIndexImpl,
+    indexEntities: indexLocalEntitiesImpl,
+    removeEntity: removeLocalEntityImpl,
+    moveEntity: moveLocalEntityImpl,
+    indexedVersions: getIndexedVersionsImpl,
+    pruneEntities: pruneLocalEntitiesImpl,
+    search: searchLocalImpl,
+    coverage: getLocalCoverageImpl,
+    setWindow: setLocalIndexWindowImpl,
+    setBuilding: setLocalIndexBuildingImpl,
+    destroy: destroyLocalIndexImpl,
+    destroyAll: destroyAllLocalIndexesImpl,
+    pruneInaccessible: pruneInaccessibleLocalIndexesImpl,
+    retryPendingDeletions: retryPendingLocalIndexDeletionsImpl,
+};
+
+let currentTransport: LocalIndexTransport = workerLocalIndexTransport;
+
+/**
+ * Swaps the `LocalIndexTransport` every export below delegates to - see this module's own doc comment
+ * ("Swappable transport"). Defaults to `workerLocalIndexTransport`; a host app with a different storage backend
+ * (e.g. `tauri-client`'s native SQLCipher/`rusqlite` index) calls this once, at startup, before any of this
+ * module's other exports are used, so every call site already wired through them runs against that backend
+ * instead - unmodified.
+ */
+export function setLocalIndexTransport(transport: LocalIndexTransport): void {
+    currentTransport = transport;
+}
+
+/** A fresh generation - see this module's doc comment. */
+export function nextLocalIndexGeneration(): number {
+    return currentTransport.nextGeneration();
+}
+
+export function initLocalIndex(params: InitParams): Promise<void> {
+    return currentTransport.init(params);
+}
+
+export function indexLocalEntities(mailboxUid: string, entities: LocalIndexEntity[], generation?: number): Promise<IndexEntitiesResult> {
+    return currentTransport.indexEntities(mailboxUid, entities, generation);
+}
+
+/** Drops one message from this session's local index (a delete). A no-op for a mailbox not indexed in
+ * this tab - a later build pass prunes it instead. Never rejects: best-effort housekeeping. */
+export function removeLocalEntity(mailboxUid: string, entityUid: string): Promise<void> {
+    return currentTransport.removeEntity(mailboxUid, entityUid);
+}
+
+/** Re-points one indexed message at its new folder (archive, cancel-scheduled-send) so `folder:`-scoped
+ * local searches stay correct. Same no-op/never-rejects rules as `removeLocalEntity()`. */
+export function moveLocalEntity(mailboxUid: string, entityUid: string, folderUid: string): Promise<void> {
+    return currentTransport.moveEntity(mailboxUid, entityUid, folderUid);
+}
+
+export function getIndexedVersions(mailboxUid: string, entityUids: string[]): Promise<Record<string, string>> {
+    return currentTransport.indexedVersions(mailboxUid, entityUids);
+}
+
+export function pruneLocalEntities(
+    mailboxUid: string,
+    keepEntityUids: string[],
+    since: string | undefined,
+    options: PruneLocalEntitiesOptions = {},
+): Promise<number> {
+    return currentTransport.pruneEntities(mailboxUid, keepEntityUids, since, options);
+}
+
+export function searchLocal(mailboxUid: string, parsed: ParsedSearchQuery, limit: number, offset = 0): Promise<LocalSearchPage> {
+    return currentTransport.search(mailboxUid, parsed, limit, offset);
+}
+
+export function getLocalCoverage(mailboxUid: string): Promise<Coverage> {
+    return currentTransport.coverage(mailboxUid);
+}
+
+export function setLocalIndexWindow(mailboxUid: string, timeFloorMonths: number, byteBudgetBytes: number, generation?: number): Promise<WindowState> {
+    return currentTransport.setWindow(mailboxUid, timeFloorMonths, byteBudgetBytes, generation);
+}
+
+export function setLocalIndexBuilding(mailboxUid: string, building: boolean, completion: SetLocalIndexBuildingCompletion = { complete: false }): Promise<void> {
+    return currentTransport.setBuilding(mailboxUid, building, completion);
+}
+
+/** Destroys one mailbox's local index - spec §11 "MUST be destroyed on the same events that destroy private
+ * keys." Never rejects (it's called from lifecycle hooks where a failure mustn't block key destruction) but
+ * resolves `false` when the index could not be removed - see the current transport's own doc comment for what
+ * that means for it (the Worker transport also logs why, and retries on the next page load). */
+export function destroyLocalIndex(mailboxUid: string): Promise<boolean> {
+    return currentTransport.destroy(mailboxUid);
+}
+
+/** Destroys **every** local index this transport knows of - not just the mailboxes this session opened - e.g.
+ * on sign-out. Never rejects. Resolves `true` only if everything was removed within `timeoutMs`. */
+export function destroyAllLocalIndexes(timeoutMs = DESTROY_ALL_TIMEOUT_MS): Promise<boolean> {
+    return currentTransport.destroyAll(timeoutMs);
+}
+
+/** Removes local indexes for mailboxes outside `accessibleMailboxUids` - e.g. left behind by a different
+ * user who signed in on this device without signing out. Never rejects. */
+export function pruneInaccessibleLocalIndexes(accessibleMailboxUids: Iterable<string>): Promise<void> {
+    return currentTransport.pruneInaccessible(accessibleMailboxUids);
+}
+
+/** Retries every deletion an earlier session couldn't finish. Never rejects. */
+export function retryPendingLocalIndexDeletions(): Promise<void> {
+    return currentTransport.retryPendingDeletions();
+}

package/apps/shared/search/localIndexTransport.ts

@@ -0,0 +1,84 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * The Tier 2 local index's transport contract - every operation `localIndexRpcClient.ts`'s public functions perform
+ * against whatever actually stores and queries the index. Type-only: this module declares the shape, it never runs
+ * anything itself.
+ *
+ * The browser/Electron path is backed by `workerLocalIndexTransport` (`localIndexRpcClient.ts`, exported from that
+ * same file) - a Promise/RPC wrapper around a Worker running `@journeyapps/wa-sqlite` over OPFS. That module's own
+ * doc comment covers the Worker/RPC mechanics this interface abstracts away (generations, cross-tab sign-out,
+ * retried deletions, Worker-crash recovery); none of that is part of this contract - it is that transport's own
+ * implementation detail, not something a second implementation needs to reproduce.
+ *
+ * A host app with no Worker/OPFS/WASM at all - `tauri-client`, backed instead by real SQLCipher-encrypted SQLite
+ * via a Rust `rusqlite` `invoke()` command - implements this same shape and installs it once at startup via
+ * `localIndexRpcClient.ts`'s `setLocalIndexTransport()`. Every call site already going through that file's exported
+ * functions (`searchTier2.ts`, `LocalIndexLifecycle.tsx`, `localIndexBuilder.ts`, and the rest) then runs against
+ * the native backend instead, unmodified - those exports are thin delegators to whichever transport is current.
+ *
+ * Method names mirror the Worker's own RPC method names (`localIndexWorker.ts`'s `LocalIndexRequest["method"]`),
+ * not `localIndexRpcClient.ts`'s public function names - a second implementation has no reason to repeat that
+ * file's "Local"-infixed naming (`indexLocalEntities`, `getLocalCoverage`, ...) for its own methods.
+ *
+ * Every method takes exactly the arguments its `localIndexRpcClient.ts` counterpart already resolves down to -
+ * where that file's own export has a default parameter (`offset = 0`, `options = {}`, `timeoutMs = DESTROY_ALL_TIMEOUT_MS`),
+ * this interface takes the resolved value as required, so an implementation never has to reproduce that default
+ * itself.
+ */
+import type { ParsedSearchQuery } from "../../../lib/search/queryGrammar.js";
+import type { Coverage, IndexEntitiesResult, InitParams, LocalSearchPage, WindowState } from "./localIndexWorker.js";
+import type { LocalIndexEntity } from "./localIndexSchema.js";
+
+/** `LocalIndexTransport.pruneEntities()`'s options - which folders' unseen rows may be pruned (see
+ * `localIndexBuilder.ts`'s own "reliable" folders), and this pass's generation tag. */
+export interface PruneLocalEntitiesOptions {
+    folderUids?: string[];
+    generation?: number;
+}
+
+/** `LocalIndexTransport.setBuilding()`'s completion summary - whether a build pass just finished, and how much of
+ * the mailbox it covered (`Coverage.complete`/`coveredFrom`/`coveredUntil`'s own source). */
+export interface SetLocalIndexBuildingCompletion {
+    complete: boolean;
+    coveredFrom?: string;
+    coveredUntil?: string;
+    generation?: number;
+}
+
+/** See this module's own doc comment. */
+export interface LocalIndexTransport {
+    /** A fresh, monotonic generation from this transport's own counter. */
+    nextGeneration(): number;
+    /** Opens (or reuses) this mailbox's index connection. */
+    init(params: InitParams): Promise<void>;
+    /** Indexes (inserts or updates) the given entities, applying byte-budget eviction as needed. */
+    indexEntities(mailboxUid: string, entities: LocalIndexEntity[], generation?: number): Promise<IndexEntitiesResult>;
+    /** Drops one indexed entity. */
+    removeEntity(mailboxUid: string, entityUid: string): Promise<void>;
+    /** Re-points one indexed entity at its new folder. */
+    moveEntity(mailboxUid: string, entityUid: string, folderUid: string): Promise<void>;
+    /** The indexed version marker (`Message.version` + folder) currently stored for each of the given entity uids. */
+    indexedVersions(mailboxUid: string, entityUids: string[]): Promise<Record<string, string>>;
+    /** Removes indexed rows outside `keepEntityUids` (and `since`/`options.folderUids`'s own scope). Returns how many rows were pruned. */
+    pruneEntities(mailboxUid: string, keepEntityUids: string[], since: string | undefined, options: PruneLocalEntitiesOptions): Promise<number>;
+    /** Runs a parsed query against the index, already scored and paginated. */
+    search(mailboxUid: string, parsed: ParsedSearchQuery, limit: number, offset: number): Promise<LocalSearchPage>;
+    /** How much of the mailbox the index currently covers. */
+    coverage(mailboxUid: string): Promise<Coverage>;
+    /** Sets this mailbox's window (time floor + byte budget), applying eviction immediately if it shrank. */
+    setWindow(mailboxUid: string, timeFloorMonths: number, byteBudgetBytes: number, generation?: number): Promise<WindowState>;
+    /** Flags whether a build pass is running, and - once it finishes - how much of the mailbox it covered. */
+    setBuilding(mailboxUid: string, building: boolean, completion: SetLocalIndexBuildingCompletion): Promise<void>;
+    /** Destroys one mailbox's index. Never rejects; resolves `false` (logging why) when it could not be removed. */
+    destroy(mailboxUid: string): Promise<boolean>;
+    /** Destroys every index this transport knows of, e.g. on sign-out. Never rejects; resolves `true` only if
+     * everything was removed within `timeoutMs`. */
+    destroyAll(timeoutMs: number): Promise<boolean>;
+    /** Removes indexes for mailboxes outside `accessibleMailboxUids`. Never rejects. */
+    pruneInaccessible(accessibleMailboxUids: Iterable<string>): Promise<void>;
+    /** Retries any deletion an earlier session couldn't finish. Never rejects. */
+    retryPendingDeletions(): Promise<void>;
+}

package/apps/shared/search/localIndexWorker.ts

@@ -31,7 +31,7 @@
  */
 import SQLiteESMFactory from "@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs";
 import * as SQLite from "@journeyapps/wa-sqlite";
-import type { ParsedSearchQuery } from "@rapidmx/react-shared/search/queryGrammar.js";
+import type { ParsedSearchQuery } from "../../../lib/search/queryGrammar.js";
 import { EncryptingVFS } from "./localIndexVFS.js";
 import { listLocalIndexMailboxUids, poolNameFor, removeLocalIndexDirectory } from "./localIndexStorage.js";
 import {

package/apps/shared/search/searchTier2.ts

@@ -17,9 +17,9 @@
  * alongside Tier 1/Tier 3 (`apps/www/index.tsx`'s own search orchestration) must never see the *whole
  * search* fail just because this one, most novel piece had a bad moment.
  */
-import type { UnlockedKeys } from "@rapidmx/react-shared/crypto/keySession.js";
-import type { ParsedSearchQuery } from "@rapidmx/react-shared/search/queryGrammar.js";
-import type { SearchResult } from "@rapidmx/react-shared/search/searchApi.js";
+import type { UnlockedKeys } from "../../../lib/crypto/keySession.js";
+import type { ParsedSearchQuery } from "../../../lib/search/queryGrammar.js";
+import type { SearchResult } from "../../../lib/search/searchApi.js";
 import { deriveLocalIndexKey } from "./localIndexKey.js";
 import { getLocalCoverage, initLocalIndex, searchLocal } from "./localIndexRpcClient.js";
 import type { Coverage } from "./localIndexWorker.js";

package/apps/shared/signing/enrollmentStorage.ts

@@ -1,33 +1,33 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright (C) 2026 Jean-Philippe Steinmetz
-// SPDX-License-Identifier: MPL-2.0
-///////////////////////////////////////////////////////////////////////////////
-
-/**
- * A started signing enrollment's id, per mailbox. Kept only so a reload - and the app frame's watcher, on any page - can ask the server
- * (`checkSignEnrollmentStatus()`) whether that enrollment is still pending: a rotation while it is pending would strand the enrollment's
- * already-submitted private key under a master key that no longer exists. The stored id is never trusted on its own - the server's answer
- * decides the state, and restapi's own `rekey()` refuses (409) a rotation during an enrollment this browser never saw (e.g. one started on
- * another device).
- */
-export const SIGN_ENROLLMENT_STORAGE_PREFIX = "rapidmx.signEnrollment.";
-
-export function readStoredSignEnrollment(mailboxUid: string): string | null {
-    try {
-        return localStorage.getItem(SIGN_ENROLLMENT_STORAGE_PREFIX + mailboxUid);
-    } catch {
-        return null;
-    }
-}
-
-export function storeSignEnrollment(mailboxUid: string, enrollmentId: string | null): void {
-    try {
-        if (enrollmentId) {
-            localStorage.setItem(SIGN_ENROLLMENT_STORAGE_PREFIX + mailboxUid, enrollmentId);
-        } else {
-            localStorage.removeItem(SIGN_ENROLLMENT_STORAGE_PREFIX + mailboxUid);
-        }
-    } catch {
-        // Storage blocked - restapi's own 409 on rekey still guards a rotation.
-    }
-}
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A started signing enrollment's id, per mailbox. Kept only so a reload - and the app frame's watcher, on any page - can ask the server
+ * (`checkSignEnrollmentStatus()`) whether that enrollment is still pending: a rotation while it is pending would strand the enrollment's
+ * already-submitted private key under a master key that no longer exists. The stored id is never trusted on its own - the server's answer
+ * decides the state, and restapi's own `rekey()` refuses (409) a rotation during an enrollment this browser never saw (e.g. one started on
+ * another device).
+ */
+export const SIGN_ENROLLMENT_STORAGE_PREFIX = "rapidmx.signEnrollment.";
+
+export function readStoredSignEnrollment(mailboxUid: string): string | null {
+    try {
+        return localStorage.getItem(SIGN_ENROLLMENT_STORAGE_PREFIX + mailboxUid);
+    } catch {
+        return null;
+    }
+}
+
+export function storeSignEnrollment(mailboxUid: string, enrollmentId: string | null): void {
+    try {
+        if (enrollmentId) {
+            localStorage.setItem(SIGN_ENROLLMENT_STORAGE_PREFIX + mailboxUid, enrollmentId);
+        } else {
+            localStorage.removeItem(SIGN_ENROLLMENT_STORAGE_PREFIX + mailboxUid);
+        }
+    } catch {
+        // Storage blocked - restapi's own 409 on rekey still guards a rotation.
+    }
+}