dirvi-lib 0.6.1 → 0.7.1

package/dist/index.d.ts

@@ -5,6 +5,4 @@ export * from './tree-surfer-ui/domain/input-state.js';
 export * from './tree-surfer-ui/domain/intent.js';
 export * from './tree-surfer-ui/domain/user-input.js';
 export * from './tree-surfer/index.js';
-export * from './domain/posix-node.js';
-export * from './domain/unix-path.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sDAAsD,CAAC;AACrE,cAAc,kDAAkD,CAAC;AAEjE,cAAc,mCAAmC,CAAC;AAClD,cAAc,wCAAwC,CAAC;AACvD,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC;AAEtD,cAAc,wBAAwB,CAAC;AAEvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sDAAsD,CAAC;AACrE,cAAc,kDAAkD,CAAC;AAEjE,cAAc,mCAAmC,CAAC;AAClD,cAAc,wCAAwC,CAAC;AACvD,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC;AAEtD,cAAc,wBAAwB,CAAC"}

package/dist/index.js

@@ -5,5 +5,3 @@ export * from './tree-surfer-ui/domain/input-state.js';
 export * from './tree-surfer-ui/domain/intent.js';
 export * from './tree-surfer-ui/domain/user-input.js';
 export * from './tree-surfer/index.js';
-export * from './domain/posix-node.js';
-export * from './domain/unix-path.js';

package/dist/tree-surfer/cursor.d.ts

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 export declare const CursorKind: {
     readonly Entry: "entry";
     readonly Fold: "fold";
@@ -13,6 +14,14 @@ export type CursorFold<Id> = {
     parentPath: readonly Id[];
 };
 export type Cursor<Id> = CursorEntry<Id> | CursorFold<Id>;
+export declare function createCursorSchema<IdSchema extends z.ZodTypeAny>(idSchema: IdSchema): z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"entry">;
+    parentPath: z.ZodArray<IdSchema>;
+    entryId: IdSchema;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"fold">;
+    parentPath: z.ZodArray<IdSchema>;
+}, z.core.$strip>], "kind">;
 export type CursorApi<Id> = {
     isEntry(cursor: Cursor<Id>): cursor is CursorEntry<Id>;
     isFold(cursor: Cursor<Id>): cursor is CursorFold<Id>;

package/dist/tree-surfer/cursor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../src/tree-surfer/cursor.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;;;CAGb,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC;AAEtE,MAAM,MAAM,WAAW,CAAC,EAAE,IAAI;IAC5B,IAAI,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IAC9B,UAAU,EAAE,SAAS,EAAE,EAAE,CAAC;IAC1B,OAAO,EAAE,EAAE,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,UAAU,CAAC,EAAE,IAAI;IAC3B,IAAI,EAAE,OAAO,UAAU,CAAC,IAAI,CAAC;IAC7B,UAAU,EAAE,SAAS,EAAE,EAAE,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,MAAM,CAAC,EAAE,IAAI,WAAW,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,EAAE,CAAC,CAAC;AAE1D,MAAM,MAAM,SAAS,CAAC,EAAE,IAAI;IAC1B,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,MAAM,IAAI,WAAW,CAAC,EAAE,CAAC,CAAC;IAEvD,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,MAAM,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC;IAErD,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;IAEpD,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,GAAG,SAAS,CAAC;IAE9C,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC;CAC/E,CAAC;AAEF,wBAAgB,eAAe,CAAC,EAAE,KAAK,SAAS,CAAC,EAAE,CAAC,CA0CnD"}
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../src/tree-surfer/cursor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,UAAU;;;CAGb,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC;AAEtE,MAAM,MAAM,WAAW,CAAC,EAAE,IAAI;IAC5B,IAAI,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IAC9B,UAAU,EAAE,SAAS,EAAE,EAAE,CAAC;IAC1B,OAAO,EAAE,EAAE,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,UAAU,CAAC,EAAE,IAAI;IAC3B,IAAI,EAAE,OAAO,UAAU,CAAC,IAAI,CAAC;IAC7B,UAAU,EAAE,SAAS,EAAE,EAAE,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,MAAM,CAAC,EAAE,IAAI,WAAW,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,EAAE,CAAC,CAAC;AAE1D,wBAAgB,kBAAkB,CAAC,QAAQ,SAAS,CAAC,CAAC,UAAU,EAC9D,QAAQ,EAAE,QAAQ;;;;;;;4BAgBnB;AAED,MAAM,MAAM,SAAS,CAAC,EAAE,IAAI;IAC1B,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,MAAM,IAAI,WAAW,CAAC,EAAE,CAAC,CAAC;IAEvD,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,MAAM,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC;IAErD,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;IAEpD,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,GAAG,SAAS,CAAC;IAE9C,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC;CAC/E,CAAC;AAEF,wBAAgB,eAAe,CAAC,EAAE,KAAK,SAAS,CAAC,EAAE,CAAC,CA0CnD"}

package/dist/tree-surfer/cursor.js

@@ -1,7 +1,22 @@
+import { z } from 'zod';
 export const CursorKind = {
     Entry: 'entry',
     Fold: 'fold',
 };
+export function createCursorSchema(idSchema) {
+    const parentPathSchema = z.array(idSchema);
+    return z.discriminatedUnion('kind', [
+        z.object({
+            kind: z.literal(CursorKind.Entry),
+            parentPath: parentPathSchema,
+            entryId: idSchema,
+        }),
+        z.object({
+            kind: z.literal(CursorKind.Fold),
+            parentPath: parentPathSchema,
+        }),
+    ]);
+}
 export function createCursorApi() {
     const cursorApi = {
         isEntry(cursor) {

package/dist/tree-surfer/fold-node/fold-node.schema.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import type { FoldNode, FoldNodeRoot } from './fold-node.types.js';
+import { SerializableKey } from '../tree-node/tree-node.types.js';
+export declare function createFoldNodeSchemas<Id extends SerializableKey>(idSchema: z.ZodType<Id>): {
+    foldNodeSchema: z.ZodType<FoldNode<Id>, unknown, z.core.$ZodTypeInternals<FoldNode<Id>, unknown>>;
+    foldNodeRootSchema: z.ZodType<FoldNodeRoot<Id>, unknown, z.core.$ZodTypeInternals<FoldNodeRoot<Id>, unknown>>;
+};
+//# sourceMappingURL=fold-node.schema.d.ts.map

package/dist/tree-surfer/fold-node/fold-node.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fold-node.schema.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/fold-node/fold-node.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAElE,wBAAgB,qBAAqB,CAAC,EAAE,SAAS,eAAe,EAC9D,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;;;EAsBxB"}

package/dist/tree-surfer/fold-node/fold-node.schema.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export function createFoldNodeSchemas(idSchema) {
+    const foldNodeSchema = z.lazy(() => z.object({
+        id: idSchema,
+        children: z.array(foldNodeSchema),
+        folds: z.array(idSchema).transform((ids) => new Set(ids)),
+    }));
+    const foldNodeRootSchema = z.object({
+        children: z.array(foldNodeSchema),
+        folds: z.array(idSchema).transform((ids) => new Set(ids)),
+    });
+    return {
+        foldNodeSchema,
+        foldNodeRootSchema,
+    };
+}

package/dist/tree-surfer/fold-node/fold-node.types.d.ts

@@ -1,4 +1,4 @@
-import { TreeNodeModifier, TreeNodeSelector } from '../tree-node/tree-node.types.js';
+import { SerializableKey } from '../tree-node/tree-node.types.js';
 /**
  * The whole fold state for a tree-node tree.
  *
@@ -8,7 +8,7 @@ import { TreeNodeModifier, TreeNodeSelector } from '../tree-node/tree-node.types
  * `folds` contains the IDs folded at this root. Fold order is not
  * represented here; the buffer tree determines entry order.
  */
-export type FoldNodeRoot<Id extends PropertyKey> = {
+export type FoldNodeRoot<Id extends SerializableKey> = {
     children: FoldNode<Id>[];
     folds: ReadonlySet<Id>;
 };
@@ -25,7 +25,7 @@ export type FoldNodeRoot<Id extends PropertyKey> = {
  * The type is structurally compatible with `TreeNode`, allowing the shared
  * `TreeNodeApi` to be used for path traversal and immutable updates.
  */
-export type FoldNode<Id extends PropertyKey> = FoldNodeRoot<Id> & {
+export type FoldNode<Id extends SerializableKey> = FoldNodeRoot<Id> & {
     id: Id;
 };
 /**
@@ -36,7 +36,7 @@ export type FoldNode<Id extends PropertyKey> = FoldNodeRoot<Id> & {
  * paths that already exist. Creation of missing fold paths belongs to
  * `FoldNodeService`.
  */
-export type FoldNodeApi<Id extends PropertyKey> = {
+export type FoldNodeApi<Id extends SerializableKey> = {
     /**
      * Returns the children of either the fold root or a fold node.
      */
@@ -48,11 +48,11 @@ export type FoldNodeApi<Id extends PropertyKey> = {
     /**
      * Selects a fold node at a path below the root.
      */
-    getAtPath<Result>(rootNode: FoldNodeRoot<Id>, path: Id[], selector: TreeNodeSelector<FoldNode<Id>, Result>): Result | undefined;
+    getAtPath<Result>(rootNode: FoldNodeRoot<Id>, path: Id[], selector: (node: FoldNode<Id>) => Result): Result | undefined;
     /**
      * Immutably modifies a fold node at a path below the root.
      */
-    modifyAtPath(rootNode: FoldNodeRoot<Id>, path: Id[], modifier: TreeNodeModifier<FoldNode<Id>>): FoldNodeRoot<Id> | undefined;
+    modifyAtPath(rootNode: FoldNodeRoot<Id>, path: Id[], modifier: (node: FoldNode<Id>) => FoldNode<Id> | undefined): FoldNodeRoot<Id> | undefined;
 };
 /**
  * Semantic operations for managing folded buffer entries.
@@ -60,7 +60,7 @@ export type FoldNodeApi<Id extends PropertyKey> = {
  * Unlike `FoldNodeApi`, the service may create missing fold paths when
  * adding a fold. This allows an empty root to be populated lazily.
  */
-export type FoldNodeService<Id extends PropertyKey> = {
+export type FoldNodeService<Id extends SerializableKey> = {
     createEmptyRoot(): FoldNodeRoot<Id>;
     getIfEntryFoldedAtPath(rootNode: FoldNodeRoot<Id>, path: Id[], entryId: Id): boolean;
     addFoldedEntryAtPath(rootNode: FoldNodeRoot<Id>, path: Id[], entryId: Id): FoldNodeRoot<Id> | undefined;

package/dist/tree-surfer/fold-node/fold-node.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fold-node.types.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/fold-node/fold-node.types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,iCAAiC,CAAC;AAEzC;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,CAAC,EAAE,SAAS,WAAW,IAAI;IACjD,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;IACzB,KAAK,EAAE,WAAW,CAAC,EAAE,CAAC,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,QAAQ,CAAC,EAAE,SAAS,WAAW,IAAI,YAAY,CAAC,EAAE,CAAC,GAAG;IAChE,EAAE,EAAE,EAAE,CAAC;CACR,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CAAC,EAAE,SAAS,WAAW,IAAI;IAChD;;OAEG;IACH,WAAW,CAAC,IAAI,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;IAE3E;;OAEG;IACH,YAAY,CACV,IAAI,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC,EACrC,EAAE,EAAE,EAAE,GACL,QAAQ,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IAE5B;;OAEG;IACH,SAAS,CAAC,MAAM,EACd,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,EACV,QAAQ,EAAE,gBAAgB,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,GAC/C,MAAM,GAAG,SAAS,CAAC;IAEtB;;OAEG;IACH,YAAY,CACV,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,EACV,QAAQ,EAAE,gBAAgB,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,GACvC,YAAY,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;CACjC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,eAAe,CAAC,EAAE,SAAS,WAAW,IAAI;IACpD,eAAe,IAAI,YAAY,CAAC,EAAE,CAAC,CAAC;IAEpC,sBAAsB,CACpB,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,EACV,OAAO,EAAE,EAAE,GACV,OAAO,CAAC;IAEX,oBAAoB,CAClB,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,EACV,OAAO,EAAE,EAAE,GACV,YAAY,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IAEhC,uBAAuB,CACrB,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,EACV,OAAO,EAAE,EAAE,GACV,YAAY,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IAEhC,wBAAwB,CACtB,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,GACT,YAAY,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;CACjC,CAAC"}
+{"version":3,"file":"fold-node.types.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/fold-node/fold-node.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAElE;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,CAAC,EAAE,SAAS,eAAe,IAAI;IACrD,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;IACzB,KAAK,EAAE,WAAW,CAAC,EAAE,CAAC,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,QAAQ,CAAC,EAAE,SAAS,eAAe,IAAI,YAAY,CAAC,EAAE,CAAC,GAAG;IACpE,EAAE,EAAE,EAAE,CAAC;CACR,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CAAC,EAAE,SAAS,eAAe,IAAI;IACpD;;OAEG;IACH,WAAW,CAAC,IAAI,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;IAE3E;;OAEG;IACH,YAAY,CACV,IAAI,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC,EACrC,EAAE,EAAE,EAAE,GACL,QAAQ,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IAE5B;;OAEG;IACH,SAAS,CAAC,MAAM,EACd,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,EACV,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,MAAM,GACvC,MAAM,GAAG,SAAS,CAAC;IAEtB;;OAEG;IACH,YAAY,CACV,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,EACV,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,QAAQ,CAAC,EAAE,CAAC,GAAG,SAAS,GACzD,YAAY,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;CACjC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,eAAe,CAAC,EAAE,SAAS,eAAe,IAAI;IACxD,eAAe,IAAI,YAAY,CAAC,EAAE,CAAC,CAAC;IAEpC,sBAAsB,CACpB,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,EACV,OAAO,EAAE,EAAE,GACV,OAAO,CAAC;IAEX,oBAAoB,CAClB,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,EACV,OAAO,EAAE,EAAE,GACV,YAAY,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IAEhC,uBAAuB,CACrB,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,EACV,OAAO,EAAE,EAAE,GACV,YAAY,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IAEhC,wBAAwB,CACtB,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,GACT,YAAY,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;CACjC,CAAC"}

package/dist/tree-surfer/index.d.ts

@@ -1,9 +1,13 @@
 export * from './fold-node/fold-node.impl.js';
+export * from './fold-node/fold-node.schema.js';
 export * from './fold-node/fold-node.types.js';
 export * from './nav-node/nav-node.impl.js';
 export * from './nav-node/nav-node.types.js';
 export * from './tree-node/tree-node.impl.js';
+export * from './tree-node/tree-node.schemas.js';
 export * from './tree-node/tree-node.types.js';
 export * from './cursor.js';
-export * from './state.js';
+export * from './state/state.impl.js';
+export * from './state/state.schemas.js';
+export * from './state/state.types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/tree-surfer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tree-surfer/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAE/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAE7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAE/C,cAAc,aAAa,CAAC;AAE5B,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tree-surfer/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAE/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAE7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,gCAAgC,CAAC;AAE/C,cAAc,aAAa,CAAC;AAE5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC"}

package/dist/tree-surfer/index.js

@@ -1,8 +1,12 @@
 export * from './fold-node/fold-node.impl.js';
+export * from './fold-node/fold-node.schema.js';
 export * from './fold-node/fold-node.types.js';
 export * from './nav-node/nav-node.impl.js';
 export * from './nav-node/nav-node.types.js';
 export * from './tree-node/tree-node.impl.js';
+export * from './tree-node/tree-node.schemas.js';
 export * from './tree-node/tree-node.types.js';
 export * from './cursor.js';
-export * from './state.js';
+export * from './state/state.impl.js';
+export * from './state/state.schemas.js';
+export * from './state/state.types.js';

package/dist/tree-surfer/state/state.impl.d.ts

@@ -0,0 +1,7 @@
+import { SerializableKey, TreeNode, TreeNodeApi } from '../tree-node/tree-node.types.js';
+import { FoldNodeApi } from '../fold-node/fold-node.types.js';
+import { CursorApi } from '../cursor.js';
+import { NavNodeApi } from '../nav-node/nav-node.types.js';
+import { StateApi } from './state.types.js';
+export declare function createStateApi<Id extends SerializableKey, Node extends TreeNode<Id, Node>>(treeNodeApi: TreeNodeApi<Id, Node>, foldNodeApi: FoldNodeApi<Id>, cursorApi: CursorApi<Id>, navNodeApi: NavNodeApi<Id, Node>): StateApi<Id, Node>;
+//# sourceMappingURL=state.impl.d.ts.map

package/dist/tree-surfer/state/state.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.impl.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/state/state.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACzF,OAAO,EAAY,WAAW,EAAgB,MAAM,iCAAiC,CAAC;AACtF,OAAO,EAAU,SAAS,EAAc,MAAM,cAAc,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAS,MAAM,kBAAkB,CAAC;AAEnD,wBAAgB,cAAc,CAC5B,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,EAE/B,WAAW,EAAE,WAAW,CAAC,EAAE,EAAE,IAAI,CAAC,EAClC,WAAW,EAAE,WAAW,CAAC,EAAE,CAAC,EAC5B,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC,EACxB,UAAU,EAAE,UAAU,CAAC,EAAE,EAAE,IAAI,CAAC,GAC/B,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,CA6IpB"}

package/dist/tree-surfer/{state.js → state/state.impl.js}

@@ -1,38 +1,20 @@
-import { CursorKind } from './cursor.js';
+import { CursorKind } from '../cursor.js';
 export function createStateApi(treeNodeApi, foldNodeApi, cursorApi, navNodeApi) {
-    // Helpers
     /**
-     * Create a new buffer and fold node at this level.
+     * Create a new buffer and fold node at a level.
      *
-     * Works on fold root and child level through the generic.
+     * Works on fold root and descendant fold nodes using the generic.
      */
-    async function reload(oldBuffer, oldFoldNode, // Can be FoldNode too
-    parentPath, loadBranches) {
-        let newBufferAtRoot = await loadBranches(parentPath);
+    async function reload(oldBuffer, oldFoldNode, parentPath, loadBranches) {
+        let newBuffer = await loadBranches(parentPath);
         let newFoldNode = oldFoldNode; // Start with assumption of no changes
-        /**
-         * Reload descendants that were already loaded in the old buffer.
-         *
-         * Fold membership is represented by IDs in `folds`, so it remains
-         * valid across a reload without rebuilding an entry array.
-         */
         for (const oldEntry of oldBuffer) {
-            // If it wasn't an open branch, then there's no need to reload descendants.
-            // Either the new entry is a leaf or an unopen branch.
             if (!treeNodeApi.isBranch(oldEntry) ||
                 !treeNodeApi.isOpenBranch(oldEntry)) {
                 continue;
             }
-            // Get the entry being updated, in the new buffer
-            const newEntry = treeNodeApi.getAtPath(newBufferAtRoot, [oldEntry.id], (entry) => entry);
-            // If it doesn't exist (an open branch was deleted) then move on
-            if (newEntry === undefined) {
-                continue;
-            }
-            // The old entry may have changed into a leaf.
-            // A newly loaded branch is normally closed here because loadBranches
-            // returns flat entries, and the descendants are to be attached below.
-            if (!treeNodeApi.isBranch(newEntry)) {
+            const newEntry = treeNodeApi.getAtPath(newBuffer, [oldEntry.id], (entry) => entry);
+            if (newEntry === undefined || !treeNodeApi.isBranch(newEntry)) {
                 continue;
             }
             const oldChildFoldNode = oldFoldNode === undefined
@@ -40,7 +22,7 @@ export function createStateApi(treeNodeApi, foldNodeApi, cursorApi, navNodeApi)
                 : foldNodeApi.getChildById(oldFoldNode, oldEntry.id);
             const entryPath = [...parentPath, oldEntry.id];
             const reloadedChild = await reload([...treeNodeApi.getChildren(oldEntry)], oldChildFoldNode, entryPath, loadBranches);
-            const updatedBuffer = treeNodeApi.modifyAtPath(newBufferAtRoot, [oldEntry.id], (entry) => {
+            const updatedBuffer = treeNodeApi.modifyAtPath(newBuffer, [oldEntry.id], (entry) => {
                 // The entry may be closed: loadBranches normally returns branches
                 // with `branches: null`. We are turning it back into an open branch.
                 if (!treeNodeApi.isBranch(entry)) {
@@ -48,15 +30,15 @@ export function createStateApi(treeNodeApi, foldNodeApi, cursorApi, navNodeApi)
                 }
                 return {
                     ...entry,
-                    branches: reloadedChild.buffer,
+                    children: reloadedChild.buffer,
                 };
             });
             if (updatedBuffer !== undefined) {
-                newBufferAtRoot = updatedBuffer;
+                newBuffer = updatedBuffer;
             }
         }
         return {
-            buffer: newBufferAtRoot,
+            buffer: newBuffer,
             foldNode: newFoldNode,
         };
     }
@@ -84,8 +66,8 @@ export function createStateApi(treeNodeApi, foldNodeApi, cursorApi, navNodeApi)
             }
             return treeNodeApi.getAtPath(state.buffer, path, (node) => node);
         },
-        async resync(oldState, loadBranches) {
-            const reloaded = await reload(oldState.buffer, oldState.foldNode, [], loadBranches);
+        async resync(oldState, loadChildren) {
+            const reloaded = await reload(oldState.buffer, oldState.foldNode, [], loadChildren);
             /*
              * `oldState.foldNode` is always present. At the root reload starts with
              * that node, so `reloaded.foldNode` should also always be present.

package/dist/tree-surfer/state/state.schemas.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { SerializableKey, TreeNode } from '../tree-node/tree-node.types.js';
+import { State } from './state.types.js';
+export declare function createStateSchema<Id extends SerializableKey, Node extends TreeNode<Id, Node>>(bufferNodeSchema: z.ZodType<Node>, foldNodeRootSchema: z.ZodType<State<Id, Node>['foldNode']>, cursorSchema: z.ZodType<State<Id, Node>['cursor']>): z.ZodObject<{
+    buffer: z.ZodArray<z.ZodType<Node, unknown, z.core.$ZodTypeInternals<Node, unknown>>>;
+    foldNode: z.ZodType<import("../index.js").FoldNodeRoot<Id>, unknown, z.core.$ZodTypeInternals<import("../index.js").FoldNodeRoot<Id>, unknown>>;
+    cursor: z.ZodType<import("../cursor.js").Cursor<Id>, unknown, z.core.$ZodTypeInternals<import("../cursor.js").Cursor<Id>, unknown>>;
+}, z.core.$strip>;
+//# sourceMappingURL=state.schemas.d.ts.map

package/dist/tree-surfer/state/state.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.schemas.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/state/state.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAC5E,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,wBAAgB,iBAAiB,CAC/B,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,EAE/B,gBAAgB,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EACjC,kBAAkB,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,UAAU,CAAC,CAAC,EAC1D,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;;;;kBAOnD"}

package/dist/tree-surfer/state/state.schemas.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export function createStateSchema(bufferNodeSchema, foldNodeRootSchema, cursorSchema) {
+    return z.object({
+        buffer: z.array(bufferNodeSchema),
+        foldNode: foldNodeRootSchema,
+        cursor: cursorSchema,
+    });
+}

package/dist/tree-surfer/state/state.types.d.ts

@@ -0,0 +1,17 @@
+import { Cursor } from '../cursor.js';
+import { SerializableKey, TreeNode } from '../tree-node/tree-node.types.js';
+import { FoldNodeRoot } from '../fold-node/fold-node.types.js';
+export type State<Id extends SerializableKey, Node extends TreeNode<Id, Node>> = {
+    buffer: Node[];
+    foldNode: FoldNodeRoot<Id>;
+    cursor: Cursor<Id>;
+};
+export type StateApi<Id extends SerializableKey, Node extends TreeNode<Id, Node>> = {
+    getNodeAtCursor(state: State<Id, Node>): Node | undefined;
+    /**
+     * Reloads the root and all descendant branches that were loaded in the
+     * previous state.
+     */
+    resync(oldState: State<Id, Node>, loadBranches: (path: Id[]) => Promise<Node[]>): Promise<State<Id, Node>>;
+};
+//# sourceMappingURL=state.types.d.ts.map

package/dist/tree-surfer/state/state.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.types.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/state/state.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EACL,eAAe,EACf,QAAQ,EACT,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,YAAY,EACb,MAAM,iCAAiC,CAAC;AAEzC,MAAM,MAAM,KAAK,CACf,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,IAC7B;IACF,MAAM,EAAE,IAAI,EAAE,CAAC;IACf,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,QAAQ,CAClB,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,IAC7B;IACF,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;IAE1D;;;OAGG;IACH,MAAM,CACJ,QAAQ,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,EACzB,YAAY,EAAE,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,IAAI,EAAE,CAAC,GAC5C,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC;CAC7B,CAAC"}

package/dist/tree-surfer/state/state.types.js

@@ -0,0 +1 @@
+export {};

package/dist/tree-surfer/tree-node/tree-node.arb.d.ts

@@ -1,31 +1,100 @@
 import * as fc from 'fast-check';
 import type { TreeNode } from './tree-node.types.js';
-export type StringNode = TreeNode<string, StringNode>;
-export type PathEntry = {
-    path: string[];
+/**
+ * The ID type used by the generated test trees.
+ *
+ * Short strings keep generated counterexamples readable.
+ */
+type TestNodeId = string;
+/**
+ * Generates valid string IDs for test nodes. Note that the API just does
+ * comparisons on the IDs so we can safely restrict to any subset.
+ */
+export declare const testIdArb: fc.Arbitrary<string>;
+/**
+ * Tree node whose IDs are strings, without additional domain properties.
+ */
+export type StringNode = TreeNode<TestNodeId, StringNode>;
+type Path = TestNodeId[];
+type NodeAtPath = {
+    path: Path;
     node: StringNode;
 };
-export type GeneratedNode = {
+type NodeWithReachableNodes = {
     node: StringNode;
-    pathEntries: PathEntry[];
+    reachableNodes: NodeAtPath[];
 };
-export declare const idArb: fc.Arbitrary<string>;
-export declare const generatedNodeArb: fc.Arbitrary<GeneratedNode>;
-export declare const generatedNodesArrayArb: fc.Arbitrary<GeneratedNode[]>;
-export declare const forestAndPathsArb: fc.Arbitrary<{
+/**
+ * Generates a leaf node.
+ */
+export declare const generatedLeafNodeArb: fc.Arbitrary<NodeWithReachableNodes>;
+/**
+ * Generates a closed branch.
+ */
+export declare const generatedClosedBranchNodeArb: fc.Arbitrary<NodeWithReachableNodes>;
+/**
+ * Generates a leaf, an open branch, or a closed branch.
+ *
+ * Open branches have unique child IDs. Root IDs are made unique separately
+ * when generating a forest.
+ *
+ * The weighted choice gives recursive open branches a geometric dropoff.
+ */
+export declare const generatedNodeArb: fc.Arbitrary<NodeWithReachableNodes>;
+/**
+ * Generates an array of generated nodes with unique IDs suitable for use as
+ * the root of a forest.
+ *
+ * Root IDs must be unique because paths begin by looking up an ID in this
+ * array.
+ */
+export declare const generatedNodesArrayArb: fc.Arbitrary<NodeWithReachableNodes[]>;
+/**
+ * An array of root-level nodes and all paths that can be resolved through
+ * those nodes.
+ *
+ * Paths through closed branches stop at the closed branch because its
+ * descendants are not loaded.
+ */
+export declare const nodesArrayAndPathsArb: fc.Arbitrary<{
     entries: any[];
-    pathEntries: PathEntry[];
+    pathEntries: NodeAtPath[];
 }>;
-export declare const forestAndPathAndExpectedArb: fc.Arbitrary<{
+/**
+ * Generates root-level nodes and a path to one of their reachable nodes.
+ *
+ * Every generated path is valid for `getAtPath`; unreachable paths are not
+ * included.
+ */
+export declare const nodesArrayAndPathAndExpectedArb: fc.Arbitrary<{
     entries: any[];
-    path: string[];
+    path: Path;
     expected: any;
 }>;
+/**
+ * Generates root-level nodes and a path to one of their branch nodes.
+ *
+ * Both open and closed branches are included. A path to a closed branch is
+ * valid, but a path through a closed branch cannot reach any descendants.
+ */
 export declare const nodesArrayAndBranchPathArb: fc.Arbitrary<{
     entries: any[];
-    path: string[];
+    path: Path;
     expected: any;
 }>;
+/**
+ * Generates a new array of loaded child nodes.
+ *
+ * The generated nodes have unique IDs, making the result suitable for use as
+ * the children of an open branch.
+ */
 export declare const newBranchesArb: fc.Arbitrary<any[]>;
+/**
+ * Generates either a new array of loaded child nodes or `null`.
+ *
+ * An array represents an open branch, including an open branch with no
+ * children. `null` represents a closed branch.
+ */
 export declare const newBranchesOrNullArb: fc.Arbitrary<any[] | null>;
+export {};
 //# sourceMappingURL=tree-node.arb.d.ts.map

package/dist/tree-surfer/tree-node/tree-node.arb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tree-node.arb.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/tree-node/tree-node.arb.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAGrD,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAEtD,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,UAAU,CAAC;IACjB,WAAW,EAAE,SAAS,EAAE,CAAC;CAC1B,CAAC;AAEF,eAAO,MAAM,KAAK,sBAGhB,CAAC;AAEH,eAAO,MAAM,gBAAgB,EAAE,EAAE,CAAC,SAAS,CAAC,aAAa,CA8DnD,CAAC;AAEP,eAAO,MAAM,sBAAsB,+BAIjC,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;EAK7B,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;EAQrC,CAAC;AAEJ,eAAO,MAAM,0BAA0B;;;;EAYpC,CAAC;AAEJ,eAAO,MAAM,cAAc,qBAE1B,CAAC;AAEF,eAAO,MAAM,oBAAoB,4BAA8C,CAAC"}
+{"version":3,"file":"tree-node.arb.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/tree-node/tree-node.arb.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD;;;;GAIG;AACH,KAAK,UAAU,GAAG,MAAM,CAAC;AASzB;;;GAGG;AACH,eAAO,MAAM,SAAS,sBAIpB,CAAC;AAEH;;GAEG;AAEH,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;AAC1D,KAAK,IAAI,GAAG,UAAU,EAAE,CAAC;AAEzB,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,IAAI,CAAC;IACX,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,IAAI,EAAE,UAAU,CAAC;IACjB,cAAc,EAAE,UAAU,EAAE,CAAC;CAC9B,CAAC;AAyEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,sCAEhC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,4BAA4B,sCAExC,CAAC;AAaF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE,EAAE,CAAC,SAAS,CAAC,sBAAsB,CA0C5D,CAAC;AAEP;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,wCAIjC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB;;;EAOjC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B;;;;EAQzC,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B;;;;EAcpC,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,cAAc,qBAE1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,4BAGhC,CAAC"}

package/dist/tree-surfer/tree-node/tree-node.arb.debug.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tree-node.arb.debug.d.ts.map

package/dist/tree-surfer/tree-node/tree-node.arb.debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-node.arb.debug.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/tree-node/tree-node.arb.debug.ts"],"names":[],"mappings":""}

package/dist/tree-surfer/tree-node/tree-node.arb.debug.js

@@ -0,0 +1,34 @@
+import { describe, it } from 'vitest';
+import * as fc from 'fast-check';
+import { generatedNodeArb, generatedNodesArrayArb, } from './tree-node.arb.js';
+/**
+ * Used for looking at the tree distributions generated by the arbs.
+ */
+describe('print generated tree node arbitraries', () => {
+    it.only('generated nodes', () => {
+        const samples = fc.sample(generatedNodeArb, {
+            numRuns: 10,
+            seed: 12345,
+        });
+        for (const [index, generated] of samples.entries()) {
+            console.log(`\n--- node ${index + 1} ---`);
+            console.dir(generated.node, {
+                depth: Infinity,
+                colors: false,
+            });
+        }
+    });
+    it.only('generated root-level node arrays', () => {
+        const samples = fc.sample(generatedNodesArrayArb, {
+            numRuns: 5,
+            seed: 12345,
+        });
+        for (const [index, generatedNodes] of samples.entries()) {
+            console.log(`\n--- root array ${index + 1} ---`);
+            console.dir(generatedNodes.map(({ node }) => node), {
+                depth: Infinity,
+                colors: false,
+            });
+        }
+    });
+});