@1771technologies/lytenyte-pro 1.0.0-beta.33 → 1.0.0-beta.36

package/dist/row-data-source-server/async-tree/+types.async-tree.d.ts

@@ -2,58 +2,61 @@
  * The root of the async tree. This is the entry point of the tree.
  */
 export type TreeRoot<K, D> = {
-    readonly kind: "root";
-    readonly byPath: Map<string | null, LeafOrParent<K, D>>;
-    readonly byIndex: Map<number, LeafOrParent<K, D>>;
-    readonly size: number;
-    readonly asOf: number;
+  readonly kind: "root";
+  readonly byPath: Map<string | null, LeafOrParent<K, D>>;
+  readonly byIndex: Map<number, LeafOrParent<K, D>>;
+  readonly size: number;
+  readonly asOf: number;
 };
 export type TreeParent<K, D> = {
-    readonly kind: "parent";
-    readonly relIndex: number;
-    readonly data: K;
-    readonly asOf: number;
-    readonly byPath: Map<string | null, LeafOrParent<K, D>>;
-    readonly byIndex: Map<number, LeafOrParent<K, D>>;
-    readonly size: number;
-    readonly path: string | null;
-    readonly parent: TreeParent<K, D> | TreeRoot<K, D>;
+  readonly kind: "parent";
+  readonly relIndex: number;
+  readonly data: K;
+  readonly asOf: number;
+  readonly byPath: Map<string | null, LeafOrParent<K, D>>;
+  readonly byIndex: Map<number, LeafOrParent<K, D>>;
+  readonly size: number;
+  readonly path: string | null;
+  readonly parent: TreeParent<K, D> | TreeRoot<K, D>;
 };
 export type TreeLeaf<K, D> = {
-    readonly kind: "leaf";
-    readonly relIndex: number;
-    readonly data: D;
-    readonly asOf: number;
-    readonly parent: TreeParent<K, D> | TreeRoot<K, D>;
-    readonly path: string;
+  readonly kind: "leaf";
+  readonly relIndex: number;
+  readonly data: D;
+  readonly asOf: number;
+  readonly parent: TreeParent<K, D> | TreeRoot<K, D>;
+  readonly path: string;
 };
 export type LeafOrParent<K, D> = TreeLeaf<K, D> | TreeParent<K, D>;
 export type TreeRootAndApi<K, D> = TreeRoot<K, D> & {
-    readonly set: (payload: SetDataAction<K, D>) => void;
-    readonly delete: (path: DeleteDataAction) => void;
-    readonly get: (payload: GetDataAction) => TreeRoot<K, D> | TreeParent<K, D> | null;
+  readonly set: (payload: SetDataAction<K, D>) => void;
+  readonly delete: (path: DeleteDataAction) => void;
+  readonly get: (payload: GetDataAction) => TreeRoot<K, D> | TreeParent<K, D> | null;
 };
 export interface SetDataAction<K = any, D = any> {
-    readonly path: (string | null)[];
-    readonly asOf?: number;
-    readonly size?: number;
-    readonly items?: ({
+  readonly path: (string | null)[];
+  readonly asOf?: number;
+  readonly size?: number;
+  readonly items?: (
+    | {
         kind: "parent";
         path: string | null;
         data: K;
         relIndex: number;
         size: number;
-    } | {
+      }
+    | {
         kind: "leaf";
         data: D;
         relIndex: number;
-    })[];
+      }
+  )[];
 }
 export interface DeleteDataAction {
-    readonly path: (string | null)[];
-    readonly paths?: string[];
-    readonly relIndices?: number[];
+  readonly path: (string | null)[];
+  readonly paths?: string[];
+  readonly relIndices?: number[];
 }
 export interface GetDataAction {
-    readonly path: (string | null)[];
+  readonly path: (string | null)[];
 }

package/dist/row-data-source-server/async-tree/apply-delete-action-to-tree.d.ts

@@ -1,2 +1,5 @@
 import type { DeleteDataAction, TreeRoot } from "./+types.async-tree";
-export declare function applyDeleteActionToTree<K, D>(p: DeleteDataAction, tree: TreeRoot<K, D>): void;
+export declare function applyDeleteActionToTree<K, D>(
+  p: DeleteDataAction,
+  tree: TreeRoot<K, D>,
+): void;

package/dist/row-data-source-server/async-tree/apply-delete-action-to-tree.js

@@ -1,27 +1,23 @@
 import { getParentNodeByPath } from "./get-parent-node-by-path.js";
 export function applyDeleteActionToTree(p, tree) {
-    // No op. We aren't deleting keys or indices
-    if (!p.relIndices?.length && !p.paths?.length)
-        return;
-    const parentNode = getParentNodeByPath(tree, p.path);
-    if (!parentNode)
-        return;
-    if (p.relIndices) {
-        for (const rel of p.relIndices) {
-            const node = parentNode.byIndex.get(rel);
-            if (!node)
-                continue;
-            parentNode.byPath.delete(node.path);
-            parentNode.byIndex.delete(rel);
-        }
+  // No op. We aren't deleting keys or indices
+  if (!p.relIndices?.length && !p.paths?.length) return;
+  const parentNode = getParentNodeByPath(tree, p.path);
+  if (!parentNode) return;
+  if (p.relIndices) {
+    for (const rel of p.relIndices) {
+      const node = parentNode.byIndex.get(rel);
+      if (!node) continue;
+      parentNode.byPath.delete(node.path);
+      parentNode.byIndex.delete(rel);
     }
-    if (p.paths) {
-        for (const path of p.paths) {
-            const node = parentNode.byPath.get(path);
-            if (!node)
-                continue;
-            parentNode.byPath.delete(node.path);
-            parentNode.byIndex.delete(node.relIndex);
-        }
+  }
+  if (p.paths) {
+    for (const path of p.paths) {
+      const node = parentNode.byPath.get(path);
+      if (!node) continue;
+      parentNode.byPath.delete(node.path);
+      parentNode.byIndex.delete(node.relIndex);
     }
+  }
 }

package/dist/row-data-source-server/async-tree/apply-set-action-to-tree.d.ts

@@ -1,2 +1,5 @@
 import type { SetDataAction, TreeRoot } from "./+types.async-tree.js";
-export declare function applySetActionToTree<K, D>(p: SetDataAction<K, D>, root: TreeRoot<K, D>): boolean;
+export declare function applySetActionToTree<K, D>(
+  p: SetDataAction<K, D>,
+  root: TreeRoot<K, D>,
+): boolean;

package/dist/row-data-source-server/async-tree/apply-set-action-to-tree.js

@@ -8,29 +8,21 @@ import { isSetActionANoOpOnNode } from "./is-set-action-a-no-op-on-node.js";
 import { maybeApplyResize } from "./maybe-apply-resize.js";
 import { maybeApplySetActionItems } from "./maybe-apply-set-action-items.js";
 export function applySetActionToTree(p, root) {
-    // If we are not adding items and we are not resizing a node, then we just
-    // return our previous data and skip the update. This is effectively a no-op.
-    if (!p.items?.length && p.size == null)
-        return false;
-    // We need to find the parent that we are adding data to. Its possible the path is invalid.
-    // If we encounter an invalid path we return early without change. An invalid path is a
-    // path that does not exist or where there is a leaf node at some point in the path.
-    const pathNode = getParentNodeByPath(root, p.path);
-    if (!pathNode)
-        return false;
-    if (!checkSetActionItemKeysFit(p, pathNode))
-        return false;
-    if (!checkSetActionItemKinds(p))
-        return false;
-    if (!checkSetActionItemKeysAreValid(p))
-        return false;
-    if (!checkSetActionItemKeysAreUnique(p))
-        return false;
-    if (isSetActionANoOpOnNode(p, pathNode))
-        return false;
-    maybeApplyResize(pathNode, p.size, p.asOf ?? Date.now());
-    if (maybeApplyParentRemoveSelf(pathNode))
-        return true;
-    maybeApplySetActionItems(p, pathNode);
-    return true;
+  // If we are not adding items and we are not resizing a node, then we just
+  // return our previous data and skip the update. This is effectively a no-op.
+  if (!p.items?.length && p.size == null) return false;
+  // We need to find the parent that we are adding data to. Its possible the path is invalid.
+  // If we encounter an invalid path we return early without change. An invalid path is a
+  // path that does not exist or where there is a leaf node at some point in the path.
+  const pathNode = getParentNodeByPath(root, p.path);
+  if (!pathNode) return false;
+  if (!checkSetActionItemKeysFit(p, pathNode)) return false;
+  if (!checkSetActionItemKinds(p)) return false;
+  if (!checkSetActionItemKeysAreValid(p)) return false;
+  if (!checkSetActionItemKeysAreUnique(p)) return false;
+  if (isSetActionANoOpOnNode(p, pathNode)) return false;
+  maybeApplyResize(pathNode, p.size, p.asOf ?? Date.now());
+  if (maybeApplyParentRemoveSelf(pathNode)) return true;
+  maybeApplySetActionItems(p, pathNode);
+  return true;
 }

package/dist/row-data-source-server/async-tree/check-set-action-item-keys-are-unique.js

@@ -2,23 +2,23 @@ import { ROOT_LEAF_PREFIX } from "./+constants.async-tree.js";
 const invalidItemKeyDupes = "Invalid set action items, the same 'key' appears more than once";
 const invalidItemPathsDupes = "Invalid set action items, the same 'path' appears more than once";
 export function checkSetActionItemKeysAreUnique(p) {
-    const seenKeys = new Set();
-    const seenPaths = new Set();
-    if (!p.items?.length)
-        return true;
-    for (let i = p.items.length - 1; i >= 0; i--) {
-        const item = p.items[i];
-        if (seenKeys.has(item.relIndex)) {
-            console.error(invalidItemKeyDupes, p);
-            return false;
-        }
-        const pathId = item.kind === "leaf" ? `${p.path.at(-1) ?? ROOT_LEAF_PREFIX}#${item.relIndex}` : item.path;
-        if (seenPaths.has(pathId)) {
-            console.error(invalidItemPathsDupes, p);
-            return false;
-        }
-        seenPaths.add(pathId);
-        seenKeys.add(item.relIndex);
+  const seenKeys = new Set();
+  const seenPaths = new Set();
+  if (!p.items?.length) return true;
+  for (let i = p.items.length - 1; i >= 0; i--) {
+    const item = p.items[i];
+    if (seenKeys.has(item.relIndex)) {
+      console.error(invalidItemKeyDupes, p);
+      return false;
     }
-    return true;
+    const pathId =
+      item.kind === "leaf" ? `${p.path.at(-1) ?? ROOT_LEAF_PREFIX}#${item.relIndex}` : item.path;
+    if (seenPaths.has(pathId)) {
+      console.error(invalidItemPathsDupes, p);
+      return false;
+    }
+    seenPaths.add(pathId);
+    seenKeys.add(item.relIndex);
+  }
+  return true;
 }

package/dist/row-data-source-server/async-tree/check-set-action-item-keys-are-valid.js

@@ -1,14 +1,13 @@
 const invalidItemKeyType = "Invalid set action items, 'relIndex' must be a positive integer";
 export function checkSetActionItemKeysAreValid(p) {
-    if (!p.items?.length)
-        return true;
-    const items = p.items;
-    for (let i = items.length - 1; i >= 0; i--) {
-        const x = items[i];
-        if (typeof x.relIndex !== "number" || x.relIndex < 0 || Math.floor(x.relIndex) !== x.relIndex) {
-            console.error(invalidItemKeyType, p);
-            return false;
-        }
+  if (!p.items?.length) return true;
+  const items = p.items;
+  for (let i = items.length - 1; i >= 0; i--) {
+    const x = items[i];
+    if (typeof x.relIndex !== "number" || x.relIndex < 0 || Math.floor(x.relIndex) !== x.relIndex) {
+      console.error(invalidItemKeyType, p);
+      return false;
     }
-    return true;
+  }
+  return true;
 }

package/dist/row-data-source-server/async-tree/check-set-action-item-keys-fit.d.ts

@@ -1,2 +1,5 @@
 import type { SetDataAction, TreeParent, TreeRoot } from "./+types.async-tree.js";
-export declare function checkSetActionItemKeysFit<K, D>(p: SetDataAction<K, D>, pathNode: TreeParent<K, D> | TreeRoot<K, D>): boolean;
+export declare function checkSetActionItemKeysFit<K, D>(
+  p: SetDataAction<K, D>,
+  pathNode: TreeParent<K, D> | TreeRoot<K, D>,
+): boolean;

package/dist/row-data-source-server/async-tree/check-set-action-item-keys-fit.js

@@ -1,18 +1,17 @@
 const invalidItemKeySize = "Invalid set action items, 'relIndex' must be less than parent size";
 export function checkSetActionItemKeysFit(p, pathNode) {
-    // If we are not adding any items, then the items definitely fit - since 0 fits in 0.
-    if (!p.items?.length)
-        return true;
-    // Grab the node size. The action may be updating the size, so we check for that first, otherwise
-    // we check if the current size.
-    const size = p.size ?? pathNode.size;
-    // We check the relative item indices. They should be within the size.
-    for (let i = p.items.length - 1; i >= 0; i--) {
-        const x = p.items[i];
-        if (x.relIndex >= size) {
-            console.error(invalidItemKeySize, p, pathNode);
-            return false;
-        }
+  // If we are not adding any items, then the items definitely fit - since 0 fits in 0.
+  if (!p.items?.length) return true;
+  // Grab the node size. The action may be updating the size, so we check for that first, otherwise
+  // we check if the current size.
+  const size = p.size ?? pathNode.size;
+  // We check the relative item indices. They should be within the size.
+  for (let i = p.items.length - 1; i >= 0; i--) {
+    const x = p.items[i];
+    if (x.relIndex >= size) {
+      console.error(invalidItemKeySize, p, pathNode);
+      return false;
     }
-    return true;
+  }
+  return true;
 }

package/dist/row-data-source-server/async-tree/check-set-action-item-kinds.js

@@ -1,14 +1,13 @@
 const invalidItemKind = "Invalid set action items, 'kind' must be 'leaf' or 'parent'";
 export function checkSetActionItemKinds(p) {
-    if (!p.items?.length)
-        return true;
-    const items = p.items;
-    for (let i = items.length - 1; i >= 0; i--) {
-        const x = items[i];
-        if (x.kind !== "leaf" && x.kind !== "parent") {
-            console.error(invalidItemKind, p);
-            return false;
-        }
+  if (!p.items?.length) return true;
+  const items = p.items;
+  for (let i = items.length - 1; i >= 0; i--) {
+    const x = items[i];
+    if (x.kind !== "leaf" && x.kind !== "parent") {
+      console.error(invalidItemKind, p);
+      return false;
     }
-    return true;
+  }
+  return true;
 }

package/dist/row-data-source-server/async-tree/get-parent-node-by-path.d.ts

@@ -1,2 +1,5 @@
 import type { TreeParent, TreeRoot } from "./+types.async-tree.js";
-export declare function getParentNodeByPath<K, D>(tree: TreeRoot<K, D>, path: (string | null)[]): TreeRoot<K, D> | TreeParent<K, D> | null;
+export declare function getParentNodeByPath<K, D>(
+  tree: TreeRoot<K, D>,
+  path: (string | null)[],
+): TreeRoot<K, D> | TreeParent<K, D> | null;

package/dist/row-data-source-server/async-tree/get-parent-node-by-path.js

@@ -1,18 +1,18 @@
 const invalidPathRoute = "Invalid path specified. Paths must be built up incrementally.";
 const invalidPathChild = "Invalid path specified. Leaf nodes can have children.";
 export function getParentNodeByPath(tree, path) {
-    let target = tree;
-    for (let i = 0; i < path.length; i++) {
-        const next = target.byPath.get(path[i]);
-        if (!next) {
-            console.error(invalidPathRoute, path.slice(0, i));
-            return null;
-        }
-        if (next.kind === "leaf") {
-            console.error(invalidPathChild, path.slice(0, i));
-            return null;
-        }
-        target = next;
+  let target = tree;
+  for (let i = 0; i < path.length; i++) {
+    const next = target.byPath.get(path[i]);
+    if (!next) {
+      console.error(invalidPathRoute, path.slice(0, i));
+      return null;
     }
-    return target;
+    if (next.kind === "leaf") {
+      console.error(invalidPathChild, path.slice(0, i));
+      return null;
+    }
+    target = next;
+  }
+  return target;
 }

package/dist/row-data-source-server/async-tree/is-set-action-a-no-op-on-node.d.ts

@@ -1,2 +1,5 @@
 import type { SetDataAction, TreeParent, TreeRoot } from "./+types.async-tree.js";
-export declare function isSetActionANoOpOnNode<K, D>(p: SetDataAction<K, D>, pathNode: TreeParent<K, D> | TreeRoot<K, D>): boolean;
+export declare function isSetActionANoOpOnNode<K, D>(
+  p: SetDataAction<K, D>,
+  pathNode: TreeParent<K, D> | TreeRoot<K, D>,
+): boolean;

package/dist/row-data-source-server/async-tree/is-set-action-a-no-op-on-node.js

@@ -1,3 +1,3 @@
 export function isSetActionANoOpOnNode(p, pathNode) {
-    return p.size === pathNode.size && !p.items?.length;
+  return p.size === pathNode.size && !p.items?.length;
 }

package/dist/row-data-source-server/async-tree/make-async-tree.js

@@ -2,18 +2,18 @@ import { applyDeleteActionToTree } from "./apply-delete-action-to-tree.js";
 import { applySetActionToTree } from "./apply-set-action-to-tree.js";
 import { getParentNodeByPath } from "./get-parent-node-by-path.js";
 export function makeAsyncTree() {
-    const tree = {
-        kind: "root",
-        byIndex: new Map(),
-        byPath: new Map(),
-        size: 0,
-        asOf: Date.now(),
-    };
-    const api = {
-        set: (p) => applySetActionToTree(p, tree),
-        delete: (p) => applyDeleteActionToTree(p, tree),
-        get: (p) => getParentNodeByPath(tree, p.path),
-    };
-    Object.assign(tree, api);
-    return tree;
+  const tree = {
+    kind: "root",
+    byIndex: new Map(),
+    byPath: new Map(),
+    size: 0,
+    asOf: Date.now(),
+  };
+  const api = {
+    set: (p) => applySetActionToTree(p, tree),
+    delete: (p) => applyDeleteActionToTree(p, tree),
+    get: (p) => getParentNodeByPath(tree, p.path),
+  };
+  Object.assign(tree, api);
+  return tree;
 }

package/dist/row-data-source-server/async-tree/maybe-apply-parent-remove-self.d.ts

@@ -1,2 +1,4 @@
 import type { TreeParent, TreeRoot } from "./+types.async-tree.js";
-export declare function maybeApplyParentRemoveSelf<K, D>(pathNode: TreeParent<K, D> | TreeRoot<K, D>): boolean;
+export declare function maybeApplyParentRemoveSelf<K, D>(
+  pathNode: TreeParent<K, D> | TreeRoot<K, D>,
+): boolean;

package/dist/row-data-source-server/async-tree/maybe-apply-parent-remove-self.js

@@ -1,8 +1,8 @@
 export function maybeApplyParentRemoveSelf(pathNode) {
-    if (!pathNode.size && pathNode.kind === "parent") {
-        pathNode.parent.byPath.delete(pathNode.path);
-        pathNode.parent.byIndex.delete(pathNode.relIndex);
-        return true;
-    }
-    return false;
+  if (!pathNode.size && pathNode.kind === "parent") {
+    pathNode.parent.byPath.delete(pathNode.path);
+    pathNode.parent.byIndex.delete(pathNode.relIndex);
+    return true;
+  }
+  return false;
 }

package/dist/row-data-source-server/async-tree/maybe-apply-resize.d.ts

@@ -1,2 +1,6 @@
 import type { TreeParent, TreeRoot } from "./+types.async-tree.js";
-export declare function maybeApplyResize<K, D>(pathNode: TreeParent<K, D> | TreeRoot<K, D>, size: number | undefined, asOf: number): boolean;
+export declare function maybeApplyResize<K, D>(
+  pathNode: TreeParent<K, D> | TreeRoot<K, D>,
+  size: number | undefined,
+  asOf: number,
+): boolean;

package/dist/row-data-source-server/async-tree/maybe-apply-resize.js

@@ -1,17 +1,14 @@
 export function maybeApplyResize(pathNode, size, asOf) {
-    if (size == null)
-        return false;
-    if (size === pathNode.size)
-        return false;
-    if (pathNode.asOf > asOf)
-        return false;
-    pathNode.size = size;
-    // Remove those nodes that are no long within the allowed size
-    for (const [number, node] of pathNode.byIndex) {
-        if (number >= size) {
-            pathNode.byIndex.delete(number);
-            pathNode.byPath.delete(node.path);
-        }
+  if (size == null) return false;
+  if (size === pathNode.size) return false;
+  if (pathNode.asOf > asOf) return false;
+  pathNode.size = size;
+  // Remove those nodes that are no long within the allowed size
+  for (const [number, node] of pathNode.byIndex) {
+    if (number >= size) {
+      pathNode.byIndex.delete(number);
+      pathNode.byPath.delete(node.path);
     }
-    return true;
+  }
+  return true;
 }

package/dist/row-data-source-server/async-tree/maybe-apply-set-action-items.d.ts

@@ -1,2 +1,5 @@
 import type { SetDataAction, TreeParent, TreeRoot } from "./+types.async-tree.js";
-export declare function maybeApplySetActionItems<K, D>(p: SetDataAction<K, D>, pathNode: TreeParent<K, D> | TreeRoot<K, D>): boolean;
+export declare function maybeApplySetActionItems<K, D>(
+  p: SetDataAction<K, D>,
+  pathNode: TreeParent<K, D> | TreeRoot<K, D>,
+): boolean;

package/dist/row-data-source-server/async-tree/maybe-apply-set-action-items.js

@@ -1,51 +1,47 @@
 import { ROOT_LEAF_PREFIX } from "./+constants.async-tree.js";
 export function maybeApplySetActionItems(p, pathNode) {
-    if (!p.items?.length) {
-        return false;
+  if (!p.items?.length) {
+    return false;
+  }
+  const asOf = p.asOf ?? Date.now();
+  for (let i = 0; i < p.items.length; i++) {
+    const item = p.items[i];
+    const path =
+      item.kind === "leaf" ? `${p.path.at(-1) ?? ROOT_LEAF_PREFIX}#${item.relIndex}` : item.path;
+    const existingIndex = pathNode.byIndex.get(item.relIndex);
+    if (existingIndex) {
+      pathNode.byPath.delete(existingIndex.path);
+      pathNode.byIndex.delete(item.relIndex);
     }
-    const asOf = p.asOf ?? Date.now();
-    for (let i = 0; i < p.items.length; i++) {
-        const item = p.items[i];
-        const path = item.kind === "leaf" ? `${p.path.at(-1) ?? ROOT_LEAF_PREFIX}#${item.relIndex}` : item.path;
-        const existingIndex = pathNode.byIndex.get(item.relIndex);
-        if (existingIndex) {
-            pathNode.byPath.delete(existingIndex.path);
-            pathNode.byIndex.delete(item.relIndex);
-        }
-        const existing = pathNode.byPath.get(path);
-        if (existing) {
-            pathNode.byPath.delete(existing.path);
-            pathNode.byIndex.delete(existing.relIndex);
-        }
-        // We always replace when making a leaf
-        if (item.kind === "leaf") {
-            const node = { ...item, parent: pathNode, path: path, asOf };
-            const currentI = pathNode.byIndex.get(item.relIndex);
-            const currentP = pathNode.byPath.get(path);
-            if (!currentI || currentI.asOf < asOf)
-                pathNode.byIndex.set(item.relIndex, node);
-            if (!currentP || currentP.asOf < asOf)
-                pathNode.byPath.set(path, node);
-        }
-        else {
-            const node = {
-                byIndex: existing?.kind === "parent" ? existing.byIndex : new Map(),
-                byPath: existing?.kind === "parent" ? existing.byPath : new Map(),
-                data: item.data,
-                kind: "parent",
-                relIndex: item.relIndex,
-                parent: pathNode,
-                path,
-                size: item.size,
-                asOf,
-            };
-            const currentI = pathNode.byIndex.get(item.relIndex);
-            const currentP = pathNode.byPath.get(path);
-            if (!currentI || currentI.asOf < asOf)
-                pathNode.byIndex.set(item.relIndex, node);
-            if (!currentP || currentP.asOf < asOf)
-                pathNode.byPath.set(path, node);
-        }
+    const existing = pathNode.byPath.get(path);
+    if (existing) {
+      pathNode.byPath.delete(existing.path);
+      pathNode.byIndex.delete(existing.relIndex);
     }
-    return true;
+    // We always replace when making a leaf
+    if (item.kind === "leaf") {
+      const node = { ...item, parent: pathNode, path: path, asOf };
+      const currentI = pathNode.byIndex.get(item.relIndex);
+      const currentP = pathNode.byPath.get(path);
+      if (!currentI || currentI.asOf < asOf) pathNode.byIndex.set(item.relIndex, node);
+      if (!currentP || currentP.asOf < asOf) pathNode.byPath.set(path, node);
+    } else {
+      const node = {
+        byIndex: existing?.kind === "parent" ? existing.byIndex : new Map(),
+        byPath: existing?.kind === "parent" ? existing.byPath : new Map(),
+        data: item.data,
+        kind: "parent",
+        relIndex: item.relIndex,
+        parent: pathNode,
+        path,
+        size: item.size,
+        asOf,
+      };
+      const currentI = pathNode.byIndex.get(item.relIndex);
+      const currentP = pathNode.byPath.get(path);
+      if (!currentI || currentI.asOf < asOf) pathNode.byIndex.set(item.relIndex, node);
+      if (!currentP || currentP.asOf < asOf) pathNode.byPath.set(path, node);
+    }
+  }
+  return true;
 }