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

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

@@ -1,16 +1,16 @@
 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';
 /**
  * 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.ZodPipe<z.ZodType<SerializableKey, unknown, z.core.$ZodTypeInternals<SerializableKey, unknown>>, z.ZodString>;
+export declare const posixFilenameSchema: z.ZodString;
 /**
  * `Id` type used for posix-fs-dirvi-app.
  */
-export type PosixId = z.output<typeof PosixFilenameSchema>;
+export type PosixId = z.output<typeof posixFilenameSchema>;
 /**
  * POSIX-specific meaning attached to a tree node.
  */
@@ -22,47 +22,9 @@ export type PosixValue = Readonly<{
 }> | Readonly<{
     kind: 'directory';
 }>;
-export declare const PosixValueSchema: z.ZodType<PosixValue>;
-/**
- * An opaque tree whose IDs are POSIX entry names and whose values describe
- * POSIX entry semantics.
- */
 export type PosixTreeNode = TreeNode<PosixId, PosixValue>;
-export declare const PosixTreeNodeApi: Readonly<{
-    createLeaf(id: string, value: PosixValue): TreeNode<string, PosixValue>;
-    createUnloadedBranch(id: string, value: PosixValue): TreeNode<string, PosixValue>;
-    createLoadedBranch(id: string, value: PosixValue, children: Iterable<TreeNode<string, PosixValue>>): TreeNode<string, PosixValue> | undefined;
-    id(node: TreeNode<string, PosixValue>): string;
-    value(node: TreeNode<string, PosixValue>): PosixValue;
-    kind(node: TreeNode<string, PosixValue>): import("dirvi-lib").TreeNodeKind;
-    matchByKind<Result>(node: TreeNode<string, PosixValue>, handlers: Readonly<{
-        leaf: (node: Readonly<{
-            id: string;
-            value: PosixValue;
-        }>) => Result;
-        unloadedBranch: (node: Readonly<{
-            id: string;
-            value: PosixValue;
-        }>) => Result;
-        loadedBranch: (node: Readonly<{
-            id: string;
-            value: PosixValue;
-            children: Iterable<TreeNode<string, PosixValue>>;
-        }>) => Result;
-    }>): Result;
-    getLoadedChildren(node: TreeNode<string, PosixValue>): Iterable<TreeNode<string, PosixValue>> | undefined;
-    findChildById(node: TreeNode<string, PosixValue>, id: string): TreeNode<string, PosixValue> | undefined;
-    withValue(node: TreeNode<string, PosixValue>, value: PosixValue): TreeNode<string, PosixValue>;
-    toLeaf(node: TreeNode<string, PosixValue>): TreeNode<string, PosixValue>;
-    toUnloadedBranch(node: TreeNode<string, PosixValue>): TreeNode<string, PosixValue>;
-    withLoadedChildren(node: TreeNode<string, PosixValue>, children: Iterable<TreeNode<string, PosixValue>>): TreeNode<string, PosixValue> | undefined;
-    findAtPath(root: TreeNode<string, PosixValue>, path: readonly string[]): TreeNode<string, PosixValue> | undefined;
-    selectAtPath<Result>(root: TreeNode<string, PosixValue>, path: readonly string[], selector: (node: TreeNode<string, PosixValue>) => Result): Result | undefined;
-    updateAtPath(root: TreeNode<string, PosixValue>, path: readonly string[], update: (node: TreeNode<string, PosixValue>) => TreeNode<string, PosixValue> | undefined): TreeNode<string, PosixValue> | undefined;
-    toModel(node: TreeNode<string, PosixValue>): TreeNodeModel<string, PosixValue>;
-    fromModel(model: TreeNodeModel<string, PosixValue>): TreeNode<string, PosixValue> | undefined;
-}>;
-export declare const PosixTreeNode: {
+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;
@@ -89,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<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 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<PosixId>;
-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<PosixId>;
-export declare const PosixFoldsModelSchema: z.ZodType<PosixFoldsModel>;
-export declare const PosixCursorSchema: z.ZodType<PosixCursor>;
-export type PosixCursor = Cursor<PosixId>;
-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<PosixId>;
-export declare const PosixNavApi: import("dirvi-lib").NavNodeApi<string, PosixValue>;
-/**
- * State should now be parameterized by application value, not a recursive
- * structural node type.
- */
-export type PosixState = State<PosixId, PosixValue>;
-export declare const PosixStateApi: Readonly<{
-    getNodeAtCursor(state: Readonly<{
-        root: TreeNode<string, PosixValue>;
-        folds: Folds<string>;
-        cursor: Cursor<string>;
-    }>): TreeNode<string, PosixValue> | undefined;
-    resync(oldState: Readonly<{
-        root: TreeNode<string, PosixValue>;
-        folds: Folds<string>;
-        cursor: Cursor<string>;
-    }>, loadBranches: (path: readonly string[]) => Promise<readonly TreeNode<string, PosixValue>[]>): Promise<Readonly<{
-        root: TreeNode<string, PosixValue>;
-        folds: Folds<string>;
-        cursor: Cursor<string>;
-    }>>;
-}>;
-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 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,16 +1,14 @@
 import { z } from 'zod';
-import { serializableKeySchema, createNavNodeApi, createStateApi, createTreeNodeApi, createFoldsApi, createFoldsModelSchema, createCursorSchema, createCursorApi, createStateModelSchema, } from 'dirvi-lib';
 import { UnixPathSchema } from './unix-path.js';
 // -----------------------------------------------------------------------------
-// PosixName: Id extends SerializableKey
+// PosixId: Id extends SerializableKey
 // -----------------------------------------------------------------------------
 /**
  * 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 = serializableKeySchema.pipe(z
-    .string()
+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.',
@@ -20,7 +18,8 @@ export const PosixFilenameSchema = serializableKeySchema.pipe(z
 })
     .refine((value) => value !== '.' && value !== '..', {
     message: "Entry name must not be '.' or '..'.",
-}));
+});
+// Schema ----------------------------------------------------------------------
 const PosixFileEntrySchema = z
     .object({
     kind: z.literal('file'),
@@ -37,153 +36,187 @@ const PosixDirectoryEntrySchema = z
     kind: z.literal('directory'),
 })
     .strict();
-export const PosixValueSchema = 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: 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) {
-    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(PosixFilenameSchema);
+;
 // -----------------------------------------------------------------------------
-// PosixCursor
+// Serializable POSIX model
 // -----------------------------------------------------------------------------
-export const PosixCursorSchema = createCursorSchema(PosixFilenameSchema);
-export const PosixCursorApi = createCursorApi();
-export const PosixNavApi = createNavNodeApi(PosixTreeNodeApi, PosixFoldsApi, PosixCursorApi, {
-    compareSiblings(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/index.d.ts

@@ -1,3 +1,3 @@
-export { posixAppPlugin2 as default } from './posix-fs-dirvi-app.js';
-export { posixAppPlugin2 } from './posix-fs-dirvi-app.js';
+export { posixAppPlugin as default } from './posix-fs-dirvi-app.js';
+export { posixAppPlugin } from './posix-fs-dirvi-app.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,OAAO,EAAE,eAAe,IAAI,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,IAAI,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/index.js

@@ -1,2 +1,2 @@
-export { posixAppPlugin2 as default } from './posix-fs-dirvi-app.js';
-export { posixAppPlugin2 } from './posix-fs-dirvi-app.js';
+export { posixAppPlugin as default } from './posix-fs-dirvi-app.js';
+export { posixAppPlugin } from './posix-fs-dirvi-app.js';

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 type { TreeNode } from 'dirvi-lib';
+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(address: UnixAbsolutePath): Promise<TreeNode<PosixId, PosixValue>[]>;
+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,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EACL,KAAK,UAAU,EACf,KAAK,OAAO,EAGb,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,KAAK,gBAAgB,EAAkB,MAAM,wBAAwB,CAAC;AAI/E,wBAAsB,aAAa,CACjC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,EAAE,CAAC,CA8B1C"}
+{"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 { PosixFilenameSchema, 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 = PosixFilenameSchema.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,11 +1,2 @@
-import { PosixValue, PosixId } 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<PosixId, PosixValue, 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":"AAIA,OAAO,EACL,UAAU,EAEV,OAAO,EAIR,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,OAAO,EAAE,UAAU,EAAE,gBAAgB,CAAC,CA0C/C;AAKD,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,MAAM,GAChB,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CA6EtC"}
+{"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,9 +1,4 @@
-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 { PosixFoldsApi, PosixFilenameSchema, PosixNavApi, PosixTreeNode, } from '../domain/posix-tree.js';
-import { createAppStateApis } from 'dirvi-lib';
 // ---*--- App Data ---*---
 // Paths for app data:
 // const environmentPaths = envPaths('dirvi');
@@ -69,46 +64,6 @@ import { createAppStateApis } from 'dirvi-lib';
 //     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 = PosixFilenameSchema.parse(basename(unixAbsPath));
-    const apis = createAppStateApis();
-    function loadBranches(path) {
-        const address = join(unixAbsPath, ...path);
-        return getDirEntries(address);
-    }
-    return {
-        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,
-    };
-}
 // `recursive: true` is supported by macOS and Windows, but
 // recursive watching is not supported on all Node/POSIX
 // platforms: Linux unsupported.

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

@@ -1,12 +1,8 @@
-import type { AppPlugin, AppPlugin2 } from 'dirvi-apis/plugin';
-/**
- * A dirvi app that exposes a POSIX filesystem as a navigable tree.
- */
-export declare const posixAppPlugin: AppPlugin;
+import type { AppPlugin } from 'dirvi-apis';
 /**
  * Creates applicator of AppDefinition.
  *
  * Input for this app is the absolute path to the directory to open on.
  */
-export declare const posixAppPlugin2: AppPlugin2;
+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,EAAiB,SAAS,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAQ9E;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,SAQ5B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,UAiD7B,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,47 +1,36 @@
-import { createFsResyncSubscription, loadNodePosixAppApi } from './infrastructure/load-node-posix-app-api.js';
-import { PosixFilenameSchema, PosixValueSchema, PosixTreeNode } from './domain/posix-tree.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.
- */
-export const posixAppPlugin = {
-    createAppApiApplicator: (input) => {
-        const appApi = loadNodePosixAppApi(input);
-        return (appApiConsumer) => {
-            return appApiConsumer(appApi);
-        };
-    },
-};
 /**
  * Creates applicator of AppDefinition.
  *
  * Input for this app is the absolute path to the directory to open on.
  */
-export const posixAppPlugin2 = {
+export const posixAppPlugin = {
     createAppDefinitionApplicator: (input) => {
         const unixAbsPath = getUnixAbsPath(input ?? process.cwd());
-        const rootId = PosixFilenameSchema.parse(basename(unixAbsPath));
-        function loadDirectoryEntries(path) {
+        const rootId = posixFilenameSchema.parse(basename(unixAbsPath));
+        function loadDirectoryEntries(treeNodeApi, path) {
             const address = join(unixAbsPath, ...path);
-            return getDirEntries(address);
+            return getDirEntries(treeNodeApi, address);
         }
         const appDefinition = {
             displayName: `POSIX: ${input}`,
             rootId,
-            idSchema: PosixFilenameSchema,
-            valueSchema: PosixValueSchema,
-            createRoot: async () => {
+            idSchema: posixFilenameSchema,
+            valueSchema: posixValueSchema,
+            createRoot: async (treeNodeApi) => {
                 // Start with root branches already loaded
-                const rootBranches = await loadDirectoryEntries([]);
-                const root = PosixTreeNode.loadedDirectory(rootId, rootBranches);
+                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: loadDirectoryEntries,
+            loadChildren: (treeNodeApi, path) => loadDirectoryEntries(treeNodeApi, path),
             subscribeToResync: createFsResyncSubscription(join(unixAbsPath)),
             createNavNodeApiOptions: {
                 compareSiblings: (left, right) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mak-98/posix-fs-dirvi-app",
-  "version": "0.11.0-beta.3",
+  "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.3",
-    "dirvi-lib": "0.11.0-beta.3",
+    "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"
   },