libpetri 1.2.0 → 1.3.1

package/dist/index.js

@@ -1894,6 +1894,1215 @@ var TimeoutSentinel = class extends Error {
     this.name = "TimeoutSentinel";
   }
 };
+
+// src/runtime/precompiled-net.ts
+var CONSUME_ONE = 0;
+var CONSUME_N = 1;
+var CONSUME_ALL = 2;
+var CONSUME_ATLEAST = 3;
+var RESET = 4;
+var SPARSE_EMPTY = -2;
+var SPARSE_MULTI = -1;
+var PrecompiledNet = class _PrecompiledNet {
+  // ==================== Identity ====================
+  compiled;
+  placeCount;
+  transitionCount;
+  wordCount;
+  // ==================== Place Cache ====================
+  /** Places indexed by pid — avoids compiled.place(pid) indirection on hot path. */
+  places;
+  // ==================== Opcode Programs ====================
+  /** Per-transition consume opcode sequences. */
+  consumeOps;
+  /** Per-transition read-arc place IDs. */
+  readOps;
+  // ==================== Enablement Masks ====================
+  needsMask;
+  inhibitorMask;
+  // ==================== Sparse Enablement (PERF-042) ====================
+  needsSingleWordIndex;
+  needsSingleWordMask;
+  needsSparseIndices;
+  needsSparseMasks;
+  inhibitorSingleWordIndex;
+  inhibitorSingleWordMask;
+  inhibitorSparseIndices;
+  inhibitorSparseMasks;
+  // ==================== Timing (CONC-024) ====================
+  earliestMs;
+  latestMs;
+  hasDeadline;
+  // ==================== Priority (CONC-023) ====================
+  priorities;
+  transitionToPriorityIndex;
+  priorityLevels;
+  distinctPriorityCount;
+  // ==================== Output Fast Path ====================
+  /** -2=no spec, -1=complex, >=0=single output place ID. */
+  simpleOutputPlaceId;
+  // ==================== Input Precomputation ====================
+  inputPlaceCount;
+  inputPlaceMaskWords;
+  // ==================== Reverse Index ====================
+  placeToTransitions;
+  consumptionPlaceIds;
+  // ==================== Cardinality & Guards ====================
+  cardinalityChecks;
+  hasGuards;
+  // ==================== Global Flags ====================
+  allImmediate;
+  allSamePriority;
+  anyDeadlines;
+  constructor(compiled) {
+    this.compiled = compiled;
+    this.placeCount = compiled.placeCount;
+    this.transitionCount = compiled.transitionCount;
+    this.wordCount = compiled.wordCount;
+    const tc = compiled.transitionCount;
+    const wc = compiled.wordCount;
+    const places = new Array(this.placeCount);
+    for (let pid = 0; pid < this.placeCount; pid++) {
+      places[pid] = compiled.place(pid);
+    }
+    this.places = places;
+    const needsMask = new Array(tc);
+    const inhibitorMask = new Array(tc);
+    for (let tid = 0; tid < tc; tid++) {
+      needsMask[tid] = new Uint32Array(wc);
+      inhibitorMask[tid] = new Uint32Array(wc);
+    }
+    for (let tid = 0; tid < tc; tid++) {
+      const t = compiled.transition(tid);
+      const needs = needsMask[tid];
+      const inhibitors = inhibitorMask[tid];
+      for (const inSpec of t.inputSpecs) {
+        const pid = compiled.placeId(inSpec.place);
+        needs[pid >>> WORD_SHIFT] |= 1 << (pid & BIT_MASK);
+      }
+      for (const arc of t.reads) {
+        const pid = compiled.placeId(arc.place);
+        needs[pid >>> WORD_SHIFT] |= 1 << (pid & BIT_MASK);
+      }
+      for (const arc of t.inhibitors) {
+        const pid = compiled.placeId(arc.place);
+        inhibitors[pid >>> WORD_SHIFT] |= 1 << (pid & BIT_MASK);
+      }
+    }
+    this.needsMask = needsMask;
+    this.inhibitorMask = inhibitorMask;
+    this.needsSingleWordIndex = new Int8Array(tc);
+    this.needsSingleWordMask = new Uint32Array(tc);
+    const needsSparseIndices = new Array(tc);
+    const needsSparseMasks = new Array(tc);
+    this.inhibitorSingleWordIndex = new Int8Array(tc);
+    this.inhibitorSingleWordMask = new Uint32Array(tc);
+    const inhibitorSparseIndices = new Array(tc);
+    const inhibitorSparseMasks = new Array(tc);
+    for (let tid = 0; tid < tc; tid++) {
+      compileSparse(
+        needsMask[tid],
+        wc,
+        this.needsSingleWordIndex,
+        this.needsSingleWordMask,
+        needsSparseIndices,
+        needsSparseMasks,
+        tid
+      );
+      compileSparse(
+        inhibitorMask[tid],
+        wc,
+        this.inhibitorSingleWordIndex,
+        this.inhibitorSingleWordMask,
+        inhibitorSparseIndices,
+        inhibitorSparseMasks,
+        tid
+      );
+    }
+    this.needsSparseIndices = needsSparseIndices;
+    this.needsSparseMasks = needsSparseMasks;
+    this.inhibitorSparseIndices = inhibitorSparseIndices;
+    this.inhibitorSparseMasks = inhibitorSparseMasks;
+    const consumeOps = new Array(tc);
+    const readOps = new Array(tc);
+    for (let tid = 0; tid < tc; tid++) {
+      const t = compiled.transition(tid);
+      consumeOps[tid] = compileConsumeProgram(t, compiled);
+      readOps[tid] = compileReadProgram(t, compiled);
+    }
+    this.consumeOps = consumeOps;
+    this.readOps = readOps;
+    const placeToTransitions = new Array(this.placeCount);
+    const consumptionPlaceIds = new Array(tc);
+    for (let pid = 0; pid < this.placeCount; pid++) {
+      placeToTransitions[pid] = [...compiled.affectedTransitions(pid)];
+    }
+    for (let tid = 0; tid < tc; tid++) {
+      consumptionPlaceIds[tid] = [...compiled.consumptionPlaceIds(tid)];
+    }
+    this.placeToTransitions = placeToTransitions;
+    this.consumptionPlaceIds = consumptionPlaceIds;
+    const cardinalityChecks = new Array(tc);
+    const hasGuards = new Array(tc);
+    for (let tid = 0; tid < tc; tid++) {
+      cardinalityChecks[tid] = compiled.cardinalityCheck(tid);
+      hasGuards[tid] = compiled.hasGuards(tid);
+    }
+    this.cardinalityChecks = cardinalityChecks;
+    this.hasGuards = hasGuards;
+    this.earliestMs = new Float64Array(tc);
+    this.latestMs = new Float64Array(tc);
+    this.hasDeadline = new Uint8Array(tc);
+    let anyDeadlines = false;
+    let allImm = true;
+    for (let tid = 0; tid < tc; tid++) {
+      const t = compiled.transition(tid);
+      this.earliestMs[tid] = earliest(t.timing);
+      this.latestMs[tid] = latest(t.timing);
+      if (hasDeadline(t.timing)) {
+        this.hasDeadline[tid] = 1;
+        anyDeadlines = true;
+      }
+      if (t.timing.type !== "immediate") allImm = false;
+    }
+    this.anyDeadlines = anyDeadlines;
+    this.allImmediate = allImm;
+    this.priorities = new Int32Array(tc);
+    const prioritySet = /* @__PURE__ */ new Set();
+    const firstPriority = tc > 0 ? compiled.transition(0).priority : 0;
+    let samePrio = true;
+    for (let tid = 0; tid < tc; tid++) {
+      const p = compiled.transition(tid).priority;
+      this.priorities[tid] = p;
+      prioritySet.add(p);
+      if (p !== firstPriority) samePrio = false;
+    }
+    this.allSamePriority = samePrio;
+    const levels = [...prioritySet].sort((a, b) => b - a);
+    this.priorityLevels = levels;
+    this.distinctPriorityCount = levels.length;
+    this.transitionToPriorityIndex = new Uint32Array(tc);
+    const levelIndex = /* @__PURE__ */ new Map();
+    for (let i = 0; i < levels.length; i++) {
+      levelIndex.set(levels[i], i);
+    }
+    for (let tid = 0; tid < tc; tid++) {
+      this.transitionToPriorityIndex[tid] = levelIndex.get(this.priorities[tid]);
+    }
+    this.simpleOutputPlaceId = new Int32Array(tc);
+    for (let tid = 0; tid < tc; tid++) {
+      const t = compiled.transition(tid);
+      if (t.outputSpec === null) {
+        this.simpleOutputPlaceId[tid] = -2;
+      } else {
+        const simplePid = simpleOutputPlace(t.outputSpec, compiled);
+        this.simpleOutputPlaceId[tid] = simplePid;
+      }
+    }
+    this.inputPlaceCount = new Uint32Array(tc);
+    const inputPlaceMaskWords = new Array(tc);
+    for (let tid = 0; tid < tc; tid++) {
+      const t = compiled.transition(tid);
+      this.inputPlaceCount[tid] = t.inputSpecs.length + t.reads.length;
+      const mask = new Uint32Array(wc);
+      for (const spec of t.inputSpecs) {
+        const pid = compiled.placeId(spec.place);
+        mask[pid >>> WORD_SHIFT] |= 1 << (pid & BIT_MASK);
+      }
+      inputPlaceMaskWords[tid] = mask;
+    }
+    this.inputPlaceMaskWords = inputPlaceMaskWords;
+  }
+  // ==================== Factory Methods ====================
+  static compile(net) {
+    return new _PrecompiledNet(CompiledNet.compile(net));
+  }
+  static compileFrom(compiled) {
+    return new _PrecompiledNet(compiled);
+  }
+  // ==================== Sparse Enablement Check ====================
+  /**
+   * Three-case sparse enablement check:
+   * 1. Empty mask (needsSingleWordIndex == -2): always passes
+   * 2. Single-word mask (>=0): one comparison
+   * 3. Multi-word mask (-1): iterate precomputed sparse indices
+   */
+  canEnableSparse(tid, snapshot) {
+    const needsIdx = this.needsSingleWordIndex[tid];
+    if (needsIdx === SPARSE_EMPTY) {
+    } else if (needsIdx >= 0) {
+      const m = this.needsSingleWordMask[tid];
+      if ((snapshot[needsIdx] & m) !== m) return false;
+    } else {
+      const indices = this.needsSparseIndices[tid];
+      const masks = this.needsSparseMasks[tid];
+      for (let i = 0; i < indices.length; i++) {
+        const m = masks[i];
+        if ((snapshot[indices[i]] & m) !== m) return false;
+      }
+    }
+    const inhIdx = this.inhibitorSingleWordIndex[tid];
+    if (inhIdx === SPARSE_EMPTY) {
+      return true;
+    } else if (inhIdx >= 0) {
+      return (snapshot[inhIdx] & this.inhibitorSingleWordMask[tid]) === 0;
+    } else {
+      const indices = this.inhibitorSparseIndices[tid];
+      const masks = this.inhibitorSparseMasks[tid];
+      for (let i = 0; i < indices.length; i++) {
+        if ((snapshot[indices[i]] & masks[i]) !== 0) return false;
+      }
+      return true;
+    }
+  }
+};
+function compileSparse(mask, wordCount, singleWordIndex, singleWordMask, sparseIndices, sparseMasks, tid) {
+  let nonZeroCount = 0;
+  let lastNonZeroWord = -1;
+  for (let w = 0; w < wordCount; w++) {
+    if (mask[w] !== 0) {
+      nonZeroCount++;
+      lastNonZeroWord = w;
+    }
+  }
+  if (nonZeroCount === 0) {
+    singleWordIndex[tid] = SPARSE_EMPTY;
+    singleWordMask[tid] = 0;
+    sparseIndices[tid] = [];
+    sparseMasks[tid] = [];
+  } else if (nonZeroCount === 1) {
+    singleWordIndex[tid] = lastNonZeroWord;
+    singleWordMask[tid] = mask[lastNonZeroWord];
+    sparseIndices[tid] = [];
+    sparseMasks[tid] = [];
+  } else {
+    singleWordIndex[tid] = SPARSE_MULTI;
+    singleWordMask[tid] = 0;
+    const idx = [];
+    const msk = [];
+    for (let w = 0; w < wordCount; w++) {
+      if (mask[w] !== 0) {
+        idx.push(w);
+        msk.push(mask[w]);
+      }
+    }
+    sparseIndices[tid] = idx;
+    sparseMasks[tid] = msk;
+  }
+}
+function compileConsumeProgram(t, compiled) {
+  const ops = [];
+  for (const spec of t.inputSpecs) {
+    const pid = compiled.placeId(spec.place);
+    switch (spec.type) {
+      case "one":
+        ops.push(CONSUME_ONE, pid);
+        break;
+      case "exactly":
+        ops.push(CONSUME_N, pid, spec.count);
+        break;
+      case "all":
+        ops.push(CONSUME_ALL, pid);
+        break;
+      case "at-least":
+        ops.push(CONSUME_ATLEAST, pid, spec.minimum);
+        break;
+    }
+  }
+  for (const arc of t.resets) {
+    const pid = compiled.placeId(arc.place);
+    ops.push(RESET, pid);
+  }
+  return ops;
+}
+function compileReadProgram(t, compiled) {
+  const pids = [];
+  for (const arc of t.reads) {
+    pids.push(compiled.placeId(arc.place));
+  }
+  return pids;
+}
+function simpleOutputPlace(spec, compiled) {
+  if (spec.type === "place") {
+    return compiled.placeId(spec.place);
+  }
+  return -1;
+}
+
+// src/runtime/precompiled-net-executor.ts
+var DEADLINE_TOLERANCE_MS2 = 5;
+var PrecompiledNetExecutor = class {
+  program;
+  eventStore;
+  environmentPlaces;
+  longRunning;
+  executionContextProvider;
+  skipOutputValidation;
+  startMs;
+  eventStoreEnabled;
+  // ==================== Token Storage ====================
+  /** Per-place token arrays, indexed by pid. */
+  tokenQueues;
+  // ==================== Marking Bitmap ====================
+  markingBitmap;
+  // ==================== Transition State ====================
+  dirtyBitmap;
+  dirtyScanBuffer;
+  enabledAtMs;
+  inFlightFlags;
+  enabledFlags;
+  transitionWords;
+  // ==================== Enabled Count ====================
+  enabledTransitionCount = 0;
+  // ==================== In-Flight Tracking ====================
+  inFlightPromises;
+  inFlightContexts;
+  inFlightConsumed;
+  inFlightStartMs;
+  inFlightResolves;
+  inFlightErrors;
+  inFlightCount = 0;
+  // ==================== Reset-Clock Detection ====================
+  pendingResetWords;
+  hasPendingResets = false;
+  // ==================== Queues ====================
+  completionQueue = [];
+  externalQueue = [];
+  wakeUpResolve = null;
+  // ==================== Reusable Buffers ====================
+  markingSnapBuffer;
+  firingSnapBuffer;
+  awaitPromises = [];
+  racePromises = [];
+  // Pre-allocated buffer for fireReadyGeneral()
+  readyBuffer = [];
+  // ==================== Lifecycle ====================
+  running = false;
+  closed = false;
+  // ==================== Lazy Marking ====================
+  marking = null;
+  constructor(net, initialTokens, options = {}) {
+    this.program = options.program ?? PrecompiledNet.compile(net);
+    this.eventStore = options.eventStore ?? noopEventStore();
+    this.environmentPlaces = new Set(
+      [...options.environmentPlaces ?? []].map((ep) => ep.place.name)
+    );
+    this.longRunning = options.longRunning ?? false;
+    this.executionContextProvider = options.executionContextProvider;
+    this.skipOutputValidation = options.skipOutputValidation ?? false;
+    this.startMs = performance.now();
+    this.eventStoreEnabled = this.eventStore.isEnabled();
+    const prog = this.program;
+    const pc = prog.placeCount;
+    const tc = prog.transitionCount;
+    const wc = prog.wordCount;
+    this.tokenQueues = new Array(pc);
+    for (let pid = 0; pid < pc; pid++) {
+      this.tokenQueues[pid] = [];
+    }
+    for (const [place2, tokens] of initialTokens) {
+      const pid = prog.compiled.placeId(place2);
+      const q = this.tokenQueues[pid];
+      for (const token of tokens) {
+        q.push(token);
+      }
+    }
+    this.markingBitmap = new Uint32Array(wc);
+    this.transitionWords = tc + BIT_MASK >>> WORD_SHIFT;
+    this.dirtyBitmap = new Uint32Array(this.transitionWords);
+    this.dirtyScanBuffer = new Uint32Array(this.transitionWords);
+    this.enabledAtMs = new Float64Array(tc);
+    this.enabledAtMs.fill(-Infinity);
+    this.inFlightFlags = new Uint8Array(tc);
+    this.enabledFlags = new Uint8Array(tc);
+    this.inFlightPromises = new Array(tc).fill(null);
+    this.inFlightContexts = new Array(tc).fill(null);
+    this.inFlightConsumed = new Array(tc).fill(null);
+    this.inFlightStartMs = new Float64Array(tc);
+    this.inFlightResolves = new Array(tc).fill(null);
+    this.inFlightErrors = new Array(tc).fill(null);
+    this.pendingResetWords = new Uint32Array(wc);
+    this.markingSnapBuffer = new Uint32Array(wc);
+    this.firingSnapBuffer = new Uint32Array(wc);
+  }
+  // ======================== Bitmap Helpers ========================
+  markTransitionDirty(tid) {
+    this.dirtyBitmap[tid >>> WORD_SHIFT] |= 1 << (tid & BIT_MASK);
+  }
+  markDirty(pid) {
+    const tids = this.program.placeToTransitions[pid];
+    for (let i = 0; i < tids.length; i++) {
+      this.markTransitionDirty(tids[i]);
+    }
+  }
+  setMarkingBit(pid) {
+    this.markingBitmap[pid >>> WORD_SHIFT] |= 1 << (pid & BIT_MASK);
+  }
+  clearMarkingBit(pid) {
+    this.markingBitmap[pid >>> WORD_SHIFT] &= ~(1 << (pid & BIT_MASK));
+  }
+  // ======================== Execution ========================
+  async run(timeoutMs) {
+    if (timeoutMs !== void 0) {
+      let timer;
+      const timeoutPromise = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("Execution timed out")), timeoutMs);
+      });
+      try {
+        return await Promise.race([this.executeLoop(), timeoutPromise]);
+      } finally {
+        if (timer !== void 0) clearTimeout(timer);
+      }
+    }
+    return this.executeLoop();
+  }
+  async executeLoop() {
+    this.running = true;
+    const prog = this.program;
+    this.emitEvent({
+      type: "execution-started",
+      timestamp: Date.now(),
+      netName: prog.compiled.net.name,
+      executionId: this.executionId()
+    });
+    this.initializeMarkingBitmap();
+    this.markAllDirty();
+    this.emitEvent({
+      type: "marking-snapshot",
+      timestamp: Date.now(),
+      marking: this.snapshotMarking()
+    });
+    while (this.running && !this.closed) {
+      this.processCompletedTransitions();
+      this.processExternalEvents();
+      this.updateDirtyTransitions();
+      const cycleNowMs = performance.now();
+      if (prog.anyDeadlines) this.enforceDeadlines(cycleNowMs);
+      if (this.shouldTerminate()) break;
+      this.fireReadyTransitions(cycleNowMs);
+      if (this.hasDirtyBits()) continue;
+      await this.awaitWork();
+    }
+    this.running = false;
+    this.drainPendingExternalEvents();
+    this.emitEvent({
+      type: "marking-snapshot",
+      timestamp: Date.now(),
+      marking: this.snapshotMarking()
+    });
+    this.emitEvent({
+      type: "execution-completed",
+      timestamp: Date.now(),
+      netName: prog.compiled.net.name,
+      executionId: this.executionId(),
+      totalDurationMs: performance.now() - this.startMs
+    });
+    return this.syncMarkingFromQueues();
+  }
+  // ======================== Environment Place API ========================
+  async inject(envPlace, token) {
+    if (!this.environmentPlaces.has(envPlace.place.name)) {
+      throw new Error(`Place ${envPlace.place.name} is not registered as an environment place`);
+    }
+    if (this.closed) return false;
+    return new Promise((resolve, reject) => {
+      this.externalQueue.push({
+        place: envPlace.place,
+        token,
+        resolve,
+        reject
+      });
+      this.wakeUp();
+    });
+  }
+  async injectValue(envPlace, value) {
+    return this.inject(envPlace, tokenOf(value));
+  }
+  // ======================== Initialize ========================
+  initializeMarkingBitmap() {
+    for (let pid = 0; pid < this.program.placeCount; pid++) {
+      if (this.tokenQueues[pid].length > 0) {
+        this.setMarkingBit(pid);
+      }
+    }
+  }
+  markAllDirty() {
+    const tw = this.transitionWords;
+    const tc = this.program.transitionCount;
+    for (let w = 0; w < tw - 1; w++) {
+      this.dirtyBitmap[w] = 4294967295;
+    }
+    if (tw > 0) {
+      const lastBits = tc & BIT_MASK;
+      this.dirtyBitmap[tw - 1] = lastBits === 0 ? 4294967295 : (1 << lastBits) - 1;
+    }
+  }
+  shouldTerminate() {
+    if (this.longRunning) return this.closed;
+    return this.enabledTransitionCount === 0 && this.inFlightCount === 0 && this.completionQueue.length === 0;
+  }
+  // ======================== Dirty Set Processing ========================
+  updateDirtyTransitions() {
+    const nowMs = performance.now();
+    const prog = this.program;
+    const tc = prog.transitionCount;
+    const markingSnap = this.markingSnapBuffer;
+    markingSnap.set(this.markingBitmap);
+    const tw = this.transitionWords;
+    const dirtySnap = this.dirtyScanBuffer;
+    for (let w = 0; w < tw; w++) {
+      dirtySnap[w] = this.dirtyBitmap[w];
+      this.dirtyBitmap[w] = 0;
+    }
+    for (let w = 0; w < tw; w++) {
+      let word = dirtySnap[w];
+      if (word === 0) continue;
+      dirtySnap[w] = 0;
+      while (word !== 0) {
+        const bit = Math.clz32(word & -word) ^ 31;
+        const tid = w << WORD_SHIFT | bit;
+        word &= word - 1;
+        if (tid >= tc) break;
+        if (this.inFlightFlags[tid]) continue;
+        const wasEnabled = this.enabledFlags[tid] !== 0;
+        const canNow = this.canEnable(tid, markingSnap);
+        if (canNow && !wasEnabled) {
+          this.enabledFlags[tid] = 1;
+          this.enabledTransitionCount++;
+          this.enabledAtMs[tid] = nowMs;
+          this.emitEvent({
+            type: "transition-enabled",
+            timestamp: Date.now(),
+            transitionName: prog.compiled.transition(tid).name
+          });
+        } else if (!canNow && wasEnabled) {
+          this.enabledFlags[tid] = 0;
+          this.enabledTransitionCount--;
+          this.enabledAtMs[tid] = -Infinity;
+        } else if (canNow && wasEnabled && this.hasInputFromResetPlace(tid)) {
+          this.enabledAtMs[tid] = nowMs;
+          this.emitEvent({
+            type: "transition-clock-restarted",
+            timestamp: Date.now(),
+            transitionName: prog.compiled.transition(tid).name
+          });
+        }
+      }
+    }
+    if (this.hasPendingResets) {
+      this.pendingResetWords.fill(0);
+      this.hasPendingResets = false;
+    }
+  }
+  enforceDeadlines(nowMs) {
+    const prog = this.program;
+    const tc = prog.transitionCount;
+    for (let tid = 0; tid < tc; tid++) {
+      if (!prog.hasDeadline[tid]) continue;
+      if (!this.enabledFlags[tid] || this.inFlightFlags[tid]) continue;
+      const elapsed = nowMs - this.enabledAtMs[tid];
+      const latestMs = prog.latestMs[tid];
+      if (elapsed > latestMs + DEADLINE_TOLERANCE_MS2) {
+        this.enabledFlags[tid] = 0;
+        this.enabledTransitionCount--;
+        this.enabledAtMs[tid] = -Infinity;
+        this.emitEvent({
+          type: "transition-timed-out",
+          timestamp: Date.now(),
+          transitionName: prog.compiled.transition(tid).name,
+          deadlineMs: latestMs,
+          actualDurationMs: elapsed
+        });
+      }
+    }
+  }
+  canEnable(tid, markingSnap) {
+    const prog = this.program;
+    if (!prog.canEnableSparse(tid, markingSnap)) return false;
+    const cardCheck = prog.cardinalityChecks[tid] ?? null;
+    if (cardCheck !== null) {
+      for (let i = 0; i < cardCheck.placeIds.length; i++) {
+        const pid = cardCheck.placeIds[i];
+        if (this.tokenQueues[pid].length < cardCheck.requiredCounts[i]) return false;
+      }
+    }
+    if (prog.hasGuards[tid]) {
+      const t = prog.compiled.transition(tid);
+      for (const spec of t.inputSpecs) {
+        if (!spec.guard) continue;
+        const required = spec.type === "one" ? 1 : spec.type === "exactly" ? spec.count : spec.type === "at-least" ? spec.minimum : 1;
+        if (this.countMatching(prog.compiled.placeId(spec.place), spec.guard) < required) return false;
+      }
+    }
+    return true;
+  }
+  countMatching(pid, guard) {
+    const q = this.tokenQueues[pid];
+    let matching = 0;
+    for (let i = 0; i < q.length; i++) {
+      if (guard(q[i].value)) matching++;
+    }
+    return matching;
+  }
+  removeFirstMatching(pid, guard) {
+    const q = this.tokenQueues[pid];
+    for (let i = 0; i < q.length; i++) {
+      if (guard(q[i].value)) {
+        return q.splice(i, 1)[0];
+      }
+    }
+    return null;
+  }
+  hasInputFromResetPlace(tid) {
+    if (!this.hasPendingResets) return false;
+    const inputMask = this.program.inputPlaceMaskWords[tid];
+    for (let w = 0; w < inputMask.length; w++) {
+      if ((inputMask[w] & this.pendingResetWords[w]) !== 0) return true;
+    }
+    return false;
+  }
+  // ======================== Firing ========================
+  fireReadyTransitions(nowMs) {
+    if (this.program.allImmediate && this.program.allSamePriority) {
+      this.fireReadyImmediate();
+      return;
+    }
+    this.fireReadyGeneral(nowMs);
+  }
+  /**
+   * Fast path for nets where all transitions are immediate and same priority.
+   * Simple linear scan matching BitmapNetExecutor's pattern.
+   */
+  fireReadyImmediate() {
+    const tc = this.program.transitionCount;
+    for (let tid = 0; tid < tc; tid++) {
+      if (!this.enabledFlags[tid] || this.inFlightFlags[tid]) continue;
+      if (this.canEnable(tid, this.markingBitmap)) {
+        this.fireTransition(tid);
+      } else {
+        this.enabledFlags[tid] = 0;
+        this.enabledTransitionCount--;
+        this.enabledAtMs[tid] = -Infinity;
+      }
+    }
+  }
+  fireReadyGeneral(nowMs) {
+    const prog = this.program;
+    const tc = prog.transitionCount;
+    const ready = this.readyBuffer;
+    ready.length = 0;
+    for (let tid = 0; tid < tc; tid++) {
+      if (!this.enabledFlags[tid] || this.inFlightFlags[tid]) continue;
+      const elapsedMs = nowMs - this.enabledAtMs[tid];
+      if (prog.earliestMs[tid] <= elapsedMs) {
+        ready.push({ tid, priority: prog.priorities[tid], enabledAtMs: this.enabledAtMs[tid] });
+      }
+    }
+    if (ready.length === 0) return;
+    ready.sort((a, b) => {
+      const prioCmp = b.priority - a.priority;
+      if (prioCmp !== 0) return prioCmp;
+      return a.enabledAtMs - b.enabledAtMs;
+    });
+    const freshSnap = this.firingSnapBuffer;
+    freshSnap.set(this.markingBitmap);
+    for (const entry of ready) {
+      const { tid } = entry;
+      if (this.enabledFlags[tid] && this.canEnable(tid, freshSnap)) {
+        this.fireTransition(tid);
+        freshSnap.set(this.markingBitmap);
+      } else {
+        this.enabledFlags[tid] = 0;
+        this.enabledTransitionCount--;
+        this.enabledAtMs[tid] = -Infinity;
+      }
+    }
+  }
+  fireTransition(tid) {
+    const prog = this.program;
+    const t = prog.compiled.transition(tid);
+    const consumed = [];
+    const inputs = new TokenInput();
+    if (prog.hasGuards[tid]) {
+      this.fireTransitionGuarded(tid, t, inputs, consumed);
+    } else {
+      const ops = prog.consumeOps[tid];
+      let pc = 0;
+      while (pc < ops.length) {
+        const opcode = ops[pc++];
+        switch (opcode) {
+          case CONSUME_ONE: {
+            const pid = ops[pc++];
+            const token = this.tokenQueues[pid].shift();
+            consumed.push(token);
+            inputs.add(prog.places[pid], token);
+            this.emitEvent({
+              type: "token-removed",
+              timestamp: Date.now(),
+              placeName: prog.places[pid].name,
+              token
+            });
+            break;
+          }
+          case CONSUME_N: {
+            const pid = ops[pc++];
+            const count = ops[pc++];
+            const place2 = prog.places[pid];
+            for (let i = 0; i < count; i++) {
+              const token = this.tokenQueues[pid].shift();
+              consumed.push(token);
+              inputs.add(place2, token);
+              this.emitEvent({
+                type: "token-removed",
+                timestamp: Date.now(),
+                placeName: place2.name,
+                token
+              });
+            }
+            break;
+          }
+          case CONSUME_ALL: {
+            const pid = ops[pc++];
+            const place2 = prog.places[pid];
+            const q = this.tokenQueues[pid];
+            const count = q.length;
+            for (let i = 0; i < count; i++) {
+              const token = q.shift();
+              consumed.push(token);
+              inputs.add(place2, token);
+              this.emitEvent({
+                type: "token-removed",
+                timestamp: Date.now(),
+                placeName: place2.name,
+                token
+              });
+            }
+            break;
+          }
+          case CONSUME_ATLEAST: {
+            const pid = ops[pc++];
+            pc++;
+            const place2 = prog.places[pid];
+            const q = this.tokenQueues[pid];
+            const count = q.length;
+            for (let i = 0; i < count; i++) {
+              const token = q.shift();
+              consumed.push(token);
+              inputs.add(place2, token);
+              this.emitEvent({
+                type: "token-removed",
+                timestamp: Date.now(),
+                placeName: place2.name,
+                token
+              });
+            }
+            break;
+          }
+          case RESET: {
+            const pid = ops[pc++];
+            const place2 = prog.places[pid];
+            const tokens = this.tokenQueues[pid].splice(0);
+            this.pendingResetWords[pid >>> WORD_SHIFT] |= 1 << (pid & BIT_MASK);
+            this.hasPendingResets = true;
+            for (const token of tokens) {
+              consumed.push(token);
+              this.emitEvent({
+                type: "token-removed",
+                timestamp: Date.now(),
+                placeName: place2.name,
+                token
+              });
+            }
+            break;
+          }
+        }
+      }
+    }
+    const readPids = prog.readOps[tid];
+    for (let i = 0; i < readPids.length; i++) {
+      const pid = readPids[i];
+      const q = this.tokenQueues[pid];
+      if (q.length > 0) {
+        inputs.add(prog.places[pid], q[0]);
+      }
+    }
+    this.updateBitmapAfterConsumption(tid);
+    this.emitEvent({
+      type: "transition-started",
+      timestamp: Date.now(),
+      transitionName: t.name,
+      consumedTokens: consumed
+    });
+    const execCtx = this.executionContextProvider?.(t.name, consumed);
+    const logFn = (level, message, error) => {
+      this.emitEvent({
+        type: "log-message",
+        timestamp: Date.now(),
+        transitionName: t.name,
+        logger: t.name,
+        level,
+        message,
+        error: error?.name ?? null,
+        errorMessage: error?.message ?? null
+      });
+    };
+    const context = new TransitionContext(
+      t.name,
+      inputs,
+      new TokenOutput(),
+      t.inputPlaces(),
+      t.readPlaces(),
+      t.outputPlaces(),
+      execCtx,
+      logFn
+    );
+    let actionPromise = t.action(context);
+    if (t.hasActionTimeout()) {
+      const timeoutSpec = t.actionTimeout;
+      if (timeoutSpec === null) throw new Error(`Expected actionTimeout on ${t.name}`);
+      const timeoutMs = timeoutSpec.afterMs;
+      actionPromise = Promise.race([
+        actionPromise,
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new TimeoutSentinel2()), timeoutMs)
+        )
+      ]).catch((err) => {
+        if (err instanceof TimeoutSentinel2) {
+          produceTimeoutOutput(context, timeoutSpec.child);
+          this.emitEvent({
+            type: "action-timed-out",
+            timestamp: Date.now(),
+            transitionName: t.name,
+            timeoutMs
+          });
+          return;
+        }
+        throw err;
+      });
+    }
+    let resolveInFlight;
+    const completionPromise = new Promise((r) => {
+      resolveInFlight = r;
+    });
+    this.inFlightPromises[tid] = completionPromise;
+    this.inFlightContexts[tid] = context;
+    this.inFlightConsumed[tid] = consumed;
+    this.inFlightStartMs[tid] = performance.now();
+    this.inFlightResolves[tid] = resolveInFlight;
+    this.inFlightErrors[tid] = null;
+    actionPromise.then(
+      () => {
+        this.completionQueue.push(tid);
+        this.wakeUp();
+        resolveInFlight();
+      },
+      (err) => {
+        this.inFlightErrors[tid] = err;
+        this.completionQueue.push(tid);
+        this.wakeUp();
+        resolveInFlight();
+      }
+    );
+    this.inFlightFlags[tid] = 1;
+    this.inFlightCount++;
+    this.enabledFlags[tid] = 0;
+    this.enabledTransitionCount--;
+    this.enabledAtMs[tid] = -Infinity;
+  }
+  fireTransitionGuarded(_tid, t, inputs, consumed) {
+    const prog = this.program;
+    for (const inSpec of t.inputSpecs) {
+      const pid = prog.compiled.placeId(inSpec.place);
+      let toConsume;
+      switch (inSpec.type) {
+        case "one":
+          toConsume = 1;
+          break;
+        case "exactly":
+          toConsume = inSpec.count;
+          break;
+        case "all":
+          toConsume = inSpec.guard ? this.countMatching(pid, inSpec.guard) : this.tokenQueues[pid].length;
+          break;
+        case "at-least":
+          toConsume = inSpec.guard ? this.countMatching(pid, inSpec.guard) : this.tokenQueues[pid].length;
+          break;
+      }
+      const guardFn = inSpec.guard;
+      for (let i = 0; i < toConsume; i++) {
+        const token = guardFn ? this.removeFirstMatching(pid, guardFn) : this.tokenQueues[pid].shift() ?? null;
+        if (token === null) break;
+        consumed.push(token);
+        inputs.add(inSpec.place, token);
+        this.emitEvent({
+          type: "token-removed",
+          timestamp: Date.now(),
+          placeName: inSpec.place.name,
+          token
+        });
+      }
+    }
+    for (const arc of t.resets) {
+      const pid = prog.compiled.placeId(arc.place);
+      const tokens = this.tokenQueues[pid].splice(0);
+      this.pendingResetWords[pid >>> WORD_SHIFT] |= 1 << (pid & BIT_MASK);
+      this.hasPendingResets = true;
+      for (const token of tokens) {
+        consumed.push(token);
+        this.emitEvent({
+          type: "token-removed",
+          timestamp: Date.now(),
+          placeName: arc.place.name,
+          token
+        });
+      }
+    }
+  }
+  updateBitmapAfterConsumption(tid) {
+    const pids = this.program.consumptionPlaceIds[tid];
+    for (let i = 0; i < pids.length; i++) {
+      const pid = pids[i];
+      if (this.tokenQueues[pid].length === 0) {
+        this.clearMarkingBit(pid);
+      }
+      this.markDirty(pid);
+    }
+  }
+  // ======================== Completion Processing ========================
+  processCompletedTransitions() {
+    if (this.completionQueue.length === 0) return;
+    const prog = this.program;
+    const len = this.completionQueue.length;
+    for (let i = 0; i < len; i++) {
+      const tid = this.completionQueue[i];
+      const context = this.inFlightContexts[tid];
+      const error = this.inFlightErrors[tid];
+      const startMs = this.inFlightStartMs[tid];
+      const t = prog.compiled.transition(tid);
+      this.inFlightFlags[tid] = 0;
+      this.inFlightPromises[tid] = null;
+      this.inFlightContexts[tid] = null;
+      this.inFlightConsumed[tid] = null;
+      this.inFlightResolves[tid] = null;
+      this.inFlightErrors[tid] = null;
+      this.inFlightCount--;
+      if (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.emitEvent({
+          type: "transition-failed",
+          timestamp: Date.now(),
+          transitionName: t.name,
+          errorMessage: err.message,
+          exceptionType: err.name,
+          stack: err.stack
+        });
+        this.markTransitionDirty(tid);
+        continue;
+      }
+      try {
+        const outputs = context.rawOutput();
+        if (!this.skipOutputValidation && t.outputSpec !== null) {
+          const simplePid = prog.simpleOutputPlaceId[tid];
+          if (simplePid >= 0) {
+            const produced2 = outputs.placesWithTokens();
+            if (!produced2.has(prog.places[simplePid].name)) {
+              throw new OutViolationError(
+                `'${t.name}': output does not satisfy declared spec`
+              );
+            }
+          } else if (simplePid === -1) {
+            const produced2 = outputs.placesWithTokens();
+            const result = validateOutSpec(t.name, t.outputSpec, produced2);
+            if (result === null) {
+              throw new OutViolationError(
+                `'${t.name}': output does not satisfy declared spec`
+              );
+            }
+          }
+        }
+        const produced = [];
+        for (const entry of outputs.entries()) {
+          const pid = prog.compiled.placeId(entry.place);
+          this.tokenQueues[pid].push(entry.token);
+          produced.push(entry.token);
+          this.setMarkingBit(pid);
+          this.markDirty(pid);
+          this.emitEvent({
+            type: "token-added",
+            timestamp: Date.now(),
+            placeName: entry.place.name,
+            token: entry.token
+          });
+        }
+        this.markTransitionDirty(tid);
+        this.emitEvent({
+          type: "transition-completed",
+          timestamp: Date.now(),
+          transitionName: t.name,
+          producedTokens: produced,
+          durationMs: performance.now() - startMs
+        });
+      } catch (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        this.emitEvent({
+          type: "transition-failed",
+          timestamp: Date.now(),
+          transitionName: t.name,
+          errorMessage: err.message,
+          exceptionType: err.name,
+          stack: err.stack
+        });
+        this.markTransitionDirty(tid);
+      }
+    }
+    this.completionQueue.length = 0;
+  }
+  // ======================== External Events ========================
+  processExternalEvents() {
+    if (this.externalQueue.length === 0) return;
+    const prog = this.program;
+    const len = this.externalQueue.length;
+    for (let i = 0; i < len; i++) {
+      const event = this.externalQueue[i];
+      try {
+        const pid = prog.compiled.placeId(event.place);
+        this.tokenQueues[pid].push(event.token);
+        this.setMarkingBit(pid);
+        this.markDirty(pid);
+        this.emitEvent({
+          type: "token-added",
+          timestamp: Date.now(),
+          placeName: event.place.name,
+          token: event.token
+        });
+        event.resolve(true);
+      } catch (e) {
+        event.reject(e instanceof Error ? e : new Error(String(e)));
+      }
+    }
+    this.externalQueue.length = 0;
+  }
+  drainPendingExternalEvents() {
+    while (this.externalQueue.length > 0) {
+      this.externalQueue.shift().resolve(false);
+    }
+  }
+  // ======================== Await Work ========================
+  async awaitWork() {
+    if (this.completionQueue.length > 0 || this.externalQueue.length > 0) return;
+    await Promise.resolve();
+    if (this.completionQueue.length > 0 || this.externalQueue.length > 0 || this.closed) return;
+    const promises = this.awaitPromises;
+    promises.length = 0;
+    if (this.inFlightCount > 0) {
+      const arr = this.racePromises;
+      arr.length = 0;
+      for (let tid = 0; tid < this.program.transitionCount; tid++) {
+        if (this.inFlightPromises[tid] !== null) {
+          arr.push(this.inFlightPromises[tid]);
+        }
+      }
+      if (arr.length > 0) {
+        promises.push(Promise.race(arr));
+      }
+    }
+    promises.push(new Promise((resolve) => {
+      this.wakeUpResolve = resolve;
+    }));
+    const timerMs = this.millisUntilNextTimedTransition();
+    if (timerMs > 0 && timerMs < Infinity) {
+      promises.push(new Promise((r) => setTimeout(r, timerMs)));
+    }
+    if (promises.length > 0) {
+      await Promise.race(promises);
+    }
+    this.wakeUpResolve = null;
+  }
+  millisUntilNextTimedTransition() {
+    const nowMs = performance.now();
+    const prog = this.program;
+    const tc = prog.transitionCount;
+    let minWaitMs = Infinity;
+    for (let tid = 0; tid < tc; tid++) {
+      if (!this.enabledFlags[tid]) continue;
+      const enabledMs = this.enabledAtMs[tid];
+      const elapsedMs = nowMs - enabledMs;
+      const eMs = prog.earliestMs[tid];
+      const remainingEarliest = eMs - elapsedMs;
+      if (remainingEarliest <= 0) return 0;
+      minWaitMs = Math.min(minWaitMs, remainingEarliest);
+      if (prog.hasDeadline[tid]) {
+        const lMs = prog.latestMs[tid];
+        const remainingDeadline = lMs - elapsedMs;
+        if (remainingDeadline <= 0) return 0;
+        minWaitMs = Math.min(minWaitMs, remainingDeadline);
+      }
+    }
+    return minWaitMs;
+  }
+  wakeUp() {
+    this.wakeUpResolve?.();
+  }
+  // ======================== Dirty Set Helpers ========================
+  hasDirtyBits() {
+    for (let w = 0; w < this.transitionWords; w++) {
+      if (this.dirtyBitmap[w] !== 0) return true;
+    }
+    return false;
+  }
+  // ======================== Lazy Marking Sync ========================
+  syncMarkingFromQueues() {
+    const prog = this.program;
+    const m = Marking.empty();
+    for (let pid = 0; pid < prog.placeCount; pid++) {
+      const q = this.tokenQueues[pid];
+      if (q.length === 0) continue;
+      const place2 = prog.places[pid];
+      for (let i = 0; i < q.length; i++) {
+        m.addToken(place2, q[i]);
+      }
+    }
+    this.marking = m;
+    return m;
+  }
+  // ======================== State Inspection ========================
+  getMarking() {
+    return this.marking ?? this.syncMarkingFromQueues();
+  }
+  snapshotMarking() {
+    const prog = this.program;
+    const snap = /* @__PURE__ */ new Map();
+    for (let pid = 0; pid < prog.placeCount; pid++) {
+      const q = this.tokenQueues[pid];
+      if (q.length === 0) continue;
+      snap.set(prog.places[pid].name, [...q]);
+    }
+    return snap;
+  }
+  isQuiescent() {
+    return this.enabledTransitionCount === 0 && this.inFlightCount === 0;
+  }
+  executionId() {
+    return this.startMs.toString(16);
+  }
+  close() {
+    this.running = false;
+    this.closed = true;
+    this.wakeUp();
+  }
+  // ======================== Event Emission ========================
+  emitEvent(event) {
+    if (this.eventStoreEnabled) {
+      this.eventStore.append(event);
+    }
+  }
+};
+var TimeoutSentinel2 = class extends Error {
+  constructor() {
+    super("action timeout");
+    this.name = "TimeoutSentinel";
+  }
+};
 export {
   BitmapNetExecutor,
   CompiledNet,
@@ -1903,6 +3112,8 @@ export {
   OutViolationError,
   PetriNet,
   PetriNetBuilder,
+  PrecompiledNet,
+  PrecompiledNetExecutor,
   TokenInput,
   TokenOutput,
   Transition,