j-templates 8.1.2 → 8.2.0

package/Store/Store/storeAsync.js

@@ -26,7 +26,7 @@ import { Store } from "./store";
  * await store.Push("users", { id: 1 }, { id: 2 });
  *
  * // Splicing an array asynchronously
- * const deletedItems = await store.Splice("users", 0, 1, { id: 3 });
+ * await store.Splice("users", 0, 1, { id: 3 });
  *
  * // Cleaning up resources
  * store.Destroy();
@@ -38,17 +38,17 @@ export class StoreAsync extends Store {
     /**
      * Creates an instance of StoreAsync.
      * @param diffWorker A `Worker` running a `DiffTree` connected via `ConnectWorkerToDiffTree`
-     *   (e.g. a bundled `defaultDiffTreeWorker` entry). Any `keyFunc`/projections the diff needs
+     *   (e.g. a bundled `defaultDiffTreeWorker` entry). Any `keyFunc`/routes the diff needs
      *   must be baked into that worker's own entry file.
      * @param keyFunc Optional function to generate a key for a given data value, used locally by
      *   this store to resolve root objects. Pass the same key logic the worker's `DiffTree` was
      *   constructed with, if any.
      */
     constructor(diffWorker, keyFunc) {
-        super(keyFunc, false);
+        super(keyFunc);
         this.writeKeySet = new Set();
         this.currentBatch = [];
-        this.currentBatchPromise = Promise.resolve([]);
+        this.currentBatchPromise = Promise.resolve();
         this.workerQueue = new WorkerQueue(diffWorker);
         this.asyncQueue = new AsyncQueue(true);
     }
@@ -59,29 +59,13 @@ export class StoreAsync extends Store {
                 await Promise.resolve();
                 if (batch === this.currentBatch)
                     this.currentBatch = [];
-                const results = await this.workerQueue.Push(batch);
-                for (let x = 0; x < results.length; x++) {
-                    const result = results[x];
-                    switch (result.type) {
-                        case "diff": {
-                            this.UpdateRootMap(result.result);
-                            break;
-                        }
-                        case "splice": {
-                            const spliceResult = result.result;
-                            this.UpdateRootMap(spliceResult.diffResult);
-                            this.SpliceRootObject(spliceResult.path[0], spliceResult.start, spliceResult.deleteCount, spliceResult.items);
-                            break;
-                        }
-                    }
-                }
-                return results;
+                // The worker's Commit() diff covers every change in the batch
+                const diff = await this.workerQueue.Push(batch);
+                this.UpdateRootMap(diff);
             });
         }
-        const batchIndex = this.currentBatch.length;
         this.currentBatch.push(method);
-        const batchResult = await this.currentBatchPromise;
-        return batchResult[batchIndex].result;
+        await this.currentBatchPromise;
     }
     /**
      * Writes data to the store asynchronously.
@@ -100,7 +84,7 @@ export class StoreAsync extends Store {
             throw new Error("No key provided for data");
         this.writeKeySet.add(key);
         await this.Schedule({
-            method: "diffpath",
+            method: "writepath",
             arguments: [key, data]
         });
         this.writeKeySet.delete(key);
@@ -146,19 +130,17 @@ export class StoreAsync extends Store {
      * @param start The position at which to start changing the array.
      * @param deleteCount Optional number of elements to delete. If not provided, all elements from start to end will be deleted.
      * @param items Optional elements to insert into the array.
-     * @returns A promise that resolves to the array of deleted elements once the splice has been
-     *   applied to the store.
+     * @returns A promise that resolves once the splice has been applied to the store.
      * @throws Will throw if the key isn't in the store and has no pending Write, or reject with
      *   the original error if an earlier change failed.
      */
     async Splice(key, start, deleteCount, ...items) {
         if (!this.Has(key) && !this.writeKeySet.has(key))
             throw "Key not found in store";
-        const spliceResult = await this.Schedule({
+        await this.Schedule({
             method: "splicepath",
-            arguments: [key, start, deleteCount, items]
+            arguments: [key, start, deleteCount ?? Infinity, items]
         });
-        return spliceResult.spliceResult;
     }
     /**
      * Returns a promise that resolves once every change made before this call has been applied

package/Store/Store/storeSync.d.ts

@@ -1,4 +1,4 @@
-import { DiffTreeProjectionMap } from "../Diff/diffTree.types";
+import { IRouteDefinitions } from "../Diff/utils/diffTree.types";
 import { Store } from "./store";
 /**
  * StoreSync class extends the base Store class to provide synchronous data management operations.
@@ -22,25 +22,26 @@ import { Store } from "./store";
  * store.Push("user.array", { id: 1 }, { id: 2 });
  *
  * // Splicing an array
- * const deletedItems = store.Splice("user.array", 0, 1, { id: 3 });
+ * store.Splice("user.array", 0, 1, { id: 3 });
  *
  * @see Store
  * @see StoreAsync
- * @see DiffSync
+ * @see DiffTree
  */
 export declare class StoreSync extends Store {
     /**
-     * The diff instance used to compute differences between current and new data states.
+     * The tree each change is applied to. Its `Commit()` diff keeps the store in sync.
      * @private
      */
     private diff;
     /**
      * Creates an instance of StoreSync.
      * @param keyFunc Optional function to generate a key for a given data value.
-     * @param projections Optional map of derived-value projections, keyed by id. A
-     * projection's result is readable through `Get` at `$projection_<id>`.
+     * @param routes Optional route definitions. A projection in the root route (`"/"`) is
+     * readable through `Get` at `$projection_<key>`.
+     * @throws When projections depend on each other in a cycle.
      */
-    constructor(keyFunc?: (value: any) => string | undefined, projections?: DiffTreeProjectionMap);
+    constructor(keyFunc?: (value: any) => string | undefined, routes?: IRouteDefinitions);
     /**
      * Writes data to the store synchronously.
      * @param data The data to be written. Can be of any type.
@@ -68,7 +69,11 @@ export declare class StoreSync extends Store {
      * @param start The position at which to start changing the array.
      * @param deleteCount Optional number of elements to delete. If not provided, all elements from start to end will be deleted.
      * @param items Optional elements to insert into the array.
-     * @returns The array of deleted elements.
      */
-    Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): unknown[];
+    Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): void;
+    /**
+     * Runs projections and applies everything changed since the last sync to the store.
+     * @private
+     */
+    private Sync;
 }

package/Store/Store/storeSync.js

@@ -1,5 +1,4 @@
-import { JsonDeepClone } from "../../Utils/json";
-import { DiffSync } from "../Diff/diffSync";
+import { DiffTree } from "../Diff/diffTree";
 import { Store } from "./store";
 /**
  * StoreSync class extends the base Store class to provide synchronous data management operations.
@@ -23,22 +22,23 @@ import { Store } from "./store";
  * store.Push("user.array", { id: 1 }, { id: 2 });
  *
  * // Splicing an array
- * const deletedItems = store.Splice("user.array", 0, 1, { id: 3 });
+ * store.Splice("user.array", 0, 1, { id: 3 });
  *
  * @see Store
  * @see StoreAsync
- * @see DiffSync
+ * @see DiffTree
  */
 export class StoreSync extends Store {
     /**
      * Creates an instance of StoreSync.
      * @param keyFunc Optional function to generate a key for a given data value.
-     * @param projections Optional map of derived-value projections, keyed by id. A
-     * projection's result is readable through `Get` at `$projection_<id>`.
+     * @param routes Optional route definitions. A projection in the root route (`"/"`) is
+     * readable through `Get` at `$projection_<key>`.
+     * @throws When projections depend on each other in a cycle.
      */
-    constructor(keyFunc, projections) {
+    constructor(keyFunc, routes) {
         super(keyFunc);
-        this.diff = new DiffSync(keyFunc, projections);
+        this.diff = new DiffTree(keyFunc, routes);
     }
     /**
      * Writes data to the store synchronously.
@@ -50,8 +50,8 @@ export class StoreSync extends Store {
         key = key || this.keyFunc?.(data);
         if (!key)
             throw "No key provided for data";
-        const diffResult = this.diff.DiffPath(key, data);
-        this.UpdateRootMap(diffResult);
+        this.diff.WritePath(key, data);
+        this.Sync();
     }
     /**
      * Patches an existing value in the store with new data synchronously.
@@ -62,8 +62,8 @@ export class StoreSync extends Store {
     Patch(key, patch) {
         if (!this.Has(key))
             throw "Key not found in store";
-        const diffResult = this.diff.PatchPath(key, patch);
-        this.UpdateRootMap(diffResult);
+        this.diff.PatchPath(key, patch);
+        this.Sync();
     }
     /**
      * Pushes data into an array stored at the specified key synchronously.
@@ -73,8 +73,8 @@ export class StoreSync extends Store {
     Push(key, ...data) {
         if (!this.Has(key))
             throw "Key not found in store";
-        const diffResult = this.diff.PushPath(key, data);
-        this.UpdateRootMap(diffResult);
+        this.diff.PushPath(key, data);
+        this.Sync();
     }
     /**
      * Splices an array stored at the specified key with new data synchronously.
@@ -83,14 +83,19 @@ export class StoreSync extends Store {
      * @param start The position at which to start changing the array.
      * @param deleteCount Optional number of elements to delete. If not provided, all elements from start to end will be deleted.
      * @param items Optional elements to insert into the array.
-     * @returns The array of deleted elements.
      */
     Splice(key, start, deleteCount, ...items) {
         if (!this.Has(key))
             throw "Key not found in store";
-        const spliceResult = this.diff.SplicePath(key, start, deleteCount, items);
-        this.UpdateRootMap(spliceResult.diffResult);
-        this.SpliceRootObject(spliceResult.path[0], spliceResult.start, spliceResult.deleteCount, items);
-        return JsonDeepClone(spliceResult.spliceResult);
+        this.diff.SplicePath(key, start, deleteCount ?? Infinity, items);
+        this.Sync();
+    }
+    /**
+     * Runs projections and applies everything changed since the last sync to the store.
+     * @private
+     */
+    Sync() {
+        this.diff.RunProjections();
+        this.UpdateRootMap(this.diff.Commit());
     }
 }

package/Store/Tree/observableNode.d.ts

@@ -48,16 +48,7 @@ export declare namespace ObservableNode {
      * @returns The snapshot, or `undefined` if `proxy` is not an observable node.
      */
     function Snapshot<T>(proxy: T): T | undefined;
-    /**
-     * Marks an observable node or its property as changed, triggering reactive updates.
-     * Used internally to notify dependencies that a value has been modified.
-     * @param value The observable node to touch.
-     * @param prop Optional property name or index to touch a specific nested property.
-     */
-    function Update<T>(value: T, prop?: keyof T): void;
-    function Assign<T>(value: T, prop: keyof T, propValue: any): void;
     function Touch<T>(value: T, prop?: keyof T): void;
-    function Read<T>(value: T, prop: keyof T): void;
     /**
      * Merges a new value into an observable node in-place, preserving the node's object identity.
      * Computes the diff between the node's current value and the provided value, then applies only
@@ -77,26 +68,14 @@ export declare namespace ObservableNode {
      * @remarks No-op when `value` deep-equals the node's current value (empty diff).
      */
     function Apply(rootNode: any, value: any): void;
-    /**
-     * Splices an observable node's underlying array in-place, invalidating its snapshot and
-     * touching its scope so reactive readers update.
-     * @param rootNode The observable array node to splice.
-     * @param start Index at which to start changing the array.
-     * @param deleteCount Number of elements to remove starting at `start`.
-     * @param items Elements to insert at `start`.
-     * @param cloneData Whether to deep-clone `items` before inserting them (true by default,
-     *   so the store isn't left holding a reference the caller can still mutate).
-     */
-    function ApplySplice(rootNode: any, start: number, deleteCount: number, items: any[], cloneData?: boolean): void;
     /**
      * Applies a JSON diff result to an observable node, efficiently updating only changed properties.
      * Optimizes nested object updates by computing paths incrementally and touching modified properties.
      * @param rootNode The observable node to apply the diff to.
      * @param diffResult The diff result from JsonDiff containing path-value pairs of changes.
-     * @param cloneData Whether to deep-clone each diff value before writing it in (true by
-     *   default), so the store isn't left holding a reference the caller can still mutate.
+     *   Each value is deep-cloned as it's applied (see JsonApplyDiff).
      */
-    function ApplyDiff(rootNode: any, diffResult: JsonDiffResult, cloneData?: boolean): void;
+    function ApplyDiff(rootNode: any, diffResult: JsonDiffResult): void;
     /**
      * Creates a factory function for making values observable with optional aliasing.
      * The alias function transforms values before creating the observable proxy,

package/Store/Tree/observableNode.js

@@ -1,9 +1,11 @@
-import { JsonDeepClone, JsonDiff } from "../../Utils/json";
+import { JsonApplyDiff, JsonDeepClone, JsonDiff } from "../../Utils/json";
 import { JsonType } from "../../Utils/json";
 import { ObservableScope } from "./observableScope";
+import { Snapshot } from "./snapshot";
 const NODE_VALUE = Symbol("NODE_VALUE");
 const NODE_PROXY = Symbol("NODE_PROXY");
 const NODE_SNAPSHOT = Symbol("NODE_SNAPSHOT");
+const NODE_WRAPPER = Symbol("NODE_WRAPPER");
 const toJSON = "toJSON";
 const IS_NODE = Symbol("IS_NODE");
 const ARRAY_SCOPE = Symbol("ARRAY_SCOPE");
@@ -15,23 +17,9 @@ function Property(value, prop) {
     return value[prop];
 }
 const wrapperCache = new WeakMap();
-const valueSnapshotCache = new WeakMap();
-const valueSnapshotHierarchy = new WeakMap();
-function CreateSnapshotLink(child, parent) {
-    let parents = valueSnapshotHierarchy.get(child);
-    if (!parents)
-        valueSnapshotHierarchy.set(child, (parents = new Set()));
-    parents.add(parent);
-}
+const snapshotState = Snapshot.Create();
 function InvalidateSnapshotForValue(value) {
-    valueSnapshotCache.delete(value);
-    const parents = valueSnapshotHierarchy.get(value);
-    if (parents === undefined)
-        return;
-    valueSnapshotHierarchy.delete(value);
-    for (const parent of parents)
-        if (valueSnapshotCache.has(parent))
-            InvalidateSnapshotForValue(parent);
+    Snapshot.Invalidate(snapshotState, value);
 }
 function getOwnPropertyDescriptor(target, prop) {
     ObservableScope.Touch(target[OBJECT_SCOPE]);
@@ -109,10 +97,8 @@ function CloneProxy(value, type = JsonType(value)) {
     }
     return value;
 }
-function GetPropertyScope(object, prop, create = true) {
+function GetPropertyScope(object, prop) {
     if (!Object.hasOwn(object, prop)) {
-        if (!create)
-            return undefined;
         Object.defineProperty(object, prop, {
             value: ObservableScope.Basic(Property.bind(null, object[NODE_VALUE], prop)),
             writable: true,
@@ -125,62 +111,37 @@ function GetPropertyScope(object, prop, create = true) {
 function SetObjectValue(object, prop, value) {
     const propExists = Object.hasOwn(object[NODE_VALUE], prop);
     object[NODE_VALUE][prop] = value;
-    InvalidateSnapshotForValue(object[NODE_VALUE]);
-    Object.hasOwn(object, prop) && ObservableScope.Update(object[prop]);
-    !propExists && ObservableScope.Update(object[OBJECT_SCOPE]);
+    NodeValueSet(object[NODE_VALUE], prop, !propExists, object);
 }
 function SetArrayValue(object, prop, value) {
     object[NODE_VALUE][prop] = value;
-    InvalidateSnapshotForValue(object[NODE_VALUE]);
-    ObservableScope.Update(object[ARRAY_SCOPE]);
+    NodeValueSet(object[NODE_VALUE], prop, false, object);
+}
+function NodeValueSet(obj, prop, added, wrapper = wrapperCache.get(obj)) {
+    InvalidateSnapshotForValue(obj);
+    if (!wrapper)
+        return;
+    const propScopeExists = !!prop && Object.hasOwn(wrapper, prop);
+    if (!prop || added || !propScopeExists)
+        ObservableScope.Update(wrapper[ARRAY_SCOPE] ?? wrapper[OBJECT_SCOPE]);
+    if (propScopeExists)
+        ObservableScope.Update(wrapper[prop]);
+}
+function AssignNodeValue(obj, prop, value) {
+    const added = !Object.hasOwn(obj, prop);
+    obj[prop] = value;
+    NodeValueSet(obj, prop, added);
 }
 function CreateProxyFactory(alias) {
-    /**
-     * An immutable snapshot of a raw node value (arrays and plain objects; other values are
-     * returned as they are). A snapshot is cached per raw value in valueSnapshotCache and
-     * returned as-is until a write invalidates it: every write path calls Invalidate, which
-     * clears the written value and every cached ancestor, found through the parent links
-     * recorded here. A rebuild makes new containers but reuses the cached snapshots of
-     * unchanged children, so a snapshot handed out never changes and unchanged parts are
-     * shared between snapshots. Keyed children are read through their root.
-     */
+    // Keyed children are read through their root. Every factory shares the module-level
+    // snapshotState, matching wrapperCache; only the resolver differs per factory.
+    // The alias ignores paths, so the root is snapshotted at the child's own path
+    const resolveSnapshot = alias && function (child, path) {
+        const value = alias(child, false);
+        return value === undefined ? undefined : { value, path: path.slice() };
+    };
     function CreateSnapshot(value) {
-        if (JsonType(value) === "value")
-            return value;
-        const cached = valueSnapshotCache.get(value);
-        if (cached !== undefined)
-            return cached;
-        let snapshot;
-        if (Array.isArray(value)) {
-            snapshot = new Array(value.length);
-            for (let x = 0; x < value.length; x++)
-                snapshot[x] = ChildSnapshot(value, value[x]);
-        }
-        else {
-            snapshot = {};
-            const keys = Object.keys(value);
-            for (let x = 0; x < keys.length; x++)
-                snapshot[keys[x]] = ChildSnapshot(value, value[keys[x]]);
-        }
-        valueSnapshotCache.set(value, snapshot);
-        return snapshot;
-    }
-    /**
-     * A child's snapshot, linking the child to its parent so a write to the child
-     * invalidates the parent. A keyed child's snapshot comes from its root, so the root is
-     * linked too; the parent's own embedded copy stays linked because a positional write
-     * (one that changes which entity a slot holds) mutates that copy in place.
-     */
-    function ChildSnapshot(parent, child) {
-        if (JsonType(child) === "value")
-            return child;
-        CreateSnapshotLink(child, parent);
-        const resolved = alias?.(child, false);
-        if (resolved !== undefined && resolved !== child) {
-            CreateSnapshotLink(resolved, parent);
-            return CreateSnapshot(resolved);
-        }
-        return CreateSnapshot(child);
+        return Snapshot.Get(snapshotState, value, resolveSnapshot);
     }
     const readOnly = alias !== undefined;
     function CreateArrayProxy(value) {
@@ -225,6 +186,8 @@ function CreateProxyFactory(alias) {
                 return function () {
                     return CreateSnapshot(object[NODE_VALUE]);
                 };
+            case NODE_WRAPPER:
+                return object;
             case NODE_VALUE:
                 return object[NODE_VALUE];
             case NODE_SNAPSHOT:
@@ -290,6 +253,8 @@ function CreateProxyFactory(alias) {
         switch (prop) {
             case IS_NODE:
                 return true;
+            case NODE_WRAPPER:
+                return object;
             case NODE_SNAPSHOT:
                 return CreateSnapshot(object[NODE_VALUE]);
             case toJSON:
@@ -404,36 +369,6 @@ export var ObservableNode;
         return undefined;
     }
     ObservableNode.Snapshot = Snapshot;
-    /**
-     * Marks an observable node or its property as changed, triggering reactive updates.
-     * Used internally to notify dependencies that a value has been modified.
-     * @param value The observable node to touch.
-     * @param prop Optional property name or index to touch a specific nested property.
-     */
-    function Update(value, prop) {
-        const wrapper = wrapperCache.get(value);
-        if (wrapper) {
-            const scope = Array.isArray(wrapper) ? wrapper[ARRAY_SCOPE] : (prop && GetPropertyScope(wrapper, prop)) ?? wrapper[OBJECT_SCOPE];
-            ObservableScope.Update(scope);
-        }
-    }
-    ObservableNode.Update = Update;
-    function Assign(value, prop, propValue) {
-        // const propExists = Object.hasOwn(value as Object, prop);
-        // value[prop] = propValue;
-        const wrapper = wrapperCache.get(value);
-        if (wrapper) {
-            if (Array.isArray(wrapper))
-                SetArrayValue(wrapper, prop, propValue);
-            else
-                SetObjectValue(wrapper, prop, propValue);
-        }
-        else {
-            InvalidateSnapshotForValue(value);
-            value[prop] = propValue;
-        }
-    }
-    ObservableNode.Assign = Assign;
     function Touch(value, prop) {
         const wrapper = wrapperCache.get(value);
         if (wrapper) {
@@ -442,14 +377,6 @@ export var ObservableNode;
         }
     }
     ObservableNode.Touch = Touch;
-    function Read(value, prop) {
-        const wrapper = wrapperCache.get(value);
-        if (wrapper) {
-            const scope = Array.isArray(wrapper) ? wrapper[ARRAY_SCOPE] : (prop && wrapper[prop]) ?? wrapper[OBJECT_SCOPE];
-            ObservableScope.Update(scope);
-        }
-    }
-    ObservableNode.Read = Read;
     /**
      * Merges a new value into an observable node in-place, preserving the node's object identity.
      * Computes the diff between the node's current value and the provided value, then applies only
@@ -474,86 +401,19 @@ export var ObservableNode;
         ApplyDiff(rootNode, diff);
     }
     ObservableNode.Apply = Apply;
-    /**
-     * Splices an observable node's underlying array in-place, invalidating its snapshot and
-     * touching its scope so reactive readers update.
-     * @param rootNode The observable array node to splice.
-     * @param start Index at which to start changing the array.
-     * @param deleteCount Number of elements to remove starting at `start`.
-     * @param items Elements to insert at `start`.
-     * @param cloneData Whether to deep-clone `items` before inserting them (true by default,
-     *   so the store isn't left holding a reference the caller can still mutate).
-     */
-    function ApplySplice(rootNode, start, deleteCount, items, cloneData = true) {
-        const root = rootNode[NODE_VALUE];
-        InvalidateSnapshotForValue(rootNode[NODE_VALUE]);
-        const addItems = cloneData ? JsonDeepClone(items) : items;
-        root.splice(start, deleteCount, ...addItems);
-        ObservableNode.Update(root);
-    }
-    ObservableNode.ApplySplice = ApplySplice;
     /**
      * Applies a JSON diff result to an observable node, efficiently updating only changed properties.
      * Optimizes nested object updates by computing paths incrementally and touching modified properties.
      * @param rootNode The observable node to apply the diff to.
      * @param diffResult The diff result from JsonDiff containing path-value pairs of changes.
-     * @param cloneData Whether to deep-clone each diff value before writing it in (true by
-     *   default), so the store isn't left holding a reference the caller can still mutate.
+     *   Each value is deep-cloned as it's applied (see JsonApplyDiff).
      */
-    function ApplyDiff(rootNode, diffResult, cloneData = true) {
+    function ApplyDiff(rootNode, diffResult) {
         const root = rootNode[NODE_VALUE];
-        if (diffResult.length === 1 && diffResult[0].path.length === 0) {
-            // Replacing rootNode
-            InvalidateSnapshotForValue(root);
-            const rootPatch = cloneData ? JsonDeepClone(diffResult[0].value) : diffResult[0].value;
-            const rootType = JsonType(root);
-            const rootPatchType = JsonType(rootPatch);
-            if (rootType !== rootPatchType)
-                throw new Error("Unable to change type of Root ObservableNode: " + rootType);
-            switch (rootType) {
-                case "array": {
-                    root.splice(0, root.length, ...rootPatch);
-                    ObservableNode.Update(root);
-                    break;
-                }
-                case "object": {
-                    const keys = Object.keys(root);
-                    const patchKeys = Object.keys(rootPatch);
-                    for (let x = 0; x < keys.length; x++)
-                        if (!patchKeys.includes(keys[x]))
-                            delete root[keys[x]];
-                    Object.assign(root, rootPatch);
-                    for (let x = 0; x < keys.length; x++)
-                        ObservableNode.Update(root, keys[x]);
-                    break;
-                }
-                case "value":
-                    throw new Error("Unable to replace value type: " + root);
-            }
-            return;
-        }
-        const pathTuples = [["", root]];
-        for (let x = 0; x < diffResult.length; x++) {
-            const { path, value } = diffResult[x];
-            let y = 0;
-            for (; y < path.length - 1; y++) {
-                const property = path[y];
-                const value = pathTuples[y][1];
-                const tupleIndex = y + 1;
-                if (pathTuples.length <= tupleIndex)
-                    pathTuples.push([property, value[property]]);
-                else if (pathTuples[tupleIndex][0] !== property) {
-                    pathTuples[tupleIndex][0] = property;
-                    pathTuples[tupleIndex][1] = value[property];
-                    const next = tupleIndex + 1;
-                    if (next < pathTuples.length)
-                        pathTuples[next][0] = null;
-                }
-            }
-            const assignValue = pathTuples[y][1];
-            const assignData = cloneData ? JsonDeepClone(value) : value;
-            ObservableNode.Assign(assignValue, path[y], assignData);
-        }
+        JsonApplyDiff(root, diffResult, AssignNodeValue);
+        // A root replacement is applied in place without calling AssignNodeValue
+        if (diffResult.length === 1 && diffResult[0].path.length === 0)
+            NodeValueSet(root, "", false, rootNode[NODE_WRAPPER]);
     }
     ObservableNode.ApplyDiff = ApplyDiff;
     /**

package/Store/Tree/snapshot.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The keys walked from the snapshot's seed to a value: property names, array indices and
+ * hidden (symbol) props. A resolved child continues from the path its resolver returns.
+ */
+export type SnapshotPath = (string | number | symbol)[];
+/**
+ * Resolves a keyed child to the root entity it should be read through, given the child's
+ * path. Returns the entity and its path, or undefined when the child isn't keyed (or has no
+ * root), in which case the child itself is used. `path` is the walk's own stack, so a
+ * resolver must not keep it.
+ */
+export type SnapshotResolver = (child: any, path: Readonly<SnapshotPath>) => {
+    value: object;
+    path: SnapshotPath;
+} | undefined;
+/**
+ * Snapshot cache state. Each owner (a `DiffTree` instance, or `ObservableNode` at module
+ * level) creates its own state, so cached snapshots are never shared between owners.
+ */
+export interface ISnapshotState {
+    /** Raw value -> its cached immutable snapshot */
+    rawToSnapshotCache: WeakMap<object, any>;
+    /** Raw value -> every parent whose cached snapshot embedded it */
+    hierarchy: WeakMap<object, Set<object>>;
+    /** Default resolver for keyed children; a call to `Snapshot.Get` may override it */
+    resolve: SnapshotResolver | undefined;
+}
+export declare namespace Snapshot {
+    /**
+     * Creates a new, empty snapshot cache.
+     * @param resolve Optional default resolver for keyed children.
+     * @returns A new snapshot state.
+     */
+    function Create(resolve?: SnapshotResolver): ISnapshotState;
+    /**
+     * Returns an immutable, cached snapshot of a raw value. The same snapshot is returned
+     * until a write invalidates it, and unchanged nested parts are shared between snapshots,
+     * so `===` holds for any part that hasn't changed.
+     * @param state The snapshot cache to read from and populate.
+     * @param value The raw value to snapshot.
+     * @param resolve Resolver for keyed children; defaults to the state's resolver.
+     * @param path The value's own path. Snapshots are cached per raw value, so a value must
+     * always be seeded with the same path or a resolver may see a different one.
+     * @returns The snapshot.
+     */
+    function Get<T>(state: ISnapshotState, value: T, resolve?: SnapshotResolver | undefined, path?: SnapshotPath): T;
+    /**
+     * Invalidates the cached snapshot of a raw value that was just written to, along with
+     * every cached ancestor that embedded it.
+     * @param state The snapshot cache to invalidate.
+     * @param value The raw value that was written to.
+     */
+    function Invalidate(state: ISnapshotState, value: object): void;
+    /**
+     * The cached snapshot of a raw value, without building one. A write to the value, or to
+     * anything its snapshot embeds, clears the cache, so a reader that kept the snapshot it got
+     * can tell nothing under the value changed when this returns that same snapshot.
+     * @param state The snapshot cache.
+     * @param value The raw value.
+     * @returns The cached snapshot, or undefined when there's none.
+     */
+    function Peek<T>(state: ISnapshotState, value: T): T | undefined;
+    /**
+     * Registers a value as its own snapshot. Use in a case where an immutable value can
+     * represent itself as a valid snapshot without cloning.
+     * @param state The snapshot cache.
+     * @param value The raw value that is its own snapshot.
+     */
+    function Register(state: ISnapshotState, value: object): void;
+}