@signaltree/enterprise 6.0.0 → 6.0.1

package/README.md

@@ -20,9 +20,9 @@ npm install @signaltree/core @signaltree/enterprise
 
 ```typescript
 import { signalTree } from '@signaltree/core';
-import { withEnterprise } from '@signaltree/enterprise';
+import { enterprise } from '@signaltree/enterprise';
 
-const tree = signalTree(largeState).with(withEnterprise());
+const tree = signalTree(largeState).with(enterprise());
 
 // Use optimized bulk updates
 const result = tree.updateOptimized(newData, {
@@ -53,15 +53,15 @@ console.log(result.stats);
 
 ## API
 
-### `withEnterprise()`
+### `enterprise()`
 
 Enhancer that adds enterprise optimizations to a SignalTree.
 
 ```typescript
 import { signalTree } from '@signaltree/core';
-import { withEnterprise } from '@signaltree/enterprise';
+import { enterprise } from '@signaltree/enterprise';
 
-const tree = signalTree(initialState).with(withEnterprise());
+const tree = signalTree(initialState).with(enterprise());
 ```
 
 ### `tree.updateOptimized(updates, options?)`
@@ -116,7 +116,7 @@ if (index) {
 
 ```typescript
 import { signalTree } from '@signaltree/core';
-import { withEnterprise } from '@signaltree/enterprise';
+import { enterprise } from '@signaltree/enterprise';
 
 interface DashboardState {
   metrics: Record<string, number>;
@@ -125,7 +125,7 @@ interface DashboardState {
   // ... hundreds more properties
 }
 
-const dashboard = signalTree<DashboardState>(initialState).with(withEnterprise());
+const dashboard = signalTree<DashboardState>(initialState).with(enterprise());
 
 // High-frequency updates from WebSocket
 socket.on('metrics', (newMetrics) => {
@@ -139,14 +139,14 @@ socket.on('metrics', (newMetrics) => {
 
 ```typescript
 import { signalTree } from '@signaltree/core';
-import { withEnterprise } from '@signaltree/enterprise';
+import { enterprise } from '@signaltree/enterprise';
 
 const grid = signalTree({
   rows: [] as GridRow[],
   columns: [] as GridColumn[],
   filters: {} as FilterState,
   selection: new Set<string>(),
-}).with(withEnterprise());
+}).with(enterprise());
 
 // Bulk update from API
 async function loadData() {
@@ -164,7 +164,7 @@ async function loadData() {
 ### Custom Equality for Complex Objects
 
 ```typescript
-const tree = signalTree(complexState).with(withEnterprise());
+const tree = signalTree(complexState).with(enterprise());
 
 tree.updateOptimized(newState, {
   equalityFn: (a, b) => {

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/dist/index.js

@@ -0,0 +1,6 @@
+export { ChangeType, DiffEngine } from './lib/diff-engine.js';
+export { PathIndex } from './lib/path-index.js';
+export { OptimizedUpdateEngine } from './lib/update-engine.js';
+export { enterprise, withEnterprise } from './lib/enterprise-enhancer.js';
+export { configureScheduler, getSchedulerMetrics, postTask } from './lib/scheduler.js';
+export { createMockPool } from './lib/thread-pools.js';

package/dist/lib/diff-engine.js

@@ -0,0 +1,239 @@
+var ChangeType;
+(function (ChangeType) {
+  ChangeType["ADD"] = "add";
+  ChangeType["UPDATE"] = "update";
+  ChangeType["DELETE"] = "delete";
+  ChangeType["REPLACE"] = "replace";
+})(ChangeType || (ChangeType = {}));
+class DiffEngine {
+  constructor() {
+    this.defaultOptions = {
+      maxDepth: 100,
+      detectDeletions: false,
+      ignoreArrayOrder: false,
+      equalityFn: (a, b) => a === b,
+      keyValidator: undefined,
+      instrumentation: false
+    };
+  }
+  diff(current, updates, options = {}) {
+    const opts = Object.assign(Object.assign({}, this.defaultOptions), options);
+    const changes = [];
+    const visited = new WeakSet();
+    const metrics = {
+      elementComparisons: 0,
+      prefixFastPathHits: 0,
+      wholeArrayReplaceHits: 0,
+      traversals: 0,
+      suffixFastPathHits: 0,
+      segmentSkips: 0,
+      samplesTaken: 0
+    };
+    this.traverse(current, updates, [], changes, visited, opts, 0, metrics);
+    return {
+      changes,
+      hasChanges: changes.length > 0,
+      instrumentation: opts.instrumentation ? metrics : undefined
+    };
+  }
+  traverse(curr, upd, path, changes, visited, opts, depth, metrics) {
+    if (opts.instrumentation) metrics.traversals++;
+    if (depth > opts.maxDepth) {
+      return;
+    }
+    if (curr === upd) {
+      return;
+    }
+    if (typeof upd !== 'object' || upd === null) {
+      if (!opts.equalityFn(curr, upd)) {
+        changes.push({
+          type: curr === undefined ? ChangeType.ADD : ChangeType.UPDATE,
+          path: [...path],
+          value: upd,
+          oldValue: curr
+        });
+      }
+      return;
+    }
+    if (visited.has(upd)) {
+      return;
+    }
+    visited.add(upd);
+    if (Array.isArray(upd)) {
+      this.diffArrays(curr, upd, path, changes, visited, opts, depth, metrics);
+      return;
+    }
+    if (!curr || typeof curr !== 'object' || Array.isArray(curr)) {
+      changes.push({
+        type: ChangeType.REPLACE,
+        path: [...path],
+        value: upd,
+        oldValue: curr
+      });
+      return;
+    }
+    const currObj = curr;
+    const updObj = upd;
+    for (const key in updObj) {
+      if (Object.prototype.hasOwnProperty.call(updObj, key)) {
+        if (opts.keyValidator && !opts.keyValidator(key)) {
+          continue;
+        }
+        this.traverse(currObj[key], updObj[key], [...path, key], changes, visited, opts, depth + 1, metrics);
+      }
+    }
+    if (opts.detectDeletions) {
+      for (const key in currObj) {
+        if (Object.prototype.hasOwnProperty.call(currObj, key) && !(key in updObj)) {
+          changes.push({
+            type: ChangeType.DELETE,
+            path: [...path, key],
+            oldValue: currObj[key]
+          });
+        }
+      }
+    }
+  }
+  diffArrays(curr, upd, path, changes, visited, opts, depth, metrics) {
+    if (!Array.isArray(curr)) {
+      changes.push({
+        type: ChangeType.REPLACE,
+        path: [...path],
+        value: upd,
+        oldValue: curr
+      });
+      return;
+    }
+    if (opts.ignoreArrayOrder) {
+      this.diffArraysUnordered(curr, upd, path, changes, opts);
+    } else {
+      this.diffArraysOrdered(curr, upd, path, changes, visited, opts, depth, metrics);
+    }
+  }
+  diffArraysOrdered(curr, upd, path, changes, visited, opts, depth, metrics) {
+    if (curr === upd) {
+      return;
+    }
+    if (curr.length === upd.length) {
+      let identical = true;
+      for (let i = 0; i < curr.length; i++) {
+        if (opts.instrumentation) metrics.elementComparisons++;
+        if (curr[i] !== upd[i]) {
+          identical = false;
+          break;
+        }
+      }
+      if (identical) return;
+    }
+    const currLen = curr.length;
+    const updLen = upd.length;
+    const minLen = Math.min(currLen, updLen);
+    if (minLen > 0) {
+      let prefixIdentical = true;
+      for (let i = 0; i < minLen; i++) {
+        if (opts.instrumentation) metrics.elementComparisons++;
+        if (curr[i] !== upd[i]) {
+          prefixIdentical = false;
+          break;
+        }
+      }
+      if (prefixIdentical && currLen !== updLen) {
+        if (opts.instrumentation) metrics.prefixFastPathHits++;
+        if (updLen > currLen) {
+          for (let i = currLen; i < updLen; i++) {
+            changes.push({
+              type: ChangeType.ADD,
+              path: [...path, i],
+              value: upd[i]
+            });
+          }
+        } else if (currLen > updLen && opts.detectDeletions) {
+          for (let i = updLen; i < currLen; i++) {
+            changes.push({
+              type: ChangeType.DELETE,
+              path: [...path, i],
+              oldValue: curr[i]
+            });
+          }
+        }
+        return;
+      }
+    }
+    const LARGE_ARRAY_THRESHOLD = 1024;
+    const REPLACE_MISMATCH_RATIO = 0.4;
+    if (currLen >= LARGE_ARRAY_THRESHOLD && updLen >= LARGE_ARRAY_THRESHOLD && currLen === updLen) {
+      let mismatches = 0;
+      for (let i = 0; i < currLen; i++) {
+        if (opts.instrumentation) metrics.elementComparisons++;
+        if (curr[i] !== upd[i]) {
+          mismatches++;
+          if (mismatches / currLen > REPLACE_MISMATCH_RATIO) {
+            changes.push({
+              type: ChangeType.REPLACE,
+              path: [...path],
+              value: upd,
+              oldValue: curr
+            });
+            if (opts.instrumentation) metrics.wholeArrayReplaceHits++;
+            return;
+          }
+        }
+      }
+    }
+    const maxLength = Math.max(currLen, updLen);
+    for (let i = 0; i < maxLength; i++) {
+      if (i >= upd.length) {
+        if (opts.detectDeletions) {
+          changes.push({
+            type: ChangeType.DELETE,
+            path: [...path, i],
+            oldValue: curr[i]
+          });
+        }
+      } else if (i >= curr.length) {
+        changes.push({
+          type: ChangeType.ADD,
+          path: [...path, i],
+          value: upd[i]
+        });
+      } else {
+        this.traverse(curr[i], upd[i], [...path, i], changes, visited, opts, depth + 1, metrics);
+      }
+    }
+  }
+  diffArraysUnordered(curr, upd, path, changes, opts) {
+    const currSet = new Set(curr.map(v => this.stringify(v)));
+    const updSet = new Set(upd.map(v => this.stringify(v)));
+    upd.forEach((value, index) => {
+      const str = this.stringify(value);
+      if (!currSet.has(str)) {
+        changes.push({
+          type: ChangeType.ADD,
+          path: [...path, index],
+          value
+        });
+      }
+    });
+    if (opts.detectDeletions) {
+      curr.forEach((value, index) => {
+        const str = this.stringify(value);
+        if (!updSet.has(str)) {
+          changes.push({
+            type: ChangeType.DELETE,
+            path: [...path, index],
+            oldValue: value
+          });
+        }
+      });
+    }
+  }
+  stringify(value) {
+    try {
+      return JSON.stringify(value);
+    } catch (_a) {
+      return String(value);
+    }
+  }
+}
+
+export { ChangeType, DiffEngine };

package/dist/lib/enterprise-enhancer.js

@@ -0,0 +1,33 @@
+import { PathIndex } from './path-index.js';
+import { OptimizedUpdateEngine } from './update-engine.js';
+
+function enterprise() {
+  return tree => {
+    let pathIndex = null;
+    let updateEngine = null;
+    const signalTree = tree;
+    const enhancedTree = tree;
+    enhancedTree.updateOptimized = (updates, options) => {
+      if (!updateEngine) {
+        pathIndex = new PathIndex();
+        pathIndex.buildFromTree(signalTree.state);
+        updateEngine = new OptimizedUpdateEngine(signalTree.state);
+      }
+      const result = updateEngine.update(signalTree.state, updates, options);
+      if (result.changed && pathIndex) {
+        if (result.changedPaths.length) {
+          pathIndex.incrementalUpdate(signalTree.state, result.changedPaths);
+        } else {
+          pathIndex.clear();
+          pathIndex.buildFromTree(signalTree.state);
+        }
+      }
+      return result;
+    };
+    enhancedTree.getPathIndex = () => pathIndex;
+    return enhancedTree;
+  };
+}
+const withEnterprise = Object.assign(enterprise, {});
+
+export { enterprise, withEnterprise };

package/dist/lib/path-index.js

@@ -0,0 +1,264 @@
+import { isSignal } from '@angular/core';
+
+class TrieNode {
+  constructor() {
+    this.value = null;
+    this.children = new Map();
+  }
+}
+class PathIndex {
+  constructor() {
+    this.root = new TrieNode();
+    this.pathCache = new Map();
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      sets: 0,
+      cleanups: 0
+    };
+    this.enableInstrumentation = false;
+    this.instrumentation = {
+      incrementalUpdates: 0,
+      fullRebuilds: 0,
+      nodesTouched: 0,
+      deletions: 0,
+      rebuildDurationNs: 0
+    };
+  }
+  set(path, signal) {
+    const pathStr = this.pathToString(path);
+    const ref = new WeakRef(signal);
+    let node = this.root;
+    for (const segment of path) {
+      const key = String(segment);
+      if (!node.children.has(key)) {
+        node.children.set(key, new TrieNode());
+      }
+      const nextNode = node.children.get(key);
+      if (!nextNode) {
+        throw new Error(`Failed to get node for key: ${key}`);
+      }
+      node = nextNode;
+    }
+    node.value = ref;
+    this.pathCache.set(pathStr, ref);
+    this.stats.sets++;
+  }
+  get(path) {
+    const pathStr = this.pathToString(path);
+    const cached = this.pathCache.get(pathStr);
+    if (cached) {
+      const value = cached.deref();
+      if (value) {
+        this.stats.hits++;
+        return value;
+      }
+      this.pathCache.delete(pathStr);
+      this.stats.cleanups++;
+    }
+    let node = this.root;
+    for (const segment of path) {
+      const key = String(segment);
+      node = node.children.get(key);
+      if (!node) {
+        this.stats.misses++;
+        return null;
+      }
+    }
+    if (node.value) {
+      const value = node.value.deref();
+      if (value) {
+        this.pathCache.set(pathStr, node.value);
+        this.stats.hits++;
+        return value;
+      }
+      node.value = null;
+      this.stats.cleanups++;
+    }
+    this.stats.misses++;
+    return null;
+  }
+  has(path) {
+    return this.get(path) !== null;
+  }
+  getByPrefix(prefix) {
+    const results = new Map();
+    let node = this.root;
+    for (const segment of prefix) {
+      const key = String(segment);
+      node = node.children.get(key);
+      if (!node) {
+        return results;
+      }
+    }
+    this.collectDescendants(node, [], results);
+    return results;
+  }
+  delete(path) {
+    const pathStr = this.pathToString(path);
+    this.pathCache.delete(pathStr);
+    let node = this.root;
+    const nodes = [node];
+    for (const segment of path) {
+      const key = String(segment);
+      node = node.children.get(key);
+      if (!node) {
+        return false;
+      }
+      nodes.push(node);
+    }
+    const hadValue = node.value !== null;
+    node.value = null;
+    for (let i = nodes.length - 1; i > 0; i--) {
+      const current = nodes[i];
+      if (current.value === null && current.children.size === 0) {
+        const parent = nodes[i - 1];
+        const segment = path[i - 1];
+        parent.children.delete(String(segment));
+      } else {
+        break;
+      }
+    }
+    return hadValue;
+  }
+  clear() {
+    this.root = new TrieNode();
+    this.pathCache.clear();
+    if (this.enableInstrumentation) this.instrumentation.fullRebuilds++;
+  }
+  getStats() {
+    const total = this.stats.hits + this.stats.misses;
+    const hitRate = total > 0 ? this.stats.hits / total : 0;
+    return Object.assign(Object.assign({}, this.stats), {
+      hitRate,
+      cacheSize: this.pathCache.size
+    });
+  }
+  buildFromTree(tree, path = []) {
+    if (!tree) {
+      return;
+    }
+    if (isSignal(tree)) {
+      this.set(path, tree);
+      return;
+    }
+    if (typeof tree !== 'object') {
+      return;
+    }
+    for (const [key, value] of Object.entries(tree)) {
+      this.buildFromTree(value, [...path, key]);
+    }
+  }
+  pathToString(path) {
+    return path.join('.');
+  }
+  collectDescendants(node, currentPath, results) {
+    if (node.value) {
+      const value = node.value.deref();
+      if (value) {
+        results.set(this.pathToString(currentPath), value);
+      }
+    }
+    for (const [key, child] of node.children) {
+      this.collectDescendants(child, [...currentPath, key], results);
+    }
+  }
+  deleteSubtree(path) {
+    if (path.length === 0) {
+      this.clear();
+      return;
+    }
+    let node = this.root;
+    const nodes = [node];
+    for (const segment of path) {
+      node = node.children.get(String(segment));
+      if (!node) {
+        return;
+      }
+      nodes.push(node);
+    }
+    const toClean = [];
+    const collectPaths = (n, current) => {
+      if (n.value) {
+        toClean.push(this.pathToString(current));
+      }
+      for (const [key, child] of n.children) {
+        collectPaths(child, [...current, key]);
+      }
+    };
+    collectPaths(nodes[nodes.length - 1], path);
+    for (const p of toClean) {
+      this.pathCache.delete(p);
+    }
+    const parent = nodes[nodes.length - 2];
+    parent.children.delete(String(path[path.length - 1]));
+    if (this.enableInstrumentation) this.instrumentation.deletions += toClean.length || 1;
+  }
+  incrementalUpdate(rootTree, changedPaths) {
+    const start = this.enableInstrumentation ? performance.now() : 0;
+    if (!changedPaths.length) return;
+    const FULL_REBUILD_THRESHOLD = 2000;
+    if (changedPaths.length > FULL_REBUILD_THRESHOLD || changedPaths.includes('')) {
+      this.clear();
+      this.buildFromTree(rootTree);
+      if (this.enableInstrumentation) {
+        this.instrumentation.rebuildDurationNs += (performance.now() - start) * 1e6;
+      }
+      return;
+    }
+    const ordered = [...changedPaths].sort((a, b) => a.length - b.length);
+    const effective = [];
+    for (const p of ordered) {
+      if (!effective.some(ep => p !== ep && p.startsWith(ep + '.'))) {
+        effective.push(p);
+      }
+    }
+    for (const pathStr of effective) {
+      const segments = pathStr === '' ? [] : pathStr.split('.');
+      let subtree = rootTree;
+      for (const seg of segments) {
+        if (!subtree || typeof subtree !== 'object') {
+          subtree = undefined;
+          break;
+        }
+        subtree = subtree[seg];
+      }
+      if (subtree === undefined || subtree === null) {
+        this.deleteSubtree(segments);
+        continue;
+      }
+      if (isSignal(subtree)) {
+        this.set(segments, subtree);
+        if (this.enableInstrumentation) this.instrumentation.nodesTouched++;
+        continue;
+      }
+      if (typeof subtree === 'object') {
+        this.deleteSubtree(segments);
+        this.buildFromTree(subtree, segments);
+        if (this.enableInstrumentation) this.instrumentation.nodesTouched++;
+      } else {
+        this.deleteSubtree(segments);
+      }
+    }
+    if (this.enableInstrumentation) {
+      this.instrumentation.incrementalUpdates++;
+      this.instrumentation.rebuildDurationNs += (performance.now() - start) * 1e6;
+    }
+  }
+  setInstrumentation(enabled) {
+    this.enableInstrumentation = enabled;
+  }
+  getInstrumentation(reset = false) {
+    const snapshot = Object.assign({}, this.instrumentation);
+    if (reset) {
+      this.instrumentation.incrementalUpdates = 0;
+      this.instrumentation.fullRebuilds = 0;
+      this.instrumentation.nodesTouched = 0;
+      this.instrumentation.deletions = 0;
+      this.instrumentation.rebuildDurationNs = 0;
+    }
+    return snapshot;
+  }
+}
+
+export { PathIndex };

package/dist/lib/scheduler.js

@@ -0,0 +1,76 @@
+import { __awaiter } from 'tslib';
+
+const defaultConfig = {
+  yieldEveryTasks: 500,
+  yieldEveryMs: 8,
+  instrumentation: false
+};
+let config = Object.assign({}, defaultConfig);
+let metrics = {
+  drainCycles: 0,
+  tasksExecuted: 0,
+  maxQueueLength: 0,
+  yields: 0,
+  lastDrainDurationMs: 0,
+  totalDrainDurationMs: 0
+};
+const q = [];
+let draining = false;
+function configureScheduler(newConfig) {
+  config = Object.assign(Object.assign({}, config), newConfig);
+}
+function getSchedulerMetrics(reset = false) {
+  const snapshot = Object.assign({}, metrics);
+  if (reset) {
+    metrics = {
+      drainCycles: 0,
+      tasksExecuted: 0,
+      maxQueueLength: 0,
+      yields: 0,
+      lastDrainDurationMs: 0,
+      totalDrainDurationMs: 0
+    };
+  }
+  return snapshot;
+}
+function postTask(t) {
+  q.push(t);
+  if (config.instrumentation && q.length > metrics.maxQueueLength) {
+    metrics.maxQueueLength = q.length;
+  }
+  if (!draining) {
+    draining = true;
+    Promise.resolve().then(drain);
+  }
+}
+function drain() {
+  return __awaiter(this, void 0, void 0, function* () {
+    const start = config.instrumentation ? performance.now() : 0;
+    if (config.instrumentation) metrics.drainCycles++;
+    let tasksSinceYield = 0;
+    while (q.length) {
+      const t = q.shift();
+      if (!t) break;
+      try {
+        t();
+      } catch (e) {
+        console.error('[EnterpriseScheduler]', e);
+      }
+      tasksSinceYield++;
+      if (config.instrumentation) metrics.tasksExecuted++;
+      if (tasksSinceYield >= config.yieldEveryTasks || config.instrumentation && performance.now() - start >= config.yieldEveryMs) {
+        if (config.instrumentation) metrics.yields++;
+        tasksSinceYield = 0;
+        yield Promise.resolve();
+      }
+    }
+    if (config.instrumentation) {
+      const duration = performance.now() - start;
+      metrics.lastDrainDurationMs = duration;
+      metrics.totalDrainDurationMs += duration;
+    }
+    draining = false;
+  });
+}
+
+export { configureScheduler, getSchedulerMetrics, postTask };

package/dist/lib/thread-pools.js

@@ -0,0 +1,13 @@
+import { __awaiter } from 'tslib';
+
+function createMockPool() {
+  return {
+    run(fn, ...args) {
+      return __awaiter(this, void 0, void 0, function* () {
+        return fn(...args);
+      });
+    }
+  };
+}
+
+export { createMockPool };

package/dist/lib/update-engine.js

@@ -0,0 +1,198 @@
+import { isSignal } from '@angular/core';
+import { DiffEngine, ChangeType } from './diff-engine.js';
+import { PathIndex } from './path-index.js';
+
+class OptimizedUpdateEngine {
+  constructor(tree) {
+    this.pathIndex = new PathIndex();
+    this.diffEngine = new DiffEngine();
+    this.pathIndex.buildFromTree(tree);
+  }
+  update(tree, updates, options = {}) {
+    const startTime = performance.now();
+    const diffOptions = {};
+    if (options.maxDepth !== undefined) diffOptions.maxDepth = options.maxDepth;
+    if (options.ignoreArrayOrder !== undefined) diffOptions.ignoreArrayOrder = options.ignoreArrayOrder;
+    if (options.equalityFn !== undefined) diffOptions.equalityFn = options.equalityFn;
+    const diff = this.diffEngine.diff(tree, updates, diffOptions);
+    if (diff.changes.length === 0) {
+      return {
+        changed: false,
+        duration: performance.now() - startTime,
+        changedPaths: []
+      };
+    }
+    const patches = this.createPatches(diff.changes);
+    const sortedPatches = this.sortPatches(patches);
+    const result = options.batch ? this.batchApplyPatches(tree, sortedPatches, options.batchSize) : this.applyPatches(tree, sortedPatches);
+    const duration = performance.now() - startTime;
+    return {
+      changed: true,
+      duration,
+      changedPaths: result.appliedPaths,
+      stats: {
+        totalPaths: diff.changes.length,
+        optimizedPaths: patches.length,
+        batchedUpdates: result.batchCount
+      }
+    };
+  }
+  rebuildIndex(tree) {
+    this.pathIndex.clear();
+    this.pathIndex.buildFromTree(tree);
+  }
+  getIndexStats() {
+    return this.pathIndex.getStats();
+  }
+  createPatches(changes) {
+    const patches = [];
+    const processedPaths = new Set();
+    for (const change of changes) {
+      const pathStr = change.path.join('.');
+      let skipPath = false;
+      for (const processed of processedPaths) {
+        if (pathStr.startsWith(processed + '.')) {
+          skipPath = true;
+          break;
+        }
+      }
+      if (skipPath) {
+        continue;
+      }
+      const patch = this.createPatch(change);
+      patches.push(patch);
+      processedPaths.add(pathStr);
+      if (change.type === ChangeType.REPLACE && typeof change.value === 'object') {
+        processedPaths.add(pathStr);
+      }
+    }
+    return patches;
+  }
+  createPatch(change) {
+    return {
+      type: change.type,
+      path: change.path,
+      value: change.value,
+      oldValue: change.oldValue,
+      priority: this.calculatePriority(change),
+      signal: this.pathIndex.get(change.path)
+    };
+  }
+  calculatePriority(change) {
+    let priority = 0;
+    priority += (10 - change.path.length) * 10;
+    if (change.path.some(p => typeof p === 'number')) {
+      priority -= 20;
+    }
+    if (change.type === ChangeType.REPLACE) {
+      priority += 30;
+    }
+    return priority;
+  }
+  sortPatches(patches) {
+    return patches.sort((a, b) => {
+      if (a.priority !== b.priority) {
+        return b.priority - a.priority;
+      }
+      return a.path.length - b.path.length;
+    });
+  }
+  applyPatches(tree, patches) {
+    const appliedPaths = [];
+    let updateCount = 0;
+    for (const patch of patches) {
+      if (this.applyPatch(patch, tree)) {
+        appliedPaths.push(patch.path.join('.'));
+        updateCount++;
+      }
+    }
+    return {
+      appliedPaths,
+      updateCount,
+      batchCount: 1
+    };
+  }
+  batchApplyPatches(tree, patches, batchSize = 50) {
+    const batches = [];
+    for (let i = 0; i < patches.length; i += batchSize) {
+      batches.push(patches.slice(i, i + batchSize));
+    }
+    const appliedPaths = [];
+    let updateCount = 0;
+    for (const currentBatch of batches) {
+      for (const patch of currentBatch) {
+        if (this.applyPatch(patch, tree)) {
+          appliedPaths.push(patch.path.join('.'));
+          updateCount++;
+        }
+      }
+    }
+    return {
+      appliedPaths,
+      updateCount,
+      batchCount: batches.length
+    };
+  }
+  applyPatch(patch, tree) {
+    try {
+      if (patch.signal && isSignal(patch.signal) && 'set' in patch.signal) {
+        const currentValue = patch.signal();
+        if (this.isEqual(currentValue, patch.value)) {
+          return false;
+        }
+        patch.signal.set(patch.value);
+        if (patch.type === ChangeType.ADD && patch.value !== undefined) {
+          this.pathIndex.set(patch.path, patch.signal);
+        }
+        return true;
+      }
+      let current = tree;
+      for (let i = 0; i < patch.path.length - 1; i++) {
+        const key = patch.path[i];
+        current = current[key];
+        if (!current || typeof current !== 'object') {
+          return false;
+        }
+      }
+      const lastKey = patch.path[patch.path.length - 1];
+      if (this.isEqual(current[lastKey], patch.value)) {
+        return false;
+      }
+      current[lastKey] = patch.value;
+      return true;
+    } catch (error) {
+      console.error(`Failed to apply patch at ${patch.path.join('.')}:`, error);
+      return false;
+    }
+  }
+  isEqual(a, b) {
+    if (a === b) return true;
+    if (typeof a !== typeof b) return false;
+    if (a === null || b === null) return false;
+    if (typeof a !== 'object') return false;
+    const ao = a;
+    const bo = b;
+    if (Array.isArray(ao) && Array.isArray(bo)) {
+      if (ao.length !== bo.length) return false;
+      for (let i = 0; i < ao.length; i++) {
+        if (ao[i] !== bo[i]) return false;
+      }
+      return true;
+    }
+    const aKeys = Object.keys(ao);
+    const bKeys = Object.keys(bo);
+    if (aKeys.length !== bKeys.length) return false;
+    for (let i = 0; i < aKeys.length; i++) {
+      const k = aKeys[i];
+      if (!(k in bo)) return false;
+      if (ao[k] !== bo[k]) return false;
+    }
+    try {
+      return JSON.stringify(a) === JSON.stringify(b);
+    } catch (_a) {
+      return false;
+    }
+  }
+}
+
+export { OptimizedUpdateEngine };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/enterprise",
-  "version": "6.0.0",
+  "version": "6.0.1",
   "description": "Enterprise-grade optimizations for SignalTree. Provides diff-based updates, bulk operation optimization, and advanced change tracking for large-scale applications.",
   "type": "module",
   "sideEffects": false,