@drakkar.software/starfish-client 1.4.0 → 1.4.1

package/dist/bindings/legend.js

@@ -18,7 +18,7 @@ export function createStarfishObservable(options) {
             state.dirty.set(false);
         }
         catch (err) {
-            state.error.set(err.message);
+            state.error.set(err instanceof Error ? err.message : String(err));
         }
         finally {
             state.syncing.set(false);
@@ -32,7 +32,7 @@ export function createStarfishObservable(options) {
             state.data.set(options.syncManager.getData());
         }
         catch (err) {
-            state.error.set(err.message);
+            state.error.set(err instanceof Error ? err.message : String(err));
         }
         finally {
             state.syncing.set(false);
@@ -48,16 +48,16 @@ export function createStarfishObservable(options) {
             state.dirty.set(true);
             state.error.set(null);
             if (state.online.get())
-                flush();
+                flush().catch(() => { });
         }
         catch (err) {
-            state.error.set(err.message);
+            state.error.set(err instanceof Error ? err.message : String(err));
         }
     };
     const setOnline = (online) => {
         state.online.set(online);
         if (online && state.dirty.get())
-            flush();
+            flush().catch(() => { });
     };
     return { state, pull, set, flush, setOnline };
 }

package/dist/bindings/zustand.js

@@ -22,7 +22,7 @@ export function createStarfishStore(options) {
                     set({ data: syncManager.getData(), syncing: false }, false, "pull/success");
                 }
                 catch (err) {
-                    set({ syncing: false, error: err.message }, false, "pull/error");
+                    set({ syncing: false, error: err instanceof Error ? err.message : String(err) }, false, "pull/error");
                 }
             },
             set: (modifier) => {
@@ -32,10 +32,10 @@ export function createStarfishStore(options) {
                         : modifier(get().data);
                     set({ data: next, dirty: true, error: null }, false, "set");
                     if (get().online)
-                        get().flush();
+                        get().flush().catch(() => { });
                 }
                 catch (err) {
-                    set({ error: err.message }, false, "set/error");
+                    set({ error: err instanceof Error ? err.message : String(err) }, false, "set/error");
                 }
             },
             restore: (data) => {
@@ -50,13 +50,13 @@ export function createStarfishStore(options) {
                     set({ data: syncManager.getData(), syncing: false, dirty: false }, false, "flush/success");
                 }
                 catch (err) {
-                    set({ syncing: false, error: err.message }, false, "flush/error");
+                    set({ syncing: false, error: err instanceof Error ? err.message : String(err) }, false, "flush/error");
                 }
             },
             setOnline: (online) => {
                 set({ online }, false, "setOnline");
                 if (online && get().dirty)
-                    get().flush();
+                    get().flush().catch(() => { });
             },
         };
     };
@@ -217,15 +217,23 @@ export function useSyncInit(config) {
             // Only call onData when data changes and store is not dirty
             // (dirty = false means data came from a pull, not a local set)
             if (data !== lastDataRef && !state.dirty) {
-                onDataRef.current?.(data);
+                lastDataRef = data;
+                try {
+                    onDataRef.current?.(data);
+                }
+                catch (err) {
+                    newStore.setState({
+                        error: `onData failed: ${err instanceof Error ? err.message : String(err)}`,
+                    });
+                }
+            }
+            else {
+                lastDataRef = data;
             }
-            lastDataRef = data;
         });
         setStore(newStore);
-        // Initial pull — errors are stored in state.error; log if logger provided
-        newStore.getState().pull().catch((err) => {
-            config.logger?.pullError(config.storeName ?? "sync", err.message);
-        });
+        // Initial pull — errors are stored in state.error by the pull() action
+        newStore.getState().pull().catch(() => { });
         return () => {
             unsub();
             setStore(null);

package/dist/broadcast.js

@@ -7,8 +7,11 @@ export function setupBroadcastSync(store, name) {
     const channel = new BroadcastChannel(`starfish-${name}`);
     let lastReceivedData = null;
     channel.onmessage = (event) => {
-        lastReceivedData = event.data.data;
-        store.setState({ data: event.data.data, dirty: event.data.dirty });
+        const payload = event.data;
+        if (!payload || typeof payload !== "object" || !payload.data || typeof payload.data !== "object")
+            return;
+        lastReceivedData = payload.data;
+        store.setState({ data: payload.data, dirty: !!payload.dirty });
     };
     const unsub = store.subscribe((state, prev) => {
         if (state.data === lastReceivedData)
@@ -43,8 +46,10 @@ export function setupStorageFallback(store, name) {
         catch {
             return;
         }
+        if (!payload || typeof payload !== "object" || !payload.data || typeof payload.data !== "object")
+            return;
         lastReceivedData = payload.data;
-        store.setState({ data: payload.data, dirty: payload.dirty });
+        store.setState({ data: payload.data, dirty: !!payload.dirty });
     };
     globalThis.addEventListener("storage", onStorage);
     const unsub = store.subscribe((state, prev) => {

package/dist/client.d.ts

@@ -3,7 +3,8 @@ import type { StarfishClientOptions } from "./types.js";
 /** Result of pulling a binary blob from the server. */
 export interface BlobPullResult {
     data: ArrayBuffer;
-    hash: string;
+    /** Content hash from the ETag header. Null if the server didn't include an ETag. */
+    hash: string | null;
     contentType: string;
 }
 /** Result of pushing a binary blob to the server. */

package/dist/client.js

@@ -82,7 +82,7 @@ export class StarfishClient {
         if (!res.ok) {
             throw new StarfishHttpError(res.status, await res.text());
         }
-        const etag = res.headers.get("ETag")?.replace(/"/g, "") ?? "";
+        const etag = res.headers.get("ETag")?.replace(/"/g, "") ?? null;
         const contentType = res.headers.get("Content-Type") ?? "application/octet-stream";
         const data = await res.arrayBuffer();
         return { data, hash: etag, contentType };

package/dist/fetch.js

@@ -2,6 +2,10 @@
 export function classifyError(err) {
     if (err instanceof Response || (err && typeof err === "object" && "status" in err)) {
         const status = err.status;
+        if (typeof status !== "number" || isNaN(status))
+            return "unknown";
+        if (status === 0)
+            return "network";
         if (status === 401 || status === 403)
             return "auth";
         if (status === 409)
@@ -35,11 +39,11 @@ export function createRetryFetch(options) {
                 const category = classifyError(res);
                 if (category !== "rate-limited" && category !== "server")
                     return res;
-                const retryAfter = res.headers.get("Retry-After");
+                const retryAfter = res.headers.get("Retry-After")?.trim();
                 let delay;
                 if (retryAfter) {
                     const seconds = Number(retryAfter);
-                    if (!isNaN(seconds)) {
+                    if (retryAfter !== "" && !isNaN(seconds)) {
                         delay = Math.min(seconds * 1000, maxDelay);
                     }
                     else {
@@ -115,15 +119,20 @@ export function createCompressedFetch(inner) {
         const bodyText = typeof init.body === "string" ? init.body : null;
         if (!bodyText)
             return baseFetch(input, init);
-        const stream = new Blob([bodyText]).stream().pipeThrough(new CompressionStream("gzip"));
-        const compressed = await new Response(stream).arrayBuffer();
-        const normalized = Object.fromEntries(new Headers(init.headers).entries());
-        normalized["content-encoding"] = "gzip";
-        return baseFetch(input, {
-            ...init,
-            body: compressed,
-            headers: normalized,
-        });
+        try {
+            const stream = new Blob([bodyText]).stream().pipeThrough(new CompressionStream("gzip"));
+            const compressed = await new Response(stream).arrayBuffer();
+            const normalized = Object.fromEntries(new Headers(init.headers).entries());
+            normalized["content-encoding"] = "gzip";
+            return baseFetch(input, {
+                ...init,
+                body: compressed,
+                headers: normalized,
+            });
+        }
+        catch {
+            return baseFetch(input, init);
+        }
     };
 }
 /**
@@ -135,16 +144,17 @@ export function createResilientFetch(retryOptions, breakerOptions) {
     const retryFetch = createRetryFetch(retryOptions);
     const resilientFetch = async (input, init) => {
         if (breaker.isOpen()) {
-            throw new Error(`Circuit breaker is open (${breaker.getState()}, cooldown ${breakerOptions?.cooldownMs ?? 30_000}ms)`);
+            const cooldown = Math.ceil((breakerOptions?.cooldownMs ?? 30_000) / 1000);
+            throw new Error(`Request blocked: too many consecutive failures. Retry in ${cooldown}s.`);
         }
         try {
             const res = await retryFetch(input, init);
-            if (res.ok) {
-                breaker.recordSuccess();
-            }
-            else if (res.status >= 500) {
+            if (res.status >= 500) {
                 breaker.recordFailure();
             }
+            else {
+                breaker.recordSuccess();
+            }
             return res;
         }
         catch (err) {

package/dist/history.d.ts

@@ -16,7 +16,7 @@ export declare class SnapshotHistory {
     constructor(options?: SnapshotHistoryOptions);
     /** Take a labeled snapshot of the given data. */
     take(label: string, data: Record<string, unknown>): void;
-    /** Restore data from a snapshot at the given index. Returns undefined if index is invalid. */
+    /** Restore data from a snapshot at the given index. Returns undefined if index is invalid or data is corrupt. */
     restore(index: number): Record<string, unknown> | undefined;
     /** List available snapshots (metadata only, no data payload). */
     list(): Array<{

package/dist/history.js

@@ -8,8 +8,11 @@ export class SnapshotHistory {
         if (this.storageKey) {
             try {
                 const raw = localStorage.getItem(this.storageKey);
-                if (raw)
-                    this.snapshots = JSON.parse(raw);
+                if (raw) {
+                    const parsed = JSON.parse(raw);
+                    if (Array.isArray(parsed))
+                        this.snapshots = parsed;
+                }
             }
             catch { /* corrupted or unavailable — start fresh */ }
         }
@@ -26,12 +29,17 @@ export class SnapshotHistory {
         }
         this.persist();
     }
-    /** Restore data from a snapshot at the given index. Returns undefined if index is invalid. */
+    /** Restore data from a snapshot at the given index. Returns undefined if index is invalid or data is corrupt. */
     restore(index) {
         const snapshot = this.snapshots[index];
         if (!snapshot)
             return undefined;
-        return JSON.parse(snapshot.data);
+        try {
+            return JSON.parse(snapshot.data);
+        }
+        catch {
+            return undefined;
+        }
     }
     /** List available snapshots (metadata only, no data payload). */
     list() {

package/dist/migrate.js

@@ -25,7 +25,12 @@ export function createMigrator(config) {
             if (!fn) {
                 throw new Error(`Missing migration for version ${v} -> ${v + 1}`);
             }
-            result = fn(result);
+            try {
+                result = fn(result);
+            }
+            catch (err) {
+                throw new Error(`Migration from version ${v} to ${v + 1} failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+            }
         }
         result._schemaVersion = config.currentVersion;
         return result;

package/dist/polling.js

@@ -14,7 +14,7 @@ export function startPolling(pullFn, getState, intervalMs = 30_000) {
     const timer = setInterval(() => {
         const { online, syncing } = getState();
         if (online && !syncing)
-            pullFn();
+            pullFn().catch(() => { });
     }, intervalMs);
     return () => clearInterval(timer);
 }
@@ -42,7 +42,7 @@ export function startAdaptivePolling(pullFn, getState, options) {
             return;
         const { online, syncing } = getState();
         if (online && !syncing)
-            pullFn();
+            pullFn().catch(() => { });
     }, intervalMs);
     return {
         pause: () => { paused = true; },

package/dist/resolvers.js

@@ -99,9 +99,9 @@ export function createSoftDeleteResolver(options) {
                         const rec = item;
                         const id = rec[idKey];
                         const deletedAt = rec[deletedAtKey];
-                        if (typeof deletedAt === "number") {
-                            const existing = tombstones.get(id) ?? 0;
-                            if (deletedAt > existing)
+                        if (typeof deletedAt === "number" || typeof deletedAt === "string") {
+                            const existing = tombstones.get(id);
+                            if (existing == null || compareTimestamps(deletedAt, existing))
                                 tombstones.set(id, deletedAt);
                         }
                     }
@@ -157,6 +157,10 @@ export function pruneTombstones(items, ttlMs = 30 * 24 * 60 * 60 * 1000, deleted
         const deletedAt = item[deletedAtKey];
         if (deletedAt == null)
             return true;
-        return typeof deletedAt === "number" && deletedAt > cutoff;
+        if (typeof deletedAt === "number")
+            return deletedAt > cutoff;
+        if (typeof deletedAt === "string")
+            return new Date(deletedAt).getTime() > cutoff;
+        return false;
     });
 }

package/dist/sync.js

@@ -52,6 +52,7 @@ export class SyncManager {
             }
             else if (this.lastCheckpoint > 0) {
                 this.localData = deepMerge(this.localData, result.data);
+                result.data = this.localData;
             }
             else {
                 this.localData = result.data;
@@ -62,7 +63,7 @@ export class SyncManager {
             return result;
         }
         catch (err) {
-            this.logger?.pullError(this.loggerName, err.message);
+            this.logger?.pullError(this.loggerName, err instanceof Error ? err.message : String(err));
             throw err;
         }
     }
@@ -93,17 +94,24 @@ export class SyncManager {
             }
             catch (err) {
                 if (!(err instanceof ConflictError) || attempt >= this.maxRetries) {
-                    this.logger?.pushError(this.loggerName, err.message);
+                    this.logger?.pushError(this.loggerName, err instanceof Error ? err.message : String(err));
                     throw err;
                 }
                 this.logger?.conflict(this.loggerName, attempt + 1);
-                const remote = await this.client.pull(this.pullPath);
-                this.lastHash = remote.hash;
-                this.lastCheckpoint = remote.timestamp;
-                const remoteData = this.encryptor
-                    ? await this.encryptor.decrypt(remote.data)
-                    : remote.data;
-                pendingData = this.onConflict(pendingData, remoteData);
+                try {
+                    const remote = await this.client.pull(this.pullPath);
+                    const remoteData = this.encryptor
+                        ? await this.encryptor.decrypt(remote.data)
+                        : remote.data;
+                    this.lastHash = remote.hash;
+                    this.lastCheckpoint = remote.timestamp;
+                    pendingData = this.onConflict(pendingData, remoteData);
+                }
+                catch (resolveErr) {
+                    const msg = resolveErr instanceof Error ? resolveErr.message : String(resolveErr);
+                    this.logger?.pushError(this.loggerName, `Conflict resolution failed (attempt ${attempt + 1}): ${msg}`);
+                    throw resolveErr;
+                }
                 await new Promise(resolve => setTimeout(resolve, Math.min(100 * Math.pow(2, attempt), 2000) + Math.random() * 100));
                 attempt++;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakkar.software/starfish-client",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/Drakkar-Software/starfish.git",
@@ -60,7 +60,7 @@
     }
   },
   "dependencies": {
-    "@drakkar.software/starfish-protocol": "1.4.0"
+    "@drakkar.software/starfish-protocol": "1.4.1"
   },
   "devDependencies": {
     "@legendapp/state": "^2.0.0",