libpetri 2.12.1 → 3.0.0

package/dist/{petri-net-Byc3gSgJ.d.ts → petri-net-UQBBkvLl.d.ts}

@@ -72,7 +72,6 @@ type Arc = ArcInput | ArcOutput | ArcInhibitor | ArcRead | ArcReset;
 interface ArcInput<T = any> {
     readonly type: 'input';
     readonly place: Place<T>;
-    readonly guard?: (value: T) => boolean;
 }
 interface ArcOutput<T = any> {
     readonly type: 'output';
@@ -91,7 +90,7 @@ interface ArcReset<T = any> {
     readonly place: Place<T>;
 }
 /** Input arc: consumes token from place when transition fires. */
-declare function inputArc<T>(place: Place<T>, guard?: (value: T) => boolean): ArcInput<T>;
+declare function inputArc<T>(place: Place<T>): ArcInput<T>;
 /** Output arc: produces token to place when transition fires. */
 declare function outputArc<T>(place: Place<T>): ArcOutput<T>;
 /** Inhibitor arc: blocks transition if place has tokens. */
@@ -102,15 +101,14 @@ declare function readArc<T>(place: Place<T>): ArcRead<T>;
 declare function resetArc<T>(place: Place<T>): ArcReset<T>;
 /** Returns the place this arc connects to. */
 declare function arcPlace(arc: Arc): Place<any>;
-/** Checks if an input arc has a guard predicate. */
-declare function hasGuard(arc: ArcInput): boolean;
-/** Checks if a token value matches an input arc's guard. */
-declare function matchesGuard<T>(arc: ArcInput<T>, value: T): boolean;
 
 /**
- * Input specification with cardinality and optional guard predicate.
- * CPN-compliant: cardinality determines how many tokens to consume,
- * guard filters which tokens are eligible.
+ * Input specification with cardinality. Purely structural (IO-006): cardinality
+ * determines how many tokens to consume; there is no per-token predicate.
+ *
+ * Conditional token selection is modeled with multiple conflicting transitions
+ * and XOR-on-input semantics rather than a predicate coupled to the enablement
+ * check.
  *
  * Inputs are always AND-joined (all must be satisfied to enable transition).
  * XOR on inputs is modeled via multiple transitions (conflict).
@@ -119,33 +117,29 @@ type In = InOne | InExactly | InAll | InAtLeast;
 interface InOne<T = any> {
     readonly type: 'one';
     readonly place: Place<T>;
-    readonly guard?: (value: T) => boolean;
 }
 interface InExactly<T = any> {
     readonly type: 'exactly';
     readonly place: Place<T>;
     readonly count: number;
-    readonly guard?: (value: T) => boolean;
 }
 interface InAll<T = any> {
     readonly type: 'all';
     readonly place: Place<T>;
-    readonly guard?: (value: T) => boolean;
 }
 interface InAtLeast<T = any> {
     readonly type: 'at-least';
     readonly place: Place<T>;
     readonly minimum: number;
-    readonly guard?: (value: T) => boolean;
 }
-/** Consume exactly 1 token (standard CPN semantics). Optional guard filters eligible tokens. */
-declare function one<T>(place: Place<T>, guard?: (value: T) => boolean): InOne<T>;
-/** Consume exactly N tokens (batching). Optional guard filters eligible tokens. */
-declare function exactly<T>(count: number, place: Place<T>, guard?: (value: T) => boolean): InExactly<T>;
-/** Consume all available tokens (must be 1+). Optional guard filters eligible tokens. */
-declare function all<T>(place: Place<T>, guard?: (value: T) => boolean): InAll<T>;
-/** Wait for N+ tokens, consume all when enabled. Optional guard filters eligible tokens. */
-declare function atLeast<T>(minimum: number, place: Place<T>, guard?: (value: T) => boolean): InAtLeast<T>;
+/** Consume exactly 1 token (standard CPN semantics). */
+declare function one<T>(place: Place<T>): InOne<T>;
+/** Consume exactly N tokens (batching). */
+declare function exactly<T>(count: number, place: Place<T>): InExactly<T>;
+/** Consume all available tokens (must be 1+). */
+declare function all<T>(place: Place<T>): InAll<T>;
+/** Wait for N+ tokens, consume all when enabled. */
+declare function atLeast<T>(minimum: number, place: Place<T>): InAtLeast<T>;
 /** Returns the minimum number of tokens required to enable. */
 declare function requiredCount(spec: In): number;
 /**
@@ -191,11 +185,11 @@ declare function nameId(value: string): NameId;
  * On firing, exactly those name-matched tokens are consumed (spec NU-020).
  *
  * This is the single *decidable* predicate — equality of opaque names — and is
- * deliberately NOT a general guard: it correlates the name dimension *across*
- * places (composition-structural, like cardinality) rather than evaluating an
- * arbitrary boolean per token. When both a unary input `guard` and a match are
- * present the guard filters first, then the name correlation runs over the
- * survivors (NU-021).
+ * deliberately NOT a general input predicate: it correlates the name dimension
+ * *across* places (composition-structural, like cardinality) rather than
+ * evaluating an arbitrary boolean per token. Input specifications themselves
+ * remain purely structural (IO-006); name correlation is the only per-token
+ * filter the enablement check ever applies (NU-021).
  */
 
 /**
@@ -228,7 +222,7 @@ declare function matchKey<T>(place: Place<T>, key: KeyFn<T>): MatchKey<T>;
  *     ))
  *
  * @throws if fewer than two inputs are correlated (a match over a single place
- *   is just a guard).
+ *   correlates nothing).
  */
 declare function matchSpec(...keys: MatchKey[]): MatchSpec;
 /** Returns the name projection for `placeName`, or `undefined` if not correlated. */
@@ -577,15 +571,19 @@ declare class TransitionContext {
 type TransitionAction = (ctx: TransitionContext) => Promise<void>;
 /**
  * Identity action: produces no outputs.
+ * For transitions that only consume tokens without producing any.
  *
- * Returns a stable singleton reference (cached on first call). Reference
- * stability is relied on by {@link import('./internal/subnet-rewriter.js')
- * .composeActions} during channel composition (MOD-021) to short-circuit a
- * passthrough-on-both-sides merge to passthrough — saving a microtask hop
- * and matching the Java implementation's behaviour where both transitions'
- * default actions collapse to the builder's own passthrough default.
+ * Returns a stable singleton reference (CORE-051), so {@link isPassthrough}
+ * can recognise it.
  */
 declare function passthrough(): TransitionAction;
+/**
+ * Whether `action` is the built-in {@link passthrough} — i.e. provably produces
+ * no output tokens. Identity-based, so a hand-written no-op is not claimed.
+ *
+ * @param action the action to test; `null` / `undefined` is not passthrough
+ */
+declare function isPassthrough(action: TransitionAction | null | undefined): boolean;
 /**
  * Transform action: applies function to context, copies result to ALL output places.
  *
@@ -1539,8 +1537,12 @@ declare class PetriNet {
     bindActions(actionBindings: Map<string, TransitionAction> | Record<string, TransitionAction>): PetriNet;
     /**
      * Creates a new PetriNet with actions bound via a resolver function.
+     *
+     * The resolver is called once per transition with its name. Returning `null`
+     * defers that transition — it keeps whatever action it already carries — which
+     * is what makes staged binding (**MOD-024** AC7) work.
      */
-    bindActionsWithResolver(actionResolver: (name: string) => TransitionAction): PetriNet;
+    bindActionsWithResolver(actionResolver: (name: string) => TransitionAction | null): PetriNet;
     static builder(name: string): PetriNetBuilder;
 }
 declare class PetriNetBuilder {
@@ -1738,7 +1740,8 @@ declare class PetriNetBuilder {
      *    Map<string, Place<unknown>> convention — TypeScript Place identity is
      *    name-based per `runtime/compiled-net.ts`).
      * 3. Walk every transition through {@link applyFusion} to rewrite arc place
-     *    references.
+     *    references; input arcs colliding on a canonical place merge per
+     *    [MOD-021] (additive where summable, rejected otherwise).
      * 4. Re-derive the place set from the rewritten transitions plus any
      *    caller-declared standalone places, dropping non-canonical members.
      *    Caller-declared standalone places that happen to be non-canonical
@@ -1774,4 +1777,4 @@ declare class PetriNetBuilder {
     private buildWithFusion;
 }
 
-export { type VerificationHarness as $, type Arc as A, type Port as B, type Channel as C, type PortDirection as D, type EnvironmentPlace as E, FusionSet as F, SubnetDefBuilder as G, type SubnetInstance as H, type In as I, type Timing as J, type KeyFn as K, type LogFn as L, MAX_DURATION_MS as M, type NameId as N, type Out as O, PetriNet as P, type TimingDeadline as Q, type TimingDelayed as R, SubnetDef as S, type Token as T, type TimingExact as U, type TimingImmediate as V, type TimingWindow as W, TokenInput as X, TokenOutput as Y, type TransitionAction as Z, TransitionBuilder as _, type Place as a, type TokenSupplier as a$, type VerificationResult as a0, all as a1, allPlaces as a2, and as a3, andPlaces as a4, arcPlace as a5, atLeast as a6, consumptionCount as a7, deadline as a8, delayed as a9, readArc as aA, requiredCount as aB, resetArc as aC, timeout as aD, timeoutPlace as aE, tokenAt as aF, tokenOf as aG, transform as aH, transformAsync as aI, transformFrom as aJ, unitToken as aK, window as aL, withTimeout as aM, xor as aN, xorPlaces as aO, MarkingState as aP, type PInvariant as aQ, MarkingStateBuilder as aR, type SmtProperty as aS, type SmtVerificationResult as aT, type BranchPlaceBound as aU, type DeadlockFree as aV, type JoinedOrDeadLettered as aW, type MutualExclusion as aX, type PlaceBound as aY, type Proven as aZ, type SmtStatistics as a_, earliest as aa, enumerateBranches as ab, environmentPlace as ac, exact as ad, exactly as ae, fork as af, forwardInput as ag, hasDeadline as ah, hasGuard as ai, immediate as aj, inhibitorArc as ak, inputArc as al, isUnit as am, keyForPlace as an, latest as ao, matchCorrelates as ap, matchKey as aq, matchSpec as ar, matchesGuard as as, nameId as at, one as au, outPlace as av, outputArc as aw, passthrough as ax, place as ay, produce as az, Transition as b, type Unknown as b0, type Unreachable as b1, type Verdict as b2, type Violated as b3, branchPlaceBound as b4, deadlockFree as b5, isProven as b6, isViolated as b7, joinedOrDeadLettered as b8, mutualExclusion as b9, pInvariant as ba, pInvariantToString as bb, placeBound as bc, propertyDescription as bd, unreachable as be, TransitionContext as c, type ArcInhibitor as d, type ArcInput as e, type ArcOutput as f, type ArcRead as g, type ArcReset as h, ComposeBindings as i, FusionSetBuilder as j, type InAll as k, type InAtLeast as l, type InExactly as m, type InOne as n, Instance as o, Interface as p, InterfaceBuilder as q, type MatchKey as r, type MatchSpec as s, type OutAnd as t, type OutForwardInput as u, type OutPlace as v, type OutTimeout as w, type OutXor as x, type OutputEntry as y, PetriNetBuilder as z };
+export { type VerificationHarness as $, type Arc as A, type Port as B, type Channel as C, type PortDirection as D, type EnvironmentPlace as E, FusionSet as F, SubnetDefBuilder as G, type SubnetInstance as H, type In as I, type Timing as J, type KeyFn as K, type LogFn as L, MAX_DURATION_MS as M, type NameId as N, type Out as O, PetriNet as P, type TimingDeadline as Q, type TimingDelayed as R, SubnetDef as S, type Token as T, type TimingExact as U, type TimingImmediate as V, type TimingWindow as W, TokenInput as X, TokenOutput as Y, type TransitionAction as Z, TransitionBuilder as _, type Place as a, type Unknown as a$, type VerificationResult as a0, all as a1, allPlaces as a2, and as a3, andPlaces as a4, arcPlace as a5, atLeast as a6, consumptionCount as a7, deadline as a8, delayed as a9, requiredCount as aA, resetArc as aB, timeout as aC, timeoutPlace as aD, tokenAt as aE, tokenOf as aF, transform as aG, transformAsync as aH, transformFrom as aI, unitToken as aJ, window as aK, withTimeout as aL, xor as aM, xorPlaces as aN, MarkingState as aO, type PInvariant as aP, MarkingStateBuilder as aQ, type SmtProperty as aR, type SmtVerificationResult as aS, type BranchPlaceBound as aT, type DeadlockFree as aU, type JoinedOrDeadLettered as aV, type MutualExclusion as aW, type PlaceBound as aX, type Proven as aY, type SmtStatistics as aZ, type TokenSupplier as a_, earliest as aa, enumerateBranches as ab, environmentPlace as ac, exact as ad, exactly as ae, fork as af, forwardInput as ag, hasDeadline as ah, immediate as ai, inhibitorArc as aj, inputArc as ak, isPassthrough as al, isUnit as am, keyForPlace as an, latest as ao, matchCorrelates as ap, matchKey as aq, matchSpec as ar, nameId as as, one as at, outPlace as au, outputArc as av, passthrough as aw, place as ax, produce as ay, readArc as az, Transition as b, type Unreachable as b0, type Verdict as b1, type Violated as b2, branchPlaceBound as b3, deadlockFree as b4, isProven as b5, isViolated as b6, joinedOrDeadLettered as b7, mutualExclusion as b8, pInvariant as b9, pInvariantToString as ba, placeBound as bb, propertyDescription as bc, unreachable as bd, TransitionContext as c, type ArcInhibitor as d, type ArcInput as e, type ArcOutput as f, type ArcRead as g, type ArcReset as h, ComposeBindings as i, FusionSetBuilder as j, type InAll as k, type InAtLeast as l, type InExactly as m, type InOne as n, Instance as o, Interface as p, InterfaceBuilder as q, type MatchKey as r, type MatchSpec as s, type OutAnd as t, type OutForwardInput as u, type OutPlace as v, type OutTimeout as w, type OutXor as x, type OutputEntry as y, PetriNetBuilder as z };

package/dist/verification/index.d.ts

@@ -1,5 +1,5 @@
-import { b as Transition, a as Place, P as PetriNet, E as EnvironmentPlace, aP as MarkingState, aQ as PInvariant, aR as MarkingStateBuilder, aS as SmtProperty, aT as SmtVerificationResult } from '../petri-net-Byc3gSgJ.js';
-export { aU as BranchPlaceBound, aV as DeadlockFree, aW as JoinedOrDeadLettered, aX as MutualExclusion, aY as PlaceBound, aZ as Proven, a_ as SmtStatistics, a$ as TokenSupplier, b0 as Unknown, b1 as Unreachable, b2 as Verdict, $ as VerificationHarness, a0 as VerificationResult, b3 as Violated, b4 as branchPlaceBound, b5 as deadlockFree, b6 as isProven, b7 as isViolated, b8 as joinedOrDeadLettered, b9 as mutualExclusion, ba as pInvariant, bb as pInvariantToString, bc as placeBound, bd as propertyDescription, be as unreachable } from '../petri-net-Byc3gSgJ.js';
+import { b as Transition, a as Place, P as PetriNet, E as EnvironmentPlace, aO as MarkingState, aP as PInvariant, aQ as MarkingStateBuilder, aR as SmtProperty, aS as SmtVerificationResult } from '../petri-net-UQBBkvLl.js';
+export { aT as BranchPlaceBound, aU as DeadlockFree, aV as JoinedOrDeadLettered, aW as MutualExclusion, aX as PlaceBound, aY as Proven, aZ as SmtStatistics, a_ as TokenSupplier, a$ as Unknown, b0 as Unreachable, b1 as Verdict, $ as VerificationHarness, a0 as VerificationResult, b2 as Violated, b3 as branchPlaceBound, b4 as deadlockFree, b5 as isProven, b6 as isViolated, b7 as joinedOrDeadLettered, b8 as mutualExclusion, b9 as pInvariant, ba as pInvariantToString, bb as placeBound, bc as propertyDescription, bd as unreachable } from '../petri-net-UQBBkvLl.js';
 import { Expr, init, Bool, FuncDecl } from 'z3-solver';
 
 /**
@@ -341,9 +341,10 @@ type PrioritySemantics = 'none' | 'conflict';
  * - Operates on the marking projection (integer vectors) — no timing
  * - An untimed deadlock-freedom proof is stronger than needed
  *   (timing can only restrict behavior)
- * - Guards are ignored — over-approximation is sound for safety properties
- * - If a counterexample is found, it may be spurious in timed/guarded
- *   semantics — the report notes this
+ * - Input specifications are purely structural (IO-006) — there is no per-arc
+ *   predicate for the encoder to be blind to
+ * - If a counterexample is found, it may be spurious in timed semantics —
+ *   the report notes this
  *
  * Verification Pipeline:
  * 1. Flatten — expand XOR, index places, build pre/post vectors
@@ -426,6 +427,8 @@ declare class SmtVerifier {
     prioritySemantics(semantics: PrioritySemantics): this;
     /**
      * Runs the verification pipeline.
+     *
+     * @throws Error if the net violates CORE-043 — verification rejects the same nets execution rejects.
      */
     verify(): Promise<SmtVerificationResult>;
     /**
@@ -646,7 +649,11 @@ declare class StateClassGraph {
     private readonly _predecessors;
     private readonly _complete;
     private constructor();
-    /** Builds the state class graph for a Time Petri Net. */
+    /**
+     * Builds the state class graph for a Time Petri Net.
+     *
+     * @throws Error if the net violates CORE-043 — analysis rejects the same nets execution rejects.
+     */
     static build(net: PetriNet, initialMarking: MarkingState, maxClasses: number, environmentPlaces?: Set<EnvironmentPlace<any>>, environmentMode?: EnvironmentAnalysisMode): StateClassGraph;
     stateClasses(): readonly StateClass[];
     size(): number;

package/dist/verification/index.js

@@ -35,7 +35,7 @@ import {
   propertyDescription,
   structuralCheck,
   unreachable
-} from "../chunk-V3WTQRHC.js";
+} from "../chunk-5W6SVYPD.js";
 import "../chunk-ATT7U5H5.js";
 
 // src/verification/analysis/scc-analyzer.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libpetri",
-  "version": "2.12.1",
+  "version": "3.0.0",
   "description": "Coloured Time Petri Net engine — TypeScript port",
   "homepage": "https://libpetri.org",
   "repository": {

package/dist/chunk-E3ZWB645.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/match-spec.ts"],"sourcesContent":["/**\n * ν-net join correlation ([[MatchSpec]]).\n *\n * A {@link MatchSpec} declares that a subset of a transition's **input** places\n * must be correlated by **name equality**: the transition is enabled only when\n * there exists a single {@link NameId} `n` such that every correlated input\n * supplies (at least) its required token count whose projected name equals `n`.\n * On firing, exactly those name-matched tokens are consumed (spec NU-020).\n *\n * This is the single *decidable* predicate — equality of opaque names — and is\n * deliberately NOT a general guard: it correlates the name dimension *across*\n * places (composition-structural, like cardinality) rather than evaluating an\n * arbitrary boolean per token. When both a unary input `guard` and a match are\n * present the guard filters first, then the name correlation runs over the\n * survivors (NU-021).\n */\nimport type { Place } from './place.js';\nimport type { NameId } from './name.js';\n\n/**\n * A name projection: maps a token's value to its {@link NameId}. A projection\n * that yields no name (returns `null`/`undefined` at runtime) is treated as\n * \"no name\" — that token never correlates — mirroring the Java/Rust `KeyFn`\n * contract; the binding selector handles a nullish result defensively.\n */\nexport type KeyFn<T = any> = (value: T) => NameId;\n\n/** One correlated input: the place plus its name projection. */\nexport interface MatchKey<T = any> {\n  readonly place: Place<T>;\n  readonly key: KeyFn<T>;\n}\n\n/** Correlated fork/join match specification (ν-net join side). */\nexport interface MatchSpec {\n  readonly keys: readonly MatchKey[];\n}\n\n/** Builds one correlated input for a {@link MatchSpec}. */\nexport function matchKey<T>(place: Place<T>, key: KeyFn<T>): MatchKey<T> {\n  return { place, key };\n}\n\n/**\n * Builds a {@link MatchSpec} from two or more correlated inputs.\n *\n * @example\n *   Transition.builder('join')\n *     .inputs(one(branchA), one(branchB))\n *     .match(matchSpec(\n *       matchKey(branchA, (m: Msg) => nameId(m.correlationId)),\n *       matchKey(branchB, (m: Msg) => nameId(m.correlationId)),\n *     ))\n *\n * @throws if fewer than two inputs are correlated (a match over a single place\n *   is just a guard).\n */\nexport function matchSpec(...keys: MatchKey[]): MatchSpec {\n  if (keys.length < 2) {\n    throw new Error(`MatchSpec must correlate at least 2 input places, got ${keys.length}`);\n  }\n  return { keys };\n}\n\n/** Returns the name projection for `placeName`, or `undefined` if not correlated. */\nexport function keyForPlace(spec: MatchSpec, placeName: string): KeyFn | undefined {\n  for (const k of spec.keys) {\n    if (k.place.name === placeName) return k.key;\n  }\n  return undefined;\n}\n\n/** True when `placeName` is one of the correlated inputs. */\nexport function matchCorrelates(spec: MatchSpec, placeName: string): boolean {\n  return spec.keys.some(k => k.place.name === placeName);\n}\n"],"mappings":";AAuCO,SAAS,SAAY,OAAiB,KAA4B;AACvE,SAAO,EAAE,OAAO,IAAI;AACtB;AAgBO,SAAS,aAAa,MAA6B;AACxD,MAAI,KAAK,SAAS,GAAG;AACnB,UAAM,IAAI,MAAM,yDAAyD,KAAK,MAAM,EAAE;AAAA,EACxF;AACA,SAAO,EAAE,KAAK;AAChB;AAGO,SAAS,YAAY,MAAiB,WAAsC;AACjF,aAAW,KAAK,KAAK,MAAM;AACzB,QAAI,EAAE,MAAM,SAAS,UAAW,QAAO,EAAE;AAAA,EAC3C;AACA,SAAO;AACT;AAGO,SAAS,gBAAgB,MAAiB,WAA4B;AAC3E,SAAO,KAAK,KAAK,KAAK,OAAK,EAAE,MAAM,SAAS,SAAS;AACvD;","names":[]}