@bayonai/offline 0.13.0 → 0.15.0

package/dist-cjs/readResourceObserver.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReadResourceObserver = createReadResourceObserver;
+/**
+ * Mounted presentation only: hosts retain cache, transport, identity and initial
+ * read policy. Accepting a snapshot preserves its source age; a successful
+ * refresh does not require persistence to have survived an unrelated write.
+ */
+function createReadResourceObserver({ enabled = true, current, now, freshForMs, canRetain, isConnected = () => true, canonical, captureSnapshot, read, retireSnapshot, classifyFailure, subscribeWake, onUpdate, onData, onError, }) {
+    let disposed = false;
+    let retired = false;
+    let confirmedAt;
+    let retainable = true;
+    let pending;
+    let stop = () => { };
+    const detach = () => { const cleanup = stop; stop = () => { }; cleanup(); };
+    const active = () => !disposed && !retired && current();
+    const canRefresh = () => enabled && active() && retainable && confirmedAt !== undefined;
+    const accept = (update, age = now()) => {
+        if (!active())
+            return;
+        if ("data" in update) {
+            confirmedAt = age;
+            retainable = canRetain(update.data);
+            onData?.(update.data);
+        }
+        if (active())
+            onUpdate(update);
+    };
+    const adoptCanonical = () => {
+        const snapshot = canonical();
+        if (!snapshot || !active() || now() - snapshot.confirmedAt >= freshForMs)
+            return false;
+        accept({ status: "fresh", data: snapshot.data }, snapshot.confirmedAt);
+        return true;
+    };
+    const run = async (force) => {
+        if (!canRefresh())
+            return;
+        if (!force && now() - confirmedAt < freshForMs)
+            return;
+        if (!isConnected()) {
+            accept({ status: "retry", error: new Error("Resource unavailable while disconnected") });
+            return;
+        }
+        if (!force && adoptCanonical())
+            return;
+        accept({ status: "refreshing" });
+        if (!canRefresh())
+            return;
+        const snapshot = captureSnapshot();
+        let result;
+        try {
+            result = await read();
+        }
+        catch (error) {
+            if (!active())
+                return;
+            const failure = classifyFailure(error);
+            if (failure === "superseded") {
+                adoptCanonical();
+                return;
+            }
+            if (failure === "retired")
+                return;
+            if (onError)
+                onError(error);
+            else
+                console.error("[Bayon offline] Mounted resource refresh failed.", { error });
+            if (failure === "transient")
+                accept({ status: "retry", error });
+            else {
+                try {
+                    await retireSnapshot(snapshot);
+                }
+                catch (storageError) {
+                    // Storage cleanup cannot turn a known denial into retained presentation.
+                    console.error("[Bayon offline] Unable to retire a mounted read snapshot.", { error: storageError });
+                }
+                if (!active())
+                    return;
+                confirmedAt = undefined;
+                accept({ status: "failed", error });
+            }
+            return;
+        }
+        accept({ status: "fresh", data: result.data }, result.confirmedAt);
+    };
+    const refresh = ({ force = true } = {}) => {
+        if (!canRefresh())
+            return;
+        // Install ownership before callbacks can synchronously request another read.
+        if (!pending)
+            pending = Promise.resolve().then(() => run(force)).finally(() => { pending = undefined; });
+        return pending;
+    };
+    if (enabled && subscribeWake)
+        stop = subscribeWake(() => refresh({ force: false }) ?? Promise.resolve());
+    return {
+        accept, canRefresh, refresh,
+        retire() {
+            if (disposed || retired)
+                return;
+            retired = true;
+            detach();
+            // Clearing protected presentation is safe even after the host changed scope.
+            onUpdate({ status: "invalidated" });
+        },
+        dispose() { disposed = true; detach(); },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bayonai/offline",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Reusable offline read-cache, pending-write, and silent recovery primitives.",
   "license": "MIT",
   "author": "Bayon AI",