feat: implement vault synchronization and decryption improvements

- Added background synchronization for vault core data, including optional folder updates.
- Introduced a new API endpoint to retrieve the vault revision date.
- Enhanced vault synchronization logic to utilize a caching mechanism for improved performance.
- Created a new vault cache module to handle IndexedDB storage for vault core snapshots.
- Implemented a worker for asynchronous decryption of vault data, improving UI responsiveness.
- Updated main application settings to adjust query stale time for better data freshness.
- Refactored vault-related API functions to support cache keys for more efficient data retrieval.

webapp/src/lib/vault-worker.ts

@@ -0,0 +1,55 @@
+import type { Send } from './types';
+import type { DecryptSendsArgs, DecryptVaultCoreArgs, DecryptVaultCoreResult } from './vault-decrypt';
+
+type WorkerSuccess<T> = { id: number; ok: true; result: T };
+type WorkerFailure = { id: number; ok: false; error: string };
+type WorkerResponse<T> = WorkerSuccess<T> | WorkerFailure;
+
+let worker: Worker | null = null;
+let nextJobId = 1;
+const pending = new Map<number, { resolve: (value: any) => void; reject: (error: Error) => void }>();
+
+function getWorker(): Worker | null {
+  if (typeof Worker === 'undefined') return null;
+  if (worker) return worker;
+  worker = new Worker(new URL('../workers/vault-decrypt.worker.ts', import.meta.url), { type: 'module' });
+  worker.addEventListener('message', (event: MessageEvent<WorkerResponse<unknown>>) => {
+    const message = event.data;
+    const job = pending.get(message.id);
+    if (!job) return;
+    pending.delete(message.id);
+    if (message.ok) {
+      job.resolve(message.result);
+      return;
+    }
+    job.reject(new Error(message.error || 'Decrypt failed'));
+  });
+  worker.addEventListener('error', () => {
+    for (const [, job] of pending) {
+      job.reject(new Error('Decrypt worker failed'));
+    }
+    pending.clear();
+    worker = null;
+  });
+  return worker;
+}
+
+function postJob<T>(payload: { kind: 'vault-core'; payload: DecryptVaultCoreArgs } | { kind: 'sends'; payload: DecryptSendsArgs }): Promise<T> {
+  const instance = getWorker();
+  if (!instance) {
+    return Promise.reject(new Error('Decrypt worker unavailable'));
+  }
+  const id = nextJobId++;
+  return new Promise<T>((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+    instance.postMessage({ id, ...payload });
+  });
+}
+
+export function decryptVaultCoreInWorker(args: DecryptVaultCoreArgs): Promise<DecryptVaultCoreResult> {
+  return postJob<DecryptVaultCoreResult>({ kind: 'vault-core', payload: args });
+}
+
+export function decryptSendsInWorker(args: DecryptSendsArgs): Promise<Send[]> {
+  return postJob<Send[]>({ kind: 'sends', payload: args });
+}