libpetri 2.5.0 → 2.6.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-C3asscb4.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-C3asscb4.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-C3asscb4.js';
+import { E as EventStore } from './event-store-E_ahsEc9.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-E_ahsEc9.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({
@@ -2529,6 +2529,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 +2590,6 @@ function produceTimeoutOutput(context, timeoutChild) {
 }
 
 // src/runtime/bitmap-net-executor.ts
-var DEADLINE_TOLERANCE_MS = 5;
 var BitmapNetExecutor = class {
   compiled;
   marking;
@@ -2614,6 +2614,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 +2645,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 +2662,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 +2673,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 +2853,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({
@@ -3364,6 +3375,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 +3501,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 +3512,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 +3680,6 @@ function simpleOutputPlace(spec, compiled) {
 }
 
 // src/runtime/precompiled-net-executor.ts
-var DEADLINE_TOLERANCE_MS2 = 5;
 var PrecompiledNetExecutor = class {
   program;
   eventStore;
@@ -3669,6 +3687,7 @@ var PrecompiledNetExecutor = class {
   hasEnvironmentPlaces;
   executionContextProvider;
   skipOutputValidation;
+  deadlineToleranceMs;
   startMs;
   eventStoreEnabled;
   // ==================== Token Storage ====================
@@ -3722,6 +3741,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 +3959,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;