@rapidmx/web-client 0.21.0 → 0.23.0

package/dist/apps/shared/search/localIndexRpcClient.d.ts

@@ -21,17 +21,44 @@
  * 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, IndexEntitiesResult, InitParams, LocalSearchPage, WindowState } from "./localIndexWorker.js";
 import type { LocalIndexEntity } from "./localIndexSchema.js";
-/** A fresh generation - see this module's doc comment. */
-export declare function nextLocalIndexGeneration(): number;
+import type { LocalIndexTransport, PruneLocalEntitiesOptions, SetLocalIndexBuildingCompletion } from "./localIndexTransport.js";
 export declare const SIGN_OUT_CHANNEL = "rapidmx-localsearch";
 export declare const PENDING_DELETIONS_KEY = "rapidmx-localsearch-pending-deletions";
-/** 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 declare function retryPendingLocalIndexDeletions(): Promise<void>;
+/** How long sign-out waits for local index destruction before navigating anyway. */
+export declare const DESTROY_ALL_TIMEOUT_MS = 3000;
+/**
+ * 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 declare const workerLocalIndexTransport: LocalIndexTransport;
+/**
+ * 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 declare function setLocalIndexTransport(transport: LocalIndexTransport): void;
+/** A fresh generation - see this module's doc comment. */
+export declare function nextLocalIndexGeneration(): number;
 export declare function initLocalIndex(params: InitParams): Promise<void>;
 export declare function indexLocalEntities(mailboxUid: string, entities: LocalIndexEntity[], generation?: number): Promise<IndexEntitiesResult>;
 /** Drops one message from this session's local index (a delete). A no-op for a mailbox not indexed in
@@ -41,36 +68,21 @@ export declare function removeLocalEntity(mailboxUid: string, entityUid: string)
  * local searches stay correct. Same no-op/never-rejects rules as `removeLocalEntity()`. */
 export declare function moveLocalEntity(mailboxUid: string, entityUid: string, folderUid: string): Promise<void>;
 export declare function getIndexedVersions(mailboxUid: string, entityUids: string[]): Promise<Record<string, string>>;
-export declare function pruneLocalEntities(mailboxUid: string, keepEntityUids: string[], since: string | undefined, options?: {
-    folderUids?: string[];
-    generation?: number;
-}): Promise<number>;
+export declare function pruneLocalEntities(mailboxUid: string, keepEntityUids: string[], since: string | undefined, options?: PruneLocalEntitiesOptions): Promise<number>;
 export declare function searchLocal(mailboxUid: string, parsed: ParsedSearchQuery, limit: number, offset?: number): Promise<LocalSearchPage>;
 export declare function getLocalCoverage(mailboxUid: string): Promise<Coverage>;
 export declare function setLocalIndexWindow(mailboxUid: string, timeFloorMonths: number, byteBudgetBytes: number, generation?: number): Promise<WindowState>;
-export declare function setLocalIndexBuilding(mailboxUid: string, building: boolean, completion?: {
-    complete: boolean;
-    coveredFrom?: string;
-    coveredUntil?: string;
-    generation?: number;
-}): Promise<void>;
-/** Destroys one mailbox's local index (both the SQLite connection and its on-disk OPFS storage) - 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` - 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 declare function setLocalIndexBuilding(mailboxUid: string, building: boolean, completion?: SetLocalIndexBuildingCompletion): Promise<void>;
+/** 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 declare function destroyLocalIndex(mailboxUid: string): Promise<boolean>;
-/** How long sign-out waits for local index destruction before navigating anyway. */
-export declare const DESTROY_ALL_TIMEOUT_MS = 3000;
-/**
- * Destroys **every** local index on this device - not just the mailboxes this page load opened (sign-out
- * from Calendar, say, never opened any), by enumerating OPFS for the index directory prefix - and tells every
- * other tab to close its own connections. Closes this tab's own open connections through the Worker first
- * (only if one was ever spawned - there's nothing to close otherwise, and booting one just to delete files
- * 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.
- */
+/** 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 declare function destroyAllLocalIndexes(timeoutMs?: number): Promise<boolean>;
 /** 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 declare function pruneInaccessibleLocalIndexes(accessibleMailboxUids: Iterable<string>): Promise<void>;
+/** Retries every deletion an earlier session couldn't finish. Never rejects. */
+export declare function retryPendingLocalIndexDeletions(): Promise<void>;

package/dist/apps/shared/search/localIndexRpcClient.js

@@ -8,7 +8,7 @@ const pending = new Map();
 const initializedMailboxes = new Set();
 let generationCounter = 0;
 /** A fresh generation - see this module's doc comment. */
-export function nextLocalIndexGeneration() {
+function nextLocalIndexGenerationImpl() {
     generationCounter += 1;
     return generationCounter;
 }
@@ -83,7 +83,7 @@ function listenForSignOut() {
 async function closeEverythingInThisTab() {
     signedOut = true;
     initializedMailboxes.clear();
-    await call("destroyAll", { generation: nextLocalIndexGeneration() }).catch(() => undefined);
+    await call("destroyAll", { generation: nextLocalIndexGenerationImpl() }).catch(() => undefined);
 }
 function call(method, params) {
     const id = nextRequestId++;
@@ -133,7 +133,7 @@ function updatePendingDeletions(update) {
 let pendingRetry;
 /** 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() {
+function retryPendingLocalIndexDeletionsImpl() {
     pendingRetry ?? (pendingRetry = (async () => {
         const uids = readPendingDeletions();
         if (uids.length === 0) {
@@ -153,49 +153,49 @@ export function retryPendingLocalIndexDeletions() {
     })());
     return pendingRetry;
 }
-export async function initLocalIndex(params) {
-    await retryPendingLocalIndexDeletions();
+async function initLocalIndexImpl(params) {
+    await retryPendingLocalIndexDeletionsImpl();
     if (signedOut) {
         throw new Error("Signed out - the local search index is unavailable in this tab.");
     }
     await call("init", params);
     initializedMailboxes.add(params.mailboxUid);
 }
-export function indexLocalEntities(mailboxUid, entities, generation) {
+function indexLocalEntitiesImpl(mailboxUid, entities, generation) {
     return call("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 async function removeLocalEntity(mailboxUid, entityUid) {
+async function removeLocalEntityImpl(mailboxUid, entityUid) {
     if (!initializedMailboxes.has(mailboxUid)) {
         return;
     }
     await call("removeEntity", { mailboxUid, entityUid }).catch(() => undefined);
 }
 /** 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, entityUid, folderUid) {
+ * local searches stay correct. Same no-op/never-rejects rules as `removeLocalEntityImpl()`. */
+async function moveLocalEntityImpl(mailboxUid, entityUid, folderUid) {
     if (!initializedMailboxes.has(mailboxUid)) {
         return;
     }
     await call("moveEntity", { mailboxUid, entityUid, folderUid }).catch(() => undefined);
 }
-export function getIndexedVersions(mailboxUid, entityUids) {
+function getIndexedVersionsImpl(mailboxUid, entityUids) {
     return call("indexedVersions", { mailboxUid, entityUids });
 }
-export function pruneLocalEntities(mailboxUid, keepEntityUids, since, options = {}) {
+function pruneLocalEntitiesImpl(mailboxUid, keepEntityUids, since, options) {
     return call("pruneEntities", { mailboxUid, keepEntityUids, since, ...options });
 }
-export function searchLocal(mailboxUid, parsed, limit, offset = 0) {
+function searchLocalImpl(mailboxUid, parsed, limit, offset) {
     return call("search", { mailboxUid, parsed, limit, offset });
 }
-export function getLocalCoverage(mailboxUid) {
+function getLocalCoverageImpl(mailboxUid) {
     return call("coverage", mailboxUid);
 }
-export function setLocalIndexWindow(mailboxUid, timeFloorMonths, byteBudgetBytes, generation) {
+function setLocalIndexWindowImpl(mailboxUid, timeFloorMonths, byteBudgetBytes, generation) {
     return call("setWindow", { mailboxUid, timeFloorMonths, byteBudgetBytes, generation });
 }
-export function setLocalIndexBuilding(mailboxUid, building, completion = { complete: false }) {
+function setLocalIndexBuildingImpl(mailboxUid, building, completion) {
     return call("setBuilding", { mailboxUid, building, ...completion });
 }
 /** Destroys one mailbox's local index (both the SQLite connection and its on-disk OPFS storage) - spec
@@ -203,10 +203,10 @@ export function setLocalIndexBuilding(mailboxUid, building, completion = { compl
  * 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) {
+async function destroyLocalIndexImpl(mailboxUid) {
     updatePendingDeletions((current) => current.add(mailboxUid));
     try {
-        await call("destroy", { mailboxUid, generation: nextLocalIndexGeneration() });
+        await call("destroy", { mailboxUid, generation: nextLocalIndexGenerationImpl() });
         updatePendingDeletions((current) => current.delete(mailboxUid));
         return true;
     }
@@ -229,7 +229,7 @@ export const DESTROY_ALL_TIMEOUT_MS = 3000;
  * 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) {
+async function destroyAllLocalIndexesImpl(timeoutMs) {
     signedOut = true;
     writePendingDeletions([ALL_INDEXES]);
     try {
@@ -241,7 +241,7 @@ export async function destroyAllLocalIndexes(timeoutMs = DESTROY_ALL_TIMEOUT_MS)
     const work = (async () => {
         let ok = true;
         if (worker) {
-            const { failed } = await call("destroyAll", { generation: nextLocalIndexGeneration() }).catch(() => ({
+            const { failed } = await call("destroyAll", { generation: nextLocalIndexGenerationImpl() }).catch(() => ({
                 failed: ["(worker)"],
             }));
             ok = failed.length === 0;
@@ -264,6 +264,99 @@ 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) {
+async function pruneInaccessibleLocalIndexesImpl(accessibleMailboxUids) {
     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 = {
+    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 = 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) {
+    currentTransport = transport;
+}
+/** A fresh generation - see this module's doc comment. */
+export function nextLocalIndexGeneration() {
+    return currentTransport.nextGeneration();
+}
+export function initLocalIndex(params) {
+    return currentTransport.init(params);
+}
+export function indexLocalEntities(mailboxUid, entities, generation) {
+    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, entityUid) {
+    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, entityUid, folderUid) {
+    return currentTransport.moveEntity(mailboxUid, entityUid, folderUid);
+}
+export function getIndexedVersions(mailboxUid, entityUids) {
+    return currentTransport.indexedVersions(mailboxUid, entityUids);
+}
+export function pruneLocalEntities(mailboxUid, keepEntityUids, since, options = {}) {
+    return currentTransport.pruneEntities(mailboxUid, keepEntityUids, since, options);
+}
+export function searchLocal(mailboxUid, parsed, limit, offset = 0) {
+    return currentTransport.search(mailboxUid, parsed, limit, offset);
+}
+export function getLocalCoverage(mailboxUid) {
+    return currentTransport.coverage(mailboxUid);
+}
+export function setLocalIndexWindow(mailboxUid, timeFloorMonths, byteBudgetBytes, generation) {
+    return currentTransport.setWindow(mailboxUid, timeFloorMonths, byteBudgetBytes, generation);
+}
+export function setLocalIndexBuilding(mailboxUid, building, completion = { complete: false }) {
+    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) {
+    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) {
+    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) {
+    return currentTransport.pruneInaccessible(accessibleMailboxUids);
+}
+/** Retries every deletion an earlier session couldn't finish. Never rejects. */
+export function retryPendingLocalIndexDeletions() {
+    return currentTransport.retryPendingDeletions();
+}

package/dist/apps/shared/search/localIndexTransport.d.ts

@@ -0,0 +1,77 @@
+/**
+ * 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/dist/apps/shared/search/localIndexTransport.js

@@ -0,0 +1 @@
+export {};

package/dist/apps/shared/search/localIndexWorker.d.ts

@@ -1,4 +1,4 @@
-import type { ParsedSearchQuery } from "@rapidmx/react-shared/search/queryGrammar.js";
+import type { ParsedSearchQuery } from "../../../lib/search/queryGrammar.js";
 import { LocalIndexEntity } from "./localIndexSchema.js";
 /** One request sent from the main thread. `id` correlates the eventual response - `postMessage` has no
  * native request/response pairing, so every RPC call carries its own id (see `localIndexRpcClient.ts`,

package/dist/apps/shared/search/searchTier2.d.ts

@@ -13,9 +13,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 type { Coverage } from "./localIndexWorker.js";
 export interface Tier2SearchOutcome {
     results: SearchResult[];

package/dist/apps/shared/signing/enrollmentTracker.d.ts

@@ -1,4 +1,4 @@
-import { CurrentSignEnrollment, EnrollmentResult } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
+import { CurrentSignEnrollment, EnrollmentResult } from "../../../lib/crypto/keyvaultApi.js";
 /** The code of the 404 the server answers for an enrollment id it does not know (another provider after a configuration change, one long gone).
  * Re-exported from react-shared's `signingProviderApi.js` (R6's) rather than a second copy of the literal. */
 export declare const UNKNOWN_ENROLLMENT_CODE = "signing-enrollment-unknown";

package/dist/apps/shared/signing/enrollmentTracker.js

@@ -3,9 +3,9 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useSyncExternalStore } from "react";
-import { ApiRequestError } from "@rapidmx/react-shared/util/api.js";
-import { checkNowRetryAfterSeconds, checkSignEnrollmentNow, checkSignEnrollmentStatus, } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
-import { SIGNING_ENROLLMENT_UNKNOWN } from "@rapidmx/react-shared/crypto/signingProviderApi.js";
+import { ApiRequestError } from "../../../lib/util/api.js";
+import { checkNowRetryAfterSeconds, checkSignEnrollmentNow, checkSignEnrollmentStatus, } from "../../../lib/crypto/keyvaultApi.js";
+import { SIGNING_ENROLLMENT_UNKNOWN } from "../../../lib/crypto/signingProviderApi.js";
 import { storeSignEnrollment } from "./enrollmentStorage.js";
 import { resetSigningInfo } from "./signingInfo.js";
 /** The code of the 404 the server answers for an enrollment id it does not know (another provider after a configuration change, one long gone).

package/dist/apps/shared/signing/enrollmentView.d.ts

@@ -1,4 +1,4 @@
-import type { EnrollmentResult, SignEnrollmentStep } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
+import type { EnrollmentResult, SignEnrollmentStep } from "../../../lib/crypto/keyvaultApi.js";
 import type { SigningEnrollmentInfo } from "./signingInfo.js";
 /** Warn about an expiring certificate this many days ahead. */
 export declare const EXPIRY_WARNING_DAYS = 30;

package/dist/apps/shared/signing/signingInfo.d.ts

@@ -1,4 +1,4 @@
-import { SigningEnrollmentInfo } from "@rapidmx/react-shared/crypto/signingProviderApi.js";
+import { SigningEnrollmentInfo } from "../../../lib/crypto/signingProviderApi.js";
 export type { SigningEnrollmentInfo };
 /** How long an answer is reused: the page asks once when it opens, and again after this if it is opened again. */
 export declare const SIGNING_INFO_CACHE_MS: number;

package/dist/apps/shared/signing/signingInfo.js

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useEffect, useState } from "react";
-import { getSigningEnrollmentInfo } from "@rapidmx/react-shared/crypto/signingProviderApi.js";
+import { getSigningEnrollmentInfo } from "../../../lib/crypto/signingProviderApi.js";
 /** How long an answer is reused: the page asks once when it opens, and again after this if it is opened again. */
 export const SIGNING_INFO_CACHE_MS = 5 * 60000;
 let cached;

package/dist/apps/shared/signing/useSigningEnrollmentWatcher.d.ts

@@ -1,4 +1,4 @@
-import type { Mailbox } from "@rapidmx/react-shared/mail/mailApi.js";
+import type { Mailbox } from "../../../lib/mail/mailApi.js";
 /** Where the pop-up's action leads: the page that shows the certificate. */
 export declare const SIGNING_SETTINGS_HREF = "/settings/encryption";
 /**

package/dist/apps/shared/signing/useSigningEnrollmentWatcher.js

@@ -3,7 +3,8 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useEffect, useRef } from "react";
-import { getCurrentSignEnrollment } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
+import { getCurrentSignEnrollment } from "../../../lib/crypto/keyvaultApi.js";
+import { useApiClient } from "../../../lib/util/apiClientContext.js";
 import { notify } from "../notifications/store.js";
 import { readStoredSignEnrollment, storeSignEnrollment } from "./enrollmentStorage.js";
 import { onEnrollmentEnded, watchCurrentEnrollment, watchEnrollment } from "./enrollmentTracker.js";
@@ -19,6 +20,7 @@ export const SIGNING_SETTINGS_HREF = "/settings/encryption";
  * was seen pending - never for a certificate issued long ago.
  */
 export function useSigningEnrollmentWatcher({ userUid, mailboxes, enabled }) {
+    const client = useApiClient();
     const mailboxesRef = useRef(mailboxes);
     mailboxesRef.current = mailboxes;
     // Keyed on the uids of the mailboxes the user owns: a refreshed list of the same mailboxes must not start over.
@@ -41,7 +43,7 @@ export function useSigningEnrollmentWatcher({ userUid, mailboxes, enabled }) {
             // Never throws or rejects: a lookup that cannot be made (an older server, offline, anything) is "nothing is pending", and the frame goes on.
             void (async () => {
                 try {
-                    const current = await getCurrentSignEnrollment(mailboxUid);
+                    const current = await getCurrentSignEnrollment(mailboxUid, client);
                     if (!cancelled && current?.status === "pending") {
                         storeSignEnrollment(mailboxUid, current.enrollmentId);
                         releases.push(watchCurrentEnrollment(mailboxUid, current));
@@ -58,7 +60,7 @@ export function useSigningEnrollmentWatcher({ userUid, mailboxes, enabled }) {
             stopListening();
             releases.forEach((release) => release());
         };
-    }, [enabled, userUid, ownedKey]);
+    }, [enabled, userUid, ownedKey, client]);
 }
 /** The pop-up for an enrollment that just ended - issued or failed (the tracker announces nothing else, and always with its answer). */
 function announce(snapshot, mailboxes) {

package/dist/apps/shared/styles/app.css

@@ -10,27 +10,6 @@
  */
 @import "tailwindcss";
 
-/*
- * Tailwind v4's automatic content scanning excludes `node_modules` by default, which is exactly where
- * `@rapidmx/react-shared`'s components live - without these, none of its Tailwind classnames (Modal/
- * Drawer/Button/Alert/Skeleton/FormField/PopoverPortal/ContactAvatar/MiniDatePicker/BottomTabBar) are
- * generated, and e.g. a Modal renders with no overlay, position or width. The published package ships
- * only its compiled `dist` (no `src`), and `@source` paths resolve from this file's directory
- * (`apps/shared/styles/`), so both install layouts are listed; a path that doesn't exist is skipped:
- * - `../../../node_modules/...`: react-shared under this package's own `node_modules` - this repo's
- *   checkout, or a consumer install that nests it under web-client.
- * - `../../../../react-shared/dist`: react-shared hoisted beside this package, i.e. this file at
- *   `<consumer>/node_modules/@rapidmx/web-client/apps/shared/styles/` and react-shared at
- *   `<consumer>/node_modules/@rapidmx/react-shared` - how `server` installs both, for its pages and
- *   for the plugin pages' `plugin-ui.css`, which imports this file from there.
- * `electron-client` links `node_modules/@rapidmx/web-client` to a checkout of this repo, so one of the
- * two matches whether this file is reached through the link or its real path. From a checkout, the
- * second path can also find a sibling `react-shared` checkout's build, which only adds classes
- * react-shared itself uses.
- */
-@source "../../../node_modules/@rapidmx/react-shared/dist";
-@source "../../../../react-shared/dist";
-
 /*
  * `server`'s own build (unlike `electron-client`, which already explicitly sourced this same tree in
  * its own `styles.css`) has no explicit `@source` for this package's *own* `apps/**` tree at all,
@@ -42,11 +21,23 @@
  * `max-w-md`, ...) used by `AdminShell.tsx` (which has its own, separate `import "./app.css"`) was
  * silently absent from the built stylesheet, even though `AdminShell.tsx` itself was very much in the
  * bundle - verified directly by diffing every classname `AdminShell.tsx` uses against the actual built
- * CSS. An explicit `@source` here makes the scan independent of Vite's per-entry chunking, the same
- * fix this file applies to `react-shared` above, just for this package's own source too.
+ * CSS. An explicit `@source` here makes the scan independent of Vite's per-entry chunking.
  */
 @source "../../";
 
+/*
+ * `lib/` (this package's own `admin/`, `appearance/`, `auth/`, `branding/`, `calendar/`, `components/`,
+ * `contacts/`, `crypto/`, `mail/`, `search/`, `tasks/`, `util/`, `videoconf/` - merged in from the former
+ * `@rapidmx/react-shared` package, 2026-09-27, see `.claude/NOTES.md`) is a sibling of `apps/`, not a
+ * descendant of it, so the `@source "../../"` above does not reach it. Its `components/` tree (Modal/
+ * Drawer/Button/Alert/Skeleton/FormField/PopoverPortal/ContactAvatar/MiniDatePicker/BottomTabBar) needs
+ * the same explicit `@source` as `apps/**` does, for the same per-chunk-scanning reason, and for the same
+ * reason wherever this file is consumed from a `node_modules/@rapidmx/web-client/apps/shared/styles/`
+ * install too: `lib/` ships alongside `apps/` there as well, so this one relative path resolves correctly
+ * from both this repo's own checkout and a consumer's install.
+ */
+@source "../../../lib";
+
 /*
  * Self-hosted display typeface — the four weights shipped in `public/fonts/`. Matches the
  * Book/Medium/Bold/Heavy naming + 400/500/700/800 weight mapping from the brand style guide

package/dist/apps/www/_layout.d.ts

@@ -1,5 +1,5 @@
 import React, { PropsWithChildren } from "react";
-import { Branding } from "@rapidmx/react-shared/branding/brandingApi.js";
+import { Branding } from "../../lib/branding/brandingApi.js";
 export interface LayoutProps {
     /**
      * Supplied by `WwwRoute`'s `fetchProps()` override (`src/mongo/routes/wwwRoute.ts`/

package/dist/apps/www/_layout.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { AppearanceHead, appearanceHtmlAttributes } from "../shared/appearance/AppearanceHead.js";
-import { CUSTOM_STYLESHEET_LINK_ID } from "@rapidmx/react-shared/branding/useBranding.js";
+import { CUSTOM_STYLESHEET_LINK_ID } from "../../lib/branding/useBranding.js";
 export default function Layout({ children, branding, appearance, userUid }) {
     const title = branding?.title || branding?.companyName ? `${branding?.title || branding?.companyName}: Mail` : "RapidMX: Mail";
     const iconHref = branding?.iconUrl || branding?.logoUrl || "/images/logo.svg";

package/dist/apps/www/calendar/index.d.ts

@@ -4,5 +4,5 @@ declare function CalendarPage(props: CalendarShellProps): React.JSX.Element;
 export default CalendarPage;
 /** The tab's title: `Brand: Calendar` (see `pageTitle()`). */
 export declare const title: (props: {
-    branding?: Pick<import("@rapidmx/react-shared/branding/brandingApi.js").Branding, "title" | "companyName"> | null;
+    branding?: Pick<import("../../../lib/branding/brandingApi.js").Branding, "title" | "companyName"> | null;
 }) => string;