j-templates 8.2.0 → 9.0.1

package/Store/Diff/diffTree.js

@@ -1,36 +1,37 @@
-import { JsonDiff, JsonMerge, JsonType } from '../../Utils/json';
+import { JsonDiffInto, JsonMerge, JsonType } from '../../Utils/json';
 import { Snapshot } from '../Tree/snapshot';
-import { ApplyDiff, ApplyValueToPath, CreateKeyResolver, DeleteRouteState, ExpandWildcardPath, IsWildcardPath, JoinPaths, PROJECTION_PREFIX, ReadPath, ReadPathFound, ROOT_ROUTE, RouteMatches, SplitRouteAndPath, ToSnapshotPath, ValidateWildcardPath, WritePath } from './utils/diffTree.utils';
+import { ApplyValueToPath, SpliceValueAtPath } from './utils/homes';
+import { JoinPaths, PROJECTION_PREFIX, ROOT_ROUTE, SplitRouteAndPath } from './utils/paths';
+import { Projections } from './utils/projections';
+import { RouteInstances } from './utils/routes';
+import { DeleteRouteState, KeyUnchanged, ReadPath, ReadSnapshot } from './utils/state';
+/**
+ * A tree of JSON state in routes, with projections, that tracks its changes as diffs. The work is
+ * split across `utils/`:
+ * - `homes`: writes, which keep every keyed value at its home
+ * - `state`: reading and writing route state, and snapshots of it
+ * - `routes`: route instances, created from the route definitions
+ * - `projections`: running each route instance's projections
+ * - `paths`: path strings
+ */
 export class DiffTree {
     constructor(keyFunc, routeDefinitions = {}) {
-        this.keyFunc = keyFunc;
-        this.routeDefinitions = routeDefinitions;
         this.rootState = {};
-        this.commitedSnapshot = {};
-        // Definitions are fixed and instances are never removed, so a route path always finds the same instance
-        this.routeCache = new Map();
-        this.routeKeyFunc = (routePath) => this.GetRouteInstance(routePath).keyFunc;
-        this.resolver = CreateKeyResolver(this.rootState, this.routeKeyFunc);
-        this.snapshot = Snapshot.Create(this.resolver);
-        // Changes whenever the order is reset, so a wildcard read can tell its matches may have changed
-        this.routeVersion = 0;
-        if (!Object.hasOwn(this.routeDefinitions, ROOT_ROUTE))
-            this.routeDefinitions = { ...this.routeDefinitions, [ROOT_ROUTE]: { projections: {} } };
-        this.rootRoute = CreateRoute([], ROOT_ROUTE, this.routeDefinitions[ROOT_ROUTE], this.keyFunc);
-        // Every other pattern in the map is a child of the root route
-        this.rootRoute.routeDefinitions = this.routeDefinitions;
-        this.rootRoute.childPartCounts = PartCounts(this.routeDefinitions);
-        // Both spellings of the root route, so the first lookup of either isn't taken for a new instance
-        this.routeCache.set("", this.rootRoute);
-        this.routeCache.set(ROOT_ROUTE, this.rootRoute);
+        this.snapshot = Snapshot.Create();
+        /** Each root key's snapshot as of the last commit */
+        this.commitedSnapshot = new Map();
+        this.routes = new RouteInstances(keyFunc, routeDefinitions);
+        this.projections = new Projections(this.snapshot, this.rootState, this.routes);
+        this.writeContext = {
+            snapshot: this.snapshot,
+            root: this.rootState,
+            routeKeyFunc: (routePath) => this.routes.Get(routePath).keyFunc
+        };
     }
     WritePath(path, value) {
-        const [routePath, propertyPath] = SplitRouteAndPath(path);
-        if (propertyPath.startsWith(PROJECTION_PREFIX))
-            throw new Error(`${PROJECTION_PREFIX} keys are read-only.`);
-        this.GetRouteInstance(routePath);
+        AssertWritable(SplitRouteAndPath(path)[1]);
         // Keyed entities are local to the route written to; a key starting with "/" is a route path from the root
-        ApplyValueToPath(this.snapshot, this.rootState, this.routeKeyFunc, routePath, path, value);
+        ApplyValueToPath(this.writeContext, path, value);
     }
     PatchPath(path, patch) {
         const value = this.Snapshot(path);
@@ -38,70 +39,16 @@ export class DiffTree {
         this.WritePath(path, merged);
     }
     PushPath(path, items) {
-        const [routePath, valuePath] = SplitRouteAndPath(path);
-        if (valuePath.startsWith(PROJECTION_PREFIX))
-            throw new Error(`${PROJECTION_PREFIX} keys are read-only.`);
-        const combinedRoutePath = JoinPaths("", routePath);
-        const routeRoot = ReadPath(this.rootState, combinedRoutePath);
-        const value = ReadPath(this.Snapshot(combinedRoutePath), valuePath);
-        if (!value)
-            throw new Error(`Array not found at path: ${path}`);
-        if (!Array.isArray(value))
-            throw new Error(`Value at path ${path} is not an array`);
-        if (items.length === 0)
-            return;
-        const diff = [];
-        for (let x = 0; x < items.length; x++)
-            diff.push({
-                type: "write",
-                path: `${valuePath}.${value.length + x}`.split('.'),
-                value: items[x]
-            });
-        diff.push({
-            type: "write",
-            path: `${valuePath}.length`.split('.'),
-            value: value.length + items.length
-        });
-        ApplyDiff(this.snapshot, this.rootState, this.routeKeyFunc, combinedRoutePath, routeRoot, diff);
-        /* const keyedValues = ApplyDiffToData(this.snapshot, this.rootState, this.routeKeyFunc, combinedRoutePath, routeRoot, diff);
-        ApplyPathValues(this.snapshot, this.rootState, keyedValues); */
+        // A start past the end appends
+        this.Splice(path, Infinity, 0, items);
     }
     SplicePath(path, start, deleteCount, items) {
-        const [routePath, valuePath] = SplitRouteAndPath(path);
-        if (valuePath.startsWith(PROJECTION_PREFIX))
-            throw new Error(`${PROJECTION_PREFIX} keys are read-only.`);
-        const combinedRoutePath = JoinPaths("", routePath);
-        const routeRoot = this.ReadPath(combinedRoutePath);
-        const routeRootSnapshot = this.Snapshot(combinedRoutePath);
-        const value = ReadPath(routeRootSnapshot, valuePath);
-        if (!value)
-            throw new Error(`Array not found at path: ${path}`);
-        if (!Array.isArray(value))
-            throw new Error(`Value at path ${path} is not an array`);
-        const moveStartIndex = start + deleteCount;
-        const moveEndIndex = start + items.length;
-        const diff = [];
-        const basePath = valuePath.split('.');
-        for (let x = moveStartIndex; x < value.length; x++)
-            diff.push({
-                type: "move",
-                path: basePath,
-                sourceProp: x,
-                targetProp: moveEndIndex + (x - moveStartIndex)
-            });
-        for (let x = 0; x < items.length; x++)
-            diff.push({
-                type: "write",
-                path: basePath.concat(start + x),
-                value: items[x]
-            });
-        const actualDelete = start + deleteCount > value.length ? value.length - start : deleteCount;
-        diff.push({
-            type: "write",
-            path: basePath.concat("length"),
-            value: value.length - actualDelete + items.length
-        });
-        ApplyDiff(this.snapshot, this.rootState, this.routeKeyFunc, combinedRoutePath, routeRoot, diff);
+        this.Splice(path, start, deleteCount, items);
+    }
+    // Shared by PushPath and SplicePath, which a DiffTreeWriter guards separately
+    Splice(path, start, deleteCount, items) {
+        AssertWritable(SplitRouteAndPath(path)[1]);
+        SpliceValueAtPath(this.writeContext, path, start, deleteCount, items);
     }
     /**
      * Deletes a route: its state, its child routes and projection outputs, and its route
@@ -116,12 +63,7 @@ export class DiffTree {
         if (propertyPath || fullRoute === ROOT_ROUTE)
             throw new Error(`Unable to delete ${routePath}: only a non-root route path, e.g. /channel/1/, can be deleted.`);
         DeleteRouteState(this.snapshot, this.rootState, fullRoute);
-        RemoveRouteInstances(this.rootRoute, fullRoute);
-        for (const cachedPath of this.routeCache.keys())
-            if (cachedPath.startsWith(fullRoute))
-                this.routeCache.delete(cachedPath);
-        this.projectionOrder = undefined;
-        this.routeVersion++;
+        this.routes.Delete(fullRoute);
     }
     /**
      * Reads the raw value at a path, root (`value.prop`) or routed (`/channel/1/value.prop`).
@@ -130,440 +72,99 @@ export class DiffTree {
     ReadPath(path) {
         return ReadPath(this.rootState, path);
     }
-    /**
-     * Runs every projection of every route instance, dependencies first. A projection is skipped
-     * when no route it reads through changed since its last run, when a read's parent is missing,
-     * or when every read value is the same as its last run. Outputs are written as-is to
-     * `$projection_<key>` in their route, without a diff.
-     * @throws When projections depend on each other in a cycle
-     */
+    /** Runs every projection of every route instance; see `Projections.Run` */
     RunProjections() {
-        const order = this.projectionOrder ??= OrderProjections(this.rootRoute);
-        for (let x = 0; x < order.length; x++) {
-            const projection = order[x];
-            if (this.SourcesUnchanged(projection.sources))
-                continue;
-            const previous = projection.sources;
-            const values = this.ReadValues(projection.reads, projection.sources = new Array(projection.reads.length), previous);
-            if (!values || SameValues(projection.reads, values, projection.values))
-                continue;
-            let output;
-            if (projection.keyed) {
-                output = RunKeyed(projection, projection.keyed, values[0]);
-                // Every entry kept its output, so the record it wrote last run still holds
-                if (output === UNCHANGED) {
-                    projection.values = values;
-                    continue;
-                }
-            }
-            else
-                output = projection.projection(...values);
-            WritePath(this.snapshot, this.rootState, projection.output, output, false);
-            Snapshot.Register(this.snapshot, output);
-            if (projection.readsOutput)
-                // Its own output is one of its reads, so the output it just wrote isn't a change
-                projection.values = this.ReadValues(projection.reads, projection.sources = new Array(projection.reads.length), projection.sources);
-            else {
-                projection.values = values;
-                this.RefreshSources(projection.sources, SplitRouteAndPath(projection.output)[0]);
-            }
-        }
-    }
-    Commit() {
-        const nextSnapshot = Snapshot.Get(this.snapshot, this.rootState, this.resolver);
-        const currentKeys = new Set(Object.keys(this.commitedSnapshot));
-        const nextKeys = Object.keys(nextSnapshot);
-        let diff = [];
-        for (let x = 0; x < nextKeys.length; x++) {
-            currentKeys.delete(nextKeys[x]);
-            diff = JsonDiff(nextSnapshot[nextKeys[x]], this.commitedSnapshot[nextKeys[x]], nextKeys[x], diff);
-        }
-        for (let key of currentKeys)
-            diff.push({
-                type: "write",
-                path: [key],
-                value: undefined
-            });
-        this.commitedSnapshot = nextSnapshot;
-        return diff;
-    }
-    Snapshot(path) {
-        const [routePath, propertyPath] = SplitRouteAndPath(path);
-        const routeState = ReadPath(this.rootState, routePath);
-        const routeSnapshot = Snapshot.Get(this.snapshot, routeState, undefined, ToSnapshotPath(routePath));
-        const snapshot = ReadPath(routeSnapshot, propertyPath);
-        return snapshot;
-    }
-    /**
-     * Finds the route instance for a route path (the portion of a path before the last `/`), creating it (and any missing
-     * parent instances) from the matching definition on first use.
-     * @returns The deepest route instance matched by a definition, or the root route when none matches
-     */
-    GetRouteInstance(routePath) {
-        let route = this.routeCache.get(routePath);
-        if (route)
-            return route;
-        this.projectionOrder = undefined;
-        this.routeVersion++;
-        const segments = RouteSegments(routePath);
-        route = segments.length === 0 ? this.rootRoute : FindRoute(this.rootRoute, segments, 0, this.keyFunc) ?? this.rootRoute;
-        this.routeCache.set(routePath, route);
-        return route;
-    }
-    /**
-     * Whether every route a projection's reads resolved through on its last full read still has
-     * the snapshot it read: a write anywhere under a route clears its cached snapshot, so then no
-     * read can have changed. A wildcard read also needs the same route instances to exist.
-     */
-    SourcesUnchanged(sources) {
-        if (!sources)
-            return false;
-        for (let x = 0; x < sources.length; x++) {
-            const source = sources[x];
-            if (!source)
-                return false;
-            if ("matches" in source) {
-                if (source.version !== this.routeVersion)
-                    return false;
-                for (let y = 0; y < source.matches.length; y++)
-                    if (Snapshot.Peek(this.snapshot, source.matches[y].state) !== source.matches[y].snapshot)
-                        return false;
-            }
-            else if (Snapshot.Peek(this.snapshot, source.state) !== source.snapshot)
-                return false;
-        }
-        return true;
+        this.projections.Run();
     }
     /**
-     * Takes a new snapshot of every source in the route a projection just wrote its output to. The
-     * write cleared that route's snapshot, but nothing the projection read changed between its read
-     * and the write, so without this the next run would read everything again for nothing.
+     * The changes since the last commit. The root is a flat record of keys, so each key's snapshot
+     * is taken and compared on its own, without building a snapshot of the whole root: a key no
+     * write touched has the same cached snapshot as the last commit, and is skipped.
      */
-    RefreshSources(sources, outputRoute) {
-        for (let x = 0; x < sources.length; x++) {
-            const source = sources[x];
-            const routes = source && ("matches" in source ? source.matches : [source]);
-            for (let y = 0; routes && y < routes.length; y++)
-                if (routes[y].route === outputRoute)
-                    routes[y].snapshot = Snapshot.Get(this.snapshot, routes[y].state, this.resolver, ToSnapshotPath(outputRoute));
-        }
-    }
-    /**
-     * Snapshots of the values at each path, read through the route's root object so keyed
-     * values resolve through their own copy.
-     * @param sources Filled with what each read resolved through; a read after a missing one is left undefined
-     * @param previous The sources of the last full read, so a wildcard read reuses its unchanged matches
-     * @returns The values, or undefined when any of them is missing
-     */
-    ReadValues(paths, sources, previous) {
-        const values = new Array(paths.length);
-        for (let x = 0; x < paths.length; x++) {
-            if (IsWildcardPath(paths[x])) {
-                const source = this.ReadWildcard(paths[x], previous?.[x]);
-                values[x] = WildcardValue(source);
-                sources[x] = source;
+    Commit() {
+        const committed = this.commitedSnapshot;
+        const keys = Object.keys(this.rootState);
+        // Diffed key by key into one result
+        const diff = [];
+        const rootKeyFunc = this.routes.root.keyFunc;
+        const strategy = CommitStrategy(rootKeyFunc);
+        const identity = CommitIdentity(rootKeyFunc);
+        // How many of the committed keys are still in the root, to tell whether any are gone
+        let kept = 0;
+        for (let x = 0; x < keys.length; x++) {
+            const key = keys[x];
+            const had = committed.has(key);
+            had && kept++;
+            const last = committed.get(key);
+            if (had && KeyUnchanged(this.snapshot, this.rootState, key, last))
+                continue;
+            const next = Snapshot.Child(this.snapshot, this.rootState, key);
+            if (had && next === last)
                 continue;
-            }
-            const [value, found, source] = this.ReadValue(paths[x]);
-            sources[x] = source;
-            if (!found)
-                return undefined;
-            values[x] = value;
+            JsonDiffInto(next, last, [key], diff, strategy, identity);
+            committed.set(key, next);
         }
-        return values;
-    }
-    /** The value at a path, whether it was found, and the route it was read through, when there is one */
-    ReadValue(path) {
-        const [route, property] = SplitRouteAndPath(path);
-        const [routeState, found] = ReadPathFound(this.rootState, route);
-        if (!found || !routeState)
-            return [undefined, false, undefined];
-        const routeSnapshot = Snapshot.Get(this.snapshot, routeState, this.resolver, ToSnapshotPath(route));
-        const [value, valueFound] = ReadPathFound(routeSnapshot, property);
-        return [value, valueFound, { route, state: routeState, snapshot: routeSnapshot }];
+        if (kept < committed.size)
+            for (const key of committed.keys())
+                if (!Object.hasOwn(this.rootState, key)) {
+                    committed.delete(key);
+                    diff.push({
+                        type: "delete",
+                        path: [key]
+                    });
+                }
+        return diff;
     }
     /**
-     * Reads every route a wildcard path matches. While no route instance was added or removed since
-     * the last read, the matches are the same, and a match whose route has the same snapshot keeps
-     * the value it read.
+     * The snapshot of the value at a path. Only the path's first property is snapshotted, not
+     * its whole route.
+     * @returns The snapshot, or undefined when any segment of the path doesn't exist
      */
-    ReadWildcard(path, previous) {
-        if (previous && previous.version === this.routeVersion) {
-            const matches = previous.matches.map(match => Snapshot.Peek(this.snapshot, match.state) === match.snapshot ? match : this.ReadMatch(match.segment, match.path));
-            return { version: this.routeVersion, matches };
-        }
-        const paths = ExpandWildcardPath(this.rootState, path);
-        const matches = [];
-        for (const segment in paths)
-            matches.push(this.ReadMatch(segment, paths[segment]));
-        return { version: this.routeVersion, matches };
-    }
-    ReadMatch(segment, path) {
-        const [value, found, source] = this.ReadValue(path);
-        // An expanded path's route exists, so a source is always found
-        return { ...source, segment, path, value, found };
-    }
-}
-/**
- * The value of a wildcard read: each match's value keyed by its segment. A match missing the
- * value is left out, so no match reads as an empty object.
- */
-function WildcardValue(source) {
-    const values = {};
-    for (let x = 0; x < source.matches.length; x++)
-        if (source.matches[x].found)
-            values[source.matches[x].segment] = source.matches[x].value;
-    return values;
-}
-/** Whether every read value is the same as its last run; a wildcard read compares each matched value */
-function SameValues(paths, values, lastValues) {
-    if (!lastValues)
-        return false;
-    for (let x = 0; x < values.length; x++)
-        if (values[x] !== lastValues[x] && !(IsWildcardPath(paths[x]) && SameEntries(values[x], lastValues[x])))
-            return false;
-    return true;
-}
-function SameEntries(values, lastValues) {
-    const keys = Object.keys(values);
-    if (keys.length !== Object.keys(lastValues).length)
-        return false;
-    for (let x = 0; x < keys.length; x++)
-        if (!Object.hasOwn(lastValues, keys[x]) || values[keys[x]] !== lastValues[keys[x]])
-            return false;
-    return true;
-}
-/**
- * Whether a read and a projection output overlap: the read's route matches the output's (see
- * `RouteMatches` for wildcards), and one dot path contains the other. A read of the route's root
- * object (`/channel/1/`) overlaps every output in that route, but not those of its child routes,
- * which a snapshot of the route doesn't include.
- */
-function PathsOverlap(read, output) {
-    const [readRoute, readProperty] = SplitRouteAndPath(read);
-    const [outputRoute, outputProperty] = SplitRouteAndPath(output);
-    return RouteMatches(readRoute, outputRoute) && PropertiesOverlap(readProperty, outputProperty);
-}
-/** What `RunKeyed` returns when no entry's output changed and none was added or removed */
-const UNCHANGED = Symbol("UNCHANGED");
-/**
- * A keyed projection's output for a record: each entry's output, from its last run when its value
- * is the same, and without the entries it returns undefined for. A value that isn't an object or
- * array reads as an empty record.
- * @returns The output, or `UNCHANGED` when it would hold the same entries as the last one written
- */
-function RunKeyed(projection, state, record) {
-    const entries = new Map();
-    const output = {};
-    let changed = projection.values === undefined;
-    const keys = JsonType(record) === "value" ? [] : Object.keys(record);
-    for (let x = 0; x < keys.length; x++) {
-        const key = keys[x];
-        if (state.routeState && key.startsWith(PROJECTION_PREFIX))
-            continue;
-        const value = record[key];
-        const last = state.entries.get(key);
-        const entry = last && last.value === value ? last : { value, output: projection.projection(value, key) };
-        entries.set(key, entry);
-        changed ||= entry !== last && entry.output !== last?.output;
-        if (entry.output !== undefined)
-            SetOwnKey(output, key, entry.output);
-    }
-    // A key that's gone changes the output unless it was left out of it
-    for (const [key, last] of state.entries)
-        if (!entries.has(key) && last.output !== undefined)
-            changed = true;
-    state.entries = entries;
-    return changed ? output : UNCHANGED;
-}
-/** Sets a key as an own property, even `__proto__`, which plain assignment would make the prototype */
-function SetOwnKey(target, key, value) {
-    if (key === "__proto__")
-        Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
-    else
-        target[key] = value;
-}
-/** Whether a read's property path and an output's in a matching route overlap; see `PathsOverlap` */
-function PropertiesOverlap(readProperty, outputProperty) {
-    return readProperty === "" ||
-        readProperty === outputProperty ||
-        readProperty.startsWith(`${outputProperty}.`) ||
-        outputProperty.startsWith(`${readProperty}.`);
-}
-function CollectProjections(route, byRoute) {
-    for (let x = 0; x < route.projections.length; x++) {
-        const [outputRoute] = SplitRouteAndPath(route.projections[x].output);
-        let projections = byRoute.get(outputRoute);
-        projections || byRoute.set(outputRoute, projections = []);
-        projections.push(route.projections[x]);
+    Snapshot(path) {
+        return ReadSnapshot(this.snapshot, this.rootState, path)[0];
     }
-    for (const child of route.childRoutes.values())
-        CollectProjections(child, byRoute);
 }
 /**
- * Topologically sorts every projection under a route: a projection depends on every other
- * projection whose output overlaps one of its reads, so that projection is sorted earlier.
- * @throws When projections depend on each other in a cycle
+ * How `Commit` diffs the root's snapshots for a Store with the same keyFunc:
+ * - An array whose first element is keyed is spliced, its elements matched by CommitIdentity.
+ * - A keyed value below a root key, with the same key as before, is skipped when the Store reads it
+ *   through its root key (any key not starting with `/`): that root key's own diff carries the
+ *   change. The Store doesn't read a route key through its key, so that one is diffed.
+ * - A keyed value with a different key is written.
+ * Each root key's own value is diffed, keyed or not: it's the entity's home.
  */
-function OrderProjections(rootRoute) {
-    const byRoute = new Map();
-    CollectProjections(rootRoute, byRoute);
-    const order = [];
-    const state = new Map();
-    // The projections of every route a wildcard read's route matches, found once per read route
-    const wildcardCandidates = new Map();
-    const CandidatesOf = (readRoute) => {
-        let candidates = wildcardCandidates.get(readRoute);
-        if (!candidates) {
-            candidates = [];
-            for (const [outputRoute, projections] of byRoute)
-                if (RouteMatches(readRoute, outputRoute))
-                    candidates.push(projections);
-            wildcardCandidates.set(readRoute, candidates);
-        }
-        return candidates;
-    };
-    function Visit(projection, stack) {
-        if (state.get(projection) === "done")
-            return;
-        if (state.get(projection) === "visiting")
-            throw new Error(`DiffTree projection cycle detected: ${stack.concat(projection.output).join(" -> ")}`);
-        state.set(projection, "visiting");
-        const next = stack.concat(projection.output);
-        // A keyed projection of its route's own state reads none of the route's projection outputs
-        for (let x = 0; !projection.keyed?.routeState && x < projection.reads.length; x++) {
-            const [readRoute, readProperty] = SplitRouteAndPath(projection.reads[x]);
-            // A wildcard read can match outputs in any number of routes; the others only in their own
-            const routeCandidates = IsWildcardPath(projection.reads[x]) ? CandidatesOf(readRoute) : [byRoute.get(readRoute) ?? []];
-            for (const candidates of routeCandidates)
-                for (let y = 0; y < candidates.length; y++)
-                    if (candidates[y] !== projection && PropertiesOverlap(readProperty, SplitRouteAndPath(candidates[y].output)[1]))
-                        Visit(candidates[y], next);
-        }
-        state.set(projection, "done");
-        order.push(projection);
-    }
-    for (const projections of byRoute.values())
-        for (let x = 0; x < projections.length; x++)
-            Visit(projections[x], []);
-    return order;
-}
-function FindRoute(parent, segments, index, defaultKeyFunc) {
-    let route = FindChildRoute(parent, segments, index);
-    if (!route) {
-        const match = MatchRouteDefinition(parent.routeDefinitions, segments, index);
-        if (!match)
+function CommitStrategy(keyFunc) {
+    return keyFunc && function (newValue, oldValue, path) {
+        if (Array.isArray(newValue))
+            return newValue.length > 0 && JsonType(newValue[0]) !== "value" && keyFunc(newValue[0]) !== undefined ? "splice" : undefined;
+        if (path.length <= 1)
             return undefined;
-        const end = index + match.length;
-        const parts = segments.slice(index, end);
-        route = CreateRoute(parts, `/${segments.slice(0, end).join("/")}/`, match.definition, defaultKeyFunc);
-        // Kept even when a deeper segment matches no definition, so a write below an undefined
-        // child route still creates the parent routes whose projections may read it
-        parent.childRoutes.set(parts.join("/"), route);
-    }
-    const nextIndex = index + route.parts.length;
-    // Segments below the deepest defined route belong to it
-    return nextIndex === segments.length ? route : FindRoute(route, segments, nextIndex, defaultKeyFunc) ?? route;
-}
-/**
- * The existing child instance the segments from `index` name, looked up by key for each number
- * of segments a child pattern spans, so finding one doesn't scan its siblings.
- */
-function FindChildRoute(parent, segments, index) {
-    for (let x = 0; x < parent.childPartCounts.length; x++) {
-        const count = parent.childPartCounts[x];
-        if (index + count > segments.length)
-            continue;
-        const route = parent.childRoutes.get(segments.slice(index, index + count).join("/"));
-        if (route)
-            return route;
-    }
-    return undefined;
-}
-/** Removes every route instance at or below a route path from the instances under `route` */
-function RemoveRouteInstances(route, routePath) {
-    for (const [key, child] of route.childRoutes) {
-        if (child.path.startsWith(routePath))
-            route.childRoutes.delete(key);
-        else if (routePath.startsWith(child.path))
-            RemoveRouteInstances(child, routePath);
-    }
-}
-/** The distinct numbers of segments the patterns in a definition map span, in definition order */
-function PartCounts(definitions) {
-    const counts = [];
-    for (const pattern in definitions) {
-        const count = RouteSegments(pattern).length;
-        // The root pattern has no segments and is never a child
-        if (count > 0 && !counts.includes(count))
-            counts.push(count);
-    }
-    return counts;
-}
-function MatchRouteDefinition(definitions, segments, index) {
-    if (!definitions)
-        return undefined;
-    for (const pattern in definitions) {
-        const patternParts = RouteSegments(pattern);
-        // The root pattern has no segments and would match anything
-        if (patternParts.length === 0 || patternParts.length > segments.length - index)
-            continue;
-        let x = 0;
-        for (; x < patternParts.length && (IsParam(patternParts[x]) || patternParts[x] === segments[index + x]); x++)
-            ;
-        if (x === patternParts.length)
-            return { definition: definitions[pattern], length: patternParts.length };
-    }
-    return undefined;
+        const key = keyFunc(newValue);
+        if (key === undefined)
+            return undefined;
+        if (key !== (JsonType(oldValue) === "value" ? undefined : keyFunc(oldValue)))
+            return "write";
+        return key.startsWith(ROOT_ROUTE) ? undefined : "skip";
+    };
 }
 /**
- * @param routePath The instance's full route from the tree root, e.g. `/Root/1234/`. Each projection
- * read is resolved against it, so `name` becomes `/Root/1234/name`; a read starting with `/` is kept as-is.
- * @param defaultKeyFunc The tree's keyFunc, used when the definition doesn't define one
+ * What `Commit` matches a spliced array's elements by:
+ * - An entity the Store reads by its root key (any key not starting with `/`) is matched by that
+ *   key. Editing it leaves the array unchanged, and its root key's own diff carries the change. An
+ *   entity whose key changed doesn't match, so it's deleted and the new one inserted.
+ * - Anything else, route-key entities included, is matched by ===: the Store doesn't read a route
+ *   key through its key, so a changed one must be replaced.
  */
-function CreateRoute(parts, routePath, definition, defaultKeyFunc) {
-    const projections = [];
-    for (const key in definition.projections) {
-        const projectionDefinition = definition.projections[key];
-        const output = JoinPaths(routePath, `${PROJECTION_PREFIX}${key}`);
-        if (IsKeyedDefinition(projectionDefinition)) {
-            const { read, projection } = projectionDefinition;
-            if (read !== undefined && IsWildcardPath(read))
-                throw new Error(`Invalid keyed projection read ${read}: a keyed projection reads one record, without a wildcard.`);
-            // Its route's own state, without the outputs, so its own output isn't one of its reads
-            const routeRead = JoinPaths(routePath, read ?? "");
-            projections.push({
-                key,
-                reads: [routeRead],
-                projection,
-                output,
-                readsOutput: read !== undefined && PathsOverlap(routeRead, output),
-                keyed: { entries: new Map(), routeState: read === undefined }
-            });
-            continue;
-        }
-        const { reads, projection } = projectionDefinition;
-        reads.forEach(ValidateWildcardPath);
-        const routeReads = reads.map(read => JoinPaths(routePath, read));
-        projections.push({ key, reads: routeReads, projection, output, readsOutput: routeReads.some(read => PathsOverlap(read, output)) });
-    }
-    return {
-        path: routePath,
-        parts,
-        projections,
-        childRoutes: new Map(),
-        childPartCounts: PartCounts(definition.routes),
-        keyFunc: definition.keyFunc ?? defaultKeyFunc,
-        routeDefinitions: definition.routes
+function CommitIdentity(keyFunc) {
+    return keyFunc && function (value) {
+        if (JsonType(value) === "value")
+            return value;
+        const key = keyFunc(value);
+        return key === undefined || key.startsWith(ROOT_ROUTE) ? value : key;
     };
 }
-/** Whether a projection definition is a keyed projection: it has no `reads` */
-function IsKeyedDefinition(definition) {
-    return definition.reads === undefined;
-}
-function IsParam(part) {
-    return part.startsWith("{") && part.endsWith("}");
-}
-function RouteSegments(route) {
-    return route.split("/").filter(part => part !== "");
+/** Projection outputs are written only by RunProjections */
+function AssertWritable(propertyPath) {
+    if (propertyPath.startsWith(PROJECTION_PREFIX))
+        throw new Error(`${PROJECTION_PREFIX} keys are read-only.`);
 }