@legendapp/state 2.2.0-next.8 → 2.2.0-next.80

package/persist.js

@@ -7,12 +7,13 @@ function configureObservablePersistence(options) {
     Object.assign(observablePersistConfiguration, options);
 }
 
+const { initializePathType, symbolDelete } = state.internal;
 let validateMap;
 function transformPath(path, pathTypes, map) {
     const data = {};
     let d = data;
     for (let i = 0; i < path.length; i++) {
-        d = d[path[i]] = i === path.length - 1 ? null : pathTypes[i] === 'array' ? [] : {};
+        d = d[path[i]] = i === path.length - 1 ? null : initializePathType(pathTypes[i]);
     }
     let value = transformObject(data, map);
     const pathOut = [];
@@ -29,7 +30,7 @@ function transformObject(dataIn, map) {
     }
     let ret = dataIn;
     if (dataIn) {
-        if (dataIn === state.symbolDelete)
+        if (dataIn === symbolDelete)
             return dataIn;
         if (state.isString(dataIn)) {
             return map[dataIn];
@@ -135,13 +136,31 @@ if (process.env.NODE_ENV === 'development') {
     };
 }
 
+function removeNullUndefined(a, recursive) {
+    const out = {};
+    Object.keys(a).forEach((key) => {
+        if (a[key] !== null && a[key] !== undefined) {
+            out[key] = recursive && state.isObject(a[key]) ? removeNullUndefined(a[key]) : a[key];
+        }
+    });
+    return out;
+}
+
 function observablePersistRemoteFunctionsAdapter({ get, set, }) {
     const ret = {};
     if (get) {
         ret.get = (async (params) => {
             try {
-                const value = (await get(params));
-                params.onChange({ value, dateModified: params.dateModified });
+                let value = get(params);
+                if (state.isPromise(value)) {
+                    value = await value;
+                }
+                params.onChange({
+                    value,
+                    dateModified: params.dateModified,
+                    lastSync: params.lastSync,
+                    mode: params.mode,
+                });
                 params.onGet();
                 // eslint-disable-next-line no-empty
             }
@@ -154,31 +173,29 @@ function observablePersistRemoteFunctionsAdapter({ get, set, }) {
     return ret;
 }
 
-const { globalState: globalState$1 } = state.internal;
+const { globalState: globalState$2, symbolLinked: symbolLinked$3, getNode: getNode$1 } = state.internal;
 const mapPersistences = new WeakMap();
-const metadatas = new WeakMap();
-const promisesLocalSaves = new Set();
-function parseLocalConfig(config) {
+const metadatas$1 = new WeakMap();
+const promisesLocalSaves$1 = new Set();
+function parseLocalConfig$1(config) {
     return config
         ? state.isString(config)
             ? { table: config, config: { name: config } }
             : { table: config.name, config }
         : {};
 }
-function doInOrder(arg1, arg2) {
+function doInOrder$1(arg1, arg2) {
     return state.isPromise(arg1) ? arg1.then(arg2) : arg2(arg1);
 }
-function onChangeRemote(cb) {
-    state.when(() => !globalState$1.isLoadingRemote$.get(), () => {
-        // Remote changes should only update local state
-        globalState$1.isLoadingRemote$.set(true);
-        state.batch(cb, () => {
-            globalState$1.isLoadingRemote$.set(false);
-        });
-    });
+function onChangeRemote$1(cb) {
+    state.endBatch(true);
+    // Remote changes should only update local state
+    globalState$2.isLoadingRemote = true;
+    state.batch(cb);
+    globalState$2.isLoadingRemote = false;
 }
 function transformOutData(value, path, pathTypes, { transform, fieldTransforms }) {
-    if (fieldTransforms || (transform === null || transform === void 0 ? void 0 : transform.out)) {
+    if (fieldTransforms || (transform === null || transform === void 0 ? void 0 : transform.save)) {
         const transformFn = () => {
             if (fieldTransforms) {
                 const { obj, path: pathTransformed } = transformObjectWithPath(value, path, pathTypes, fieldTransforms);
@@ -187,69 +204,111 @@ function transformOutData(value, path, pathTypes, { transform, fieldTransforms }
             }
             return { value, path };
         };
-        if (transform === null || transform === void 0 ? void 0 : transform.out) {
+        if (transform === null || transform === void 0 ? void 0 : transform.save) {
             const constructed = state.constructObjectWithPath(path, pathTypes, value);
-            const saved = transform.out(constructed);
+            const saved = transform.save(constructed);
             const deconstruct = (toDeconstruct) => {
                 value = state.deconstructObjectWithPath(path, pathTypes, toDeconstruct);
                 return transformFn();
             };
-            return doInOrder(saved, deconstruct);
+            return doInOrder$1(saved, deconstruct);
         }
         return transformFn();
     }
     return { value, path };
 }
-function transformLoadData(value, { transform, fieldTransforms }, doUserTransform) {
+function transformLoadData$1(value, { transform, fieldTransforms }, doUserTransform) {
     if (fieldTransforms) {
         const inverted = invertFieldMap(fieldTransforms);
         value = transformObject(value, inverted);
     }
-    if (doUserTransform && (transform === null || transform === void 0 ? void 0 : transform.in)) {
-        value = transform.in(value);
+    if (doUserTransform && (transform === null || transform === void 0 ? void 0 : transform.load)) {
+        value = transform.load(value);
     }
     return value;
 }
-async function updateMetadataImmediate(obs, localState, syncState, persistOptions, newMetadata) {
-    const saves = Array.from(promisesLocalSaves);
+async function updateMetadataImmediate$1(obs, localState, syncState, persistOptions, newMetadata) {
+    const saves = Array.from(promisesLocalSaves$1);
     if (saves.length > 0) {
         await Promise.all(saves);
     }
     const { persistenceLocal } = localState;
     const local = persistOptions.local;
-    const { table, config } = parseLocalConfig(local);
+    const { table, config } = parseLocalConfig$1(local);
     // Save metadata
-    const oldMetadata = metadatas.get(obs);
-    const { modified, pending } = newMetadata;
-    const needsUpdate = pending || (modified && (!oldMetadata || modified !== oldMetadata.modified));
+    const oldMetadata = metadatas$1.get(obs);
+    const { lastSync, pending } = newMetadata;
+    const needsUpdate = pending || (lastSync && (!oldMetadata || lastSync !== oldMetadata.lastSync));
     if (needsUpdate) {
         const metadata = Object.assign({}, oldMetadata, newMetadata);
-        metadatas.set(obs, metadata);
+        metadatas$1.set(obs, metadata);
         if (persistenceLocal) {
             await persistenceLocal.setMetadata(table, metadata, config);
         }
-        if (modified) {
-            syncState.dateModified.set(modified);
+        if (lastSync) {
+            syncState.assign({
+                lastSync: lastSync,
+                dateModified: lastSync,
+            });
         }
     }
 }
-function updateMetadata(obs, localState, syncState, persistOptions, newMetadata) {
+function updateMetadata$1(obs, localState, syncState, persistOptions, newMetadata) {
     var _a;
     if (localState.timeoutSaveMetadata) {
         clearTimeout(localState.timeoutSaveMetadata);
     }
-    localState.timeoutSaveMetadata = setTimeout(() => updateMetadataImmediate(obs, localState, syncState, persistOptions, newMetadata), ((_a = persistOptions === null || persistOptions === void 0 ? void 0 : persistOptions.remote) === null || _a === void 0 ? void 0 : _a.metadataTimeout) || 0);
+    localState.timeoutSaveMetadata = setTimeout(() => updateMetadataImmediate$1(obs, localState, syncState, persistOptions, newMetadata), ((_a = persistOptions === null || persistOptions === void 0 ? void 0 : persistOptions.remote) === null || _a === void 0 ? void 0 : _a.metadataTimeout) || 0);
 }
-let _queuedChanges = [];
-async function processQueuedChanges() {
+let _queuedChanges$1 = [];
+let _queuedRemoteChanges$1 = [];
+let timeoutSaveRemote = undefined;
+function mergeChanges$1(changes) {
+    const changesByPath = new Map();
+    const changesOut = [];
+    // TODO: This could be even more robust by going deeper into paths like the firebase plugin's _updatePendingSave
+    for (let i = 0; i < changes.length; i++) {
+        const change = changes[i];
+        const pathStr = change.path.join('/');
+        const existing = changesByPath.get(pathStr);
+        if (existing) {
+            existing.valueAtPath = change.valueAtPath;
+        }
+        else {
+            changesByPath.set(pathStr, change);
+            changesOut.push(change);
+        }
+    }
+    return changesOut;
+}
+function mergeQueuedChanges$1(allChanges) {
+    const changesByObsRemote = new Map();
+    const changesByObsLocal = new Map();
+    const outRemote = new Map();
+    const outLocal = new Map();
+    for (let i = 0; i < allChanges.length; i++) {
+        const value = allChanges[i];
+        const { obs, changes, inRemoteChange } = value;
+        const changesMap = inRemoteChange ? changesByObsRemote : changesByObsLocal;
+        const existing = changesMap.get(obs);
+        const newChanges = existing ? [...existing, ...changes] : changes;
+        const merged = mergeChanges$1(newChanges);
+        changesMap.set(obs, merged);
+        value.changes = merged;
+        (inRemoteChange ? outRemote : outLocal).set(obs, value);
+    }
+    return Array.from(outRemote.values()).concat(Array.from(outLocal.values()));
+}
+async function processQueuedChanges$1() {
+    var _a;
     // Get a local copy of the queued changes and clear the global queue
-    const queuedChanges = _queuedChanges;
-    _queuedChanges = [];
+    const queuedChanges = mergeQueuedChanges$1(_queuedChanges$1);
+    _queuedChanges$1 = [];
+    _queuedRemoteChanges$1.push(...queuedChanges.filter((c) => !c.inRemoteChange));
     // Note: Summary of the order of operations these functions:
     // 1. Prepare all changes for saving. This may involve waiting for promises if the user has asynchronous transform.
     // We need to prepare all of the changes in the queue before saving so that the saves happen in the correct order,
     // since some may take longer to transformSaveData than others.
-    const changes = await Promise.all(queuedChanges.map(prepChange));
     // 2. Save pending to the metadata table first. If this is the only operation that succeeds, it would try to save
     // the current value again on next load, which isn't too bad.
     // 3. Save local changes to storage. If they never make it to remote, then on the next load they will be pending
@@ -257,25 +316,46 @@ async function processQueuedChanges() {
     // 4. Wait for remote load or error if allowed
     // 5. Save to remote
     // 6. On successful save, merge changes (if any) back into observable
-    // 7. Lastly, update metadata to clear pending and update dateModified. Doing this earlier could potentially cause
+    // 7. Lastly, update metadata to clear pending and update lastSync. Doing this earlier could potentially cause
     // sync inconsistences so it's very important that this is last.
-    changes.forEach(doChange);
+    const preppedChangesLocal = await Promise.all(queuedChanges.map(prepChangeLocal$1));
+    // TODO Clean this up: We only need to prep this now in ordre to save pending changes, don't need any of the other stuff. Should split that up?
+    await Promise.all(queuedChanges.map(prepChangeRemote$1));
+    await Promise.all(preppedChangesLocal.map(doChangeLocal$1));
+    const timeout = (_a = observablePersistConfiguration === null || observablePersistConfiguration === void 0 ? void 0 : observablePersistConfiguration.remoteOptions) === null || _a === void 0 ? void 0 : _a.debounceSet;
+    if (timeout) {
+        if (timeoutSaveRemote) {
+            clearTimeout(timeoutSaveRemote);
+        }
+        timeoutSaveRemote = setTimeout(processQueuedRemoteChanges$1, timeout);
+    }
+    else {
+        processQueuedRemoteChanges$1();
+    }
+}
+async function processQueuedRemoteChanges$1() {
+    const queuedRemoteChanges = mergeQueuedChanges$1(_queuedRemoteChanges$1);
+    _queuedRemoteChanges$1 = [];
+    const preppedChangesRemote = await Promise.all(queuedRemoteChanges.map(prepChangeRemote$1));
+    preppedChangesRemote.forEach(doChangeRemote$1);
 }
-async function prepChange(queuedChange) {
+async function prepChangeLocal$1(queuedChange) {
     const { syncState, changes, localState, persistOptions, inRemoteChange, isApplyingPending } = queuedChange;
     const local = persistOptions.local;
     const { persistenceRemote } = localState;
-    const { config: configLocal } = parseLocalConfig(local);
+    const { config: configLocal } = parseLocalConfig$1(local);
     const configRemote = persistOptions.remote;
     const saveLocal = local && !configLocal.readonly && !isApplyingPending && syncState.isEnabledLocal.peek();
-    const saveRemote = !inRemoteChange && (persistenceRemote === null || persistenceRemote === void 0 ? void 0 : persistenceRemote.set) && !(configRemote === null || configRemote === void 0 ? void 0 : configRemote.readonly) && syncState.isEnabledRemote.peek();
+    const saveRemote = !!(!inRemoteChange &&
+        (persistenceRemote === null || persistenceRemote === void 0 ? void 0 : persistenceRemote.set) &&
+        !(configRemote === null || configRemote === void 0 ? void 0 : configRemote.readonly) &&
+        syncState.isEnabledRemote.peek());
     if (saveLocal || saveRemote) {
         if (saveLocal && !syncState.isLoadedLocal.peek()) {
             console.error('[legend-state] WARNING: An observable was changed before being loaded from persistence', local);
-            return;
+            return undefined;
         }
         const changesLocal = [];
-        const changesRemote = [];
         const changesPaths = new Set();
         let promisesTransform = [];
         // Reverse order
@@ -300,7 +380,7 @@ async function prepChange(queuedChange) {
                 const { prevAtPath, valueAtPath, pathTypes } = changes[i];
                 if (saveLocal) {
                     const promiseTransformLocal = transformOutData(valueAtPath, path, pathTypes, configLocal);
-                    promisesTransform.push(doInOrder(promiseTransformLocal, ({ path: pathTransformed, value: valueTransformed }) => {
+                    promisesTransform.push(doInOrder$1(promiseTransformLocal, ({ path: pathTransformed, value: valueTransformed }) => {
                         // If path includes undefined there was a null in fieldTransforms so don't need to save it
                         if (!pathTransformed.includes(undefined)) {
                             // Prepare the local change with the transformed path/value
@@ -314,9 +394,55 @@ async function prepChange(queuedChange) {
                         }
                     }));
                 }
+            }
+        }
+        // If there's any transform promises, wait for them before saving
+        promisesTransform = promisesTransform.filter(Boolean);
+        if (promisesTransform.length > 0) {
+            await Promise.all(promisesTransform);
+        }
+        return { queuedChange, changesLocal, saveRemote };
+    }
+}
+async function prepChangeRemote$1(queuedChange) {
+    const { syncState, changes, localState, persistOptions, inRemoteChange, isApplyingPending } = queuedChange;
+    const local = persistOptions.local;
+    const { persistenceRemote } = localState;
+    const { config: configLocal } = parseLocalConfig$1(local);
+    const configRemote = persistOptions.remote;
+    const saveLocal = local && !configLocal.readonly && !isApplyingPending && syncState.isEnabledLocal.peek();
+    const saveRemote = !inRemoteChange && (persistenceRemote === null || persistenceRemote === void 0 ? void 0 : persistenceRemote.set) && !(configRemote === null || configRemote === void 0 ? void 0 : configRemote.readonly) && syncState.isEnabledRemote.peek();
+    if (saveLocal || saveRemote) {
+        if (saveLocal && !syncState.isLoadedLocal.peek()) {
+            console.error('[legend-state] WARNING: An observable was changed before being loaded from persistence', local);
+            return undefined;
+        }
+        const changesRemote = [];
+        const changesPaths = new Set();
+        let promisesTransform = [];
+        // Reverse order
+        for (let i = changes.length - 1; i >= 0; i--) {
+            const { path } = changes[i];
+            let found = false;
+            // Optimization to only save the latest update at each path. We might have multiple changes at the same path
+            // and we only need the latest value, so it starts from the end of the array, skipping any earlier changes
+            // already processed. If a later change modifies a parent of an earlier change (which happens on delete()
+            // it should be ignored as it's superseded by the parent modification.
+            if (changesPaths.size > 0) {
+                for (let u = 0; u < path.length; u++) {
+                    if (changesPaths.has((u === path.length - 1 ? path : path.slice(0, u + 1)).join('/'))) {
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            if (!found) {
+                const pathStr = path.join('/');
+                changesPaths.add(pathStr);
+                const { prevAtPath, valueAtPath, pathTypes } = changes[i];
                 if (saveRemote) {
                     const promiseTransformRemote = transformOutData(valueAtPath, path, pathTypes, configRemote || {});
-                    promisesTransform.push(doInOrder(promiseTransformRemote, ({ path: pathTransformed, value: valueTransformed }) => {
+                    promisesTransform.push(doInOrder$1(promiseTransformRemote, ({ path: pathTransformed, value: valueTransformed }) => {
                         var _a;
                         // If path includes undefined there was a null in fieldTransforms so don't need to save it
                         if (!pathTransformed.includes(undefined)) {
@@ -371,23 +497,22 @@ async function prepChange(queuedChange) {
         if (promisesTransform.length > 0) {
             await Promise.all(promisesTransform);
         }
-        return { queuedChange, changesLocal, changesRemote };
+        return { queuedChange, changesRemote };
     }
 }
-async function doChange(changeInfo) {
-    var _a, _b, _c, _d;
+async function doChangeLocal$1(changeInfo) {
     if (!changeInfo)
         return;
-    const { queuedChange, changesLocal, changesRemote } = changeInfo;
+    const { queuedChange, changesLocal, saveRemote } = changeInfo;
     const { obs, syncState, localState, persistOptions } = queuedChange;
-    const { persistenceLocal, persistenceRemote } = localState;
+    const { persistenceLocal } = localState;
     const local = persistOptions.local;
-    const { table, config: configLocal } = parseLocalConfig(local);
+    const { table, config: configLocal } = parseLocalConfig$1(local);
     const configRemote = persistOptions.remote;
     const shouldSaveMetadata = local && (configRemote === null || configRemote === void 0 ? void 0 : configRemote.offlineBehavior) === 'retry';
-    if (changesRemote.length > 0 && shouldSaveMetadata) {
+    if (saveRemote && shouldSaveMetadata) {
         // First save pending changes before saving local or remote
-        await updateMetadataImmediate(obs, localState, syncState, persistOptions, {
+        await updateMetadataImmediate$1(obs, localState, syncState, persistOptions, {
             pending: localState.pendingChanges,
         });
     }
@@ -397,37 +522,63 @@ async function doChange(changeInfo) {
         let promiseSet = persistenceLocal.set(table, changesLocal, configLocal);
         if (promiseSet) {
             promiseSet = promiseSet.then(() => {
-                promisesLocalSaves.delete(promiseSet);
+                promisesLocalSaves$1.delete(promiseSet);
             });
             // Keep track of local save promises so that updateMetadata runs only after everything is saved
-            promisesLocalSaves.add(promiseSet);
+            promisesLocalSaves$1.add(promiseSet);
             // await the local save before proceeding to save remotely
             await promiseSet;
         }
     }
+}
+async function doChangeRemote$1(changeInfo) {
+    var _a;
+    if (!changeInfo)
+        return;
+    const { queuedChange, changesRemote } = changeInfo;
+    const { obs, syncState, localState, persistOptions } = queuedChange;
+    const { persistenceLocal, persistenceRemote } = localState;
+    const local = persistOptions.local;
+    const { table, config: configLocal } = parseLocalConfig$1(local);
+    const { offlineBehavior, allowSetIfError, onBeforeSet, onSetError, waitForSet, onAfterSet } = persistOptions.remote || {};
+    const shouldSaveMetadata = local && offlineBehavior === 'retry';
     if (changesRemote.length > 0) {
         // Wait for remote to be ready before saving
-        await state.when(() => syncState.isLoaded.get() || ((configRemote === null || configRemote === void 0 ? void 0 : configRemote.allowSetIfError) && syncState.error.get()));
+        await state.when(() => syncState.isLoaded.get() || (allowSetIfError && syncState.error.get()));
+        if (waitForSet) {
+            const waitFor = state.isFunction(waitForSet)
+                ? waitForSet({ changes: changesRemote, value: obs.peek() })
+                : waitForSet;
+            if (waitFor) {
+                await state.when(waitFor);
+            }
+        }
         const value = obs.peek();
-        (_a = configRemote === null || configRemote === void 0 ? void 0 : configRemote.onBeforeSet) === null || _a === void 0 ? void 0 : _a.call(configRemote);
-        const saved = await ((_b = persistenceRemote.set({
+        onBeforeSet === null || onBeforeSet === void 0 ? void 0 : onBeforeSet();
+        localState.numSavesOutstanding = (localState.numSavesOutstanding || 0) + 1;
+        let savedPromise = persistenceRemote.set({
             obs,
             syncState: syncState,
             options: persistOptions,
             changes: changesRemote,
             value,
-        })) === null || _b === void 0 ? void 0 : _b.catch((err) => { var _a; return (_a = configRemote === null || configRemote === void 0 ? void 0 : configRemote.onSetError) === null || _a === void 0 ? void 0 : _a.call(configRemote, err); }));
+        });
+        if (state.isPromise(savedPromise)) {
+            savedPromise = savedPromise.catch((err) => onSetError === null || onSetError === void 0 ? void 0 : onSetError(err));
+        }
+        const saved = await savedPromise;
+        localState.numSavesOutstanding--;
         // If this remote save changed anything then update persistence and metadata
         // Because save happens after a timeout and they're batched together, some calls to save will
         // return saved data and others won't, so those can be ignored.
         if (saved) {
             const pathStrs = Array.from(new Set(changesRemote.map((change) => change.pathStr)));
-            const { changes, dateModified } = saved;
+            const { changes, lastSync } = saved;
             if (pathStrs.length > 0) {
                 if (local) {
                     const metadata = {};
-                    const pending = (_c = persistenceLocal.getMetadata(table, configLocal)) === null || _c === void 0 ? void 0 : _c.pending;
-                    let transformedChanges = [];
+                    const pending = (_a = persistenceLocal.getMetadata(table, configLocal)) === null || _a === void 0 ? void 0 : _a.pending;
+                    let transformedChanges = undefined;
                     for (let i = 0; i < pathStrs.length; i++) {
                         const pathStr = pathStrs[i];
                         // Clear pending for this path
@@ -437,35 +588,47 @@ async function doChange(changeInfo) {
                             metadata.pending = pending;
                         }
                     }
-                    if (dateModified) {
-                        metadata.modified = dateModified;
+                    if (lastSync) {
+                        metadata.lastSync = lastSync;
                     }
                     // Remote can optionally have data that needs to be merged back into the observable,
                     // for example Firebase may update dateModified with the server timestamp
                     if (changes && !state.isEmpty(changes)) {
-                        transformedChanges.push(transformLoadData(changes, persistOptions.remote, false));
+                        transformedChanges = transformLoadData$1(changes, persistOptions.remote, false);
                     }
-                    if (transformedChanges.length > 0) {
-                        if (transformedChanges.some((change) => state.isPromise(change))) {
-                            transformedChanges = await Promise.all(transformedChanges);
+                    if (localState.numSavesOutstanding > 0) {
+                        if (transformedChanges) {
+                            if (!localState.pendingSaveResults) {
+                                localState.pendingSaveResults = [];
+                            }
+                            localState.pendingSaveResults.push(transformedChanges);
                         }
-                        onChangeRemote(() => state.mergeIntoObservable(obs, ...transformedChanges));
                     }
-                    if (shouldSaveMetadata && !state.isEmpty(metadata)) {
-                        updateMetadata(obs, localState, syncState, persistOptions, metadata);
+                    else {
+                        let allChanges = [...(localState.pendingSaveResults || []), transformedChanges];
+                        if (allChanges.length > 0) {
+                            if (allChanges.some((change) => state.isPromise(change))) {
+                                allChanges = await Promise.all(allChanges);
+                            }
+                            onChangeRemote$1(() => state.mergeIntoObservable(obs, ...allChanges));
+                        }
+                        if (shouldSaveMetadata && !state.isEmpty(metadata)) {
+                            updateMetadata$1(obs, localState, syncState, persistOptions, metadata);
+                        }
+                        localState.pendingSaveResults = [];
                     }
                 }
-                (_d = configRemote === null || configRemote === void 0 ? void 0 : configRemote.onSet) === null || _d === void 0 ? void 0 : _d.call(configRemote);
+                onAfterSet === null || onAfterSet === void 0 ? void 0 : onAfterSet();
             }
         }
     }
 }
-function onObsChange(obs, syncState, localState, persistOptions, { changes }) {
-    if (!state.internal.globalState.isLoadingLocal) {
-        const inRemoteChange = state.internal.globalState.isLoadingRemote$.peek();
+function onObsChange$1(obs, syncState, localState, persistOptions, { changes, loading, remote }) {
+    if (!loading) {
+        const inRemoteChange = remote;
         const isApplyingPending = localState.isApplyingPending;
         // Queue changes in a microtask so that multiple changes within a frame get run together
-        _queuedChanges.push({
+        _queuedChanges$1.push({
             obs: obs,
             syncState,
             localState,
@@ -474,17 +637,17 @@ function onObsChange(obs, syncState, localState, persistOptions, { changes }) {
             inRemoteChange,
             isApplyingPending: isApplyingPending,
         });
-        if (_queuedChanges.length === 1) {
-            queueMicrotask(processQueuedChanges);
+        if (_queuedChanges$1.length === 1) {
+            queueMicrotask(processQueuedChanges$1);
         }
     }
 }
-async function loadLocal(obs, persistOptions, syncState, localState) {
+async function loadLocal$1(obs, persistOptions, syncState, localState) {
     var _a;
     const { local } = persistOptions;
     const localPersistence = persistOptions.pluginLocal || observablePersistConfiguration.pluginLocal;
     if (local) {
-        const { table, config } = parseLocalConfig(local);
+        const { table, config } = parseLocalConfig$1(local);
         if (!localPersistence) {
             throw new Error('Local persistence is not configured');
         }
@@ -503,7 +666,7 @@ async function loadLocal(obs, persistOptions, syncState, localState) {
         }
         const { persist: persistenceLocal, initialized } = mapPersistences.get(localPersistence);
         localState.persistenceLocal = persistenceLocal;
-        if (!initialized.get()) {
+        if (!initialized.peek()) {
             await state.when(initialized);
         }
         // If persistence has an asynchronous load, wait for it
@@ -517,28 +680,40 @@ async function loadLocal(obs, persistOptions, syncState, localState) {
         let value = persistenceLocal.getTable(table, config);
         const metadata = persistenceLocal.getMetadata(table, config);
         if (metadata) {
-            metadatas.set(obs, metadata);
+            // @ts-expect-error Migration from old version
+            if (!metadata.lastSync && metadata.modified) {
+                // @ts-expect-error Migration from old
+                metadata.lastSync = metadata.modified;
+            }
+            metadatas$1.set(obs, metadata);
             localState.pendingChanges = metadata.pending;
-            syncState.dateModified.set(metadata.modified);
+            // TODOV3 Remove dateModified
+            syncState.assign({
+                dateModified: metadata.lastSync,
+                lastSync: metadata.lastSync,
+            });
         }
         // Merge the data from local persistence into the default state
-        if (value !== null && value !== undefined) {
+        if (value !== undefined) {
             const { transform, fieldTransforms } = config;
-            value = transformLoadData(value, { transform, fieldTransforms }, true);
+            value = transformLoadData$1(value, { transform, fieldTransforms }, true);
             if (state.isPromise(value)) {
                 value = await value;
             }
-            state.batch(() => {
-                // isLoadingLocal prevents saving remotely when two different persistences
-                // are set on the same observable
-                state.internal.globalState.isLoadingLocal = true;
-                // We want to merge the local data on top of any initial state the object is created with
+            // isLoadingLocal prevents saving remotely when two different persistences
+            // are set on the same observable
+            state.internal.globalState.isLoadingLocal = true;
+            // We want to merge the local data on top of any initial state the object is created with
+            const prevValue = obs.peek();
+            if (value === null && (!prevValue || prevValue[symbolLinked$3])) {
+                obs.set(value);
+            }
+            else {
                 state.mergeIntoObservable(obs, value);
-            }, () => {
-                state.internal.globalState.isLoadingLocal = false;
-            });
+            }
+            state.internal.globalState.isLoadingLocal = false;
         }
-        const node = state.getNode(obs);
+        const node = getNode$1(obs);
         node.state.peek().clearLocal = () => Promise.all([
             persistenceLocal.deleteTable(table, config),
             persistenceLocal.deleteMetadata(table, config),
@@ -547,17 +722,13 @@ async function loadLocal(obs, persistOptions, syncState, localState) {
     syncState.isLoadedLocal.set(true);
 }
 function persistObservable(initialOrObservable, persistOptions) {
-    var _a;
-    const obs = (state.isObservable(initialOrObservable)
+    const obs$ = (state.isObservable(initialOrObservable)
         ? initialOrObservable
         : state.observable(state.isFunction(initialOrObservable) ? initialOrObservable() : initialOrObservable));
-    const node = state.getNode(obs);
-    if (process.env.NODE_ENV === 'development' && ((_a = obs === null || obs === void 0 ? void 0 : obs.peek()) === null || _a === void 0 ? void 0 : _a._state)) {
-        console.warn('[legend-state] WARNING: persistObservable creates a property named "_state" but your observable already has "state" in it');
-    }
-    // Merge remote persist options with clobal options
+    const node = getNode$1(obs$);
+    // Merge remote persist options with global options
     if (persistOptions.remote) {
-        persistOptions.remote = Object.assign({}, observablePersistConfiguration.remoteOptions, persistOptions.remote);
+        persistOptions.remote = Object.assign({}, observablePersistConfiguration.remoteOptions, removeNullUndefined(persistOptions.remote));
     }
     let { remote } = persistOptions;
     const { local } = persistOptions;
@@ -569,12 +740,11 @@ function persistObservable(initialOrObservable, persistOptions) {
         isLoaded: false,
         isEnabledLocal: true,
         isEnabledRemote: true,
-        refreshNum: 0,
         clearLocal: undefined,
         sync: () => Promise.resolve(),
         getPendingChanges: () => localState.pendingChanges,
     }));
-    loadLocal(obs, persistOptions, syncState, localState);
+    loadLocal$1(obs$, persistOptions, syncState, localState);
     if (remote || remotePersistence) {
         if (!remotePersistence) {
             throw new Error('Remote persistence is not configured');
@@ -598,88 +768,92 @@ function persistObservable(initialOrObservable, persistOptions) {
         let isSynced = false;
         sync = async () => {
             var _a, _b;
-            if (!isSynced) {
-                isSynced = true;
-                const dateModified = (_a = metadatas.get(obs)) === null || _a === void 0 ? void 0 : _a.modified;
-                const get = (_b = localState.persistenceRemote.get) === null || _b === void 0 ? void 0 : _b.bind(localState.persistenceRemote);
-                if (get) {
-                    const runGet = () => {
-                        get({
-                            state: syncState,
-                            obs,
-                            options: persistOptions,
-                            dateModified,
-                            onError: (error) => {
-                                var _a;
-                                (_a = remote.onGetError) === null || _a === void 0 ? void 0 : _a.call(remote, error);
-                            },
-                            onGet: () => {
-                                node.state.assign({
-                                    isLoaded: true,
-                                    error: undefined,
-                                });
-                            },
-                            onChange: async ({ value, path = [], pathTypes = [], mode = 'set', dateModified }) => {
-                                // Note: value is the constructed value, path is used for setInObservableAtPath
-                                // to start the set into the observable from the path
-                                if (value !== undefined) {
-                                    value = transformLoadData(value, remote, true);
-                                    if (state.isPromise(value)) {
-                                        value = await value;
-                                    }
-                                    const invertedMap = remote.fieldTransforms && invertFieldMap(remote.fieldTransforms);
-                                    if (path.length && invertedMap) {
-                                        path = transformPath(path, pathTypes, invertedMap);
-                                    }
-                                    if (mode === 'dateModified') {
-                                        if (dateModified && !state.isEmpty(value)) {
-                                            onChangeRemote(() => {
-                                                state.setInObservableAtPath(obs, path, pathTypes, value, 'assign');
-                                            });
-                                        }
-                                    }
-                                    else {
-                                        const pending = localState.pendingChanges;
-                                        if (pending) {
-                                            Object.keys(pending).forEach((key) => {
-                                                const p = key.split('/').filter((p) => p !== '');
-                                                const { v, t } = pending[key];
-                                                if (value[p[0]] !== undefined) {
-                                                    value = state.setAtPath(value, p, t, v, obs.peek(), (path, value) => {
-                                                        delete pending[key];
-                                                        pending[path.join('/')] = {
-                                                            p: null,
-                                                            v: value,
-                                                            t: t.slice(0, path.length),
-                                                        };
-                                                    });
-                                                }
-                                            });
-                                        }
-                                        onChangeRemote(() => {
-                                            state.setInObservableAtPath(obs, path, pathTypes, value, mode);
+            const lastSync = (_a = metadatas$1.get(obs$)) === null || _a === void 0 ? void 0 : _a.lastSync;
+            const pending = localState.pendingChanges;
+            const get = (_b = localState.persistenceRemote.get) === null || _b === void 0 ? void 0 : _b.bind(localState.persistenceRemote);
+            if (get) {
+                const runGet = () => {
+                    get({
+                        state: syncState,
+                        obs: obs$,
+                        options: persistOptions,
+                        lastSync,
+                        dateModified: lastSync,
+                        onError: (error) => {
+                            var _a;
+                            (_a = remote.onGetError) === null || _a === void 0 ? void 0 : _a.call(remote, error);
+                        },
+                        onGet: () => {
+                            node.state.assign({
+                                isLoaded: true,
+                                error: undefined,
+                            });
+                        },
+                        onChange: async ({ value, path = [], pathTypes = [], mode = 'set', lastSync }) => {
+                            // Note: value is the constructed value, path is used for setInObservableAtPath
+                            // to start the set into the observable from the path
+                            if (value !== undefined) {
+                                value = transformLoadData$1(value, remote, true);
+                                if (state.isPromise(value)) {
+                                    value = await value;
+                                }
+                                const invertedMap = remote.fieldTransforms && invertFieldMap(remote.fieldTransforms);
+                                if (path.length && invertedMap) {
+                                    path = transformPath(path, pathTypes, invertedMap);
+                                }
+                                if (mode === 'lastSync' || mode === 'dateModified') {
+                                    if (lastSync && !state.isEmpty(value)) {
+                                        onChangeRemote$1(() => {
+                                            state.setInObservableAtPath(obs$, path, pathTypes, value, 'assign');
                                         });
                                     }
                                 }
-                                if (dateModified && local) {
-                                    updateMetadata(obs, localState, syncState, persistOptions, {
-                                        modified: dateModified,
+                                else {
+                                    const pending = localState.pendingChanges;
+                                    if (pending) {
+                                        Object.keys(pending).forEach((key) => {
+                                            const p = key.split('/').filter((p) => p !== '');
+                                            const { v, t } = pending[key];
+                                            if (t.length === 0 || !value) {
+                                                value = v;
+                                            }
+                                            else if (value[p[0]] !== undefined) {
+                                                value = state.setAtPath(value, p, t, v, obs$.peek(), (path, value) => {
+                                                    delete pending[key];
+                                                    pending[path.join('/')] = {
+                                                        p: null,
+                                                        v: value,
+                                                        t: t.slice(0, path.length),
+                                                    };
+                                                });
+                                            }
+                                        });
+                                    }
+                                    onChangeRemote$1(() => {
+                                        state.setInObservableAtPath(obs$, path, pathTypes, value, mode);
                                     });
                                 }
-                            },
-                        });
-                    };
-                    runGet();
-                }
-                else {
-                    node.state.assign({
-                        isLoaded: true,
-                        error: undefined,
+                            }
+                            if (lastSync && local) {
+                                updateMetadata$1(obs$, localState, syncState, persistOptions, {
+                                    lastSync,
+                                });
+                            }
+                        },
                     });
-                }
+                };
+                runGet();
+            }
+            else {
+                node.state.assign({
+                    isLoaded: true,
+                    error: undefined,
+                });
+            }
+            if (!isSynced) {
+                isSynced = true;
                 // Wait for remote to be ready before saving pending
                 await state.when(() => syncState.isLoaded.get() || (remote.allowSetIfError && syncState.error.get()));
-                const pending = localState.pendingChanges;
                 if (pending && !state.isEmpty(pending)) {
                     localState.isApplyingPending = true;
                     const keys = Object.keys(pending);
@@ -692,8 +866,11 @@ function persistObservable(initialOrObservable, persistOptions) {
                         changes.push({ path, valueAtPath: v, prevAtPath: p, pathTypes: t });
                     }
                     // Send the changes into onObsChange so that they get persisted remotely
-                    onObsChange(obs, syncState, localState, persistOptions, {
-                        value: obs.peek(),
+                    // TODO: Not sure why this needs to as unknown as Observable
+                    onObsChange$1(obs$, syncState, localState, persistOptions, {
+                        value: obs$.peek(),
+                        loading: false,
+                        remote: false,
                         // TODO getPrevious if any remote persistence layers need it
                         getPrevious: () => undefined,
                         changes,
@@ -702,17 +879,15 @@ function persistObservable(initialOrObservable, persistOptions) {
                 }
             }
         };
-        // If remote is manual, then sync() must be called manually
-        if (remote.manual) {
-            syncState.assign({ sync });
-        }
+        syncState.assign({ sync });
     }
     // Wait for this node and all parent nodes up the hierarchy to be loaded
     const onAllLoadedLocal = () => {
         var _a, _b;
         let parentNode = node;
         while (parentNode) {
-            if (((_b = (_a = parentNode.state) === null || _a === void 0 ? void 0 : _a.isLoadedLocal) === null || _b === void 0 ? void 0 : _b.get()) === false) {
+            if (((_b = (_a = parentNode.state) === null || _a === void 0 ? void 0 : _a.isLoadedLocal) === null || _b === void 0 ? void 0 : _b.get()) ===
+                false) {
                 return false;
             }
             parentNode = parentNode.parent;
@@ -725,100 +900,925 @@ function persistObservable(initialOrObservable, persistOptions) {
         if (remote && !remote.manual) {
             sync();
         }
-        obs.onChange(onObsChange.bind(this, obs, syncState, localState, persistOptions));
+        obs$.onChange(onObsChange$1.bind(this, obs$, syncState, localState, persistOptions));
     });
-    return obs;
+    return obs$;
 }
 
-const { getProxy, globalState, setupRetry } = state.internal;
-function persistActivateNode() {
-    globalState.activateNode = function activateNodePersist(node, refresh, wasPromise, newValue) {
-        const { onSetFn, subscriber, lastSync, cacheOptions, retryOptions } = node.activationState;
-        let onChange = undefined;
-        const pluginRemote = {
-            get: async (params) => {
-                onChange = params.onChange;
-                if (state.isPromise(newValue)) {
-                    try {
-                        newValue = await newValue;
-                        // eslint-disable-next-line no-empty
-                    }
-                    catch (_a) { }
-                }
-                if (lastSync.value) {
-                    params.dateModified = lastSync.value;
-                }
-                return newValue;
-            },
-        };
-        if (onSetFn) {
-            // TODO: Work out these types better
-            pluginRemote.set = async (params) => {
-                var _a;
-                if ((_a = node.state) === null || _a === void 0 ? void 0 : _a.isLoaded.get()) {
-                    return new Promise((resolve) => {
-                        const attemptNum = { current: 0 };
-                        const run = async () => {
-                            let changes = {};
-                            let maxModified = 0;
-                            let didError = false;
-                            let onError;
-                            if (retryOptions) {
-                                onError = setupRetry(retryOptions, run, attemptNum).handleError;
-                            }
-                            await onSetFn(params, {
-                                update: (params) => {
-                                    const { value, dateModified } = params;
-                                    maxModified = Math.max(dateModified || 0, maxModified);
-                                    changes = state.mergeIntoObservable(changes, value);
-                                },
-                                onError: () => {
-                                    didError = true;
-                                    onError === null || onError === void 0 ? void 0 : onError();
-                                },
-                                refresh,
-                            });
-                            if (!didError) {
-                                resolve({ changes, dateModified: maxModified || undefined });
-                            }
-                        };
-                        run();
-                    });
+const observableSyncConfiguration = {};
+
+function syncObservableAdapter({ get, set }) {
+    const ret = {};
+    if (get) {
+        ret.get = (async (params) => {
+            try {
+                let value = get(params);
+                if (state.isPromise(value)) {
+                    value = await value;
                 }
-            };
+                params.onChange({
+                    value,
+                    lastSync: params.lastSync,
+                    mode: params.mode,
+                });
+                params.onGet();
+                // eslint-disable-next-line no-empty
+            }
+            catch (_a) { }
+        });
+    }
+    if (set) {
+        ret.set = set;
+    }
+    return ret;
+}
+
+const { createPreviousHandler, clone, getValueAtPath, globalState: globalState$1, symbolLinked: symbolLinked$2, getNode, getNodeValue: getNodeValue$1 } = state.internal;
+const mapSyncPlugins = new WeakMap();
+const metadatas = new WeakMap();
+const promisesLocalSaves = new Set();
+function parseLocalConfig(config) {
+    return config
+        ? state.isString(config)
+            ? { table: config, config: { name: config } }
+            : { table: config.name, config }
+        : {};
+}
+function doInOrder(arg1, arg2) {
+    return state.isPromise(arg1) ? arg1.then(arg2) : arg2(arg1);
+}
+function onChangeRemote(cb) {
+    state.endBatch(true);
+    // Remote changes should only update local state
+    globalState$1.isLoadingRemote = true;
+    state.beginBatch();
+    cb();
+    // Reset isLoadingRemote before ending the batch so it doesn't
+    // apply to any side effects
+    globalState$1.isLoadingRemote = false;
+    state.endBatch(true);
+}
+function transformSaveData(value, path, pathTypes, { transform }) {
+    if (transform === null || transform === void 0 ? void 0 : transform.save) {
+        const constructed = state.constructObjectWithPath(path, pathTypes, value);
+        const saved = transform.save(constructed);
+        value = state.deconstructObjectWithPath(path, pathTypes, saved);
+    }
+    return value;
+}
+function transformLoadData(value, { transform }, doUserTransform, method) {
+    if (doUserTransform && (transform === null || transform === void 0 ? void 0 : transform.load)) {
+        value = transform.load(value, method);
+    }
+    return value;
+}
+async function updateMetadataImmediate(obs, localState, syncState, syncOptions, newMetadata) {
+    const saves = Array.from(promisesLocalSaves);
+    if (saves.length > 0) {
+        await Promise.all(saves);
+    }
+    const { pluginPersist } = localState;
+    const { table, config } = parseLocalConfig(syncOptions === null || syncOptions === void 0 ? void 0 : syncOptions.persist);
+    // Save metadata
+    const oldMetadata = metadatas.get(obs);
+    const { lastSync, pending } = newMetadata;
+    const needsUpdate = pending || (lastSync && (!oldMetadata || lastSync !== oldMetadata.lastSync));
+    if (needsUpdate) {
+        const metadata = Object.assign({}, oldMetadata, newMetadata);
+        metadatas.set(obs, metadata);
+        if (pluginPersist) {
+            await pluginPersist.setMetadata(table, metadata, config);
         }
-        if (subscriber) {
-            subscriber({
-                update: (params) => {
-                    if (!onChange) {
-                        // TODO: Make this message better
-                        console.log('[legend-state] Cannot update immediately before the first return');
-                    }
-                    else {
-                        onChange(params);
-                    }
-                },
-                refresh,
+        if (lastSync) {
+            syncState.assign({
+                lastSync: lastSync,
             });
         }
-        persistObservable(getProxy(node), {
-            pluginRemote,
-            ...(cacheOptions || {}),
-            remote: {
-                retry: retryOptions,
-            },
-        });
-        return { update: onChange };
-    };
+    }
+}
+function updateMetadata(obs, localState, syncState, syncOptions, newMetadata) {
+    if (localState.timeoutSaveMetadata) {
+        clearTimeout(localState.timeoutSaveMetadata);
+    }
+    localState.timeoutSaveMetadata = setTimeout(() => updateMetadataImmediate(obs, localState, syncState, syncOptions, newMetadata), 0);
+}
+let _queuedChanges = [];
+const _queuedRemoteChanges = new Map();
+const _queuedRemoteChangesTimeouts = new Map();
+function mergeChanges(changes) {
+    const changesByPath = new Map();
+    const changesOut = [];
+    // TODO: This could be even more robust by going deeper into paths like the firebase plugin's _updatePendingSave
+    for (let i = 0; i < changes.length; i++) {
+        const change = changes[i];
+        const pathStr = change.path.join('/');
+        const existing = changesByPath.get(pathStr);
+        if (existing) {
+            // If setting a value back to what it was, no need to save it
+            if (change.valueAtPath === existing.prevAtPath) {
+                changesOut.splice(changesOut.indexOf(change), 1);
+            }
+            else {
+                existing.valueAtPath = change.valueAtPath;
+            }
+        }
+        else {
+            changesByPath.set(pathStr, change);
+            changesOut.push(change);
+        }
+    }
+    return changesOut;
+}
+function mergeQueuedChanges(allChanges) {
+    const changesByObsRemote = new Map();
+    const changesByObsLocal = new Map();
+    const previousByObs = new Map();
+    const outRemote = new Map();
+    const outLocal = new Map();
+    for (let i = 0; i < allChanges.length; i++) {
+        const value = allChanges[i];
+        const { obs, changes, inRemoteChange, getPrevious } = value;
+        const targetMap = inRemoteChange ? outRemote : outLocal;
+        const changesMap = inRemoteChange ? changesByObsRemote : changesByObsLocal;
+        const existing = changesMap.get(obs);
+        const newChanges = existing ? [...existing, ...changes] : changes;
+        const merged = mergeChanges(newChanges);
+        changesMap.set(obs, merged);
+        value.changes = merged;
+        if (!previousByObs.has(obs)) {
+            previousByObs.set(obs, getPrevious());
+        }
+        value.valuePrevious = previousByObs.get(obs);
+        targetMap.set(obs, value);
+    }
+    return Array.from(outRemote.values()).concat(Array.from(outLocal.values()));
+}
+async function processQueuedChanges() {
+    var _a;
+    // Get a local copy of the queued changes and clear the global queue
+    const queuedChanges = mergeQueuedChanges(_queuedChanges);
+    _queuedChanges = [];
+    const pendingSyncOptions = new Set();
+    for (let i = 0; i < queuedChanges.length; i++) {
+        const change = queuedChanges[i];
+        if (!change.inRemoteChange) {
+            if (!_queuedRemoteChanges.has(change.syncOptions)) {
+                _queuedRemoteChanges.set(change.syncOptions, []);
+            }
+            pendingSyncOptions.add(change.syncOptions);
+            _queuedRemoteChanges.get(change.syncOptions).push(change);
+        }
+    }
+    // Note: Summary of the order of operations these functions:
+    // 1. Prepare all changes for saving. This may involve waiting for promises if the user has asynchronous transform.
+    // We need to prepare all of the changes in the queue before saving so that the saves happen in the correct order,
+    // since some may take longer to transformSaveData than others.
+    // 2. Save pending to the metadata table first. If this is the only operation that succeeds, it would try to save
+    // the current value again on next load, which isn't too bad.
+    // 3. Save local changes to storage. If they never make it to remote, then on the next load they will be pending
+    // and attempted again.
+    // 4. Wait for remote load or error if allowed
+    // 5. Save to remote
+    // 6. On successful save, merge changes (if any) back into observable
+    // 7. Lastly, update metadata to clear pending and update lastSync. Doing this earlier could potentially cause
+    // sync inconsistences so it's very important that this is last.
+    const preppedChangesLocal = await Promise.all(queuedChanges.map(prepChangeLocal));
+    // TODO Clean this up: We only need to prep this now in order to save pending changes, don't need any of the other stuff. Should split that up?
+    await Promise.all(queuedChanges.map(prepChangeRemote));
+    await Promise.all(preppedChangesLocal.map(doChangeLocal));
+    for (const options of pendingSyncOptions) {
+        const timeout = (_a = options.debounceSet) !== null && _a !== void 0 ? _a : observableSyncConfiguration === null || observableSyncConfiguration === void 0 ? void 0 : observableSyncConfiguration.debounceSet;
+        const timeoutSaveRemote = _queuedRemoteChangesTimeouts.get(options);
+        const run = () => processQueuedRemoteChanges(options);
+        if (timeout) {
+            if (timeoutSaveRemote) {
+                clearTimeout(timeoutSaveRemote);
+            }
+            _queuedRemoteChangesTimeouts.set(options, setTimeout(run, timeout));
+        }
+        else {
+            run();
+        }
+    }
+}
+async function processQueuedRemoteChanges(syncOptions) {
+    const arr = _queuedRemoteChanges.get(syncOptions);
+    if (arr === null || arr === void 0 ? void 0 : arr.length) {
+        const queuedRemoteChanges = mergeQueuedChanges(arr);
+        _queuedRemoteChanges.set(syncOptions, []);
+        const preppedChangesRemote = await Promise.all(queuedRemoteChanges.map(prepChangeRemote));
+        preppedChangesRemote.forEach(doChangeRemote);
+    }
+}
+async function prepChangeLocal(queuedChange) {
+    const { syncState, changes, localState, syncOptions, inRemoteChange, isApplyingPending } = queuedChange;
+    const persist = syncOptions.persist;
+    const { pluginSync } = localState;
+    const { config: configLocal } = parseLocalConfig(persist);
+    const configRemote = syncOptions;
+    const saveLocal = (persist === null || persist === void 0 ? void 0 : persist.name) && !configLocal.readonly && !isApplyingPending && syncState.isPersistEnabled.peek();
+    const saveRemote = !!(!inRemoteChange &&
+        (pluginSync === null || pluginSync === void 0 ? void 0 : pluginSync.set) &&
+        (configRemote === null || configRemote === void 0 ? void 0 : configRemote.enableSync) !== false &&
+        syncState.isSyncEnabled.peek());
+    if (saveLocal || saveRemote) {
+        if (saveLocal && !syncState.isPersistLoaded.peek()) {
+            console.error('[legend-state] WARNING: An observable was changed before being loaded from persist', persist);
+            return undefined;
+        }
+        const changesLocal = [];
+        const changesPaths = new Set();
+        let promisesTransform = [];
+        // Reverse order
+        for (let i = changes.length - 1; i >= 0; i--) {
+            const { path } = changes[i];
+            let found = false;
+            // Optimization to only save the latest update at each path. We might have multiple changes at the same path
+            // and we only need the latest value, so it starts from the end of the array, skipping any earlier changes
+            // already processed. If a later change modifies a parent of an earlier change (which happens on delete()
+            // it should be ignored as it's superseded by the parent modification.
+            if (changesPaths.size > 0) {
+                for (let u = 0; u < path.length; u++) {
+                    if (changesPaths.has((u === path.length - 1 ? path : path.slice(0, u + 1)).join('/'))) {
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            if (!found) {
+                const pathStr = path.join('/');
+                changesPaths.add(pathStr);
+                const { prevAtPath, valueAtPath, pathTypes } = changes[i];
+                if (saveLocal) {
+                    const promiseTransformLocal = transformSaveData(valueAtPath, path, pathTypes, configLocal);
+                    promisesTransform.push(doInOrder(promiseTransformLocal, (valueTransformed) => {
+                        // Prepare the local change with the transformed path/value
+                        changesLocal.push({
+                            path,
+                            pathTypes,
+                            prevAtPath,
+                            valueAtPath: valueTransformed,
+                            pathStr,
+                        });
+                    }));
+                }
+            }
+        }
+        // If there's any transform promises, wait for them before saving
+        promisesTransform = promisesTransform.filter(Boolean);
+        if (promisesTransform.length > 0) {
+            await Promise.all(promisesTransform);
+        }
+        return { queuedChange, changesLocal, saveRemote };
+    }
+}
+async function prepChangeRemote(queuedChange) {
+    const { syncState, changes, localState, syncOptions: syncOptions, inRemoteChange, isApplyingPending, valuePrevious, } = queuedChange;
+    const persist = syncOptions.persist;
+    const { pluginSync } = localState;
+    const { config: configLocal } = parseLocalConfig(persist);
+    const configRemote = syncOptions;
+    const saveLocal = persist && !configLocal.readonly && !isApplyingPending && syncState.isPersistEnabled.peek();
+    const saveRemote = !inRemoteChange && (pluginSync === null || pluginSync === void 0 ? void 0 : pluginSync.set) && (configRemote === null || configRemote === void 0 ? void 0 : configRemote.enableSync) !== false && syncState.isSyncEnabled.peek();
+    if (saveLocal || saveRemote) {
+        if (saveLocal && !syncState.isPersistLoaded.peek()) {
+            console.error('[legend-state] WARNING: An observable was changed before being loaded from persist', persist);
+            return undefined;
+        }
+        const changesRemote = [];
+        const changesPaths = new Set();
+        let promisesTransform = [];
+        // Reverse order
+        for (let i = changes.length - 1; i >= 0; i--) {
+            const { path } = changes[i];
+            let found = false;
+            // Optimization to only save the latest update at each path. We might have multiple changes at the same path
+            // and we only need the latest value, so it starts from the end of the array, skipping any earlier changes
+            // already processed. If a later change modifies a parent of an earlier change (which happens on delete()
+            // it should be ignored as it's superseded by the parent modification.
+            if (changesPaths.size > 0) {
+                for (let u = 0; u < path.length; u++) {
+                    if (changesPaths.has((u === path.length - 1 ? path : path.slice(0, u + 1)).join('/'))) {
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            if (!found) {
+                const pathStr = path.join('/');
+                changesPaths.add(pathStr);
+                const { prevAtPath, valueAtPath, pathTypes } = changes[i];
+                if (saveRemote) {
+                    const promiseTransformRemote = transformSaveData(valueAtPath, path, pathTypes, configRemote || {});
+                    promisesTransform.push(doInOrder(promiseTransformRemote, (valueTransformed) => {
+                        var _a;
+                        // Prepare pending changes
+                        if (!localState.pendingChanges) {
+                            localState.pendingChanges = {};
+                        }
+                        // First look for existing pending changes at a higher level than this change
+                        // If they exist then merge this change into it
+                        let found = false;
+                        for (let i = 0; !found && i < path.length - 1; i++) {
+                            const pathParent = path.slice(0, i + 1).join('/');
+                            if ((_a = localState.pendingChanges[pathParent]) === null || _a === void 0 ? void 0 : _a.v) {
+                                found = true;
+                                const pathChild = path.slice(i + 1);
+                                const pathTypesChild = pathTypes.slice(i + 1);
+                                state.setAtPath(localState.pendingChanges[pathParent].v, pathChild, pathTypesChild, valueAtPath);
+                            }
+                        }
+                        if (!found) {
+                            // If an existing pending change is deeper than this change, just delete it
+                            // in favor of this wider change
+                            for (const key in localState.pendingChanges) {
+                                if (key !== pathStr && key.startsWith(pathStr)) {
+                                    delete localState.pendingChanges[key];
+                                }
+                            }
+                            // The "p" saved in pending should be the previous state before changes,
+                            // so don't overwrite it if it already exists
+                            if (!localState.pendingChanges[pathStr]) {
+                                localState.pendingChanges[pathStr] = { p: prevAtPath !== null && prevAtPath !== void 0 ? prevAtPath : null, t: pathTypes };
+                            }
+                            // Pending value is the untransformed value because it gets loaded without transformment
+                            // and forwarded through to onObsChange where it gets transformed before save
+                            localState.pendingChanges[pathStr].v = valueAtPath;
+                        }
+                        // Prepare the remote change with the transformed path/value
+                        changesRemote.push({
+                            path,
+                            pathTypes,
+                            prevAtPath,
+                            valueAtPath: valueTransformed,
+                            pathStr,
+                            valuePrevious,
+                        });
+                    }));
+                }
+            }
+        }
+        // If there's any transform promises, wait for them before saving
+        promisesTransform = promisesTransform.filter(Boolean);
+        if (promisesTransform.length > 0) {
+            await Promise.all(promisesTransform);
+        }
+        return { queuedChange, changesRemote };
+    }
+}
+async function doChangeLocal(changeInfo) {
+    if (!changeInfo)
+        return;
+    const { queuedChange, changesLocal, saveRemote } = changeInfo;
+    const { obs, syncState, localState, syncOptions: syncOptions } = queuedChange;
+    const { pluginPersist } = localState;
+    const persist = syncOptions.persist;
+    const { table, config: configLocal } = parseLocalConfig(persist);
+    const shouldSaveMetadata = persist === null || persist === void 0 ? void 0 : persist.retrySync;
+    if (saveRemote && shouldSaveMetadata) {
+        // First save pending changes before saving local or remote
+        await updateMetadataImmediate(obs, localState, syncState, syncOptions, {
+            pending: localState.pendingChanges,
+        });
+    }
+    if (changesLocal.length > 0) {
+        // Save the changes to local cache before saving to remote. They are already marked as pending so
+        // if remote sync fails or the app is closed before remote sync, it will attempt to sync them on the next load.
+        let promiseSet = pluginPersist.set(table, changesLocal, configLocal);
+        if (promiseSet) {
+            promiseSet = promiseSet.then(() => {
+                promisesLocalSaves.delete(promiseSet);
+            });
+            // Keep track of local save promises so that updateMetadata runs only after everything is saved
+            promisesLocalSaves.add(promiseSet);
+            // await the local save before proceeding to save remotely
+            await promiseSet;
+        }
+    }
+}
+async function doChangeRemote(changeInfo) {
+    var _a, _b;
+    if (!changeInfo)
+        return;
+    const { queuedChange, changesRemote } = changeInfo;
+    const { obs, syncState, localState, syncOptions, valuePrevious: previous } = queuedChange;
+    const { pluginPersist, pluginSync } = localState;
+    const persist = syncOptions.persist;
+    const { table, config: configLocal } = parseLocalConfig(persist);
+    const { allowSetIfGetError, onBeforeSet, onSetError, waitForSet, onAfterSet } = syncOptions || {};
+    const shouldSaveMetadata = persist === null || persist === void 0 ? void 0 : persist.retrySync;
+    if (changesRemote.length > 0) {
+        // Wait for remote to be ready before saving
+        await state.when(() => syncState.isLoaded.get() || (allowSetIfGetError && syncState.error.get()));
+        if (waitForSet) {
+            const waitFor = state.isFunction(waitForSet)
+                ? waitForSet({ changes: changesRemote, value: obs.peek() })
+                : waitForSet;
+            if (waitFor) {
+                await state.when(waitFor);
+            }
+        }
+        let value = obs.peek();
+        const transformSave = (_a = syncOptions === null || syncOptions === void 0 ? void 0 : syncOptions.transform) === null || _a === void 0 ? void 0 : _a.save;
+        if (transformSave) {
+            value = transformSave(value);
+        }
+        onBeforeSet === null || onBeforeSet === void 0 ? void 0 : onBeforeSet();
+        localState.numSavesOutstanding = (localState.numSavesOutstanding || 0) + 1;
+        let savedPromise = pluginSync.set({
+            obs,
+            syncState: syncState,
+            options: syncOptions,
+            changes: changesRemote,
+            value,
+            valuePrevious: previous,
+        });
+        if (state.isPromise(savedPromise)) {
+            savedPromise = savedPromise.catch((err) => onSetError === null || onSetError === void 0 ? void 0 : onSetError(err));
+        }
+        const saved = await savedPromise;
+        localState.numSavesOutstanding--;
+        // If this remote save changed anything then update cache and metadata
+        // Because save happens after a timeout and they're batched together, some calls to save will
+        // return saved data and others won't, so those can be ignored.
+        if (saved) {
+            const pathStrs = Array.from(new Set(changesRemote.map((change) => change.pathStr)));
+            const { changes, lastSync } = saved;
+            if (pathStrs.length > 0) {
+                let transformedChanges = undefined;
+                const metadata = {};
+                if (persist) {
+                    const pendingMetadata = (_b = pluginPersist.getMetadata(table, configLocal)) === null || _b === void 0 ? void 0 : _b.pending;
+                    const pending = localState.pendingChanges;
+                    for (let i = 0; i < pathStrs.length; i++) {
+                        const pathStr = pathStrs[i];
+                        // Clear pending for this path
+                        if (pendingMetadata === null || pendingMetadata === void 0 ? void 0 : pendingMetadata[pathStr]) {
+                            // Remove pending from persisted medata state
+                            delete pendingMetadata[pathStr];
+                            metadata.pending = pendingMetadata;
+                        }
+                        // Clear pending for this path if not already removed by above
+                        // pendingMetadata === pending sometimes
+                        if (pending === null || pending === void 0 ? void 0 : pending[pathStr]) {
+                            // Remove pending from local state
+                            delete pending[pathStr];
+                        }
+                    }
+                    if (lastSync) {
+                        metadata.lastSync = lastSync;
+                    }
+                }
+                // Remote can optionally have data that needs to be merged back into the observable,
+                // for example Firebase may update dateModified with the server timestamp
+                if (changes && !state.isEmpty(changes)) {
+                    transformedChanges = transformLoadData(changes, syncOptions, false, 'set');
+                }
+                if (localState.numSavesOutstanding > 0) {
+                    if (transformedChanges) {
+                        if (!localState.pendingSaveResults) {
+                            localState.pendingSaveResults = [];
+                        }
+                        localState.pendingSaveResults.push(transformedChanges);
+                    }
+                }
+                else {
+                    let allChanges = [...(localState.pendingSaveResults || []), transformedChanges].filter((v) => v !== undefined);
+                    if (allChanges.length > 0) {
+                        if (allChanges.some((change) => state.isPromise(change))) {
+                            allChanges = await Promise.all(allChanges);
+                        }
+                        onChangeRemote(() => state.mergeIntoObservable(obs, ...allChanges));
+                    }
+                    if (persist) {
+                        if (shouldSaveMetadata && !state.isEmpty(metadata)) {
+                            updateMetadata(obs, localState, syncState, syncOptions, metadata);
+                        }
+                    }
+                    localState.pendingSaveResults = [];
+                }
+                onAfterSet === null || onAfterSet === void 0 ? void 0 : onAfterSet();
+            }
+        }
+    }
+}
+function onObsChange(obs, syncState, localState, syncOptions, { changes, loading, remote, getPrevious }) {
+    if (!loading) {
+        const inRemoteChange = remote;
+        const isApplyingPending = localState.isApplyingPending;
+        // Queue changes in a microtask so that multiple changes within a frame get run together
+        _queuedChanges.push({
+            obs: obs,
+            syncState,
+            localState,
+            syncOptions,
+            changes,
+            inRemoteChange,
+            isApplyingPending: isApplyingPending,
+            getPrevious,
+        });
+        if (_queuedChanges.length === 1) {
+            queueMicrotask(processQueuedChanges);
+        }
+    }
+}
+async function loadLocal(obs, syncOptions, syncState, localState) {
+    var _a, _b;
+    const { persist } = syncOptions;
+    if (persist) {
+        const PersistPlugin = persist.plugin || ((_a = observableSyncConfiguration.persist) === null || _a === void 0 ? void 0 : _a.plugin);
+        const { table, config } = parseLocalConfig(persist);
+        const node = getNode(obs);
+        if (!PersistPlugin) {
+            throw new Error('Local persist is not configured');
+        }
+        // Ensure there's only one instance of the cache plugin
+        if (!mapSyncPlugins.has(PersistPlugin)) {
+            const persistPlugin = new PersistPlugin();
+            const mapValue = { plugin: persistPlugin, initialized: state.observable(false) };
+            mapSyncPlugins.set(PersistPlugin, mapValue);
+            if (persistPlugin.initialize) {
+                const initializePromise = (_b = persistPlugin.initialize) === null || _b === void 0 ? void 0 : _b.call(persistPlugin, (observableSyncConfiguration === null || observableSyncConfiguration === void 0 ? void 0 : observableSyncConfiguration.persist) || {});
+                if (state.isPromise(initializePromise)) {
+                    await initializePromise;
+                }
+            }
+            mapValue.initialized.set(true);
+        }
+        const { plugin, initialized: initialized$ } = mapSyncPlugins.get(PersistPlugin);
+        const persistPlugin = plugin;
+        localState.pluginPersist = persistPlugin;
+        if (!initialized$.peek()) {
+            await state.when(initialized$);
+        }
+        // If cache has an asynchronous load, wait for it
+        if (persistPlugin.loadTable) {
+            const promise = persistPlugin.loadTable(table, config);
+            if (promise) {
+                await promise;
+            }
+        }
+        // Get current value for init
+        const prevValue = getNodeValue$1(node);
+        // Get the value from state
+        let value = persistPlugin.getTable(table, prevValue, config);
+        const metadata = persistPlugin.getMetadata(table, config);
+        if (metadata) {
+            metadatas.set(obs, metadata);
+            localState.pendingChanges = metadata.pending;
+            syncState.assign({
+                lastSync: metadata.lastSync,
+            });
+        }
+        // Merge the data from local cache into the default state
+        if (value !== undefined) {
+            const { transform } = config;
+            value = transformLoadData(value, { transform }, true, 'get');
+            if (state.isPromise(value)) {
+                value = await value;
+            }
+            // isLoadingLocal prevents saving remotely when two different caches
+            // are set on the same observable
+            state.internal.globalState.isLoadingLocal = true;
+            // We want to merge the local data on top of any initial state the object is created with
+            if (value === null && (!prevValue || prevValue[symbolLinked$2])) {
+                obs.set(value);
+            }
+            else {
+                state.mergeIntoObservable(obs, value);
+            }
+            state.internal.globalState.isLoadingLocal = false;
+        }
+        node.state.peek().clearPersist = () => Promise.all([
+            persistPlugin.deleteTable(table, config),
+            persistPlugin.deleteMetadata(table, config),
+        ]);
+    }
+    syncState.isPersistLoaded.set(true);
+}
+function syncObservable(obs$, syncOptionsOrSynced) {
+    let syncOptions = syncOptionsOrSynced;
+    // If it's a synced then get the SyncOptions from it
+    if (state.isFunction(syncOptions)) {
+        syncOptions = syncOptions()[symbolLinked$2];
+    }
+    const node = getNode(obs$);
+    // Merge remote sync options with global options
+    syncOptions = state.mergeIntoObservable({
+        syncMode: 'auto',
+    }, clone(observableSyncConfiguration), removeNullUndefined(syncOptions || {}));
+    const localState = {};
+    let sync;
+    const syncState = (node.state = state.observable({
+        isPersistLoaded: false,
+        isLoaded: !syncOptions.get,
+        isPersistEnabled: true,
+        isSyncEnabled: true,
+        clearPersist: undefined,
+        sync: () => Promise.resolve(),
+        getPendingChanges: () => localState.pendingChanges,
+    }));
+    loadLocal(obs$, syncOptions, syncState, localState);
+    localState.pluginSync = syncObservableAdapter(syncOptions);
+    if (syncOptions.get) {
+        let isSynced = false;
+        sync = async () => {
+            var _a, _b;
+            const lastSync = (_a = metadatas.get(obs$)) === null || _a === void 0 ? void 0 : _a.lastSync;
+            const pending = localState.pendingChanges;
+            const get = (_b = localState.pluginSync.get) === null || _b === void 0 ? void 0 : _b.bind(localState.pluginSync);
+            if (get) {
+                const runGet = () => {
+                    const onChange = async ({ value, mode, lastSync }) => {
+                        mode = mode || syncOptions.mode || 'set';
+                        if (value !== undefined) {
+                            value = transformLoadData(value, syncOptions, true, 'get');
+                            if (state.isPromise(value)) {
+                                value = await value;
+                            }
+                            const pending = localState.pendingChanges;
+                            const currentValue = obs$.peek();
+                            if (pending) {
+                                let didChangeMetadata = false;
+                                Object.keys(pending).forEach((key) => {
+                                    const p = key.split('/').filter((p) => p !== '');
+                                    const { v, t } = pending[key];
+                                    if (t.length === 0 || !value) {
+                                        if (state.isObject(value) && state.isObject(v)) {
+                                            Object.assign(value, v);
+                                        }
+                                        else {
+                                            value = v;
+                                        }
+                                    }
+                                    else if (value[p[0]] !== undefined) {
+                                        const curValue = getValueAtPath(currentValue, p);
+                                        const newValue = getValueAtPath(value, p);
+                                        if (JSON.stringify(curValue) === JSON.stringify(newValue)) {
+                                            delete pending[key];
+                                            didChangeMetadata = true;
+                                        }
+                                        else {
+                                            value = state.setAtPath(value, p, t, v, 'merge', obs$.peek(), (path, value) => {
+                                                delete pending[key];
+                                                pending[path.join('/')] = {
+                                                    p: null,
+                                                    v: value,
+                                                    t: t.slice(0, path.length),
+                                                };
+                                            });
+                                        }
+                                    }
+                                });
+                                if (didChangeMetadata) {
+                                    updateMetadata(obs$, localState, syncState, syncOptions, {
+                                        pending,
+                                    });
+                                }
+                            }
+                            onChangeRemote(() => {
+                                if (mode === 'assign' && state.isObject(value)) {
+                                    obs$.assign(value);
+                                }
+                                else if (mode === 'append' && state.isArray(value)) {
+                                    obs$.push(...value);
+                                }
+                                else if (mode === 'prepend' && state.isArray(value)) {
+                                    obs$.splice(0, 0, ...value);
+                                }
+                                else if (mode === 'merge') {
+                                    state.mergeIntoObservable(obs$, value);
+                                }
+                                else {
+                                    obs$.set(value);
+                                }
+                            });
+                        }
+                        if (lastSync && syncOptions.persist) {
+                            updateMetadata(obs$, localState, syncState, syncOptions, {
+                                lastSync,
+                            });
+                        }
+                    };
+                    get({
+                        state: syncState,
+                        obs: obs$,
+                        options: syncOptions,
+                        lastSync,
+                        dateModified: lastSync,
+                        onError: (error) => {
+                            var _a;
+                            (_a = syncOptions.onGetError) === null || _a === void 0 ? void 0 : _a.call(syncOptions, error);
+                        },
+                        onGet: () => {
+                            const isFirstLoad = !node.state.isLoaded.peek();
+                            node.state.assign({
+                                isLoaded: true,
+                                error: undefined,
+                            });
+                            if (isFirstLoad && syncOptions.subscribe) {
+                                syncOptions.subscribe({
+                                    node,
+                                    update: (params) => {
+                                        params.mode || (params.mode = syncOptions.mode || 'merge');
+                                        onChange(params);
+                                    },
+                                    refresh: sync,
+                                });
+                            }
+                        },
+                        onChange,
+                    });
+                };
+                runGet();
+            }
+            else {
+                node.state.assign({
+                    isLoaded: true,
+                    error: undefined,
+                });
+            }
+            if (!isSynced) {
+                isSynced = true;
+                // Wait for remote to be ready before saving pending
+                await state.when(() => syncState.isLoaded.get() || (syncOptions.allowSetIfGetError && syncState.error.get()));
+                if (pending && !state.isEmpty(pending)) {
+                    localState.isApplyingPending = true;
+                    const keys = Object.keys(pending);
+                    // Bundle up all the changes from pending
+                    const changes = [];
+                    for (let i = 0; i < keys.length; i++) {
+                        const key = keys[i];
+                        const path = key.split('/').filter((p) => p !== '');
+                        const { p, v, t } = pending[key];
+                        changes.push({ path, valueAtPath: v, prevAtPath: p, pathTypes: t });
+                    }
+                    // Send the changes into onObsChange so that they get synced remotely
+                    const value = getNodeValue$1(node);
+                    onObsChange(obs$, syncState, localState, syncOptions, {
+                        value,
+                        loading: false,
+                        remote: false,
+                        getPrevious: createPreviousHandler(value, changes),
+                        changes,
+                    });
+                    localState.isApplyingPending = false;
+                }
+            }
+        };
+        syncState.assign({ sync });
+    }
+    // Wait for this node and all parent nodes up the hierarchy to be loaded
+    const onAllPersistLoaded = () => {
+        var _a, _b;
+        let parentNode = node;
+        while (parentNode) {
+            if (((_b = (_a = parentNode.state) === null || _a === void 0 ? void 0 : _a.isPersistLoaded) === null || _b === void 0 ? void 0 : _b.get()) === false) {
+                return false;
+            }
+            parentNode = parentNode.parent;
+        }
+        return true;
+    };
+    // When all is loaded locally we can start syncing and listening for changes
+    state.when(onAllPersistLoaded, function () {
+        // If remote is not manual, then sync() is called automatically
+        if (syncOptions.get && syncOptions.syncMode === 'auto') {
+            sync();
+        }
+        obs$.onChange(onObsChange.bind(this, obs$, syncState, localState, syncOptions));
+    });
+    return syncState;
+}
+
+const { getProxy, globalState, runWithRetry, symbolLinked: symbolLinked$1, setNodeValue, getNodeValue } = state.internal;
+function enableActivateSyncedNode() {
+    globalState.activateSyncedNode = function activateSyncedNode(node, newValue) {
+        const obs$ = getProxy(node);
+        if (node.activationState) {
+            // If it is a Synced
+            const { get, initial, set, retry } = node.activationState;
+            let onChange = undefined;
+            const pluginRemote = {};
+            let promiseReturn = undefined;
+            // Not sure why this disable is needed, but it's needed to make the linter happy
+            // eslint-disable-next-line prefer-const
+            let syncState;
+            const refresh = () => syncState === null || syncState === void 0 ? void 0 : syncState.sync();
+            if (get) {
+                pluginRemote.get = (params) => {
+                    var _a;
+                    onChange = params.onChange;
+                    const updateLastSync = (lastSync) => (params.lastSync = lastSync);
+                    const existingValue = getNodeValue(node);
+                    const value = runWithRetry(node, { attemptNum: 0, retry: retry || ((_a = params.options) === null || _a === void 0 ? void 0 : _a.retry) }, () => {
+                        const paramsToGet = {
+                            value: state.isFunction(existingValue) || (existingValue === null || existingValue === void 0 ? void 0 : existingValue[symbolLinked$1]) ? undefined : existingValue,
+                            lastSync: params.lastSync,
+                            updateLastSync,
+                            mode: params.mode,
+                            refresh,
+                        };
+                        const ret = get(paramsToGet);
+                        params.mode = paramsToGet.mode;
+                        return ret;
+                    });
+                    promiseReturn = value;
+                    return value;
+                };
+            }
+            if (set) {
+                // TODO: Work out these types better
+                pluginRemote.set = async (params) => {
+                    var _a, _b;
+                    if ((_a = node.state) === null || _a === void 0 ? void 0 : _a.isLoaded.get()) {
+                        const retryAttempts = { attemptNum: 0, retry: retry || ((_b = params.options) === null || _b === void 0 ? void 0 : _b.retry) };
+                        return runWithRetry(node, retryAttempts, async (retryEvent) => {
+                            let changes = {};
+                            let maxModified = 0;
+                            if (!node.state.isLoaded.peek()) {
+                                await state.whenReady(node.state.isLoaded);
+                            }
+                            const cancelRetry = () => {
+                                retryEvent.cancel = true;
+                            };
+                            await set({
+                                ...params,
+                                node,
+                                update: (params) => {
+                                    const { value, lastSync } = params;
+                                    maxModified = Math.max(lastSync || 0, maxModified);
+                                    changes = state.mergeIntoObservable(changes, value);
+                                },
+                                retryNum: retryAttempts.attemptNum,
+                                cancelRetry,
+                                refresh,
+                                fromSubscribe: false,
+                            });
+                            return { changes, lastSync: maxModified || undefined };
+                        });
+                    }
+                };
+            }
+            const nodeVal = getNodeValue(node);
+            if (promiseReturn !== undefined) {
+                newValue = promiseReturn;
+            }
+            else if (nodeVal !== undefined && !state.isFunction(nodeVal)) {
+                newValue = nodeVal;
+            }
+            else {
+                newValue = initial;
+            }
+            setNodeValue(node, promiseReturn ? undefined : newValue);
+            // @ts-expect-error TODO fix these types
+            syncState = syncObservable(obs$, { ...node.activationState, ...pluginRemote });
+            return { update: onChange, value: newValue };
+        }
+        else {
+            // If it is not a Synced
+            let update = undefined;
+            const get = async (params) => {
+                update = params.refresh;
+                if (state.isPromise(newValue)) {
+                    try {
+                        newValue = await newValue;
+                    }
+                    catch (_a) {
+                        // TODO Once we have global retry settings this should retry
+                    }
+                }
+                return newValue;
+            };
+            syncObservable(obs$, {
+                get,
+            });
+            return { update: update, value: newValue };
+        }
+    };
+}
+
+const { symbolLinked } = state.internal;
+function synced(params) {
+    installPersistActivateNode();
+    return (() => ({
+        [symbolLinked]: { ...params, synced: true },
+    }));
+}
+let didInstall = false;
+function installPersistActivateNode() {
+    if (!didInstall) {
+        enableActivateSyncedNode();
+        didInstall = true;
+    }
 }
 
 function isInRemoteChange() {
-    return state.internal.globalState.isLoadingRemote$.get();
+    return state.internal.globalState.isLoadingRemote;
 }
 const internal = {
     observablePersistConfiguration,
 };
-persistActivateNode();
 
 exports.configureObservablePersistence = configureObservablePersistence;
 exports.internal = internal;
@@ -826,6 +1826,7 @@ exports.invertFieldMap = invertFieldMap;
 exports.isInRemoteChange = isInRemoteChange;
 exports.mapPersistences = mapPersistences;
 exports.persistObservable = persistObservable;
+exports.synced = synced;
 exports.transformObject = transformObject;
 exports.transformPath = transformPath;
 //# sourceMappingURL=persist.js.map