@rljson/db 0.0.7 → 0.0.8

package/dist/db.js

@@ -1,14 +1,16 @@
-import { equals, merge } from "@rljson/json";
-import { timeId, createInsertHistoryTableCfg, Validate, BaseValidator, Route, validateInsert, isTimeId } from "@rljson/rljson";
-import { traverse } from "object-traversal";
 import { rmhsh, hsh, Hash, hip } from "@rljson/hash";
+import { equals, merge } from "@rljson/json";
+import { timeId, createInsertHistoryTableCfg, Validate, BaseValidator, Route, isTimeId } from "@rljson/rljson";
 import { IoMem } from "@rljson/io";
+import { traverse } from "object-traversal";
 import { compileExpression } from "filtrex";
 class BaseController {
   constructor(_core, _tableKey) {
     this._core = _core;
     this._tableKey = _tableKey;
   }
+  _contentType;
+  _tableCfg;
   // ...........................................................................
   /**
    * Retrieves the current state of the table.
@@ -67,6 +69,28 @@ class BaseController {
     });
     return rows;
   }
+  // ...........................................................................
+  /**
+   * Gets the content type of the controller.
+   * @returns The content type managed by the controller.
+   */
+  /* v8 ignore next -- @preserve */
+  contentType() {
+    return this._contentType ?? "components";
+  }
+  // ...........................................................................
+  /**
+   * Gets the table configuration of the controller.
+   * @returns The table configuration managed by the controller.
+   */
+  tableCfg() {
+    if (!this._tableCfg) {
+      throw new Error(
+        `TableCfg for controller ${this._tableKey} is not initialized.`
+      );
+    }
+    return this._tableCfg;
+  }
 }
 class CakeController extends BaseController {
   constructor(_core, _tableKey, _refs) {
@@ -74,6 +98,7 @@ class CakeController extends BaseController {
     this._core = _core;
     this._tableKey = _tableKey;
     this._refs = _refs;
+    this._contentType = "cakes";
   }
   _table = null;
   _baseLayers = {};
@@ -88,7 +113,8 @@ class CakeController extends BaseController {
     if (this._table._type !== "cakes") {
       throw new Error(`Table ${this._tableKey} is not of type cakes.`);
     }
-    if (this._refs && this._refs.base && this._refs.base.length > 0) {
+    this._tableCfg = await this._core.tableCfg(this._tableKey);
+    if (this._refs && this._refs.base && this._refs.base !== void 0 && this._refs.base.length > 0) {
       const {
         [this._tableKey]: { _data: baseCakes }
       } = await this._core.readRow(this._tableKey, this._refs.base);
@@ -99,11 +125,13 @@ class CakeController extends BaseController {
       this._baseLayers = rmhsh(baseCake.layers);
     } else {
       const cake = this._table._data[0];
-      this._refs = {
-        sliceIdsTable: cake.sliceIdsTable,
-        sliceIdsRow: cake.sliceIdsRow
-      };
-      this._baseLayers = rmhsh(cake.layers);
+      if (!!cake) {
+        this._refs = {
+          sliceIdsTable: cake.sliceIdsTable,
+          sliceIdsRow: cake.sliceIdsRow
+        };
+        this._baseLayers = rmhsh(cake.layers);
+      }
     }
   }
   async getChildRefs(where, filter) {
@@ -131,7 +159,7 @@ class CakeController extends BaseController {
     if (this._refs?.base) delete this._refs.base;
     const normalizedValue = {};
     for (const [layerTable, layerRef] of Object.entries(
-      value
+      value.layers
     )) {
       if (Array.isArray(layerRef) && layerRef.length > 1) {
         throw new Error(
@@ -141,6 +169,7 @@ class CakeController extends BaseController {
       normalizedValue[layerTable] = Array.isArray(layerRef) ? layerRef[0] : layerRef;
     }
     const cake = {
+      ...value,
       layers: { ...this._baseLayers, ...normalizedValue },
       ...refs || this._refs
     };
@@ -166,7 +195,7 @@ class CakeController extends BaseController {
       return Promise.resolve({});
     }
   }
-  filterRow(row, key, value) {
+  async filterRow(row, key, value) {
     const cake = row;
     for (const [layerKey, layerRef] of Object.entries(cake.layers)) {
       if (layerKey === key && layerRef === value) {
@@ -182,8 +211,14 @@ class ComponentController extends BaseController {
     this._core = _core;
     this._tableKey = _tableKey;
     this._refs = _refs;
+    this._contentType = "components";
   }
-  _tableCfg = null;
+  _allowedContentTypes = [
+    "components",
+    "edits",
+    "editHistory",
+    "multiEdits"
+  ];
   _resolvedColumns = null;
   _refTableKeyToColumnKeyMap = null;
   async init() {
@@ -192,7 +227,7 @@ class ComponentController extends BaseController {
     }
     const rljson = await this._core.dumpTable(this._tableKey);
     const table = rljson[this._tableKey];
-    if (table._type !== "components") {
+    if (this._allowedContentTypes.indexOf(table._type) === -1) {
       throw new Error(`Table ${this._tableKey} is not of type components.`);
     }
     this._tableCfg = await this._core.tableCfg(this._tableKey);
@@ -210,38 +245,12 @@ class ComponentController extends BaseController {
     if (!!refs) {
       throw new Error(`Refs are not supported on ComponentController.`);
     }
-    const values = [];
-    const referencedValues = /* @__PURE__ */ new Map();
-    for (const [k, v] of Object.entries(value)) {
-      if (Array.isArray(v)) {
-        for (const possibleRef of v) {
-          if (typeof possibleRef === "object" && possibleRef.hasOwnProperty("_ref") && possibleRef.hasOwnProperty("_value")) {
-            const ref = possibleRef._ref;
-            const val = possibleRef._value;
-            if (!referencedValues.has(ref))
-              referencedValues.set(ref, { [k]: val });
-            else {
-              const existing = referencedValues.get(ref);
-              referencedValues.set(ref, { ...{ [k]: val }, ...existing });
-            }
-          }
-        }
-      }
-    }
-    if (referencedValues.size > 0) {
-      for (const refValue of referencedValues.values()) {
-        values.push({ ...value, ...refValue });
-      }
-    } else {
-      values.push(value);
-    }
-    const components = values;
-    const results = [];
-    for (const component of components) {
-      delete component._somethingToInsert;
-      const rlJson = { [this._tableKey]: { _data: [component] } };
-      await this._core.import(rlJson);
-      const result = {
+    const component = value;
+    delete component._somethingToInsert;
+    const rlJson = { [this._tableKey]: { _data: [component] } };
+    await this._core.import(rlJson);
+    return [
+      {
         //Ref to component
         [this._tableKey + "Ref"]: hsh(component)._hash,
         //Data from edit
@@ -249,10 +258,8 @@ class ComponentController extends BaseController {
         origin,
         //Unique id/timestamp
         timeId: timeId()
-      };
-      results.push(result);
-    }
-    return results;
+      }
+    ];
   }
   // ...........................................................................
   /**
@@ -287,6 +294,20 @@ class ComponentController extends BaseController {
                 columnKey: propertyKey,
                 ref: refItem
               });
+              continue;
+            }
+            if (typeof refItem === "object" && refItem !== null) {
+              const cakeReference = refItem;
+              childRefs.set(
+                `${childRefTableKey}|${propertyKey}|${cakeReference.ref}|${cakeReference.sliceIds?.join(",")}`,
+                {
+                  tableKey: childRefTableKey,
+                  columnKey: propertyKey,
+                  ref: cakeReference.ref,
+                  sliceIds: cakeReference.sliceIds
+                }
+              );
+              continue;
             }
           }
           continue;
@@ -319,7 +340,7 @@ class ComponentController extends BaseController {
         const column = Object.keys(refWhere)[0];
         const refValue = refWhere[column];
         for (const row of tableData) {
-          if (this.filterRow(row, column, refValue)) {
+          if (await this.filterRow(row, column, refValue)) {
             consolidatedRows.set(row._hash, row);
           }
         }
@@ -518,7 +539,7 @@ class ComponentController extends BaseController {
       return this._core.readRows(table, where);
     }
   }
-  filterRow(row, key, value) {
+  async filterRow(row, key, value) {
     for (const [propertyKey, propertyValue] of Object.entries(row)) {
       if (propertyKey === key && equals(propertyValue, value)) {
         return true;
@@ -533,12 +554,131 @@ class ComponentController extends BaseController {
     return false;
   }
 }
+class SliceIdController extends BaseController {
+  constructor(_core, _tableKey, _refs) {
+    super(_core, _tableKey);
+    this._core = _core;
+    this._tableKey = _tableKey;
+    this._refs = _refs;
+    this._contentType = "sliceIds";
+  }
+  async init() {
+    if (this._tableKey.endsWith("SliceId") === false) {
+      throw new Error(
+        `Table ${this._tableKey} is not supported by SliceIdController.`
+      );
+    }
+    const rljson = await this._core.dumpTable(this._tableKey);
+    const table = rljson[this._tableKey];
+    if (table._type !== "sliceIds") {
+      throw new Error(`Table ${this._tableKey} is not of type sliceIds.`);
+    }
+    this._tableCfg = await this._core.tableCfg(this._tableKey);
+    if (this._refs && this._refs.base) {
+      const {
+        [this._tableKey]: { _data: SliceIds2 }
+      } = await this._core.readRow(this._tableKey, this._refs.base);
+      if (SliceIds2.length === 0) {
+        throw new Error(`Base sliceId ${this._refs.base} does not exist.`);
+      }
+    } else {
+      const sliceId = table._data[0];
+      if (!!sliceId) {
+        this._refs = {
+          base: sliceId.base
+        };
+      }
+    }
+  }
+  async insert(command, value, origin, refs) {
+    if (!command.startsWith("add") && !command.startsWith("remove")) {
+      throw new Error(
+        `Command ${command} is not supported by SliceIdController.`
+      );
+    }
+    const sliceIds = command.startsWith("add") === true ? {
+      add: value,
+      ...refs || this._refs
+    } : {
+      add: [],
+      remove: value,
+      ...refs || this._refs
+    };
+    const rlJson = { [this._tableKey]: { _data: [sliceIds] } };
+    await this._core.import(rlJson);
+    const result = {
+      //Ref to component
+      [this._tableKey + "Ref"]: hsh(sliceIds)._hash,
+      //Data from edit
+      route: "",
+      origin,
+      //Unique id/timestamp
+      timeId: timeId()
+    };
+    return [result];
+  }
+  async get(where, filter) {
+    if (typeof where === "string") {
+      return this._getByHash(where, filter);
+    } else {
+      return this._getByWhere(where, filter);
+    }
+  }
+  async resolveBaseSliceIds(sliceIds) {
+    const add = /* @__PURE__ */ new Set();
+    const remove = /* @__PURE__ */ new Set();
+    if (!!sliceIds.base) {
+      const baseSliceIds = await this.get(sliceIds.base);
+      if (!baseSliceIds[this._tableKey]?._data?.[0]) {
+        throw new Error(`Base sliceIds ${sliceIds.base} does not exist.`);
+      }
+      if (baseSliceIds[this._tableKey]._data.length > 1) {
+        throw new Error(
+          `Base sliceIds ${sliceIds.base} has more than one entry.`
+        );
+      }
+      const baseSliceId = baseSliceIds[this._tableKey]._data[0];
+      const resolvedBaseSliceIds = await this.resolveBaseSliceIds(baseSliceId);
+      for (const sliceId of resolvedBaseSliceIds.add) {
+        add.add(sliceId);
+      }
+    }
+    for (const sliceId of sliceIds.add) {
+      add.add(sliceId);
+    }
+    if (!!sliceIds.remove)
+      for (const sliceId of sliceIds.remove) {
+        remove.add(sliceId);
+      }
+    for (const sliceId of remove.values()) {
+      if (add.has(sliceId)) {
+        add.delete(sliceId);
+      }
+    }
+    return { add: Array.from(add) };
+  }
+  /* v8 ignore next -- @preserve */
+  async getChildRefs() {
+    return [];
+  }
+  async filterRow(row, _, value) {
+    const sliceIds = row;
+    const sliceId = value;
+    for (const sId of Object.values(sliceIds.add)) {
+      if (sliceId === sId) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
 class LayerController extends BaseController {
   constructor(_core, _tableKey, _refs) {
     super(_core, _tableKey);
     this._core = _core;
     this._tableKey = _tableKey;
     this._refs = _refs;
+    this._contentType = "layers";
   }
   async init() {
     if (this._tableKey.endsWith("Layer") === false) {
@@ -551,6 +691,7 @@ class LayerController extends BaseController {
     if (table._type !== "layers") {
       throw new Error(`Table ${this._tableKey} is not of type layers.`);
     }
+    this._tableCfg = await this._core.tableCfg(this._tableKey);
     if (this._refs && this._refs.base) {
       const {
         [this._tableKey]: { _data: baseLayers }
@@ -568,11 +709,13 @@ class LayerController extends BaseController {
       }
     } else {
       const layer = table._data[0];
-      this._refs = {
-        sliceIdsTable: layer.sliceIdsTable,
-        sliceIdsTableRow: layer.sliceIdsTableRow,
-        componentsTable: layer.componentsTable
-      };
+      if (!!layer) {
+        this._refs = {
+          sliceIdsTable: layer.sliceIdsTable,
+          sliceIdsTableRow: layer.sliceIdsTableRow,
+          componentsTable: layer.componentsTable
+        };
+      }
     }
   }
   async insert(command, value, origin, refs) {
@@ -581,10 +724,9 @@ class LayerController extends BaseController {
         `Command ${command} is not supported by LayerController.`
       );
     }
+    const isAdd = command.startsWith("add");
     const normalizedValue = {};
-    for (const [sliceId, compRef] of Object.entries(
-      value
-    )) {
+    for (const [sliceId, compRef] of isAdd ? Object.entries(value.add) : Object.entries(value.remove)) {
       if (Array.isArray(compRef) && compRef.length > 1) {
         throw new Error(
           `LayerController insert: Component ref for slice ${sliceId} cannot be an array of size > 1. No 1:n relations supported.`
@@ -592,13 +734,20 @@ class LayerController extends BaseController {
       }
       normalizedValue[sliceId] = Array.isArray(compRef) ? compRef[0] : compRef;
     }
-    const layer = command.startsWith("add") === true ? {
-      add: normalizedValue,
-      ...refs || this._refs
+    const layer = isAdd ? {
+      ...value,
+      ...{
+        add: normalizedValue,
+        remove: {}
+      },
+      ...refs
     } : {
-      add: {},
-      remove: normalizedValue,
-      ...refs || this._refs
+      ...value,
+      ...{
+        remove: normalizedValue,
+        add: {}
+      },
+      ...refs
     };
     const rlJson = { [this._tableKey]: { _data: [layer] } };
     await this._core.import(rlJson);
@@ -620,25 +769,108 @@ class LayerController extends BaseController {
       return this._getByWhere(where, filter);
     }
   }
+  async resolveBaseLayer(layer) {
+    const add = /* @__PURE__ */ new Map();
+    const sliceIds = /* @__PURE__ */ new Set();
+    if (!!layer.base) {
+      const baseLayer = await this.get(layer.base);
+      if (!baseLayer[this._tableKey]?._data?.[0]) {
+        throw new Error(`Base layer ${layer.base} does not exist.`);
+      }
+      if (baseLayer[this._tableKey]._data.length > 1) {
+        throw new Error(
+          `Base layer ${layer.base} resolving not possible. Not unique.`
+        );
+      }
+      const baseLayerData = rmhsh(baseLayer[this._tableKey]._data[0]);
+      const baseLayerResolved = await this.resolveBaseLayer(baseLayerData);
+      for (const [sliceId, compRef] of Object.entries(baseLayerResolved.add)) {
+        if (sliceId.startsWith("_")) continue;
+        add.set(sliceId, compRef);
+      }
+      for (const sliceId of baseLayerResolved.sliceIds) {
+        sliceIds.add(sliceId);
+      }
+      const baseLayerSliceIdsTable = baseLayerData.sliceIdsTable;
+      const baseLayerSliceIdsRow = baseLayerData.sliceIdsTableRow;
+      const {
+        [baseLayerSliceIdsTable]: { _data: baseLayerSliceIds }
+      } = await this._core.readRow(
+        baseLayerSliceIdsTable,
+        baseLayerSliceIdsRow
+      );
+      for (const sIds of baseLayerSliceIds) {
+        const sliceIdController = new SliceIdController(
+          this._core,
+          baseLayerSliceIdsTable
+        );
+        const resolvedSliceIds = await sliceIdController.resolveBaseSliceIds(
+          sIds
+        );
+        for (const sId of resolvedSliceIds.add) {
+          if (sId.startsWith("_")) continue;
+          sliceIds.add(sId);
+        }
+      }
+    }
+    const {
+      [layer.sliceIdsTable]: { _data: layerSliceIds }
+    } = await this._core.readRow(layer.sliceIdsTable, layer.sliceIdsTableRow);
+    if (!layerSliceIds || layerSliceIds.length === 0) {
+      throw new Error(
+        `Layer sliceIds ${layer.sliceIdsTableRow} does not exist.`
+      );
+    }
+    if (layerSliceIds.length > 1) {
+      throw new Error(
+        `Layer sliceIds ${layer.sliceIdsTableRow} has more than one entry.`
+      );
+    }
+    const layerSliceId = layerSliceIds[0];
+    for (const sId of layerSliceId.add) {
+      if (sId.startsWith("_")) continue;
+      sliceIds.add(sId);
+    }
+    if (!!layerSliceId.remove)
+      for (const sId of Object.keys(layerSliceId.remove)) {
+        if (sliceIds.has(sId)) {
+          sliceIds.delete(sId);
+        }
+      }
+    for (const [sliceId, compRef] of Object.entries(layer.add)) {
+      if (sliceId.startsWith("_")) continue;
+      add.set(sliceId, compRef);
+    }
+    if (!!layer.remove)
+      for (const sliceId of Object.keys(layer.remove)) {
+        if (add.has(sliceId)) {
+          add.delete(sliceId);
+        }
+      }
+    return { add: Object.fromEntries(add), sliceIds: Array.from(sliceIds) };
+  }
   async getChildRefs(where, filter) {
     const { [this._tableKey]: table } = await this.get(where, filter);
     const childRefs = [];
     for (const row of table._data) {
       const layer = row;
-      for (const [sliceId, compRef] of Object.entries(layer.add)) {
+      const resolvedLayer = await this.resolveBaseLayer(layer);
+      for (const [sliceId, ref] of Object.entries(resolvedLayer.add)) {
         if (sliceId.startsWith("_")) continue;
         childRefs.push({
           tableKey: layer.componentsTable,
-          ref: compRef
+          ref,
+          sliceIds: [sliceId]
         });
       }
     }
     return childRefs;
   }
-  filterRow(row, _, value) {
+  async filterRow(row, _, value) {
     const layer = row;
     const compRef = value;
-    for (const componentRef of Object.values(layer.add)) {
+    const resolvedLayer = await this.resolveBaseLayer(layer);
+    for (const componentRef of Object.values(resolvedLayer.add)) {
       if (componentRef === compRef) {
         return true;
       }
@@ -653,11 +885,21 @@ const createController = async (type, core, tableKey, refs) => {
       ctrl = new LayerController(core, tableKey, refs);
       break;
     case "components":
+    case "edits":
+    case "editHistory":
+    case "multiEdits":
       ctrl = new ComponentController(core, tableKey, refs);
       break;
     case "cakes":
       ctrl = new CakeController(core, tableKey, refs);
       break;
+    case "sliceIds":
+      ctrl = new SliceIdController(
+        core,
+        tableKey,
+        refs
+      );
+      break;
     default:
       throw new Error(`Controller for type ${type} is not implemented yet.`);
   }
@@ -721,7 +963,7 @@ class Core {
     const validate = new Validate();
     validate.addValidator(new BaseValidator());
     const result = await validate.run(data);
-    if ((result.hasErrors || result.base && result.base.hasErrors) && !result.base.refsNotFound) {
+    if ((result.hasErrors || result.base && result.base.hasErrors) && !result.base.refsNotFound && !result.base.layerBasesNotFound) {
       throw new Error(
         "The imported rljson data is not valid:\n" + JSON.stringify(result, null, 2)
       );
@@ -767,6 +1009,152 @@ class Core {
     return this._io.readRows({ table, where });
   }
 }
+const inject = (tree, path, value) => {
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (i === path.length - 1) {
+      tree[segment] = value;
+      delete tree["_hash"];
+    } else {
+      if (!tree[segment]) {
+        tree[segment] = {};
+      }
+      tree = tree[segment];
+    }
+  }
+};
+const isolate = (tree, path, preservedKeys = []) => {
+  if (path.length === 0) {
+    return Array.isArray(tree) ? [] : {};
+  }
+  if (tree == null) {
+    return null;
+  }
+  const [currentKey, ...remainingPath] = path;
+  const result = Array.isArray(tree) ? [] : {};
+  if (!Array.isArray(tree)) {
+    for (const key in tree) {
+      if (typeof key === "string" && key.startsWith("_") || preservedKeys.includes(key)) {
+        result[key] = tree[key];
+      }
+    }
+  }
+  if (!(currentKey in tree)) {
+    return result;
+  }
+  const currentValue = tree[currentKey];
+  if (remainingPath.length === 0) {
+    if (Array.isArray(result)) {
+      result[currentKey] = currentValue;
+    } else {
+      result[currentKey] = currentValue;
+    }
+  } else {
+    const isolatedChild = isolate(currentValue, remainingPath, preservedKeys);
+    const hasContent = Array.isArray(isolatedChild) ? isolatedChild.length > 0 : Object.keys(isolatedChild).length > 0;
+    if (hasContent || isolatedChild === null) {
+      if (Array.isArray(result)) {
+        result[currentKey] = isolatedChild;
+      } else {
+        result[currentKey] = isolatedChild;
+      }
+    }
+  }
+  return result;
+};
+const mergeTrees = (trees) => {
+  if (!trees || trees.length === 0) {
+    return {};
+  }
+  let result = {};
+  for (const { tree } of trees) {
+    if (tree != null) {
+      result = mergeStructures(result, tree);
+    }
+  }
+  const pathValues = [];
+  for (const { tree, path } of trees) {
+    if (tree == null) continue;
+    let current = tree;
+    let pathExists = true;
+    for (const key of path) {
+      if (current == null || !(key in current)) {
+        pathExists = false;
+        break;
+      }
+      current = current[key];
+    }
+    if (pathExists && current != null) {
+      pathValues.push({ path, value: current });
+    }
+  }
+  const pathGroups = /* @__PURE__ */ new Map();
+  for (const { path, value } of pathValues) {
+    const pathKey = JSON.stringify(path);
+    if (!pathGroups.has(pathKey)) {
+      pathGroups.set(pathKey, []);
+    }
+    pathGroups.get(pathKey).push(value);
+  }
+  for (const [pathKey, values] of pathGroups) {
+    const path = JSON.parse(pathKey);
+    let mergedValue = void 0;
+    for (const value of values) {
+      if (value == null) continue;
+      if (mergedValue === void 0) {
+        mergedValue = value;
+        continue;
+      }
+      if (Array.isArray(mergedValue) && Array.isArray(value)) {
+        mergedValue = [...mergedValue, ...value];
+      } else if (!Array.isArray(mergedValue) && !Array.isArray(value)) {
+        mergedValue = {
+          ...mergedValue,
+          ...value
+        };
+      }
+    }
+    let current = result;
+    for (let i = 0; i < path.length - 1; i++) {
+      const key = path[i];
+      if (current == null || !(key in current)) {
+        current[key] = typeof path[i + 1] === "number" ? [] : {};
+      }
+      current = current[key];
+    }
+    if (path.length > 0) {
+      current[path[path.length - 1]] = mergedValue;
+    }
+  }
+  return result;
+};
+function mergeStructures(target, source) {
+  if (source == null) return target;
+  if (target == null) return source;
+  if (Array.isArray(target) && Array.isArray(source)) {
+    const result = [...target];
+    for (let i = 0; i < source.length; i++) {
+      if (result[i] === void 0) {
+        result[i] = source[i];
+      } else {
+        result[i] = mergeStructures(result[i], source[i]);
+      }
+    }
+    return result;
+  }
+  if (typeof target === "object" && typeof source === "object" && !Array.isArray(target) && !Array.isArray(source) && target !== null && source !== null) {
+    const result = { ...target };
+    for (const key in source) {
+      if (key in result) {
+        result[key] = mergeStructures(result[key], source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    }
+    return result;
+  }
+  return source;
+}
 class ColumnSelection {
   constructor(columns) {
     this._throwOnWrongAlias(columns);
@@ -1113,6 +1501,19 @@ class ColumnSelection {
       }
     ]);
   }
+  static exampleCarsDeeplyNestedColumnSelection() {
+    return new ColumnSelection([
+      {
+        key: "brand",
+        route: "catalogCake/catalogSeriesLayer/catalogSeries/seriesCake/seriesCarsLayer/seriesCars/carCake/carGeneralLayer/carGeneral/brand",
+        alias: "brand",
+        titleLong: "Car Brand",
+        titleShort: "Brand",
+        type: "string",
+        _hash: ""
+      }
+    ]);
+  }
   static exampleCarsColumnSelectionOnlySomeColumns() {
     return new ColumnSelection([
       {
@@ -1638,23 +2039,8 @@ class RowFilterProcessor {
       return remainingIndices;
     }
     for (const i of remainingIndices) {
-      const cellValue = join.value(i, columnIndex);
-      if (Array.isArray(cellValue)) {
-        for (const v of cellValue) {
-          if (typeof v === "object" && v !== null && v.hasOwnProperty("_value")) {
-            const matchValue = v._value;
-            if (filter.matches(matchValue)) {
-              result.push(i);
-              break;
-            }
-          } else {
-            if (filter.matches(v)) {
-              result.push(i);
-              break;
-            }
-          }
-        }
-      } else {
+      const cellValues = join.value(i, columnIndex);
+      for (const cellValue of cellValues) {
         if (filter.matches(cellValue)) {
           result.push(i);
         }
@@ -1695,9 +2081,11 @@ class RowFilterProcessor {
       if (applyTo[r]) {
         continue;
       }
-      const cellValue = join.value(r, columnIndex);
-      if (filter.matches(cellValue)) {
-        applyTo[r] = true;
+      const cellValues = join.value(r, columnIndex);
+      for (const cellValue of cellValues) {
+        if (filter.matches(cellValue)) {
+          applyTo[r] = true;
+        }
       }
     }
   }
@@ -1717,14 +2105,22 @@ ${availableRoutes.map((a) => `- ${a}`).join("\n")}`
     }
   }
 }
+const joinPreserveKeys = [
+  "sliceIdsTable",
+  "sliceIdsRow",
+  /*'base',*/
+  "sliceIdsTable",
+  "sliceIdsTableRow",
+  "componentsTable"
+];
 class Join {
-  constructor(baseRows, _baseColumnSelection, _objectMap) {
-    this._baseColumnSelection = _baseColumnSelection;
-    this._objectMap = _objectMap;
-    this._base = this._hashedRows(baseRows);
-  }
   _base = {};
+  _baseColumnSelection;
   _processes = [];
+  constructor(rows, columnSelection) {
+    this._base = this._hashedRows(rows);
+    this._baseColumnSelection = columnSelection;
+  }
   // ...........................................................................
   /**
    * Applies a filter to the join and returns the filtered view
@@ -1753,14 +2149,62 @@ class Join {
     const data = {};
     for (const [sliceId, joinRowH] of Object.entries(this.data)) {
       const cols = [...joinRowH.columns];
+      const insertCols = [];
       for (const col of cols) {
-        if (Route.fromFlat(setValue.route).equalsWithoutRefs(col.route))
-          col.insert = setValue.value;
-        else continue;
+        const insertCol = {
+          ...col
+          //inserts: col.inserts ? [...col.inserts] : [],
+        };
+        if (Route.fromFlat(setValue.route).equalsWithoutRefs(col.route)) {
+          for (const cell of col.value.cell) {
+            if (cell.path.length === 0) {
+              throw new Error(
+                `Join: Error while applying SetValue: Cannot set value for column without paths. Route: ${setValue.route.toString()}.`
+              );
+            }
+            if (cell.path.length > 1) {
+              throw new Error(
+                `Join: Error while applying SetValue: Cannot set value for multiple paths in one cell. Found paths: [${cell.path.join(", ")}] for route: ${setValue.route.toString()}.`
+              );
+            }
+            const cellInsertTree = isolate(
+              { ...col.value.tree },
+              cell.path[0],
+              joinPreserveKeys
+            );
+            inject(cellInsertTree, cell.path[0], setValue.value);
+            const propertyKey = cell.path[0].slice(-1)[0];
+            const insert = {
+              cell: [
+                {
+                  ...cell,
+                  ...{ value: setValue.value },
+                  ...{
+                    row: {
+                      ...cell.row,
+                      ...{ [propertyKey]: setValue.value }
+                    }
+                  }
+                }
+              ],
+              tree: cellInsertTree,
+              rljson: col.value.rljson
+            };
+            if (insert) {
+              if (insertCol.inserts) insertCol.inserts.push(insert);
+              else insertCol.inserts = [insert];
+            }
+          }
+        }
+        insertCols.push(insertCol);
       }
       data[sliceId] = {
-        rowHash: Hash.default.calcHash(cols.map((c) => c.value)),
-        columns: cols
+        rowHash: Hash.default.calcHash(
+          insertCols.map(
+            (col) => col.value.cell.flatMap((c) => c.value)
+          )
+        ),
+        columns: insertCols
       };
     }
     const process = {
@@ -1803,15 +2247,15 @@ class Join {
     const data = {};
     for (let i2 = 0; i2 < this.rowCount; i2++) {
       const [sliceId, row] = Object.entries(this.data)[i2];
-      const selectedColumns = [];
+      const cols = [];
       for (let j = 0; j < masterColumnIndices.length; j++) {
-        selectedColumns.push(row.columns[masterColumnIndices[j]]);
+        cols.push(row.columns[masterColumnIndices[j]]);
       }
       data[sliceId] = {
         rowHash: Hash.default.calcHash(
-          selectedColumns.map((c) => c.value)
+          cols.map((col) => col.value.cell.flatMap((c) => c.value))
         ),
-        columns: selectedColumns
+        columns: cols
       };
     }
     const process = {
@@ -1850,30 +2294,51 @@ class Join {
    * Returns insert Object of the join
    */
   insert() {
-    const cakeInserts = this._insertCakeObjects(this.data);
-    const cakeInsertsMergedOfLayerRoutes = /* @__PURE__ */ new Map();
-    for (const { [this.cakeRoute.root.tableKey]: cakeInsert } of cakeInserts) {
-      const cakeInsertRoute = cakeInsert.route.flat;
-      if (!cakeInsertsMergedOfLayerRoutes.has(cakeInsertRoute)) {
-        cakeInsertsMergedOfLayerRoutes.set(cakeInsertRoute, cakeInsert.value);
-      } else {
-        const existingValue = cakeInsertsMergedOfLayerRoutes.get(
-          cakeInsertRoute
+    const inserts = [];
+    for (let i = 0; i < this.columnCount; i++) {
+      const colInserts = [];
+      for (const row of Object.values(this.data)) {
+        const col = row.columns[i];
+        if (col.inserts && col.inserts.length > 0) {
+          for (const insert of col.inserts) {
+            for (const cell of insert.cell) {
+              const tree = insert.tree;
+              const path = cell.path;
+              inject(tree, path[0].slice(0, -1), cell.row);
+              colInserts.push({
+                route: col.route,
+                tree,
+                path: path[0]
+              });
+            }
+          }
+        }
+      }
+      if (colInserts.length === 0) continue;
+      const routes = colInserts.map((ins) => ins.route.flat);
+      const uniqueRoute = Array.from(new Set(routes));
+      if (uniqueRoute.length > 1) {
+        throw new Error(
+          `Join: Error while generating insert: Multiple different routes found in inserts: ${uniqueRoute.map((r) => r.toString()).join(", ")}. Cannot generate single insert object.`
         );
-        const mergedValue = merge(existingValue, cakeInsert.value);
-        cakeInsertsMergedOfLayerRoutes.set(cakeInsertRoute, mergedValue);
       }
+      const merged = mergeTrees(
+        colInserts.map((ins) => ({
+          tree: ins.tree,
+          path: ins.path.slice(0, -1)
+        }))
+      );
+      traverse(merged, ({ parent, key, value }) => {
+        if (key == "_data" && Array.isArray(value) && value.length > 0) {
+          parent[key] = value.filter((v) => !!v);
+        }
+      });
+      inserts.push({
+        route: Route.fromFlat(uniqueRoute[0]).toRouteWithProperty(),
+        tree: merged
+      });
     }
-    const results = [];
-    for (const [route, value] of cakeInsertsMergedOfLayerRoutes) {
-      const insert = {
-        command: "add",
-        route,
-        value
-      };
-      results.push(insert);
-    }
-    return results;
+    return inserts;
   }
   // ...........................................................................
   /**
@@ -2020,7 +2485,11 @@ class Join {
           const dataColRoute = dataCol.route;
           return colInfoRoute.equalsWithoutRefs(dataColRoute);
         });
-        row.push(joinCol ? joinCol.insert ?? joinCol.value : null);
+        const insertValue = joinCol && joinCol.inserts ? joinCol.inserts.flatMap(
+          (con) => con.cell.flatMap((c) => c.value)
+        ) ?? null : null;
+        const baseValue = joinCol && joinCol.value.cell ? joinCol.value.cell.flatMap((c) => c.value) ?? null : null;
+        row.push(insertValue ?? baseValue);
       }
       result.push(row);
     }
@@ -2029,184 +2498,26 @@ class Join {
   static empty() {
     return new Join({}, ColumnSelection.empty());
   }
-  //#############################################################
-  // ############# Private Methods ##############################
-  //#############################################################
   // ...........................................................................
   /**
-   * Builds cake insert objects from the given join rows
-   * @param rows - The join rows
-   * @returns The cake insert objects
+   * Hashes the given join rows. If insert value is present, it is used for hashing.
+   *
+   * @param rows The join rows to hash
+   * @returns The hashed join rows
    */
-  _insertCakeObjects(rows) {
-    const cakeInsertObjects = [];
-    const cakeRoute = this.cakeRoute;
-    for (const [sliceId, row] of Object.entries(rows)) {
-      const layerInsertObjectList = this._insertLayerObjects(
-        sliceId,
-        row.columns
-      );
-      for (const layerInsertObject of layerInsertObjectList) {
-        const cakeInsertObject = {};
-        for (const [layerRoute, layerInsertObj] of Object.entries(
-          layerInsertObject
-        )) {
-          cakeInsertObject[cakeRoute.root.tableKey] = {
-            route: layerInsertObj.route,
-            value: {
-              [layerRoute]: layerInsertObj.value
-            }
-          };
-        }
-        cakeInsertObjects.push(cakeInsertObject);
-      }
-    }
-    return cakeInsertObjects;
-  }
-  // ...........................................................................
-  /**
-   * Wraps component insert objects into layer insert objects
-   * @param sliceId - The slice id
-   * @param componentInsertObjects - The component insert objects
-   * @returns
-   */
-  _insertLayerObjects(sliceId, insertRow) {
-    const layerRoutes = this.layerRoutes;
-    const layerInsertObjects = [];
-    const insertComponentObjects = this._insertComponentObjects(
-      sliceId,
-      insertRow
-    );
-    for (const layerRoute of layerRoutes) {
-      for (const [compRouteFlat, compInsertObj] of Object.entries(
-        insertComponentObjects
-      )) {
-        if (!compInsertObj._somethingToInsert) continue;
-        const compRoute = Route.fromFlat(compRouteFlat);
-        if (layerRoute.includes(compRoute)) {
-          const layerInsertObj = {};
-          layerInsertObj[layerRoute.root.tableKey] = {
-            route: Route.fromFlat(compRouteFlat),
-            value: {
-              [sliceId]: compInsertObj
-            }
-          };
-          layerInsertObjects.push(layerInsertObj);
-        } else {
-          continue;
-        }
-      }
-    }
-    return layerInsertObjects;
-  }
-  // ...........................................................................
-  /**
-   * Merges columns into component insert objects
-   * @param insertColumns - The columns to merge
-   * @returns
-   */
-  _insertComponentObjects(sliceId, insertColumns) {
-    const columns = this._mergeInsertRow(sliceId, insertColumns);
-    return this._denormalizeComponentInserts(columns, this._objectMap || {});
-  }
-  _denormalizeComponentInserts(columns, objectMap, refTableKey) {
-    const result = {};
-    for (const [propertyKey, propertyValue] of Object.entries(objectMap)) {
-      if (typeof propertyValue === "object") {
-        const refObjectMap = {};
-        const refTableKey2 = propertyValue._tableKey;
-        for (const [refKey, refValue] of Object.entries(
-          propertyValue
-        )) {
-          if (refKey === "_tableKey") continue;
-          refObjectMap[refTableKey2 + "/" + refKey] = refValue;
-        }
-        const refInsert = this._denormalizeComponentInserts(
-          columns,
-          refObjectMap,
-          refTableKey2
-        );
-        for (const [refRoute, refObject] of Object.entries(refInsert)) {
-          const insertObj = { [propertyKey]: refObject };
-          result[refRoute] = {
-            ...result[refRoute],
-            ...insertObj,
-            ...{
-              _somethingToInsert: result[refRoute]._somethingToInsert || refObject._somethingToInsert
-            }
-          };
-        }
-      } else {
-        let compKey = Route.fromFlat(propertyValue).upper().flat;
-        compKey = refTableKey ? compKey.replace(`/${refTableKey}`, "") : compKey;
-        const refPropertyKey = refTableKey ? propertyKey.replace(`${refTableKey}/`, "") : propertyKey;
-        if (!result[compKey]) result[compKey] = {};
-        if (refTableKey && !result[compKey]._tableKey)
-          result[compKey]._tableKey = refTableKey;
-        const propValue = columns.find((col) => {
-          return col.route.propertyKey === propertyKey;
-        });
-        if (!propValue) {
-          throw new Error(
-            `Join._denormalizeComponentInserts: Could not find column value for property key "${propertyKey}".`
-          );
-        }
-        const somethingToInsert = !!propValue.insert;
-        result[compKey] = {
-          ...result[compKey],
-          [refPropertyKey]: propValue.insert ?? propValue.value,
-          ...{
-            _somethingToInsert: result[compKey]._somethingToInsert || somethingToInsert
-          }
-        };
-      }
-    }
-    return result;
-  }
-  // ...........................................................................
-  /**
-   * Merges the insert values into the base row
-   * @param sliceId - The slice id
-   * @param insertRow - The insert row
-   * @returns The merged join row
-   */
-  _mergeInsertRow(sliceId, insertRow) {
-    const baseColumns = this._base[sliceId].columns;
-    const mergedRow = [];
-    for (const baseCol of baseColumns) {
-      const insertCol = insertRow.find(
-        (col) => col.route.equalsWithoutRefs(baseCol.route)
-      );
-      if (insertCol) {
-        mergedRow.push({
-          route: baseCol.route,
-          value: baseCol.value,
-          insert: insertCol.insert
-        });
-      } else {
-        mergedRow.push(baseCol);
-      }
-    }
-    return mergedRow;
-  }
-  // ...........................................................................
-  /**
-   * Hashes the given join rows. If insert value is present, it is used for hashing.
-   *
-   * @param rows The join rows to hash
-   * @returns The hashed join rows
-   */
-  _hashedRows(rows) {
-    const sliceIds = Object.keys(rows);
-    const hashedRows = {};
-    for (const sliceId of sliceIds) {
-      const columns = rows[sliceId];
-      const rowHash = Hash.default.calcHash(
-        columns.map((col) => col.insert ?? col.value)
+  _hashedRows(rows) {
+    const sliceIds = Object.keys(rows);
+    const hashedRows = {};
+    for (const sliceId of sliceIds) {
+      const cols = rows[sliceId];
+      const rowHash = Hash.default.calcHash(
+        cols.map(
+          (col) => col.inserts?.flatMap((con) => con.cell.flatMap((c) => c.value)) ?? col.value.cell ? col.value.cell.flatMap((c) => c.value) : []
+        )
       );
       hashedRows[sliceId] = {
         rowHash,
-        columns
+        columns: cols
       };
     }
     return hashedRows;
@@ -2276,6 +2587,25 @@ class Notify {
     return this._callbacks.get(route.flat) || [];
   }
 }
+const makeUniqueArrayByHash = (arr) => {
+  const seen = /* @__PURE__ */ new Map();
+  const result = [];
+  for (const item of arr) {
+    if (!seen.has(item._hash)) {
+      seen.set(item._hash, item);
+      result.push(item);
+    }
+  }
+  return result;
+};
+const makeUnique = (rljson) => {
+  traverse(rljson, ({ parent, key, value }) => {
+    if (key == "_data" && Array.isArray(value)) {
+      parent[key] = makeUniqueArrayByHash(value);
+    }
+  });
+  return rljson;
+};
 class Db {
   /**
    * Constructor
@@ -2300,22 +2630,27 @@ class Db {
    * Get data from a route with optional filtering
    * @param route - The route to get data from
    * @param where - Optional filter to apply to the data
+   * @param filter - Optional filter to apply to child entries in related tables
+   * @param sliceIds - Optional slice IDs to filter the data
    * @returns An array of Rljson objects matching the route and filter
    * @throws {Error} If the route is not valid or if any controller cannot be created
    */
-  async get(route, where) {
+  async get(route, where, filter, sliceIds) {
     if (!route.isValid) throw new Error(`Route ${route.flat} is not valid.`);
     const isolatedRoute = await this.isolatePropertyKeyFromRoute(route);
-    const cacheHash = `${isolatedRoute.flat}|${JSON.stringify(where)}`;
-    const isCached = this._cache.has(cacheHash);
-    if (isCached) {
-      return this._cache.get(cacheHash);
-    } else {
-      const controllers = await this._indexedControllers(isolatedRoute);
-      const data = await this._get(isolatedRoute, where, controllers);
-      this._cache.set(cacheHash, data);
-      return data;
-    }
+    const controllers = await this.indexedControllers(isolatedRoute);
+    const data = await this._get(
+      isolatedRoute,
+      where,
+      controllers,
+      filter,
+      sliceIds
+    );
+    const dataWithControllers = {
+      ...data,
+      ...{ controllers }
+    };
+    return dataWithControllers;
   }
   // ...........................................................................
   /**
@@ -2326,37 +2661,108 @@ class Db {
    * @param where - The recursive filtering key/value pairs to apply to the data
    * @param controllers - The controllers to use for fetching data
    * @param filter - Optional filter to apply to the data at the current route segment
+   * @param sliceIds - Optional slice IDs to filter the data at the current route segment
    * @returns - An Rljson object matching the route and filters
    */
-  async _get(route, where, controllers, filter) {
+  async _get(route, where, controllers, filter, sliceIds, routeAccumulator) {
+    const params = {
+      route: route.flat,
+      where,
+      filter,
+      sliceIds,
+      routeAccumulator: routeAccumulator ? routeAccumulator.flat : ""
+    };
+    const cacheHash = hsh(rmhsh(params))._hash;
+    const isCached = this._cache.has(cacheHash);
+    if (isCached) {
+      return this._cache.get(cacheHash);
+    }
     const nodeTableKey = route.top.tableKey;
     const nodeRoute = route;
     const nodeRouteRef = await this._getReferenceOfRouteSegment(nodeRoute.top);
     const nodeController = controllers[nodeTableKey];
+    const nodeSliceIds = nodeRoute.top.sliceIds ?? sliceIds;
     let nodeWhere = typeof where === "object" ? { ...where } : where;
     if (!route.isRoot && typeof nodeWhere === "object") {
       delete nodeWhere[nodeRoute.deeper().top.tableKey];
     }
     nodeWhere = nodeWhere ? typeof nodeWhere === "string" ? { _hash: nodeWhere } : nodeWhere : {};
     if (nodeRouteRef && nodeRouteRef.length > 0)
-      nodeWhere = { ...nodeWhere, ...{ _hash: nodeRouteRef } };
+      nodeWhere = { _hash: nodeRouteRef };
     delete nodeWhere["_through"];
     delete nodeWhere["_tableKey"];
     const {
       [nodeTableKey]: { _data: nodeRows, _type: nodeType, _hash: nodeHash }
     } = await nodeController.get(nodeWhere);
+    const nodeColumnCfgs = nodeController.tableCfg().columns;
     const nodeRowsFiltered = [];
-    if (filter && filter.length > 0) {
-      for (const f of filter) {
-        if (f.tableKey !== nodeTableKey) continue;
-        for (const nodeRow of nodeRows) {
+    for (const nodeRow of nodeRows) {
+      const filterActive = filter && filter.length > 0;
+      const sliceIdActive = nodeSliceIds && nodeSliceIds.length > 0;
+      if (!filterActive && !sliceIdActive) {
+        nodeRowsFiltered.push(nodeRow);
+        continue;
+      }
+      let filterResult = false;
+      const filterProperties = [];
+      if (filterActive) {
+        for (const f of filter) {
+          if (f.tableKey !== nodeTableKey) continue;
           if (nodeRow._hash === f.ref) {
-            nodeRowsFiltered.push(nodeRow);
+            filterProperties.push(f);
+            filterResult = true;
           }
         }
+      } else {
+        filterResult = true;
+      }
+      let sliceIdResult = false;
+      if (sliceIdActive) {
+        switch (nodeType) {
+          case "cakes":
+            const cake = nodeRow;
+            const cakeSliceIds = await this._resolveSliceIds(
+              cake.sliceIdsTable,
+              cake.sliceIdsRow
+            );
+            const cakeMatchesSliceIds = nodeSliceIds.filter(
+              (sId) => cakeSliceIds.includes(sId)
+            );
+            if (cakeMatchesSliceIds.length > 0) sliceIdResult = true;
+            break;
+          case "layers":
+            const layer = nodeRow;
+            const layerSliceIds = await this._resolveSliceIds(
+              layer.sliceIdsTable,
+              layer.sliceIdsTableRow
+            );
+            const layerMatchesSliceIds = nodeSliceIds.filter(
+              (sId) => layerSliceIds.includes(sId)
+            );
+            if (layerMatchesSliceIds.length > 0) sliceIdResult = true;
+            break;
+          case "components":
+            if (filterProperties.length > 0) {
+              const componentSliceIds = filterProperties.flatMap(
+                (f) => f.sliceIds
+              );
+              const componentMatchesSliceIds = nodeSliceIds.filter(
+                (sId) => componentSliceIds.includes(sId)
+              );
+              if (componentMatchesSliceIds.length > 0) {
+                sliceIdResult = true;
+              }
+            }
+            break;
+          /* v8 ignore next -- @preserve */
+          default:
+            sliceIdResult = true;
+            break;
+        }
+      } else {
+        sliceIdResult = true;
       }
-    } else {
-      nodeRowsFiltered.push(...nodeRows);
+      if (filterResult && sliceIdResult) nodeRowsFiltered.push(nodeRow);
     }
     const node = {
       [nodeTableKey]: {
@@ -2365,11 +2771,48 @@ class Db {
         _hash: nodeHash
       }
     };
+    const nodeValue = node[nodeTableKey]._data.filter(
+      (v) => v !== void 0 && v !== null
+    );
     if (route.isRoot) {
       if (route.hasPropertyKey) {
-        return this.isolatePropertyFromComponents(node, route.propertyKey);
-      }
-      return node;
+        const isolatedNode = this.isolatePropertyFromComponents(
+          node,
+          route.propertyKey
+        );
+        const result3 = {
+          rljson: isolatedNode,
+          tree: { [nodeTableKey]: node[nodeTableKey] },
+          cell: nodeValue.map(
+            (v, idx) => ({
+              value: v[route.propertyKey] ?? null,
+              row: v,
+              route: Route.fromFlat(
+                (routeAccumulator ? routeAccumulator.flat : nodeTableKey) + (nodeHash ? `@${nodeHash}` : "") + `/${route.propertyKey}`
+              ).toRouteWithProperty(),
+              path: [[nodeTableKey, "_data", idx, route.propertyKey]]
+            })
+          )
+        };
+        this._cache.set(cacheHash, result3);
+        return result3;
+      }
+      const result2 = {
+        rljson: node,
+        tree: { [nodeTableKey]: node[nodeTableKey] },
+        cell: nodeValue.map(
+          (v, idx) => ({
+            value: v[route.propertyKey] ?? null,
+            row: v,
+            route: Route.fromFlat(
+              (routeAccumulator ? routeAccumulator.flat : nodeTableKey) + (nodeHash ? `@${nodeHash}` : "")
+            ),
+            path: [[nodeTableKey, "_data", idx]]
+          })
+        )
+      };
+      this._cache.set(cacheHash, result2);
+      return result2;
     }
     const childrenRoute = route.deeper();
     const childrenTableKey = childrenRoute.top.tableKey;
@@ -2379,21 +2822,60 @@ class Db {
     const nodeRowsMatchingChildrenRefs = /* @__PURE__ */ new Map();
     for (let i = 0; i < nodeRowsFiltered.length; i++) {
       const nodeRow = nodeRowsFiltered[i];
+      const nodeRowObj = { ...{}, ...nodeRow };
       const childrenRefs = await nodeController.getChildRefs(
         nodeRow._hash
       );
-      const rowChildren = await this._get(
+      const childrenRefTypes = /* @__PURE__ */ new Map();
+      const childrenRefSliceIds = /* @__PURE__ */ new Set();
+      for (const cr of childrenRefs) {
+        if (!!cr.columnKey) {
+          const childrenRefColumnCfg = nodeColumnCfgs.find(
+            (c) => c.key === cr.columnKey
+          );
+          if (childrenRefColumnCfg) {
+            childrenRefTypes.set(
+              childrenRefColumnCfg.key,
+              childrenRefColumnCfg.ref?.type ?? ""
+            );
+          }
+          if (cr.sliceIds && cr.sliceIds.length > 0) {
+            for (const sId of cr.sliceIds) {
+              childrenRefSliceIds.add(sId);
+            }
+          }
+        }
+      }
+      if (childrenRefTypes.size > 1) {
+        throw new Error(
+          `Db._get: Multiple reference types found for children of table ${nodeTableKey}.`
+        );
+      }
+      const cakeIsReferenced = childrenRefTypes.size === 1 && [...childrenRefTypes.values()][0] === "cakes";
+      const componentIsReferenced = childrenRefTypes.size === 1 && nodeType === "components" && [...childrenRefTypes.values()][0] === "components";
+      const childrenSliceIds = cakeIsReferenced ? [...childrenRefSliceIds] : componentIsReferenced ? void 0 : nodeSliceIds;
+      const {
+        rljson: rowChildrenRljson,
+        tree: rowChildrenTree,
+        cell: rowChildrenCell
+      } = await this._get(
         childrenRoute,
         childrenWhere,
         controllers,
-        childrenRefs
+        childrenRefs,
+        childrenSliceIds,
+        Route.fromFlat(
+          (routeAccumulator ? routeAccumulator.flat : nodeTableKey) + (nodeHash ? `@${nodeHash}` : "") + "/" + childrenTableKey
+        )
       );
-      if (rowChildren[childrenTableKey]._data.length === 0) continue;
-      nodeChildrenArray.push(rowChildren);
+      if (cakeIsReferenced) {
+        const refKey = [...childrenRefTypes.keys()][0];
+        nodeRowObj[refKey] = rowChildrenTree;
+      }
+      if (rowChildrenRljson[childrenTableKey]._data.length === 0) continue;
+      nodeChildrenArray.push(rowChildrenRljson);
       if (childrenThroughProperty) {
-        const childrenHashes = rowChildren[childrenTableKey]._data.map(
-          (rc) => rc._hash
-        );
+        const resolvedChildrenHashes = rowChildrenRljson[childrenTableKey]._data.map((rc) => rc._hash);
         for (const nr of nodeRowsFiltered) {
           {
             const throughHashesInRowCouldBeArray = nr[childrenThroughProperty];
@@ -2401,30 +2883,191 @@ class Db {
               throughHashesInRowCouldBeArray
             ) ? throughHashesInRowCouldBeArray : [throughHashesInRowCouldBeArray];
             for (const th of throughHashesInRow) {
-              if (childrenHashes.includes(th)) {
-                nodeRowsMatchingChildrenRefs.set(nr._hash, nr);
+              if (resolvedChildrenHashes.includes(th)) {
+                nodeRowObj[childrenThroughProperty] = {
+                  ...rowChildrenTree[childrenTableKey],
+                  ...{ _tableKey: childrenTableKey }
+                };
               }
             }
           }
         }
       }
+      const resolvedChildren = rowChildrenRljson[childrenTableKey]._data;
+      const childrenRefsOfRow = childrenRefs.filter(
+        (cr) => cr.tableKey == childrenTableKey
+      );
+      const matchingChildrenRefs = childrenRefsOfRow.filter(
+        (cr) => !!resolvedChildren.find((ch) => cr.ref === ch._hash)
+      );
+      if (nodeType === "layers") {
+        const compChildrenTrees = rowChildrenTree[childrenTableKey]._data;
+        const compChildrenPaths = rowChildrenCell.map((c) => c.path);
+        const components = compChildrenTrees.map((c, idx) => {
+          return {
+            tree: c,
+            path: compChildrenPaths.filter((p) => p[0][2] == idx)
+          };
+        });
+        const layerTreesAndPaths = components.map(({ tree: comp, path }) => {
+          const sliceIds2 = matchingChildrenRefs.find(
+            (cr) => cr.ref === comp._hash
+          )?.sliceIds;
+          if (!sliceIds2 || sliceIds2.length === 0) {
+            throw new Error(
+              `Db._get: No sliceIds found for component ${comp._hash} of layer ${nodeRow._hash}.`
+            );
+          }
+          if (sliceIds2.length > 1) {
+            throw new Error(
+              `Db._get: Multiple sliceIds found for component ${comp._hash} of layer ${nodeRow._hash}.`
+            );
+          }
+          const sliceId = sliceIds2[0];
+          const pathsForSliceId = [
+            ...path.map((p) => p[0]).map((p) => {
+              const newPath = [...p];
+              newPath[2] = 0;
+              return ["add", sliceId, ...newPath];
+            })
+          ];
+          return {
+            [sliceId]: {
+              tree: {
+                [childrenTableKey]: {
+                  ...{ _data: [comp] },
+                  ...{ _type: "components" }
+                }
+              },
+              path: pathsForSliceId
+            }
+          };
+        });
+        const layer = layerTreesAndPaths.flatMap(
+          (ltap) => Object.entries(ltap).map(([sliceId, { tree }]) => ({
+            [sliceId]: tree
+          }))
+        ).reduce((a, b) => ({ ...a, ...b }), {});
+        const paths = layerTreesAndPaths.map(
+          (ltap) => Object.values(ltap)[0].path
+        );
+        nodeRowsMatchingChildrenRefs.set(nodeRow._hash, {
+          rljson: nodeRow,
+          tree: {
+            ...nodeRowObj,
+            add: { ...nodeRowObj.add, ...layer }
+          },
+          cell: rowChildrenCell.map(
+            (c, idx) => ({
+              ...c,
+              ...{
+                path: [paths.flat()[idx]]
+              }
+            })
+          )
+        });
+      } else if (nodeType === "cakes") {
+        nodeRowsMatchingChildrenRefs.set(nodeRow._hash, {
+          rljson: nodeRow,
+          tree: {
+            ...nodeRowObj,
+            layers: { ...nodeRowObj.layers, ...rowChildrenTree }
+          },
+          cell: rowChildrenCell.map((c) => ({
+            ...c,
+            ...{
+              path: c.path.map((p) => ["layers", ...p])
+            }
+          }))
+        });
+      } else if (nodeType === "components") {
+        if (rowChildrenTree && Object.keys(rowChildrenTree).length > 0) {
+          const columnReferenceMap = nodeColumnCfgs.filter(
+            (c) => c.ref && ["components", "cakes"].includes(c.ref.type)
+          ).reduce((acc, curr) => {
+            acc.set(curr.key, curr.ref.tableKey);
+            return acc;
+          }, /* @__PURE__ */ new Map());
+          const resolvedRefs = {};
+          for (const [colKey, childTableKey] of columnReferenceMap) {
+            const tree = {
+              ...rowChildrenTree[childTableKey],
+              ...{ _tableKey: childTableKey }
+            };
+            const cell = rowChildrenCell.map((c) => ({
+              ...c,
+              ...{
+                path: c.path.filter((p) => p[0] === childTableKey).map((p) => [colKey, ...p.slice(1)])
+              }
+            }));
+            resolvedRefs[colKey] = { tree, cell };
+          }
+          const resolvedProperties = Object.entries(resolvedRefs).map(([colKey, { tree }]) => ({
+            [colKey]: tree
+          })).reduce((a, b) => ({ ...a, ...b }), {});
+          const resolvedTree = {
+            ...nodeRowObj,
+            ...resolvedProperties
+          };
+          const resolvedCell = Object.values(resolvedRefs).map((r) => r.cell).flat();
+          nodeRowsMatchingChildrenRefs.set(nodeRow._hash, {
+            rljson: nodeRow,
+            tree: resolvedTree,
+            cell: resolvedCell
+          });
+        } else {
+          nodeRowsMatchingChildrenRefs.set(nodeRow._hash, {
+            rljson: nodeRow,
+            tree: { ...nodeRowObj },
+            cell: rowChildrenCell
+          });
+        }
+      } else {
+        throw new Error(
+          `Db._get: Unsupported node type ${nodeType} for getting children.`
+        );
+      }
     }
-    const nodeChildren = merge(...nodeChildrenArray);
-    if (childrenThroughProperty) {
-      const matchedNodeRows = Array.from(nodeRowsMatchingChildrenRefs.values());
-      return {
+    const nodeChildren = makeUnique(
+      merge(...nodeChildrenArray)
+    );
+    const matchedNodeRows = Array.from(nodeRowsMatchingChildrenRefs.values());
+    const result = {
+      rljson: {
         ...node,
         ...{
           [nodeTableKey]: {
-            _data: matchedNodeRows,
-            _type: nodeType,
-            _hash: nodeHash
+            ...{
+              _data: matchedNodeRows.map((mr) => mr.rljson),
+              _type: nodeType
+            },
+            ...{
+              ...nodeHash ? { _hash: nodeHash } : {}
+            }
           }
         },
         ...nodeChildren
-      };
-    }
-    return { ...node, ...nodeChildren };
+      },
+      tree: {
+        [nodeTableKey]: {
+          ...{
+            _data: matchedNodeRows.map((mr) => mr.tree),
+            _type: nodeType
+          },
+          ...{
+            ...nodeHash ? { _hash: nodeHash } : {}
+          }
+        }
+      },
+      cell: matchedNodeRows.map(
+        (mr, idx) => mr.cell.map((c) => ({
+          ...c,
+          ...{ path: c.path.map((p) => [nodeTableKey, "_data", idx, ...p]) }
+        }))
+      ).flat()
+    };
+    this._cache.set(cacheHash, result);
+    return result;
   }
   // ...........................................................................
   /**
@@ -2451,234 +3094,66 @@ class Db {
    * @param rljson - The Rljson to join data for
    */
   async join(columnSelection, cakeKey, cakeRef) {
-    const data = await this._getBaseDataForColumnSelection(columnSelection);
-    const cakesTable = data[cakeKey];
-    const cake = cakesTable._data.find((c) => c._hash === cakeRef);
-    if (!cake) {
+    const {
+      tree: { [cakeKey]: cakesTable }
+    } = await this.get(Route.fromFlat(`${cakeKey}@${cakeRef}`), {});
+    const cakes = cakesTable._data;
+    if (cakes.length === 0) {
       throw new Error(
         `Db.join: Cake with ref "${cakeRef}" not found in cake table "${cakeKey}".`
       );
     }
-    const layers = /* @__PURE__ */ new Map();
-    for (const layerKey of Object.keys(cake.layers)) {
-      if (!data[layerKey]) continue;
-      const layersTable = data[layerKey];
-      const layer = layersTable._data.find(
-        (l) => l._hash === cake.layers[layerKey]
+    if (cakes.length > 1) {
+      throw new Error(
+        `Db.join: Multiple cakes with ref "${cakeRef}" found in cake table "${cakeKey}".`
       );
-      layers.set(layerKey, layer);
-    }
-    const components = /* @__PURE__ */ new Map();
-    for (const [tableKey, table] of Object.entries(data)) {
-      if (table._type !== "components") continue;
-      components.set(tableKey, table);
-    }
-    const mergedSliceIds = /* @__PURE__ */ new Set();
-    for (const layer of layers.values()) {
-      const sliceIdsTable = layer.sliceIdsTable;
-      const sliceIdsTableRow = layer.sliceIdsTableRow;
-      const {
-        [sliceIdsTable]: { _data: sliceIds }
-      } = await this.core.readRows(sliceIdsTable, { _hash: sliceIdsTableRow });
-      for (const sid of sliceIds) {
-        for (const s of sid.add) {
-          mergedSliceIds.add(s);
-        }
-      }
     }
-    const columnCfgs = /* @__PURE__ */ new Map();
-    const columnInfos = /* @__PURE__ */ new Map();
-    let objectMap = {};
-    for (const [layerKey, layer] of layers.entries()) {
-      const componentKey = layer.componentsTable;
-      const componentResolved = await this._resolveComponent(
-        `${cakeKey}/${layerKey}/`,
-        componentKey
-      );
-      objectMap = { ...objectMap, ...componentResolved.objectMap };
-      columnInfos.set(componentKey, componentResolved.columnInfos);
-      columnCfgs.set(componentKey, componentResolved.columnCfgs);
-    }
-    const rowMap = /* @__PURE__ */ new Map();
-    const joinColumnInfos = /* @__PURE__ */ new Map();
-    for (const sliceId of mergedSliceIds) {
-      const sliceIdRow = [];
-      for (const [layerKey, layer] of layers.entries()) {
-        const layerRef = layer._hash;
-        const componentKey = layer.componentsTable;
-        const componentRef = layer.add[sliceId];
-        const componentsTable = data[componentKey];
-        const rowComponentProperties = componentsTable._data.find(
-          (r) => r._hash === componentRef
-        );
-        const resolvedProperties = this._resolveComponentProperties(
-          rowComponentProperties,
-          objectMap,
-          data
-        );
-        const joinColumns = [];
-        for (const [
-          resolvedPropertyKey,
-          resolvedPropertyValue
-        ] of Object.entries(resolvedProperties)) {
-          const propertyRoute = cakeKey + "/" + layerKey + "/" + componentKey + "/" + resolvedPropertyKey;
-          const propertyColumnInfo = columnInfos.get(componentKey).find((cI) => cI.route === propertyRoute);
-          if (!!propertyColumnInfo) {
-            const joinColumnRoute = Route.fromFlat(
-              `${cakeKey}@${cakeRef}/${layerKey}@${layerRef}/${componentKey}@${componentRef}`
-            );
-            joinColumnRoute.propertyKey = resolvedPropertyKey;
-            joinColumnInfos.set(resolvedPropertyKey, {
-              ...propertyColumnInfo,
-              key: resolvedPropertyKey,
-              route: joinColumnRoute.flatWithoutRefs.slice(1)
-            });
-            joinColumns.push({
-              route: joinColumnRoute,
-              value: resolvedPropertyValue ?? null,
-              insert: null
-            });
-          }
-        }
-        sliceIdRow.push(...joinColumns);
-      }
-      rowMap.set(sliceId, sliceIdRow);
-    }
-    const joinRows = {};
-    for (const [sliceId, joinColumns] of rowMap.entries()) {
-      Object.assign(joinRows, {
-        [sliceId]: joinColumns
-      });
-    }
-    return new Join(
-      joinRows,
-      new ColumnSelection(Array.from(joinColumnInfos.values())),
-      objectMap
-    ).select(columnSelection);
-  }
-  _resolveComponentProperties(componentData, objectMapOrRoute, baseData) {
-    let result = {};
-    for (const [propertyKey, propertyObjectMap] of Object.entries(
-      objectMapOrRoute
-    )) {
-      if (propertyKey === "_tableKey") continue;
-      if (typeof propertyObjectMap === "object") {
-        const refs = Array.isArray(componentData[propertyKey]) ? componentData[propertyKey] : [componentData[propertyKey]];
-        const refTableKey = propertyObjectMap["_tableKey"];
-        const refCompTable = baseData[refTableKey];
-        if (!refCompTable) continue;
-        const prefixedResolvedRefCompData = {};
-        for (const ref of refs) {
-          const refCompData = refCompTable._data.find((r) => r._hash === ref);
-          if (refCompData) {
-            const resolvedRefCompData = this._resolveComponentProperties(
-              refCompData,
-              propertyObjectMap,
-              baseData
-            );
-            for (const [refPropKey, value] of Object.entries(
-              resolvedRefCompData
-            )) {
-              if (!prefixedResolvedRefCompData[`${refTableKey}/${refPropKey}`]) {
-                prefixedResolvedRefCompData[`${refTableKey}/${refPropKey}`] = [];
-              }
-              prefixedResolvedRefCompData[`${refTableKey}/${refPropKey}`].push({
-                _ref: ref,
-                _value: value
-              });
-            }
-          }
-          result = {
-            ...result,
-            ...prefixedResolvedRefCompData
-          };
-        }
-      }
-      result = {
-        ...result,
-        ...{ [propertyKey]: componentData[propertyKey] }
-      };
-    }
-    return result;
-  }
-  // ...........................................................................
-  /**
-   * Resolve a component's columns, including referenced components
-   *
-   * @param baseRoute - The base route for the component
-   * @param componentKey - The component's table key
-   * @returns - The resolved column configurations, column infos, and object map
-   */
-  async _resolveComponent(baseRoute, componentKey) {
-    const { columns: colCfgs } = await this.core.tableCfg(componentKey);
-    const objectMap = {};
-    const columnCfgs = [];
-    const columnInfos = [];
-    for (let i = 0; i < colCfgs.length; i++) {
-      if (colCfgs[i].key === "_hash") continue;
-      const colCfg = colCfgs[i];
-      if (colCfg.ref) {
-        const columnCfgsAndInfosForRef = await this._resolveComponent(
-          baseRoute + `/${componentKey}`,
-          colCfg.ref.tableKey
+    const cake = cakes[0];
+    const sliceIds = await this._resolveSliceIds(
+      cake.sliceIdsTable,
+      cake.sliceIdsRow
+    );
+    const rows = {};
+    for (const sliceId of sliceIds) {
+      const row = [];
+      for (const columnInfo of columnSelection.columns) {
+        const columnRoute = Route.fromFlat(
+          columnInfo.route
+        ).toRouteWithProperty();
+        const columnContainer = await this.get(
+          columnRoute,
+          cakeRef,
+          void 0,
+          [sliceId]
         );
-        objectMap[colCfg.key] = {
-          _tableKey: colCfg.ref.tableKey,
-          ...columnCfgsAndInfosForRef.objectMap
+        const column = {
+          route: columnRoute,
+          value: columnContainer,
+          inserts: null
         };
-        const columnCfgsForRef = columnCfgsAndInfosForRef.columnCfgs.map(
-          (cc) => ({
-            ...cc,
-            key: colCfg.ref.tableKey + "/" + cc.key
-          })
-        );
-        const columnInfosForRef = columnCfgsAndInfosForRef.columnInfos.map(
-          (cc) => ({
-            ...cc,
-            key: colCfg.ref.tableKey + "/" + cc.key
-          })
-        );
-        columnCfgs.push(...columnCfgsForRef);
-        columnInfos.push(...columnInfosForRef);
-      }
-      const columnRoute = Route.fromFlat(
-        baseRoute.length > 0 ? `${baseRoute}/${componentKey}/${colCfg.key}` : `/${componentKey}/${colCfg.key}`
-      ).flat.slice(1);
-      if (!objectMap[colCfg.key]) objectMap[colCfg.key] = columnRoute;
-      columnCfgs.push(colCfg);
-      columnInfos.push({
-        ...colCfg,
-        alias: `${colCfg.key}`,
-        route: columnRoute,
-        titleShort: colCfg.key,
-        titleLong: colCfg.key
-      });
+        row.push(column);
+      }
+      rows[sliceId] = row;
     }
-    return { columnCfgs, columnInfos, objectMap };
+    return new Join(rows, columnSelection);
   }
   // ...........................................................................
-  /**
-   * Fetches data for the given ColumnSelection
-   * @param columnSelection - The ColumnSelection to fetch data for
-   */
-  async _getBaseDataForColumnSelection(columnSelection) {
-    const uniqueComponentRoutes = /* @__PURE__ */ new Set();
-    for (const colInfo of columnSelection.columns) {
-      const componentRoute = Route.fromFlat(colInfo.route);
-      const isolatedComponentRoute = await this.isolatePropertyKeyFromRoute(
-        componentRoute
-      );
-      uniqueComponentRoutes.add(
-        isolatedComponentRoute.toRouteWithoutProperty().flat
+  async _resolveSliceIds(sliceIdTable, sliceIdRow) {
+    const sliceIdController = new SliceIdController(this.core, sliceIdTable);
+    sliceIdController.init();
+    const resolvedSliceIds = /* @__PURE__ */ new Set();
+    const {
+      [sliceIdTable]: { _data: sliceIds }
+    } = await sliceIdController.get(sliceIdRow);
+    for (const sliceId of sliceIds) {
+      const baseSliceIds = await sliceIdController.resolveBaseSliceIds(
+        sliceId
       );
+      for (const sId of baseSliceIds.add) {
+        resolvedSliceIds.add(sId);
+      }
     }
-    const data = {};
-    for (const compRouteFlat of uniqueComponentRoutes) {
-      const uniqueComponentRoute = Route.fromFlat(compRouteFlat);
-      const componentData = await this.get(uniqueComponentRoute, {});
-      Object.assign(data, componentData);
-    }
-    return data;
+    return Array.from(resolvedSliceIds);
   }
   // ...........................................................................
   /**
@@ -2687,17 +3162,15 @@ class Db {
    * @returns The result of the Insert as an InsertHistoryRow
    * @throws {Error} If the Insert is not valid or if any controller cannot be created
    */
-  async insert(insert, options) {
-    const initialRoute = Route.fromFlat(insert.route);
-    const runs = await this._resolveInsert(insert);
-    const errors = validateInsert(insert);
-    if (!!errors.hasErrors) {
-      throw new Error(
-        `Db.insert: Insert is not valid:
-${JSON.stringify(errors, null, 2)}`
-      );
+  async insert(route, tree, options) {
+    const controllers = await this.indexedControllers(
+      Route.fromFlat(route.flatWithoutRefs)
+    );
+    const runFns = {};
+    for (const [tableKey, controller] of Object.entries(controllers)) {
+      runFns[tableKey] = controller.insert.bind(controller);
     }
-    return this._insert(insert, initialRoute, runs, options);
+    return this._insert(route, tree, runFns, options);
   }
   // ...........................................................................
   /**
@@ -2708,87 +3181,190 @@ ${JSON.stringify(errors, null, 2)}`
    * @returns The result of the Insert
    * @throws {Error} If the route is not valid or if any controller cannot be created
    */
-  async _insert(insert, route, runFns, options) {
-    let results;
-    let tableKey;
-    const segment = route.segment(0);
-    tableKey = segment.tableKey;
-    let previous = [];
-    if (Route.segmentHasRef(segment)) {
-      const routeRef = Route.segmentRef(segment);
-      if (Route.segmentHasInsertHistoryRef(segment)) {
-        previous = [...previous, routeRef];
-      }
-      if (Route.segmentHasDefaultRef(segment)) {
-        const timeIds = await this.getTimeIdsForRef(
-          tableKey,
-          Route.segmentRef(segment)
-        );
-        previous = [...previous, ...timeIds];
-      }
+  async _insert(route, tree, runFns, options) {
+    const results = [];
+    const nodeRoute = route;
+    const nodeSegment = nodeRoute.segment(0);
+    const nodeTableKey = nodeSegment.tableKey;
+    const nodeTree = tree[nodeTableKey];
+    const nodeType = nodeTree._type;
+    if (nodeTree._data.length === 0) {
+      throw new Error(
+        `Db._insert: No data found for table "${nodeTableKey}" in route "${route.flat}".`
+      );
     }
-    if (!route.isRoot) {
-      const childRoute = route.deeper(1);
-      const childKeys = this._childKeys(insert.value);
-      const childRefs = {};
-      for (const k of childKeys) {
-        const childValue = insert.value[k];
-        const childInsert = { ...insert, value: childValue };
+    const previousHash = nodeSegment[nodeTableKey + "Ref"] ?? null;
+    const previousTimeId = nodeSegment[nodeTableKey + "InsertHistoryRef"] ?? null;
+    const previous = previousHash ? await this.getTimeIdsForRef(nodeTableKey, previousHash) : previousTimeId ? [previousTimeId] : [];
+    if (!nodeRoute.isRoot) {
+      const childRoute = nodeRoute.deeper(1);
+      const childTableKey = childRoute.top.tableKey;
+      if (nodeType === "cakes") {
+        const cakes = nodeTree._data;
+        if (cakes.length > 1) ;
+        const cake = cakes[0];
+        const childTree = cake.layers[childTableKey];
         const childResults = await this._insert(
-          childInsert,
           childRoute,
+          { [childTableKey]: childTree },
           runFns
         );
-        const childRefKey = childRoute.top.tableKey + "Ref";
-        const childRefArray = childResults.map(
-          (childResult) => childResult[childRefKey]
+        if (childResults.length > 1) {
+          throw new Error(
+            `Db._insert: Multiple inserts returned for child table "${childTableKey}" when inserting into cake table "${nodeTableKey}". Only single child inserts are supported.`
+          );
+        }
+        const childResult = childResults[0];
+        const insertValue = {
+          ...cake,
+          ...{
+            layers: {
+              ...cake.layers,
+              ...{
+                [childTableKey]: childResult[childTableKey + "Ref"]
+              }
+            }
+          }
+        };
+        const runFn = runFns[nodeTableKey];
+        const result = await runFn("add", rmhsh(insertValue), "db.insert");
+        results.push(
+          ...result.map((r) => ({
+            ...r,
+            ...{ previous },
+            ...{ route: route.flat }
+          }))
         );
-        childRefs[k] = childRefArray;
       }
-      const runFn = runFns[tableKey];
-      results = [
-        ...(await runFn(
-          insert.command,
-          {
-            ...insert.value,
-            ...childRefs
-          },
-          insert.origin
-        )).map((r) => ({ ...r, ...{ previous } }))
-      ];
+      if (nodeType === "layers") {
+        const layers = nodeTree._data;
+        for (const layer of layers) {
+          const layerInsert = {};
+          for (const [sliceId, componentTree] of Object.entries(layer.add)) {
+            if (sliceId === "_hash") continue;
+            const writtenComponents = await this._insert(
+              childRoute,
+              componentTree,
+              runFns
+            );
+            if (writtenComponents.length > 1) {
+              throw new Error(
+                `Db._insert: Multiple components written for layer "${layer._hash}" and sliceId "${sliceId}" is currently not supported.`
+              );
+            }
+            const writtenComponent = writtenComponents[0];
+            if (!writtenComponent || !writtenComponent[childTableKey + "Ref"]) {
+              throw new Error(
+                `Db._insert: No component reference returned for layer "${layer._hash}" and sliceId "${sliceId}".`
+              );
+            }
+            layerInsert[sliceId] = writtenComponent[childTableKey + "Ref"];
+          }
+          const runFn = runFns[nodeTableKey];
+          const result = await runFn(
+            "add",
+            rmhsh({
+              ...layer,
+              ...{ add: layerInsert }
+            }),
+            "db.insert"
+          );
+          results.push(
+            ...result.map((r) => ({
+              ...r,
+              ...{ previous },
+              ...{ route: route.flat }
+            }))
+          );
+        }
+      }
+      if (["components", "edits", "multiEdits"].includes(
+        nodeType
+      )) {
+        const runFn = runFns[nodeTableKey];
+        const components = nodeTree._data;
+        for (const component of components) {
+          const resolvedComponent = { ...component };
+          for (const [property, value] of Object.entries(component)) {
+            if (value.hasOwnProperty("_tableKey") && value._tableKey === childTableKey) {
+              const writtenReferences = await this._insert(
+                childRoute,
+                { [childTableKey]: value },
+                runFns
+              );
+              resolvedComponent[property] = writtenReferences.map(
+                (wr) => wr[childTableKey + "Ref"]
+              );
+            }
+          }
+          const result = await runFn(
+            "add",
+            rmhsh(resolvedComponent),
+            "db.insert"
+          );
+          results.push(
+            ...result.map((r) => ({
+              ...r,
+              ...{ previous },
+              ...{ route: route.flat }
+            }))
+          );
+        }
+      }
     } else {
-      tableKey = route.root.tableKey;
-      const runFn = runFns[tableKey];
-      const insertValue = insert.value;
-      for (const [propertyKey, propertyValue] of Object.entries(insert.value)) {
-        if (propertyValue && typeof propertyValue === "object" && !!propertyValue._tableKey) {
-          const referenceRoute = propertyValue._tableKey;
-          delete propertyValue._tableKey;
-          const referenceInsert = {
-            command: insert.command,
-            route: referenceRoute,
-            value: propertyValue
-          };
-          const referencesWritten = (await this._insert(
-            referenceInsert,
-            Route.fromFlat(referenceRoute),
-            runFns
-          )).map((h) => h[referenceRoute + "Ref"]);
-          insertValue[propertyKey] = referencesWritten.length === 1 ? referencesWritten[0] : referencesWritten;
+      const runFn = runFns[nodeTableKey];
+      if (["components", "edits", "multiEdits"].includes(
+        nodeType
+      )) {
+        const components = rmhsh(
+          tree[nodeTableKey]
+        );
+        for (const component of components._data) {
+          if (!component) continue;
+          delete component._tableKey;
+          delete component._type;
+          const result = await runFn("add", component, "db.insert");
+          results.push(
+            ...result.map((r) => ({
+              ...r,
+              ...{ previous },
+              ...{ route: route.flat }
+            }))
+          );
+        }
+      }
+      if (nodeType === "layers") {
+        const layers = rmhsh(tree[nodeTableKey]);
+        for (const layer of layers._data) {
+          const result = await runFn("add", layer, "db.insert");
+          results.push(
+            ...result.map((r) => ({
+              ...r,
+              ...{ previous },
+              ...{ route: route.flat }
+            }))
+          );
+        }
+      }
+      if (nodeType === "cakes") {
+        const cakes = rmhsh(tree[nodeTableKey]);
+        for (const cake of cakes._data) {
+          const result = await runFn("add", cake, "db.insert");
+          results.push(
+            ...result.map((r) => ({
+              ...r,
+              ...{ previous },
+              ...{ route: route.flat }
+            }))
+          );
         }
       }
-      results = [
-        ...(await runFn(insert.command, insertValue, insert.origin)).map(
-          (r) => ({ ...r, previous })
-        )
-      ];
     }
     for (const result of results) {
-      result.route = insert.route;
       if (!options?.skipHistory)
-        await this._writeInsertHistory(tableKey, result);
+        await this._writeInsertHistory(nodeTableKey, result);
       if (!options?.skipNotification)
-        this.notify.notify(Route.fromFlat(insert.route), result);
+        this.notify.notify(Route.fromFlat(result.route), result);
     }
     return results;
   }
@@ -2811,48 +3387,6 @@ ${JSON.stringify(errors, null, 2)}`
     this.notify.unregister(route, callback);
   }
   // ...........................................................................
-  /**
-   * Resolves an Insert by returning the run functions of all controllers involved in the Insert's route
-   * @param Insert - The Insert to resolve
-   * @returns A record of controller run functions, keyed by table name
-   * @throws {Error} If the route is not valid or if any controller cannot be created
-   */
-  async _resolveInsert(Insert2) {
-    const controllers = await this._indexedControllers(
-      Route.fromFlat(Insert2.route)
-    );
-    const referencedComponentTableKeys = /* @__PURE__ */ new Set();
-    traverse(Insert2.value, ({ key, parent }) => {
-      if (key == "_tableKey")
-        referencedComponentTableKeys.add(parent[key]);
-    });
-    for (const tableKey of referencedComponentTableKeys) {
-      controllers[tableKey] ??= await this.getController(tableKey);
-    }
-    const runFns = {};
-    for (const tableKey of Object.keys(controllers)) {
-      runFns[tableKey] = controllers[tableKey].insert.bind(
-        controllers[tableKey]
-      );
-    }
-    return runFns;
-  }
-  // ...........................................................................
-  /**
-   * Returns the keys of child refs in a value based on a route
-   * @param value - The value to check
-   * @returns An array of keys of child refs in the value
-   */
-  _childKeys(value) {
-    const keys = Object.keys(value);
-    const childKeys = [];
-    for (const k of keys) {
-      if (typeof value[k] !== "object") continue;
-      childKeys.push(k);
-    }
-    return childKeys;
-  }
-  // ...........................................................................
   /**
    * Get a controller for a specific table
    * @param tableKey - The key of the table to get the controller for
@@ -2869,7 +3403,7 @@ ${JSON.stringify(errors, null, 2)}`
     return createController(contentType, this.core, tableKey, refs);
   }
   // ...........................................................................
-  async _indexedControllers(route) {
+  async indexedControllers(route) {
     const controllers = {};
     const isolatedRoute = await this.isolatePropertyKeyFromRoute(route);
     for (let i = 0; i < isolatedRoute.segments.length; i++) {