@mak-98/posix-fs-dirvi-app 0.11.0-beta.2 → 0.11.0-beta.4

package/dist/domain/posix-tree.d.ts

@@ -1,12 +1,20 @@
 import { z } from 'zod';
-import { NavNode, SerializableKey, State, TreeNode, TreeNodeModel, Folds, FoldsModel, Cursor, StateModel } from 'dirvi-lib';
+import type { TreeNode, TreeNodeApi } from 'dirvi-lib';
 import { UnixPath } from './unix-path.js';
-export declare const PosixNameSchema: z.ZodPipe<z.ZodType<SerializableKey, unknown, z.core.$ZodTypeInternals<SerializableKey, unknown>>, z.ZodString>;
-export type PosixName = z.output<typeof PosixNameSchema>;
+/**
+ * A JavaScript-string representation of a non-special POSIX filename.
+ *
+ * Validates invariants needed for a tree entry ID, not full POSIX compatibility.
+ */
+export declare const posixFilenameSchema: z.ZodString;
+/**
+ * `Id` type used for posix-fs-dirvi-app.
+ */
+export type PosixId = z.output<typeof posixFilenameSchema>;
 /**
  * POSIX-specific meaning attached to a tree node.
  */
-export type PosixEntry = Readonly<{
+export type PosixValue = Readonly<{
     kind: 'file';
 }> | Readonly<{
     kind: 'symlink';
@@ -14,51 +22,13 @@ export type PosixEntry = Readonly<{
 }> | Readonly<{
     kind: 'directory';
 }>;
-export declare const PosixEntrySchema: z.ZodType<PosixEntry>;
-/**
- * An opaque tree whose IDs are POSIX entry names and whose values describe
- * POSIX entry semantics.
- */
-export type PosixTreeNode = TreeNode<PosixName, PosixEntry>;
-export declare const PosixTreeNodeApi: Readonly<{
-    createLeaf(id: string, value: PosixEntry): TreeNode<string, PosixEntry>;
-    createUnloadedBranch(id: string, value: PosixEntry): TreeNode<string, PosixEntry>;
-    createLoadedBranch(id: string, value: PosixEntry, children: Iterable<TreeNode<string, PosixEntry>>): TreeNode<string, PosixEntry> | undefined;
-    id(node: TreeNode<string, PosixEntry>): string;
-    value(node: TreeNode<string, PosixEntry>): PosixEntry;
-    kind(node: TreeNode<string, PosixEntry>): import("dirvi-lib").TreeNodeKind;
-    match<Result>(node: TreeNode<string, PosixEntry>, handlers: Readonly<{
-        leaf: (node: Readonly<{
-            id: string;
-            value: PosixEntry;
-        }>) => Result;
-        unloadedBranch: (node: Readonly<{
-            id: string;
-            value: PosixEntry;
-        }>) => Result;
-        loadedBranch: (node: Readonly<{
-            id: string;
-            value: PosixEntry;
-            children: Iterable<TreeNode<string, PosixEntry>>;
-        }>) => Result;
-    }>): Result;
-    getLoadedChildren(node: TreeNode<string, PosixEntry>): Iterable<TreeNode<string, PosixEntry>> | undefined;
-    findChildById(node: TreeNode<string, PosixEntry>, id: string): TreeNode<string, PosixEntry> | undefined;
-    withValue(node: TreeNode<string, PosixEntry>, value: PosixEntry): TreeNode<string, PosixEntry>;
-    toLeaf(node: TreeNode<string, PosixEntry>): TreeNode<string, PosixEntry>;
-    toUnloadedBranch(node: TreeNode<string, PosixEntry>): TreeNode<string, PosixEntry>;
-    withLoadedChildren(node: TreeNode<string, PosixEntry>, children: Iterable<TreeNode<string, PosixEntry>>): TreeNode<string, PosixEntry> | undefined;
-    findAtPath(root: TreeNode<string, PosixEntry>, path: readonly string[]): TreeNode<string, PosixEntry> | undefined;
-    selectAtPath<Result>(root: TreeNode<string, PosixEntry>, path: readonly string[], selector: (node: TreeNode<string, PosixEntry>) => Result): Result | undefined;
-    updateAtPath(root: TreeNode<string, PosixEntry>, path: readonly string[], update: (node: TreeNode<string, PosixEntry>) => TreeNode<string, PosixEntry> | undefined): TreeNode<string, PosixEntry> | undefined;
-    toModel(node: TreeNode<string, PosixEntry>): TreeNodeModel<string, PosixEntry>;
-    fromModel(model: TreeNodeModel<string, PosixEntry>): TreeNode<string, PosixEntry> | undefined;
-}>;
-export declare const PosixTreeNode: {
-    readonly file: (name: PosixName) => PosixTreeNode;
-    readonly symlink: (name: PosixName, target: UnixPath) => PosixTreeNode;
-    readonly unloadedDirectory: (name: PosixName) => PosixTreeNode;
-    readonly loadedDirectory: (name: PosixName, children: Iterable<PosixTreeNode>) => PosixTreeNode | undefined;
+export type PosixTreeNode = TreeNode<PosixId, PosixValue>;
+export declare const posixValueSchema: z.ZodType<PosixValue>;
+export declare function createConstructors(posixTreeNodeApi: TreeNodeApi<PosixId, PosixValue>): {
+    readonly file: (name: PosixId) => PosixTreeNode;
+    readonly symlink: (name: PosixId, target: UnixPath) => PosixTreeNode;
+    readonly unloadedDirectory: (name: PosixId) => PosixTreeNode;
+    readonly loadedDirectory: (name: PosixId, children: Iterable<PosixTreeNode>) => PosixTreeNode | undefined;
     /**
      * Runtime domain invariant check.
      *
@@ -81,153 +51,4 @@ export declare const PosixTreeNode: {
      */
     readonly toUnloadedDirectory: (node: PosixTreeNode) => PosixTreeNode | undefined;
 };
-/**
- * This is a DTO / persistence shape, not the runtime domain type.
- *
- * It intentionally exposes `id`, `value`, and `children`, because serialized
- * data must have a concrete public format.
- */
-export type PosixTreeNodeModel = TreeNodeModel<PosixName, PosixEntry>;
-/**
- * Validates both the generic tree model shape and the POSIX-specific
- * file/symlink/directory invariants.
- *
- * Files and symlinks must be leaf models.
- * Directories must be unloaded or loaded branch models.
- */
-export declare const PosixTreeNodeModelSchema: z.ZodType<PosixTreeNodeModel>;
-/**
- * Decodes validated external data into the opaque domain type.
- *
- * `fromModel` additionally checks sibling-name uniqueness. That validation is
- * separate from Zod's object-shape validation.
- */
-export declare function decodePosixTreeNode(input: unknown): PosixTreeNode | undefined;
-export declare function encodePosixTreeNode(node: PosixTreeNode): PosixTreeNodeModel;
-/**
- * Fold definitions for one POSIX directory tree.
- */
-export type PosixFolds = Folds<PosixName>;
-export declare const PosixFoldsApi: Readonly<{
-    create(rootId: string, initialPrimaryInfo: Readonly<{
-        name: string;
-        description: string | null;
-    }>): Folds<string>;
-    getIndexByName(folds: Folds<string>, name: string): import("dirvi-lib").FoldIndex | undefined;
-    getInfoAtIndex(folds: Folds<string>, index: import("dirvi-lib").FoldIndex): Readonly<{
-        name: string;
-        description: string | null;
-    }> | undefined;
-    isActiveAtIndex(folds: Folds<string>, index: import("dirvi-lib").FoldIndex): boolean | undefined;
-    hasAtIndex(folds: Folds<string>, index: import("dirvi-lib").FoldIndex): boolean;
-    indexes(folds: Folds<string>): Iterable<import("dirvi-lib").FoldIndex>;
-    setAtIndex(folds: Folds<string>, index: import("dirvi-lib").FoldIndex, foldData: Readonly<{
-        name: string;
-        description: string | null;
-        active: boolean;
-        tree: Readonly<{
-            id: string;
-            hiddenEntryIds: readonly string[];
-            children: readonly Readonly</*elided*/ any>[];
-        }>;
-    }>): Folds<string> | undefined;
-    setAdditionalFoldAtIndex(folds: Folds<string>, index: import("dirvi-lib").FoldIndex, rootId: string, info: Readonly<{
-        name: string;
-        description: string | null;
-    }>): Folds<string> | undefined;
-    removeAdditionalFoldAtIndex(folds: Folds<string>, index: import("dirvi-lib").FoldIndex): Folds<string> | undefined;
-    updateInfoAtIndex(folds: Folds<string>, index: import("dirvi-lib").FoldIndex, update: Readonly<{
-        name?: string;
-        description?: string | null;
-    }>): Folds<string> | undefined;
-    activateAtIndex(folds: Folds<string>, index: import("dirvi-lib").FoldIndex): Folds<string> | undefined;
-    deactivateAtIndex(folds: Folds<string>, index: import("dirvi-lib").FoldIndex): Folds<string> | undefined;
-    toggleActiveAtIndex(folds: Folds<string>, index: import("dirvi-lib").FoldIndex): Folds<string> | undefined;
-    isEntryHiddenInFoldAtPath(folds: Folds<string>, index: import("dirvi-lib").FoldIndex, path: readonly string[], entryId: string): boolean;
-    isEntryHiddenAtPath(folds: Folds<string>, path: readonly string[], entryId: string): boolean;
-    hiddenEntryIdsAtPath(folds: Folds<string>, index: import("dirvi-lib").FoldIndex, path: readonly string[]): Iterable<string> | undefined;
-    hideEntryAtPath(folds: Folds<string>, index: import("dirvi-lib").FoldIndex, path: readonly string[], entryId: string): Folds<string> | undefined;
-    showEntryAtPath(folds: Folds<string>, index: import("dirvi-lib").FoldIndex, path: readonly string[], entryId: string): Folds<string> | undefined;
-    showAllHiddenEntriesAtPath(folds: Folds<string>, index: import("dirvi-lib").FoldIndex, path: readonly string[]): Folds<string> | undefined;
-    toModel(folds: Folds<string>): Readonly<{
-        slots: readonly [Readonly<{
-            name: string;
-            description: string | null;
-            active: boolean;
-            tree: Readonly<{
-                id: string;
-                hiddenEntryIds: readonly string[];
-                children: readonly Readonly</*elided*/ any>[];
-            }>;
-        }>, ...(Readonly<{
-            name: string;
-            description: string | null;
-            active: boolean;
-            tree: Readonly<{
-                id: string;
-                hiddenEntryIds: readonly string[];
-                children: readonly Readonly</*elided*/ any>[];
-            }>;
-        }> | null)[]];
-    }>;
-    fromModel(model: Readonly<{
-        slots: readonly [Readonly<{
-            name: string;
-            description: string | null;
-            active: boolean;
-            tree: Readonly<{
-                id: string;
-                hiddenEntryIds: readonly string[];
-                children: readonly Readonly</*elided*/ any>[];
-            }>;
-        }>, ...(Readonly<{
-            name: string;
-            description: string | null;
-            active: boolean;
-            tree: Readonly<{
-                id: string;
-                hiddenEntryIds: readonly string[];
-                children: readonly Readonly</*elided*/ any>[];
-            }>;
-        }> | null)[]];
-    }>): Folds<string> | undefined;
-}>;
-export type PosixFoldsModel = FoldsModel<PosixName>;
-export declare const PosixFoldsModelSchema: z.ZodType<PosixFoldsModel>;
-export declare const PosixCursorSchema: z.ZodType<PosixCursor>;
-export type PosixCursor = Cursor<PosixName>;
-export declare const PosixCursorApi: import("dirvi-lib").CursorApi<string>;
-/**
- * NavNode should now be parameterized by node value, not the recursive
- * application node shape.
- */
-export type PosixNavNode = NavNode<PosixName>;
-export declare const PosixNavApi: import("dirvi-lib").NavNodeApi<string, PosixEntry>;
-/**
- * State should now be parameterized by application value, not a recursive
- * structural node type.
- */
-export type PosixState = State<PosixName, PosixEntry>;
-export declare const PosixStateApi: Readonly<{
-    getNodeAtCursor(state: Readonly<{
-        root: TreeNode<string, PosixEntry>;
-        folds: Folds<string>;
-        cursor: Cursor<string>;
-    }>): TreeNode<string, PosixEntry> | undefined;
-    resync(oldState: Readonly<{
-        root: TreeNode<string, PosixEntry>;
-        folds: Folds<string>;
-        cursor: Cursor<string>;
-    }>, loadBranches: (path: readonly string[]) => Promise<readonly TreeNode<string, PosixEntry>[]>): Promise<Readonly<{
-        root: TreeNode<string, PosixEntry>;
-        folds: Folds<string>;
-        cursor: Cursor<string>;
-    }>>;
-}>;
-export type PosixStateModel = StateModel<PosixName, PosixEntry>;
-/**
- * The state schema should operate on a serializable tree *model*, then decode
- * it to opaque nodes. Do not try to make Zod construct TreeNode directly.
- */
-export declare const PosixStateModelSchema: z.ZodType<PosixStateModel>;
 //# sourceMappingURL=posix-tree.d.ts.map

package/dist/domain/posix-tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"posix-tree.d.ts","sourceRoot":"","sources":["../../src/domain/posix-tree.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"posix-tree.d.ts","sourceRoot":"","sources":["../../src/domain/posix-tree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAEV,QAAQ,EACR,WAAW,EACZ,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,QAAQ,EAAkB,MAAM,gBAAgB,CAAC;AAY1D;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,aAU1B,CAAC;AAEP;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAY3D;;GAEG;AACH,MAAM,MAAM,UAAU,GAClB,QAAQ,CAAC;IACP,IAAI,EAAE,MAAM,CAAC;CACd,CAAC,GACF,QAAQ,CAAC;IACP,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,QAAQ,CAAC;CAClB,CAAC,GACF,QAAQ,CAAC;IACP,IAAI,EAAE,WAAW,CAAC;CACnB,CAAC,CAAC;AAEP,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;AAuB1D,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,CAGlD,CAAC;AAMF,wBAAgB,kBAAkB,CAChC,gBAAgB,EAAE,WAAW,CAAC,OAAO,EAAE,UAAU,CAAC;0BAGrC,OAAO,KAAG,aAAa;6BAMpB,OAAO,UAAU,QAAQ,KAAG,aAAa;uCAO/B,OAAO,KAAG,aAAa;qCAOvC,OAAO,YACH,QAAQ,CAAC,aAAa,CAAC,KAChC,aAAa,GAAG,SAAS;IAQ5B;;;;;OAKG;6BACW,aAAa,KAAG,OAAO;IAcrC;;;;;;OAMG;wCAEK,aAAa,YACT,QAAQ,CAAC,aAAa,CAAC,KAChC,aAAa,GAAG,SAAS;IAQ5B;;;;OAIG;yCACuB,aAAa,KAAG,aAAa,GAAG,SAAS;EAQtE"}

package/dist/domain/posix-tree.js

@@ -1,18 +1,25 @@
 import { z } from 'zod';
-import { serializableKeySchema, createNavNodeApi, createStateApi, createTreeNodeApi, createFoldsApi, createFoldsModelSchema, createCursorSchema, createCursorApi, createStateModelSchema, } from 'dirvi-lib';
 import { UnixPathSchema } from './unix-path.js';
 // -----------------------------------------------------------------------------
-// PosixName
+// PosixId: Id extends SerializableKey
 // -----------------------------------------------------------------------------
-export const PosixNameSchema = serializableKeySchema.pipe(z
-    .string()
+/**
+ * A JavaScript-string representation of a non-special POSIX filename.
+ *
+ * Validates invariants needed for a tree entry ID, not full POSIX compatibility.
+ */
+export const posixFilenameSchema = z.string()
     .min(1, 'Entry name cannot be empty.')
+    .refine((value) => !value.includes('\0'), {
+    message: 'Entry name must not contain a NUL character.',
+})
     .refine((value) => !value.includes('/'), {
     message: "Entry name must not contain '/'.",
 })
     .refine((value) => value !== '.' && value !== '..', {
-    message: "Entry name cannot be '.' or '..'.",
-}));
+    message: "Entry name must not be '.' or '..'.",
+});
+// Schema ----------------------------------------------------------------------
 const PosixFileEntrySchema = z
     .object({
     kind: z.literal('file'),
@@ -29,153 +36,187 @@ const PosixDirectoryEntrySchema = z
     kind: z.literal('directory'),
 })
     .strict();
-export const PosixEntrySchema = z.discriminatedUnion('kind', [PosixFileEntrySchema, PosixSymlinkEntrySchema, PosixDirectoryEntrySchema]);
-export const PosixTreeNodeApi = createTreeNodeApi();
+export const posixValueSchema = z.discriminatedUnion('kind', [PosixFileEntrySchema, PosixSymlinkEntrySchema, PosixDirectoryEntrySchema]);
 // -----------------------------------------------------------------------------
 // POSIX domain constructors
 // -----------------------------------------------------------------------------
-export const PosixTreeNode = {
-    file(name) {
-        return PosixTreeNodeApi.createLeaf(name, {
-            kind: 'file',
-        });
-    },
-    symlink(name, target) {
-        return PosixTreeNodeApi.createLeaf(name, {
-            kind: 'symlink',
-            target,
-        });
-    },
-    unloadedDirectory(name) {
-        return PosixTreeNodeApi.createUnloadedBranch(name, {
-            kind: 'directory',
-        });
-    },
-    loadedDirectory(name, children) {
-        return PosixTreeNodeApi.createLoadedBranch(name, { kind: 'directory' }, children);
-    },
-    /**
-     * Runtime domain invariant check.
-     *
-     * A file and symlink must be leaves. A directory must be a branch, whether
-     * loaded or unloaded.
-     */
-    isValid(node) {
-        const entry = PosixTreeNodeApi.value(node);
-        const treeKind = PosixTreeNodeApi.kind(node);
-        switch (entry.kind) {
-            case 'file':
-            case 'symlink':
-                return treeKind === 'leaf';
-            case 'directory':
-                return treeKind === 'unloaded-branch' || treeKind === 'loaded-branch';
-        }
-    },
-    /**
-     * Adds or replaces the loaded children of a directory.
-     *
-     * Returns `undefined` when:
-     * - the supplied node is not a directory; or
-     * - siblings have duplicate names.
-     */
-    withLoadedChildren(node, children) {
-        if (PosixTreeNodeApi.value(node).kind !== 'directory') {
-            return undefined;
-        }
-        return PosixTreeNodeApi.withLoadedChildren(node, children);
-    },
-    /**
-     * Converts a directory to an unloaded directory.
-     *
-     * Files and symlinks cannot be converted to branches through this POSIX API.
-     */
-    toUnloadedDirectory(node) {
-        if (PosixTreeNodeApi.value(node).kind !== 'directory') {
-            return undefined;
-        }
-        return PosixTreeNodeApi.toUnloadedBranch(node);
-    },
-};
-/**
- * Validates both the generic tree model shape and the POSIX-specific
- * file/symlink/directory invariants.
- *
- * Files and symlinks must be leaf models.
- * Directories must be unloaded or loaded branch models.
- */
-export const PosixTreeNodeModelSchema = z.lazy(() => z.union([
-    // Leaf: file
-    z
-        .object({
-        id: PosixNameSchema,
-        value: PosixFileEntrySchema,
-    })
-        .strict(),
-    // Leaf: symlink
-    z
-        .object({
-        id: PosixNameSchema,
-        value: PosixSymlinkEntrySchema,
-    })
-        .strict(),
-    // Unloaded branch: directory
-    z
-        .object({
-        id: PosixNameSchema,
-        value: PosixDirectoryEntrySchema,
-        children: z.null(),
-    })
-        .strict(),
-    // Loaded branch: directory
-    z
-        .object({
-        id: PosixNameSchema,
-        value: PosixDirectoryEntrySchema,
-        children: z.array(PosixTreeNodeModelSchema),
-    })
-        .strict(),
-]));
-/**
- * Decodes validated external data into the opaque domain type.
- *
- * `fromModel` additionally checks sibling-name uniqueness. That validation is
- * separate from Zod's object-shape validation.
- */
-export function decodePosixTreeNode(input) {
-    const model = PosixTreeNodeModelSchema.safeParse(input);
-    if (!model.success) {
-        return undefined;
-    }
-    const node = PosixTreeNodeApi.fromModel(model.data);
-    if (node === undefined) {
-        return undefined;
-    }
-    return PosixTreeNode.isValid(node) ? node : undefined;
+export function createConstructors(posixTreeNodeApi) {
+    return {
+        file(name) {
+            return posixTreeNodeApi.createLeaf(name, {
+                kind: 'file',
+            });
+        },
+        symlink(name, target) {
+            return posixTreeNodeApi.createLeaf(name, {
+                kind: 'symlink',
+                target,
+            });
+        },
+        unloadedDirectory(name) {
+            return posixTreeNodeApi.createUnloadedBranch(name, {
+                kind: 'directory',
+            });
+        },
+        loadedDirectory(name, children) {
+            return posixTreeNodeApi.createLoadedBranch(name, { kind: 'directory' }, children);
+        },
+        /**
+         * Runtime domain invariant check.
+         *
+         * A file and symlink must be leaves. A directory must be a branch, whether
+         * loaded or unloaded.
+         */
+        isValid(node) {
+            const entry = posixTreeNodeApi.value(node);
+            const treeKind = posixTreeNodeApi.kind(node);
+            switch (entry.kind) {
+                case 'file':
+                case 'symlink':
+                    return treeKind === 'leaf';
+                case 'directory':
+                    return treeKind === 'unloaded-branch' || treeKind === 'loaded-branch';
+            }
+        },
+        /**
+         * Adds or replaces the loaded children of a directory.
+         *
+         * Returns `undefined` when:
+         * - the supplied node is not a directory; or
+         * - siblings have duplicate names.
+         */
+        withLoadedChildren(node, children) {
+            if (posixTreeNodeApi.value(node).kind !== 'directory') {
+                return undefined;
+            }
+            return posixTreeNodeApi.withLoadedChildren(node, children);
+        },
+        /**
+         * Converts a directory to an unloaded directory.
+         *
+         * Files and symlinks cannot be converted to branches through this POSIX API.
+         */
+        toUnloadedDirectory(node) {
+            if (posixTreeNodeApi.value(node).kind !== 'directory') {
+                return undefined;
+            }
+            return posixTreeNodeApi.toUnloadedBranch(node);
+        },
+    };
 }
-export function encodePosixTreeNode(node) {
-    return PosixTreeNodeApi.toModel(node);
-}
-/**
- * Folds internally store sparse trees whose values are direct child IDs hidden
- * at that tree position. This implementation detail remains private to the
- * POSIX domain module.
- */
-const PosixFoldTreeNodeApi = createTreeNodeApi();
-export const PosixFoldsApi = createFoldsApi(PosixFoldTreeNodeApi);
-export const PosixFoldsModelSchema = createFoldsModelSchema(PosixNameSchema);
+;
 // -----------------------------------------------------------------------------
-// PosixCursor
+// Serializable POSIX model
 // -----------------------------------------------------------------------------
-export const PosixCursorSchema = createCursorSchema(PosixNameSchema);
-export const PosixCursorApi = createCursorApi();
-export const PosixNavApi = createNavNodeApi(PosixTreeNodeApi, PosixFoldsApi, PosixCursorApi, {
-    compareEntries(left, right) {
-        return left.id.localeCompare(right.id);
-    },
-});
-export const PosixStateApi = createStateApi(PosixTreeNodeApi, PosixCursorApi);
-/**
- * The state schema should operate on a serializable tree *model*, then decode
- * it to opaque nodes. Do not try to make Zod construct TreeNode directly.
- */
-export const PosixStateModelSchema = createStateModelSchema(PosixTreeNodeModelSchema, PosixFoldsModelSchema, PosixCursorSchema);
+// /**
+//  * This is a DTO / persistence shape, not the runtime domain type.
+//  *
+//  * It intentionally exposes `id`, `value`, and `children`, because serialized
+//  * data must have a concrete public format.
+//  */
+// export type PosixTreeNodeModel = TreeNodeModel<PosixId, PosixValue>;
+//
+// /**
+//  * Validates both the generic tree model shape and the POSIX-specific
+//  * file/symlink/directory invariants.
+//  *
+//  * Files and symlinks must be leaf models.
+//  * Directories must be unloaded or loaded branch models.
+//  */
+// export const PosixTreeNodeModelSchema: z.ZodType<PosixTreeNodeModel> = z.lazy(
+//   () =>
+//     z.union([
+//       // Leaf: file
+//       z
+//         .object({
+//           id: posixFilenameSchema,
+//           value: PosixFileEntrySchema,
+//         })
+//         .strict(),
+//
+//       // Leaf: symlink
+//       z
+//         .object({
+//           id: posixFilenameSchema,
+//           value: PosixSymlinkEntrySchema,
+//         })
+//         .strict(),
+//
+//       // Unloaded branch: directory
+//       z
+//         .object({
+//           id: posixFilenameSchema,
+//           value: PosixDirectoryEntrySchema,
+//           children: z.null(),
+//         })
+//         .strict(),
+//
+//       // Loaded branch: directory
+//       z
+//         .object({
+//           id: posixFilenameSchema,
+//           value: PosixDirectoryEntrySchema,
+//           children: z.array(PosixTreeNodeModelSchema),
+//         })
+//         .strict(),
+//     ]),
+// );
+// /**
+//  * Decodes validated external data into the opaque domain type.
+//  *
+//  * `fromModel` additionally checks sibling-name uniqueness. That validation is
+//  * separate from Zod's object-shape validation.
+//  */
+// export function decodePosixTreeNode(input: unknown): PosixTreeNode | undefined {
+//   const model = PosixTreeNodeModelSchema.safeParse(input);
+//
+//   if (!model.success) {
+//     return undefined;
+//   }
+//
+//   const node = PosixTreeNodeApi.fromModel(model.data);
+//
+//   if (node === undefined) {
+//     return undefined;
+//   }
+//
+//   return PosixTreeNode.isValid(node) ? node : undefined;
+// }
+//
+// export function encodePosixTreeNode(node: PosixTreeNode): PosixTreeNodeModel {
+//   return PosixTreeNodeApi.toModel(node);
+// }
+// // -----------------------------------------------------------------------------
+// // PosixFolds
+// // -----------------------------------------------------------------------------
+//
+// export type PosixFoldsModel = FoldsModel<PosixId>;
+//
+// export const PosixFoldsModelSchema: z.ZodType<PosixFoldsModel> =
+//   createFoldsModelSchema(posixFilenameSchema);
+//
+// // -----------------------------------------------------------------------------
+// // PosixCursor
+// // -----------------------------------------------------------------------------
+//
+// export const PosixCursorSchema: z.ZodType<PosixCursor> =
+//   createCursorSchema(posixFilenameSchema);
+//
+// export type PosixCursor = Cursor<PosixId>;
+//
+// // -----------------------------------------------------------------------------
+// // PosixState
+// // -----------------------------------------------------------------------------
+//
+// export type PosixStateModel = StateModel<PosixId, PosixValue>;
+//
+// /**
+//  * The state schema should operate on a serializable tree *model*, then decode
+//  * it to opaque nodes. Do not try to make Zod construct TreeNode directly.
+//  */
+// export const PosixStateModelSchema: z.ZodType<PosixStateModel> =
+//   createStateModelSchema(
+//     posixTreeNodeModelSchema,
+//     PosixFoldsModelSchema,
+//     PosixCursorSchema,
+//   );

package/dist/infrastructure/create-file-view-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-file-view-api.d.ts","sourceRoot":"","sources":["../../src/infrastructure/create-file-view-api.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EACV,eAAe,EACf,KAAK,EACL,UAAU,EACV,OAAO,EAER,MAAM,WAAW,CAAC;AAEnB;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,CACpB,EAAE,SAAS,eAAe,EAC1B,KAAK,EACL,WAAW,SAAS,UAAU,CAAC,EAAE,EAAE,KAAK,CAAC,IACvC,QAAQ,CAAC;IACX,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IAC/B,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,KAAK,WAAW,CAAC;IAOjD,MAAM,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,GAAG,SAAS,CAAC;CAC9D,CAAC,CAAC;AA2BH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,SAAS,eAAe,EAC1B,KAAK,EACL,WAAW,SAAS,UAAU,CAAC,EAAE,EAAE,KAAK,CAAC,EACzC,GAAG,EACH,EACA,SAAS,EACT,SAAS,EACT,UAAU,GACX,EAAE;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC;IAChC,UAAU,EAAE,UAAU,CAAC,EAAE,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC;CAChD,GAAG,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,EAAE,GAAG,CAAC,CAkKjC"}
+{"version":3,"file":"create-file-view-api.d.ts","sourceRoot":"","sources":["../../src/infrastructure/create-file-view-api.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EACV,eAAe,EACf,KAAK,EACL,UAAU,EACV,OAAO,EAER,MAAM,WAAW,CAAC;AAInB;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,CACpB,EAAE,SAAS,eAAe,EAC1B,KAAK,EACL,WAAW,SAAS,UAAU,CAAC,EAAE,EAAE,KAAK,CAAC,IACvC,QAAQ,CAAC;IACX,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IAC/B,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,KAAK,WAAW,CAAC;IAOjD,MAAM,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,GAAG,SAAS,CAAC;CAC9D,CAAC,CAAC;AA2BH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,SAAS,eAAe,EAC1B,KAAK,EACL,WAAW,SAAS,UAAU,CAAC,EAAE,EAAE,KAAK,CAAC,EACzC,GAAG,EACH,EACA,SAAS,EACT,SAAS,EACT,UAAU,GACX,EAAE;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC;IAChC,UAAU,EAAE,UAAU,CAAC,EAAE,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC;CAChD,GAAG,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,EAAE,GAAG,CAAC,CAkKjC"}

package/dist/infrastructure/get-dir-entries.d.ts

@@ -1,5 +1,5 @@
-import { TreeNode } from 'dirvi-lib';
-import { PosixEntry, PosixName } from '../domain/posix-tree.js';
-import { UnixAbsolutePath } from '../domain/unix-path.js';
-export declare function getDirEntries(address: UnixAbsolutePath): Promise<TreeNode<PosixName, PosixEntry>[]>;
+import type { TreeNode, TreeNodeApi } from 'dirvi-lib';
+import { type PosixValue, type PosixId } from '../domain/posix-tree.js';
+import { type UnixAbsolutePath } from '../domain/unix-path.js';
+export declare function getDirEntries(treeNodeApi: TreeNodeApi<PosixId, PosixValue>, address: UnixAbsolutePath): Promise<TreeNode<PosixId, PosixValue>[]>;
 //# sourceMappingURL=get-dir-entries.d.ts.map

package/dist/infrastructure/get-dir-entries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-dir-entries.d.ts","sourceRoot":"","sources":["../../src/infrastructure/get-dir-entries.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAe,MAAM,WAAW,CAAC;AAClD,OAAO,EACL,UAAU,EACV,SAAS,EAGV,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,gBAAgB,EAAkB,MAAM,wBAAwB,CAAC;AAI1E,wBAAsB,aAAa,CACjC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC,EAAE,CAAC,CA8B5C"}
+{"version":3,"file":"get-dir-entries.d.ts","sourceRoot":"","sources":["../../src/infrastructure/get-dir-entries.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAEvD,OAAO,EACL,KAAK,UAAU,EACf,KAAK,OAAO,EAIb,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,KAAK,gBAAgB,EAAkB,MAAM,wBAAwB,CAAC;AAE/E,wBAAsB,aAAa,CACjC,WAAW,EAAE,WAAW,CAAC,OAAO,EAAE,UAAU,CAAC,EAC7C,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,EAAE,CAAC,CA+B1C"}

package/dist/infrastructure/get-dir-entries.js

@@ -1,22 +1,23 @@
-import { PosixNameSchema, PosixTreeNode, } from '../domain/posix-tree.js';
-import { UnixPathSchema } from '../domain/unix-path.js';
 import { readdir, readlink } from 'node:fs/promises';
 import { join } from 'node:path';
-export async function getDirEntries(address) {
+import { posixFilenameSchema, createConstructors, } from '../domain/posix-tree.js';
+import { UnixPathSchema } from '../domain/unix-path.js';
+export async function getDirEntries(treeNodeApi, address) {
     const directoryEntries = await readdir(address, {
         withFileTypes: true,
     });
+    const constructors = createConstructors(treeNodeApi);
     return Promise.all(directoryEntries.map(async (directoryEntry) => {
-        const id = PosixNameSchema.parse(directoryEntry.name);
+        const id = posixFilenameSchema.parse(directoryEntry.name);
         if (directoryEntry.isSymbolicLink()) {
             const target = UnixPathSchema.parse(await readlink(join(address, directoryEntry.name)));
-            return PosixTreeNode.symlink(id, target);
+            return constructors.symlink(id, target);
         }
         if (directoryEntry.isDirectory()) {
-            return PosixTreeNode.unloadedDirectory(id);
+            return constructors.unloadedDirectory(id);
         }
         if (directoryEntry.isFile()) {
-            return PosixTreeNode.file(id);
+            return constructors.file(id);
         }
         throw new Error(`Unsupported filesystem entry "${join(address, directoryEntry.name)}"`);
     }));

package/dist/infrastructure/get-unix-abs-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-unix-abs-path.d.ts","sourceRoot":"","sources":["../../src/infrastructure/get-unix-abs-path.ts"],"names":[],"mappings":"AACA,OAAO,EACL,gBAAgB,EAEjB,MAAM,wBAAwB,CAAC;AAEhC,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAgBlE"}
+{"version":3,"file":"get-unix-abs-path.d.ts","sourceRoot":"","sources":["../../src/infrastructure/get-unix-abs-path.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,gBAAgB,EAEjB,MAAM,wBAAwB,CAAC;AAEhC,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAgBlE"}

package/dist/infrastructure/load-node-posix-app-api.d.ts

@@ -1,10 +1,2 @@
-import { PosixEntry, PosixName } from '../domain/posix-tree.js';
-import { UnixAbsolutePath } from '../domain/unix-path.js';
-import type { AppApi } from 'dirvi-apis';
-/**
- * Creates the AppApi for the POSIX app.
- *
- * @param directory - optional directory path for loading the app not at the cwd.
- */
-export declare function loadNodePosixAppApi(directory?: string): AppApi<PosixName, PosixEntry, UnixAbsolutePath>;
+export declare function createFsResyncSubscription(directory: string): (listener: () => void) => () => void;
 //# sourceMappingURL=load-node-posix-app-api.d.ts.map

package/dist/infrastructure/load-node-posix-app-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load-node-posix-app-api.d.ts","sourceRoot":"","sources":["../../src/infrastructure/load-node-posix-app-api.ts"],"names":[],"mappings":"AAQA,OAAO,EAEL,UAAU,EAEV,SAAS,EAQV,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAwEzC;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CAAC,SAAS,EAAE,UAAU,EAAE,gBAAgB,CAAC,CA2CjD"}
+{"version":3,"file":"load-node-posix-app-api.d.ts","sourceRoot":"","sources":["../../src/infrastructure/load-node-posix-app-api.ts"],"names":[],"mappings":"AAwEA,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,MAAM,GAChB,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CA6EtC"}

package/dist/infrastructure/load-node-posix-app-api.js

@@ -1,112 +1,73 @@
-import { basename, join } from 'node:path';
 import { watch } from 'node:fs';
-import { getUnixAbsPath } from './get-unix-abs-path.js';
-import { getDirEntries } from './get-dir-entries.js';
-import envPaths from 'env-paths';
-import { createFileViewApi } from './create-file-view-api.js';
-import { createHash } from 'node:crypto';
-import { PosixCursorApi, PosixFoldsApi, PosixNameSchema, PosixNavApi, PosixStateModelSchema, PosixTreeNode, PosixTreeNodeApi, } from '../domain/posix-tree.js';
-import { createAppStateApis } from 'dirvi-lib';
 // ---*--- App Data ---*---
 // Paths for app data:
-const environmentPaths = envPaths('dirvi');
-const posixAppDataDirectory = join(environmentPaths.data, 'apps', 'posix');
-const posixAppViewsDirectory = join(posixAppDataDirectory, 'views');
-// Helpers for saving app data:
-function encodeKey(key) {
-    return createHash('sha256').update(key).digest('hex');
-}
-/**
- * Persists public POSIX state models while keeping TreeNode and Folds runtime
- * representations opaque.
- */
-const posixStateCodec = {
-    schema: PosixStateModelSchema,
-    encode: encodePosixState,
-    decode: decodePosixState,
-};
-/**
- * Converts opaque POSIX runtime state into its serializable persistence model.
- */
-function encodePosixState(state) {
-    return {
-        root: PosixTreeNodeApi.toModel(state.root),
-        folds: PosixFoldsApi.toModel(state.folds),
-        cursor: PosixCursorApi.getPath(state.cursor),
-    };
-}
-/**
- * Restores opaque POSIX runtime state from a schema-validated model.
- *
- * `TreeNodeApi.fromModel` performs the structural sibling-ID uniqueness check
- * which cannot be fully expressed by the JSON/Zod model schema.
- */
-function decodePosixState(model) {
-    const root = PosixTreeNodeApi.fromModel(model.root);
-    /*
-     * State requires an open root branch. The POSIX domain additionally requires
-     * files and symlinks to be leaves, and directories to be branches.
-     */
-    if (root === undefined ||
-        !PosixTreeNode.isValid(root) ||
-        PosixTreeNodeApi.kind(root) !== 'loaded-branch') {
-        return undefined;
-    }
-    const folds = PosixFoldsApi.fromModel(model.folds);
-    if (folds === undefined) {
-        return undefined;
-    }
-    return {
-        root,
-        folds,
-        cursor: PosixCursorApi.getPath(model.cursor),
-    };
-}
-// --- Creating Posix App API ---
-/**
- * Creates the AppApi for the POSIX app.
- *
- * @param directory - optional directory path for loading the app not at the cwd.
- */
-export function loadNodePosixAppApi(directory) {
-    const unixAbsPath = getUnixAbsPath(directory ?? process.cwd());
-    const rootId = PosixNameSchema.parse(basename(unixAbsPath));
-    const apis = createAppStateApis();
-    function loadBranches(path) {
-        const address = join(unixAbsPath, ...path);
-        return getDirEntries(address);
-    }
-    return {
-        appId: 'posix',
-        name: unixAbsPath,
-        rootId,
-        loadBranches,
-        createRoot: async () => {
-            // Start with root branches already loaded
-            const rootBranches = await loadBranches([]);
-            const root = PosixTreeNode.loadedDirectory(rootId, rootBranches);
-            if (root === undefined) {
-                throw new Error('Cannot create POSIX root: duplicate directory entry names');
-            }
-            return root;
-        },
-        subscribeToResync: createFsResyncSubscription(join(unixAbsPath)),
-        // The key for the Posix app instance is just the directory working in:
-        viewKey: unixAbsPath,
-        viewApi: createFileViewApi({
-            directory: posixAppViewsDirectory,
-            encodeKey,
-            stateCodec: posixStateCodec,
-        }),
-        foldsApi: PosixFoldsApi,
-        navNodeApi: PosixNavApi,
-        ...apis,
-    };
-}
+// const environmentPaths = envPaths('dirvi');
+// const posixAppDataDirectory = join(environmentPaths.data, 'apps', 'posix');
+// const posixAppViewsDirectory = join(posixAppDataDirectory, 'views');
+//
+// // Helpers for saving app data:
+// function encodeKey(key: UnixAbsolutePath): string {
+//   return createHash('sha256').update(key).digest('hex');
+// }
+//
+// /**
+//  * Persists public POSIX state models while keeping TreeNode and Folds runtime
+//  * representations opaque.
+//  */
+// const posixStateCodec: StateCodec<PosixId, PosixValue, PosixStateModel> = {
+//   schema: PosixStateModelSchema,
+//   encode: encodePosixState,
+//   decode: decodePosixState,
+// };
+//
+// /**
+//  * Converts opaque POSIX runtime state into its serializable persistence model.
+//  */
+// function encodePosixState(state: PosixState): PosixStateModel {
+//   return {
+//     root: PosixTreeNodeApi.toModel(state.root),
+//     folds: PosixFoldsApi.toModel(state.folds),
+//     cursor: PosixCursorApi.getPath(state.cursor),
+//   };
+// }
+//
+// /**
+//  * Restores opaque POSIX runtime state from a schema-validated model.
+//  *
+//  * `TreeNodeApi.fromModel` performs the structural sibling-ID uniqueness check
+//  * which cannot be fully expressed by the JSON/Zod model schema.
+//  */
+// function decodePosixState(model: PosixStateModel): PosixState | undefined {
+//   const root = PosixTreeNodeApi.fromModel(model.root);
+//
+//   /*
+//    * State requires an open root branch. The POSIX domain additionally requires
+//    * files and symlinks to be leaves, and directories to be branches.
+//    */
+//   if (
+//     root === undefined ||
+//     !PosixTreeNode.isValid(root) ||
+//     PosixTreeNodeApi.kind(root) !== 'loaded-branch'
+//   ) {
+//     return undefined;
+//   }
+//
+//   const folds = PosixFoldsApi.fromModel(model.folds);
+//
+//   if (folds === undefined) {
+//     return undefined;
+//   }
+//
+//   return {
+//     root,
+//     folds,
+//     cursor: PosixCursorApi.getPath(model.cursor),
+//   };
+// }
 // `recursive: true` is supported by macOS and Windows, but
 // recursive watching is not supported on all Node/POSIX
 // platforms: Linux unsupported.
-function createFsResyncSubscription(directory) {
+export function createFsResyncSubscription(directory) {
     const listeners = new Set();
     let watcher;
     let notificationTimer;

package/dist/posix-fs-dirvi-app.d.ts

@@ -1,6 +1,8 @@
-import type { AppPlugin } from 'dirvi-apis/plugin';
+import type { AppPlugin } from 'dirvi-apis';
 /**
- * A dirvi app that exposes a POSIX filesystem as a navigable tree.
+ * Creates applicator of AppDefinition.
+ *
+ * Input for this app is the absolute path to the directory to open on.
  */
 export declare const posixAppPlugin: AppPlugin;
 //# sourceMappingURL=posix-fs-dirvi-app.d.ts.map

package/dist/posix-fs-dirvi-app.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"posix-fs-dirvi-app.d.ts","sourceRoot":"","sources":["../src/posix-fs-dirvi-app.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAInD;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,SAQ5B,CAAC"}
+{"version":3,"file":"posix-fs-dirvi-app.d.ts","sourceRoot":"","sources":["../src/posix-fs-dirvi-app.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAa5C;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,SAwD5B,CAAC"}

package/dist/posix-fs-dirvi-app.js

@@ -1,12 +1,45 @@
-import { loadNodePosixAppApi } from './infrastructure/load-node-posix-app-api.js';
+import { basename, join } from 'node:path';
+import { posixFilenameSchema, posixValueSchema, createConstructors, } from './domain/posix-tree.js';
+import { createFsResyncSubscription } from './infrastructure/load-node-posix-app-api.js';
+import { getUnixAbsPath } from './infrastructure/get-unix-abs-path.js';
+import { getDirEntries } from './infrastructure/get-dir-entries.js';
 /**
- * A dirvi app that exposes a POSIX filesystem as a navigable tree.
+ * Creates applicator of AppDefinition.
+ *
+ * Input for this app is the absolute path to the directory to open on.
  */
 export const posixAppPlugin = {
-    createAppApiApplicator: (input) => {
-        const appApi = loadNodePosixAppApi(input);
-        return (appApiConsumer) => {
-            return appApiConsumer(appApi);
+    createAppDefinitionApplicator: (input) => {
+        const unixAbsPath = getUnixAbsPath(input ?? process.cwd());
+        const rootId = posixFilenameSchema.parse(basename(unixAbsPath));
+        function loadDirectoryEntries(treeNodeApi, path) {
+            const address = join(unixAbsPath, ...path);
+            return getDirEntries(treeNodeApi, address);
+        }
+        const appDefinition = {
+            displayName: `POSIX: ${input}`,
+            rootId,
+            idSchema: posixFilenameSchema,
+            valueSchema: posixValueSchema,
+            createRoot: async (treeNodeApi) => {
+                // Start with root branches already loaded
+                const rootBranches = await loadDirectoryEntries(treeNodeApi, []);
+                const root = createConstructors(treeNodeApi).loadedDirectory(rootId, rootBranches);
+                if (root === undefined) {
+                    throw new Error('Cannot create POSIX root: duplicate directory entry names');
+                }
+                return root;
+            },
+            loadChildren: (treeNodeApi, path) => loadDirectoryEntries(treeNodeApi, path),
+            subscribeToResync: createFsResyncSubscription(join(unixAbsPath)),
+            createNavNodeApiOptions: {
+                compareSiblings: (left, right) => {
+                    return left.id.localeCompare(right.id);
+                },
+            },
+        };
+        return (appDefinitionConsumer) => {
+            return appDefinitionConsumer(appDefinition);
         };
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mak-98/posix-fs-dirvi-app",
-  "version": "0.11.0-beta.2",
+  "version": "0.11.0-beta.4",
   "description": "POSIX filesystem app for dirvi.",
   "license": "GPL-3.0-or-later",
   "type": "module",
@@ -19,12 +19,12 @@
     "node": ">=22"
   },
   "dependencies": {
-    "dirvi-apis": "0.11.0-beta.1",
-    "dirvi-lib": "0.11.0-beta.1",
+    "dirvi-apis": "0.11.0-beta.4",
     "zod": "^4.4.3",
     "env-paths": "^4.0.0"
   },
   "devDependencies": {
+    "dirvi-lib": "0.11.0-beta.4",
     "@types/node": "^22.0.0",
     "typescript": "^5.0.0"
   },