@soulcraft/brainy 3.10.1 → 3.13.0

package/dist/vfs/PathResolver.d.ts

@@ -40,10 +40,12 @@ export declare class PathResolver {
     private fullResolve;
     /**
      * Resolve a child entity by name within a parent directory
+     * Uses proper graph relationships instead of metadata queries
      */
     private resolveChild;
     /**
      * Get all children of a directory
+     * Uses proper graph relationships to traverse the tree
      */
     getChildren(dirId: string): Promise<VFSEntity[]>;
     /**

package/dist/vfs/PathResolver.js

@@ -122,69 +122,56 @@ export class PathResolver {
     }
     /**
      * Resolve a child entity by name within a parent directory
+     * Uses proper graph relationships instead of metadata queries
      */
     async resolveChild(parentId, name) {
         // Check parent cache first
         const cachedChildren = this.parentCache.get(parentId);
         if (cachedChildren && cachedChildren.has(name)) {
-            // We know this child exists, find it by path since parent queries don't work
-            const parentEntity = await this.getEntity(parentId);
-            const parentPath = parentEntity.metadata.path;
-            const childPath = this.joinPath(parentPath, name);
-            const pathResults = await this.brain.find({
-                where: { path: childPath },
-                limit: 1
-            });
-            if (pathResults.length > 0) {
-                return pathResults[0].entity.id;
-            }
+            // Use cached knowledge to quickly find the child
+            // Still need to verify it exists
         }
-        // Since parent field queries don't work reliably, construct the expected path
-        // and query by path instead
-        const parentEntity = await this.getEntity(parentId);
-        const parentPath = parentEntity.metadata.path;
-        const childPath = this.joinPath(parentPath, name);
-        const results = await this.brain.find({
-            where: { path: childPath },
-            limit: 1
+        // Use proper graph traversal to find children
+        // Get all relationships where parentId contains other entities
+        const relations = await this.brain.getRelations({
+            from: parentId,
+            type: VerbType.Contains
         });
-        if (results.length > 0) {
-            const childId = results[0].entity.id;
-            // Update parent cache
-            if (!this.parentCache.has(parentId)) {
-                this.parentCache.set(parentId, new Set());
+        // Find the child with matching name
+        for (const relation of relations) {
+            const childEntity = await this.brain.get(relation.to);
+            if (childEntity && childEntity.metadata?.name === name) {
+                // Update parent cache
+                if (!this.parentCache.has(parentId)) {
+                    this.parentCache.set(parentId, new Set());
+                }
+                this.parentCache.get(parentId).add(name);
+                return childEntity.id;
             }
-            this.parentCache.get(parentId).add(name);
-            return childId;
         }
         return null;
     }
     /**
      * Get all children of a directory
+     * Uses proper graph relationships to traverse the tree
      */
     async getChildren(dirId) {
-        // Use Brainy's relationship query to find all children
-        const results = await this.brain.find({
-            connected: {
-                from: dirId,
-                via: VerbType.Contains
-            },
-            limit: 10000 // Large limit for directories
+        // Use proper graph API to get all Contains relationships from this directory
+        const relations = await this.brain.getRelations({
+            from: dirId,
+            type: VerbType.Contains
         });
-        // Filter and process valid VFS entities only
         const validChildren = [];
         const childNames = new Set();
-        for (const result of results) {
-            const entity = result.entity;
-            // Only include entities with proper VFS metadata and non-empty names
-            if (entity.metadata?.vfsType &&
-                entity.metadata?.name &&
-                entity.metadata?.path &&
-                entity.id !== dirId) { // Don't include the directory itself
+        // Fetch all child entities
+        for (const relation of relations) {
+            const entity = await this.brain.get(relation.to);
+            if (entity && entity.metadata?.vfsType && entity.metadata?.name) {
                 validChildren.push(entity);
                 childNames.add(entity.metadata.name);
             }
         }
+        // Update cache
         this.parentCache.set(dirId, childNames);
         return validChildren;
     }

package/dist/vfs/TreeUtils.d.ts

@@ -0,0 +1,67 @@
+/**
+ * VFS Tree Utilities
+ * Provides safe tree operations that prevent common recursion issues
+ */
+import { VFSEntity } from './types.js';
+export interface TreeNode {
+    name: string;
+    path: string;
+    type: 'file' | 'directory';
+    entityId?: string;
+    children?: TreeNode[];
+    metadata?: any;
+}
+export interface TreeOptions {
+    maxDepth?: number;
+    includeHidden?: boolean;
+    filter?: (node: VFSEntity) => boolean;
+    sort?: 'name' | 'modified' | 'size';
+    expandAll?: boolean;
+}
+/**
+ * Tree utility functions for VFS
+ * These functions ensure proper tree structure without recursion issues
+ */
+export declare class VFSTreeUtils {
+    /**
+     * Build a safe tree structure from VFS entities
+     * Guarantees no directory appears as its own child
+     */
+    static buildTree(entities: VFSEntity[], rootPath?: string, options?: TreeOptions): TreeNode;
+    /**
+     * Get direct children only - guaranteed no self-inclusion
+     */
+    static getDirectChildren(entities: VFSEntity[], parentPath: string): VFSEntity[];
+    /**
+     * Get all descendants (recursive children)
+     */
+    static getDescendants(entities: VFSEntity[], ancestorPath: string, includeAncestor?: boolean): VFSEntity[];
+    /**
+     * Flatten a tree structure back to a list
+     */
+    static flattenTree(node: TreeNode): TreeNode[];
+    /**
+     * Find a node in the tree by path
+     */
+    static findNode(root: TreeNode, targetPath: string): TreeNode | null;
+    /**
+     * Calculate tree statistics
+     */
+    static getTreeStats(node: TreeNode): {
+        totalNodes: number;
+        files: number;
+        directories: number;
+        maxDepth: number;
+        totalSize?: number;
+    };
+    private static getParentPath;
+    private static sortTreeNodes;
+    private static limitDepth;
+    /**
+     * Validate tree structure - ensures no recursion
+     */
+    static validateTree(node: TreeNode, visited?: Set<string>): {
+        valid: boolean;
+        errors: string[];
+    };
+}

package/dist/vfs/TreeUtils.js

@@ -0,0 +1,268 @@
+/**
+ * VFS Tree Utilities
+ * Provides safe tree operations that prevent common recursion issues
+ */
+/**
+ * Tree utility functions for VFS
+ * These functions ensure proper tree structure without recursion issues
+ */
+export class VFSTreeUtils {
+    /**
+     * Build a safe tree structure from VFS entities
+     * Guarantees no directory appears as its own child
+     */
+    static buildTree(entities, rootPath = '/', options = {}) {
+        const pathToEntity = new Map();
+        const pathToNode = new Map();
+        // First pass: index all entities by path
+        for (const entity of entities) {
+            const path = entity.metadata.path;
+            // Critical: Skip if entity IS the root we're building from
+            if (path === rootPath) {
+                continue;
+            }
+            pathToEntity.set(path, entity);
+        }
+        // Create root node
+        const rootNode = {
+            name: rootPath === '/' ? 'root' : rootPath.split('/').pop(),
+            path: rootPath,
+            type: 'directory',
+            children: []
+        };
+        pathToNode.set(rootPath, rootNode);
+        // Second pass: build tree structure
+        const sortedPaths = Array.from(pathToEntity.keys()).sort();
+        for (const path of sortedPaths) {
+            const entity = pathToEntity.get(path);
+            // Apply filter if provided
+            if (options.filter && !options.filter(entity)) {
+                continue;
+            }
+            // Skip hidden files if requested
+            if (!options.includeHidden && entity.metadata.name.startsWith('.')) {
+                continue;
+            }
+            // Create node for this entity
+            const node = {
+                name: entity.metadata.name,
+                path: entity.metadata.path,
+                type: entity.metadata.vfsType === 'directory' ? 'directory' : 'file',
+                entityId: entity.id,
+                metadata: entity.metadata
+            };
+            if (entity.metadata.vfsType === 'directory') {
+                node.children = [];
+            }
+            pathToNode.set(path, node);
+            // Find parent and attach
+            const parentPath = this.getParentPath(path);
+            const parentNode = pathToNode.get(parentPath);
+            if (parentNode && parentNode.children) {
+                parentNode.children.push(node);
+            }
+        }
+        // Sort children if requested
+        if (options.sort) {
+            this.sortTreeNodes(rootNode, options.sort);
+        }
+        // Apply depth limit if specified
+        if (options.maxDepth !== undefined) {
+            this.limitDepth(rootNode, options.maxDepth);
+        }
+        return rootNode;
+    }
+    /**
+     * Get direct children only - guaranteed no self-inclusion
+     */
+    static getDirectChildren(entities, parentPath) {
+        const children = [];
+        const parentDepth = parentPath === '/' ? 0 : parentPath.split('/').length - 1;
+        for (const entity of entities) {
+            const path = entity.metadata.path;
+            // Critical check 1: Skip if this IS the parent
+            if (path === parentPath) {
+                continue;
+            }
+            // Check if entity is a direct child
+            if (path.startsWith(parentPath)) {
+                const relativePath = parentPath === '/'
+                    ? path.substring(1)
+                    : path.substring(parentPath.length + 1);
+                // Direct child has no additional slashes
+                if (!relativePath.includes('/')) {
+                    children.push(entity);
+                }
+            }
+        }
+        return children;
+    }
+    /**
+     * Get all descendants (recursive children)
+     */
+    static getDescendants(entities, ancestorPath, includeAncestor = false) {
+        const descendants = [];
+        for (const entity of entities) {
+            const path = entity.metadata.path;
+            // Include ancestor only if explicitly requested
+            if (path === ancestorPath) {
+                if (includeAncestor) {
+                    descendants.push(entity);
+                }
+                continue;
+            }
+            // Check if entity is under ancestor path
+            const prefix = ancestorPath === '/' ? '/' : ancestorPath + '/';
+            if (path.startsWith(prefix)) {
+                descendants.push(entity);
+            }
+        }
+        return descendants;
+    }
+    /**
+     * Flatten a tree structure back to a list
+     */
+    static flattenTree(node) {
+        const result = [node];
+        if (node.children) {
+            for (const child of node.children) {
+                result.push(...this.flattenTree(child));
+            }
+        }
+        return result;
+    }
+    /**
+     * Find a node in the tree by path
+     */
+    static findNode(root, targetPath) {
+        if (root.path === targetPath) {
+            return root;
+        }
+        if (root.children) {
+            for (const child of root.children) {
+                const found = this.findNode(child, targetPath);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    }
+    /**
+     * Calculate tree statistics
+     */
+    static getTreeStats(node) {
+        let stats = {
+            totalNodes: 0,
+            files: 0,
+            directories: 0,
+            maxDepth: 0,
+            totalSize: 0
+        };
+        function traverse(n, depth) {
+            stats.totalNodes++;
+            stats.maxDepth = Math.max(stats.maxDepth, depth);
+            if (n.type === 'file') {
+                stats.files++;
+                if (n.metadata?.size) {
+                    stats.totalSize += n.metadata.size;
+                }
+            }
+            else {
+                stats.directories++;
+            }
+            if (n.children) {
+                for (const child of n.children) {
+                    traverse(child, depth + 1);
+                }
+            }
+        }
+        traverse(node, 0);
+        return stats;
+    }
+    // Helper methods
+    static getParentPath(path) {
+        if (path === '/')
+            return '/';
+        const parts = path.split('/');
+        parts.pop();
+        return parts.length === 1 ? '/' : parts.join('/');
+    }
+    static sortTreeNodes(node, sortBy) {
+        if (!node.children)
+            return;
+        node.children.sort((a, b) => {
+            // Directories first, then files
+            if (a.type !== b.type) {
+                return a.type === 'directory' ? -1 : 1;
+            }
+            switch (sortBy) {
+                case 'name':
+                    return a.name.localeCompare(b.name);
+                case 'modified':
+                    const aTime = a.metadata?.modified || 0;
+                    const bTime = b.metadata?.modified || 0;
+                    return bTime - aTime;
+                case 'size':
+                    const aSize = a.metadata?.size || 0;
+                    const bSize = b.metadata?.size || 0;
+                    return bSize - aSize;
+                default:
+                    return 0;
+            }
+        });
+        // Recursively sort children
+        for (const child of node.children) {
+            this.sortTreeNodes(child, sortBy);
+        }
+    }
+    static limitDepth(node, maxDepth, currentDepth = 0) {
+        if (currentDepth >= maxDepth) {
+            delete node.children;
+            return;
+        }
+        if (node.children) {
+            for (const child of node.children) {
+                this.limitDepth(child, maxDepth, currentDepth + 1);
+            }
+        }
+    }
+    /**
+     * Validate tree structure - ensures no recursion
+     */
+    static validateTree(node, visited = new Set()) {
+        const errors = [];
+        // Check for cycles
+        if (visited.has(node.path)) {
+            errors.push(`Cycle detected at path: ${node.path}`);
+            return { valid: false, errors };
+        }
+        visited.add(node.path);
+        // Check children
+        if (node.children) {
+            const childPaths = new Set();
+            for (const child of node.children) {
+                // Check for duplicate children
+                if (childPaths.has(child.path)) {
+                    errors.push(`Duplicate child path: ${child.path}`);
+                }
+                childPaths.add(child.path);
+                // Check child is not parent
+                if (child.path === node.path) {
+                    errors.push(`Directory contains itself: ${node.path}`);
+                }
+                // Check child is actually under parent
+                if (node.path !== '/' && !child.path.startsWith(node.path + '/')) {
+                    errors.push(`Child ${child.path} not under parent ${node.path}`);
+                }
+                // Recursively validate children
+                const childValidation = this.validateTree(child, new Set(visited));
+                errors.push(...childValidation.errors);
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+}
+//# sourceMappingURL=TreeUtils.js.map

package/dist/vfs/VirtualFileSystem.d.ts

@@ -52,6 +52,37 @@ export declare class VirtualFileSystem implements IVirtualFileSystem {
      * Delete a file
      */
     unlink(path: string): Promise<void>;
+    /**
+     * Get only direct children of a directory - guaranteed no self-inclusion
+     * This is the SAFE way to get children for building tree UIs
+     */
+    getDirectChildren(path: string): Promise<VFSEntity[]>;
+    /**
+     * Get a properly structured tree for the given path
+     * This prevents recursion issues common when building file explorers
+     */
+    getTreeStructure(path: string, options?: {
+        maxDepth?: number;
+        includeHidden?: boolean;
+        sort?: 'name' | 'modified' | 'size';
+    }): Promise<any>;
+    /**
+     * Get all descendants of a directory (flat list)
+     */
+    getDescendants(path: string, options?: {
+        includeAncestor?: boolean;
+        type?: 'file' | 'directory';
+    }): Promise<VFSEntity[]>;
+    /**
+     * Inspect a path and return structured information
+     * This is the recommended method for file explorers to use
+     */
+    inspect(path: string): Promise<{
+        node: VFSEntity;
+        children: VFSEntity[];
+        parent: VFSEntity | null;
+        stats: VFSStats;
+    }>;
     /**
      * Create a directory
      */

package/dist/vfs/VirtualFileSystem.js

@@ -322,6 +322,116 @@ export class VirtualFileSystem {
         this.triggerWatchers(path, 'rename');
         // Knowledge Layer hooks will be added by augmentation if enabled
     }
+    // ============= Tree Operations (NEW) =============
+    /**
+     * Get only direct children of a directory - guaranteed no self-inclusion
+     * This is the SAFE way to get children for building tree UIs
+     */
+    async getDirectChildren(path) {
+        await this.ensureInitialized();
+        const entityId = await this.pathResolver.resolve(path);
+        const entity = await this.getEntityById(entityId);
+        // Verify it's a directory
+        if (entity.metadata.vfsType !== 'directory') {
+            throw new VFSError(VFSErrorCode.ENOTDIR, `Not a directory: ${path}`, path, 'getDirectChildren');
+        }
+        // Use the safe getChildren from PathResolver
+        const children = await this.pathResolver.getChildren(entityId);
+        // Double-check no self-inclusion (paranoid safety)
+        return children.filter(child => child.metadata.path !== path);
+    }
+    /**
+     * Get a properly structured tree for the given path
+     * This prevents recursion issues common when building file explorers
+     */
+    async getTreeStructure(path, options) {
+        await this.ensureInitialized();
+        const { VFSTreeUtils } = await import('./TreeUtils.js');
+        const entityId = await this.pathResolver.resolve(path);
+        const entity = await this.getEntityById(entityId);
+        if (entity.metadata.vfsType !== 'directory') {
+            throw new VFSError(VFSErrorCode.ENOTDIR, `Not a directory: ${path}`, path, 'getTreeStructure');
+        }
+        // Recursively gather all descendants
+        const allEntities = [];
+        const visited = new Set();
+        const gatherDescendants = async (dirId) => {
+            if (visited.has(dirId))
+                return; // Prevent cycles
+            visited.add(dirId);
+            const children = await this.pathResolver.getChildren(dirId);
+            for (const child of children) {
+                allEntities.push(child);
+                if (child.metadata.vfsType === 'directory') {
+                    await gatherDescendants(child.id);
+                }
+            }
+        };
+        await gatherDescendants(entityId);
+        // Build safe tree structure
+        return VFSTreeUtils.buildTree(allEntities, path, options || {});
+    }
+    /**
+     * Get all descendants of a directory (flat list)
+     */
+    async getDescendants(path, options) {
+        await this.ensureInitialized();
+        const entityId = await this.pathResolver.resolve(path);
+        const entity = await this.getEntityById(entityId);
+        if (entity.metadata.vfsType !== 'directory') {
+            throw new VFSError(VFSErrorCode.ENOTDIR, `Not a directory: ${path}`, path, 'getDescendants');
+        }
+        const descendants = [];
+        if (options?.includeAncestor) {
+            descendants.push(entity);
+        }
+        const visited = new Set();
+        const queue = [entityId];
+        while (queue.length > 0) {
+            const currentId = queue.shift();
+            if (visited.has(currentId))
+                continue;
+            visited.add(currentId);
+            const children = await this.pathResolver.getChildren(currentId);
+            for (const child of children) {
+                // Filter by type if specified
+                if (!options?.type || child.metadata.vfsType === options.type) {
+                    descendants.push(child);
+                }
+                // Add directories to queue for traversal
+                if (child.metadata.vfsType === 'directory') {
+                    queue.push(child.id);
+                }
+            }
+        }
+        return descendants;
+    }
+    /**
+     * Inspect a path and return structured information
+     * This is the recommended method for file explorers to use
+     */
+    async inspect(path) {
+        await this.ensureInitialized();
+        const entityId = await this.pathResolver.resolve(path);
+        const entity = await this.getEntityById(entityId);
+        const stats = await this.stat(path);
+        let children = [];
+        if (entity.metadata.vfsType === 'directory') {
+            children = await this.getDirectChildren(path);
+        }
+        let parent = null;
+        if (path !== '/') {
+            const parentPath = path.substring(0, path.lastIndexOf('/')) || '/';
+            const parentId = await this.pathResolver.resolve(parentPath);
+            parent = await this.getEntityById(parentId);
+        }
+        return {
+            node: entity,
+            children,
+            parent,
+            stats
+        };
+    }
     // ============= Directory Operations =============
     /**
      * Create a directory
@@ -1364,37 +1474,29 @@ export class VirtualFileSystem {
         await this.ensureInitialized();
         const entityId = await this.pathResolver.resolve(path);
         const results = [];
-        // Get all relationships involving this entity (both from and to)
+        // Use proper Brainy relationship API to get all relationships
         const [fromRelations, toRelations] = await Promise.all([
-            this.brain.find({
-                connected: {
-                    from: entityId
-                },
-                limit: 1000
-            }),
-            this.brain.find({
-                connected: {
-                    to: entityId
-                },
-                limit: 1000
-            })
+            this.brain.getRelations({ from: entityId }),
+            this.brain.getRelations({ to: entityId })
         ]);
         // Add outgoing relationships
         for (const rel of fromRelations) {
-            if (rel.entity.metadata?.path) {
+            const targetEntity = await this.brain.get(rel.to);
+            if (targetEntity && targetEntity.metadata?.path) {
                 results.push({
-                    path: rel.entity.metadata.path,
-                    relationship: 'related',
+                    path: targetEntity.metadata.path,
+                    relationship: rel.type || 'related',
                     direction: 'from'
                 });
             }
         }
         // Add incoming relationships
         for (const rel of toRelations) {
-            if (rel.entity.metadata?.path) {
+            const sourceEntity = await this.brain.get(rel.from);
+            if (sourceEntity && sourceEntity.metadata?.path) {
                 results.push({
-                    path: rel.entity.metadata.path,
-                    relationship: 'related',
+                    path: sourceEntity.metadata.path,
+                    relationship: rel.type || 'related',
                     direction: 'to'
                 });
             }
@@ -1405,49 +1507,37 @@ export class VirtualFileSystem {
         await this.ensureInitialized();
         const entityId = await this.pathResolver.resolve(path);
         const relationships = [];
-        // Get all relationships involving this entity (both from and to)
+        // Use proper Brainy relationship API
         const [fromRelations, toRelations] = await Promise.all([
-            this.brain.find({
-                connected: {
-                    from: entityId
-                },
-                limit: 1000
-            }),
-            this.brain.find({
-                connected: {
-                    to: entityId
-                },
-                limit: 1000
-            })
+            this.brain.getRelations({ from: entityId }),
+            this.brain.getRelations({ to: entityId })
         ]);
-        // Add outgoing relationships (exclude parent-child relationships)
+        // Process outgoing relationships (excluding Contains for parent-child)
         for (const rel of fromRelations) {
-            if (rel.entity.metadata?.path && rel.entity.metadata?.vfsType) {
-                // Skip parent-child relationships to focus on user-defined relationships
-                const parentPath = this.getParentPath(rel.entity.metadata.path);
-                if (parentPath !== path) { // Not a direct child
+            if (rel.type !== VerbType.Contains) { // Skip filesystem hierarchy
+                const targetEntity = await this.brain.get(rel.to);
+                if (targetEntity && targetEntity.metadata?.path) {
                     relationships.push({
-                        id: crypto.randomUUID(),
-                        from: path,
-                        to: rel.entity.metadata.path,
-                        type: VerbType.References,
-                        createdAt: Date.now()
+                        id: rel.id || crypto.randomUUID(),
+                        from: entityId,
+                        to: rel.to,
+                        type: rel.type,
+                        createdAt: rel.createdAt || Date.now()
                     });
                 }
             }
         }
-        // Add incoming relationships (exclude parent-child relationships)
+        // Process incoming relationships (excluding Contains for parent-child)
         for (const rel of toRelations) {
-            if (rel.entity.metadata?.path && rel.entity.metadata?.vfsType) {
-                // Skip parent-child relationships to focus on user-defined relationships
-                const parentPath = this.getParentPath(path);
-                if (rel.entity.metadata.path !== parentPath) { // Not the parent
+            if (rel.type !== VerbType.Contains) { // Skip filesystem hierarchy
+                const sourceEntity = await this.brain.get(rel.from);
+                if (sourceEntity && sourceEntity.metadata?.path) {
                     relationships.push({
-                        id: crypto.randomUUID(),
-                        from: rel.entity.metadata.path,
-                        to: path,
-                        type: VerbType.References,
-                        createdAt: Date.now()
+                        id: rel.id || crypto.randomUUID(),
+                        from: rel.from,
+                        to: entityId,
+                        type: rel.type,
+                        createdAt: rel.createdAt || Date.now()
                     });
                 }
             }

package/dist/vfs/types.d.ts

@@ -283,6 +283,22 @@ export interface IVirtualFileSystem {
         recursive?: boolean;
     }): Promise<void>;
     readdir(path: string, options?: ReaddirOptions): Promise<string[] | VFSDirent[]>;
+    getDirectChildren(path: string): Promise<VFSEntity[]>;
+    getTreeStructure(path: string, options?: {
+        maxDepth?: number;
+        includeHidden?: boolean;
+        sort?: 'name' | 'modified' | 'size';
+    }): Promise<any>;
+    getDescendants(path: string, options?: {
+        includeAncestor?: boolean;
+        type?: 'file' | 'directory';
+    }): Promise<VFSEntity[]>;
+    inspect(path: string): Promise<{
+        node: VFSEntity;
+        children: VFSEntity[];
+        parent: VFSEntity | null;
+        stats: VFSStats;
+    }>;
     stat(path: string): Promise<VFSStats>;
     lstat(path: string): Promise<VFSStats>;
     exists(path: string): Promise<boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "3.10.1",
+  "version": "3.13.0",
   "description": "Universal Knowledge Protocol™ - World's first Triple Intelligence database unifying vector, graph, and document search in one API. 31 nouns × 40 verbs for infinite expressiveness.",
   "main": "dist/index.js",
   "module": "dist/index.js",