libpetri 2.9.0 → 2.10.1

package/dist/index.js

@@ -2847,6 +2847,15 @@ var IncrementalMatcher = class {
     this.ts = requireds.map(() => /* @__PURE__ */ new Map());
   }
   ts;
+  /** Monotonic fast path: ascending `(rep_ts, name)`; `fifo[fifoHead]` (after
+   * `cleanTop`) is the min. Active while `!heaped`. Advance `fifoHead` instead of
+   * `shift()` (O(1)); reset when the head catches the length. */
+  fifo = [];
+  fifoHead = 0;
+  /** Largest entry appended to `fifo` in the current monotonic run. */
+  maxPushed = null;
+  /** Once an out-of-order push migrates `fifo` into `heap`. */
+  heaped = false;
   heap = new ReadyHeap();
   ready = /* @__PURE__ */ new Map();
   /** Add one (already guard-passing) token carrying `name` at `createdAt` to input `i`. */
@@ -2874,8 +2883,35 @@ var IncrementalMatcher = class {
   }
   /** The name `selectMatchName` would pick, or `null`. O(1) read. */
   best() {
-    const top = this.heap.peek();
-    return top ? top.name : null;
+    if (this.heaped) {
+      const top = this.heap.peek();
+      return top ? top.name : null;
+    }
+    return this.fifoHead < this.fifo.length ? this.fifo[this.fifoHead].name : null;
+  }
+  /**
+   * Route a ready name's `(rep, name)` to the active structure: append to the
+   * FIFO in O(1) while pushes stay non-decreasing; on the first inversion,
+   * migrate the FIFO into the heap and stay heap-backed.
+   */
+  pushReady(rep, name) {
+    const entry = { ts: rep, name };
+    if (this.heaped) {
+      this.heap.push(entry);
+      return;
+    }
+    const max = this.maxPushed;
+    const monotonic = max === null || rep > max.ts || rep === max.ts && name >= max.name;
+    if (monotonic) {
+      this.maxPushed = entry;
+      this.fifo.push(entry);
+    } else {
+      this.heaped = true;
+      for (let i = this.fifoHead; i < this.fifo.length; i++) this.heap.push(this.fifo[i]);
+      this.fifo.length = 0;
+      this.fifoHead = 0;
+      this.heap.push(entry);
+    }
   }
   repTs(name) {
     let rep = Infinity;
@@ -2892,19 +2928,40 @@ var IncrementalMatcher = class {
     if (rep !== null) {
       if (this.ready.get(name) !== rep) {
         this.ready.set(name, rep);
-        this.heap.push({ ts: rep, name });
+        this.pushReady(rep, name);
       }
     } else {
       this.ready.delete(name);
     }
   }
   cleanTop() {
-    for (; ; ) {
-      const top = this.heap.peek();
-      if (top && this.ready.get(top.name) !== top.ts) this.heap.pop();
-      else break;
+    if (this.heaped) {
+      for (; ; ) {
+        const top = this.heap.peek();
+        if (top && this.ready.get(top.name) !== top.ts) this.heap.pop();
+        else break;
+      }
+      if (this.heap.size === 0) {
+        this.heaped = false;
+        this.maxPushed = null;
+      }
+    } else {
+      while (this.fifoHead < this.fifo.length) {
+        const top = this.fifo[this.fifoHead];
+        if (this.ready.get(top.name) !== top.ts) this.fifoHead++;
+        else break;
+      }
+      if (this.fifoHead >= this.fifo.length) {
+        this.fifo.length = 0;
+        this.fifoHead = 0;
+        this.maxPushed = null;
+      }
     }
   }
+  /** Test-only: has the matcher fallen back from the FIFO fast path to the heap? */
+  isHeaped() {
+    return this.heaped;
+  }
 };
 
 // src/runtime/out-violation-error.ts