@rljson/rljson 0.0.73 → 0.0.74

package/dist/content/tree.d.ts

@@ -0,0 +1,52 @@
+import { Json } from '@rljson/json';
+import { RljsonTable } from '../rljson.ts';
+import { Ref } from '../typedefs.ts';
+import { TableCfg } from './table-cfg.ts';
+/**
+ * A TreeRef is a hash pointing to another hash in the tree
+ */
+export type TreeRef = Ref;
+/**
+ * A Tree is a hierarchical structure of Trees
+ */
+export interface Tree extends Json {
+    /**
+     * `id` identifies the tree node, it has to be unique among sibling nodes
+     */
+    id?: string;
+    /**
+     * If `isParent` is true, this node is a parent node and can have children
+     */
+    isParent: boolean;
+    /**
+     * Optional meta information about this tree node
+     */
+    meta: Json | null;
+    /**
+     * The children of this tree node
+     */
+    children: Array<TreeRef> | null;
+}
+export type TreeWithHash = Tree & {
+    _hash: string;
+};
+/**
+ * A table containing trees
+ */
+export type TreesTable = RljsonTable<Tree, 'trees'>;
+/**
+ * Creates a TableCfg for Trees tables
+ * @param treesTableKey - The table key of the trees table
+ * @returns A TableCfg for Trees tables
+ */
+export declare const createTreesTableCfg: (treesTableKey: string) => TableCfg;
+/**
+ * Provides an example treesTable for test purposes
+ */
+export declare const exampleTreesTable: () => TreesTable;
+/**
+ * Converts a plain object into a tree structure
+ * @param obj - The plain object to convert
+ * @returns An array of Tree nodes representing the tree structure
+ */
+export declare const treeFromObject: (obj: any) => TreeWithHash[];

package/dist/example/bakery-example.d.ts

@@ -4,6 +4,7 @@ import { CakesTable } from '../content/cake.ts';
 import { ComponentsTable } from '../content/components.ts';
 import { LayersTable } from '../content/layer.ts';
 import { SliceIdsTable } from '../content/slice-ids.ts';
+import { TreesTable } from '../content/tree.ts';
 import { InsertHistoryTable } from '../insertHistory/insertHistory.ts';
 import { Rljson } from '../rljson.ts';
 import { Ref } from '../typedefs.ts';
@@ -33,5 +34,6 @@ export interface Bakery extends Rljson {
     ingredients: ComponentsTable<Ingredient>;
     nutritionalValues: ComponentsTable<NutritionalValues>;
     ingredientsInsertHistory: InsertHistoryTable<'Ingredients'>;
+    recipesTreeTable: TreesTable;
 }
 export declare const bakeryExample: () => Bakery;

package/dist/example.d.ts

@@ -10,6 +10,7 @@ export declare class Example {
         multiRef: () => Rljson;
         singleSliceIdRef: () => Rljson;
         multiSliceIdRef: () => Rljson;
+        tree: () => Rljson;
         complete: () => Rljson;
     };
     static readonly broken: {
@@ -30,6 +31,12 @@ export declare class Example {
         tableCfg: {
             wrongType: () => Rljson;
         };
+        trees: {
+            missingChildNodes: () => Rljson;
+            cyclicTree: () => Rljson;
+            duplicateChildNodeIds: () => Rljson;
+            nonParentWithChildren: () => Rljson;
+        };
         layers: {
             missingBase: () => Rljson;
             missingSliceIdSet: () => Rljson;

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 export * from './content/buffet.ts';
 export * from './content/cake.ts';
 export * from './content/components.ts';
-export * from './content/head.ts';
 export * from './content/layer.ts';
 export * from './content/revision.ts';
 export * from './content/slice-ids.ts';
 export * from './content/table-cfg.ts';
+export * from './content/tree.ts';
 export * from './edit/edit-history.ts';
 export * from './edit/edit.ts';
 export * from './edit/multi-edit.ts';

package/dist/rljson.d.ts

@@ -2,11 +2,11 @@ import { Json } from '@rljson/json';
 import { BuffetsTable } from './content/buffet.ts';
 import { CakesTable } from './content/cake.ts';
 import { ComponentsTable } from './content/components.ts';
-import { HeadsTable } from './content/head.ts';
 import { LayersTable } from './content/layer.ts';
 import { RevisionsTable } from './content/revision.ts';
 import { SliceIdsTable } from './content/slice-ids.ts';
 import { TableCfgRef, TablesCfgTable } from './content/table-cfg.ts';
+import { TreesTable } from './content/tree.ts';
 import { EditHistoryTable } from './edit/edit-history.ts';
 import { EditsTable } from './edit/edit.ts';
 import { MultiEditsTable } from './edit/multi-edit.ts';
@@ -17,7 +17,7 @@ export declare const reservedTableKeys: string[];
 /**
  * One of the supported Rljson table types
  */
-export type TableType = BuffetsTable | ComponentsTable<any> | LayersTable | SliceIdsTable | CakesTable | RevisionsTable | TablesCfgTable | InsertHistoryTable<any> | EditsTable | MultiEditsTable | EditHistoryTable | HeadsTable;
+export type TableType = BuffetsTable | ComponentsTable<any> | LayersTable | SliceIdsTable | CakesTable | RevisionsTable | TablesCfgTable | InsertHistoryTable<any> | EditsTable | MultiEditsTable | EditHistoryTable | TreesTable;
 /** The rljson data format */
 export interface Rljson extends Json {
     [tableId: TableKey]: TableType;

package/dist/rljson.js

@@ -154,7 +154,7 @@ class Route {
    * @returns True if the current route is the root route, false otherwise
    */
   get isRoot() {
-    return this._segments.length === 1;
+    return this._segments.length <= 1;
   }
   // .............................................................................
   /**
@@ -486,6 +486,23 @@ const bakeryExample = () => {
     ],
     _hash: ""
   });
+  const recipesTreeChildren = hip({
+    id: "tastyCake",
+    isParent: false,
+    meta: { description: "A tasty cake recipe" },
+    children: null
+  });
+  const recipesTreeRoot = hip({
+    id: "root",
+    isParent: true,
+    meta: { description: "Root of the recipes tree" },
+    children: [recipesTreeChildren._hash]
+  });
+  const recipesTreeTable = hip({
+    _type: "trees",
+    _data: [recipesTreeRoot, recipesTreeChildren],
+    _hash: ""
+  });
   const result = {
     buffets,
     cakes,
@@ -496,7 +513,8 @@ const bakeryExample = () => {
     recipeIngredients,
     ingredients,
     nutritionalValues,
-    ingredientsInsertHistory
+    ingredientsInsertHistory,
+    recipesTreeTable
   };
   return result;
 };
@@ -527,36 +545,6 @@ const createCakeTableCfg = (cakeKey) => ({
 });
 const exampleCakesTable = () => bakeryExample().cakes;
 const exampleComponentsTable = () => bakeryExample().nutritionalValues;
-const createHeadsTableCfg = (cakeKey) => ({
-  key: `${cakeKey}Heads`,
-  type: "head",
-  columns: [
-    {
-      key: "_hash",
-      type: "string",
-      titleLong: "Hash",
-      titleShort: "Hash"
-    },
-    {
-      key: "timeId",
-      type: "string",
-      titleLong: "Time Identifier",
-      titleShort: "Time ID"
-    },
-    {
-      key: "cakeRef",
-      type: "string",
-      titleLong: "Cake Reference",
-      titleShort: "Cake Ref",
-      ref: {
-        tableKey: `${cakeKey}`
-      }
-    }
-  ],
-  isHead: false,
-  isRoot: false,
-  isShared: true
-});
 const createLayerTableCfg = (layerKey) => ({
   key: layerKey,
   type: "layers",
@@ -625,6 +613,127 @@ const createSliceIdsTableCfg = (tableKey) => ({
   isRoot: false,
   isShared: true
 });
+const createTreesTableCfg = (treesTableKey) => ({
+  key: treesTableKey,
+  type: "trees",
+  columns: [
+    { key: "_hash", type: "string", titleLong: "Hash", titleShort: "Hash" },
+    { key: "id", type: "string", titleLong: "Identifier", titleShort: "Id" },
+    {
+      key: "isParent",
+      type: "boolean",
+      titleLong: "Is Parent",
+      titleShort: "Is Parent"
+    },
+    {
+      key: "meta",
+      type: "json",
+      titleLong: "Meta Information",
+      titleShort: "Meta"
+    },
+    {
+      key: "children",
+      type: "jsonArray",
+      titleLong: "Children",
+      titleShort: "Children"
+    }
+  ],
+  isHead: false,
+  isRoot: false,
+  isShared: true
+});
+const exampleTreesTable = () => bakeryExample().recipesTreeTable;
+const treeFromObject = (obj) => {
+  const result = [];
+  const processedIds = /* @__PURE__ */ new Set();
+  const idToHashMap = /* @__PURE__ */ new Map();
+  const processNode = (value, nodeId) => {
+    if (processedIds.has(nodeId)) {
+      return;
+    }
+    processedIds.add(nodeId);
+    const childIds = [];
+    if (Array.isArray(value)) {
+      const isChildrenArray = value.length === 0 || value.every(
+        (item) => item !== null && typeof item === "object" && !Array.isArray(item) && Object.keys(item).length === 1
+      );
+      if (isChildrenArray) {
+        for (const item of value) {
+          const keys = Object.keys(item);
+          const childId = keys[0];
+          childIds.push(childId);
+          processNode(item[childId], childId);
+        }
+        const treeNode = {
+          id: nodeId,
+          isParent: true,
+          meta: null,
+          children: childIds.length > 0 ? childIds.map((id) => idToHashMap.get(id)) : null
+        };
+        const hashedNode = hip(treeNode);
+        idToHashMap.set(nodeId, hashedNode._hash);
+        result.push(hashedNode);
+      } else {
+        const treeNode = {
+          id: nodeId,
+          isParent: false,
+          meta: { value },
+          children: null
+        };
+        const hashedNode = hip(treeNode);
+        idToHashMap.set(nodeId, hashedNode._hash);
+        result.push(hashedNode);
+      }
+    } else if (value !== null && typeof value === "object") {
+      const keys = Object.keys(value);
+      if (keys.includes("meta") || keys.includes("isParent") || keys.includes("children")) {
+        const treeNode = {
+          id: nodeId,
+          isParent: false,
+          meta: value.meta,
+          children: null
+        };
+        const hashedNode = hip(treeNode);
+        idToHashMap.set(nodeId, hashedNode._hash);
+        result.push(hashedNode);
+      } else {
+        for (const key in value) {
+          if (Object.prototype.hasOwnProperty.call(value, key)) {
+            childIds.push(key);
+            processNode(value[key], key);
+          }
+        }
+        const treeNode = {
+          id: nodeId,
+          isParent: true,
+          meta: null,
+          children: childIds.length > 0 ? childIds.map((id) => idToHashMap.get(id)) : null
+        };
+        const hashedNode = hip(treeNode);
+        idToHashMap.set(nodeId, hashedNode._hash);
+        result.push(hashedNode);
+      }
+    } else {
+      const treeNode = {
+        id: nodeId,
+        isParent: false,
+        meta: { value },
+        children: null
+      };
+      const hashedNode = hip(treeNode);
+      idToHashMap.set(nodeId, hashedNode._hash);
+      result.push(hashedNode);
+    }
+  };
+  if (obj !== null && typeof obj === "object" && !Array.isArray(obj)) {
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        processNode(obj[key], key);
+      }
+    }
+  }
+  return result;
+};
 class Example {
   static ok = {
     bakery: () => bakeryExample(),
@@ -966,6 +1075,11 @@ class Example {
         }
       };
     },
+    tree: () => {
+      return {
+        recipesTreeTable: exampleTreesTable()
+      };
+    },
     complete: () => {
       const sliceIds = hip({
         _type: "sliceIds",
@@ -1324,6 +1438,42 @@ class Example {
         });
       }
     },
+    trees: {
+      missingChildNodes: () => {
+        const result = Example.ok.tree();
+        const treeTable = result.recipesTreeTable;
+        treeTable._data.pop();
+        return hip(result, {
+          updateExistingHashes: true,
+          throwOnWrongHashes: false
+        });
+      },
+      cyclicTree: () => {
+        const result = Example.ok.tree();
+        const treeTable = result.recipesTreeTable;
+        treeTable._data[0].children = [treeTable._data[0]._hash];
+        return { recipesTreeTable: treeTable };
+      },
+      duplicateChildNodeIds: () => {
+        const result = Example.ok.tree();
+        const treeTable = result.recipesTreeTable;
+        const firstChildHash = treeTable._data[1]._hash;
+        treeTable._data[0].children = [firstChildHash, firstChildHash];
+        return hip(result, {
+          updateExistingHashes: true,
+          throwOnWrongHashes: false
+        });
+      },
+      nonParentWithChildren: () => {
+        const result = Example.ok.tree();
+        const treeTable = result.recipesTreeTable;
+        treeTable._data[0].isParent = false;
+        return hip(result, {
+          updateExistingHashes: true,
+          throwOnWrongHashes: false
+        });
+      }
+    },
     layers: {
       missingBase: () => {
         const result = Example.ok.complete();
@@ -1745,7 +1895,11 @@ const createInsertHistoryTableCfg = (tableCfg) => ({
       key: `${tableCfg.key}Ref`,
       type: "string",
       titleLong: "Reference",
-      titleShort: "Ref"
+      titleShort: "Ref",
+      ref: {
+        tableKey: `${tableCfg.key}MultiEdits`,
+        type: tableCfg.type
+      }
     },
     { key: "route", type: "string", titleLong: "Route", titleShort: "Route" },
     {
@@ -1849,7 +2003,7 @@ const contentTypes = [
   "edits",
   "multiEdits",
   "editHistory",
-  "head"
+  "trees"
 ];
 const exampleTypedefs = () => {
   return {
@@ -1924,6 +2078,10 @@ class _BaseValidator {
       () => this._rootOrHeadTableHasNoIdColumn(),
       // Check references
       () => this._refsNotFound(),
+      // Check trees
+      () => this._treeChildNodesNotFound(),
+      () => this._treeDuplicateNodeIdsAsSibling(),
+      () => this._treeIsNotParentButHasChildren(),
       // Check layers
       () => this._layerBasesNotFound(),
       () => this._layerSliceIdsTableNotFound(),
@@ -2345,9 +2503,112 @@ class _BaseValidator {
     }
   }
   // ...........................................................................
+  _treeChildNodesNotFound() {
+    const brokenTrees = [];
+    iterateTablesSync(this.rljson, (tableKey, table) => {
+      if (table._type !== "trees") {
+        return;
+      }
+      const treesTable = table;
+      for (const tree of treesTable._data) {
+        const childIds = tree.children;
+        if (!childIds) {
+          continue;
+        }
+        for (const childId of childIds) {
+          const childNode = treesTable._data.find(
+            (n) => n._hash === childId
+          );
+          if (!childNode) {
+            brokenTrees.push({
+              treesTable: tableKey,
+              brokenTree: tree._hash,
+              missingChildNode: childId
+            });
+          }
+        }
+      }
+    });
+    if (brokenTrees.length > 0) {
+      this.errors.treeChildNodesNotFound = {
+        error: "Child nodes are missing",
+        brokenTrees
+      };
+    }
+  }
+  // ...........................................................................
+  _treeDuplicateNodeIdsAsSibling() {
+    const treesWithDuplicateSiblingIds = [];
+    iterateTablesSync(this.rljson, (tableKey, table) => {
+      if (table._type !== "trees") {
+        return;
+      }
+      const treesTable = table;
+      for (const tree of treesTable._data) {
+        const childIds = tree.children;
+        if (!childIds) {
+          continue;
+        }
+        const seenIds = /* @__PURE__ */ new Set();
+        const duplicateIds = /* @__PURE__ */ new Set();
+        for (const childId of childIds) {
+          if (seenIds.has(childId)) {
+            duplicateIds.add(childId);
+          } else {
+            seenIds.add(childId);
+          }
+        }
+        if (duplicateIds.size > 0) {
+          treesWithDuplicateSiblingIds.push({
+            treesTable: tableKey,
+            tree: tree._hash,
+            duplicateChildIds: Array.from(duplicateIds)
+          });
+        }
+      }
+    });
+    if (treesWithDuplicateSiblingIds.length > 0) {
+      this.errors.treeDuplicateNodeIdsAsSibling = {
+        error: "Trees have duplicate sibling node IDs",
+        trees: treesWithDuplicateSiblingIds
+      };
+    }
+  }
+  // ...........................................................................
+  _treeIsNotParentButHasChildren() {
+    const invalidTrees = [];
+    iterateTablesSync(this.rljson, (tableKey, table) => {
+      if (table._type !== "trees") {
+        return;
+      }
+      const treesTable = table;
+      for (const tree of treesTable._data) {
+        const isParent = tree.isParent;
+        const childIds = tree.children;
+        if (!isParent && childIds && childIds.length > 0) {
+          invalidTrees.push({
+            treesTable: tableKey,
+            tree: tree._hash,
+            isParent,
+            children: childIds
+          });
+        }
+      }
+    });
+    if (invalidTrees.length > 0) {
+      this.errors.treeIsNotParentButHasChildren = {
+        error: "Trees marked as non-parents have children",
+        trees: invalidTrees
+      };
+    }
+  }
+  // ...........................................................................
   _layerBasesNotFound() {
     const brokenLayers = [];
     iterateTablesSync(this.rljson, (tableKey, table) => {
+      if (table._type !== "layers") {
+        return;
+      }
       const layersIndexed = this.rljsonIndexed[tableKey];
       const layersTable = table;
       for (const layer of layersTable._data) {
@@ -2703,11 +2964,11 @@ export {
   createCakeTableCfg,
   createEditHistoryTableCfg,
   createEditTableCfg,
-  createHeadsTableCfg,
   createInsertHistoryTableCfg,
   createLayerTableCfg,
   createMultiEditTableCfg,
   createSliceIdsTableCfg,
+  createTreesTableCfg,
   exampleBuffetsTable,
   exampleCakesTable,
   exampleComponentsTable,
@@ -2719,6 +2980,7 @@ export {
   exampleSliceIdsTable,
   exampleTableCfg,
   exampleTableCfgTable,
+  exampleTreesTable,
   exampleTypedefs,
   getTimeIdTimestamp,
   getTimeIdUniquePart,
@@ -2734,6 +2996,7 @@ export {
   routeSliceIdSeperator,
   throwOnInvalidTableCfg,
   timeId,
+  treeFromObject,
   validateInsert,
   validateRljsonAgainstTableCfg
 };

package/dist/src/example.ts

@@ -13,9 +13,11 @@ import { ComponentsTable } from './content/components.ts';
 import { Layer, LayersTable } from './content/layer.ts';
 import { SliceIdsTable } from './content/slice-ids.ts';
 import { ColumnCfg, TablesCfgTable } from './content/table-cfg.ts';
+import { exampleTreesTable, TreesTable } from './content/tree.ts';
 import { bakeryExample } from './example/bakery-example.ts';
 import { Rljson } from './rljson.ts';
 
+
 export class Example {
   static readonly ok = {
     bakery: (): Rljson => bakeryExample(),
@@ -371,6 +373,11 @@ export class Example {
         } as ComponentsTable<Json>,
       };
     },
+    tree: (): Rljson => {
+      return {
+        recipesTreeTable: exampleTreesTable(),
+      };
+    },
     complete: (): Rljson => {
       const sliceIds = hip<SliceIdsTable>({
         _type: 'sliceIds',
@@ -751,6 +758,56 @@ export class Example {
       },
     },
 
+    trees: {
+      missingChildNodes: (): Rljson => {
+        const result = Example.ok.tree();
+        const treeTable = result.recipesTreeTable as TreesTable;
+
+        treeTable._data.pop(); // Remove child node from _data array
+
+        return hip(result, {
+          updateExistingHashes: true,
+          throwOnWrongHashes: false,
+        });
+      },
+
+      cyclicTree: (): Rljson => {
+        const result = Example.ok.tree();
+        const treeTable = result.recipesTreeTable as TreesTable;
+
+        // Introduce a cycle
+        treeTable._data[0].children = [treeTable._data[0]._hash as string];
+
+        return { recipesTreeTable: treeTable } as Rljson;
+      },
+
+      duplicateChildNodeIds: (): Rljson => {
+        const result = Example.ok.tree();
+        const treeTable = result.recipesTreeTable as TreesTable;
+
+        // Introduce duplicate child node ids
+        const firstChildHash = treeTable._data[1]._hash as string;
+        treeTable._data[0].children = [firstChildHash, firstChildHash];
+
+        return hip(result, {
+          updateExistingHashes: true,
+          throwOnWrongHashes: false,
+        });
+      },
+
+      nonParentWithChildren: (): Rljson => {
+        const result = Example.ok.tree();
+        const treeTable = result.recipesTreeTable as TreesTable;
+
+        // Make a non-parent have children
+        treeTable._data[0].isParent = false;
+
+        return hip(result, {
+          updateExistingHashes: true,
+          throwOnWrongHashes: false,
+        });
+      },
+    },
     layers: {
       missingBase: (): Rljson => {
         const result = Example.ok.complete();

package/dist/tools/time-id.d.ts

@@ -1,3 +1,4 @@
+export type TimeId = string;
 /**
  * Generates a new TimeId.
  * A TimeId has the format "timestamp:xxxx" where:
@@ -5,7 +6,7 @@
  * - "xxxx" is a 4-character unique identifier
  * @returns A new TimeId string
  */
-export declare const timeId: () => string;
+export declare const timeId: () => TimeId;
 /**
  * Checks if a given id is a valid TimeId.
  * A TimeId has the format "timestamp:xxxx" where:
@@ -14,16 +15,16 @@ export declare const timeId: () => string;
  * @param id - The id to check
  * @returns True if the id is a valid TimeId, false otherwise
  */
-export declare const isTimeId: (id: string) => boolean;
+export declare const isTimeId: (id: TimeId) => boolean;
 /**
  * Extracts the timestamp from a TimeId.
  * @param id - The TimeId string
  * @returns The timestamp in milliseconds since epoch, or null if the id is not a valid TimeId
  */
-export declare const getTimeIdTimestamp: (id: string) => number | null;
+export declare const getTimeIdTimestamp: (id: TimeId) => number | null;
 /**
  * Extracts the unique part from a TimeId.
  * @param id - The TimeId string
  * @returns The unique identifier part, or null if the id is not a valid TimeId
  */
-export declare const getTimeIdUniquePart: (id: string) => string | null;
+export declare const getTimeIdUniquePart: (id: TimeId) => string | null;

package/dist/typedefs.d.ts

@@ -26,7 +26,7 @@ export type ColumnKey = JsonKey;
  * - `ids` Tables containing slice ids
  * - `components` Tables containing slice components
  */
-export declare const contentTypes: readonly ["buffets", "cakes", "layers", "sliceIds", "components", "revisions", "tableCfgs", "insertHistory", "edits", "multiEdits", "editHistory", "head"];
+export declare const contentTypes: readonly ["buffets", "cakes", "layers", "sliceIds", "components", "revisions", "tableCfgs", "insertHistory", "edits", "multiEdits", "editHistory", "trees"];
 export type ContentType = (typeof contentTypes)[number];
 /**
  * An example object using the typedefs

package/dist/validate/base-validator.d.ts

@@ -18,6 +18,9 @@ export interface BaseErrors extends Errors {
     rootOrHeadTableHasNoIdColumn?: Json;
     tableCfgHasRootHeadSharedError?: Json;
     refsNotFound?: Json;
+    treeChildNodesNotFound?: Json;
+    treeDuplicateNodeIdsAsSibling?: Json;
+    treeIsNotParentButHasChildren?: Json;
     layerBasesNotFound?: Json;
     layerSliceIdsGivenButNoTable?: Json;
     layerSliceIdsTableNotFound?: Json;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rljson/rljson",
-  "version": "0.0.73",
+  "version": "0.0.74",
   "description": "The RLJSON data format specification",
   "homepage": "https://github.com/rljson/rljson",
   "bugs": "https://github.com/rljson/rljson/issues",
@@ -20,28 +20,28 @@
   ],
   "type": "module",
   "devDependencies": {
-    "@types/node": "^24.10.1",
-    "@typescript-eslint/eslint-plugin": "^8.48.1",
-    "@typescript-eslint/parser": "^8.48.1",
-    "@vitest/coverage-v8": "^4.0.15",
+    "@types/node": "^25.0.9",
+    "@typescript-eslint/eslint-plugin": "^8.53.1",
+    "@typescript-eslint/parser": "^8.53.1",
+    "@vitest/coverage-v8": "^4.0.17",
     "cross-env": "^10.1.0",
-    "eslint": "^9.39.1",
-    "eslint-plugin-jsdoc": "^61.4.1",
+    "eslint": "^9.39.2",
+    "eslint-plugin-jsdoc": "^62.2.0",
     "eslint-plugin-tsdoc": "^0.5.0",
-    "globals": "^16.5.0",
+    "globals": "^17.0.0",
     "jsdoc": "^4.0.5",
     "read-pkg": "^10.0.0",
     "typescript": "~5.9.3",
-    "typescript-eslint": "^8.48.1",
-    "vite": "^7.2.6",
-    "vite-node": "^5.2.0",
+    "typescript-eslint": "^8.53.1",
+    "vite": "^7.3.1",
+    "vite-node": "^5.3.0",
     "vite-plugin-dts": "^4.5.4",
-    "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^4.0.15",
+    "vite-tsconfig-paths": "^6.0.4",
+    "vitest": "^4.0.17",
     "vitest-dom": "^0.1.1"
   },
   "dependencies": {
-    "@rljson/hash": "^0.0.17",
+    "@rljson/hash": "^0.0.18",
     "@rljson/json": "^0.0.23",
     "nanoid": "^5.1.6"
   },

package/dist/content/head.d.ts

@@ -1,10 +0,0 @@
-import { Json } from '@rljson/json';
-import { RljsonTable } from '../rljson.ts';
-import { TableCfg } from './table-cfg.ts';
-export interface Head extends Json {
-    timeId: string;
-    cakeRef: string;
-    _hash: string;
-}
-export type HeadsTable = RljsonTable<Head, 'head'>;
-export declare const createHeadsTableCfg: (cakeKey: string) => TableCfg;