@effect-app/vue 4.0.4 → 4.0.6

package/dist/liveQueryInvalidation.js

@@ -1,115 +1,392 @@
 import { DataDependencies } from "effect-app/client";
-import * as Hash from "effect/Hash";
-const entries = new Map();
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as Option from "effect/Option";
+const entries = MutableHashMap.empty();
+const fetches = new WeakMap();
+/** One shared `ready()` call per epoch; waiters detach on abort so none accumulate on the promise. */
+let observation;
 let source;
 let unsubscribe;
-let discovering = 0;
-let bufferedWrites = DataDependencies.empty();
+let subscribing = false;
+let epoch = 0;
+// a synchronous refresh can remove or replace registrations while dispatching
+const isCurrent = (entry) => Option.getOrUndefined(MutableHashMap.get(entries, entry.key)) === entry;
+const forEachCurrent = (f) => {
+    for (const entry of Array.from(MutableHashMap.values(entries))) {
+        if (isCurrent(entry))
+            f(entry);
+    }
+};
 const invalidateEntry = (entry) => {
     entry.timer = undefined;
-    source?.invalidate([entry.key]);
+    if (isCurrent(entry))
+        source?.invalidate([entry.key]);
+};
+// (re)arm for the strictest observer; a stricter observer or write can only bring the deadline forward
+const arm = (entry) => {
+    const deadline = entry.firstWriteAt + Math.min(...entry.delays.keys());
+    if (entry.timer !== undefined) {
+        if (entry.deadline <= deadline)
+            return;
+        clearTimeout(entry.timer);
+        entry.timer = undefined;
+    }
+    entry.deadline = deadline;
+    const wait = deadline - Date.now();
+    if (wait <= 0)
+        return invalidateEntry(entry);
+    entry.timer = setTimeout(() => invalidateEntry(entry), wait);
 };
 const schedule = (entry) => {
+    if (entry.timer === undefined)
+        entry.firstWriteAt = Date.now();
+    arm(entry);
+};
+// catch-up replaces a refetch, so it bypasses write coalescing; a running refetch makes SWR skip its own
+const invalidateNow = (entry) => {
+    if (entry.discovering > 0)
+        return void (entry.dirty = true);
     if (entry.timer !== undefined)
-        return;
-    const maxDelayMs = Math.min(...entry.delays.keys());
-    if (maxDelayMs <= 0)
-        return invalidateEntry(entry);
-    entry.timer = setTimeout(() => invalidateEntry(entry), maxDelayMs);
+        clearTimeout(entry.timer);
+    invalidateEntry(entry);
 };
-const dispatch = (writes) => {
+const receive = (writes) => {
     if (!DataDependencies.isNonEmpty(writes))
         return;
-    for (const entry of entries.values()) {
-        if (DataDependencies.intersects(entry.reads(), writes))
+    forEachCurrent((entry) => {
+        if (entry.discovering > 0)
+            entry.buffered = DataDependencies.merge(entry.buffered, writes);
+        else if (DataDependencies.intersects(entry.reads(), writes))
             schedule(entry);
-    }
+    });
 };
-const receive = (writes) => {
-    if (discovering > 0) {
-        bufferedWrites = DataDependencies.merge(bufferedWrites, writes);
+const reset = () => {
+    forEachCurrent((entry) => {
+        if (entry.discovering > 0)
+            entry.dirty = true;
+        else if (DataDependencies.isNonEmpty(entry.reads()))
+            schedule(entry);
+    });
+};
+const settle = (current, outcome) => {
+    if (observation === current)
+        observation = undefined;
+    if (current.epoch !== epoch)
         return;
+    const waiters = Array.from(current.waiters);
+    current.waiters.clear();
+    for (const f of waiters)
+        f(outcome);
+};
+const observeReady = (waiter) => {
+    let current = observation;
+    if (current === undefined || current.epoch !== epoch) {
+        const started = { epoch, waiters: new Set([waiter]) };
+        current = observation = started;
+        // the waiter is attached first: `ready()` may reconfigure synchronously
+        let ready;
+        try {
+            ready = source?.ready() ?? Promise.resolve();
+        }
+        catch (error) {
+            ready = Promise.reject(error);
+        }
+        ready.then(() => settle(started, { _tag: "ready" }), (error) => settle(started, { _tag: "failed", error }));
+    }
+    else {
+        current.waiters.add(waiter);
     }
-    dispatch(writes);
+    const observed = current;
+    return () => observed.waiters.delete(waiter);
 };
-const reset = () => {
-    bufferedWrites = DataDependencies.empty();
-    for (const entry of entries.values()) {
-        if (DataDependencies.isNonEmpty(entry.reads()))
-            schedule(entry);
+/** Whether the current source became ready before being replaced; rejects with its error or on abort. */
+const readyOnce = (signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted === true)
+        return reject(signal.reason);
+    if (source === undefined)
+        return resolve(true);
+    let detach;
+    let aborted = false;
+    const onAbort = () => {
+        aborted = true;
+        detach?.();
+        reject(signal?.reason);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    // `ready()` may abort synchronously, before `detach` exists
+    detach = observeReady((outcome) => {
+        signal?.removeEventListener("abort", onAbort);
+        if (outcome._tag === "failed")
+            reject(outcome.error);
+        else
+            resolve(outcome._tag === "ready");
+    });
+    if (aborted)
+        detach();
+});
+/** Resolves with the epoch whose readiness was observed; a reconfigured source supersedes the wait. */
+const waitReady = async (signal) => {
+    const target = epoch;
+    let ready;
+    try {
+        ready = await readyOnce(signal);
     }
+    catch (error) {
+        // a reconfiguration can run between settlement and this continuation
+        if (epoch === target || signal?.aborted === true)
+            throw error;
+        return waitReady(signal);
+    }
+    return ready && epoch === target ? target : waitReady(signal);
+};
+const cancelCatchUp = (entry) => {
+    entry.catchUp?.abort();
+    entry.catchUp = undefined;
+};
+// a reconfigured source restarts it; a live fetch or unregistering cancels it
+const catchUp = (entry) => {
+    cancelCatchUp(entry);
+    if (source === undefined)
+        return;
+    const target = epoch;
+    const controller = new AbortController();
+    entry.catchUp = controller;
+    readyOnce(controller.signal).then((ready) => {
+        if (entry.catchUp === controller)
+            entry.catchUp = undefined;
+        if (!ready || epoch !== target || !isCurrent(entry))
+            return;
+        if (entry.awaitingReady === 0 && entry.coveredEpoch !== target)
+            invalidateNow(entry);
+    }, () => { });
+};
+const unsubscribeNow = () => {
+    const current = unsubscribe;
+    unsubscribe = undefined;
+    current?.();
 };
 const ensureSubscribed = () => {
-    if (unsubscribe === undefined && source !== undefined && entries.size > 0) {
-        unsubscribe = source.subscribe(receive, reset);
+    if (unsubscribe !== undefined || subscribing || source === undefined || MutableHashMap.size(entries) === 0)
+        return;
+    const target = epoch;
+    const active = () => epoch === target;
+    subscribing = true;
+    let handle;
+    try {
+        handle = source.subscribe((writes) => {
+            if (active())
+                receive(writes);
+        }, () => {
+            if (active())
+                reset();
+        });
+    }
+    finally {
+        subscribing = false;
+    }
+    if (!active() || MutableHashMap.size(entries) === 0) {
+        handle();
+        return ensureSubscribed();
     }
+    unsubscribe = handle;
 };
 export const configureLiveQueryInvalidation = (next) => {
-    unsubscribe?.();
-    unsubscribe = undefined;
+    unsubscribeNow();
     source = next;
+    epoch++;
+    const previous = observation;
+    observation = undefined;
+    if (previous !== undefined) {
+        const waiters = Array.from(previous.waiters);
+        previous.waiters.clear();
+        for (const f of waiters)
+            f({ _tag: "switched" });
+    }
     ensureSubscribed();
+    forEachCurrent(catchUp);
 };
 export const registerLiveQuery = (key, reads, options) => {
-    const hash = Hash.hash(key);
     const delay = options.maxDelayMs ?? 0;
-    const current = entries.get(hash);
-    if (current !== undefined) {
-        current.observers++;
-        current.delays.set(delay, (current.delays.get(delay) ?? 0) + 1);
+    let entry = Option.getOrUndefined(MutableHashMap.get(entries, key));
+    if (entry !== undefined) {
+        entry.observers++;
+        entry.delays.set(delay, (entry.delays.get(delay) ?? 0) + 1);
+        if (entry.timer !== undefined)
+            arm(entry);
     }
     else {
-        entries.set(hash, {
+        entry = {
             key,
             reads,
             observers: 1,
             delays: new Map([[delay, 1]]),
-            timer: undefined
-        });
+            timer: undefined,
+            firstWriteAt: 0,
+            deadline: 0,
+            discovering: 0,
+            awaitingReady: 0,
+            buffered: DataDependencies.empty(),
+            dirty: false,
+            coveredEpoch: -1,
+            catchUp: undefined
+        };
+        MutableHashMap.set(entries, key, entry);
+        ensureSubscribed();
+        // writes missed while unsubscribed (cached result, or a fetch that started before this registration)
+        catchUp(entry);
     }
-    ensureSubscribed();
+    const registered = entry;
+    let active = true;
     return () => {
-        const entry = entries.get(hash);
-        if (entry === undefined)
+        if (!active)
             return;
-        const delayObservers = entry.delays.get(delay) ?? 0;
+        active = false;
+        const delayObservers = registered.delays.get(delay) ?? 0;
         if (delayObservers <= 1)
-            entry.delays.delete(delay);
+            registered.delays.delete(delay);
         else
-            entry.delays.set(delay, delayObservers - 1);
-        if (--entry.observers > 0)
+            registered.delays.set(delay, delayObservers - 1);
+        if (--registered.observers > 0)
             return;
-        if (entry.timer !== undefined)
-            clearTimeout(entry.timer);
-        entries.delete(hash);
-        if (entries.size === 0) {
-            unsubscribe?.();
-            unsubscribe = undefined;
-            bufferedWrites = DataDependencies.empty();
-        }
+        if (registered.timer !== undefined)
+            clearTimeout(registered.timer);
+        registered.timer = undefined;
+        cancelCatchUp(registered);
+        if (isCurrent(registered))
+            MutableHashMap.remove(entries, key);
+        if (MutableHashMap.size(entries) === 0)
+            unsubscribeNow();
     };
 };
+/** Synchronously starts a live fetch for a registered key; release it with `releaseLiveQueryFetch` on every exit. */
+export const acquireLiveQueryFetch = (key) => {
+    const entry = Option.getOrUndefined(MutableHashMap.get(entries, key));
+    if (entry === undefined || source === undefined)
+        return undefined;
+    entry.discovering++;
+    entry.awaitingReady++;
+    // this fetch awaits readiness itself, covering the epoch the catch-up was waiting for
+    cancelCatchUp(entry);
+    const fetch = { key };
+    fetches.set(fetch, { entry, awaiting: true, released: false });
+    return fetch;
+};
+const stopAwaiting = (state) => {
+    if (!state.awaiting)
+        return;
+    state.awaiting = false;
+    state.entry.awaitingReady--;
+};
+/** Waits until writes after this point reach the fetch; abort to stop waiting. */
+export const awaitLiveQueryFetch = async (fetch, signal) => {
+    const state = fetches.get(fetch);
+    if (state === undefined || state.released)
+        return;
+    try {
+        // every `await` is a gap in which the source can be switched: only settle for a still-current epoch
+        for (;;) {
+            const target = epoch;
+            let ready;
+            try {
+                ready = await waitReady(signal);
+            }
+            catch (error) {
+                if (signal?.aborted === true || epoch === target)
+                    throw error;
+                continue;
+            }
+            if (ready !== epoch)
+                continue;
+            state.entry.coveredEpoch = Math.max(state.entry.coveredEpoch, ready);
+            break;
+        }
+    }
+    finally {
+        stopAwaiting(state);
+    }
+};
+export const releaseLiveQueryFetch = (fetch) => {
+    const state = fetches.get(fetch);
+    if (state === undefined || state.released)
+        return;
+    state.released = true;
+    stopAwaiting(state);
+    state.entry.discovering--;
+    finishDiscovery(state.entry);
+};
+const finishDiscovery = (entry) => {
+    if (entry.discovering > 0 || !isCurrent(entry))
+        return;
+    const { buffered, dirty } = entry;
+    entry.buffered = DataDependencies.empty();
+    entry.dirty = false;
+    if (dirty || DataDependencies.intersects(entry.reads(), buffered))
+        schedule(entry);
+};
+/** Waits for the current source; a reconfigured source supersedes a pending wait on the previous one. */
+export const liveQueryReady = async () => {
+    for (;;) {
+        const target = epoch;
+        try {
+            if (await waitReady() === epoch)
+                return;
+        }
+        catch (error) {
+            if (epoch === target)
+                throw error;
+        }
+    }
+};
+// Boolean callers cannot say which fetch ended: their entries keep buffering until every legacy fetch has
+// ended. Other queries are unaffected; bookkeeping is per entry, not per call.
+const legacyEntries = new Map();
+let legacyDiscovering = 0;
+/** @deprecated Waits for all concurrent legacy fetches; use `acquireLiveQueryFetch` + `awaitLiveQueryFetch`. */
 export const beginLiveQueryFetch = async (key) => {
-    if (!entries.has(Hash.hash(key)) || source === undefined)
+    const fetch = acquireLiveQueryFetch(key);
+    const state = fetch && fetches.get(fetch);
+    if (fetch === undefined || state === undefined)
         return false;
-    discovering++;
+    // hand the discovery count over to the legacy barrier
+    state.released = true;
+    legacyDiscovering++;
+    legacyEntries.set(state.entry, (legacyEntries.get(state.entry) ?? 0) + 1);
     try {
-        await source.ready();
-        return true;
+        for (;;) {
+            const target = epoch;
+            let ready;
+            try {
+                ready = await waitReady();
+            }
+            catch (error) {
+                if (epoch === target)
+                    throw error;
+                continue;
+            }
+            if (ready !== epoch)
+                continue;
+            state.entry.coveredEpoch = Math.max(state.entry.coveredEpoch, ready);
+            break;
+        }
     }
     catch (error) {
-        discovering--;
+        endLiveQueryFetch(true);
         throw error;
     }
+    finally {
+        stopAwaiting(state);
+    }
+    return true;
 };
+/** @deprecated Pairs with `beginLiveQueryFetch`; use `releaseLiveQueryFetch`. */
 export const endLiveQueryFetch = (wasLive) => {
-    if (!wasLive)
+    if (!wasLive || legacyDiscovering === 0 || --legacyDiscovering > 0)
         return;
-    discovering = Math.max(0, discovering - 1);
-    if (discovering > 0 || !DataDependencies.isNonEmpty(bufferedWrites))
-        return;
-    const writes = bufferedWrites;
-    bufferedWrites = DataDependencies.empty();
-    dispatch(writes);
+    const ended = Array.from(legacyEntries);
+    legacyEntries.clear();
+    for (const [entry, count] of ended) {
+        entry.discovering -= count;
+        finishDiscovery(entry);
+    }
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGl2ZVF1ZXJ5SW52YWxpZGF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2xpdmVRdWVyeUludmFsaWRhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQTtBQUNwRCxPQUFPLEtBQUssSUFBSSxNQUFNLGFBQWEsQ0FBQTtBQXlCbkMsTUFBTSxPQUFPLEdBQUcsSUFBSSxHQUFHLEVBQTBCLENBQUE7QUFDakQsSUFBSSxNQUErQyxDQUFBO0FBQ25ELElBQUksV0FBcUMsQ0FBQTtBQUN6QyxJQUFJLFdBQVcsR0FBRyxDQUFDLENBQUE7QUFDbkIsSUFBSSxjQUFjLEdBQUcsZ0JBQWdCLENBQUMsS0FBSyxFQUFFLENBQUE7QUFFN0MsTUFBTSxlQUFlLEdBQUcsQ0FBQyxLQUFxQixFQUFFLEVBQUU7SUFDaEQsS0FBSyxDQUFDLEtBQUssR0FBRyxTQUFTLENBQUE7SUFDdkIsTUFBTSxFQUFFLFVBQVUsQ0FBQyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFBO0FBQ2pDLENBQUMsQ0FBQTtBQUVELE1BQU0sUUFBUSxHQUFHLENBQUMsS0FBcUIsRUFBRSxFQUFFO0lBQ3pDLElBQUksS0FBSyxDQUFDLEtBQUssS0FBSyxTQUFTO1FBQUUsT0FBTTtJQUNyQyxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsS0FBSyxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFBO0lBQ25ELElBQUksVUFBVSxJQUFJLENBQUM7UUFBRSxPQUFPLGVBQWUsQ0FBQyxLQUFLLENBQUMsQ0FBQTtJQUNsRCxLQUFLLENBQUMsS0FBSyxHQUFHLFVBQVUsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxlQUFlLENBQUMsS0FBSyxDQUFDLEVBQUUsVUFBVSxDQUFDLENBQUE7QUFDcEUsQ0FBQyxDQUFBO0FBRUQsTUFBTSxRQUFRLEdBQUcsQ0FBQyxNQUF5QyxFQUFFLEVBQUU7SUFDN0QsSUFBSSxDQUFDLGdCQUFnQixDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUM7UUFBRSxPQUFNO0lBQ2hELEtBQUssTUFBTSxLQUFLLElBQUksT0FBTyxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQUM7UUFDckMsSUFBSSxnQkFBZ0IsQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLEtBQUssRUFBRSxFQUFFLE1BQU0sQ0FBQztZQUFFLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQTtJQUN6RSxDQUFDO0FBQ0gsQ0FBQyxDQUFBO0FBRUQsTUFBTSxPQUFPLEdBQUcsQ0FBQyxNQUF5QyxFQUFFLEVBQUU7SUFDNUQsSUFBSSxXQUFXLEdBQUcsQ0FBQyxFQUFFLENBQUM7UUFDcEIsY0FBYyxHQUFHLGdCQUFnQixDQUFDLEtBQUssQ0FBQyxjQUFjLEVBQUUsTUFBTSxDQUFDLENBQUE7UUFDL0QsT0FBTTtJQUNSLENBQUM7SUFDRCxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUE7QUFDbEIsQ0FBQyxDQUFBO0FBRUQsTUFBTSxLQUFLLEdBQUcsR0FBRyxFQUFFO0lBQ2pCLGNBQWMsR0FBRyxnQkFBZ0IsQ0FBQyxLQUFLLEVBQUUsQ0FBQTtJQUN6QyxLQUFLLE1BQU0sS0FBSyxJQUFJLE9BQU8sQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDO1FBQ3JDLElBQUksZ0JBQWdCLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUFFLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQTtJQUNqRSxDQUFDO0FBQ0gsQ0FBQyxDQUFBO0FBRUQsTUFBTSxnQkFBZ0IsR0FBRyxHQUFHLEVBQUU7SUFDNUIsSUFBSSxXQUFXLEtBQUssU0FBUyxJQUFJLE1BQU0sS0FBSyxTQUFTLElBQUksT0FBTyxDQUFDLElBQUksR0FBRyxDQUFDLEVBQUUsQ0FBQztRQUMxRSxXQUFXLEdBQUcsTUFBTSxDQUFDLFNBQVMsQ0FBQyxPQUFPLEVBQUUsS0FBSyxDQUFDLENBQUE7SUFDaEQsQ0FBQztBQUNILENBQUMsQ0FBQTtBQUVELE1BQU0sQ0FBQyxNQUFNLDhCQUE4QixHQUFHLENBQUMsSUFBaUMsRUFBRSxFQUFFO0lBQ2xGLFdBQVcsRUFBRSxFQUFFLENBQUE7SUFDZixXQUFXLEdBQUcsU0FBUyxDQUFBO0lBQ3ZCLE1BQU0sR0FBRyxJQUFJLENBQUE7SUFDYixnQkFBZ0IsRUFBRSxDQUFBO0FBQ3BCLENBQUMsQ0FBQTtBQUVELE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHLENBQy9CLEdBQTJCLEVBQzNCLEtBQThDLEVBQzlDLE9BQXlCLEVBQ3pCLEVBQUU7SUFDRixNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFBO0lBQzNCLE1BQU0sS0FBSyxHQUFHLE9BQU8sQ0FBQyxVQUFVLElBQUksQ0FBQyxDQUFBO0lBQ3JDLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUE7SUFDakMsSUFBSSxPQUFPLEtBQUssU0FBUyxFQUFFLENBQUM7UUFDMUIsT0FBTyxDQUFDLFNBQVMsRUFBRSxDQUFBO1FBQ25CLE9BQU8sQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLEtBQUssRUFBRSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFBO0lBQ2pFLENBQUM7U0FBTSxDQUFDO1FBQ04sT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLEVBQUU7WUFDaEIsR0FBRztZQUNILEtBQUs7WUFDTCxTQUFTLEVBQUUsQ0FBQztZQUNaLE1BQU0sRUFBRSxJQUFJLEdBQUcsQ0FBQyxDQUFDLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDN0IsS0FBSyxFQUFFLFNBQVM7U0FDakIsQ0FBQyxDQUFBO0lBQ0osQ0FBQztJQUNELGdCQUFnQixFQUFFLENBQUE7SUFFbEIsT0FBTyxHQUFHLEVBQUU7UUFDVixNQUFNLEtBQUssR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFBO1FBQy9CLElBQUksS0FBSyxLQUFLLFNBQVM7WUFBRSxPQUFNO1FBQy9CLE1BQU0sY0FBYyxHQUFHLEtBQUssQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQTtRQUNuRCxJQUFJLGNBQWMsSUFBSSxDQUFDO1lBQUUsS0FBSyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUE7O1lBQzlDLEtBQUssQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLEtBQUssRUFBRSxjQUFjLEdBQUcsQ0FBQyxDQUFDLENBQUE7UUFDaEQsSUFBSSxFQUFFLEtBQUssQ0FBQyxTQUFTLEdBQUcsQ0FBQztZQUFFLE9BQU07UUFDakMsSUFBSSxLQUFLLENBQUMsS0FBSyxLQUFLLFNBQVM7WUFBRSxZQUFZLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFBO1FBQ3hELE9BQU8sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUE7UUFDcEIsSUFBSSxPQUFPLENBQUMsSUFBSSxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQ3ZCLFdBQVcsRUFBRSxFQUFFLENBQUE7WUFDZixXQUFXLEdBQUcsU0FBUyxDQUFBO1lBQ3ZCLGNBQWMsR0FBRyxnQkFBZ0IsQ0FBQyxLQUFLLEVBQUUsQ0FBQTtRQUMzQyxDQUFDO0lBQ0gsQ0FBQyxDQUFBO0FBQ0gsQ0FBQyxDQUFBO0FBRUQsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsS0FBSyxFQUFFLEdBQTJCLEVBQUUsRUFBRTtJQUN2RSxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksTUFBTSxLQUFLLFNBQVM7UUFBRSxPQUFPLEtBQUssQ0FBQTtJQUN0RSxXQUFXLEVBQUUsQ0FBQTtJQUNiLElBQUksQ0FBQztRQUNILE1BQU0sTUFBTSxDQUFDLEtBQUssRUFBRSxDQUFBO1FBQ3BCLE9BQU8sSUFBSSxDQUFBO0lBQ2IsQ0FBQztJQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7UUFDZixXQUFXLEVBQUUsQ0FBQTtRQUNiLE1BQU0sS0FBSyxDQUFBO0lBQ2IsQ0FBQztBQUNILENBQUMsQ0FBQTtBQUVELE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHLENBQUMsT0FBZ0IsRUFBRSxFQUFFO0lBQ3BELElBQUksQ0FBQyxPQUFPO1FBQUUsT0FBTTtJQUNwQixXQUFXLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsV0FBVyxHQUFHLENBQUMsQ0FBQyxDQUFBO0lBQzFDLElBQUksV0FBVyxHQUFHLENBQUMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLFVBQVUsQ0FBQyxjQUFjLENBQUM7UUFBRSxPQUFNO0lBQzNFLE1BQU0sTUFBTSxHQUFHLGNBQWMsQ0FBQTtJQUM3QixjQUFjLEdBQUcsZ0JBQWdCLENBQUMsS0FBSyxFQUFFLENBQUE7SUFDekMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFBO0FBQ2xCLENBQUMsQ0FBQSJ9
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"liveQueryInvalidation.js","sourceRoot":"","sources":["../src/liveQueryInvalidation.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue",
-  "version": "4.0.4",
+  "version": "4.0.6",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -15,7 +15,7 @@
     "@vueuse/core": "^14.3.0",
     "change-case": "^5.4.4",
     "query-string": "^9.4.0",
-    "effect-app": "4.0.4"
+    "effect-app": "4.0.6"
   },
   "peerDependencies": {
     "@effect/atom-vue": "^4.0.6",