@ninebix/nmt-system 1.0.0

package/dist/src/core/attractor-model.js

@@ -0,0 +1,821 @@
+/**
+ * Future Attractor Model - Goal-Driven Probability Steering
+ *
+ * Based on Probabilistic Ontology Framework - Teleological Determinism:
+ * - Future states act as "attractors" that influence present choices
+ * - Current state probabilities are shaped by potential futures
+ * - Goals create probability gradients that guide decision paths
+ *
+ * @module core/attractor-model
+ */
+import { cosineSimilarity } from '../utils/similarity.js';
+/**
+ * Priority Queue for A* algorithm
+ */
+class PriorityQueue {
+    items = [];
+    enqueue(item) {
+        this.items.push(item);
+        this.bubbleUp(this.items.length - 1);
+    }
+    dequeue() {
+        if (this.items.length === 0)
+            return undefined;
+        if (this.items.length === 1)
+            return this.items.pop();
+        const result = this.items[0];
+        this.items[0] = this.items.pop();
+        this.bubbleDown(0);
+        return result;
+    }
+    isEmpty() {
+        return this.items.length === 0;
+    }
+    has(predicate) {
+        return this.items.some(predicate);
+    }
+    update(predicate, newItem) {
+        const index = this.items.findIndex(predicate);
+        if (index >= 0) {
+            this.items[index] = newItem;
+            this.bubbleUp(index);
+            this.bubbleDown(index);
+        }
+    }
+    bubbleUp(index) {
+        while (index > 0) {
+            const parentIndex = Math.floor((index - 1) / 2);
+            if (this.items[parentIndex].f <= this.items[index].f)
+                break;
+            [this.items[parentIndex], this.items[index]] = [this.items[index], this.items[parentIndex]];
+            index = parentIndex;
+        }
+    }
+    bubbleDown(index) {
+        while (true) {
+            const left = 2 * index + 1;
+            const right = 2 * index + 2;
+            let smallest = index;
+            if (left < this.items.length && this.items[left].f < this.items[smallest].f) {
+                smallest = left;
+            }
+            if (right < this.items.length && this.items[right].f < this.items[smallest].f) {
+                smallest = right;
+            }
+            if (smallest === index)
+                break;
+            [this.items[index], this.items[smallest]] = [this.items[smallest], this.items[index]];
+            index = smallest;
+        }
+    }
+}
+/**
+ * Attractor Model - Goal-Driven Probability Steering
+ *
+ * Implements teleological determinism where future goals (attractors)
+ * influence present state probabilities through probability fields.
+ *
+ * Key Concepts:
+ * - **Attractors**: Future goal states that "pull" the system towards them
+ * - **Probability Fields**: Gradients that guide state transitions
+ * - **Influence**: How strongly an attractor affects current decisions
+ *
+ * @example
+ * ```typescript
+ * const model = new AttractorModel({ neuronStore: store });
+ *
+ * // Create a goal attractor
+ * const attractor = model.createAttractor(
+ *   'goal-1',
+ *   'Complete Project',
+ *   'Finish all remaining tasks',
+ *   goalEmbedding,
+ *   { strength: 0.8, priority: 10 }
+ * );
+ *
+ * // Calculate influence on current state
+ * const influence = model.calculateInfluence(currentStateEmbedding);
+ * console.log(`Goal influence: ${influence.get('goal-1')}`);
+ *
+ * // Find path to goal
+ * const path = await model.findPathToAttractor('current-neuron', 'goal-1');
+ * console.log(`Path probability: ${path?.probability}`);
+ * ```
+ *
+ * @see {@link Attractor} for attractor state structure
+ * @see {@link ProbabilityField} for field configuration
+ */
+export class AttractorModel {
+    store;
+    maxAttractors;
+    defaultStrength;
+    decayRate;
+    influenceRadius;
+    // A* algorithm options
+    heuristicWeight;
+    maxSearchNodes;
+    // Attractor storage
+    attractors = new Map();
+    // Probability fields
+    fields = new Map();
+    // State history
+    stateHistory = [];
+    transitions = [];
+    // Current dominant attractor
+    dominantAttractor = null;
+    // Caching for A* heuristics
+    embeddingCache = new Map();
+    constructor(options) {
+        this.store = options.neuronStore;
+        this.maxAttractors = options.maxAttractors ?? 100;
+        this.defaultStrength = options.defaultStrength ?? 0.5;
+        this.decayRate = options.decayRate ?? 0.95;
+        this.influenceRadius = options.influenceRadius ?? 0.7;
+        this.heuristicWeight = options.heuristicWeight ?? 1.0;
+        this.maxSearchNodes = options.maxSearchNodes ?? 1000;
+    }
+    /**
+     * Create a new attractor (future goal state).
+     *
+     * Attractors represent desired future states that influence present
+     * probability distributions. The strength and priority determine how
+     * much pull the attractor has on state transitions.
+     *
+     * @param id - Unique identifier for the attractor
+     * @param name - Human-readable name for the goal
+     * @param description - Detailed description of the goal state
+     * @param embedding - Semantic embedding representing the goal
+     * @param options - Configuration options
+     * @param options.strength - Pull strength (0-1), default: 0.5
+     * @param options.probability - Initial probability of reaching (0-1), default: 0.5
+     * @param options.priority - User-defined priority (1-10), default: 5
+     * @param options.deadline - Optional ISO8601 deadline
+     * @param options.prerequisites - IDs of required states before this
+     * @returns The created Attractor object
+     *
+     * @example
+     * ```typescript
+     * const attractor = model.createAttractor(
+     *   'learn-typescript',
+     *   'Master TypeScript',
+     *   'Become proficient in TypeScript development',
+     *   tsEmbedding,
+     *   { strength: 0.9, priority: 8, deadline: '2024-12-31' }
+     * );
+     * ```
+     */
+    createAttractor(id, name, description, embedding, options = {}) {
+        if (this.attractors.size >= this.maxAttractors) {
+            // Remove least activated attractor
+            this.pruneWeakestAttractor();
+        }
+        const attractor = {
+            id,
+            name,
+            description,
+            embedding,
+            strength: options.strength ?? this.defaultStrength,
+            probability: options.probability ?? 0.5,
+            priority: options.priority ?? 5,
+            deadline: options.deadline,
+            prerequisites: options.prerequisites ?? [],
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            activations: 0
+        };
+        this.attractors.set(id, attractor);
+        this.updateProbabilityField(attractor);
+        return attractor;
+    }
+    /**
+     * Get attractor by ID
+     */
+    getAttractor(id) {
+        return this.attractors.get(id);
+    }
+    /**
+     * Update attractor properties
+     */
+    updateAttractor(id, updates) {
+        const attractor = this.attractors.get(id);
+        if (!attractor)
+            return null;
+        Object.assign(attractor, updates, { updatedAt: new Date().toISOString() });
+        this.updateProbabilityField(attractor);
+        return attractor;
+    }
+    /**
+     * Calculate influence of all attractors on a given state.
+     *
+     * Influence is calculated using exponential decay based on semantic
+     * distance, multiplied by attractor strength and priority.
+     *
+     * @param stateEmbedding - The current state's embedding vector
+     * @returns Map of attractor IDs to their influence values (0-1)
+     *
+     * @example
+     * ```typescript
+     * const influences = model.calculateInfluence(currentEmbedding);
+     * for (const [attractorId, influence] of influences) {
+     *   if (influence > 0.5) {
+     *     console.log(`Strong pull from ${attractorId}: ${influence}`);
+     *   }
+     * }
+     * ```
+     */
+    calculateInfluence(stateEmbedding) {
+        const influences = new Map();
+        for (const [id, attractor] of this.attractors) {
+            const similarity = cosineSimilarity(stateEmbedding, attractor.embedding);
+            // Influence decreases with distance but increases with strength
+            const distance = 1 - similarity;
+            const influence = attractor.strength * Math.exp(-distance / this.influenceRadius);
+            // Apply priority multiplier
+            const priorityMultiplier = attractor.priority / 10;
+            influences.set(id, influence * priorityMultiplier);
+        }
+        return influences;
+    }
+    /**
+     * Get the dominant attractor for a state
+     */
+    getDominantAttractor(stateEmbedding) {
+        const influences = this.calculateInfluence(stateEmbedding);
+        let maxInfluence = 0;
+        let dominant = null;
+        for (const [id, influence] of influences) {
+            if (influence > maxInfluence) {
+                maxInfluence = influence;
+                dominant = this.attractors.get(id) ?? null;
+            }
+        }
+        return dominant;
+    }
+    /**
+     * Calculate transition probabilities from current state
+     */
+    async calculateTransitionProbabilities(currentNeuronId, candidateIds) {
+        const current = await this.store.getNeuron(currentNeuronId);
+        if (!current)
+            return new Map();
+        const probabilities = new Map();
+        const currentInfluences = this.calculateInfluence(current.embedding);
+        for (const candidateId of candidateIds) {
+            const candidate = await this.store.getNeuron(candidateId);
+            if (!candidate)
+                continue;
+            // Base probability from semantic similarity
+            const baseSimilarity = cosineSimilarity(current.embedding, candidate.embedding);
+            // Attractor boost: how much better is candidate for reaching attractors?
+            let attractorBoost = 0;
+            const candidateInfluences = this.calculateInfluence(candidate.embedding);
+            for (const [attractorId, currentInf] of currentInfluences) {
+                const candidateInf = candidateInfluences.get(attractorId) ?? 0;
+                // Positive if candidate is closer to attractor
+                attractorBoost += (candidateInf - currentInf);
+            }
+            // Normalize attractor boost
+            attractorBoost = Math.tanh(attractorBoost);
+            // Combined probability
+            const probability = baseSimilarity * 0.4 + (0.5 + attractorBoost * 0.5) * 0.6;
+            probabilities.set(candidateId, Math.max(0, Math.min(1, probability)));
+        }
+        // Normalize probabilities
+        const total = Array.from(probabilities.values()).reduce((a, b) => a + b, 0);
+        if (total > 0) {
+            for (const [id, prob] of probabilities) {
+                probabilities.set(id, prob / total);
+            }
+        }
+        return probabilities;
+    }
+    /**
+     * Find optimal path from current state to an attractor using A* algorithm.
+     *
+     * A* guarantees the optimal path by combining:
+     * - g(n): Actual cost from start to node n
+     * - h(n): Heuristic estimate from n to goal (semantic distance)
+     * - f(n) = g(n) + h(n): Total estimated cost
+     *
+     * The heuristic uses semantic distance (1 - cosine similarity) which is
+     * admissible (never overestimates) for semantic spaces.
+     *
+     * @param currentNeuronId - Starting neuron ID
+     * @param attractorId - Target attractor ID
+     * @param maxDepth - Maximum search depth, default: 10
+     * @returns Path information including probability and bottlenecks, or null if not found
+     *
+     * @example
+     * ```typescript
+     * const result = await model.findPathToAttractor('start', 'goal', 10);
+     * if (result.found) {
+     *   console.log(`Optimal path: ${result.path.join(' → ')}`);
+     *   console.log(`Path probability: ${(result.pathProbability * 100).toFixed(1)}%`);
+     *   console.log(`Nodes explored: ${result.nodesExplored}`);
+     *   for (const bottleneck of result.bottlenecks) {
+     *     console.log(`Bottleneck: ${bottleneck.nodeId} (cost: ${bottleneck.costContribution})`);
+     *   }
+     * }
+     * ```
+     */
+    async findPathToAttractor(currentNeuronId, attractorId, maxDepth = 10) {
+        const attractor = this.attractors.get(attractorId);
+        if (!attractor)
+            return null;
+        const result = await this.aStarSearch(currentNeuronId, attractor, maxDepth);
+        if (!result.found)
+            return null;
+        return {
+            path: result.path,
+            probability: result.pathProbability,
+            estimatedSteps: result.path.length - 1,
+            bottlenecks: result.bottlenecks.map(b => b.nodeId)
+        };
+    }
+    /**
+     * A* Search Algorithm Implementation
+     *
+     * Uses:
+     * - g(n) = sum of edge costs (1 - synapse.weight) from start
+     * - h(n) = semantic distance (1 - cosine_similarity) to goal
+     * - f(n) = g(n) + w * h(n) where w is heuristicWeight
+     *
+     * @param startId - Starting neuron ID
+     * @param goal - Target attractor
+     * @param maxDepth - Maximum path length
+     * @returns A* search result with path, cost, and bottlenecks
+     */
+    async aStarSearch(startId, goal, maxDepth = 10) {
+        // Initialize result
+        const result = {
+            found: false,
+            path: [],
+            totalCost: Infinity,
+            nodesExplored: 0,
+            pathProbability: 0,
+            bottlenecks: []
+        };
+        // Get start node
+        const startNode = await this.store.getNeuron(startId);
+        if (!startNode)
+            return result;
+        // Cache start embedding
+        this.embeddingCache.set(startId, startNode.embedding);
+        // Calculate initial heuristic
+        const startH = this.calculateHeuristic(startNode.embedding, goal.embedding);
+        // Check if already at goal
+        if (startH < 0.1) {
+            result.found = true;
+            result.path = [startId];
+            result.totalCost = 0;
+            result.pathProbability = 1;
+            return result;
+        }
+        // Initialize open set (priority queue)
+        const openSet = new PriorityQueue();
+        openSet.enqueue({
+            id: startId,
+            parent: null,
+            g: 0,
+            h: startH,
+            f: this.heuristicWeight * startH
+        });
+        // Initialize closed set
+        const closedSet = new Set();
+        // Track best g values
+        const gScores = new Map();
+        gScores.set(startId, 0);
+        // Track parent pointers for path reconstruction
+        const cameFrom = new Map();
+        // Track edge costs for bottleneck analysis
+        const edgeCosts = new Map();
+        // Main A* loop
+        while (!openSet.isEmpty() && result.nodesExplored < this.maxSearchNodes) {
+            const current = openSet.dequeue();
+            result.nodesExplored++;
+            // Skip if already processed
+            if (closedSet.has(current.id))
+                continue;
+            // Get current node embedding
+            let currentEmbedding = this.embeddingCache.get(current.id);
+            if (!currentEmbedding) {
+                const node = await this.store.getNeuron(current.id);
+                if (!node)
+                    continue;
+                currentEmbedding = node.embedding;
+                this.embeddingCache.set(current.id, currentEmbedding);
+            }
+            // Check if goal reached (similarity > 0.9)
+            const similarity = cosineSimilarity(currentEmbedding, goal.embedding);
+            if (similarity > 0.9) {
+                result.found = true;
+                result.totalCost = current.g;
+                result.path = this.reconstructPath(current.id, cameFrom);
+                result.pathProbability = this.calculatePathProbability(result.path, edgeCosts);
+                result.bottlenecks = this.identifyAStarBottlenecks(result.path, edgeCosts);
+                return result;
+            }
+            // Add to closed set
+            closedSet.add(current.id);
+            // Check depth limit
+            const depth = this.reconstructPath(current.id, cameFrom).length - 1;
+            if (depth >= maxDepth)
+                continue;
+            // Expand neighbors
+            const outgoing = await this.store.getOutgoingSynapses(current.id);
+            for (const synapse of outgoing) {
+                if (closedSet.has(synapse.targetId))
+                    continue;
+                // Get neighbor embedding
+                let neighborEmbedding = this.embeddingCache.get(synapse.targetId);
+                if (!neighborEmbedding) {
+                    const neighborNode = await this.store.getNeuron(synapse.targetId);
+                    if (!neighborNode)
+                        continue;
+                    neighborEmbedding = neighborNode.embedding;
+                    this.embeddingCache.set(synapse.targetId, neighborEmbedding);
+                }
+                // Calculate edge cost (lower weight = higher cost)
+                // Cost = 1 - weight, so strong connections are cheap
+                const edgeCost = 1 - synapse.weight;
+                // Factor in attractor pull (moving towards attractor reduces cost)
+                const currentToGoal = 1 - cosineSimilarity(currentEmbedding, goal.embedding);
+                const neighborToGoal = 1 - cosineSimilarity(neighborEmbedding, goal.embedding);
+                const attractorBonus = Math.max(0, currentToGoal - neighborToGoal) * 0.5;
+                const adjustedCost = Math.max(0.01, edgeCost - attractorBonus);
+                // Calculate tentative g score
+                const tentativeG = current.g + adjustedCost;
+                // Check if this path is better
+                const existingG = gScores.get(synapse.targetId) ?? Infinity;
+                if (tentativeG < existingG) {
+                    // Record this path
+                    cameFrom.set(synapse.targetId, current.id);
+                    gScores.set(synapse.targetId, tentativeG);
+                    edgeCosts.set(`${current.id}:${synapse.targetId}`, adjustedCost);
+                    // Calculate heuristic
+                    const h = this.calculateHeuristic(neighborEmbedding, goal.embedding);
+                    const f = tentativeG + this.heuristicWeight * h;
+                    // Add to open set
+                    openSet.enqueue({
+                        id: synapse.targetId,
+                        parent: current.id,
+                        g: tentativeG,
+                        h,
+                        f
+                    });
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Calculate heuristic for A* (semantic distance to goal)
+     *
+     * Uses 1 - cosine_similarity as distance metric.
+     * This heuristic is admissible for semantic spaces.
+     */
+    calculateHeuristic(embedding, goalEmbedding) {
+        const similarity = cosineSimilarity(embedding, goalEmbedding);
+        // Distance = 1 - similarity, bounded [0, 2] for cosine
+        return 1 - similarity;
+    }
+    /**
+     * Reconstruct path from A* search
+     */
+    reconstructPath(goalId, cameFrom) {
+        const path = [goalId];
+        let current = goalId;
+        while (cameFrom.has(current)) {
+            current = cameFrom.get(current);
+            path.unshift(current);
+        }
+        return path;
+    }
+    /**
+     * Calculate path probability (product of edge weights)
+     */
+    calculatePathProbability(path, edgeCosts) {
+        if (path.length < 2)
+            return 1;
+        let probability = 1;
+        for (let i = 0; i < path.length - 1; i++) {
+            const edgeKey = `${path[i]}:${path[i + 1]}`;
+            const cost = edgeCosts.get(edgeKey) ?? 0.5;
+            // Convert cost back to probability-like value
+            // cost = 1 - weight, so weight = 1 - cost
+            probability *= (1 - cost);
+        }
+        return probability;
+    }
+    /**
+     * Identify bottlenecks from A* search (high-cost edges)
+     */
+    identifyAStarBottlenecks(path, edgeCosts) {
+        const bottlenecks = [];
+        // Calculate average edge cost
+        let totalCost = 0;
+        let edgeCount = 0;
+        for (let i = 0; i < path.length - 1; i++) {
+            const edgeKey = `${path[i]}:${path[i + 1]}`;
+            const cost = edgeCosts.get(edgeKey) ?? 0;
+            totalCost += cost;
+            edgeCount++;
+        }
+        const avgCost = edgeCount > 0 ? totalCost / edgeCount : 0;
+        // Bottlenecks are edges with above-average cost
+        for (let i = 0; i < path.length - 1; i++) {
+            const edgeKey = `${path[i]}:${path[i + 1]}`;
+            const cost = edgeCosts.get(edgeKey) ?? 0;
+            if (cost > avgCost * 1.5) {
+                bottlenecks.push({
+                    nodeId: path[i + 1],
+                    costContribution: cost
+                });
+            }
+        }
+        // Sort by cost contribution (highest first)
+        bottlenecks.sort((a, b) => b.costContribution - a.costContribution);
+        return bottlenecks;
+    }
+    /**
+     * Find multiple alternative paths to attractor
+     *
+     * Uses A* with path exclusion to find k-best paths
+     */
+    async findAlternativePaths(currentNeuronId, attractorId, k = 3, maxDepth = 10) {
+        const attractor = this.attractors.get(attractorId);
+        if (!attractor)
+            return [];
+        const results = [];
+        const usedPaths = new Set();
+        for (let i = 0; i < k; i++) {
+            const result = await this.aStarSearchWithExclusion(currentNeuronId, attractor, maxDepth, usedPaths);
+            if (!result.found)
+                break;
+            results.push(result);
+            usedPaths.add(result.path.join(':'));
+        }
+        return results;
+    }
+    /**
+     * A* search with path exclusion for k-best paths
+     */
+    async aStarSearchWithExclusion(startId, goal, maxDepth, excludedPaths) {
+        // Similar to aStarSearch but with path exclusion
+        const result = await this.aStarSearch(startId, goal, maxDepth);
+        // If the found path is excluded, try again with penalty
+        if (result.found && excludedPaths.has(result.path.join(':'))) {
+            // Add penalty and retry - this is simplified
+            result.found = false;
+        }
+        return result;
+    }
+    /**
+     * Bidirectional A* search for faster pathfinding
+     *
+     * Searches from both start and goal simultaneously
+     */
+    async bidirectionalAStarSearch(startId, attractorId, maxDepth = 10) {
+        const attractor = this.attractors.get(attractorId);
+        if (!attractor) {
+            return { found: false, path: [], totalCost: Infinity, nodesExplored: 0, pathProbability: 0, bottlenecks: [] };
+        }
+        // For now, delegate to standard A* (full bidirectional needs goal node ID)
+        // In a full implementation, you'd need to identify goal nodes first
+        return this.aStarSearch(startId, attractor, maxDepth);
+    }
+    /**
+     * Clear embedding cache to free memory
+     */
+    clearCache() {
+        this.embeddingCache.clear();
+    }
+    /**
+     * Record a state transition between neurons.
+     *
+     * Tracks how state transitions are influenced by attractors,
+     * updating attractor activation counts when transitions move
+     * towards them.
+     *
+     * @param fromId - Source neuron ID
+     * @param toId - Target neuron ID
+     * @returns The recorded transition with attractor influences
+     * @throws Error if either neuron ID is invalid
+     */
+    async recordTransition(fromId, toId) {
+        const from = await this.store.getNeuron(fromId);
+        const to = await this.store.getNeuron(toId);
+        if (!from || !to) {
+            throw new Error('Invalid neuron IDs for transition');
+        }
+        // Calculate probability based on attractor influences
+        const fromInfluences = this.calculateInfluence(from.embedding);
+        const toInfluences = this.calculateInfluence(to.embedding);
+        let probability = cosineSimilarity(from.embedding, to.embedding);
+        // Track attractor contribution
+        const attractorInfluence = new Map();
+        for (const [attractorId, fromInf] of fromInfluences) {
+            const toInf = toInfluences.get(attractorId) ?? 0;
+            const contribution = toInf - fromInf;
+            attractorInfluence.set(attractorId, contribution);
+            // If moving towards an attractor, increase that attractor's activation
+            if (contribution > 0) {
+                const attractor = this.attractors.get(attractorId);
+                if (attractor) {
+                    attractor.activations++;
+                }
+            }
+        }
+        const transition = {
+            from: fromId,
+            to: toId,
+            probability,
+            attractorInfluence,
+            timestamp: new Date().toISOString()
+        };
+        this.transitions.push(transition);
+        // Update state history
+        this.stateHistory.push({
+            neuronId: toId,
+            embedding: to.embedding,
+            timestamp: transition.timestamp,
+            activeAttractors: Array.from(attractorInfluence.keys()).filter(id => (attractorInfluence.get(id) ?? 0) > 0),
+            dominantAttractor: this.getDominantAttractor(to.embedding)?.id,
+            transitionProbabilities: new Map()
+        });
+        return transition;
+    }
+    /**
+     * Update attractor probabilities based on current state
+     */
+    async updateAttractorProbabilities(currentNeuronId) {
+        const current = await this.store.getNeuron(currentNeuronId);
+        if (!current)
+            return;
+        for (const [id, attractor] of this.attractors) {
+            const similarity = cosineSimilarity(current.embedding, attractor.embedding);
+            // Update probability with exponential smoothing
+            const newProb = 0.8 * attractor.probability + 0.2 * similarity;
+            attractor.probability = Math.max(0, Math.min(1, newProb));
+            attractor.updatedAt = new Date().toISOString();
+        }
+    }
+    /**
+     * Decay attractor strengths over time.
+     *
+     * Applies exponential decay to attractors that haven't been
+     * updated in 24+ hours. Very weak attractors with few activations
+     * are automatically removed.
+     *
+     * Call this periodically (e.g., hourly) to maintain attractor health.
+     */
+    decayAttractors() {
+        const now = Date.now();
+        for (const attractor of this.attractors.values()) {
+            const lastUpdated = new Date(attractor.updatedAt).getTime();
+            const hoursSinceUpdate = (now - lastUpdated) / (1000 * 60 * 60);
+            if (hoursSinceUpdate > 24) {
+                // Apply decay
+                attractor.strength *= this.decayRate;
+                // Remove very weak attractors
+                if (attractor.strength < 0.01 && attractor.activations < 5) {
+                    this.attractors.delete(attractor.id);
+                    this.fields.delete(attractor.id);
+                }
+            }
+        }
+    }
+    /**
+     * Get all active attractors
+     */
+    getActiveAttractors() {
+        return Array.from(this.attractors.values())
+            .filter(a => a.strength > 0.1)
+            .sort((a, b) => b.priority * b.strength - a.priority * a.strength);
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        let totalStrength = 0;
+        let totalActivations = 0;
+        let activeCount = 0;
+        for (const attractor of this.attractors.values()) {
+            totalStrength += attractor.strength;
+            totalActivations += attractor.activations;
+            if (attractor.strength > 0.1)
+                activeCount++;
+        }
+        return {
+            totalAttractors: this.attractors.size,
+            activeAttractors: activeCount,
+            transitions: this.transitions.length,
+            stateHistory: this.stateHistory.length,
+            averageStrength: this.attractors.size > 0 ? totalStrength / this.attractors.size : 0,
+            averageActivations: this.attractors.size > 0 ? totalActivations / this.attractors.size : 0
+        };
+    }
+    /**
+     * Serialize attractor model state for persistence.
+     *
+     * Converts all attractors, transitions, and state to a JSON-serializable
+     * object. Embeddings are converted to plain arrays.
+     *
+     * @returns Serialized state object for storage
+     * @see {@link load} for restoring state
+     */
+    serialize() {
+        return {
+            attractors: Array.from(this.attractors.entries()).map(([id, a]) => ({
+                ...a,
+                embedding: Array.from(a.embedding)
+            })),
+            transitions: this.transitions.slice(-1000), // Keep last 1000 transitions
+            dominantAttractor: this.dominantAttractor
+        };
+    }
+    /**
+     * Load attractor model from serialized data.
+     *
+     * Restores all attractors, transitions, and state from previously
+     * serialized data. Embeddings are converted back to Float32Array.
+     *
+     * @param data - Previously serialized attractor model state
+     * @see {@link serialize} for creating serialized state
+     */
+    load(data) {
+        this.attractors.clear();
+        for (const a of data.attractors ?? []) {
+            const attractor = {
+                ...a,
+                embedding: new Float32Array(a.embedding)
+            };
+            this.attractors.set(a.id, attractor);
+            this.updateProbabilityField(attractor);
+        }
+        this.transitions = data.transitions ?? [];
+        this.dominantAttractor = data.dominantAttractor ?? null;
+    }
+    // ==================== Private Methods ====================
+    updateProbabilityField(attractor) {
+        const field = {
+            attractor,
+            gradient: new Map(),
+            reachableStates: [],
+            pathProbabilities: []
+        };
+        this.fields.set(attractor.id, field);
+    }
+    pruneWeakestAttractor() {
+        let weakest = null;
+        let weakestScore = Infinity;
+        for (const attractor of this.attractors.values()) {
+            const score = attractor.strength * attractor.priority * (1 + attractor.activations / 100);
+            if (score < weakestScore) {
+                weakestScore = score;
+                weakest = attractor;
+            }
+        }
+        if (weakest) {
+            this.attractors.delete(weakest.id);
+            this.fields.delete(weakest.id);
+        }
+    }
+    /**
+     * Simple bottleneck identification for legacy compatibility
+     * @deprecated Use identifyAStarBottlenecks for accurate bottleneck detection
+     */
+    identifyBottlenecks(path) {
+        // Bottlenecks are nodes where probability drops significantly
+        // For now, return middle nodes as potential bottlenecks
+        if (path.length <= 2)
+            return [];
+        return path.slice(1, -1);
+    }
+    /**
+     * Get path cost breakdown
+     */
+    async analyzePathCost(path) {
+        const edgeCosts = [];
+        let totalCost = 0;
+        for (let i = 0; i < path.length - 1; i++) {
+            const synapses = await this.store.getOutgoingSynapses(path[i]);
+            const synapse = synapses.find(s => s.targetId === path[i + 1]);
+            const cost = synapse ? 1 - synapse.weight : 0.5;
+            edgeCosts.push({ from: path[i], to: path[i + 1], cost });
+            totalCost += cost;
+        }
+        return {
+            totalCost,
+            edgeCosts,
+            avgCost: edgeCosts.length > 0 ? totalCost / edgeCosts.length : 0
+        };
+    }
+}
+/**
+ * Create an AttractorModel instance
+ */
+export function createAttractorModel(options) {
+    return new AttractorModel(options);
+}
+//# sourceMappingURL=attractor-model.js.map