Fix more typings

src/apps/webapp/adapters/FSAPIConversionAdapter.ts

@@ -1,4 +1,4 @@
-import type { UXFileInfoStub, UXFolderInfo } from "@lib/common/types";
+import type { FilePath, UXFileInfoStub, UXFolderInfo } from "@lib/common/types";
 import type { IConversionAdapter } from "@lib/serviceModules/adapters";
 import type { FSAPIFile, FSAPIFolder } from "./FSAPITypes";
 
@@ -28,7 +28,7 @@ export class FSAPIConversionAdapter implements IConversionAdapter<FSAPIFile, FSA
             path: folder.path,
             isFolder: true,
             children: [],
-            parent: parentPath as any,
+            parent: parentPath as FilePath,
         };
     }
 }

src/apps/webapp/adapters/FSAPIFileSystemAdapter.ts

@@ -173,7 +173,11 @@ export class FSAPIFileSystemAdapter implements IFileSystemAdapter<FSAPIFile, FSA
                 }
 
                 // Use AsyncIterator instead of .values() for better compatibility
-                for await (const [name, entry] of (currentHandle as any).entries()) {
+                for await (const [name, entry] of (
+                    currentHandle as unknown as {
+                        entries(): AsyncIterable<[string, FileSystemHandle]>;
+                    }
+                ).entries()) {
                     const entryPath = relativePath ? `${relativePath}/${name}` : name;
 
                     if (entry.kind === "directory") {

src/apps/webapp/adapters/FSAPIStorageAdapter.ts

@@ -195,7 +195,11 @@ export class FSAPIStorageAdapter implements IStorageAdapter<FSAPIStat> {
         const folders: string[] = [];
 
         // Use AsyncIterator instead of .values() for better compatibility
-        for await (const [name, entry] of (dirHandle as any).entries()) {
+        for await (const [name, entry] of (
+            dirHandle as unknown as {
+                entries(): AsyncIterable<[string, FileSystemHandle]>;
+            }
+        ).entries()) {
             const entryPath = basePath ? `${basePath}/${name}` : name;
 
             if (entry.kind === "directory") {

src/apps/webapp/adapters/FSAPITypeGuardAdapter.ts

@@ -5,13 +5,24 @@ import type { FSAPIFile, FSAPIFolder } from "./FSAPITypes";
  * Type guard adapter implementation for FileSystem API
  */
 export class FSAPITypeGuardAdapter implements ITypeGuardAdapter<FSAPIFile, FSAPIFolder> {
-    isFile(file: any): file is FSAPIFile {
-        return (
-            file && typeof file === "object" && "path" in file && "stat" in file && "handle" in file && !file.isFolder
+    isFile(file: unknown): file is FSAPIFile {
+        return !!(
+            file &&
+            typeof file === "object" &&
+            "path" in file &&
+            "stat" in file &&
+            "handle" in file &&
+            !(file as { isFolder?: boolean }).isFolder
         );
     }
 
-    isFolder(item: any): item is FSAPIFolder {
-        return item && typeof item === "object" && "path" in item && item.isFolder === true && "handle" in item;
+    isFolder(item: unknown): item is FSAPIFolder {
+        return !!(
+            item &&
+            typeof item === "object" &&
+            "path" in item &&
+            (item as { isFolder?: boolean }).isFolder === true &&
+            "handle" in item
+        );
     }
 }

src/apps/webapp/adapters/FSAPIVaultAdapter.ts

@@ -116,8 +116,7 @@ export class FSAPIVaultAdapter implements IVaultAdapter<FSAPIFile> {
         await this.delete(file, force);
     }
 
-    trigger(name: string, ...data: any[]): any {
+    trigger(name: string, ...data: unknown[]): void {
         // No-op in webapp version (no event system yet)
-        return undefined;
     }
 }

src/apps/webapp/bootstrap.ts

@@ -121,13 +121,11 @@ async function initializeVaultSelector(): Promise<void> {
     await renderHistoryList();
 }
 
-compatGlobal.addEventListener("load", async () => {
-    try {
-        await initializeVaultSelector();
-    } catch (error) {
+compatGlobal.addEventListener("load", () => {
+    initializeVaultSelector().catch((error) => {
         console.error("Failed to initialize vault selector:", error);
         setStatus("error", `Initialization failed: ${String(error)}`);
-    }
+    });
 });
 
 compatGlobal.addEventListener("beforeunload", () => {

src/apps/webapp/main.ts

@@ -97,13 +97,15 @@ class LiveSyncWebApp {
         });
 
         // App lifecycle handlers
-        this.serviceHub.appLifecycle.scheduleRestart.setHandler(async () => {
-            console.log("[AppLifecycle] Restart requested");
-            await this.shutdown();
-            await this.initialize();
-            compatGlobal.setTimeout(() => {
-                compatGlobal.location.reload();
-            }, 1000);
+        this.serviceHub.appLifecycle.scheduleRestart.setHandler(() => {
+            void (async () => {
+                console.log("[AppLifecycle] Restart requested");
+                await this.shutdown();
+                await this.initialize();
+                compatGlobal.setTimeout(() => {
+                    compatGlobal.location.reload();
+                }, 1000);
+            })();
         });
 
         // Create LiveSync core

src/apps/webapp/managers/FSAPIStorageEventManagerAdapter.ts

@@ -207,9 +207,9 @@ class FSAPIWatchAdapter implements IStorageEventWatchAdapter {
                                 };
 
                                 if (type === "appeared") {
-                                    await handlers.onCreate(fileInfo, undefined);
+                                    handlers.onCreate(fileInfo, undefined);
                                 } else {
-                                    await handlers.onChange(fileInfo, undefined);
+                                    handlers.onChange(fileInfo, undefined);
                                 }
                             }
                         } else if (type === "disappeared") {
@@ -223,7 +223,7 @@ class FSAPIWatchAdapter implements IStorageEventWatchAdapter {
                                 },
                                 handle: null as unknown as FileSystemFileHandle, // No handle available for disappeared files
                             };
-                            await handlers.onDelete(fileInfo, undefined);
+                            handlers.onDelete(fileInfo, undefined);
                         } else if (type === "moved") {
                             // Handle as delete + create
                             // Note: FileSystemObserver provides both old and new paths in some cases
@@ -240,7 +240,7 @@ class FSAPIWatchAdapter implements IStorageEventWatchAdapter {
                                     },
                                     handle: changedHandle,
                                 };
-                                await handlers.onChange(fileInfo, undefined);
+                                handlers.onChange(fileInfo, undefined);
                             }
                         }
                     } catch (error) {

src/apps/webapp/test-entry.ts

@@ -28,11 +28,38 @@ function stripPrefix(raw: string): string {
     return raw.replace(/^[^:]+:/, "");
 }
 
+interface TestCore {
+    services?: {
+        replication?: {
+            databaseQueueCount?: { value: number };
+            storageApplyingCount?: { value: number };
+        };
+        fileProcessing?: {
+            totalQueued?: { value: number };
+            batched?: { value: number };
+            processing?: { value: number };
+        };
+        database?: {
+            localDatabase: {
+                findAllNormalDocs(options?: { conflicts?: boolean }): AsyncIterable<{
+                    _deleted?: boolean;
+                    deleted?: boolean;
+                    path?: string;
+                    _rev?: string;
+                    _conflicts?: string[];
+                    size?: number;
+                    mtime?: number;
+                }>;
+            };
+        };
+    };
+}
+
 /**
  * Poll every 300 ms until all known processing queues are drained, or until
  * the timeout elapses.  Mirrors `waitForIdle` in the existing vitest harness.
  */
-async function waitForIdle(core: any, timeoutMs = 60_000): Promise<void> {
+async function waitForIdle(core: TestCore, timeoutMs = 60_000): Promise<void> {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
         const q =
@@ -47,8 +74,8 @@ async function waitForIdle(core: any, timeoutMs = 60_000): Promise<void> {
     throw new Error(`waitForIdle timed out after ${timeoutMs} ms`);
 }
 
-function getCore(): any {
-    const core = (app as any)?.core;
+function getCore(): TestCore {
+    const core = (app as unknown as { core: TestCore | null })?.core;
     if (!core) throw new Error("Vault not initialised – call livesyncTest.init() first");
     return core;
 }
@@ -201,4 +228,4 @@ const livesyncTest: LiveSyncTestAPI = {
 };
 
 // Expose on window for Playwright page.evaluate() calls.
-(compatGlobal as any).livesyncTest = livesyncTest;
+(compatGlobal as unknown as Record<string, unknown>).livesyncTest = livesyncTest;

src/apps/webapp/vaultSelector.ts

@@ -32,7 +32,10 @@ function randomId(): string {
 }
 
 async function hasReadWritePermission(handle: FileSystemDirectoryHandle, requestIfNeeded: boolean): Promise<boolean> {
-    const h = handle as any;
+    const h = handle as unknown as {
+        queryPermission?: (options: { mode: "readwrite" }) => Promise<PermissionState>;
+        requestPermission?: (options: { mode: "readwrite" }) => Promise<PermissionState>;
+    };
     if (typeof h.queryPermission === "function") {
         const queried = await h.queryPermission({ mode: "readwrite" });
         if (queried === "granted") {
@@ -172,15 +175,17 @@ export class VaultHistoryStore {
     }
 
     async pickNewVault(): Promise<FileSystemDirectoryHandle> {
-        const picker = (compatGlobal as any).showDirectoryPicker;
+        const picker = (compatGlobal as unknown as Record<string, unknown>).showDirectoryPicker as
+            | ((options?: { mode?: "readwrite" | "read"; startIn?: string }) => Promise<FileSystemDirectoryHandle>)
+            | undefined;
         if (typeof picker !== "function") {
             throw new Error("FileSystem API showDirectoryPicker is not supported in this browser");
         }
 
-        const handle = (await picker({
+        const handle = await picker({
             mode: "readwrite",
             startIn: "documents",
-        })) as FileSystemDirectoryHandle;
+        });
 
         const granted = await hasReadWritePermission(handle, true);
         if (!granted) {