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

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 { 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.ZodPipe<z.ZodType<SerializableKey, unknown, z.core.$ZodTypeInternals<SerializableKey, unknown>>, 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,51 @@ export type PosixEntry = Readonly<{
 }> | Readonly<{
     kind: 'directory';
 }>;
-export declare const PosixEntrySchema: z.ZodType<PosixEntry>;
+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<PosixName, PosixEntry>;
+export type PosixTreeNode = TreeNode<PosixId, PosixValue>;
 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<{
+    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: PosixEntry;
+            value: PosixValue;
         }>) => Result;
         unloadedBranch: (node: Readonly<{
             id: string;
-            value: PosixEntry;
+            value: PosixValue;
         }>) => Result;
         loadedBranch: (node: Readonly<{
             id: string;
-            value: PosixEntry;
-            children: Iterable<TreeNode<string, PosixEntry>>;
+            value: PosixValue;
+            children: Iterable<TreeNode<string, PosixValue>>;
         }>) => 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;
+    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: {
-    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;
+    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.
      *
@@ -87,7 +95,7 @@ export declare const PosixTreeNode: {
  * It intentionally exposes `id`, `value`, and `children`, because serialized
  * data must have a concrete public format.
  */
-export type PosixTreeNodeModel = TreeNodeModel<PosixName, PosixEntry>;
+export type PosixTreeNodeModel = TreeNodeModel<PosixId, PosixValue>;
 /**
  * Validates both the generic tree model shape and the POSIX-specific
  * file/symlink/directory invariants.
@@ -107,7 +115,7 @@ export declare function encodePosixTreeNode(node: PosixTreeNode): PosixTreeNodeM
 /**
  * Fold definitions for one POSIX directory tree.
  */
-export type PosixFolds = Folds<PosixName>;
+export type PosixFolds = Folds<PosixId>;
 export declare const PosixFoldsApi: Readonly<{
     create(rootId: string, initialPrimaryInfo: Readonly<{
         name: string;
@@ -192,39 +200,39 @@ export declare const PosixFoldsApi: Readonly<{
         }> | null)[]];
     }>): Folds<string> | undefined;
 }>;
-export type PosixFoldsModel = FoldsModel<PosixName>;
+export type PosixFoldsModel = FoldsModel<PosixId>;
 export declare const PosixFoldsModelSchema: z.ZodType<PosixFoldsModel>;
 export declare const PosixCursorSchema: z.ZodType<PosixCursor>;
-export type PosixCursor = Cursor<PosixName>;
+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<PosixName>;
-export declare const PosixNavApi: import("dirvi-lib").NavNodeApi<string, PosixEntry>;
+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<PosixName, PosixEntry>;
+export type PosixState = State<PosixId, PosixValue>;
 export declare const PosixStateApi: Readonly<{
     getNodeAtCursor(state: Readonly<{
-        root: TreeNode<string, PosixEntry>;
+        root: TreeNode<string, PosixValue>;
         folds: Folds<string>;
         cursor: Cursor<string>;
-    }>): TreeNode<string, PosixEntry> | undefined;
+    }>): TreeNode<string, PosixValue> | undefined;
     resync(oldState: Readonly<{
-        root: TreeNode<string, PosixEntry>;
+        root: TreeNode<string, PosixValue>;
         folds: Folds<string>;
         cursor: Cursor<string>;
-    }>, loadBranches: (path: readonly string[]) => Promise<readonly TreeNode<string, PosixEntry>[]>): Promise<Readonly<{
-        root: TreeNode<string, PosixEntry>;
+    }>, 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<PosixName, PosixEntry>;
+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.

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;AACxB,OAAO,EAIL,OAAO,EACP,eAAe,EACf,KAAK,EACL,QAAQ,EAER,aAAa,EACb,KAAK,EAEL,UAAU,EAGV,MAAM,EAGN,UAAU,EACX,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,QAAQ,EAAkB,MAAM,gBAAgB,CAAC;AAY1D;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,iHAa/B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAU3D;;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;AAqBP,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,CAGlD,CAAC;AAMF;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;AAE1D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA2C,CAAC;AAMzE,eAAO,MAAM,aAAa;0BACb,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;CAO3D,CAAC;AAMX;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;AAEpE;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,EAAE,CAAC,CAAC,OAAO,CAAC,kBAAkB,CAqClE,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,GAAG,SAAS,CAc7E;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,aAAa,GAAG,kBAAkB,CAE3E;AAMD;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;AAYxC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAnIiB,CAAC;mBACnB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkIuC,CAAC;AAElE,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;AAElD,eAAO,MAAM,qBAAqB,EAAE,CAAC,CAAC,OAAO,CAAC,eAAe,CAChB,CAAC;AAM9C,eAAO,MAAM,iBAAiB,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CACZ,CAAC;AAE1C,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;AAE1C,eAAO,MAAM,cAAc,uCAA6B,CAAC;AAMzD;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAE5C,eAAO,MAAM,WAAW,oDASvB,CAAC;AAMF;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;AAEpD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;EAAmD,CAAC;AAE9E,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,CAAC,CAAC,OAAO,CAAC,eAAe,CAK1D,CAAC"}

package/dist/domain/posix-tree.js

@@ -2,16 +2,24 @@ import { z } from 'zod';
 import { serializableKeySchema, createNavNodeApi, createStateApi, createTreeNodeApi, createFoldsApi, createFoldsModelSchema, createCursorSchema, createCursorApi, createStateModelSchema, } from 'dirvi-lib';
 import { UnixPathSchema } from './unix-path.js';
 // -----------------------------------------------------------------------------
-// PosixName
+// PosixName: Id extends SerializableKey
 // -----------------------------------------------------------------------------
-export const PosixNameSchema = serializableKeySchema.pipe(z
+/**
+ * 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()
     .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 '..'.",
 }));
 const PosixFileEntrySchema = z
     .object({
@@ -29,7 +37,7 @@ const PosixDirectoryEntrySchema = z
     kind: z.literal('directory'),
 })
     .strict();
-export const PosixEntrySchema = z.discriminatedUnion('kind', [PosixFileEntrySchema, PosixSymlinkEntrySchema, PosixDirectoryEntrySchema]);
+export const PosixValueSchema = z.discriminatedUnion('kind', [PosixFileEntrySchema, PosixSymlinkEntrySchema, PosixDirectoryEntrySchema]);
 export const PosixTreeNodeApi = createTreeNodeApi();
 // -----------------------------------------------------------------------------
 // POSIX domain constructors
@@ -107,21 +115,21 @@ export const PosixTreeNodeModelSchema = z.lazy(() => z.union([
     // Leaf: file
     z
         .object({
-        id: PosixNameSchema,
+        id: PosixFilenameSchema,
         value: PosixFileEntrySchema,
     })
         .strict(),
     // Leaf: symlink
     z
         .object({
-        id: PosixNameSchema,
+        id: PosixFilenameSchema,
         value: PosixSymlinkEntrySchema,
     })
         .strict(),
     // Unloaded branch: directory
     z
         .object({
-        id: PosixNameSchema,
+        id: PosixFilenameSchema,
         value: PosixDirectoryEntrySchema,
         children: z.null(),
     })
@@ -129,7 +137,7 @@ export const PosixTreeNodeModelSchema = z.lazy(() => z.union([
     // Loaded branch: directory
     z
         .object({
-        id: PosixNameSchema,
+        id: PosixFilenameSchema,
         value: PosixDirectoryEntrySchema,
         children: z.array(PosixTreeNodeModelSchema),
     })
@@ -162,14 +170,14 @@ export function encodePosixTreeNode(node) {
  */
 const PosixFoldTreeNodeApi = createTreeNodeApi();
 export const PosixFoldsApi = createFoldsApi(PosixFoldTreeNodeApi);
-export const PosixFoldsModelSchema = createFoldsModelSchema(PosixNameSchema);
+export const PosixFoldsModelSchema = createFoldsModelSchema(PosixFilenameSchema);
 // -----------------------------------------------------------------------------
 // PosixCursor
 // -----------------------------------------------------------------------------
-export const PosixCursorSchema = createCursorSchema(PosixNameSchema);
+export const PosixCursorSchema = createCursorSchema(PosixFilenameSchema);
 export const PosixCursorApi = createCursorApi();
 export const PosixNavApi = createNavNodeApi(PosixTreeNodeApi, PosixFoldsApi, PosixCursorApi, {
-    compareEntries(left, right) {
+    compareSiblings(left, right) {
         return left.id.localeCompare(right.id);
     },
 });

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { posixAppPlugin as default } from './posix-fs-dirvi-app.js';
-export { posixAppPlugin } from './posix-fs-dirvi-app.js';
+export { posixAppPlugin2 as default } from './posix-fs-dirvi-app.js';
+export { posixAppPlugin2 } 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,cAAc,IAAI,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC"}
+{"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"}

package/dist/index.js

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

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 } 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>[]>;
 //# 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":"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"}

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

@@ -1,4 +1,4 @@
-import { PosixNameSchema, PosixTreeNode, } from '../domain/posix-tree.js';
+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';
@@ -7,7 +7,7 @@ export async function getDirEntries(address) {
         withFileTypes: true,
     });
     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);

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

@@ -1,4 +1,4 @@
-import { PosixEntry, PosixName } from '../domain/posix-tree.js';
+import { PosixValue, PosixId } from '../domain/posix-tree.js';
 import { UnixAbsolutePath } from '../domain/unix-path.js';
 import type { AppApi } from 'dirvi-apis';
 /**
@@ -6,5 +6,6 @@ import type { AppApi } from 'dirvi-apis';
  *
  * @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 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":"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":"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"}

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

@@ -2,66 +2,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 { PosixFoldsApi, PosixFilenameSchema, PosixNavApi, PosixTreeNode, } 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),
-    };
-}
+// 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),
+//   };
+// }
 // --- Creating Posix App API ---
 /**
  * Creates the AppApi for the POSIX app.
@@ -70,14 +77,13 @@ function decodePosixState(model) {
  */
 export function loadNodePosixAppApi(directory) {
     const unixAbsPath = getUnixAbsPath(directory ?? process.cwd());
-    const rootId = PosixNameSchema.parse(basename(unixAbsPath));
+    const rootId = PosixFilenameSchema.parse(basename(unixAbsPath));
     const apis = createAppStateApis();
     function loadBranches(path) {
         const address = join(unixAbsPath, ...path);
         return getDirEntries(address);
     }
     return {
-        appId: 'posix',
         name: unixAbsPath,
         rootId,
         loadBranches,
@@ -92,12 +98,12 @@ export function loadNodePosixAppApi(directory) {
         },
         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,
-        }),
+        // viewKey: unixAbsPath,
+        // viewApi: createFileViewApi({
+        //   directory: posixAppViewsDirectory,
+        //   encodeKey,
+        //   stateCodec: posixStateCodec,
+        // }),
         foldsApi: PosixFoldsApi,
         navNodeApi: PosixNavApi,
         ...apis,
@@ -106,7 +112,7 @@ export function loadNodePosixAppApi(directory) {
 // `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,12 @@
-import type { AppPlugin } from 'dirvi-apis/plugin';
+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;
+/**
+ * Creates applicator of AppDefinition.
+ *
+ * Input for this app is the absolute path to the directory to open on.
+ */
+export declare const posixAppPlugin2: AppPlugin2;
 //# 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":"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"}

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

@@ -1,4 +1,8 @@
-import { loadNodePosixAppApi } from './infrastructure/load-node-posix-app-api.js';
+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 { 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.
  */
@@ -10,3 +14,43 @@ export const posixAppPlugin = {
         };
     },
 };
+/**
+ * Creates applicator of AppDefinition.
+ *
+ * Input for this app is the absolute path to the directory to open on.
+ */
+export const posixAppPlugin2 = {
+    createAppDefinitionApplicator: (input) => {
+        const unixAbsPath = getUnixAbsPath(input ?? process.cwd());
+        const rootId = PosixFilenameSchema.parse(basename(unixAbsPath));
+        function loadDirectoryEntries(path) {
+            const address = join(unixAbsPath, ...path);
+            return getDirEntries(address);
+        }
+        const appDefinition = {
+            displayName: `POSIX: ${input}`,
+            rootId,
+            idSchema: PosixFilenameSchema,
+            valueSchema: PosixValueSchema,
+            createRoot: async () => {
+                // Start with root branches already loaded
+                const rootBranches = await loadDirectoryEntries([]);
+                const root = PosixTreeNode.loadedDirectory(rootId, rootBranches);
+                if (root === undefined) {
+                    throw new Error('Cannot create POSIX root: duplicate directory entry names');
+                }
+                return root;
+            },
+            loadChildren: loadDirectoryEntries,
+            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.3",
   "description": "POSIX filesystem app for dirvi.",
   "license": "GPL-3.0-or-later",
   "type": "module",
@@ -19,8 +19,8 @@
     "node": ">=22"
   },
   "dependencies": {
-    "dirvi-apis": "0.11.0-beta.1",
-    "dirvi-lib": "0.11.0-beta.1",
+    "dirvi-apis": "0.11.0-beta.3",
+    "dirvi-lib": "0.11.0-beta.3",
     "zod": "^4.4.3",
     "env-paths": "^4.0.0"
   },