@soulcraft/brainy 3.17.0 → 3.18.0

package/README.md

@@ -767,13 +767,12 @@ We welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
 - [Next.js Integration](docs/guides/nextjs-integration.md) - **NEW!** React and Next.js examples
 - [Vue.js Integration](docs/guides/vue-integration.md) - **NEW!** Vue and Nuxt examples
 
-### Virtual Filesystem & Knowledge Layer 🧠📁
-- [VFS Core Documentation](docs/vfs/VFS_CORE.md) - **NEW!** Complete filesystem architecture and API
-- [VFS + Knowledge Layer](docs/vfs/VFS_KNOWLEDGE_LAYER.md) - **NEW!** Intelligent knowledge management features
-- [Examples & Scenarios](docs/vfs/VFS_EXAMPLES_SCENARIOS.md) - **NEW!** Real-world use cases and code
+### Virtual Filesystem (Semantic VFS) 🧠📁
+- [VFS Core Documentation](docs/vfs/VFS_CORE.md) - Complete filesystem architecture and API
+- [Semantic VFS Guide](docs/vfs/SEMANTIC_VFS.md) - Multi-dimensional file access (6 semantic dimensions)
+- [Neural Extraction API](docs/vfs/NEURAL_EXTRACTION.md) - AI-powered concept and entity extraction
+- [Examples & Scenarios](docs/vfs/VFS_EXAMPLES_SCENARIOS.md) - Real-world use cases and code
 - [VFS API Guide](docs/vfs/VFS_API_GUIDE.md) - Complete API reference
-- [Knowledge Layer API](docs/vfs/KNOWLEDGE_LAYER_API.md) - Advanced knowledge features
-- [Knowledge Layer Overview](docs/KNOWLEDGE_LAYER_OVERVIEW.md) - Non-technical guide
 
 ### Core Documentation
 - [Getting Started Guide](docs/guides/getting-started.md)

package/dist/augmentations/defaultAugmentations.d.ts

@@ -25,7 +25,6 @@ export declare function createDefaultAugmentations(config?: {
     metrics?: boolean | Record<string, any>;
     monitoring?: boolean | Record<string, any>;
     display?: boolean | Record<string, any>;
-    knowledge?: boolean | Record<string, any>;
 }): BaseAugmentation[];
 /**
  * Get augmentation by name with type safety

package/dist/augmentations/defaultAugmentations.js

@@ -11,7 +11,6 @@ import { CacheAugmentation } from './cacheAugmentation.js';
 import { MetricsAugmentation } from './metricsAugmentation.js';
 import { MonitoringAugmentation } from './monitoringAugmentation.js';
 import { UniversalDisplayAugmentation } from './universalDisplayAugmentation.js';
-import { KnowledgeAugmentation } from './KnowledgeAugmentation.js';
 /**
  * Create default augmentations for zero-config operation
  * Returns an array of augmentations to be registered
@@ -45,10 +44,6 @@ export function createDefaultAugmentations(config = {}) {
         const monitoringConfig = typeof config.monitoring === 'object' ? config.monitoring : {};
         augmentations.push(new MonitoringAugmentation(monitoringConfig));
     }
-    // Knowledge Layer augmentation for VFS intelligence
-    if (config.knowledge !== false) {
-        augmentations.push(new KnowledgeAugmentation());
-    }
     return augmentations;
 }
 /**

package/dist/brainy.d.ts

@@ -7,6 +7,7 @@
 import { Vector } from './coreTypes.js';
 import { ImprovedNeuralAPI } from './neural/improvedNeuralAPI.js';
 import { NaturalLanguageProcessor } from './neural/naturalLanguageProcessor.js';
+import { ExtractedEntity } from './neural/entityExtractor.js';
 import { TripleIntelligenceSystem } from './triple/TripleIntelligenceSystem.js';
 import { VirtualFileSystem } from './vfs/VirtualFileSystem.js';
 import { Entity, Relation, Result, AddParams, UpdateParams, RelateParams, FindParams, SimilarParams, GetRelationsParams, AddManyParams, DeleteManyParams, RelateManyParams, BatchResult, BrainyConfig } from './types/brainy.types.js';
@@ -34,6 +35,7 @@ export declare class Brainy<T = any> implements BrainyInterface<T> {
     private originalConsole?;
     private _neural?;
     private _nlp?;
+    private _extractor?;
     private _tripleIntelligence?;
     private _vfs?;
     private initialized;
@@ -594,6 +596,50 @@ export declare class Brainy<T = any> implements BrainyInterface<T> {
      * Natural Language Processing API
      */
     nlp(): NaturalLanguageProcessor;
+    /**
+     * Entity Extraction API - Neural extraction with NounType taxonomy
+     *
+     * Extracts entities from text using:
+     * - Pattern-based candidate detection
+     * - Embedding-based type classification
+     * - Context-aware confidence scoring
+     *
+     * @param text - Text to extract entities from
+     * @param options - Extraction options
+     * @returns Array of extracted entities with types and confidence
+     *
+     * @example
+     * const entities = await brain.extract('John Smith founded Acme Corp in New York')
+     * // [
+     * //   { text: 'John Smith', type: NounType.Person, confidence: 0.95 },
+     * //   { text: 'Acme Corp', type: NounType.Organization, confidence: 0.92 },
+     * //   { text: 'New York', type: NounType.Location, confidence: 0.88 }
+     * // ]
+     */
+    extract(text: string, options?: {
+        types?: NounType[];
+        confidence?: number;
+        includeVectors?: boolean;
+        neuralMatching?: boolean;
+    }): Promise<ExtractedEntity[]>;
+    /**
+     * Extract concepts from text
+     *
+     * Simplified interface for concept/topic extraction
+     * Returns only concept names as strings for easy metadata population
+     *
+     * @param text - Text to extract concepts from
+     * @param options - Extraction options
+     * @returns Array of concept names
+     *
+     * @example
+     * const concepts = await brain.extractConcepts('Using OAuth for authentication')
+     * // ['oauth', 'authentication']
+     */
+    extractConcepts(text: string, options?: {
+        confidence?: number;
+        limit?: number;
+    }): Promise<string[]>;
     /**
      * Virtual File System API - Knowledge Operating System
      */

package/dist/brainy.js

@@ -13,6 +13,7 @@ import { AugmentationRegistry } from './augmentations/brainyAugmentation.js';
 import { createDefaultAugmentations } from './augmentations/defaultAugmentations.js';
 import { ImprovedNeuralAPI } from './neural/improvedNeuralAPI.js';
 import { NaturalLanguageProcessor } from './neural/naturalLanguageProcessor.js';
+import { NeuralEntityExtractor } from './neural/entityExtractor.js';
 import { TripleIntelligenceSystem } from './triple/TripleIntelligenceSystem.js';
 import { VirtualFileSystem } from './vfs/VirtualFileSystem.js';
 import { MetadataIndexManager } from './utils/metadataIndex.js';
@@ -1357,6 +1358,58 @@ export class Brainy {
         }
         return this._nlp;
     }
+    /**
+     * Entity Extraction API - Neural extraction with NounType taxonomy
+     *
+     * Extracts entities from text using:
+     * - Pattern-based candidate detection
+     * - Embedding-based type classification
+     * - Context-aware confidence scoring
+     *
+     * @param text - Text to extract entities from
+     * @param options - Extraction options
+     * @returns Array of extracted entities with types and confidence
+     *
+     * @example
+     * const entities = await brain.extract('John Smith founded Acme Corp in New York')
+     * // [
+     * //   { text: 'John Smith', type: NounType.Person, confidence: 0.95 },
+     * //   { text: 'Acme Corp', type: NounType.Organization, confidence: 0.92 },
+     * //   { text: 'New York', type: NounType.Location, confidence: 0.88 }
+     * // ]
+     */
+    async extract(text, options) {
+        if (!this._extractor) {
+            this._extractor = new NeuralEntityExtractor(this);
+        }
+        return await this._extractor.extract(text, options);
+    }
+    /**
+     * Extract concepts from text
+     *
+     * Simplified interface for concept/topic extraction
+     * Returns only concept names as strings for easy metadata population
+     *
+     * @param text - Text to extract concepts from
+     * @param options - Extraction options
+     * @returns Array of concept names
+     *
+     * @example
+     * const concepts = await brain.extractConcepts('Using OAuth for authentication')
+     * // ['oauth', 'authentication']
+     */
+    async extractConcepts(text, options) {
+        const entities = await this.extract(text, {
+            types: [NounType.Concept, NounType.Topic],
+            confidence: options?.confidence || 0.7,
+            neuralMatching: true
+        });
+        // Deduplicate and normalize
+        const conceptSet = new Set(entities.map(e => e.text.toLowerCase()));
+        const concepts = Array.from(conceptSet);
+        // Apply limit if specified
+        return options?.limit ? concepts.slice(0, options.limit) : concepts;
+    }
     /**
      * Virtual File System API - Knowledge Operating System
      */

package/dist/neural/embeddedPatterns.d.ts

@@ -2,7 +2,7 @@
  * 🧠 BRAINY EMBEDDED PATTERNS
  *
  * AUTO-GENERATED - DO NOT EDIT
- * Generated: 2025-09-15T16:41:42.483Z
+ * Generated: 2025-09-29T17:05:30.153Z
  * Patterns: 220
  * Coverage: 94-98% of all queries
  *

package/dist/neural/embeddedPatterns.js

@@ -2,7 +2,7 @@
  * 🧠 BRAINY EMBEDDED PATTERNS
  *
  * AUTO-GENERATED - DO NOT EDIT
- * Generated: 2025-09-15T16:41:42.483Z
+ * Generated: 2025-09-29T17:05:30.153Z
  * Patterns: 220
  * Coverage: 94-98% of all queries
  *

package/dist/neural/naturalLanguageProcessor.js

@@ -1015,7 +1015,6 @@ export class NaturalLanguageProcessor {
                         confidence
                     };
                     if (options?.includeMetadata) {
-                        ;
                         entity.metadata = {
                             pattern: pattern.source,
                             contextBefore: text.substring(Math.max(0, match.index - 20), match.index),

package/dist/setup.js

@@ -34,7 +34,6 @@ if (globalObj) {
         globalObj.TextDecoder = TextDecoder;
     }
     // Create special global constructors for library compatibility
-    ;
     globalObj.__TextEncoder__ = TextEncoder;
     globalObj.__TextDecoder__ = TextDecoder;
 }

package/dist/unified.js

@@ -41,7 +41,6 @@ export const environment = {
 };
 // Make environment information available globally
 if (typeof globalThis !== 'undefined') {
-    ;
     globalThis.__ENV__ = environment;
 }
 // Log the detected environment

package/dist/vfs/VirtualFileSystem.d.ts

@@ -19,6 +19,7 @@ import { IVirtualFileSystem, VFSConfig, VFSEntity, VFSMetadata, VFSStats, VFSDir
 export declare class VirtualFileSystem implements IVirtualFileSystem {
     private brain;
     private pathResolver;
+    private projectionRegistry;
     private config;
     private rootEntityId?;
     private initialized;
@@ -35,6 +36,11 @@ export declare class VirtualFileSystem implements IVirtualFileSystem {
     /**
      * Create or find the root directory entity
      */
+    /**
+     * Auto-register built-in projection strategies
+     * Zero-config: All semantic dimensions work out of the box
+     */
+    private registerBuiltInProjections;
     private initializeRoot;
     /**
      * Read a file's content
@@ -183,10 +189,6 @@ export declare class VirtualFileSystem implements IVirtualFileSystem {
      * Merges with existing metadata
      */
     setMetadata(path: string, metadata: Partial<VFSMetadata>): Promise<void>;
-    /**
-     * Enable Knowledge Layer on this VFS instance
-     */
-    enableKnowledgeLayer(): Promise<void>;
     /**
      * Set the current user for tracking who makes changes
      */

package/dist/vfs/VirtualFileSystem.js

@@ -7,8 +7,8 @@
 import crypto from 'crypto';
 import { Brainy } from '../brainy.js';
 import { NounType, VerbType } from '../types/graphTypes.js';
-import { PathResolver } from './PathResolver.js';
-// Knowledge Layer imports removed - now in KnowledgeAugmentation
+import { SemanticPathResolver, ProjectionRegistry, ConceptProjection, AuthorProjection, TemporalProjection, RelationshipProjection, SimilarityProjection, TagProjection } from './semantic/index.js';
+// Knowledge Layer can remain as optional augmentation for now
 import { VFSError, VFSErrorCode } from './types.js';
 /**
  * Main Virtual Filesystem Implementation
@@ -46,12 +46,12 @@ export class VirtualFileSystem {
         }
         // Create or find root entity
         this.rootEntityId = await this.initializeRoot();
-        // Initialize path resolver
-        this.pathResolver = new PathResolver(this.brain, this.rootEntityId, {
-            maxCacheSize: this.config.cache?.maxPaths,
-            cacheTTL: this.config.cache?.ttl,
-            hotPathThreshold: 10
-        });
+        // Initialize projection registry with auto-discovery of built-in projections
+        this.projectionRegistry = new ProjectionRegistry();
+        this.registerBuiltInProjections();
+        // Initialize semantic path resolver (zero-config, uses brain.config)
+        this.pathResolver = new SemanticPathResolver(this.brain, this, // Pass VFS instance for resolvePath
+        this.rootEntityId, this.projectionRegistry);
         // Knowledge Layer is now a separate augmentation
         // Enable with: brain.use('knowledge')
         // Start background tasks
@@ -61,6 +61,31 @@ export class VirtualFileSystem {
     /**
      * Create or find the root directory entity
      */
+    /**
+     * Auto-register built-in projection strategies
+     * Zero-config: All semantic dimensions work out of the box
+     */
+    registerBuiltInProjections() {
+        const projections = [
+            ConceptProjection,
+            AuthorProjection,
+            TemporalProjection,
+            RelationshipProjection,
+            SimilarityProjection,
+            TagProjection
+        ];
+        for (const ProjectionClass of projections) {
+            try {
+                this.projectionRegistry.register(new ProjectionClass());
+            }
+            catch (err) {
+                // Silently skip if already registered (e.g., in tests)
+                if (!(err instanceof Error && err.message.includes('already registered'))) {
+                    throw err;
+                }
+            }
+        }
+    }
     async initializeRoot() {
         // Check if root already exists - search using where clause
         const existing = await this.brain.find({
@@ -1026,6 +1051,17 @@ export class VirtualFileSystem {
             metadata.lineCount = text.split('\n').length;
             metadata.wordCount = text.split(/\s+/).filter(w => w).length;
             metadata.charset = 'utf-8';
+            // Extract concepts using brain.extractConcepts() (neural extraction)
+            if (this.config.intelligence?.autoConcepts) {
+                try {
+                    const concepts = await this.brain.extractConcepts(text, { limit: 20 });
+                    metadata.conceptNames = concepts; // Flattened for O(log n) queries
+                }
+                catch (error) {
+                    // Concept extraction is optional - don't fail if it errors
+                    console.debug('Concept extraction failed:', error);
+                }
+            }
         }
         // Extract hash for integrity
         const crypto = await import('crypto');
@@ -1193,9 +1229,6 @@ export class VirtualFileSystem {
                 maxFileSize: 1000000000, // 1GB
                 maxPathLength: 4096,
                 maxDirectoryEntries: 100000
-            },
-            knowledgeLayer: {
-                enabled: false // Default to disabled
             }
         };
     }
@@ -1732,16 +1765,6 @@ export class VirtualFileSystem {
         // Invalidate caches
         this.invalidateCaches(path);
     }
-    // ============= Knowledge Layer =============
-    // Knowledge Layer methods are added by KnowledgeLayer.enable()
-    // This keeps VFS pure and fast while allowing optional intelligence
-    /**
-     * Enable Knowledge Layer on this VFS instance
-     */
-    async enableKnowledgeLayer() {
-        const { enableKnowledgeLayer } = await import('./KnowledgeLayer.js');
-        await enableKnowledgeLayer(this, this.brain);
-    }
     /**
      * Set the current user for tracking who makes changes
      */

package/dist/vfs/index.d.ts

@@ -11,9 +11,4 @@ export { FSCompat, createFS } from './FSCompat.js';
 export { DirectoryImporter } from './importers/DirectoryImporter.js';
 export { VFSReadStream } from './streams/VFSReadStream.js';
 export { VFSWriteStream } from './streams/VFSWriteStream.js';
-export { EventRecorder } from './EventRecorder.js';
-export { SemanticVersioning } from './SemanticVersioning.js';
-export { PersistentEntitySystem } from './PersistentEntitySystem.js';
-export { ConceptSystem } from './ConceptSystem.js';
-export { GitBridge } from './GitBridge.js';
 export { VirtualFileSystem as VFS } from './VirtualFileSystem.js';

package/dist/vfs/index.js

@@ -15,12 +15,6 @@ export { DirectoryImporter } from './importers/DirectoryImporter.js';
 // Streaming
 export { VFSReadStream } from './streams/VFSReadStream.js';
 export { VFSWriteStream } from './streams/VFSWriteStream.js';
-// Knowledge Layer Components (optional via augmentation)
-export { EventRecorder } from './EventRecorder.js';
-export { SemanticVersioning } from './SemanticVersioning.js';
-export { PersistentEntitySystem } from './PersistentEntitySystem.js';
-export { ConceptSystem } from './ConceptSystem.js';
-export { GitBridge } from './GitBridge.js';
 // Convenience alias
 export { VirtualFileSystem as VFS } from './VirtualFileSystem.js';
 //# sourceMappingURL=index.js.map

package/dist/vfs/semantic/ProjectionRegistry.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Projection Registry
+ *
+ * Central registry for all projection strategies
+ * Manages strategy lookup and execution
+ */
+import { ProjectionStrategy } from './ProjectionStrategy.js';
+import { Brainy } from '../../brainy.js';
+import { VirtualFileSystem } from '../VirtualFileSystem.js';
+import { VFSEntity } from '../types.js';
+/**
+ * Registry for projection strategies
+ * Allows dynamic registration and lookup of strategies
+ */
+export declare class ProjectionRegistry {
+    private strategies;
+    /**
+     * Register a projection strategy
+     * @param strategy - The strategy to register
+     * @throws Error if strategy with same name already registered
+     */
+    register(strategy: ProjectionStrategy): void;
+    /**
+     * Get a projection strategy by name
+     * @param name - Strategy name
+     * @returns The strategy or undefined if not found
+     */
+    get(name: string): ProjectionStrategy | undefined;
+    /**
+     * Check if a strategy is registered
+     * @param name - Strategy name
+     */
+    has(name: string): boolean;
+    /**
+     * List all registered strategy names
+     */
+    listDimensions(): string[];
+    /**
+     * Get count of registered strategies
+     */
+    count(): number;
+    /**
+     * Resolve a dimension value to entity IDs
+     * Convenience method that looks up strategy and calls resolve()
+     *
+     * @param dimension - The semantic dimension
+     * @param value - The value to resolve
+     * @param brain - REAL Brainy instance
+     * @param vfs - REAL VirtualFileSystem instance
+     * @returns Array of entity IDs
+     * @throws Error if dimension not registered
+     */
+    resolve(dimension: string, value: any, brain: Brainy, vfs: VirtualFileSystem): Promise<string[]>;
+    /**
+     * List entities in a dimension
+     * Convenience method for strategies that support listing
+     *
+     * @param dimension - The semantic dimension
+     * @param brain - REAL Brainy instance
+     * @param vfs - REAL VirtualFileSystem instance
+     * @param limit - Max results
+     * @returns Array of VFSEntity
+     * @throws Error if dimension not registered or doesn't support listing
+     */
+    list(dimension: string, brain: Brainy, vfs: VirtualFileSystem, limit?: number): Promise<VFSEntity[]>;
+    /**
+     * Unregister a strategy
+     * Useful for testing or dynamic strategy management
+     *
+     * @param name - Strategy name to remove
+     * @returns true if removed, false if not found
+     */
+    unregister(name: string): boolean;
+    /**
+     * Clear all registered strategies
+     * Useful for testing
+     */
+    clear(): void;
+    /**
+     * Get all registered strategies
+     * Returns a copy to prevent external modification
+     */
+    getAll(): ProjectionStrategy[];
+}

package/dist/vfs/semantic/ProjectionRegistry.js

@@ -0,0 +1,118 @@
+/**
+ * Projection Registry
+ *
+ * Central registry for all projection strategies
+ * Manages strategy lookup and execution
+ */
+/**
+ * Registry for projection strategies
+ * Allows dynamic registration and lookup of strategies
+ */
+export class ProjectionRegistry {
+    constructor() {
+        this.strategies = new Map();
+    }
+    /**
+     * Register a projection strategy
+     * @param strategy - The strategy to register
+     * @throws Error if strategy with same name already registered
+     */
+    register(strategy) {
+        if (this.strategies.has(strategy.name)) {
+            throw new Error(`Projection strategy '${strategy.name}' is already registered`);
+        }
+        this.strategies.set(strategy.name, strategy);
+    }
+    /**
+     * Get a projection strategy by name
+     * @param name - Strategy name
+     * @returns The strategy or undefined if not found
+     */
+    get(name) {
+        return this.strategies.get(name);
+    }
+    /**
+     * Check if a strategy is registered
+     * @param name - Strategy name
+     */
+    has(name) {
+        return this.strategies.has(name);
+    }
+    /**
+     * List all registered strategy names
+     */
+    listDimensions() {
+        return Array.from(this.strategies.keys());
+    }
+    /**
+     * Get count of registered strategies
+     */
+    count() {
+        return this.strategies.size;
+    }
+    /**
+     * Resolve a dimension value to entity IDs
+     * Convenience method that looks up strategy and calls resolve()
+     *
+     * @param dimension - The semantic dimension
+     * @param value - The value to resolve
+     * @param brain - REAL Brainy instance
+     * @param vfs - REAL VirtualFileSystem instance
+     * @returns Array of entity IDs
+     * @throws Error if dimension not registered
+     */
+    async resolve(dimension, value, brain, vfs) {
+        const strategy = this.get(dimension);
+        if (!strategy) {
+            throw new Error(`Unknown projection dimension: ${dimension}. Registered dimensions: ${this.listDimensions().join(', ')}`);
+        }
+        // Call REAL strategy resolve method
+        return await strategy.resolve(brain, vfs, value);
+    }
+    /**
+     * List entities in a dimension
+     * Convenience method for strategies that support listing
+     *
+     * @param dimension - The semantic dimension
+     * @param brain - REAL Brainy instance
+     * @param vfs - REAL VirtualFileSystem instance
+     * @param limit - Max results
+     * @returns Array of VFSEntity
+     * @throws Error if dimension not registered or doesn't support listing
+     */
+    async list(dimension, brain, vfs, limit) {
+        const strategy = this.get(dimension);
+        if (!strategy) {
+            throw new Error(`Unknown projection dimension: ${dimension}`);
+        }
+        if (!strategy.list) {
+            throw new Error(`Projection '${dimension}' does not support listing`);
+        }
+        return await strategy.list(brain, vfs, limit);
+    }
+    /**
+     * Unregister a strategy
+     * Useful for testing or dynamic strategy management
+     *
+     * @param name - Strategy name to remove
+     * @returns true if removed, false if not found
+     */
+    unregister(name) {
+        return this.strategies.delete(name);
+    }
+    /**
+     * Clear all registered strategies
+     * Useful for testing
+     */
+    clear() {
+        this.strategies.clear();
+    }
+    /**
+     * Get all registered strategies
+     * Returns a copy to prevent external modification
+     */
+    getAll() {
+        return Array.from(this.strategies.values());
+    }
+}
+//# sourceMappingURL=ProjectionRegistry.js.map

package/dist/vfs/semantic/ProjectionStrategy.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Projection Strategy Interface
+ *
+ * Defines how to map semantic path dimensions to Brainy queries
+ * Each strategy uses EXISTING Brainy indexes and methods
+ */
+import { Brainy } from '../../brainy.js';
+import { VirtualFileSystem } from '../VirtualFileSystem.js';
+import { FindParams } from '../../types/brainy.types.js';
+import { VFSEntity } from '../types.js';
+/**
+ * Strategy for projecting semantic paths into entity queries
+ * All implementations MUST use real Brainy methods (no stubs!)
+ */
+export interface ProjectionStrategy {
+    /**
+     * Strategy name (used for registration)
+     */
+    readonly name: string;
+    /**
+     * Convert semantic value to Brainy FindParams
+     * Uses EXISTING FindParams type from brainy.types.ts
+     */
+    toQuery(value: any, subpath?: string): FindParams;
+    /**
+     * Resolve semantic value to entity IDs
+     * Uses REAL Brainy.find() method
+     *
+     * @param brain - REAL Brainy instance
+     * @param vfs - REAL VirtualFileSystem instance
+     * @param value - The semantic value to resolve
+     * @returns Array of entity IDs that match
+     */
+    resolve(brain: Brainy, vfs: VirtualFileSystem, value: any): Promise<string[]>;
+    /**
+     * List all entities in this dimension
+     * Optional - not all strategies need to implement
+     *
+     * @param brain - REAL Brainy instance
+     * @param vfs - REAL VirtualFileSystem instance
+     * @param limit - Max results to return
+     */
+    list?(brain: Brainy, vfs: VirtualFileSystem, limit?: number): Promise<VFSEntity[]>;
+}
+/**
+ * Base class for projection strategies with common utilities
+ */
+export declare abstract class BaseProjectionStrategy implements ProjectionStrategy {
+    abstract readonly name: string;
+    abstract toQuery(value: any, subpath?: string): FindParams;
+    abstract resolve(brain: Brainy, vfs: VirtualFileSystem, value: any): Promise<string[]>;
+    /**
+     * Convert Brainy Results to entity IDs
+     * Helper method for subclasses
+     */
+    protected extractIds(results: Array<{
+        id: string;
+    }>): string[];
+    /**
+     * Verify that an entity is a file (not directory)
+     * Uses REAL Brainy.get() method
+     */
+    protected isFile(brain: Brainy, entityId: string): Promise<boolean>;
+    /**
+     * Filter entity IDs to only include files
+     * Uses REAL Brainy.get() for each entity
+     */
+    protected filterFiles(brain: Brainy, entityIds: string[]): Promise<string[]>;
+}