@signaltree/enterprise 4.1.2 → 4.1.4

package/dist/index.js

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

package/dist/lib/diff-engine.js

@@ -12,23 +12,38 @@ class DiffEngine {
       detectDeletions: false,
       ignoreArrayOrder: false,
       equalityFn: (a, b) => a === b,
-      keyValidator: undefined
+      keyValidator: undefined,
+      instrumentation: false
     };
   }
   diff(current, updates, options = {}) {
     const opts = Object.assign(Object.assign({}, this.defaultOptions), options);
     const changes = [];
     const visited = new WeakSet();
-    this.traverse(current, updates, [], changes, visited, opts, 0);
+    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
+      hasChanges: changes.length > 0,
+      instrumentation: opts.instrumentation ? metrics : undefined
     };
   }
-  traverse(curr, upd, path, changes, visited, opts, depth) {
+  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({
@@ -45,7 +60,7 @@ class DiffEngine {
     }
     visited.add(upd);
     if (Array.isArray(upd)) {
-      this.diffArrays(curr, upd, path, changes, visited, opts, depth);
+      this.diffArrays(curr, upd, path, changes, visited, opts, depth, metrics);
       return;
     }
     if (!curr || typeof curr !== 'object' || Array.isArray(curr)) {
@@ -64,7 +79,7 @@ class DiffEngine {
         if (opts.keyValidator && !opts.keyValidator(key)) {
           continue;
         }
-        this.traverse(currObj[key], updObj[key], [...path, key], changes, visited, opts, depth + 1);
+        this.traverse(currObj[key], updObj[key], [...path, key], changes, visited, opts, depth + 1, metrics);
       }
     }
     if (opts.detectDeletions) {
@@ -79,7 +94,7 @@ class DiffEngine {
       }
     }
   }
-  diffArrays(curr, upd, path, changes, visited, opts, depth) {
+  diffArrays(curr, upd, path, changes, visited, opts, depth, metrics) {
     if (!Array.isArray(curr)) {
       changes.push({
         type: ChangeType.REPLACE,
@@ -92,11 +107,80 @@ class DiffEngine {
     if (opts.ignoreArrayOrder) {
       this.diffArraysUnordered(curr, upd, path, changes, opts);
     } else {
-      this.diffArraysOrdered(curr, upd, path, changes, visited, opts, depth);
+      this.diffArraysOrdered(curr, upd, path, changes, visited, opts, depth, metrics);
     }
   }
-  diffArraysOrdered(curr, upd, path, changes, visited, opts, depth) {
-    const maxLength = Math.max(curr.length, upd.length);
+  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) {
@@ -113,7 +197,7 @@ class DiffEngine {
           value: upd[i]
         });
       } else {
-        this.traverse(curr[i], upd[i], [...path, i], changes, visited, opts, depth + 1);
+        this.traverse(curr[i], upd[i], [...path, i], changes, visited, opts, depth + 1, metrics);
       }
     }
   }

package/dist/lib/enterprise-enhancer.js

@@ -14,9 +14,13 @@ function withEnterprise() {
         updateEngine = new OptimizedUpdateEngine(signalTree.state);
       }
       const result = updateEngine.update(signalTree.state, updates, options);
-      if (result.changed && result.stats && pathIndex) {
-        pathIndex.clear();
-        pathIndex.buildFromTree(signalTree.state);
+      if (result.changed && pathIndex) {
+        if (result.changedPaths.length) {
+          pathIndex.incrementalUpdate(signalTree.state, result.changedPaths);
+        } else {
+          pathIndex.clear();
+          pathIndex.buildFromTree(signalTree.state);
+        }
       }
       return result;
     };

package/dist/lib/path-index.js

@@ -16,6 +16,14 @@ class PathIndex {
       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);
@@ -116,6 +124,7 @@ class PathIndex {
   clear() {
     this.root = new TrieNode();
     this.pathCache.clear();
+    if (this.enableInstrumentation) this.instrumentation.fullRebuilds++;
   }
   getStats() {
     const total = this.stats.hits + this.stats.misses;
@@ -154,6 +163,102 @@ class PathIndex {
       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

@@ -1,12 +1,53 @@
 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 (q.length === 1) flush();
+  if (config.instrumentation && q.length > metrics.maxQueueLength) {
+    metrics.maxQueueLength = q.length;
+  }
+  if (!draining) {
+    draining = true;
+    Promise.resolve().then(drain);
+  }
 }
-function flush() {
+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();
       try {
@@ -14,9 +55,21 @@ function flush() {
       } catch (e) {
         console.error('[EnterpriseScheduler]', e);
       }
-      yield Promise.resolve();
+      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 { postTask };
+export { configureScheduler, getSchedulerMetrics, postTask };

package/dist/lib/update-engine.js

@@ -166,14 +166,26 @@ class OptimizedUpdateEngine {
     }
   }
   isEqual(a, b) {
-    if (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;
     }
-    if (typeof a !== typeof b) {
-      return false;
-    }
-    if (typeof a !== 'object' || a === null || b === null) {
-      return false;
+    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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/enterprise",
-  "version": "4.1.2",
+  "version": "4.1.4",
   "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,
@@ -10,38 +10,31 @@
   "exports": {
     ".": {
       "import": "./dist/index.js",
-      "default": "./dist/index.js",
-      "types": "./src/index.d.ts"
+      "default": "./dist/index.js"
     },
     "./diff-engine": {
       "import": "./dist/lib/diff-engine.js",
-      "default": "./dist/lib/diff-engine.js",
-      "types": "./src/lib/diff-engine.d.ts"
+      "default": "./dist/lib/diff-engine.js"
     },
     "./path-index": {
       "import": "./dist/lib/path-index.js",
-      "default": "./dist/lib/path-index.js",
-      "types": "./src/lib/path-index.d.ts"
+      "default": "./dist/lib/path-index.js"
     },
     "./update-engine": {
       "import": "./dist/lib/update-engine.js",
-      "default": "./dist/lib/update-engine.js",
-      "types": "./src/lib/update-engine.d.ts"
+      "default": "./dist/lib/update-engine.js"
     },
     "./enterprise-enhancer": {
       "import": "./dist/lib/enterprise-enhancer.js",
-      "default": "./dist/lib/enterprise-enhancer.js",
-      "types": "./src/lib/enterprise-enhancer.d.ts"
+      "default": "./dist/lib/enterprise-enhancer.js"
     },
     "./scheduler": {
       "import": "./dist/lib/scheduler.js",
-      "default": "./dist/lib/scheduler.js",
-      "types": "./src/lib/scheduler.d.ts"
+      "default": "./dist/lib/scheduler.js"
     },
     "./thread-pools": {
       "import": "./dist/lib/thread-pools.js",
-      "default": "./dist/lib/thread-pools.js",
-      "types": "./src/lib/thread-pools.d.ts"
+      "default": "./dist/lib/thread-pools.js"
     }
   },
   "keywords": [
@@ -68,7 +61,7 @@
   },
   "peerDependencies": {
     "@angular/core": "^20.3.0",
-    "@signaltree/core": "4.1.2",
+    "@signaltree/core": "4.1.4",
     "tslib": "^2.0.0"
   },
   "devDependencies": {