fix(cache-sqlite-wasm): add degradedMode guards to prevent 'Worker not initialized' errors

When WASM initialization fails (e.g., iOS Lockdown Mode, restricted
environments), the adapter enters degradedMode with no worker available.
However, many functions called ensureInitialized() which returns early
in degraded mode, then proceeded to call postWorkerMessage() which
throws 'Worker not initialized' because this.worker is null.

Several functions already had proper guards (fetchProfile, getEvent,
query, setEvent, saveProfile), but 13 others were missing them:
- getRelayStatus, updateRelayStatus
- getDecryptedEvent, addDecryptedEvent
- addUnpublishedEvent, getUnpublishedEvents, discardUnpublishedEvent
- loadNip05, saveNip05
- getProfiles, getCacheStats
- getCacheData, setCacheData (inline in index.ts)

The fix adds consistent degradedMode checks after ensureInitialized()
and before any postWorkerMessage() call. Functions with LRU caches
(updateRelayStatus, saveNip05) still update the in-memory cache before
returning, matching the pattern used by saveProfile.

Author: Execution Coordinator

cache-sqlite-wasm/src/functions/addDecryptedEvent.ts

@@ -9,6 +9,9 @@ import type { NDKCacheAdapterSqliteWasm } from "../index";
 export async function addDecryptedEvent(this: NDKCacheAdapterSqliteWasm, wrapperId: NDKEventId, decryptedEvent: NDKEvent): Promise<void> {
     await this.ensureInitialized();
 
+    // If in degraded mode, silently skip caching
+    if (this.degradedMode) return;
+
     const serialized = decryptedEvent.serialize(true, true);
 
     await this.postWorkerMessage({

cache-sqlite-wasm/src/functions/addUnpublishedEvent.ts

@@ -15,6 +15,9 @@ export async function addUnpublishedEvent(
 ): Promise<void> {
     await this.ensureInitialized();
 
+    // If in degraded mode, silently skip caching
+    if (this.degradedMode) return;
+
     await this.postWorkerMessage({
         type: "addUnpublishedEvent",
         payload: {

cache-sqlite-wasm/src/functions/discardUnpublishedEvent.ts

@@ -6,6 +6,9 @@ import type { NDKCacheAdapterSqliteWasm } from "../index";
 export async function discardUnpublishedEvent(this: NDKCacheAdapterSqliteWasm, eventId: string): Promise<void> {
     await this.ensureInitialized();
 
+    // If in degraded mode, silently skip
+    if (this.degradedMode) return;
+
     await this.postWorkerMessage({
         type: "discardUnpublishedEvent",
         payload: { id: eventId },

cache-sqlite-wasm/src/functions/getCacheStats.ts

@@ -16,6 +16,19 @@ export interface CacheStats {
 export async function getCacheStats(this: NDKCacheAdapterSqliteWasm): Promise<CacheStats> {
     await this.ensureInitialized();
 
+    // If in degraded mode, return empty stats
+    if (this.degradedMode) {
+        return {
+            eventsByKind: {},
+            totalEvents: 0,
+            totalProfiles: 0,
+            totalEventTags: 0,
+            totalDecryptedEvents: 0,
+            totalUnpublishedEvents: 0,
+            cacheData: 0,
+        };
+    }
+
     return this.postWorkerMessage<CacheStats>({
         type: "getCacheStats",
     });

cache-sqlite-wasm/src/functions/getDecryptedEvent.ts

@@ -10,6 +10,9 @@ export async function getDecryptedEvent(
 ): Promise<NDKEvent | null> {
     await this.ensureInitialized();
 
+    // If in degraded mode, return null (no cache available)
+    if (this.degradedMode) return null;
+
     const result = await this.postWorkerMessage<{ event?: string }>({
         type: "getDecryptedEvent",
         payload: { wrapperId: eventId },

cache-sqlite-wasm/src/functions/getProfiles.ts

@@ -21,6 +21,9 @@ export async function getProfiles(
 ): Promise<Map<Hexpubkey, NDKUserProfile> | undefined> {
     await this.ensureInitialized();
 
+    // If in degraded mode, return undefined (no cache available)
+    if (this.degradedMode) return undefined;
+
     // Worker mode only supports filter descriptors
     if (typeof filter === 'function') {
         throw new Error('getProfiles with filter functions is not supported in worker mode. Use filter descriptors instead.');

cache-sqlite-wasm/src/functions/getRelayStatus.ts

@@ -17,6 +17,9 @@ export async function getRelayStatus(
         return cached;
     }
 
+    // If in degraded mode, return undefined (only LRU cache available)
+    if (this.degradedMode) return undefined;
+
     const result = await this.postWorkerMessage<{ info?: string }>({
         type: "getRelayStatus",
         payload: { relayUrl },

cache-sqlite-wasm/src/functions/getUnpublishedEvents.ts

@@ -10,6 +10,9 @@ export async function getUnpublishedEvents(
 ): Promise<{ event: NDKEvent; relays?: string[]; lastTryAt?: number }[]> {
     await this.ensureInitialized();
 
+    // If in degraded mode, return empty (no cache available)
+    if (this.degradedMode) return [];
+
     const results = await this.postWorkerMessage<
         Array<{ id: string; event: string; relays: string; lastTryAt: number }>
     >({

cache-sqlite-wasm/src/functions/loadNip05.ts

@@ -29,6 +29,9 @@ export async function loadNip05(
         return cached.profile;
     }
 
+    // If in degraded mode, return "missing" (only LRU cache available)
+    if (this.degradedMode) return "missing";
+
     const result = await this.postWorkerMessage<{ profile?: string; fetched_at?: number }>({
         type: "loadNip05",
         payload: { nip05 },

cache-sqlite-wasm/src/functions/saveNip05.ts

@@ -20,6 +20,9 @@ export async function saveNip05(
     // Update LRU cache immediately
     this.metadataCache?.setNip05(nip05, { profile: profileStr, fetched_at: fetchedAt });
 
+    // If in degraded mode, skip persistent storage (LRU cache only)
+    if (this.degradedMode) return;
+
     await this.postWorkerMessage({
         type: "saveNip05",
         payload: {