libpetri 0.3.2

package/dist/index.js

@@ -0,0 +1,1972 @@
+import {
+  MAX_DURATION_MS,
+  deadline,
+  delayed,
+  earliest,
+  exact,
+  hasDeadline,
+  immediate,
+  latest,
+  window
+} from "./chunk-FN773SSE.js";
+import {
+  allPlaces,
+  and,
+  andPlaces,
+  enumerateBranches,
+  forwardInput,
+  outPlace,
+  timeout,
+  timeoutPlace,
+  xor,
+  xorPlaces
+} from "./chunk-VQ4XMJTD.js";
+
+// src/core/token.ts
+var UNIT_TOKEN = Object.freeze({
+  value: null,
+  createdAt: 0
+});
+function tokenOf(value) {
+  return { value, createdAt: Date.now() };
+}
+function unitToken() {
+  return UNIT_TOKEN;
+}
+function tokenAt(value, createdAt) {
+  return { value, createdAt };
+}
+function isUnit(token) {
+  return token === UNIT_TOKEN;
+}
+
+// src/core/place.ts
+function place(name) {
+  return { name };
+}
+function environmentPlace(name) {
+  return { place: place(name) };
+}
+
+// src/core/arc.ts
+function inputArc(place2, guard) {
+  return guard !== void 0 ? { type: "input", place: place2, guard } : { type: "input", place: place2 };
+}
+function outputArc(place2) {
+  return { type: "output", place: place2 };
+}
+function inhibitorArc(place2) {
+  return { type: "inhibitor", place: place2 };
+}
+function readArc(place2) {
+  return { type: "read", place: place2 };
+}
+function resetArc(place2) {
+  return { type: "reset", place: place2 };
+}
+function arcPlace(arc) {
+  return arc.place;
+}
+function hasGuard(arc) {
+  return arc.guard !== void 0;
+}
+function matchesGuard(arc, value) {
+  if (arc.guard === void 0) return true;
+  return arc.guard(value);
+}
+
+// src/core/in.ts
+function one(place2, guard) {
+  return guard !== void 0 ? { type: "one", place: place2, guard } : { type: "one", place: place2 };
+}
+function exactly(count, place2, guard) {
+  if (count < 1) {
+    throw new Error(`count must be >= 1, got: ${count}`);
+  }
+  return guard !== void 0 ? { type: "exactly", place: place2, count, guard } : { type: "exactly", place: place2, count };
+}
+function all(place2, guard) {
+  return guard !== void 0 ? { type: "all", place: place2, guard } : { type: "all", place: place2 };
+}
+function atLeast(minimum, place2, guard) {
+  if (minimum < 1) {
+    throw new Error(`minimum must be >= 1, got: ${minimum}`);
+  }
+  return guard !== void 0 ? { type: "at-least", place: place2, minimum, guard } : { type: "at-least", place: place2, minimum };
+}
+function requiredCount(spec) {
+  switch (spec.type) {
+    case "one":
+      return 1;
+    case "exactly":
+      return spec.count;
+    case "all":
+      return 1;
+    case "at-least":
+      return spec.minimum;
+  }
+}
+function consumptionCount(spec, available) {
+  if (available < requiredCount(spec)) {
+    throw new Error(
+      `Cannot consume from '${spec.place.name}': available=${available}, required=${requiredCount(spec)}`
+    );
+  }
+  switch (spec.type) {
+    case "one":
+      return 1;
+    case "exactly":
+      return spec.count;
+    case "all":
+      return available;
+    case "at-least":
+      return available;
+  }
+}
+
+// src/core/transition-action.ts
+function passthrough() {
+  return async () => {
+  };
+}
+function transform(fn) {
+  return async (ctx) => {
+    const result = fn(ctx);
+    for (const outputPlace of ctx.outputPlaces()) {
+      ctx.output(outputPlace, result);
+    }
+  };
+}
+function fork() {
+  return transform((ctx) => {
+    const inputPlaces = ctx.inputPlaces();
+    if (inputPlaces.size !== 1) {
+      throw new Error(`Fork requires exactly 1 input place, found ${inputPlaces.size}`);
+    }
+    const inputPlace = inputPlaces.values().next().value;
+    return ctx.input(inputPlace);
+  });
+}
+function transformFrom(inputPlace, fn) {
+  return transform((ctx) => fn(ctx.input(inputPlace)));
+}
+function transformAsync(fn) {
+  return async (ctx) => {
+    const result = await fn(ctx);
+    for (const outputPlace of ctx.outputPlaces()) {
+      ctx.output(outputPlace, result);
+    }
+  };
+}
+function produce(place2, value) {
+  return async (ctx) => {
+    ctx.output(place2, value);
+  };
+}
+function withTimeout(action, timeoutMs, timeoutPlace2, timeoutValue) {
+  return (ctx) => {
+    return new Promise((resolve, reject) => {
+      let completed = false;
+      const timer = setTimeout(() => {
+        if (!completed) {
+          completed = true;
+          ctx.output(timeoutPlace2, timeoutValue);
+          resolve();
+        }
+      }, timeoutMs);
+      action(ctx).then(
+        () => {
+          if (!completed) {
+            completed = true;
+            clearTimeout(timer);
+            resolve();
+          }
+        },
+        (err) => {
+          if (!completed) {
+            completed = true;
+            clearTimeout(timer);
+            reject(err);
+          }
+        }
+      );
+    });
+  };
+}
+
+// src/core/transition-context.ts
+var TransitionContext = class {
+  rawInput;
+  _rawOutput;
+  allowedInputs;
+  allowedReads;
+  allowedOutputs;
+  _inputPlaces;
+  _readPlaces;
+  _outputPlaces;
+  _transitionName;
+  executionCtx;
+  _logFn;
+  constructor(transitionName, rawInput, rawOutput, inputPlaces, readPlaces, outputPlaces, executionContext, logFn) {
+    this._transitionName = transitionName;
+    this.rawInput = rawInput;
+    this._rawOutput = rawOutput;
+    this._inputPlaces = inputPlaces;
+    this._readPlaces = readPlaces;
+    this._outputPlaces = outputPlaces;
+    const ai = /* @__PURE__ */ new Set();
+    for (const p of inputPlaces) ai.add(p.name);
+    this.allowedInputs = ai;
+    const ar = /* @__PURE__ */ new Set();
+    for (const p of readPlaces) ar.add(p.name);
+    this.allowedReads = ar;
+    const ao = /* @__PURE__ */ new Set();
+    for (const p of outputPlaces) ao.add(p.name);
+    this.allowedOutputs = ao;
+    this.executionCtx = executionContext ?? /* @__PURE__ */ new Map();
+    this._logFn = logFn;
+  }
+  // ==================== Input Access (consumed) ====================
+  /** Get single consumed input value. Throws if place not declared or multiple tokens. */
+  input(place2) {
+    this.requireInput(place2);
+    const values = this.rawInput.values(place2);
+    if (values.length !== 1) {
+      throw new Error(
+        `Place '${place2.name}' consumed ${values.length} tokens, use inputs() for batched access`
+      );
+    }
+    return values[0];
+  }
+  /** Get all consumed input values for a place. */
+  inputs(place2) {
+    this.requireInput(place2);
+    return this.rawInput.values(place2);
+  }
+  /** Get consumed input token with metadata. */
+  inputToken(place2) {
+    this.requireInput(place2);
+    return this.rawInput.get(place2);
+  }
+  /** Returns declared input places (consumed). */
+  inputPlaces() {
+    return this._inputPlaces;
+  }
+  requireInput(place2) {
+    if (!this.allowedInputs.has(place2.name)) {
+      throw new Error(
+        `Place '${place2.name}' not in declared inputs: [${[...this.allowedInputs].join(", ")}]`
+      );
+    }
+  }
+  // ==================== Read Access (not consumed) ====================
+  /** Get read-only context value. Throws if place not declared as read. */
+  read(place2) {
+    this.requireRead(place2);
+    return this.rawInput.value(place2);
+  }
+  /** Get all read-only context values for a place. */
+  reads(place2) {
+    this.requireRead(place2);
+    return this.rawInput.values(place2);
+  }
+  /** Returns declared read places (context, not consumed). */
+  readPlaces() {
+    return this._readPlaces;
+  }
+  requireRead(place2) {
+    if (!this.allowedReads.has(place2.name)) {
+      throw new Error(
+        `Place '${place2.name}' not in declared reads: [${[...this.allowedReads].join(", ")}]`
+      );
+    }
+  }
+  // ==================== Output Access ====================
+  /** Add output value. Throws if place not declared as output. */
+  output(place2, value) {
+    this.requireOutput(place2);
+    this._rawOutput.add(place2, value);
+    return this;
+  }
+  /** Add output token with metadata. */
+  outputToken(place2, token) {
+    this.requireOutput(place2);
+    this._rawOutput.addToken(place2, token);
+    return this;
+  }
+  /** Returns declared output places. */
+  outputPlaces() {
+    return this._outputPlaces;
+  }
+  requireOutput(place2) {
+    if (!this.allowedOutputs.has(place2.name)) {
+      throw new Error(
+        `Place '${place2.name}' not in declared outputs: [${[...this.allowedOutputs].join(", ")}]`
+      );
+    }
+  }
+  // ==================== Structure Info ====================
+  /** Returns the transition name. */
+  transitionName() {
+    return this._transitionName;
+  }
+  // ==================== Execution Context ====================
+  /** Retrieves an execution context object by key. */
+  executionContext(key) {
+    return this.executionCtx.get(key);
+  }
+  /** Checks if an execution context object of the given key is present. */
+  hasExecutionContext(key) {
+    return this.executionCtx.has(key);
+  }
+  // ==================== Logging ====================
+  /** Emits a structured log message into the event store. */
+  log(level, message, error) {
+    this._logFn?.(level, message, error);
+  }
+  // ==================== Internal ====================
+  /** @internal Used by BitmapNetExecutor to collect outputs after action completion. */
+  rawOutput() {
+    return this._rawOutput;
+  }
+};
+
+// src/core/token-input.ts
+var TokenInput = class {
+  tokens = /* @__PURE__ */ new Map();
+  /** Add a token (used by executor when firing transition). */
+  add(place2, token) {
+    const existing = this.tokens.get(place2.name);
+    if (existing) {
+      existing.push(token);
+    } else {
+      this.tokens.set(place2.name, [token]);
+    }
+    return this;
+  }
+  /** Get all tokens for a place. */
+  getAll(place2) {
+    return this.tokens.get(place2.name) ?? [];
+  }
+  /** Get the first token for a place. Throws if no tokens. */
+  get(place2) {
+    const list = this.tokens.get(place2.name);
+    if (!list || list.length === 0) {
+      throw new Error(`No token for place: ${place2.name}`);
+    }
+    return list[0];
+  }
+  /** Get the first token's value for a place. Throws if no tokens. */
+  value(place2) {
+    return this.get(place2).value;
+  }
+  /** Get all token values for a place. */
+  values(place2) {
+    return this.getAll(place2).map((t) => t.value);
+  }
+  /** Get token count for a place. */
+  count(place2) {
+    return this.getAll(place2).length;
+  }
+  /** Check if any tokens exist for a place. */
+  has(place2) {
+    return this.count(place2) > 0;
+  }
+};
+
+// src/core/token-output.ts
+var TokenOutput = class {
+  _entries = [];
+  /** Add a value to an output place (creates token with current timestamp). */
+  add(place2, value) {
+    this._entries.push({ place: place2, token: tokenOf(value) });
+    return this;
+  }
+  /** Add a pre-existing token to an output place. */
+  addToken(place2, token) {
+    this._entries.push({ place: place2, token });
+    return this;
+  }
+  /** Returns all collected outputs. */
+  entries() {
+    return this._entries;
+  }
+  /** Check if any outputs were produced. */
+  isEmpty() {
+    return this._entries.length === 0;
+  }
+  /** Returns the set of place names that received tokens. */
+  placesWithTokens() {
+    const result = /* @__PURE__ */ new Set();
+    for (const entry of this._entries) {
+      result.add(entry.place.name);
+    }
+    return result;
+  }
+};
+
+// src/core/transition.ts
+var TRANSITION_KEY = /* @__PURE__ */ Symbol("Transition.internal");
+var Transition = class {
+  name;
+  inputSpecs;
+  outputSpec;
+  inhibitors;
+  reads;
+  resets;
+  timing;
+  actionTimeout;
+  action;
+  priority;
+  _inputPlaces;
+  _readPlaces;
+  _outputPlaces;
+  /** @internal Use {@link Transition.builder} to create instances. */
+  constructor(key, name, inputSpecs, outputSpec, inhibitors, reads, resets, timing, action, priority) {
+    if (key !== TRANSITION_KEY) throw new Error("Use Transition.builder() to create instances");
+    this.name = name;
+    this.inputSpecs = inputSpecs;
+    this.outputSpec = outputSpec;
+    this.inhibitors = inhibitors;
+    this.reads = reads;
+    this.resets = resets;
+    this.timing = timing;
+    this.actionTimeout = findTimeout(outputSpec);
+    this.action = action;
+    this.priority = priority;
+    const inputPlaces = /* @__PURE__ */ new Set();
+    for (const spec of inputSpecs) {
+      inputPlaces.add(spec.place);
+    }
+    this._inputPlaces = inputPlaces;
+    const readPlaces = /* @__PURE__ */ new Set();
+    for (const r of reads) {
+      readPlaces.add(r.place);
+    }
+    this._readPlaces = readPlaces;
+    const outputPlaces = /* @__PURE__ */ new Set();
+    if (outputSpec !== null) {
+      for (const p of allPlaces(outputSpec)) {
+        outputPlaces.add(p);
+      }
+    }
+    this._outputPlaces = outputPlaces;
+  }
+  /** Returns set of input places — consumed tokens. */
+  inputPlaces() {
+    return this._inputPlaces;
+  }
+  /** Returns set of read places — context tokens, not consumed. */
+  readPlaces() {
+    return this._readPlaces;
+  }
+  /** Returns set of output places — where tokens are produced. */
+  outputPlaces() {
+    return this._outputPlaces;
+  }
+  /** Returns true if this transition has an action timeout. */
+  hasActionTimeout() {
+    return this.actionTimeout !== null;
+  }
+  toString() {
+    return `Transition[${this.name}]`;
+  }
+  static builder(name) {
+    return new TransitionBuilder(name);
+  }
+};
+var TransitionBuilder = class {
+  _name;
+  _inputSpecs = [];
+  _outputSpec = null;
+  _inhibitors = [];
+  _reads = [];
+  _resets = [];
+  _timing = immediate();
+  _action = passthrough();
+  _priority = 0;
+  constructor(name) {
+    this._name = name;
+  }
+  /** Add input specifications with cardinality. */
+  inputs(...specs) {
+    this._inputSpecs.push(...specs);
+    return this;
+  }
+  /** Set the output specification (composite AND/XOR structure). */
+  outputs(spec) {
+    this._outputSpec = spec;
+    return this;
+  }
+  /** Add inhibitor arc. */
+  inhibitor(place2) {
+    this._inhibitors.push({ type: "inhibitor", place: place2 });
+    return this;
+  }
+  /** Add inhibitor arcs. */
+  inhibitors(...places) {
+    for (const p of places) {
+      this._inhibitors.push({ type: "inhibitor", place: p });
+    }
+    return this;
+  }
+  /** Add read arc. */
+  read(place2) {
+    this._reads.push({ type: "read", place: place2 });
+    return this;
+  }
+  /** Add read arcs. */
+  reads(...places) {
+    for (const p of places) {
+      this._reads.push({ type: "read", place: p });
+    }
+    return this;
+  }
+  /** Add reset arc. */
+  reset(place2) {
+    this._resets.push({ type: "reset", place: place2 });
+    return this;
+  }
+  /** Add reset arcs. */
+  resets(...places) {
+    for (const p of places) {
+      this._resets.push({ type: "reset", place: p });
+    }
+    return this;
+  }
+  /** Set timing specification. */
+  timing(timing) {
+    this._timing = timing;
+    return this;
+  }
+  /** Set the transition action. */
+  action(action) {
+    this._action = action;
+    return this;
+  }
+  /** Set the priority (higher fires first). */
+  priority(priority) {
+    this._priority = priority;
+    return this;
+  }
+  build() {
+    if (this._outputSpec !== null) {
+      const inputPlaceNames = new Set(this._inputSpecs.map((s) => s.place.name));
+      for (const fi of findForwardInputs(this._outputSpec)) {
+        if (!inputPlaceNames.has(fi.from.name)) {
+          throw new Error(
+            `Transition '${this._name}': ForwardInput references non-input place '${fi.from.name}'`
+          );
+        }
+      }
+    }
+    return new Transition(
+      TRANSITION_KEY,
+      this._name,
+      [...this._inputSpecs],
+      this._outputSpec,
+      [...this._inhibitors],
+      [...this._reads],
+      [...this._resets],
+      this._timing,
+      this._action,
+      this._priority
+    );
+  }
+};
+function findTimeout(out) {
+  if (out === null) return null;
+  switch (out.type) {
+    case "timeout":
+      return out;
+    case "and":
+    case "xor":
+      for (const child of out.children) {
+        const found = findTimeout(child);
+        if (found !== null) return found;
+      }
+      return null;
+    case "place":
+    case "forward-input":
+      return null;
+  }
+}
+function findForwardInputs(out) {
+  switch (out.type) {
+    case "forward-input":
+      return [{ from: out.from, to: out.to }];
+    case "and":
+    case "xor":
+      return out.children.flatMap(findForwardInputs);
+    case "timeout":
+      return findForwardInputs(out.child);
+    case "place":
+      return [];
+  }
+}
+
+// src/core/petri-net.ts
+var PETRI_NET_KEY = /* @__PURE__ */ Symbol("PetriNet.internal");
+var PetriNet = class _PetriNet {
+  name;
+  places;
+  transitions;
+  /** @internal Use {@link PetriNet.builder} to create instances. */
+  constructor(key, name, places, transitions) {
+    if (key !== PETRI_NET_KEY) throw new Error("Use PetriNet.builder() to create instances");
+    this.name = name;
+    this.places = places;
+    this.transitions = transitions;
+  }
+  /**
+   * Creates a new PetriNet with actions bound to transitions by name.
+   * Unbound transitions keep passthrough action.
+   */
+  bindActions(actionBindings) {
+    const bindings = actionBindings instanceof Map ? actionBindings : new Map(Object.entries(actionBindings));
+    return this.bindActionsWithResolver(
+      (name) => bindings.get(name) ?? passthrough()
+    );
+  }
+  /**
+   * Creates a new PetriNet with actions bound via a resolver function.
+   */
+  bindActionsWithResolver(actionResolver) {
+    const boundTransitions = /* @__PURE__ */ new Set();
+    for (const t of this.transitions) {
+      const action = actionResolver(t.name);
+      if (action !== null && action !== t.action) {
+        boundTransitions.add(rebuildWithAction(t, action));
+      } else {
+        boundTransitions.add(t);
+      }
+    }
+    return new _PetriNet(PETRI_NET_KEY, this.name, this.places, boundTransitions);
+  }
+  static builder(name) {
+    return new PetriNetBuilder(name);
+  }
+};
+var PetriNetBuilder = class {
+  _name;
+  _places = /* @__PURE__ */ new Set();
+  _transitions = /* @__PURE__ */ new Set();
+  constructor(name) {
+    this._name = name;
+  }
+  /** Add an explicit place. */
+  place(place2) {
+    this._places.add(place2);
+    return this;
+  }
+  /** Add explicit places. */
+  places(...places) {
+    for (const p of places) this._places.add(p);
+    return this;
+  }
+  /** Add a transition (auto-collects places from arcs). */
+  transition(transition) {
+    this._transitions.add(transition);
+    for (const spec of transition.inputSpecs) {
+      this._places.add(spec.place);
+    }
+    for (const p of transition.outputPlaces()) {
+      this._places.add(p);
+    }
+    for (const inh of transition.inhibitors) {
+      this._places.add(inh.place);
+    }
+    for (const r of transition.reads) {
+      this._places.add(r.place);
+    }
+    for (const r of transition.resets) {
+      this._places.add(r.place);
+    }
+    return this;
+  }
+  /** Add transitions (auto-collects places from arcs). */
+  transitions(...transitions) {
+    for (const t of transitions) this.transition(t);
+    return this;
+  }
+  build() {
+    return new PetriNet(PETRI_NET_KEY, this._name, this._places, this._transitions);
+  }
+};
+function rebuildWithAction(t, action) {
+  const builder = Transition.builder(t.name).timing(t.timing).priority(t.priority).action(action);
+  if (t.inputSpecs.length > 0) {
+    builder.inputs(...t.inputSpecs);
+  }
+  if (t.outputSpec !== null) {
+    builder.outputs(t.outputSpec);
+  }
+  for (const inh of t.inhibitors) {
+    builder.inhibitor(inh.place);
+  }
+  for (const r of t.reads) {
+    builder.read(r.place);
+  }
+  for (const r of t.resets) {
+    builder.reset(r.place);
+  }
+  return builder.build();
+}
+
+// src/runtime/marking.ts
+var EMPTY_TOKENS = Object.freeze([]);
+var Marking = class _Marking {
+  /** Place name -> FIFO queue of tokens. */
+  tokens = /* @__PURE__ */ new Map();
+  /** Place name -> Place reference (for inspection). */
+  placeRefs = /* @__PURE__ */ new Map();
+  static empty() {
+    return new _Marking();
+  }
+  static from(initial) {
+    const m = new _Marking();
+    for (const [place2, tokens] of initial) {
+      m.placeRefs.set(place2.name, place2);
+      m.tokens.set(place2.name, [...tokens]);
+    }
+    return m;
+  }
+  // ======================== Token Addition ========================
+  addToken(place2, token) {
+    this.placeRefs.set(place2.name, place2);
+    const queue = this.tokens.get(place2.name);
+    if (queue) {
+      queue.push(token);
+    } else {
+      this.tokens.set(place2.name, [token]);
+    }
+  }
+  // ======================== Token Removal ========================
+  /** Removes and returns the oldest token. Returns null if empty. */
+  removeFirst(place2) {
+    const queue = this.tokens.get(place2.name);
+    if (!queue || queue.length === 0) return null;
+    return queue.shift();
+  }
+  /** Removes and returns all tokens from a place. */
+  removeAll(place2) {
+    const queue = this.tokens.get(place2.name);
+    if (!queue || queue.length === 0) return [];
+    const result = [...queue];
+    queue.length = 0;
+    return result;
+  }
+  /**
+   * Removes and returns the first token whose value satisfies the guard predicate.
+   *
+   * Performs a linear scan of the place's FIFO queue. If no guard is provided,
+   * behaves like `removeFirst()`. If a guard is provided, skips non-matching
+   * tokens and splices the first match out of the queue (O(n) worst case).
+   */
+  removeFirstMatching(spec) {
+    const queue = this.tokens.get(spec.place.name);
+    if (!queue || queue.length === 0) return null;
+    if (!spec.guard) {
+      return queue.shift();
+    }
+    for (let i = 0; i < queue.length; i++) {
+      const token = queue[i];
+      if (spec.guard(token.value)) {
+        queue.splice(i, 1);
+        return token;
+      }
+    }
+    return null;
+  }
+  // ======================== Token Inspection ========================
+  /** Check if any token matches a guard predicate. */
+  hasMatchingToken(spec) {
+    const queue = this.tokens.get(spec.place.name);
+    if (!queue || queue.length === 0) return false;
+    if (!spec.guard) return true;
+    return queue.some((t) => spec.guard(t.value));
+  }
+  /**
+   * Counts tokens in a place whose values satisfy the guard predicate.
+   *
+   * If no guard is provided, returns the total token count (O(1)).
+   * With a guard, performs a linear scan over all tokens (O(n)).
+   * Used by the executor for enablement checks on guarded `all`/`at-least` inputs.
+   */
+  countMatching(spec) {
+    const queue = this.tokens.get(spec.place.name);
+    if (!queue || queue.length === 0) return 0;
+    if (!spec.guard) return queue.length;
+    let count = 0;
+    for (const t of queue) {
+      if (spec.guard(t.value)) count++;
+    }
+    return count;
+  }
+  /**
+   * Returns tokens in a place. **Returns a live reference** to the internal
+   * array — callers must not mutate it. Copy with `[...peekTokens(p)]` if
+   * mutation or snapshot semantics are needed.
+   */
+  peekTokens(place2) {
+    return this.tokens.get(place2.name) ?? EMPTY_TOKENS;
+  }
+  /** Returns the oldest token without removing it. */
+  peekFirst(place2) {
+    const queue = this.tokens.get(place2.name);
+    return queue && queue.length > 0 ? queue[0] : null;
+  }
+  /** Checks if a place has any tokens. */
+  hasTokens(place2) {
+    const queue = this.tokens.get(place2.name);
+    return queue !== void 0 && queue.length > 0;
+  }
+  /** Returns the number of tokens in a place. */
+  tokenCount(place2) {
+    const queue = this.tokens.get(place2.name);
+    return queue ? queue.length : 0;
+  }
+  // ======================== Debugging ========================
+  toString() {
+    const parts = [];
+    for (const [name, queue] of this.tokens) {
+      if (queue.length > 0) {
+        parts.push(`${name}: ${queue.length}`);
+      }
+    }
+    return `Marking{${parts.join(", ")}}`;
+  }
+};
+
+// src/runtime/compiled-net.ts
+var WORD_SHIFT = 5;
+var BIT_MASK = 31;
+var CompiledNet = class _CompiledNet {
+  net;
+  placeCount;
+  transitionCount;
+  wordCount;
+  // ID mappings
+  _placesById;
+  _transitionsById;
+  _placeIndex;
+  _transitionIndex;
+  // Precomputed masks per transition
+  _needsMask;
+  _inhibitorMask;
+  // Reverse index: place -> affected transition IDs
+  _placeToTransitions;
+  // Consumption place IDs per transition (input + reset places)
+  _consumptionPlaceIds;
+  // Cardinality and guard flags
+  _cardinalityChecks;
+  _hasGuards;
+  constructor(net) {
+    this.net = net;
+    const allPlacesSet = /* @__PURE__ */ new Map();
+    for (const t of net.transitions) {
+      for (const spec of t.inputSpecs) allPlacesSet.set(spec.place.name, spec.place);
+      for (const r of t.reads) allPlacesSet.set(r.place.name, r.place);
+      for (const inh of t.inhibitors) allPlacesSet.set(inh.place.name, inh.place);
+      for (const rst of t.resets) allPlacesSet.set(rst.place.name, rst.place);
+      if (t.outputSpec !== null) {
+        for (const p of allPlaces(t.outputSpec)) allPlacesSet.set(p.name, p);
+      }
+    }
+    for (const p of net.places) allPlacesSet.set(p.name, p);
+    this.placeCount = allPlacesSet.size;
+    this.wordCount = this.placeCount + BIT_MASK >>> WORD_SHIFT;
+    this._placesById = [...allPlacesSet.values()];
+    this._placeIndex = /* @__PURE__ */ new Map();
+    for (let i = 0; i < this._placesById.length; i++) {
+      this._placeIndex.set(this._placesById[i].name, i);
+    }
+    this._transitionsById = [...net.transitions];
+    this.transitionCount = this._transitionsById.length;
+    this._transitionIndex = /* @__PURE__ */ new Map();
+    for (let i = 0; i < this._transitionsById.length; i++) {
+      this._transitionIndex.set(this._transitionsById[i], i);
+    }
+    this._needsMask = new Array(this.transitionCount);
+    this._inhibitorMask = new Array(this.transitionCount);
+    this._consumptionPlaceIds = new Array(this.transitionCount);
+    this._cardinalityChecks = new Array(this.transitionCount).fill(null);
+    this._hasGuards = new Array(this.transitionCount).fill(false);
+    const placeToTransitionsList = new Array(this.placeCount);
+    for (let i = 0; i < this.placeCount; i++) {
+      placeToTransitionsList[i] = [];
+    }
+    for (let tid = 0; tid < this.transitionCount; tid++) {
+      const t = this._transitionsById[tid];
+      const needs = new Uint32Array(this.wordCount);
+      const inhibitors = new Uint32Array(this.wordCount);
+      let needsCardinality = false;
+      for (const inSpec of t.inputSpecs) {
+        const pid = this._placeIndex.get(inSpec.place.name);
+        setBit(needs, pid);
+        placeToTransitionsList[pid].push(tid);
+        if (inSpec.type !== "one") {
+          needsCardinality = true;
+        }
+        if (inSpec.guard) {
+          this._hasGuards[tid] = true;
+        }
+      }
+      if (needsCardinality) {
+        const pids = [];
+        const reqs = [];
+        for (const inSpec of t.inputSpecs) {
+          pids.push(this._placeIndex.get(inSpec.place.name));
+          reqs.push(requiredCount(inSpec));
+        }
+        this._cardinalityChecks[tid] = { placeIds: pids, requiredCounts: reqs };
+      }
+      for (const arc of t.reads) {
+        const pid = this._placeIndex.get(arc.place.name);
+        setBit(needs, pid);
+        placeToTransitionsList[pid].push(tid);
+      }
+      for (const arc of t.inhibitors) {
+        const pid = this._placeIndex.get(arc.place.name);
+        setBit(inhibitors, pid);
+        placeToTransitionsList[pid].push(tid);
+      }
+      for (const arc of t.resets) {
+        const pid = this._placeIndex.get(arc.place.name);
+        placeToTransitionsList[pid].push(tid);
+      }
+      const consumptionSet = /* @__PURE__ */ new Set();
+      for (const spec of t.inputSpecs) consumptionSet.add(this._placeIndex.get(spec.place.name));
+      for (const arc of t.resets) consumptionSet.add(this._placeIndex.get(arc.place.name));
+      this._consumptionPlaceIds[tid] = [...consumptionSet];
+      this._needsMask[tid] = needs;
+      this._inhibitorMask[tid] = inhibitors;
+    }
+    this._placeToTransitions = new Array(this.placeCount);
+    for (let pid = 0; pid < this.placeCount; pid++) {
+      this._placeToTransitions[pid] = [...new Set(placeToTransitionsList[pid])];
+    }
+  }
+  static compile(net) {
+    return new _CompiledNet(net);
+  }
+  // ==================== Accessors ====================
+  place(pid) {
+    return this._placesById[pid];
+  }
+  transition(tid) {
+    return this._transitionsById[tid];
+  }
+  placeId(place2) {
+    const id = this._placeIndex.get(place2.name);
+    if (id === void 0) throw new Error(`Unknown place: ${place2.name}`);
+    return id;
+  }
+  transitionId(t) {
+    const id = this._transitionIndex.get(t);
+    if (id === void 0) throw new Error(`Unknown transition: ${t.name}`);
+    return id;
+  }
+  affectedTransitions(pid) {
+    return this._placeToTransitions[pid];
+  }
+  consumptionPlaceIds(tid) {
+    return this._consumptionPlaceIds[tid];
+  }
+  cardinalityCheck(tid) {
+    return this._cardinalityChecks[tid];
+  }
+  hasGuards(tid) {
+    return this._hasGuards[tid];
+  }
+  // ==================== Enablement Check ====================
+  /**
+   * Two-phase bitmap enablement check for a transition:
+   * 1. **Presence check**: verifies all required places (inputs + reads) have tokens
+   *    via `containsAll(snapshot, needsMask)`.
+   * 2. **Inhibitor check**: verifies no inhibitor places have tokens
+   *    via `!intersects(snapshot, inhibitorMask)`.
+   *
+   * This is a necessary but not sufficient condition — cardinality and guard checks
+   * are performed separately by the executor for transitions that pass this fast path.
+   */
+  canEnableBitmap(tid, markingSnapshot) {
+    if (!containsAll(markingSnapshot, this._needsMask[tid])) return false;
+    if (intersects(markingSnapshot, this._inhibitorMask[tid])) return false;
+    return true;
+  }
+};
+function setBit(arr, bit) {
+  arr[bit >>> WORD_SHIFT] |= 1 << (bit & BIT_MASK);
+}
+function clearBit(arr, bit) {
+  arr[bit >>> WORD_SHIFT] &= ~(1 << (bit & BIT_MASK));
+}
+function testBit(arr, bit) {
+  return (arr[bit >>> WORD_SHIFT] & 1 << (bit & BIT_MASK)) !== 0;
+}
+function containsAll(snapshot, mask) {
+  for (let i = 0; i < mask.length; i++) {
+    const m = mask[i];
+    if (m === 0) continue;
+    const s = i < snapshot.length ? snapshot[i] : 0;
+    if ((s & m) !== m) return false;
+  }
+  return true;
+}
+function intersects(snapshot, mask) {
+  for (let i = 0; i < mask.length; i++) {
+    const m = mask[i];
+    if (m === 0) continue;
+    if (i < snapshot.length && (snapshot[i] & m) !== 0) return true;
+  }
+  return false;
+}
+
+// src/event/net-event.ts
+function eventTransitionName(event) {
+  switch (event.type) {
+    case "transition-enabled":
+    case "transition-clock-restarted":
+    case "transition-started":
+    case "transition-completed":
+    case "transition-failed":
+    case "transition-timed-out":
+    case "action-timed-out":
+    case "log-message":
+      return event.transitionName;
+    default:
+      return null;
+  }
+}
+function isFailureEvent(event) {
+  return event.type === "transition-failed" || event.type === "transition-timed-out" || event.type === "action-timed-out";
+}
+
+// src/event/event-store.ts
+function filterEvents(store, predicate) {
+  return store.events().filter(predicate);
+}
+function eventsOfType(store, type) {
+  return store.events().filter((e) => e.type === type);
+}
+function transitionEvents(store, transitionName) {
+  return store.events().filter((e) => eventTransitionName(e) === transitionName);
+}
+function failures(store) {
+  return store.events().filter(isFailureEvent);
+}
+var InMemoryEventStore = class {
+  _events = [];
+  append(event) {
+    this._events.push(event);
+  }
+  events() {
+    return this._events;
+  }
+  isEnabled() {
+    return true;
+  }
+  size() {
+    return this._events.length;
+  }
+  isEmpty() {
+    return this._events.length === 0;
+  }
+  /** Clears all stored events. */
+  clear() {
+    this._events.length = 0;
+  }
+};
+var EMPTY = Object.freeze([]);
+var NoopEventStoreImpl = class {
+  append(_event) {
+  }
+  events() {
+    return EMPTY;
+  }
+  isEnabled() {
+    return false;
+  }
+  size() {
+    return 0;
+  }
+  isEmpty() {
+    return true;
+  }
+};
+var NOOP_INSTANCE = new NoopEventStoreImpl();
+function noopEventStore() {
+  return NOOP_INSTANCE;
+}
+function inMemoryEventStore() {
+  return new InMemoryEventStore();
+}
+
+// src/runtime/out-violation-error.ts
+var OutViolationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OutViolationError";
+  }
+};
+
+// src/runtime/executor-support.ts
+function validateOutSpec(tName, spec, producedPlaceNames) {
+  switch (spec.type) {
+    case "place":
+      return producedPlaceNames.has(spec.place.name) ? /* @__PURE__ */ new Set([spec.place.name]) : null;
+    case "forward-input":
+      return producedPlaceNames.has(spec.to.name) ? /* @__PURE__ */ new Set([spec.to.name]) : null;
+    case "and": {
+      const claimed = /* @__PURE__ */ new Set();
+      for (const child of spec.children) {
+        const result = validateOutSpec(tName, child, producedPlaceNames);
+        if (result === null) return null;
+        for (const p of result) claimed.add(p);
+      }
+      return claimed;
+    }
+    case "xor": {
+      const satisfied = [];
+      for (const child of spec.children) {
+        const result = validateOutSpec(tName, child, producedPlaceNames);
+        if (result !== null) satisfied.push(result);
+      }
+      if (satisfied.length === 0) {
+        throw new OutViolationError(
+          `'${tName}': XOR violation - no branch produced (exactly 1 required)`
+        );
+      }
+      if (satisfied.length > 1) {
+        throw new OutViolationError(
+          `'${tName}': XOR violation - multiple branches produced`
+        );
+      }
+      return satisfied[0];
+    }
+    case "timeout":
+      return validateOutSpec(tName, spec.child, producedPlaceNames);
+  }
+}
+function produceTimeoutOutput(context, timeoutChild) {
+  switch (timeoutChild.type) {
+    case "place":
+      context.output(timeoutChild.place, null);
+      break;
+    case "forward-input": {
+      const value = context.input(timeoutChild.from);
+      context.output(timeoutChild.to, value);
+      break;
+    }
+    case "and":
+      for (const child of timeoutChild.children) {
+        produceTimeoutOutput(context, child);
+      }
+      break;
+    case "xor":
+      throw new Error("XOR not allowed in timeout child");
+    case "timeout":
+      throw new Error("Nested Timeout not allowed");
+  }
+}
+
+// src/runtime/bitmap-net-executor.ts
+var DEADLINE_TOLERANCE_MS = 1;
+var BitmapNetExecutor = class {
+  compiled;
+  marking;
+  eventStore;
+  environmentPlaces;
+  longRunning;
+  executionContextProvider;
+  startMs;
+  hasAnyDeadlines;
+  allImmediate;
+  allSamePriority;
+  eventStoreEnabled;
+  // Bitmaps (Uint32Array, direct writes)
+  markedPlaces;
+  dirtySet;
+  markingSnapBuffer;
+  dirtySnapBuffer;
+  firingSnapBuffer;
+  // Orchestrator state
+  enabledAtMs;
+  inFlightFlags;
+  enabledFlags;
+  /** Precomputed: 1 if transition has a finite deadline, 0 otherwise. */
+  hasDeadlineFlags;
+  enabledTransitionCount = 0;
+  // In-flight tracking
+  inFlight = /* @__PURE__ */ new Map();
+  inFlightPromises = [];
+  awaitPromises = [];
+  // Queues
+  completionQueue = [];
+  externalQueue = [];
+  // Wake-up mechanism
+  wakeUpResolve = null;
+  // Pre-allocated buffer for fireReadyTransitions() to avoid per-cycle allocation
+  readyBuffer = [];
+  // Pending reset places for clock-restart detection
+  pendingResetPlaces = /* @__PURE__ */ new Set();
+  transitionInputPlaceNames;
+  running = false;
+  closed = false;
+  constructor(net, initialTokens, options = {}) {
+    this.compiled = CompiledNet.compile(net);
+    this.marking = Marking.from(initialTokens);
+    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.startMs = performance.now();
+    const wordCount = this.compiled.wordCount;
+    this.markedPlaces = new Uint32Array(wordCount);
+    this.markingSnapBuffer = new Uint32Array(wordCount);
+    this.firingSnapBuffer = new Uint32Array(wordCount);
+    const dirtyWords = this.compiled.transitionCount + BIT_MASK >>> WORD_SHIFT;
+    this.dirtySet = new Uint32Array(dirtyWords);
+    this.dirtySnapBuffer = new Uint32Array(dirtyWords);
+    this.enabledAtMs = new Float64Array(this.compiled.transitionCount);
+    this.enabledAtMs.fill(-Infinity);
+    this.inFlightFlags = new Uint8Array(this.compiled.transitionCount);
+    this.enabledFlags = new Uint8Array(this.compiled.transitionCount);
+    this.hasDeadlineFlags = new Uint8Array(this.compiled.transitionCount);
+    let anyDeadlines = false;
+    let allImm = true;
+    let samePrio = true;
+    const firstPriority = this.compiled.transitionCount > 0 ? this.compiled.transition(0).priority : 0;
+    for (let tid = 0; tid < this.compiled.transitionCount; tid++) {
+      const t = this.compiled.transition(tid);
+      if (hasDeadline(t.timing)) {
+        this.hasDeadlineFlags[tid] = 1;
+        anyDeadlines = true;
+      }
+      if (t.timing.type !== "immediate") allImm = false;
+      if (t.priority !== firstPriority) samePrio = false;
+    }
+    this.hasAnyDeadlines = anyDeadlines;
+    this.allImmediate = allImm;
+    this.allSamePriority = samePrio;
+    this.eventStoreEnabled = this.eventStore.isEnabled();
+    this.transitionInputPlaceNames = /* @__PURE__ */ new Map();
+    for (const t of net.transitions) {
+      const names = /* @__PURE__ */ new Set();
+      for (const spec of t.inputSpecs) names.add(spec.place.name);
+      this.transitionInputPlaceNames.set(t, names);
+    }
+  }
+  // ======================== 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;
+    this.emitEvent({
+      type: "execution-started",
+      timestamp: Date.now(),
+      netName: this.compiled.net.name,
+      executionId: this.executionId()
+    });
+    this.initializeMarkedBitmap();
+    this.markAllDirty();
+    this.emitEvent({
+      type: "marking-snapshot",
+      timestamp: Date.now(),
+      marking: this.snapshotMarking()
+    });
+    while (this.running && !this.closed) {
+      this.processCompletedTransitions();
+      this.processExternalEvents();
+      this.updateDirtyTransitions();
+      if (this.hasAnyDeadlines) this.enforceDeadlines(performance.now());
+      if (this.shouldTerminate()) break;
+      this.fireReadyTransitions();
+      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: this.compiled.net.name,
+      executionId: this.executionId(),
+      totalDurationMs: performance.now() - this.startMs
+    });
+    return this.marking;
+  }
+  // ======================== 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();
+    });
+  }
+  /** Convenience: inject a raw value (creates token with current timestamp). */
+  async injectValue(envPlace, value) {
+    return this.inject(envPlace, tokenOf(value));
+  }
+  // ======================== Initialize ========================
+  initializeMarkedBitmap() {
+    for (let pid = 0; pid < this.compiled.placeCount; pid++) {
+      const place2 = this.compiled.place(pid);
+      if (this.marking.hasTokens(place2)) {
+        setBit(this.markedPlaces, pid);
+      }
+    }
+  }
+  markAllDirty() {
+    const tc = this.compiled.transitionCount;
+    const dirtyWords = this.dirtySet.length;
+    for (let w = 0; w < dirtyWords - 1; w++) {
+      this.dirtySet[w] = 4294967295;
+    }
+    if (dirtyWords > 0) {
+      const lastWordBits = tc & BIT_MASK;
+      this.dirtySet[dirtyWords - 1] = lastWordBits === 0 ? 4294967295 : (1 << lastWordBits) - 1;
+    }
+  }
+  shouldTerminate() {
+    if (this.longRunning) return this.closed;
+    return this.enabledTransitionCount === 0 && this.inFlight.size === 0 && this.completionQueue.length === 0;
+  }
+  // ======================== Dirty Set Transitions ========================
+  updateDirtyTransitions() {
+    const nowMs = performance.now();
+    const markingSnap = this.markingSnapBuffer;
+    markingSnap.set(this.markedPlaces);
+    const dirtyWords = this.dirtySet.length;
+    const dirtySnap = this.dirtySnapBuffer;
+    for (let w = 0; w < dirtyWords; w++) {
+      dirtySnap[w] = this.dirtySet[w];
+      this.dirtySet[w] = 0;
+    }
+    for (let w = 0; w < dirtyWords; w++) {
+      let word = dirtySnap[w];
+      while (word !== 0) {
+        const bit = Math.clz32(word & -word) ^ 31;
+        const tid = w << WORD_SHIFT | bit;
+        word &= word - 1;
+        if (tid >= this.compiled.transitionCount) 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: this.compiled.transition(tid).name
+          });
+        } else if (!canNow && wasEnabled) {
+          this.enabledFlags[tid] = 0;
+          this.enabledTransitionCount--;
+          this.enabledAtMs[tid] = -Infinity;
+        } else if (canNow && wasEnabled && this.hasInputFromResetPlace(this.compiled.transition(tid))) {
+          this.enabledAtMs[tid] = nowMs;
+          this.emitEvent({
+            type: "transition-clock-restarted",
+            timestamp: Date.now(),
+            transitionName: this.compiled.transition(tid).name
+          });
+        }
+      }
+    }
+    this.pendingResetPlaces.clear();
+  }
+  /**
+   * Checks all enabled transitions with finite deadlines. If a transition has been
+   * enabled longer than `latest(timing)`, it is forcibly disabled and a
+   * `TransitionTimedOut` event is emitted. Classical TPN semantics require transitions
+   * to either fire within their window or become disabled.
+   *
+   * A 1ms tolerance is applied to account for timer jitter and microtask scheduling
+   * delays. Without this, exact-timed transitions (where earliest == latest) would
+   * almost always be disabled before they can fire.
+   */
+  enforceDeadlines(nowMs) {
+    for (let tid = 0; tid < this.compiled.transitionCount; tid++) {
+      if (!this.hasDeadlineFlags[tid]) continue;
+      if (!this.enabledFlags[tid] || this.inFlightFlags[tid]) continue;
+      const t = this.compiled.transition(tid);
+      const elapsed = nowMs - this.enabledAtMs[tid];
+      const latestMs = latest(t.timing);
+      if (elapsed > latestMs + DEADLINE_TOLERANCE_MS) {
+        this.enabledFlags[tid] = 0;
+        this.enabledTransitionCount--;
+        this.emitEvent({
+          type: "transition-timed-out",
+          timestamp: Date.now(),
+          transitionName: t.name,
+          deadlineMs: latestMs,
+          actualDurationMs: elapsed
+        });
+        this.enabledAtMs[tid] = -Infinity;
+      }
+    }
+  }
+  canEnable(tid, markingSnap) {
+    if (!this.compiled.canEnableBitmap(tid, markingSnap)) return false;
+    const cardCheck = this.compiled.cardinalityCheck(tid);
+    if (cardCheck !== null) {
+      for (let i = 0; i < cardCheck.placeIds.length; i++) {
+        const pid = cardCheck.placeIds[i];
+        const required = cardCheck.requiredCounts[i];
+        const place2 = this.compiled.place(pid);
+        if (this.marking.tokenCount(place2) < required) return false;
+      }
+    }
+    if (this.compiled.hasGuards(tid)) {
+      const t = this.compiled.transition(tid);
+      for (const spec of t.inputSpecs) {
+        if (!spec.guard) continue;
+        const requiredCount2 = spec.type === "one" ? 1 : spec.type === "exactly" ? spec.count : spec.type === "at-least" ? spec.minimum : 1;
+        if (this.marking.countMatching(spec) < requiredCount2) return false;
+      }
+    }
+    return true;
+  }
+  hasInputFromResetPlace(t) {
+    if (this.pendingResetPlaces.size === 0) return false;
+    const inputNames = this.transitionInputPlaceNames.get(t);
+    if (!inputNames) return false;
+    for (const name of this.pendingResetPlaces) {
+      if (inputNames.has(name)) return true;
+    }
+    return false;
+  }
+  // ======================== Firing ========================
+  fireReadyTransitions() {
+    if (this.allImmediate && this.allSamePriority) {
+      this.fireReadyImmediate();
+      return;
+    }
+    this.fireReadyGeneral();
+  }
+  /**
+   * Fast path for nets where all transitions are immediate and same priority.
+   * Skips timing checks, sorting, and snapshot buffer — just scan and fire.
+   *
+   * Uses live `markedPlaces` instead of a snapshot. Safe because
+   * `updateBitmapAfterConsumption()` synchronously updates the bitmap before the next
+   * iteration. For equal-priority immediate transitions, tid scan order satisfies
+   * FIFO-by-enablement-time (all enabled in the same cycle).
+   */
+  fireReadyImmediate() {
+    for (let tid = 0; tid < this.compiled.transitionCount; tid++) {
+      if (!this.enabledFlags[tid] || this.inFlightFlags[tid]) continue;
+      if (this.canEnable(tid, this.markedPlaces)) {
+        this.fireTransition(tid);
+      } else {
+        this.enabledFlags[tid] = 0;
+        this.enabledTransitionCount--;
+        this.enabledAtMs[tid] = -Infinity;
+      }
+    }
+  }
+  fireReadyGeneral() {
+    const nowMs = performance.now();
+    const ready = this.readyBuffer;
+    ready.length = 0;
+    for (let tid = 0; tid < this.compiled.transitionCount; tid++) {
+      if (!this.enabledFlags[tid] || this.inFlightFlags[tid]) continue;
+      const t = this.compiled.transition(tid);
+      const enabledMs = this.enabledAtMs[tid];
+      const elapsedMs = nowMs - enabledMs;
+      const earliestMs = earliest(t.timing);
+      if (earliestMs <= elapsedMs) {
+        ready.push({ tid, priority: t.priority, enabledAtMs: enabledMs });
+      }
+    }
+    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.markedPlaces);
+    for (const entry of ready) {
+      const { tid } = entry;
+      if (this.enabledFlags[tid] && this.canEnable(tid, freshSnap)) {
+        this.fireTransition(tid);
+        freshSnap.set(this.markedPlaces);
+      } else {
+        this.enabledFlags[tid] = 0;
+        this.enabledTransitionCount--;
+        this.enabledAtMs[tid] = -Infinity;
+      }
+    }
+  }
+  fireTransition(tid) {
+    const t = this.compiled.transition(tid);
+    const inputs = new TokenInput();
+    const consumed = [];
+    for (const inSpec of t.inputSpecs) {
+      let toConsume;
+      switch (inSpec.type) {
+        case "one":
+          toConsume = 1;
+          break;
+        case "exactly":
+          toConsume = inSpec.count;
+          break;
+        case "all":
+          toConsume = inSpec.guard ? this.marking.countMatching(inSpec) : this.marking.tokenCount(inSpec.place);
+          break;
+        case "at-least":
+          toConsume = inSpec.guard ? this.marking.countMatching(inSpec) : this.marking.tokenCount(inSpec.place);
+          break;
+      }
+      for (let i = 0; i < toConsume; i++) {
+        const token = inSpec.guard ? this.marking.removeFirstMatching(inSpec) : this.marking.removeFirst(inSpec.place);
+        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.reads) {
+      const token = this.marking.peekFirst(arc.place);
+      if (token !== null) {
+        inputs.add(arc.place, token);
+      }
+    }
+    for (const arc of t.resets) {
+      const removed = this.marking.removeAll(arc.place);
+      this.pendingResetPlaces.add(arc.place.name);
+      for (const token of removed) {
+        consumed.push(token);
+        this.emitEvent({
+          type: "token-removed",
+          timestamp: Date.now(),
+          placeName: arc.place.name,
+          token
+        });
+      }
+    }
+    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 TimeoutSentinel()), timeoutMs)
+        )
+      ]).catch((err) => {
+        if (err instanceof TimeoutSentinel) {
+          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;
+    });
+    const flight = {
+      promise: completionPromise,
+      context,
+      consumed,
+      startMs: performance.now(),
+      resolve: resolveInFlight
+    };
+    actionPromise.then(
+      () => {
+        this.completionQueue.push(t);
+        this.wakeUp();
+        resolveInFlight();
+      },
+      (err) => {
+        flight.error = err;
+        this.completionQueue.push(t);
+        this.wakeUp();
+        resolveInFlight();
+      }
+    );
+    this.inFlight.set(t, flight);
+    this.inFlightFlags[tid] = 1;
+    this.enabledFlags[tid] = 0;
+    this.enabledTransitionCount--;
+    this.enabledAtMs[tid] = -Infinity;
+  }
+  updateBitmapAfterConsumption(tid) {
+    const pids = this.compiled.consumptionPlaceIds(tid);
+    for (const pid of pids) {
+      const place2 = this.compiled.place(pid);
+      if (!this.marking.hasTokens(place2)) {
+        clearBit(this.markedPlaces, pid);
+      }
+      this.markDirty(pid);
+    }
+  }
+  // ======================== Completion Processing ========================
+  processCompletedTransitions() {
+    if (this.completionQueue.length === 0) return;
+    const len = this.completionQueue.length;
+    for (let i = 0; i < len; i++) {
+      const t = this.completionQueue[i];
+      const flight = this.inFlight.get(t);
+      if (!flight) continue;
+      this.inFlight.delete(t);
+      const tid = this.compiled.transitionId(t);
+      this.inFlightFlags[tid] = 0;
+      if (flight.error) {
+        const err = flight.error instanceof Error ? flight.error : new Error(String(flight.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 = flight.context.rawOutput();
+        if (t.outputSpec !== null) {
+          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()) {
+          this.marking.addToken(entry.place, entry.token);
+          produced.push(entry.token);
+          const pid = this.compiled.placeId(entry.place);
+          setBit(this.markedPlaces, 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() - flight.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 len = this.externalQueue.length;
+    for (let i = 0; i < len; i++) {
+      const event = this.externalQueue[i];
+      try {
+        this.marking.addToken(event.place, event.token);
+        const pid = this.compiled.placeId(event.place);
+        setBit(this.markedPlaces, 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 ========================
+  /**
+   * Suspends the executor until work is available. Composes up to 3 promise sources
+   * into a single Promise.race: (1) any in-flight action completing, (2) external
+   * event injection via wakeUp(), (3) timer for the next delayed transition's earliest
+   * firing time. This avoids busy-waiting while remaining responsive to all event types.
+   *
+   * **Microtask flush**: Before building Promise.race, yields via `await Promise.resolve()`
+   * to drain the microtask queue. Sync actions complete via `.then()` microtask; this
+   * yield lets those fire, avoiding ~5 allocations when work is already available.
+   * After the yield, re-checks queues and `this.closed` for close-during-yield safety.
+   */
+  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.inFlight.size > 0) {
+      const arr = this.inFlightPromises;
+      arr.length = 0;
+      for (const f of this.inFlight.values()) arr.push(f.promise);
+      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();
+    let minWaitMs = Infinity;
+    for (let tid = 0; tid < this.compiled.transitionCount; tid++) {
+      if (!this.enabledFlags[tid]) continue;
+      const t = this.compiled.transition(tid);
+      const enabledMs = this.enabledAtMs[tid];
+      const elapsedMs = nowMs - enabledMs;
+      const earliestMs = earliest(t.timing);
+      const remainingEarliest = earliestMs - elapsedMs;
+      if (remainingEarliest <= 0) return 0;
+      minWaitMs = Math.min(minWaitMs, remainingEarliest);
+      if (hasDeadline(t.timing)) {
+        const latestMs = latest(t.timing);
+        const remainingDeadline = latestMs - elapsedMs;
+        if (remainingDeadline <= 0) return 0;
+        minWaitMs = Math.min(minWaitMs, remainingDeadline);
+      }
+    }
+    return minWaitMs;
+  }
+  wakeUp() {
+    this.wakeUpResolve?.();
+  }
+  // ======================== Dirty Set Helpers ========================
+  /** Returns true if any transition needs re-evaluation. O(W) where W = ceil(transitions/32). */
+  hasDirtyBits() {
+    for (let w = 0; w < this.dirtySet.length; w++) {
+      if (this.dirtySet[w] !== 0) return true;
+    }
+    return false;
+  }
+  markDirty(pid) {
+    const tids = this.compiled.affectedTransitions(pid);
+    for (const tid of tids) {
+      this.markTransitionDirty(tid);
+    }
+  }
+  markTransitionDirty(tid) {
+    this.dirtySet[tid >>> WORD_SHIFT] |= 1 << (tid & BIT_MASK);
+  }
+  // ======================== State Inspection ========================
+  getMarking() {
+    return this.marking;
+  }
+  /** Builds a snapshot of the current marking for event emission. */
+  snapshotMarking() {
+    const snap = /* @__PURE__ */ new Map();
+    for (let pid = 0; pid < this.compiled.placeCount; pid++) {
+      const p = this.compiled.place(pid);
+      const tokens = this.marking.peekTokens(p);
+      if (tokens.length > 0) {
+        snap.set(p.name, [...tokens]);
+      }
+    }
+    return snap;
+  }
+  isQuiescent() {
+    return this.enabledTransitionCount === 0 && this.inFlight.size === 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 TimeoutSentinel = class extends Error {
+  constructor() {
+    super("action timeout");
+    this.name = "TimeoutSentinel";
+  }
+};
+export {
+  BitmapNetExecutor,
+  CompiledNet,
+  InMemoryEventStore,
+  MAX_DURATION_MS,
+  Marking,
+  OutViolationError,
+  PetriNet,
+  PetriNetBuilder,
+  TokenInput,
+  TokenOutput,
+  Transition,
+  TransitionBuilder,
+  TransitionContext,
+  all,
+  allPlaces,
+  and,
+  andPlaces,
+  arcPlace,
+  atLeast,
+  clearBit,
+  consumptionCount,
+  containsAll,
+  deadline,
+  delayed,
+  earliest,
+  enumerateBranches,
+  environmentPlace,
+  eventTransitionName,
+  eventsOfType,
+  exact,
+  exactly,
+  failures,
+  filterEvents,
+  fork,
+  forwardInput,
+  hasDeadline,
+  hasGuard,
+  immediate,
+  inMemoryEventStore,
+  inhibitorArc,
+  inputArc,
+  intersects,
+  isFailureEvent,
+  isUnit,
+  latest,
+  matchesGuard,
+  noopEventStore,
+  one,
+  outPlace,
+  outputArc,
+  passthrough,
+  place,
+  produce,
+  produceTimeoutOutput,
+  readArc,
+  requiredCount,
+  resetArc,
+  setBit,
+  testBit,
+  timeout,
+  timeoutPlace,
+  tokenAt,
+  tokenOf,
+  transform,
+  transformAsync,
+  transformFrom,
+  transitionEvents,
+  unitToken,
+  validateOutSpec,
+  window,
+  withTimeout,
+  xor,
+  xorPlaces
+};
+//# sourceMappingURL=index.js.map