@legendapp/state 2.1.2 → 2.2.0-next.10

package/index.mjs

@@ -1,3 +1,5 @@
+import { noop } from '@babel/types';
+
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 function isArray(obj) {
     return Array.isArray(obj);
@@ -53,14 +55,25 @@ const symbolGetNode = Symbol('getNode');
 const symbolDelete = /* @__PURE__ */ Symbol('delete');
 const symbolOpaque = Symbol('opaque');
 const optimized = Symbol('optimized');
+const symbolActivated = Symbol('activated');
 // TODOV3 Remove these
 const extraPrimitiveActivators = new Map();
 const extraPrimitiveProps = new Map();
 const globalState = {
     isLoadingLocal: false,
-    isLoadingRemote: false,
     isMerging: false,
+    isLoadingRemote$: undefined,
+    activateNode: undefined,
+    pendingNodes: new Map(),
+    dirtyNodes: new Set(),
 };
+function isObservable(obs) {
+    return !!obs && !!obs[symbolGetNode];
+}
+function isComputed(obs) {
+    var _a;
+    return obs && ((_a = obs[symbolGetNode]) === null || _a === void 0 ? void 0 : _a.isComputed);
+}
 function checkActivate(node) {
     var _a;
     const root = node.root;
@@ -87,12 +100,13 @@ function setNodeValue(node, newValue) {
     const prevValue = parentValue[key];
     const isFunc = isFunction(newValue);
     // Compute newValue if newValue is a function or an observable
-    newValue =
-        !parentNode.isAssigning && isFunc
-            ? newValue(prevValue)
-            : isObject(newValue) && (newValue === null || newValue === void 0 ? void 0 : newValue[symbolGetNode])
-                ? newValue.peek()
-                : newValue;
+    newValue = !parentNode.isAssigning && isFunc ? newValue(prevValue) : newValue;
+    // If setting an observable, set a link to the observable instead
+    if (isObservable(newValue) && !isComputed(newValue)) {
+        const val = newValue;
+        node.lazy = () => val;
+        newValue = undefined;
+    }
     try {
         parentNode.isSetting = (parentNode.isSetting || 0) + 1;
         // Save the new value
@@ -126,7 +140,13 @@ function getNodeValue(node) {
     }
     return child;
 }
-function getChildNode(node, key) {
+const cloneFunction = (originalFunction) => {
+    const length = originalFunction.length;
+    return length > 1
+        ? (arg1, arg2) => originalFunction(arg1, arg2)
+        : (...args) => originalFunction(...args);
+};
+function getChildNode(node, key, asFunction) {
     var _a;
     // Get the child by key
     let child = (_a = node.children) === null || _a === void 0 ? void 0 : _a.get(key);
@@ -138,6 +158,20 @@ function getChildNode(node, key) {
             key,
             lazy: true,
         };
+        if (asFunction) {
+            child = Object.assign(cloneFunction(asFunction), child);
+        }
+        else {
+            if (node.activationState) {
+                const { lookup } = node.activationState;
+                if (lookup) {
+                    child = Object.assign(lookup.bind(node, key), child);
+                    if (isFunction(child)) {
+                        extractFunction(node, key, child);
+                    }
+                }
+            }
+        }
         if (!node.children) {
             node.children = new Map();
         }
@@ -159,6 +193,7 @@ function ensureNodeValue(node) {
     return value;
 }
 function findIDKey(obj, node) {
+    var _a, _b;
     let idKey = isObject(obj)
         ? 'id' in obj
             ? 'id'
@@ -171,7 +206,8 @@ function findIDKey(obj, node) {
                         : undefined
         : undefined;
     if (!idKey && node.parent) {
-        const keyExtractor = getNodeValue(node.parent)[node.key + '_keyExtractor'];
+        const k = node.key + '_keyExtractor';
+        const keyExtractor = (_b = (_a = node.functions) === null || _a === void 0 ? void 0 : _a.get(k)) !== null && _b !== void 0 ? _b : getNodeValue(node.parent)[node.key + '_keyExtractor'];
         if (keyExtractor && isFunction(keyExtractor)) {
             idKey = keyExtractor;
         }
@@ -179,9 +215,11 @@ function findIDKey(obj, node) {
     return idKey;
 }
 function extractFunction(node, key, fnOrComputed, computedChildNode) {
+    var _a;
     if (!node.functions) {
         node.functions = new Map();
     }
+    (_a = node.children) === null || _a === void 0 ? void 0 : _a.delete(key);
     node.functions.set(key, fnOrComputed);
     if (computedChildNode) {
         computedChildNode.parentOther = getChildNode(node, key);
@@ -192,226 +230,10 @@ function extractFunction(node, key, fnOrComputed, computedChildNode) {
     }
 }
 
-function isObservable(obs) {
-    return obs && !!obs[symbolGetNode];
-}
-function isEvent(obs) {
-    var _a;
-    return obs && ((_a = obs[symbolGetNode]) === null || _a === void 0 ? void 0 : _a.isEvent);
-}
-function computeSelector(selector, e, retainObservable) {
-    let c = selector;
-    if (isFunction(c)) {
-        c = e ? c(e) : c();
-    }
-    return isObservable(c) && !retainObservable ? c.get() : c;
-}
-function getObservableIndex(obs) {
-    const node = getNode(obs);
-    const n = +node.key;
-    return n - n < 1 ? +n : -1;
-}
-function opaqueObject(value) {
-    if (value) {
-        value[symbolOpaque] = true;
-    }
-    return value;
-}
-function lockObservable(obs, value) {
-    var _a;
-    const root = (_a = getNode(obs)) === null || _a === void 0 ? void 0 : _a.root;
-    if (root) {
-        root.locked = value;
-    }
-}
-function setAtPath(obj, path, pathTypes, value, fullObj, restore) {
-    let o = obj;
-    let oFull = fullObj;
-    if (path.length > 0) {
-        for (let i = 0; i < path.length; i++) {
-            const p = path[i];
-            if (i === path.length - 1) {
-                // Don't set if the value is the same. This prevents creating a new key
-                // when setting undefined on an object without this key
-                if (o[p] !== value) {
-                    o[p] = value;
-                }
-            }
-            else if (o[p] === symbolDelete) {
-                // If this was previously deleted, restore it
-                if (oFull) {
-                    o[p] = oFull[p];
-                    restore === null || restore === void 0 ? void 0 : restore(path.slice(0, i + 1), o[p]);
-                }
-                break;
-            }
-            else if (o[p] === undefined || o[p] === null) {
-                o[p] = initializePathType(pathTypes[i]);
-            }
-            o = o[p];
-            if (oFull) {
-                oFull = oFull[p];
-            }
-        }
-    }
-    else {
-        obj = value;
-    }
-    return obj;
-}
-function setInObservableAtPath(obs, path, pathTypes, value, mode) {
-    let o = obs;
-    let v = value;
-    for (let i = 0; i < path.length; i++) {
-        const p = path[i];
-        if (!o.peek()[p]) {
-            o[p].set(initializePathType(pathTypes[i]));
-        }
-        o = o[p];
-        v = v[p];
-    }
-    if (v === symbolDelete) {
-        o.delete();
-    }
-    // Assign if possible, or set otherwise
-    else if (mode === 'assign' && o.assign && isObject(o.peek())) {
-        o.assign(v);
-    }
-    else {
-        o.set(v);
-    }
-}
-function mergeIntoObservable(target, ...sources) {
-    beginBatch();
-    globalState.isMerging = true;
-    for (let i = 0; i < sources.length; i++) {
-        target = _mergeIntoObservable(target, sources[i]);
-    }
-    globalState.isMerging = false;
-    endBatch();
-    return target;
-}
-function _mergeIntoObservable(target, source) {
-    var _a;
-    const needsSet = isObservable(target);
-    const targetValue = needsSet ? target.peek() : target;
-    const isTargetArr = isArray(targetValue);
-    const isTargetObj = !isTargetArr && isObject(targetValue);
-    if ((isTargetObj && isObject(source) && !isEmpty(targetValue)) ||
-        (isTargetArr && isArray(source) && targetValue.length > 0)) {
-        const keys = Object.keys(source);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            const sourceValue = source[key];
-            if (sourceValue === symbolDelete) {
-                needsSet && ((_a = target[key]) === null || _a === void 0 ? void 0 : _a.delete) ? target[key].delete() : delete target[key];
-            }
-            else {
-                const isObj = isObject(sourceValue);
-                const isArr = !isObj && isArray(sourceValue);
-                const targetChild = target[key];
-                if ((isObj || isArr) && targetChild && (needsSet || !isEmpty(targetChild))) {
-                    if (!needsSet && (!targetChild || (isObj ? !isObject(targetChild) : !isArray(targetChild)))) {
-                        target[key] = sourceValue;
-                    }
-                    else {
-                        _mergeIntoObservable(targetChild, sourceValue);
-                    }
-                }
-                else {
-                    needsSet
-                        ? targetChild.set(sourceValue)
-                        : (target[key] = sourceValue);
-                }
-            }
-        }
-    }
-    else if (source !== undefined) {
-        needsSet ? target.set(source) : (target = source);
-    }
-    return target;
-}
-function constructObjectWithPath(path, pathTypes, value) {
-    let out;
-    if (path.length > 0) {
-        let o = (out = {});
-        for (let i = 0; i < path.length; i++) {
-            const p = path[i];
-            o[p] = i === path.length - 1 ? value : initializePathType(pathTypes[i]);
-            o = o[p];
-        }
-    }
-    else {
-        out = value;
-    }
-    return out;
-}
-function deconstructObjectWithPath(path, pathTypes, value) {
-    let o = value;
-    for (let i = 0; i < path.length; i++) {
-        const p = path[i];
-        o = o ? o[p] : initializePathType(pathTypes[i]);
-    }
-    return o;
-}
-function isObservableValueReady(value) {
-    return !!value && ((!isObject(value) && !isArray(value)) || !isEmpty(value));
-}
-function setSilently(obs, newValue) {
-    const node = getNode(obs);
-    return setNodeValue(node, newValue).newValue;
-}
-function getPathType(value) {
-    return isArray(value) ? 'array' : value instanceof Map ? 'map' : value instanceof Set ? 'set' : 'object';
-}
-function initializePathType(pathType) {
-    switch (pathType) {
-        case 'array':
-            return [];
-        case 'object':
-            return {};
-        case 'map':
-            return new Map();
-        case 'set':
-            return new Set();
-    }
-}
-function replacer(_, value) {
-    if (value instanceof Map) {
-        return {
-            __LSType: 'Map',
-            value: Array.from(value.entries()), // or with spread: value: [...value]
-        };
-    }
-    else if (value instanceof Set) {
-        return {
-            __LSType: 'Set',
-            value: Array.from(value), // or with spread: value: [...value]
-        };
-    }
-    else {
-        return value;
-    }
-}
-function reviver(_, value) {
-    if (typeof value === 'object' && value) {
-        if (value.__LSType === 'Map') {
-            return new Map(value.value);
-        }
-        else if (value.__LSType === 'Set') {
-            return new Set(value.value);
-        }
-    }
-    return value;
-}
-function safeStringify(value) {
-    return JSON.stringify(value, replacer);
-}
-function safeParse(value) {
-    return JSON.parse(value, reviver);
-}
-function clone(value) {
-    return safeParse(safeStringify(value));
+function activated(params) {
+    return (() => ({
+        [symbolActivated]: params,
+    }));
 }
 
 let timeout;
@@ -439,28 +261,22 @@ function isArraySubset(mainArr, subsetArr) {
 }
 function createPreviousHandlerInner(value, changes) {
     // Clones the current state and inject the previous data at the changed path
-    let cloned = value ? clone(value) : {};
+    let clone = value ? JSON.parse(JSON.stringify(value)) : {};
     for (let i = 0; i < changes.length; i++) {
         const { path, prevAtPath } = changes[i];
-        let o = cloned;
+        let o = clone;
         if (path.length > 0) {
             let i;
             for (i = 0; i < path.length - 1; i++) {
                 o = o[path[i]];
             }
-            const key = path[i];
-            if (o instanceof Map) {
-                o.set(key, prevAtPath);
-            }
-            else {
-                o[key] = prevAtPath;
-            }
+            o[path[i]] = prevAtPath;
         }
         else {
-            cloned = prevAtPath;
+            clone = prevAtPath;
         }
     }
-    return cloned;
+    return clone;
 }
 function createPreviousHandler(value, changes) {
     // Create a function that generates the previous state
@@ -530,7 +346,7 @@ function computeChangesRecursive(changesInBatch, node, value, path, pathTypes, v
         const parent = node.parent;
         if (parent) {
             const parentValue = getNodeValue(parent);
-            computeChangesRecursive(changesInBatch, parent, parentValue, [node.key].concat(path), [getPathType(value)].concat(pathTypes), valueAtPath, prevAtPath, immediate, level + 1, whenOptimizedOnlyIf);
+            computeChangesRecursive(changesInBatch, parent, parentValue, [node.key].concat(path), [(isArray(value) ? 'array' : 'object')].concat(pathTypes), valueAtPath, prevAtPath, immediate, level + 1, whenOptimizedOnlyIf);
         }
     }
 }
@@ -569,6 +385,13 @@ function batchNotifyChanges(changesInBatch, immediate) {
     });
 }
 function runBatch() {
+    const dirtyNodes = Array.from(globalState.dirtyNodes);
+    globalState.dirtyNodes.clear();
+    dirtyNodes.forEach((node) => {
+        var _a;
+        (_a = node.dirtyFn) === null || _a === void 0 ? void 0 : _a.call(node);
+        node.dirtyFn = undefined;
+    });
     // Save batch locally and reset _batchMap first because a new batch could begin while looping over callbacks.
     // This can happen with observableComputed for example.
     const map = _batchMap;
@@ -655,68 +478,261 @@ function endBatch(force) {
     }
 }
 
-function createObservable(value, makePrimitive, createObject, createPrimitive) {
+function createObservable(value, makePrimitive, extractPromise, createObject, createPrimitive) {
     const valueIsPromise = isPromise(value);
+    const valueIsFunction = isFunction(value);
     const root = {
         _: value,
     };
-    const node = {
+    let node = {
         root,
         lazy: true,
     };
+    if (valueIsFunction) {
+        node = Object.assign(cloneFunction(value), node);
+    }
     const prim = makePrimitive || isActualPrimitive(value);
     const obs = prim
         ? new createPrimitive(node)
         : createObject(node);
     if (valueIsPromise) {
+        setNodeValue(node, undefined);
         extractPromise(node, value);
     }
     return obs;
 }
 
-function onChange(node, callback, options = {}) {
-    const { initial, immediate, noArgs } = options;
-    const { trackingType } = options;
-    let listeners = immediate ? node.listenersImmediate : node.listeners;
-    if (!listeners) {
-        listeners = new Set();
-        if (immediate) {
-            node.listenersImmediate = listeners;
-        }
-        else {
-            node.listeners = listeners;
-        }
+function isEvent(obs) {
+    var _a;
+    return obs && ((_a = obs[symbolGetNode]) === null || _a === void 0 ? void 0 : _a.isEvent);
+}
+function computeSelector(selector, e, retainObservable) {
+    let c = selector;
+    if (!isObservable(c) && isFunction(c)) {
+        c = e ? c(e) : c();
     }
-    checkActivate(node);
-    const listener = {
-        listener: callback,
-        track: trackingType,
-        noArgs,
-    };
-    listeners.add(listener);
-    if (initial) {
-        const value = getNodeValue(node);
-        callback({
-            value,
-            changes: [
-                {
-                    path: [],
-                    pathTypes: [],
-                    prevAtPath: value,
-                    valueAtPath: value,
-                },
-            ],
-            getPrevious: () => undefined,
-        });
+    return isObservable(c) && !retainObservable ? c.get() : c;
+}
+function getObservableIndex(obs) {
+    const node = getNode(obs);
+    const n = +node.key;
+    return n - n < 1 ? +n : -1;
+}
+function opaqueObject(value) {
+    if (value) {
+        value[symbolOpaque] = true;
     }
-    return () => listeners.delete(listener);
+    return value;
 }
-
-let trackCount = 0;
-const trackingQueue = [];
-const tracking = {
-    current: undefined,
-};
+function lockObservable(obs, value) {
+    var _a;
+    const root = (_a = getNode(obs)) === null || _a === void 0 ? void 0 : _a.root;
+    if (root) {
+        root.locked = value;
+    }
+}
+function setAtPath(obj, path, pathTypes, value, fullObj, restore) {
+    let o = obj;
+    let oFull = fullObj;
+    if (path.length > 0) {
+        for (let i = 0; i < path.length; i++) {
+            const p = path[i];
+            if (i === path.length - 1) {
+                // Don't set if the value is the same. This prevents creating a new key
+                // when setting undefined on an object without this key
+                if (o[p] !== value) {
+                    o[p] = value;
+                }
+            }
+            else if (o[p] === symbolDelete) {
+                // If this was previously deleted, restore it
+                if (oFull) {
+                    o[p] = oFull[p];
+                    restore === null || restore === void 0 ? void 0 : restore(path.slice(0, i + 1), o[p]);
+                }
+                break;
+            }
+            else if (o[p] === undefined || o[p] === null) {
+                o[p] = pathTypes[i] === 'array' ? [] : {};
+            }
+            o = o[p];
+            if (oFull) {
+                oFull = oFull[p];
+            }
+        }
+    }
+    else {
+        obj = value;
+    }
+    return obj;
+}
+function setInObservableAtPath(obs, path, pathTypes, value, mode) {
+    let o = obs;
+    let v = value;
+    for (let i = 0; i < path.length; i++) {
+        const p = path[i];
+        if (!o.peek()[p] && pathTypes[i] === 'array') {
+            o[p].set([]);
+        }
+        o = o[p];
+        v = v[p];
+    }
+    if (v === symbolDelete) {
+        o.delete();
+    }
+    // Assign if possible, or set otherwise
+    else if (mode === 'assign' && o.assign && isObject(o.peek())) {
+        o.assign(v);
+    }
+    else {
+        o.set(v);
+    }
+}
+function mergeIntoObservable(target, ...sources) {
+    beginBatch();
+    globalState.isMerging = true;
+    for (let i = 0; i < sources.length; i++) {
+        target = _mergeIntoObservable(target, sources[i]);
+    }
+    globalState.isMerging = false;
+    endBatch();
+    return target;
+}
+function _mergeIntoObservable(target, source) {
+    var _a;
+    if (isObservable(source)) {
+        source = source.peek();
+    }
+    const needsSet = isObservable(target);
+    const targetValue = needsSet ? target.peek() : target;
+    const isTargetArr = isArray(targetValue);
+    const isTargetObj = !isTargetArr && isObject(targetValue);
+    if ((isTargetObj && isObject(source) && !isEmpty(targetValue)) || (isTargetArr && targetValue.length > 0)) {
+        const keys = Object.keys(source);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const sourceValue = source[key];
+            if (sourceValue === symbolDelete) {
+                needsSet && ((_a = target[key]) === null || _a === void 0 ? void 0 : _a.delete)
+                    ? target[key].delete()
+                    : delete target[key];
+            }
+            else {
+                const isObj = isObject(sourceValue);
+                const isArr = !isObj && isArray(sourceValue);
+                const targetChild = target[key];
+                if ((isObj || isArr) && targetChild && (needsSet || !isEmpty(targetChild))) {
+                    if (!needsSet && (!targetChild || (isObj ? !isObject(targetChild) : !isArray(targetChild)))) {
+                        target[key] = sourceValue;
+                    }
+                    else {
+                        _mergeIntoObservable(targetChild, sourceValue);
+                    }
+                }
+                else {
+                    needsSet
+                        ? targetChild.set(sourceValue)
+                        : (target[key] = sourceValue);
+                }
+            }
+        }
+    }
+    else if (source !== undefined) {
+        needsSet ? target.set(source) : (target = source);
+    }
+    return target;
+}
+function constructObjectWithPath(path, pathTypes, value) {
+    let out;
+    if (path.length > 0) {
+        let o = (out = {});
+        for (let i = 0; i < path.length; i++) {
+            const p = path[i];
+            o[p] = i === path.length - 1 ? value : pathTypes[i] === 'array' ? [] : {};
+            o = o[p];
+        }
+    }
+    else {
+        out = value;
+    }
+    return out;
+}
+function deconstructObjectWithPath(path, pathTypes, value) {
+    let o = value;
+    for (let i = 0; i < path.length; i++) {
+        const p = path[i];
+        o = o ? o[p] : pathTypes[i] === 'array' ? [] : {};
+    }
+    return o;
+}
+function isObservableValueReady(value) {
+    return !!value && ((!isObject(value) && !isArray(value)) || !isEmpty(value));
+}
+function setSilently(obs, newValue) {
+    const node = getNode(obs);
+    return setNodeValue(node, newValue).newValue;
+}
+
+function onChange(node, callback, options = {}) {
+    const { initial, immediate, noArgs } = options;
+    const { trackingType } = options;
+    let listeners = immediate ? node.listenersImmediate : node.listeners;
+    if (!listeners) {
+        listeners = new Set();
+        if (immediate) {
+            node.listenersImmediate = listeners;
+        }
+        else {
+            node.listeners = listeners;
+        }
+    }
+    checkActivate(node);
+    const listener = {
+        listener: callback,
+        track: trackingType,
+        noArgs,
+    };
+    listeners.add(listener);
+    if (initial) {
+        const value = getNodeValue(node);
+        callback({
+            value,
+            changes: [
+                {
+                    path: [],
+                    pathTypes: [],
+                    prevAtPath: value,
+                    valueAtPath: value,
+                },
+            ],
+            getPrevious: () => undefined,
+        });
+    }
+    return () => listeners.delete(listener);
+}
+
+function setupTracking(nodes, update, noArgs, immediate) {
+    let listeners = [];
+    // Listen to tracked nodes
+    nodes === null || nodes === void 0 ? void 0 : nodes.forEach((tracked) => {
+        const { node, track } = tracked;
+        listeners.push(onChange(node, update, { trackingType: track, immediate, noArgs }));
+    });
+    return () => {
+        if (listeners) {
+            for (let i = 0; i < listeners.length; i++) {
+                listeners[i]();
+            }
+            listeners = undefined;
+        }
+    };
+}
+
+let trackCount = 0;
+const trackingQueue = [];
+const tracking = {
+    current: undefined,
+};
 function beginTracking() {
     // Keep a copy of the previous tracking context so it can be restored
     // when this context is complete
@@ -745,11 +761,194 @@ function updateTracking(node, track) {
                 existing.num++;
             }
             else {
-                tracker.nodes.set(node, { node, track, num: 1 });
+                tracker.nodes.set(node, { node, track, num: 1 });
+            }
+        }
+    }
+}
+
+function trackSelector(selector, update, observeEvent, observeOptions, createResubscribe) {
+    var _a;
+    let nodes;
+    let value;
+    let dispose;
+    let tracker;
+    let resubscribe;
+    let updateFn = update;
+    if (isObservable(selector)) {
+        value = selector.peek();
+        dispose = selector.onChange(update);
+        resubscribe = createResubscribe ? selector.onChange(update) : undefined;
+    }
+    else {
+        // Compute the selector inside a tracking context
+        beginTracking();
+        value = selector ? computeSelector(selector, observeEvent, observeOptions === null || observeOptions === void 0 ? void 0 : observeOptions.fromComputed) : selector;
+        tracker = tracking.current;
+        nodes = tracker.nodes;
+        endTracking();
+        if ((process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') && tracker && nodes) {
+            (_a = tracker.traceListeners) === null || _a === void 0 ? void 0 : _a.call(tracker, nodes);
+            if (tracker.traceUpdates) {
+                updateFn = tracker.traceUpdates(update);
+            }
+            // Clear tracing so it doesn't leak to other components
+            tracker.traceListeners = undefined;
+            tracker.traceUpdates = undefined;
+        }
+    }
+    if (!(observeEvent === null || observeEvent === void 0 ? void 0 : observeEvent.cancel)) {
+        // Do tracing if it was requested
+        // useSyncExternalStore doesn't subscribe until after the component mount.
+        // We want to subscribe immediately so we don't miss any updates
+        dispose = setupTracking(nodes, updateFn, false, observeOptions === null || observeOptions === void 0 ? void 0 : observeOptions.immediate);
+        resubscribe = createResubscribe ? () => setupTracking(nodes, updateFn) : undefined;
+    }
+    return { value, nodes, dispose, resubscribe };
+}
+
+function observe(selectorOrRun, reactionOrOptions, options) {
+    let reaction;
+    if (isFunction(reactionOrOptions)) {
+        reaction = reactionOrOptions;
+    }
+    else {
+        options = reactionOrOptions;
+    }
+    let dispose;
+    const e = { num: 0 };
+    // Wrap it in a function so it doesn't pass all the arguments to run()
+    const update = function () {
+        if (e.onCleanup) {
+            e.onCleanup();
+            e.onCleanup = undefined;
+        }
+        // Run in a batch so changes don't happen until we're done tracking here
+        beginBatch();
+        // Run the function/selector
+        delete e.value;
+        // Dispose listeners from previous run
+        dispose === null || dispose === void 0 ? void 0 : dispose();
+        const { dispose: _dispose, value, nodes } = trackSelector(selectorOrRun, update, e, options);
+        dispose = _dispose;
+        e.value = value;
+        e.nodes = nodes;
+        e.refresh = update;
+        if (e.onCleanupReaction) {
+            e.onCleanupReaction();
+            e.onCleanupReaction = undefined;
+        }
+        endBatch();
+        // Call the reaction if there is one and the value changed
+        if (reaction &&
+            ((options === null || options === void 0 ? void 0 : options.fromComputed) || ((e.num > 0 || !isEvent(selectorOrRun)) && e.previous !== e.value))) {
+            reaction(e);
+        }
+        // Update the previous value
+        e.previous = e.value;
+        // Increment the counter
+        e.num++;
+    };
+    update();
+    // Return function calling dispose because dispose may be changed in update()
+    return () => {
+        var _a, _b;
+        (_a = e.onCleanup) === null || _a === void 0 ? void 0 : _a.call(e);
+        e.onCleanup = undefined;
+        (_b = e.onCleanupReaction) === null || _b === void 0 ? void 0 : _b.call(e);
+        e.onCleanupReaction = undefined;
+        dispose === null || dispose === void 0 ? void 0 : dispose();
+    };
+}
+
+function setupRetry(retryOptions, refresh, attemptNum) {
+    const timeout = {};
+    // let didGiveUp = false;
+    const { backoff, delay = 1000, infinite, times = 3, maxDelay = 30000 } = retryOptions;
+    let handleError;
+    attemptNum.current++;
+    if (infinite || attemptNum.current < times) {
+        const delayTime = Math.min(delay * (backoff === 'constant' ? 1 : 2 ** attemptNum.current), maxDelay);
+        handleError = () => {
+            timeout.current = setTimeout(refresh, delayTime);
+        };
+    }
+    else {
+        handleError = () => {
+            // didGiveUp = true;
+        };
+    }
+    // TODO: Make an easy way to opt into this if
+    // if (typeof window !== 'undefined') {
+    //     window.addEventListener('online', () => {
+    //         if (didGiveUp || timeout) {
+    //             if (timeout) {
+    //                 clearTimeout(timeout.current);
+    //                 timeout.current = undefined;
+    //             }
+    //             // Restart the backoff when coming back online
+    //             attemptNum.current = 0;
+    //             didGiveUp = false;
+    //             refresh();
+    //         }
+    //     });
+    // }
+    return { handleError, timeout };
+}
+
+function _when(predicate, effect, checkReady) {
+    // If predicate is a regular Promise skip all the observable stuff
+    if (isPromise(predicate)) {
+        return effect ? predicate.then(effect) : predicate;
+    }
+    let value;
+    // Create a wrapping fn that calls the effect if predicate returns true
+    function run(e) {
+        const ret = computeSelector(predicate);
+        if (!isPromise(ret) && (checkReady ? isObservableValueReady(ret) : ret)) {
+            value = ret;
+            // Set cancel so that observe does not track anymore
+            e.cancel = true;
+        }
+        return value;
+    }
+    function doEffect() {
+        // If value is truthy then run the effect
+        effect === null || effect === void 0 ? void 0 : effect(value);
+    }
+    // Run in an observe
+    observe(run, doEffect);
+    // If first run resulted in a truthy value just return it.
+    // It will have set e.cancel so no need to dispose
+    if (isPromise(value)) {
+        return effect ? value.then(effect) : value;
+    }
+    else if (value !== undefined) {
+        return Promise.resolve(value);
+    }
+    else {
+        // Wrap it in a promise
+        const promise = new Promise((resolve) => {
+            if (effect) {
+                const originalEffect = effect;
+                effect = (value) => {
+                    const effectValue = originalEffect(value);
+                    resolve(effectValue);
+                };
+            }
+            else {
+                effect = resolve;
             }
-        }
+        });
+        return promise;
     }
 }
+function when(predicate, effect) {
+    return _when(predicate, effect, false);
+}
+function whenReady(predicate, effect) {
+    return _when(predicate, effect, true);
+}
 
 const ArrayModifiers = new Set([
     'copyWithin',
@@ -791,19 +990,24 @@ if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
 }
 function collectionSetter(node, target, prop, ...args) {
     var _a;
-    const prevValue = (isArray(target) && target.slice()) || target;
-    const ret = target[prop].apply(target, args);
-    if (node) {
-        const hasParent = isChildNodeValue(node);
-        const key = hasParent ? node.key : '_';
-        const parentValue = hasParent ? getNodeValue(node.parent) : node.root;
-        // Set the object to the previous value first
-        parentValue[key] = prevValue;
-        // Then set with the new value so it notifies with the correct prevValue
-        setKey((_a = node.parent) !== null && _a !== void 0 ? _a : node, key, target);
-    }
-    // Return the original value
-    return ret;
+    if (prop === 'push') {
+        setKey(node, target.length + '', args[0]);
+    }
+    else {
+        const prevValue = target.slice();
+        const ret = target[prop].apply(target, args);
+        if (node) {
+            const hasParent = isChildNodeValue(node);
+            const key = hasParent ? node.key : '_';
+            const parentValue = hasParent ? getNodeValue(node.parent) : node.root;
+            // Set the object to the previous value first
+            parentValue[key] = prevValue;
+            // Then set with the new value so it notifies with the correct prevValue
+            setKey((_a = node.parent) !== null && _a !== void 0 ? _a : node, key, target);
+        }
+        // Return the original value
+        return ret;
+    }
 }
 function getKeys(obj, isArr, isMap) {
     return isArr ? undefined : obj ? (isMap ? Array.from(obj.keys()) : Object.keys(obj)) : [];
@@ -989,13 +1193,22 @@ function updateNodes(parent, obj, prevValue) {
     }
     return retValue !== null && retValue !== void 0 ? retValue : false;
 }
-function getProxy(node, p) {
+function getProxy(node, p, asFunction) {
     // Get the child node if p prop
     if (p !== undefined)
-        node = getChildNode(node, p);
+        node = getChildNode(node, p, asFunction);
     // Create a proxy if not already cached and return it
     return (node.proxy || (node.proxy = new Proxy(node, proxyHandler)));
 }
+function flushPending() {
+    // Need to short circuit the computed batching because the user called get() or peek()
+    // in which case the set needs to run immediately so that the values are up to date.
+    if (globalState.pendingNodes.size > 0) {
+        const nodes = Array.from(globalState.pendingNodes.values());
+        globalState.pendingNodes.clear();
+        nodes.forEach((fn) => fn());
+    }
+}
 const proxyHandler = {
     get(node, p, receiver) {
         var _a;
@@ -1023,6 +1236,9 @@ const proxyHandler = {
         const fn = observableFns.get(p);
         // If this is an observable function, call it
         if (fn) {
+            if (p === 'get' || p === 'peek') {
+                flushPending();
+            }
             return function (a, b, c) {
                 const l = arguments.length;
                 // Array call and apply are slow so micro-optimize this hot path.
@@ -1070,6 +1286,15 @@ const proxyHandler = {
         if (isObject(value) && value[symbolOpaque]) {
             return vProp;
         }
+        const fnOrComputed = (_a = node.functions) === null || _a === void 0 ? void 0 : _a.get(p);
+        if (fnOrComputed) {
+            if (isObservable(fnOrComputed)) {
+                return fnOrComputed;
+            }
+            else {
+                return getProxy(node, p, fnOrComputed);
+            }
+        }
         // Handle function calls
         if (isFunction(vProp)) {
             if (isArray(value)) {
@@ -1116,15 +1341,9 @@ const proxyHandler = {
             // Update that this primitive node was accessed for observers
             if (isArray(value) && p === 'length') {
                 updateTracking(node, true);
-                // } else if (!isPrimitive(value)) {
-                //     updateTracking(getChildNode(node, p));
                 return vProp;
             }
         }
-        const fnOrComputed = (_a = node.functions) === null || _a === void 0 ? void 0 : _a.get(p);
-        if (fnOrComputed) {
-            return fnOrComputed;
-        }
         // TODOV3: Remove "state"
         if (vProp === undefined && (p === 'state' || p === '_state') && node.state) {
             return node.state;
@@ -1191,6 +1410,10 @@ const proxyHandler = {
         const value = getNodeValue(node);
         return Reflect.has(value, prop);
     },
+    apply(target, thisArg, argArray) {
+        // If it's a function call it as a function
+        return Reflect.apply(target, thisArg, argArray);
+    },
 };
 function set(node, newValue) {
     if (node.parent) {
@@ -1216,12 +1439,14 @@ function setKey(node, key, newValue, level) {
             console.warn(`[legend-state] Set an HTMLElement into state. You probably don't want to do that.`);
         }
     }
+    const isRoot = !node.parent && key === '_';
+    // TODOv3 root locking will be removed with old computeds
     if (node.root.locked && !node.root.set) {
         // This happens when modifying a locked observable such as a computed.
         // If merging this could be happening deep in a hierarchy so we don't want to throw errors so we'll just do nothing.
         // This could happen during persistence local load for example.
         if (globalState.isMerging) {
-            return;
+            return isRoot ? getProxy(node) : getProxy(node, key);
         }
         else {
             throw new Error(process.env.NODE_ENV === 'development'
@@ -1229,9 +1454,11 @@ function setKey(node, key, newValue, level) {
                 : '[legend-state] Modified locked observable');
         }
     }
-    const isRoot = !node.parent && key === '_';
+    if (node.parent && !getNodeValue(node)) {
+        return set(node, { [key]: newValue });
+    }
     // Get the child node for updating and notifying
-    const childNode = isRoot ? node : getChildNode(node, key);
+    const childNode = isRoot ? node : getChildNode(node, key, isFunction(newValue) ? newValue : undefined);
     // Set the raw value on the parent object
     const { newValue: savedValue, prevValue, parentValue } = setNodeValue(childNode, newValue);
     const isFunc = isFunction(savedValue);
@@ -1347,9 +1574,6 @@ function updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRo
         childNode = node;
     // Make sure we don't call too many listeners for ever property set
     beginBatch();
-    if (isPrim === undefined) {
-        isPrim = isPrimitive(newValue);
-    }
     let hasADiff = isPrim;
     let whenOptimizedOnlyIf = false;
     // If new value is an object or array update notify down the tree
@@ -1369,27 +1593,36 @@ function updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRo
     }
     endBatch();
 }
-function extractPromise(node, value) {
+function extractPromise(node, value, setter, handleError) {
     if (!node.state) {
         node.state = createObservable({
             isLoaded: false,
-        }, false, getProxy);
+        }, false, extractPromise, getProxy);
     }
     value
         .then((value) => {
-        set(node, value);
-        node.state.isLoaded.set(true);
+        setter ? setter({ value }) : set(node, value);
+        node.state.assign({
+            isLoaded: true,
+            error: undefined,
+        });
     })
         .catch((error) => {
         node.state.error.set(error);
+        if (handleError) {
+            handleError(error);
+        }
     });
 }
 function extractFunctionOrComputed(node, obj, k, v) {
     if (isPromise(v)) {
-        extractPromise(getChildNode(node, k), v);
+        const childNode = getChildNode(node, k);
+        extractPromise(childNode, v);
+        setNodeValue(childNode, undefined);
     }
     else if (typeof v === 'function') {
         extractFunction(node, k, v);
+        delete obj[k];
     }
     else if (typeof v == 'object' && v !== null && v !== undefined) {
         const childNode = getNode(v);
@@ -1409,10 +1642,19 @@ function get(node, options) {
     return peek(node);
 }
 function peek(node) {
-    const value = getNodeValue(node);
+    if (node.dirtyFn) {
+        node.dirtyFn();
+        globalState.dirtyNodes.delete(node);
+        node.dirtyFn = undefined;
+    }
+    let value = getNodeValue(node);
     // If node is not yet lazily computed go do that
-    if (node.lazy) {
+    const lazy = node.lazy;
+    if (lazy) {
         delete node.lazy;
+        if (isFunction(node) || isFunction(lazy)) {
+            value = activateNodeFunction(node, lazy);
+        }
         for (const key in value) {
             if (hasOwnProperty.call(value, key)) {
                 extractFunctionOrComputed(node, value, key, value[key]);
@@ -1423,6 +1665,265 @@ function peek(node) {
     checkActivate(node);
     return value;
 }
+function activateNodeFunction(node, lazyFn) {
+    // let prevTarget$: Observable<any>;
+    // let curTarget$: Observable<any>;
+    let update;
+    let wasPromise;
+    let timeoutRetry;
+    const attemptNum = { current: 0 };
+    const activateFn = (isFunction(node) ? node : lazyFn);
+    const doRetry = () => { var _a; return (_a = node.state) === null || _a === void 0 ? void 0 : _a.refreshNum.set((v) => v + 1); };
+    let activatedValue;
+    let disposes = [];
+    let refreshFn;
+    function markDirty() {
+        node.dirtyFn = refreshFn;
+        globalState.dirtyNodes.add(node);
+    }
+    observe(() => {
+        var _a, _b, _c, _d;
+        // const params = createNodeActivationParams(node);
+        // Run the function at this node
+        let value = activateFn();
+        // If target is an observable, make this node a link to it
+        if (isObservable(value)) {
+            // If the computed is a proxy to another observable
+            // link it to the target observable
+            const linkedNode = getNode(value);
+            const prevNode = node.linkedToNode;
+            node.linkedToNode = linkedNode;
+            if (!linkedNode.linkedFromNodes) {
+                linkedNode.linkedFromNodes = new Set();
+            }
+            linkedNode.linkedFromNodes.add(node);
+            onChange(linkedNode, ({ value: newValue }) => {
+                value = newValue;
+                set(node, value);
+            }, { initial: true });
+            // If the target observable is different then notify for the change
+            if (prevNode) {
+                const value = getNodeValue(linkedNode);
+                const prevValue = getNodeValue(prevNode);
+                notify(node, value, prevValue, 0);
+            }
+        }
+        if (isFunction(value)) {
+            value = value();
+        }
+        const activated = value === null || value === void 0 ? void 0 : value[symbolActivated];
+        if (activated) {
+            node.activationState = activated;
+            value = activated.initial;
+        }
+        wasPromise = isPromise(value);
+        // Activate this node if not activated already (may be called recursively)
+        // TODO: Is calling recursively bad? If so can it be fixed?
+        if (!node.activated) {
+            node.activated = true;
+            const isCached = !!((_a = node.activationState) === null || _a === void 0 ? void 0 : _a.cache);
+            wasPromise = wasPromise || !!isCached;
+            const activateNodeFn = wasPromise ? globalState.activateNode : activateNodeBase;
+            const { update: newUpdate, value: newValue } = activateNodeFn(node, doRetry, !!wasPromise, value);
+            update = newUpdate;
+            value = newValue;
+        }
+        else if (node.activationState) {
+            if (!node.activationState.persistedRetry) {
+                const activated = node.activationState;
+                value = (_c = (_b = activated.get) === null || _b === void 0 ? void 0 : _b.call(activated, {})) !== null && _c !== void 0 ? _c : activated.initial;
+            }
+        }
+        wasPromise = wasPromise || isPromise(value);
+        get(getNode((_d = node.state) === null || _d === void 0 ? void 0 : _d.refreshNum));
+        return value;
+    }, (e) => {
+        const { value, nodes, refresh } = e;
+        refreshFn = refresh;
+        if (!globalState.isLoadingRemote$.peek()) {
+            if (wasPromise) {
+                if (node.activationState) {
+                    const { retry, initial } = node.activationState;
+                    let onError;
+                    if (retry) {
+                        if (timeoutRetry === null || timeoutRetry === void 0 ? void 0 : timeoutRetry.current) {
+                            clearTimeout(timeoutRetry.current);
+                        }
+                        const { handleError, timeout } = setupRetry(retry, doRetry, attemptNum);
+                        onError = handleError;
+                        timeoutRetry = timeout;
+                        node.activationState.onError = onError;
+                    }
+                    if (value && isPromise(value)) {
+                        // Extract the promise to make it set the value/error when it comes in
+                        extractPromise(node, value, update, onError);
+                    }
+                    // Set this to undefined only if it's replacing the activation function,
+                    // so we don't overwrite it if it already has real data from either local
+                    // cache or a previous run
+                    if (isFunction(getNodeValue(node))) {
+                        setNodeValue(node, initial !== null && initial !== void 0 ? initial : undefined);
+                    }
+                }
+                else if (node.activated) {
+                    let onError;
+                    // Extract the promise to make it set the value/error when it comes in
+                    extractPromise(node, value, update, onError);
+                    // Set this to undefined only if it's replacing the activation function,
+                    // so we don't overwrite it if it already has real data from either local
+                    // cache or a previous run
+                    if (isFunction(getNodeValue(node))) {
+                        setNodeValue(node, undefined);
+                    }
+                }
+            }
+            else {
+                activatedValue = value;
+                set(node, value);
+                node.state.assign({
+                    isLoaded: true,
+                    error: undefined,
+                });
+            }
+        }
+        disposes.forEach((fn) => fn());
+        disposes = [];
+        nodes === null || nodes === void 0 ? void 0 : nodes.forEach(({ node }) => {
+            disposes.push(onChange(node, markDirty, { immediate: true }));
+        });
+        e.cancel = true;
+    }, { fromComputed: true });
+    return activatedValue;
+}
+const activateNodeBase = (globalState.activateNode = function activateNodeBase(node, refresh, wasPromise, value) {
+    if (!node.state) {
+        node.state = createObservable({
+            isLoaded: false,
+        }, false, extractPromise, getProxy);
+    }
+    let isSetting = false;
+    let isSettingFromSubscribe = false;
+    let _mode = 'set';
+    if (node.activationState) {
+        const { onSet, subscribe, get: getFn, initial, retry, waitFor } = node.activationState;
+        // @ts-expect-error asdf
+        const run = () => getFn({ updateLastSync: noop, setMode: (mode) => (_mode = mode) });
+        value = getFn
+            ? waitFor
+                ? new Promise((resolve) => {
+                    whenReady(waitFor, () => {
+                        resolve(run());
+                    });
+                })
+                : run()
+            : undefined;
+        if (value == undefined || value === null) {
+            value = initial;
+        }
+        let timeoutRetry;
+        if (onSet) {
+            let allChanges = [];
+            let latestValue = undefined;
+            const runChanges = (listenerParams) => {
+                // Don't call the set if this is the first value coming in
+                if (allChanges.length > 0) {
+                    let changes;
+                    let value;
+                    if (listenerParams) {
+                        changes = listenerParams.changes;
+                        value = listenerParams.value;
+                    }
+                    else {
+                        // If this is called by flushPending then get the change array
+                        // that we've been building up.
+                        changes = allChanges;
+                        value = latestValue;
+                    }
+                    allChanges = [];
+                    latestValue = undefined;
+                    globalState.pendingNodes.delete(node);
+                    const attemptNum = { current: 0 };
+                    const run = () => {
+                        let onError;
+                        if (retry) {
+                            if (timeoutRetry === null || timeoutRetry === void 0 ? void 0 : timeoutRetry.current) {
+                                clearTimeout(timeoutRetry.current);
+                            }
+                            const { handleError, timeout } = setupRetry(retry, run, attemptNum);
+                            onError = handleError;
+                            timeoutRetry = timeout;
+                        }
+                        isSetting = true;
+                        batch(() => onSet({
+                            value,
+                            changes,
+                            getPrevious: () => {
+                                // TODO
+                                // debugger;
+                            },
+                        }, {
+                            node,
+                            update,
+                            refresh,
+                            onError,
+                            fromSubscribe: isSettingFromSubscribe,
+                        }), () => {
+                            isSetting = false;
+                        });
+                    };
+                    run();
+                }
+            };
+            const onChangeImmediate = ({ value, changes }) => {
+                if (!isSetting || isSettingFromSubscribe) {
+                    if (get(getNode(node.state.isLoaded)) &&
+                        (changes.length > 1 || !isFunction(changes[0].prevAtPath))) {
+                        latestValue = value;
+                        allChanges.push(...changes);
+                        globalState.pendingNodes.set(node, runChanges);
+                    }
+                }
+            };
+            // Create an immediate listener to mark this node as pending. Then actually run
+            // the changes at the end of the batch so everything is properly batched.
+            // However, this can be short circuited if the user calls get() or peek()
+            // in which case the set needs to run immediately so that the values are up to date.
+            onChange(node, onChangeImmediate, { immediate: true });
+            onChange(node, runChanges);
+        }
+        if (process.env.NODE_ENV === 'development' && node.activationState.cache) {
+            // TODO Better message
+            console.log('[legend-state] Using cache without setting up persistence first');
+        }
+        if (process.env.NODE_ENV === 'development' && node.activationState.retry) {
+            // TODO Better message
+            console.log('[legend-state] Using retry without setting up persistence first');
+        }
+        if (subscribe) {
+            const updateFromSubscribe = (params) => {
+                isSettingFromSubscribe = true;
+                update(params);
+                isSettingFromSubscribe = false;
+            };
+            subscribe({ node, update: updateFromSubscribe, refresh });
+        }
+    }
+    const update = ({ value, mode }) => {
+        // TODO: This isSetting might not be necessary? Tests still work if removing it.
+        // Write tests that would break it if removed? I'd guess a combination of subscribe and
+        if (!isSetting) {
+            isSetting = true;
+            if (_mode === 'assign' || mode === 'assign') {
+                assign(node, value);
+            }
+            else {
+                set(node, value);
+            }
+            isSetting = false;
+        }
+    };
+    return { update, value };
+});
 
 const fns = ['get', 'set', 'peek', 'onChange', 'toggle'];
 function ObservablePrimitiveClass(node) {
@@ -1439,8 +1940,14 @@ function proto(key, fn) {
         return fn.call(this, this._node, ...args);
     };
 }
-proto('peek', peek);
-proto('get', get);
+proto('peek', (node) => {
+    flushPending();
+    return peek(node);
+});
+proto('get', (node, options) => {
+    flushPending();
+    return get(node, options);
+});
 proto('set', set);
 proto('onChange', onChange);
 // Getters
@@ -1466,121 +1973,12 @@ ObservablePrimitiveClass.prototype.delete = function () {
 };
 
 function observable(value) {
-    return createObservable(value, false, getProxy, ObservablePrimitiveClass);
+    return createObservable(value, false, extractPromise, getProxy, ObservablePrimitiveClass);
 }
 function observablePrimitive(value) {
-    return createObservable(value, true, getProxy, ObservablePrimitiveClass);
-}
-
-function setupTracking(nodes, update, noArgs, immediate) {
-    let listeners = [];
-    // Listen to tracked nodes
-    nodes === null || nodes === void 0 ? void 0 : nodes.forEach((tracked) => {
-        const { node, track } = tracked;
-        listeners.push(onChange(node, update, { trackingType: track, immediate, noArgs }));
-    });
-    return () => {
-        if (listeners) {
-            for (let i = 0; i < listeners.length; i++) {
-                listeners[i]();
-            }
-            listeners = undefined;
-        }
-    };
-}
-
-function trackSelector(selector, update, observeEvent, observeOptions, createResubscribe) {
-    var _a;
-    let nodes;
-    let value;
-    let dispose;
-    let tracker;
-    let resubscribe;
-    let updateFn = update;
-    if (isObservable(selector)) {
-        value = selector.peek();
-        dispose = selector.onChange(update);
-        resubscribe = createResubscribe ? selector.onChange(update) : undefined;
-    }
-    else {
-        // Compute the selector inside a tracking context
-        beginTracking();
-        value = selector ? computeSelector(selector, observeEvent, observeOptions === null || observeOptions === void 0 ? void 0 : observeOptions.fromComputed) : selector;
-        tracker = tracking.current;
-        nodes = tracker.nodes;
-        endTracking();
-        if ((process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') && tracker && nodes) {
-            (_a = tracker.traceListeners) === null || _a === void 0 ? void 0 : _a.call(tracker, nodes);
-            if (tracker.traceUpdates) {
-                updateFn = tracker.traceUpdates(update);
-            }
-            // Clear tracing so it doesn't leak to other components
-            tracker.traceListeners = undefined;
-            tracker.traceUpdates = undefined;
-        }
-    }
-    if (!(observeEvent === null || observeEvent === void 0 ? void 0 : observeEvent.cancel)) {
-        // Do tracing if it was requested
-        // useSyncExternalStore doesn't subscribe until after the component mount.
-        // We want to subscribe immediately so we don't miss any updates
-        dispose = setupTracking(nodes, updateFn, false, observeOptions === null || observeOptions === void 0 ? void 0 : observeOptions.immediate);
-        resubscribe = createResubscribe ? () => setupTracking(nodes, updateFn) : undefined;
-    }
-    return { value, dispose, resubscribe };
-}
-
-function observe(selectorOrRun, reactionOrOptions, options) {
-    let reaction;
-    if (isFunction(reactionOrOptions)) {
-        reaction = reactionOrOptions;
-    }
-    else {
-        options = reactionOrOptions;
-    }
-    let dispose;
-    const e = { num: 0 };
-    // Wrap it in a function so it doesn't pass all the arguments to run()
-    const update = function () {
-        if (e.onCleanup) {
-            e.onCleanup();
-            e.onCleanup = undefined;
-        }
-        // Run in a batch so changes don't happen until we're done tracking here
-        beginBatch();
-        // Run the function/selector
-        delete e.value;
-        // Dispose listeners from previous run
-        dispose === null || dispose === void 0 ? void 0 : dispose();
-        const { dispose: _dispose, value } = trackSelector(selectorOrRun, update, e, options);
-        dispose = _dispose;
-        e.value = value;
-        if (e.onCleanupReaction) {
-            e.onCleanupReaction();
-            e.onCleanupReaction = undefined;
-        }
-        endBatch();
-        // Call the reaction if there is one and the value changed
-        if (reaction &&
-            (e.num > 0 || !isEvent(selectorOrRun)) &&
-            (e.previous !== e.value || (options === null || options === void 0 ? void 0 : options.fromComputed))) {
-            reaction(e);
-        }
-        // Update the previous value
-        e.previous = e.value;
-        // Increment the counter
-        e.num++;
-    };
-    update();
-    // Return function calling dispose because dispose may be changed in update()
-    return () => {
-        var _a, _b;
-        (_a = e.onCleanup) === null || _a === void 0 ? void 0 : _a.call(e);
-        e.onCleanup = undefined;
-        (_b = e.onCleanupReaction) === null || _b === void 0 ? void 0 : _b.call(e);
-        e.onCleanupReaction = undefined;
-        dispose === null || dispose === void 0 ? void 0 : dispose();
-    };
+    return createObservable(value, true, extractPromise, getProxy, ObservablePrimitiveClass);
 }
+globalState.isLoadingRemote$ = observable(false);
 
 function computed(compute, set$1) {
     // Create an observable for this computed variable
@@ -1744,80 +2142,23 @@ function proxy(get, set) {
     return obs;
 }
 
-function _when(predicate, effect, checkReady) {
-    // If predicate is a regular Promise skip all the observable stuff
-    if (isPromise(predicate)) {
-        return effect ? predicate.then(effect) : predicate;
-    }
-    let value;
-    // Create a wrapping fn that calls the effect if predicate returns true
-    function run(e) {
-        const ret = computeSelector(predicate);
-        if (!isPromise(ret) && (checkReady ? isObservableValueReady(ret) : ret)) {
-            value = ret;
-            // Set cancel so that observe does not track anymore
-            e.cancel = true;
-        }
-        return value;
-    }
-    function doEffect() {
-        // If value is truthy then run the effect
-        effect === null || effect === void 0 ? void 0 : effect(value);
-    }
-    // Run in an observe
-    observe(run, doEffect);
-    // If first run resulted in a truthy value just return it.
-    // It will have set e.cancel so no need to dispose
-    if (isPromise(value)) {
-        return effect ? value.then(effect) : value;
-    }
-    else if (value !== undefined) {
-        return Promise.resolve(value);
-    }
-    else {
-        // Wrap it in a promise
-        const promise = new Promise((resolve) => {
-            if (effect) {
-                const originalEffect = effect;
-                effect = (value) => {
-                    const effectValue = originalEffect(value);
-                    resolve(effectValue);
-                };
-            }
-            else {
-                effect = resolve;
-            }
-        });
-        return promise;
-    }
-}
-function when(predicate, effect) {
-    return _when(predicate, effect, false);
-}
-function whenReady(predicate, effect) {
-    return _when(predicate, effect, true);
-}
-
 const internal = {
-    clone,
     ensureNodeValue,
     findIDKey,
     get,
     getNode,
-    getPathType,
     getProxy,
     globalState,
-    initializePathType,
     observableFns,
     optimized,
     peek,
-    safeParse,
-    safeStringify,
     set,
     setAtPath,
     setNodeValue,
+    setupRetry,
+    symbolActivated,
     symbolDelete,
 };
 
-export { ObservablePrimitiveClass, batch, beginBatch, beginTracking, checkActivate, computeSelector, computed, configureLegendState, constructObjectWithPath, deconstructObjectWithPath, endBatch, endTracking, event, extraPrimitiveActivators, extraPrimitiveProps, findIDKey, getNode, getNodeValue, getObservableIndex, hasOwnProperty, internal, isArray, isBoolean, isEmpty, isFunction, isObject, isObservable, isObservableValueReady, isPrimitive, isPromise, isString, isSymbol, lockObservable, mergeIntoObservable, observable, observablePrimitive, observe, opaqueObject, optimized, proxy, setAtPath, setInObservableAtPath, setSilently, setupTracking, symbolDelete, trackSelector, tracking, updateTracking, when, whenReady };
+export { ObservablePrimitiveClass, activated, batch, beginBatch, beginTracking, checkActivate, computeSelector, computed, configureLegendState, constructObjectWithPath, deconstructObjectWithPath, endBatch, endTracking, event, extraPrimitiveActivators, extraPrimitiveProps, findIDKey, getNode, getNodeValue, getObservableIndex, hasOwnProperty, internal, isArray, isBoolean, isEmpty, isFunction, isObject, isObservable, isObservableValueReady, isPrimitive, isPromise, isString, isSymbol, lockObservable, mergeIntoObservable, observable, observablePrimitive, observe, opaqueObject, optimized, proxy, setAtPath, setInObservableAtPath, setSilently, setupTracking, symbolDelete, trackSelector, tracking, updateTracking, when, whenReady };
 //# sourceMappingURL=index.mjs.map