libpetri 2.5.0 → 2.7.0

package/dist/export/index.d.ts

@@ -1,4 +1,4 @@
-import { P as PetriNet } from '../petri-net-DXdpd0r5.js';
+import { P as PetriNet } from '../petri-net-D73-PO6d.js';
 
 /**
  * Format-agnostic typed graph model.

package/dist/export/index.js

@@ -8,8 +8,8 @@ import {
   nodeStyle,
   renderDot,
   sanitize
-} from "../chunk-2GAZLDH3.js";
-import "../chunk-FN773SSE.js";
+} from "../chunk-ULX3OG6H.js";
+import "../chunk-ATT7U5H5.js";
 export {
   DEFAULT_DOT_CONFIG,
   FONT,

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { P as PetriNet, S as SubnetDef, a as Place, T as Token, b as Transition, E as EnvironmentPlace, c as TransitionContext, O as Out } from './petri-net-DXdpd0r5.js';
-export { A as Arc, d as ArcInhibitor, e as ArcInput, f as ArcOutput, g as ArcRead, h as ArcReset, C as Channel, i as ComposeBindings, F as FusionSet, j as FusionSetBuilder, I as In, k as InAll, l as InAtLeast, m as InExactly, n as InOne, o as Instance, p as Interface, q as InterfaceBuilder, L as LogFn, M as MAX_DURATION_MS, r as OutAnd, s as OutForwardInput, t as OutPlace, u as OutTimeout, v as OutXor, w as OutputEntry, x as PetriNetBuilder, y as Port, z as PortDirection, B as SubnetDefBuilder, D as SubnetInstance, G as Timing, H as TimingDeadline, J as TimingDelayed, K as TimingExact, N as TimingImmediate, Q as TimingWindow, R as TokenInput, U as TokenOutput, V as TransitionAction, W as TransitionBuilder, X as VerificationHarness, Y as VerificationResult, Z as all, _ as allPlaces, $ as and, a0 as andPlaces, a1 as arcPlace, a2 as atLeast, a3 as consumptionCount, a4 as deadline, a5 as delayed, a6 as earliest, a7 as enumerateBranches, a8 as environmentPlace, a9 as exact, aa as exactly, ab as fork, ac as forwardInput, ad as hasDeadline, ae as hasGuard, af as immediate, ag as inhibitorArc, ah as inputArc, ai as isUnit, aj as latest, ak as matchesGuard, al as one, am as outPlace, an as outputArc, ao as passthrough, ap as place, aq as produce, ar as readArc, as as requiredCount, at as resetArc, au as timeout, av as timeoutPlace, aw as tokenAt, ax as tokenOf, ay as transform, az as transformAsync, aA as transformFrom, aB as unitToken, aC as window, aD as withTimeout, aE as xor, aF as xorPlaces } from './petri-net-DXdpd0r5.js';
-import { E as EventStore } from './event-store-z30VMn0T.js';
-export { A as ActionTimedOut, a as ExecutionCompleted, b as ExecutionStarted, I as InMemoryEventStore, L as LogMessage, M as MarkingSnapshot, N as NetEvent, T as TokenAdded, c as TokenRemoved, d as TransitionClockRestarted, e as TransitionCompleted, f as TransitionEnabled, g as TransitionFailed, h as TransitionStarted, i as TransitionTimedOut, j as eventTransitionName, k as eventsOfType, l as failures, m as filterEvents, n as inMemoryEventStore, o as isFailureEvent, p as noopEventStore, t as transitionEvents } from './event-store-z30VMn0T.js';
+import { P as PetriNet, S as SubnetDef, a as Place, T as Token, b as Transition, E as EnvironmentPlace, c as TransitionContext, O as Out } from './petri-net-D73-PO6d.js';
+export { A as Arc, d as ArcInhibitor, e as ArcInput, f as ArcOutput, g as ArcRead, h as ArcReset, C as Channel, i as ComposeBindings, F as FusionSet, j as FusionSetBuilder, I as In, k as InAll, l as InAtLeast, m as InExactly, n as InOne, o as Instance, p as Interface, q as InterfaceBuilder, L as LogFn, M as MAX_DURATION_MS, r as OutAnd, s as OutForwardInput, t as OutPlace, u as OutTimeout, v as OutXor, w as OutputEntry, x as PetriNetBuilder, y as Port, z as PortDirection, B as SubnetDefBuilder, D as SubnetInstance, G as Timing, H as TimingDeadline, J as TimingDelayed, K as TimingExact, N as TimingImmediate, Q as TimingWindow, R as TokenInput, U as TokenOutput, V as TransitionAction, W as TransitionBuilder, X as VerificationHarness, Y as VerificationResult, Z as all, _ as allPlaces, $ as and, a0 as andPlaces, a1 as arcPlace, a2 as atLeast, a3 as consumptionCount, a4 as deadline, a5 as delayed, a6 as earliest, a7 as enumerateBranches, a8 as environmentPlace, a9 as exact, aa as exactly, ab as fork, ac as forwardInput, ad as hasDeadline, ae as hasGuard, af as immediate, ag as inhibitorArc, ah as inputArc, ai as isUnit, aj as latest, ak as matchesGuard, al as one, am as outPlace, an as outputArc, ao as passthrough, ap as place, aq as produce, ar as readArc, as as requiredCount, at as resetArc, au as timeout, av as timeoutPlace, aw as tokenAt, ax as tokenOf, ay as transform, az as transformAsync, aA as transformFrom, aB as unitToken, aC as window, aD as withTimeout, aE as xor, aF as xorPlaces } from './petri-net-D73-PO6d.js';
+import { E as EventStore } from './event-store-8XkpYUeU.js';
+export { A as ActionTimedOut, a as ExecutionCompleted, b as ExecutionStarted, I as InMemoryEventStore, L as LogMessage, M as MarkingSnapshot, N as NetEvent, T as TokenAdded, c as TokenRemoved, d as TransitionClockRestarted, e as TransitionCompleted, f as TransitionEnabled, g as TransitionFailed, h as TransitionStarted, i as TransitionTimedOut, j as eventTransitionName, k as eventsOfType, l as failures, m as filterEvents, n as inMemoryEventStore, o as isFailureEvent, p as noopEventStore, t as transitionEvents } from './event-store-8XkpYUeU.js';
 
 /**
  * Discriminated sum-type abstraction over Petri nets, distinguishing **closed**
@@ -221,6 +221,13 @@ interface BitmapNetExecutorOptions {
     environmentPlaces?: Set<EnvironmentPlace<any>>;
     /** Provides execution context data for each transition firing. */
     executionContextProvider?: (transitionName: string, consumed: Token<any>[]) => Map<string, unknown>;
+    /**
+     * Grace band (ms) beyond a hard deadline (`deadline()` / `window()`) before a transition is
+     * force-disabled with a `transition-timed-out` event (TIME-013). Defaults to {@link DEADLINE_TOLERANCE_MS}
+     * (5ms); `0` gives strict enforcement. Must be non-negative. Does not affect `exact()` transitions,
+     * which are enforced softly (TIME-006).
+     */
+    deadlineToleranceMs?: number;
 }
 /**
  * Async bitmap-based executor for Coloured Time Petri Nets.
@@ -262,6 +269,10 @@ declare class BitmapNetExecutor implements PetriNetExecutor {
     private readonly enabledFlags;
     /** Precomputed: 1 if transition has a finite deadline, 0 otherwise. */
     private readonly hasDeadlineFlags;
+    /** Precomputed: 1 for exact() transitions — enforced softly, never force-disabled (TIME-006). */
+    private readonly isExactFlags;
+    /** Grace band (ms) before a hard deadline force-disables (TIME-013). */
+    private readonly deadlineToleranceMs;
     private enabledTransitionCount;
     private readonly inFlight;
     private readonly inFlightPromises;
@@ -394,6 +405,12 @@ declare class PrecompiledNet {
     readonly earliestMs: Float64Array;
     readonly latestMs: Float64Array;
     readonly hasDeadline: Uint8Array;
+    /**
+     * 1 for `exact()` transitions. Exact transitions fire at the first opportunity at/after their
+     * target time (delayed-style liveness) and are never force-disabled by deadline enforcement —
+     * their upper bound is observed, not enforced. See TIME-006.
+     */
+    readonly isExact: Uint8Array;
     readonly priorities: Int32Array;
     readonly transitionToPriorityIndex: Uint32Array;
     readonly priorityLevels: readonly number[];
@@ -456,6 +473,13 @@ interface PrecompiledNetExecutorOptions {
     skipOutputValidation?: boolean;
     /** Reuse a precompiled program (avoids recompilation). */
     program?: PrecompiledNet;
+    /**
+     * Grace band (ms) beyond a hard deadline (`deadline()` / `window()`) before a transition is
+     * force-disabled with a `transition-timed-out` event (TIME-013). Defaults to {@link DEADLINE_TOLERANCE_MS}
+     * (5ms); `0` gives strict enforcement. Must be non-negative. Does not affect `exact()` transitions,
+     * which are enforced softly (TIME-006).
+     */
+    deadlineToleranceMs?: number;
 }
 /**
  * High-performance executor using `PrecompiledNet`.
@@ -470,6 +494,7 @@ declare class PrecompiledNetExecutor implements PetriNetExecutor {
     private readonly hasEnvironmentPlaces;
     private readonly executionContextProvider?;
     private readonly skipOutputValidation;
+    private readonly deadlineToleranceMs;
     private readonly startMs;
     private readonly eventStoreEnabled;
     /** Per-place token arrays, indexed by pid. */

package/dist/index.js

@@ -12,7 +12,7 @@ import {
   timeoutPlace,
   xor,
   xorPlaces
-} from "./chunk-H62Z76FY.js";
+} from "./chunk-ETNHEAS6.js";
 import {
   eventTransitionName,
   isFailureEvent
@@ -27,7 +27,7 @@ import {
   immediate,
   latest,
   window
-} from "./chunk-FN773SSE.js";
+} from "./chunk-ATT7U5H5.js";
 
 // src/core/token.ts
 var UNIT_TOKEN = Object.freeze({
@@ -203,6 +203,7 @@ function withTimeout(action, timeoutMs, timeoutPlace2, timeoutValue) {
 }
 
 // src/core/transition-context.ts
+var EMPTY_ALIAS = /* @__PURE__ */ new Map();
 var TransitionContext = class {
   rawInput;
   _rawOutput;
@@ -215,7 +216,8 @@ var TransitionContext = class {
   _transitionName;
   executionCtx;
   _logFn;
-  constructor(transitionName, rawInput, rawOutput, inputPlaces, readPlaces, outputPlaces, executionContext, logFn) {
+  placeAlias;
+  constructor(transitionName, rawInput, rawOutput, inputPlaces, readPlaces, outputPlaces, executionContext, logFn, placeAlias) {
     this._transitionName = transitionName;
     this.rawInput = rawInput;
     this._rawOutput = rawOutput;
@@ -233,28 +235,45 @@ var TransitionContext = class {
     this.allowedOutputs = ao;
     this.executionCtx = executionContext ?? /* @__PURE__ */ new Map();
     this._logFn = logFn;
+    this.placeAlias = placeAlias ?? EMPTY_ALIAS;
+  }
+  /**
+   * Resolves a place key through the transition's declared→actual place
+   * correspondence (per **MOD-031**). For a hand-written or directly-composed
+   * transition the correspondence is the identity, so this returns `place`
+   * unchanged; after instancing / port binding it maps a *declared* place
+   * constant the action hardcodes to the *actual* composed place. The result
+   * feeds both the declared-set check and the token-store access (both keyed by
+   * `place.name`), so `inputPlaces()`/`outputPlaces()` discovery is unaffected.
+   */
+  resolve(place2) {
+    const actual = this.placeAlias.get(place2.name);
+    return actual !== void 0 ? actual : place2;
   }
   // ==================== 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);
+    const actual = this.resolve(place2);
+    this.requireInput(actual);
+    const values = this.rawInput.values(actual);
     if (values.length !== 1) {
       throw new Error(
-        `Place '${place2.name}' consumed ${values.length} tokens, use inputs() for batched access`
+        `Place '${actual.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);
+    const actual = this.resolve(place2);
+    this.requireInput(actual);
+    return this.rawInput.values(actual);
   }
   /** Get consumed input token with metadata. */
   inputToken(place2) {
-    this.requireInput(place2);
-    return this.rawInput.get(place2);
+    const actual = this.resolve(place2);
+    this.requireInput(actual);
+    return this.rawInput.get(actual);
   }
   /** Returns declared input places (consumed). */
   inputPlaces() {
@@ -270,13 +289,15 @@ var TransitionContext = class {
   // ==================== 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);
+    const actual = this.resolve(place2);
+    this.requireRead(actual);
+    return this.rawInput.value(actual);
   }
   /** Get all read-only context values for a place. */
   reads(place2) {
-    this.requireRead(place2);
-    return this.rawInput.values(place2);
+    const actual = this.resolve(place2);
+    this.requireRead(actual);
+    return this.rawInput.values(actual);
   }
   /** Returns declared read places (context, not consumed). */
   readPlaces() {
@@ -303,9 +324,10 @@ var TransitionContext = class {
    * @throws if place not declared as output.
    */
   output(place2, ...values) {
-    this.requireOutput(place2);
+    const actual = this.resolve(place2);
+    this.requireOutput(actual);
     for (const value of values) {
-      this._rawOutput.add(place2, value);
+      this._rawOutput.add(actual, value);
     }
     return this;
   }
@@ -318,9 +340,10 @@ var TransitionContext = class {
    * @throws if place not declared as output.
    */
   outputToken(place2, ...tokens) {
-    this.requireOutput(place2);
+    const actual = this.resolve(place2);
+    this.requireOutput(actual);
     for (const token of tokens) {
-      this._rawOutput.addToken(place2, token);
+      this._rawOutput.addToken(actual, token);
     }
     return this;
   }
@@ -437,6 +460,7 @@ var TokenOutput = class {
 
 // src/core/transition.ts
 var TRANSITION_KEY = /* @__PURE__ */ Symbol("Transition.internal");
+var EMPTY_PLACE_ALIAS = /* @__PURE__ */ new Map();
 var Transition = class {
   name;
   inputSpecs;
@@ -448,11 +472,23 @@ var Transition = class {
   actionTimeout;
   action;
   priority;
+  /**
+   * Per-transition **declared → actual** place correspondence (per
+   * **MOD-031**), keyed by the author-original declared place **name** →
+   * actual composed place. Empty for a hand-written or directly-composed
+   * ([MOD-025]) transition (identity). Populated by the subnet rewriter after
+   * instantiation ([MOD-010]) / port binding ([MOD-020]) so an action that
+   * hardcodes a declared place constant resolves to the composed place via
+   * {@link import('./transition-context.js').TransitionContext}. Consumed only
+   * by the action-facing context I/O — never by enablement, firing, the
+   * verifier, the exporter, or events (so [MOD-023] is unaffected).
+   */
+  placeAlias;
   _inputPlaces;
   _readPlaces;
   _outputPlaces;
   /** @internal Use {@link Transition.builder} to create instances. */
-  constructor(key, name, inputSpecs, outputSpec, inhibitors, reads, resets, timing, action, priority) {
+  constructor(key, name, inputSpecs, outputSpec, inhibitors, reads, resets, timing, action, priority, placeAlias = EMPTY_PLACE_ALIAS) {
     if (key !== TRANSITION_KEY) throw new Error("Use Transition.builder() to create instances");
     this.name = name;
     this.inputSpecs = inputSpecs;
@@ -464,6 +500,7 @@ var Transition = class {
     this.actionTimeout = findTimeout(outputSpec);
     this.action = action;
     this.priority = priority;
+    this.placeAlias = placeAlias.size === 0 ? EMPTY_PLACE_ALIAS : placeAlias;
     const inputPlaces = /* @__PURE__ */ new Set();
     for (const spec of inputSpecs) {
       inputPlaces.add(spec.place);
@@ -515,6 +552,7 @@ var TransitionBuilder = class {
   _timing = immediate();
   _action = passthrough();
   _priority = 0;
+  _placeAlias = EMPTY_PLACE_ALIAS;
   constructor(name) {
     this._name = name;
   }
@@ -579,6 +617,16 @@ var TransitionBuilder = class {
     this._priority = priority;
     return this;
   }
+  /**
+   * Sets the per-transition declared→actual place correspondence (per
+   * **MOD-031**). Populated by the subnet rewriter during the compose-time
+   * rewrite; not normally called by hand-written nets, whose correspondence is
+   * the identity (empty map).
+   */
+  placeAlias(alias) {
+    this._placeAlias = alias;
+    return this;
+  }
   build() {
     if (this._outputSpec !== null) {
       const inputPlaceNames = new Set(this._inputSpecs.map((s) => s.place.name));
@@ -600,7 +648,8 @@ var TransitionBuilder = class {
       [...this._resets],
       this._timing,
       this._action,
-      this._priority
+      this._priority,
+      this._placeAlias
     );
   }
 };
@@ -895,6 +944,10 @@ function substitutePlaces(t, remap) {
 }
 function rebuildWithName(t, name, remap) {
   const builder = Transition.builder(name).timing(t.timing).priority(t.priority).action(t.action);
+  const alias = buildPlaceAlias(t, remap);
+  if (alias.size > 0) {
+    builder.placeAlias(alias);
+  }
   if (t.inputSpecs.length > 0) {
     const rewrittenInputs = new Array(t.inputSpecs.length);
     for (let i = 0; i < t.inputSpecs.length; i++) {
@@ -916,6 +969,39 @@ function rebuildWithName(t, name, remap) {
   }
   return builder.build();
 }
+function buildPlaceAlias(t, remap) {
+  const prev = t.placeAlias;
+  if (remap.size === 0 && prev.size === 0) {
+    return EMPTY_ALIAS2;
+  }
+  const alias = /* @__PURE__ */ new Map();
+  if (prev.size > 0) {
+    for (const [declaredName, prevActual] of prev) {
+      const replaced = remap.get(prevActual.name);
+      const finalActual = replaced !== void 0 ? replaced : prevActual;
+      if (finalActual.name !== declaredName) {
+        alias.set(declaredName, finalActual);
+      }
+    }
+    return alias;
+  }
+  const record = (p) => {
+    if (alias.has(p.name)) return;
+    const replaced = remap.get(p.name);
+    if (replaced !== void 0 && replaced.name !== p.name) {
+      alias.set(p.name, replaced);
+    }
+  };
+  for (const spec of t.inputSpecs) record(spec.place);
+  for (const rd of t.reads) record(rd.place);
+  for (const inh of t.inhibitors) record(inh.place);
+  for (const rs of t.resets) record(rs.place);
+  if (t.outputSpec !== null) {
+    for (const p of allPlaces(t.outputSpec)) record(p);
+  }
+  return alias;
+}
+var EMPTY_ALIAS2 = /* @__PURE__ */ new Map();
 function rewriteIn(spec, remap) {
   switch (spec.type) {
     case "one":
@@ -2529,6 +2615,7 @@ var OutViolationError = class extends Error {
 };
 
 // src/runtime/executor-support.ts
+var DEADLINE_TOLERANCE_MS = 5;
 function validateOutSpec(tName, spec, producedPlaceNames) {
   switch (spec.type) {
     case "place":
@@ -2589,7 +2676,6 @@ function produceTimeoutOutput(context, timeoutChild) {
 }
 
 // src/runtime/bitmap-net-executor.ts
-var DEADLINE_TOLERANCE_MS = 5;
 var BitmapNetExecutor = class {
   compiled;
   marking;
@@ -2614,6 +2700,10 @@ var BitmapNetExecutor = class {
   enabledFlags;
   /** Precomputed: 1 if transition has a finite deadline, 0 otherwise. */
   hasDeadlineFlags;
+  /** Precomputed: 1 for exact() transitions — enforced softly, never force-disabled (TIME-006). */
+  isExactFlags;
+  /** Grace band (ms) before a hard deadline force-disables (TIME-013). */
+  deadlineToleranceMs;
   enabledTransitionCount = 0;
   // In-flight tracking
   inFlight = /* @__PURE__ */ new Map();
@@ -2641,6 +2731,10 @@ var BitmapNetExecutor = class {
     );
     this.hasEnvironmentPlaces = this.environmentPlaces.size > 0;
     this.executionContextProvider = options.executionContextProvider;
+    this.deadlineToleranceMs = options.deadlineToleranceMs ?? DEADLINE_TOLERANCE_MS;
+    if (this.deadlineToleranceMs < 0) {
+      throw new Error(`Deadline tolerance must be non-negative: ${this.deadlineToleranceMs}`);
+    }
     this.startMs = performance.now();
     const wordCount = this.compiled.wordCount;
     this.markedPlaces = new Uint32Array(wordCount);
@@ -2654,6 +2748,7 @@ var BitmapNetExecutor = class {
     this.inFlightFlags = new Uint8Array(this.compiled.transitionCount);
     this.enabledFlags = new Uint8Array(this.compiled.transitionCount);
     this.hasDeadlineFlags = new Uint8Array(this.compiled.transitionCount);
+    this.isExactFlags = new Uint8Array(this.compiled.transitionCount);
     let anyDeadlines = false;
     let allImm = true;
     let samePrio = true;
@@ -2664,6 +2759,7 @@ var BitmapNetExecutor = class {
         this.hasDeadlineFlags[tid] = 1;
         anyDeadlines = true;
       }
+      if (t.timing.type === "exact") this.isExactFlags[tid] = 1;
       if (t.timing.type !== "immediate") allImm = false;
       if (t.priority !== firstPriority) samePrio = false;
     }
@@ -2843,11 +2939,12 @@ var BitmapNetExecutor = class {
   enforceDeadlines(nowMs) {
     for (let tid = 0; tid < this.compiled.transitionCount; tid++) {
       if (!this.hasDeadlineFlags[tid]) continue;
+      if (this.isExactFlags[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) {
+      if (elapsed > latestMs + this.deadlineToleranceMs) {
         this.enabledFlags[tid] = 0;
         this.enabledTransitionCount--;
         this.emitEvent({
@@ -3033,7 +3130,8 @@ var BitmapNetExecutor = class {
       t.readPlaces(),
       t.outputPlaces(),
       execCtx,
-      logFn
+      logFn,
+      t.placeAlias
     );
     let actionPromise = t.action(context);
     if (t.hasActionTimeout()) {
@@ -3364,6 +3462,12 @@ var PrecompiledNet = class _PrecompiledNet {
   earliestMs;
   latestMs;
   hasDeadline;
+  /**
+   * 1 for `exact()` transitions. Exact transitions fire at the first opportunity at/after their
+   * target time (delayed-style liveness) and are never force-disabled by deadline enforcement —
+   * their upper bound is observed, not enforced. See TIME-006.
+   */
+  isExact;
   // ==================== Priority (CONC-023) ====================
   priorities;
   transitionToPriorityIndex;
@@ -3484,6 +3588,7 @@ var PrecompiledNet = class _PrecompiledNet {
     this.earliestMs = new Float64Array(tc);
     this.latestMs = new Float64Array(tc);
     this.hasDeadline = new Uint8Array(tc);
+    this.isExact = new Uint8Array(tc);
     let anyDeadlines = false;
     let allImm = true;
     for (let tid = 0; tid < tc; tid++) {
@@ -3494,6 +3599,7 @@ var PrecompiledNet = class _PrecompiledNet {
         this.hasDeadline[tid] = 1;
         anyDeadlines = true;
       }
+      if (t.timing.type === "exact") this.isExact[tid] = 1;
       if (t.timing.type !== "immediate") allImm = false;
     }
     this.anyDeadlines = anyDeadlines;
@@ -3661,7 +3767,6 @@ function simpleOutputPlace(spec, compiled) {
 }
 
 // src/runtime/precompiled-net-executor.ts
-var DEADLINE_TOLERANCE_MS2 = 5;
 var PrecompiledNetExecutor = class {
   program;
   eventStore;
@@ -3669,6 +3774,7 @@ var PrecompiledNetExecutor = class {
   hasEnvironmentPlaces;
   executionContextProvider;
   skipOutputValidation;
+  deadlineToleranceMs;
   startMs;
   eventStoreEnabled;
   // ==================== Token Storage ====================
@@ -3722,6 +3828,10 @@ var PrecompiledNetExecutor = class {
     this.hasEnvironmentPlaces = this.environmentPlaces.size > 0;
     this.executionContextProvider = options.executionContextProvider;
     this.skipOutputValidation = options.skipOutputValidation ?? false;
+    this.deadlineToleranceMs = options.deadlineToleranceMs ?? DEADLINE_TOLERANCE_MS;
+    if (this.deadlineToleranceMs < 0) {
+      throw new Error(`Deadline tolerance must be non-negative: ${this.deadlineToleranceMs}`);
+    }
     this.startMs = performance.now();
     this.eventStoreEnabled = this.eventStore.isEnabled();
     const prog = this.program;
@@ -3936,10 +4046,11 @@ var PrecompiledNetExecutor = class {
     const tc = prog.transitionCount;
     for (let tid = 0; tid < tc; tid++) {
       if (!prog.hasDeadline[tid]) continue;
+      if (prog.isExact[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) {
+      if (elapsed > latestMs + this.deadlineToleranceMs) {
         this.enabledFlags[tid] = 0;
         this.enabledTransitionCount--;
         this.enabledAtMs[tid] = -Infinity;
@@ -4191,7 +4302,8 @@ var PrecompiledNetExecutor = class {
       t.readPlaces(),
       t.outputPlaces(),
       execCtx,
-      logFn
+      logFn,
+      t.placeAlias
     );
     let actionPromise = t.action(context);
     if (t.hasActionTimeout()) {